@alanszp/express-common-fn 10.0.0 → 10.0.1

package/node_modules/@alanszp/errors/node_modules/@types/node/ts4.8/globals.d.ts

@@ -0,0 +1,411 @@
+export {}; // Make this a module
+
+// #region Fetch and friends
+// Conditional type aliases, used at the end of this file.
+// Will either be empty if lib-dom is included, or the undici version otherwise.
+type _Request = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Request;
+type _Response = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Response;
+type _FormData = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").FormData;
+type _Headers = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Headers;
+type _RequestInit = typeof globalThis extends { onmessage: any } ? {}
+    : import("undici-types").RequestInit;
+type _ResponseInit = typeof globalThis extends { onmessage: any } ? {}
+    : import("undici-types").ResponseInit;
+type _File = typeof globalThis extends { onmessage: any } ? {} : import("node:buffer").File;
+// #endregion Fetch and friends
+
+declare global {
+    // Declare "static" methods in Error
+    interface ErrorConstructor {
+        /** Create .stack property on a target object */
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+
+        /**
+         * Optional override for formatting stack traces
+         *
+         * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+         */
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+
+        stackTraceLimit: number;
+    }
+
+    /*-----------------------------------------------*
+    *                                               *
+    *                   GLOBAL                      *
+    *                                               *
+    ------------------------------------------------*/
+
+    // For backwards compability
+    interface NodeRequire extends NodeJS.Require {}
+    interface RequireResolve extends NodeJS.RequireResolve {}
+    interface NodeModule extends NodeJS.Module {}
+
+    var process: NodeJS.Process;
+    var console: Console;
+
+    var __filename: string;
+    var __dirname: string;
+
+    var require: NodeRequire;
+    var module: NodeModule;
+
+    // Same as module.exports
+    var exports: any;
+
+    /**
+     * Only available if `--expose-gc` is passed to the process.
+     */
+    var gc: undefined | (() => void);
+
+    // #region borrowed
+    // from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
+    /** A controller object that allows you to abort one or more DOM requests as and when desired. */
+    interface AbortController {
+        /**
+         * Returns the AbortSignal object associated with this object.
+         */
+
+        readonly signal: AbortSignal;
+        /**
+         * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
+         */
+        abort(reason?: any): void;
+    }
+
+    /** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
+    interface AbortSignal extends EventTarget {
+        /**
+         * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+         */
+        readonly aborted: boolean;
+        readonly reason: any;
+        onabort: null | ((this: AbortSignal, event: Event) => any);
+        throwIfAborted(): void;
+    }
+
+    var AbortController: typeof globalThis extends { onmessage: any; AbortController: infer T } ? T
+        : {
+            prototype: AbortController;
+            new(): AbortController;
+        };
+
+    var AbortSignal: typeof globalThis extends { onmessage: any; AbortSignal: infer T } ? T
+        : {
+            prototype: AbortSignal;
+            new(): AbortSignal;
+            abort(reason?: any): AbortSignal;
+            timeout(milliseconds: number): AbortSignal;
+        };
+    // #endregion borrowed
+
+    // #region Disposable
+    interface SymbolConstructor {
+        /**
+         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+         */
+        readonly dispose: unique symbol;
+
+        /**
+         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+         */
+        readonly asyncDispose: unique symbol;
+    }
+
+    interface Disposable {
+        [Symbol.dispose](): void;
+    }
+
+    interface AsyncDisposable {
+        [Symbol.asyncDispose](): PromiseLike<void>;
+    }
+    // #endregion Disposable
+
+    // #region ArrayLike.at()
+    interface RelativeIndexable<T> {
+        /**
+         * Takes an integer value and returns the item at that index,
+         * allowing for positive and negative integers.
+         * Negative integers count back from the last item in the array.
+         */
+        at(index: number): T | undefined;
+    }
+    interface String extends RelativeIndexable<string> {}
+    interface Array<T> extends RelativeIndexable<T> {}
+    interface ReadonlyArray<T> extends RelativeIndexable<T> {}
+    interface Int8Array extends RelativeIndexable<number> {}
+    interface Uint8Array extends RelativeIndexable<number> {}
+    interface Uint8ClampedArray extends RelativeIndexable<number> {}
+    interface Int16Array extends RelativeIndexable<number> {}
+    interface Uint16Array extends RelativeIndexable<number> {}
+    interface Int32Array extends RelativeIndexable<number> {}
+    interface Uint32Array extends RelativeIndexable<number> {}
+    interface Float32Array extends RelativeIndexable<number> {}
+    interface Float64Array extends RelativeIndexable<number> {}
+    interface BigInt64Array extends RelativeIndexable<bigint> {}
+    interface BigUint64Array extends RelativeIndexable<bigint> {}
+    // #endregion ArrayLike.at() end
+
+    /**
+     * @since v17.0.0
+     *
+     * Creates a deep clone of an object.
+     */
+    function structuredClone<T>(
+        value: T,
+        transfer?: { transfer: ReadonlyArray<import("worker_threads").TransferListItem> },
+    ): T;
+
+    /*----------------------------------------------*
+    *                                               *
+    *               GLOBAL INTERFACES               *
+    *                                               *
+    *-----------------------------------------------*/
+    namespace NodeJS {
+        interface CallSite {
+            /**
+             * Value of "this"
+             */
+            getThis(): unknown;
+
+            /**
+             * Type of "this" as a string.
+             * This is the name of the function stored in the constructor field of
+             * "this", if available.  Otherwise the object's [[Class]] internal
+             * property.
+             */
+            getTypeName(): string | null;
+
+            /**
+             * Current function
+             */
+            getFunction(): Function | undefined;
+
+            /**
+             * Name of the current function, typically its name property.
+             * If a name property is not available an attempt will be made to try
+             * to infer a name from the function's context.
+             */
+            getFunctionName(): string | null;
+
+            /**
+             * Name of the property [of "this" or one of its prototypes] that holds
+             * the current function
+             */
+            getMethodName(): string | null;
+
+            /**
+             * Name of the script [if this function was defined in a script]
+             */
+            getFileName(): string | undefined;
+
+            /**
+             * Current line number [if this function was defined in a script]
+             */
+            getLineNumber(): number | null;
+
+            /**
+             * Current column number [if this function was defined in a script]
+             */
+            getColumnNumber(): number | null;
+
+            /**
+             * A call site object representing the location where eval was called
+             * [if this function was created using a call to eval]
+             */
+            getEvalOrigin(): string | undefined;
+
+            /**
+             * Is this a toplevel invocation, that is, is "this" the global object?
+             */
+            isToplevel(): boolean;
+
+            /**
+             * Does this call take place in code defined by a call to eval?
+             */
+            isEval(): boolean;
+
+            /**
+             * Is this call in native V8 code?
+             */
+            isNative(): boolean;
+
+            /**
+             * Is this a constructor call?
+             */
+            isConstructor(): boolean;
+
+            /**
+             * is this an async call (i.e. await, Promise.all(), or Promise.any())?
+             */
+            isAsync(): boolean;
+
+            /**
+             * is this an async call to Promise.all()?
+             */
+            isPromiseAll(): boolean;
+
+            /**
+             * returns the index of the promise element that was followed in
+             * Promise.all() or Promise.any() for async stack traces, or null
+             * if the CallSite is not an async
+             */
+            getPromiseIndex(): number | null;
+
+            getScriptNameOrSourceURL(): string;
+            getScriptHash(): string;
+
+            getEnclosingColumnNumber(): number;
+            getEnclosingLineNumber(): number;
+            getPosition(): number;
+
+            toString(): string;
+        }
+
+        interface ErrnoException extends Error {
+            errno?: number | undefined;
+            code?: string | undefined;
+            path?: string | undefined;
+            syscall?: string | undefined;
+        }
+
+        interface ReadableStream extends EventEmitter {
+            readable: boolean;
+            read(size?: number): string | Buffer;
+            setEncoding(encoding: BufferEncoding): this;
+            pause(): this;
+            resume(): this;
+            isPaused(): boolean;
+            pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined }): T;
+            unpipe(destination?: WritableStream): this;
+            unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
+            wrap(oldStream: ReadableStream): this;
+            [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+        }
+
+        interface WritableStream extends EventEmitter {
+            writable: boolean;
+            write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+            write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            end(cb?: () => void): this;
+            end(data: string | Uint8Array, cb?: () => void): this;
+            end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
+        }
+
+        interface ReadWriteStream extends ReadableStream, WritableStream {}
+
+        interface RefCounted {
+            ref(): this;
+            unref(): this;
+        }
+
+        type TypedArray =
+            | Uint8Array
+            | Uint8ClampedArray
+            | Uint16Array
+            | Uint32Array
+            | Int8Array
+            | Int16Array
+            | Int32Array
+            | BigUint64Array
+            | BigInt64Array
+            | Float32Array
+            | Float64Array;
+        type ArrayBufferView = TypedArray | DataView;
+
+        interface Require {
+            (id: string): any;
+            resolve: RequireResolve;
+            cache: Dict<NodeModule>;
+            /**
+             * @deprecated
+             */
+            extensions: RequireExtensions;
+            main: Module | undefined;
+        }
+
+        interface RequireResolve {
+            (id: string, options?: { paths?: string[] | undefined }): string;
+            paths(request: string): string[] | null;
+        }
+
+        interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
+            ".js": (m: Module, filename: string) => any;
+            ".json": (m: Module, filename: string) => any;
+            ".node": (m: Module, filename: string) => any;
+        }
+        interface Module {
+            /**
+             * `true` if the module is running during the Node.js preload
+             */
+            isPreloading: boolean;
+            exports: any;
+            require: Require;
+            id: string;
+            filename: string;
+            loaded: boolean;
+            /** @deprecated since v14.6.0 Please use `require.main` and `module.children` instead. */
+            parent: Module | null | undefined;
+            children: Module[];
+            /**
+             * @since v11.14.0
+             *
+             * The directory name of the module. This is usually the same as the path.dirname() of the module.id.
+             */
+            path: string;
+            paths: string[];
+        }
+
+        interface Dict<T> {
+            [key: string]: T | undefined;
+        }
+
+        interface ReadOnlyDict<T> {
+            readonly [key: string]: T | undefined;
+        }
+    }
+
+    interface RequestInit extends _RequestInit {}
+
+    function fetch(
+        input: string | URL | globalThis.Request,
+        init?: RequestInit,
+    ): Promise<Response>;
+
+    interface Request extends _Request {}
+    var Request: typeof globalThis extends {
+        onmessage: any;
+        Request: infer T;
+    } ? T
+        : typeof import("undici-types").Request;
+
+    interface ResponseInit extends _ResponseInit {}
+
+    interface Response extends _Response {}
+    var Response: typeof globalThis extends {
+        onmessage: any;
+        Response: infer T;
+    } ? T
+        : typeof import("undici-types").Response;
+
+    interface FormData extends _FormData {}
+    var FormData: typeof globalThis extends {
+        onmessage: any;
+        FormData: infer T;
+    } ? T
+        : typeof import("undici-types").FormData;
+
+    interface Headers extends _Headers {}
+    var Headers: typeof globalThis extends {
+        onmessage: any;
+        Headers: infer T;
+    } ? T
+        : typeof import("undici-types").Headers;
+
+    interface File extends _File {}
+    var File: typeof globalThis extends {
+        onmessage: any;
+        File: infer T;
+    } ? T
+        : typeof import("node:buffer").File;
+}

package/node_modules/@alanszp/errors/node_modules/@types/node/ts4.8/globals.global.d.ts

@@ -0,0 +1 @@
+declare var global: typeof globalThis;