316 lines
14 KiB
Plaintext
316 lines
14 KiB
Plaintext
|
/**
|
||
|
* @since v0.3.7
|
||
|
* @experimental
|
||
|
*/
|
||
|
declare module "module" {
|
||
|
import { URL } from "node:url";
|
||
|
import { MessagePort } from "node:worker_threads";
|
||
|
namespace Module {
|
||
|
/**
|
||
|
* The `module.syncBuiltinESMExports()` method updates all the live bindings for
|
||
|
* builtin `ES Modules` to match the properties of the `CommonJS` exports. It
|
||
|
* does not add or remove exported names from the `ES Modules`.
|
||
|
*
|
||
|
* ```js
|
||
|
* const fs = require('node:fs');
|
||
|
* const assert = require('node:assert');
|
||
|
* const { syncBuiltinESMExports } = require('node:module');
|
||
|
*
|
||
|
* fs.readFile = newAPI;
|
||
|
*
|
||
|
* delete fs.readFileSync;
|
||
|
*
|
||
|
* function newAPI() {
|
||
|
* // ...
|
||
|
* }
|
||
|
*
|
||
|
* fs.newAPI = newAPI;
|
||
|
*
|
||
|
* syncBuiltinESMExports();
|
||
|
*
|
||
|
* import('node:fs').then((esmFS) => {
|
||
|
* // It syncs the existing readFile property with the new value
|
||
|
* assert.strictEqual(esmFS.readFile, newAPI);
|
||
|
* // readFileSync has been deleted from the required fs
|
||
|
* assert.strictEqual('readFileSync' in fs, false);
|
||
|
* // syncBuiltinESMExports() does not remove readFileSync from esmFS
|
||
|
* assert.strictEqual('readFileSync' in esmFS, true);
|
||
|
* // syncBuiltinESMExports() does not add names
|
||
|
* assert.strictEqual(esmFS.newAPI, undefined);
|
||
|
* });
|
||
|
* ```
|
||
|
* @since v12.12.0
|
||
|
*/
|
||
|
function syncBuiltinESMExports(): void;
|
||
|
/**
|
||
|
* `path` is the resolved path for the file for which a corresponding source map
|
||
|
* should be fetched.
|
||
|
* @since v13.7.0, v12.17.0
|
||
|
* @return Returns `module.SourceMap` if a source map is found, `undefined` otherwise.
|
||
|
*/
|
||
|
function findSourceMap(path: string, error?: Error): SourceMap;
|
||
|
interface SourceMapPayload {
|
||
|
file: string;
|
||
|
version: number;
|
||
|
sources: string[];
|
||
|
sourcesContent: string[];
|
||
|
names: string[];
|
||
|
mappings: string;
|
||
|
sourceRoot: string;
|
||
|
}
|
||
|
interface SourceMapping {
|
||
|
generatedLine: number;
|
||
|
generatedColumn: number;
|
||
|
originalSource: string;
|
||
|
originalLine: number;
|
||
|
originalColumn: number;
|
||
|
}
|
||
|
interface SourceOrigin {
|
||
|
/**
|
||
|
* The name of the range in the source map, if one was provided
|
||
|
*/
|
||
|
name?: string;
|
||
|
/**
|
||
|
* The file name of the original source, as reported in the SourceMap
|
||
|
*/
|
||
|
fileName: string;
|
||
|
/**
|
||
|
* The 1-indexed lineNumber of the corresponding call site in the original source
|
||
|
*/
|
||
|
lineNumber: number;
|
||
|
/**
|
||
|
* The 1-indexed columnNumber of the corresponding call site in the original source
|
||
|
*/
|
||
|
columnNumber: number;
|
||
|
}
|
||
|
/**
|
||
|
* @since v13.7.0, v12.17.0
|
||
|
*/
|
||
|
class SourceMap {
|
||
|
/**
|
||
|
* Getter for the payload used to construct the `SourceMap` instance.
|
||
|
*/
|
||
|
readonly payload: SourceMapPayload;
|
||
|
constructor(payload: SourceMapPayload);
|
||
|
/**
|
||
|
* Given a line offset and column offset in the generated source
|
||
|
* file, returns an object representing the SourceMap range in the
|
||
|
* original file if found, or an empty object if not.
|
||
|
*
|
||
|
* The object returned contains the following keys:
|
||
|
*
|
||
|
* The returned value represents the raw range as it appears in the
|
||
|
* SourceMap, based on zero-indexed offsets, _not_ 1-indexed line and
|
||
|
* column numbers as they appear in Error messages and CallSite
|
||
|
* objects.
|
||
|
*
|
||
|
* To get the corresponding 1-indexed line and column numbers from a
|
||
|
* lineNumber and columnNumber as they are reported by Error stacks
|
||
|
* and CallSite objects, use `sourceMap.findOrigin(lineNumber, columnNumber)`
|
||
|
* @param lineOffset The zero-indexed line number offset in the generated source
|
||
|
* @param columnOffset The zero-indexed column number offset in the generated source
|
||
|
*/
|
||
|
findEntry(lineOffset: number, columnOffset: number): SourceMapping;
|
||
|
/**
|
||
|
* Given a 1-indexed `lineNumber` and `columnNumber` from a call site in the generated source,
|
||
|
* find the corresponding call site location in the original source.
|
||
|
*
|
||
|
* If the `lineNumber` and `columnNumber` provided are not found in any source map,
|
||
|
* then an empty object is returned.
|
||
|
* @param lineNumber The 1-indexed line number of the call site in the generated source
|
||
|
* @param columnNumber The 1-indexed column number of the call site in the generated source
|
||
|
*/
|
||
|
findOrigin(lineNumber: number, columnNumber: number): SourceOrigin | {};
|
||
|
}
|
||
|
/** @deprecated Use `ImportAttributes` instead */
|
||
|
interface ImportAssertions extends ImportAttributes {}
|
||
|
interface ImportAttributes extends NodeJS.Dict<string> {
|
||
|
type?: string | undefined;
|
||
|
}
|
||
|
type ModuleFormat = "builtin" | "commonjs" | "json" | "module" | "wasm";
|
||
|
type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
|
||
|
interface GlobalPreloadContext {
|
||
|
port: MessagePort;
|
||
|
}
|
||
|
/**
|
||
|
* @deprecated This hook will be removed in a future version.
|
||
|
* Use `initialize` instead. When a loader has an `initialize` export, `globalPreload` will be ignored.
|
||
|
*
|
||
|
* Sometimes it might be necessary to run some code inside of the same global scope that the application runs in.
|
||
|
* This hook allows the return of a string that is run as a sloppy-mode script on startup.
|
||
|
*
|
||
|
* @param context Information to assist the preload code
|
||
|
* @return Code to run before application startup
|
||
|
*/
|
||
|
type GlobalPreloadHook = (context: GlobalPreloadContext) => string;
|
||
|
/**
|
||
|
* The `initialize` hook provides a way to define a custom function that runs in the hooks thread
|
||
|
* when the hooks module is initialized. Initialization happens when the hooks module is registered via `register`.
|
||
|
*
|
||
|
* This hook can receive data from a `register` invocation, including ports and other transferrable objects.
|
||
|
* The return value of `initialize` can be a `Promise`, in which case it will be awaited before the main application thread execution resumes.
|
||
|
*/
|
||
|
type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
|
||
|
interface ResolveHookContext {
|
||
|
/**
|
||
|
* Export conditions of the relevant `package.json`
|
||
|
*/
|
||
|
conditions: string[];
|
||
|
/**
|
||
|
* @deprecated Use `importAttributes` instead
|
||
|
*/
|
||
|
importAssertions: ImportAttributes;
|
||
|
/**
|
||
|
* An object whose key-value pairs represent the assertions for the module to import
|
||
|
*/
|
||
|
importAttributes: ImportAttributes;
|
||
|
/**
|
||
|
* The module importing this one, or undefined if this is the Node.js entry point
|
||
|
*/
|
||
|
parentURL: string | undefined;
|
||
|
}
|
||
|
interface ResolveFnOutput {
|
||
|
/**
|
||
|
* A hint to the load hook (it might be ignored)
|
||
|
*/
|
||
|
format?: ModuleFormat | null | undefined;
|
||
|
/**
|
||
|
* @deprecated Use `importAttributes` instead
|
||
|
*/
|
||
|
importAssertions?: ImportAttributes | undefined;
|
||
|
/**
|
||
|
* The import attributes to use when caching the module (optional; if excluded the input will be used)
|
||
|
*/
|
||
|
importAttributes?: ImportAttributes | undefined;
|
||
|
/**
|
||
|
* A signal that this hook intends to terminate the chain of `resolve` hooks.
|
||
|
* @default false
|
||
|
*/
|
||
|
shortCircuit?: boolean | undefined;
|
||
|
/**
|
||
|
* The absolute URL to which this input resolves
|
||
|
*/
|
||
|
url: string;
|
||
|
}
|
||
|
/**
|
||
|
* The `resolve` hook chain is responsible for resolving file URL for a given module specifier and parent URL, and optionally its format (such as `'module'`) as a hint to the `load` hook.
|
||
|
* If a format is specified, the load hook is ultimately responsible for providing the final `format` value (and it is free to ignore the hint provided by `resolve`);
|
||
|
* if `resolve` provides a format, a custom `load` hook is required even if only to pass the value to the Node.js default `load` hook.
|
||
|
*
|
||
|
* @param specifier The specified URL path of the module to be resolved
|
||
|
* @param context
|
||
|
* @param nextResolve The subsequent `resolve` hook in the chain, or the Node.js default `resolve` hook after the last user-supplied resolve hook
|
||
|
*/
|
||
|
type ResolveHook = (
|
||
|
specifier: string,
|
||
|
context: ResolveHookContext,
|
||
|
nextResolve: (
|
||
|
specifier: string,
|
||
|
context?: ResolveHookContext,
|
||
|
) => ResolveFnOutput | Promise<ResolveFnOutput>,
|
||
|
) => ResolveFnOutput | Promise<ResolveFnOutput>;
|
||
|
interface LoadHookContext {
|
||
|
/**
|
||
|
* Export conditions of the relevant `package.json`
|
||
|
*/
|
||
|
conditions: string[];
|
||
|
/**
|
||
|
* The format optionally supplied by the `resolve` hook chain
|
||
|
*/
|
||
|
format: ModuleFormat;
|
||
|
/**
|
||
|
* @deprecated Use `importAttributes` instead
|
||
|
*/
|
||
|
importAssertions: ImportAttributes;
|
||
|
/**
|
||
|
* An object whose key-value pairs represent the assertions for the module to import
|
||
|
*/
|
||
|
importAttributes: ImportAttributes;
|
||
|
}
|
||
|
interface LoadFnOutput {
|
||
|
format: ModuleFormat;
|
||
|
/**
|
||
|
* A signal that this hook intends to terminate the chain of `resolve` hooks.
|
||
|
* @default false
|
||
|
*/
|
||
|
shortCircuit?: boolean | undefined;
|
||
|
/**
|
||
|
* The source for Node.js to evaluate
|
||
|
*/
|
||
|
source?: ModuleSource;
|
||
|
}
|
||
|
/**
|
||
|
* The `load` hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed.
|
||
|
* It is also in charge of validating the import assertion.
|
||
|
*
|
||
|
* @param url The URL/path of the module to be loaded
|
||
|
* @param context Metadata about the module
|
||
|
* @param nextLoad The subsequent `load` hook in the chain, or the Node.js default `load` hook after the last user-supplied `load` hook
|
||
|
*/
|
||
|
type LoadHook = (
|
||
|
url: string,
|
||
|
context: LoadHookContext,
|
||
|
nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>,
|
||
|
) => LoadFnOutput | Promise<LoadFnOutput>;
|
||
|
}
|
||
|
interface RegisterOptions<Data> {
|
||
|
parentURL: string | URL;
|
||
|
data?: Data | undefined;
|
||
|
transferList?: any[] | undefined;
|
||
|
}
|
||
|
interface Module extends NodeModule {}
|
||
|
class Module {
|
||
|
static runMain(): void;
|
||
|
static wrap(code: string): string;
|
||
|
static createRequire(path: string | URL): NodeRequire;
|
||
|
static builtinModules: string[];
|
||
|
static isBuiltin(moduleName: string): boolean;
|
||
|
static Module: typeof Module;
|
||
|
static register<Data = any>(
|
||
|
specifier: string | URL,
|
||
|
parentURL?: string | URL,
|
||
|
options?: RegisterOptions<Data>,
|
||
|
): void;
|
||
|
static register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
|
||
|
constructor(id: string, parent?: Module);
|
||
|
}
|
||
|
global {
|
||
|
interface ImportMeta {
|
||
|
/**
|
||
|
* The directory name of the current module. This is the same as the `path.dirname()` of the `import.meta.filename`.
|
||
|
* **Caveat:** only present on `file:` modules.
|
||
|
*/
|
||
|
dirname: string;
|
||
|
/**
|
||
|
* The full absolute path and filename of the current module, with symlinks resolved.
|
||
|
* This is the same as the `url.fileURLToPath()` of the `import.meta.url`.
|
||
|
* **Caveat:** only local modules support this property. Modules not using the `file:` protocol will not provide it.
|
||
|
*/
|
||
|
filename: string;
|
||
|
/**
|
||
|
* The absolute `file:` URL of the module.
|
||
|
*/
|
||
|
url: string;
|
||
|
/**
|
||
|
* Provides a module-relative resolution function scoped to each module, returning
|
||
|
* the URL string.
|
||
|
*
|
||
|
* Second `parent` parameter is only used when the `--experimental-import-meta-resolve`
|
||
|
* command flag enabled.
|
||
|
*
|
||
|
* @since v20.6.0
|
||
|
*
|
||
|
* @param specifier The module specifier to resolve relative to `parent`.
|
||
|
* @param parent The absolute parent module URL to resolve from.
|
||
|
* @returns The absolute (`file:`) URL string for the resolved module.
|
||
|
*/
|
||
|
resolve(specifier: string, parent?: string | URL | undefined): string;
|
||
|
}
|
||
|
}
|
||
|
export = Module;
|
||
|
}
|
||
|
declare module "node:module" {
|
||
|
import module = require("module");
|
||
|
export = module;
|
||
|
}
|