From 2cc85c64f1c64a2dbaeae276a3e2ca8420de76b7 Mon Sep 17 00:00:00 2001
From: WXL <wl_5969728@163.com>
Date: 星期三, 22 四月 2026 18:09:58 +0800
Subject: [PATCH] 上报转运调试
---
node_modules/@types/node/perf_hooks.d.ts | 231 +++++++++++++++++++++++++++------------------------------
1 files changed, 111 insertions(+), 120 deletions(-)
diff --git a/node_modules/@types/node/perf_hooks.d.ts b/node_modules/@types/node/perf_hooks.d.ts
index 699f3bf..46e725c 100644
--- a/node_modules/@types/node/perf_hooks.d.ts
+++ b/node_modules/@types/node/perf_hooks.d.ts
@@ -1,34 +1,3 @@
-/**
- * This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
- * Node.js-specific performance measurements.
- *
- * Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
- *
- * * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
- * * [Performance Timeline](https://w3c.github.io/performance-timeline/)
- * * [User Timing](https://www.w3.org/TR/user-timing/)
- * * [Resource Timing](https://www.w3.org/TR/resource-timing-2/)
- *
- * ```js
- * import { PerformanceObserver, performance } from 'node:perf_hooks';
- *
- * const obs = new PerformanceObserver((items) => {
- * console.log(items.getEntries()[0].duration);
- * performance.clearMarks();
- * });
- * obs.observe({ type: 'measure' });
- * performance.measure('Start to Now');
- *
- * performance.mark('A');
- * doSomeLongRunningProcess(() => {
- * performance.measure('A to Now', 'A');
- *
- * performance.mark('B');
- * performance.measure('A to B', 'A', 'B');
- * });
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/perf_hooks.js)
- */
declare module "node:perf_hooks" {
import { InternalEventTargetEventProperties } from "node:events";
// #region web types
@@ -43,11 +12,6 @@
| "net" // Node.js only
| "node" // Node.js only
| "resource"; // available on the Web
- interface EventLoopUtilization {
- idle: number;
- active: number;
- utilization: number;
- }
interface ConnectionTimingInfo {
domainLookupStartTime: number;
domainLookupEndTime: number;
@@ -88,6 +52,9 @@
entryTypes?: EntryType[];
type?: EntryType;
}
+ // TODO: remove in next major
+ /** @deprecated Use `TimerifyOptions` instead. */
+ interface PerformanceTimerifyOptions extends TimerifyOptions {}
interface PerformanceEventMap {
"resourcetimingbufferfull": Event;
}
@@ -137,50 +104,9 @@
options?: EventListenerOptions | boolean,
): void;
/**
- * The `eventLoopUtilization()` method returns an object that contains the
- * cumulative duration of time the event loop has been both idle and active as a
- * high resolution milliseconds timer. The `utilization` value is the calculated
- * Event Loop Utilization (ELU).
+ * This is an alias of `perf_hooks.eventLoopUtilization()`.
*
- * If bootstrapping has not yet finished on the main thread the properties have
- * the value of `0`. The ELU is immediately available on [Worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#worker-threads) since
- * bootstrap happens within the event loop.
- *
- * Both `utilization1` and `utilization2` are optional parameters.
- *
- * If `utilization1` is passed, then the delta between the current call's `active`
- * and `idle` times, as well as the corresponding `utilization` value are
- * calculated and returned (similar to `process.hrtime()`).
- *
- * If `utilization1` and `utilization2` are both passed, then the delta is
- * calculated between the two arguments. This is a convenience option because,
- * unlike `process.hrtime()`, calculating the ELU is more complex than a
- * single subtraction.
- *
- * ELU is similar to CPU utilization, except that it only measures event loop
- * statistics and not CPU usage. It represents the percentage of time the event
- * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
- * No other CPU idle time is taken into consideration. The following is an example
- * of how a mostly idle process will have a high ELU.
- *
- * ```js
- * import { eventLoopUtilization } from 'node:perf_hooks';
- * import { spawnSync } from 'node:child_process';
- *
- * setImmediate(() => {
- * const elu = eventLoopUtilization();
- * spawnSync('sleep', ['5']);
- * console.log(eventLoopUtilization(elu).utilization);
- * });
- * ```
- *
- * Although the CPU is mostly idle while running this script, the value of
- * `utilization` is `1`. This is because the call to
- * `child_process.spawnSync()` blocks the event loop from proceeding.
- *
- * Passing in a user-defined object instead of the result of a previous call to
- * `eventLoopUtilization()` will lead to undefined behavior. The return values
- * are not guaranteed to reflect any correct state of the event loop.
+ * _This property is an extension by Node.js. It is not available in Web browsers._
* @since v14.10.0, v12.19.0
* @param utilization1 The result of a previous call to
* `eventLoopUtilization()`.
@@ -192,40 +118,12 @@
utilization2?: EventLoopUtilization,
): EventLoopUtilization;
/**
+ * This is an alias of `perf_hooks.timerify()`.
+ *
* _This property is an extension by Node.js. It is not available in Web browsers._
- *
- * Wraps a function within a new function that measures the running time of the
- * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
- * event type in order for the timing details to be accessed.
- *
- * ```js
- * import { performance, PerformanceObserver } from 'node:perf_hooks';
- *
- * function someFunction() {
- * console.log('hello world');
- * }
- *
- * const wrapped = performance.timerify(someFunction);
- *
- * const obs = new PerformanceObserver((list) => {
- * console.log(list.getEntries()[0].duration);
- *
- * performance.clearMarks();
- * performance.clearMeasures();
- * obs.disconnect();
- * });
- * obs.observe({ entryTypes: ['function'] });
- *
- * // A performance timeline entry will be created
- * wrapped();
- * ```
- *
- * If the wrapped function returns a promise, a finally handler will be attached
- * to the promise and the duration will be reported once the finally handler is
- * invoked.
* @since v8.5.0
*/
- timerify<T extends (...args: any[]) => any>(fn: T, options?: PerformanceTimerifyOptions): T;
+ timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
}
var Performance: {
prototype: Performance;
@@ -305,14 +203,6 @@
};
var performance: Performance;
// #endregion
- interface PerformanceTimerifyOptions {
- /**
- * A histogram object created using
- * `perf_hooks.createHistogram()` that will record runtime durations in
- * nanoseconds.
- */
- histogram?: RecordableHistogram | undefined;
- }
/**
* _This class is an extension by Node.js. It is not available in Web browsers._
*
@@ -557,6 +447,66 @@
*/
add(other: RecordableHistogram): void;
}
+ interface EventLoopUtilization {
+ idle: number;
+ active: number;
+ utilization: number;
+ }
+ /**
+ * The `eventLoopUtilization()` function returns an object that contains the
+ * cumulative duration of time the event loop has been both idle and active as a
+ * high resolution milliseconds timer. The `utilization` value is the calculated
+ * Event Loop Utilization (ELU).
+ *
+ * If bootstrapping has not yet finished on the main thread the properties have
+ * the value of `0`. The ELU is immediately available on [Worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#worker-threads) since
+ * bootstrap happens within the event loop.
+ *
+ * Both `utilization1` and `utilization2` are optional parameters.
+ *
+ * If `utilization1` is passed, then the delta between the current call's `active`
+ * and `idle` times, as well as the corresponding `utilization` value are
+ * calculated and returned (similar to `process.hrtime()`).
+ *
+ * If `utilization1` and `utilization2` are both passed, then the delta is
+ * calculated between the two arguments. This is a convenience option because,
+ * unlike `process.hrtime()`, calculating the ELU is more complex than a
+ * single subtraction.
+ *
+ * ELU is similar to CPU utilization, except that it only measures event loop
+ * statistics and not CPU usage. It represents the percentage of time the event
+ * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
+ * No other CPU idle time is taken into consideration. The following is an example
+ * of how a mostly idle process will have a high ELU.
+ *
+ * ```js
+ * import { eventLoopUtilization } from 'node:perf_hooks';
+ * import { spawnSync } from 'node:child_process';
+ *
+ * setImmediate(() => {
+ * const elu = eventLoopUtilization();
+ * spawnSync('sleep', ['5']);
+ * console.log(eventLoopUtilization(elu).utilization);
+ * });
+ * ```
+ *
+ * Although the CPU is mostly idle while running this script, the value of
+ * `utilization` is `1`. This is because the call to
+ * `child_process.spawnSync()` blocks the event loop from proceeding.
+ *
+ * Passing in a user-defined object instead of the result of a previous call to
+ * `eventLoopUtilization()` will lead to undefined behavior. The return values
+ * are not guaranteed to reflect any correct state of the event loop.
+ * @since v25.2.0
+ * @param utilization1 The result of a previous call to
+ * `eventLoopUtilization()`.
+ * @param utilization2 The result of a previous call to
+ * `eventLoopUtilization()` prior to `utilization1`.
+ */
+ function eventLoopUtilization(
+ utilization1?: EventLoopUtilization,
+ utilization2?: EventLoopUtilization,
+ ): EventLoopUtilization;
/**
* _This property is an extension by Node.js. It is not available in Web browsers._
*
@@ -586,6 +536,49 @@
* @since v11.10.0
*/
function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+ interface TimerifyOptions {
+ /**
+ * A histogram object created using
+ * `perf_hooks.createHistogram()` that will record runtime durations in
+ * nanoseconds.
+ */
+ histogram?: RecordableHistogram | undefined;
+ }
+ /**
+ * _This property is an extension by Node.js. It is not available in Web browsers._
+ *
+ * Wraps a function within a new function that measures the running time of the
+ * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
+ * event type in order for the timing details to be accessed.
+ *
+ * ```js
+ * import { timerify, performance, PerformanceObserver } from 'node:perf_hooks';
+ *
+ * function someFunction() {
+ * console.log('hello world');
+ * }
+ *
+ * const wrapped = timerify(someFunction);
+ *
+ * const obs = new PerformanceObserver((list) => {
+ * console.log(list.getEntries()[0].duration);
+ *
+ * performance.clearMarks();
+ * performance.clearMeasures();
+ * obs.disconnect();
+ * });
+ * obs.observe({ entryTypes: ['function'] });
+ *
+ * // A performance timeline entry will be created
+ * wrapped();
+ * ```
+ *
+ * If the wrapped function returns a promise, a finally handler will be attached
+ * to the promise and the duration will be reported once the finally handler is
+ * invoked.
+ * @since v25.2.0
+ */
+ function timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
interface CreateHistogramOptions {
/**
* The minimum recordable value. Must be an integer value greater than 0.
@@ -613,8 +606,6 @@
interface MarkOptions extends PerformanceMarkOptions {}
/** @deprecated Use the canonical `PerformanceMeasureOptions` instead. */
interface MeasureOptions extends PerformanceMeasureOptions {}
- /** @deprecated Use `PerformanceTimerifyOptions` instead. */
- interface TimerifyOptions extends PerformanceTimerifyOptions {}
}
declare module "perf_hooks" {
export * from "node:perf_hooks";
--
Gitblit v1.9.3