@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/test.d.ts

@@ -0,0 +1,462 @@
+declare module "node:test" {
+    import { AssertMethodNames, AssertPredicate } from "node:assert";
+    import { Readable, ReadableEventMap } from "node:stream";
+    import { TestEvent } from "node:test/reporters";
+    import { URL } from "node:url";
+    import TestFn = test.TestFn;
+    import TestOptions = test.TestOptions;
+    function test(name?: string, fn?: TestFn): Promise<void>;
+    function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+    function test(options?: TestOptions, fn?: TestFn): Promise<void>;
+    function test(fn?: TestFn): Promise<void>;
+    namespace test {
+        export { test };
+        export { suite as describe, test as it };
+    }
+    namespace test {
+        function run(options?: RunOptions): TestsStream;
+        function suite(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function suite(name?: string, fn?: SuiteFn): Promise<void>;
+        function suite(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+        function suite(fn?: SuiteFn): Promise<void>;
+        namespace suite {
+            function skip(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function skip(name?: string, fn?: SuiteFn): Promise<void>;
+            function skip(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function skip(fn?: SuiteFn): Promise<void>;
+            function todo(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function todo(name?: string, fn?: SuiteFn): Promise<void>;
+            function todo(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function todo(fn?: SuiteFn): Promise<void>;
+            function only(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function only(name?: string, fn?: SuiteFn): Promise<void>;
+            function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function only(fn?: SuiteFn): Promise<void>;
+            function expectFailure(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function expectFailure(name?: string, fn?: SuiteFn): Promise<void>;
+            function expectFailure(options?: TestOptions, fn?: SuiteFn): Promise<void>;
+            function expectFailure(fn?: SuiteFn): Promise<void>;
+        }
+        function skip(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+        function skip(name?: string, fn?: TestFn): Promise<void>;
+        function skip(options?: TestOptions, fn?: TestFn): Promise<void>;
+        function skip(fn?: TestFn): Promise<void>;
+        function todo(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+        function todo(name?: string, fn?: TestFn): Promise<void>;
+        function todo(options?: TestOptions, fn?: TestFn): Promise<void>;
+        function todo(fn?: TestFn): Promise<void>;
+        function only(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+        function only(name?: string, fn?: TestFn): Promise<void>;
+        function only(options?: TestOptions, fn?: TestFn): Promise<void>;
+        function only(fn?: TestFn): Promise<void>;
+        function expectFailure(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+        function expectFailure(name?: string, fn?: TestFn): Promise<void>;
+        function expectFailure(options?: TestOptions, fn?: TestFn): Promise<void>;
+        function expectFailure(fn?: TestFn): Promise<void>;
+        type TestFn = (t: TestContext, done: (result?: any) => void) => void | Promise<void>;
+        type SuiteFn = (s: SuiteContext) => void | Promise<void>;
+        interface TestShard {
+            index: number;
+            total: number;
+        }
+        interface RunOptions {
+            concurrency?: number | boolean | undefined;
+            cwd?: string | undefined;
+            files?: readonly string[] | undefined;
+            forceExit?: boolean | undefined;
+            globPatterns?: readonly string[] | undefined;
+            inspectPort?: number | (() => number) | undefined;
+            isolation?: "process" | "none" | undefined;
+            only?: boolean | undefined;
+            setup?: ((reporter: TestsStream) => void | Promise<void>) | undefined;
+            execArgv?: readonly string[] | undefined;
+            argv?: readonly string[] | undefined;
+            signal?: AbortSignal | undefined;
+            testNamePatterns?: string | RegExp | ReadonlyArray<string | RegExp> | undefined;
+            testSkipPatterns?: string | RegExp | ReadonlyArray<string | RegExp> | undefined;
+            timeout?: number | undefined;
+            watch?: boolean | undefined;
+            shard?: TestShard | undefined;
+            rerunFailuresFilePath?: string | undefined;
+            coverage?: boolean | undefined;
+            coverageExcludeGlobs?: string | readonly string[] | undefined;
+            coverageIncludeGlobs?: string | readonly string[] | undefined;
+            lineCoverage?: number | undefined;
+            branchCoverage?: number | undefined;
+            functionCoverage?: number | undefined;
+            env?: NodeJS.ProcessEnv | undefined;
+        }
+        interface TestsStreamEventMap extends ReadableEventMap {
+            "data": [
+                data: TestEvent
+            ];
+            "test:coverage": [
+                data: EventData.TestCoverage
+            ];
+            "test:complete": [
+                data: EventData.TestComplete
+            ];
+            "test:dequeue": [
+                data: EventData.TestDequeue
+            ];
+            "test:diagnostic": [
+                data: EventData.TestDiagnostic
+            ];
+            "test:enqueue": [
+                data: EventData.TestEnqueue
+            ];
+            "test:fail": [
+                data: EventData.TestFail
+            ];
+            "test:interrupted": [
+                data: EventData.TestInterrupted
+            ];
+            "test:pass": [
+                data: EventData.TestPass
+            ];
+            "test:plan": [
+                data: EventData.TestPlan
+            ];
+            "test:start": [
+                data: EventData.TestStart
+            ];
+            "test:stderr": [
+                data: EventData.TestStderr
+            ];
+            "test:stdout": [
+                data: EventData.TestStdout
+            ];
+            "test:summary": [
+                data: EventData.TestSummary
+            ];
+            "test:watch:drained": [
+            ];
+            "test:watch:restarted": [
+            ];
+        }
+        interface TestsStream extends Readable {
+            addListener<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof TestsStreamEventMap>(eventName: E, ...args: TestsStreamEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof TestsStreamEventMap>(eventName: E, listener?: (...args: TestsStreamEventMap[E]) => void): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof TestsStreamEventMap>(eventName: E): ((...args: TestsStreamEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof TestsStreamEventMap>(eventName: E): ((...args: TestsStreamEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            removeAllListeners<E extends keyof TestsStreamEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof TestsStreamEventMap>(eventName: E, listener: (...args: TestsStreamEventMap[E]) => void): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        }
+        namespace EventData {
+            interface Error extends globalThis.Error {
+                cause: unknown;
+            }
+            interface LocationInfo {
+                column?: number;
+                file?: string;
+                line?: number;
+            }
+            interface TestDiagnostic extends LocationInfo {
+                message: string;
+                nesting: number;
+                level: "info" | "warn" | "error";
+            }
+            interface TestCoverage {
+                summary: {
+                    files: Array<{
+                        path: string;
+                        totalLineCount: number;
+                        totalBranchCount: number;
+                        totalFunctionCount: number;
+                        coveredLineCount: number;
+                        coveredBranchCount: number;
+                        coveredFunctionCount: number;
+                        coveredLinePercent: number;
+                        coveredBranchPercent: number;
+                        coveredFunctionPercent: number;
+                        functions: Array<{
+                            name: string;
+                            line: number;
+                            count: number;
+                        }>;
+                        branches: Array<{
+                            line: number;
+                            count: number;
+                        }>;
+                        lines: Array<{
+                            line: number;
+                            count: number;
+                        }>;
+                    }>;
+                    thresholds: {
+                        function: number;
+                        branch: number;
+                        line: number;
+                    };
+                    totals: {
+                        totalLineCount: number;
+                        totalBranchCount: number;
+                        totalFunctionCount: number;
+                        coveredLineCount: number;
+                        coveredBranchCount: number;
+                        coveredFunctionCount: number;
+                        coveredLinePercent: number;
+                        coveredBranchPercent: number;
+                        coveredFunctionPercent: number;
+                    };
+                    workingDirectory: string;
+                };
+                nesting: number;
+            }
+            interface TestComplete extends LocationInfo {
+                details: {
+                    passed: boolean;
+                    duration_ms: number;
+                    error?: Error;
+                    type?: "suite" | "test";
+                };
+                name: string;
+                nesting: number;
+                testNumber: number;
+                todo?: string | boolean;
+                skip?: string | boolean;
+            }
+            interface TestDequeue extends LocationInfo {
+                name: string;
+                nesting: number;
+                type: "suite" | "test";
+            }
+            interface TestEnqueue extends LocationInfo {
+                name: string;
+                nesting: number;
+                type: "suite" | "test";
+            }
+            interface TestFail extends LocationInfo {
+                details: {
+                    duration_ms: number;
+                    error: Error;
+                    type?: "suite" | "test";
+                    attempt?: number;
+                };
+                name: string;
+                nesting: number;
+                testNumber: number;
+                todo?: string | boolean;
+                skip?: string | boolean;
+            }
+            interface TestInterrupted {
+                tests: TestStart[];
+            }
+            interface TestPass extends LocationInfo {
+                details: {
+                    duration_ms: number;
+                    type?: "suite" | "test";
+                    attempt?: number;
+                    passed_on_attempt?: number;
+                };
+                name: string;
+                nesting: number;
+                testNumber: number;
+                todo?: string | boolean;
+                skip?: string | boolean;
+            }
+            interface TestPlan extends LocationInfo {
+                nesting: number;
+                count: number;
+            }
+            interface TestStart extends LocationInfo {
+                name: string;
+                nesting: number;
+            }
+            interface TestStderr {
+                file: string;
+                message: string;
+            }
+            interface TestStdout {
+                file: string;
+                message: string;
+            }
+            interface TestSummary {
+                counts: {
+                    cancelled: number;
+                    passed: number;
+                    skipped: number;
+                    suites: number;
+                    tests: number;
+                    todo: number;
+                    topLevel: number;
+                };
+                duration_ms: number;
+                file: string | undefined;
+                success: boolean;
+            }
+        }
+        interface TestContext {
+            readonly assert: TestContextAssert;
+            before(fn?: TestContextHookFn, options?: HookOptions): void;
+            beforeEach(fn?: TestContextHookFn, options?: HookOptions): void;
+            after(fn?: TestContextHookFn, options?: HookOptions): void;
+            afterEach(fn?: TestContextHookFn, options?: HookOptions): void;
+            diagnostic(message: string): void;
+            readonly filePath: string | undefined;
+            readonly fullName: string;
+            readonly name: string;
+            readonly passed: boolean;
+            readonly error: EventData.Error | null;
+            readonly attempt: number;
+            readonly workerId: number | undefined;
+            plan(count: number, options?: TestContextPlanOptions): void;
+            runOnly(shouldRunOnlyTests: boolean): void;
+            readonly signal: AbortSignal;
+            skip(message?: string): void;
+            todo(message?: string): void;
+            test: typeof test;
+            waitFor<T>(condition: () => T, options?: TestContextWaitForOptions): Promise<Awaited<T>>;
+            readonly mock: MockTracker;
+        }
+        interface TestContextAssert extends Pick<typeof import("assert"), AssertMethodNames> {
+            fileSnapshot(value: any, path: string, options?: AssertSnapshotOptions): void;
+            snapshot(value: any, options?: AssertSnapshotOptions): void;
+            [name: string]: (...args: any[]) => void;
+        }
+        interface AssertSnapshotOptions {
+            serializers?: ReadonlyArray<(value: any) => any> | undefined;
+        }
+        interface TestContextPlanOptions {
+            wait?: boolean | number | undefined;
+        }
+        interface TestContextWaitForOptions {
+            interval?: number | undefined;
+            timeout?: number | undefined;
+        }
+        interface SuiteContext {
+            readonly filePath: string | undefined;
+            readonly fullName: string;
+            readonly name: string;
+            readonly signal: AbortSignal;
+        }
+        interface TestOptions {
+            concurrency?: number | boolean | undefined;
+            expectFailure?: boolean | string | AssertPredicate | undefined;
+            only?: boolean | undefined;
+            signal?: AbortSignal | undefined;
+            skip?: boolean | string | undefined;
+            timeout?: number | undefined;
+            todo?: boolean | string | undefined;
+            plan?: number | undefined;
+        }
+        function before(fn?: HookFn, options?: HookOptions): void;
+        function after(fn?: HookFn, options?: HookOptions): void;
+        function beforeEach(fn?: HookFn, options?: HookOptions): void;
+        function afterEach(fn?: HookFn, options?: HookOptions): void;
+        type HookFn = (c: TestContext | SuiteContext, done: (result?: any) => void) => any;
+        type TestContextHookFn = (t: TestContext, done: (result?: any) => void) => any;
+        interface HookOptions {
+            signal?: AbortSignal | undefined;
+            timeout?: number | undefined;
+        }
+        interface MockFunctionOptions {
+            times?: number | undefined;
+        }
+        interface MockMethodOptions extends MockFunctionOptions {
+            getter?: boolean | undefined;
+            setter?: boolean | undefined;
+        }
+        type Mock<F extends Function> = F & {
+            mock: MockFunctionContext<F>;
+        };
+        interface MockModuleOptions {
+            cache?: boolean | undefined;
+            exports?: object | undefined;
+            defaultExport?: any;
+            namedExports?: object | undefined;
+        }
+        interface MockTracker {
+            fn<F extends Function = (...args: any[]) => undefined>(original?: F, options?: MockFunctionOptions): Mock<F>;
+            fn<F extends Function = (...args: any[]) => undefined, Implementation extends Function = F>(original?: F, implementation?: Implementation, options?: MockFunctionOptions): Mock<F | Implementation>;
+            method<MockedObject extends object, MethodName extends FunctionPropertyNames<MockedObject>>(object: MockedObject, methodName: MethodName, options?: MockFunctionOptions): MockedObject[MethodName] extends Function ? Mock<MockedObject[MethodName]> : never;
+            method<MockedObject extends object, MethodName extends FunctionPropertyNames<MockedObject>, Implementation extends Function>(object: MockedObject, methodName: MethodName, implementation: Implementation, options?: MockFunctionOptions): MockedObject[MethodName] extends Function ? Mock<MockedObject[MethodName] | Implementation> : never;
+            method<MockedObject extends object>(object: MockedObject, methodName: keyof MockedObject, options: MockMethodOptions): Mock<Function>;
+            method<MockedObject extends object>(object: MockedObject, methodName: keyof MockedObject, implementation: Function, options: MockMethodOptions): Mock<Function>;
+            getter<MockedObject extends object, MethodName extends keyof MockedObject>(object: MockedObject, methodName: MethodName, options?: MockFunctionOptions): Mock<() => MockedObject[MethodName]>;
+            getter<MockedObject extends object, MethodName extends keyof MockedObject, Implementation extends Function>(object: MockedObject, methodName: MethodName, implementation?: Implementation, options?: MockFunctionOptions): Mock<(() => MockedObject[MethodName]) | Implementation>;
+            setter<MockedObject extends object, MethodName extends keyof MockedObject>(object: MockedObject, methodName: MethodName, options?: MockFunctionOptions): Mock<(value: MockedObject[MethodName]) => void>;
+            setter<MockedObject extends object, MethodName extends keyof MockedObject, Implementation extends Function>(object: MockedObject, methodName: MethodName, implementation?: Implementation, options?: MockFunctionOptions): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
+            module(specifier: string | URL, options?: MockModuleOptions): MockModuleContext;
+            property<MockedObject extends object, PropertyName extends keyof MockedObject>(object: MockedObject, property: PropertyName, value?: MockedObject[PropertyName]): MockedObject & {
+                mock: MockPropertyContext<MockedObject[PropertyName]>;
+            };
+            reset(): void;
+            restoreAll(): void;
+            readonly timers: MockTimers;
+        }
+        const mock: MockTracker;
+        interface MockFunctionCall<F extends Function, ReturnType = F extends (...args: any) => infer T ? T : F extends abstract new (...args: any) => infer T ? T : unknown, Args = F extends (...args: infer Y) => any ? Y : F extends abstract new (...args: infer Y) => any ? Y : unknown[]> {
+            arguments: Args;
+            error: unknown | undefined;
+            result: ReturnType | undefined;
+            stack: Error;
+            target: F extends abstract new (...args: any) => any ? F : undefined;
+            this: unknown;
+        }
+        interface MockFunctionContext<F extends Function> {
+            readonly calls: MockFunctionCall<F>[];
+            callCount(): number;
+            mockImplementation(implementation: F): void;
+            mockImplementationOnce(implementation: F, onCall?: number): void;
+            resetCalls(): void;
+            restore(): void;
+        }
+        interface MockModuleContext {
+            restore(): void;
+        }
+        class MockPropertyContext<PropertyType = any> {
+            readonly accesses: Array<{
+                type: "get" | "set";
+                value: PropertyType;
+                stack: Error;
+            }>;
+            accessCount(): number;
+            mockImplementation(value: PropertyType): void;
+            mockImplementationOnce(value: PropertyType, onAccess?: number): void;
+            resetAccesses(): void;
+            restore(): void;
+        }
+        interface MockTimersOptions {
+            apis: ReadonlyArray<"setInterval" | "setTimeout" | "setImmediate" | "Date">;
+            now?: number | Date | undefined;
+        }
+        interface MockTimers {
+            enable(options?: MockTimersOptions): void;
+            setTime(milliseconds: number): void;
+            reset(): void;
+            tick(milliseconds: number): void;
+            runAll(): void;
+            [Symbol.dispose](): void;
+        }
+        namespace assert {
+            function register(name: string, fn: (this: TestContext, ...args: any[]) => void): void;
+        }
+        namespace snapshot {
+            function setDefaultSnapshotSerializers(serializers: ReadonlyArray<(value: any) => any>): void;
+            function setResolveSnapshotPath(fn: (path: string | undefined) => string): void;
+        }
+    }
+    type FunctionPropertyNames<T> = {
+        [K in keyof T]: T[K] extends Function ? K : never;
+    }[keyof T];
+    export = test;
+}

package/types/node/timers/promises.d.ts

@@ -0,0 +1,16 @@
+declare module "node:timers/promises" {
+    import { TimerOptions } from "node:timers";
+    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
+    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
+    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): NodeJS.AsyncIterator<T>;
+    interface Scheduler {
+        wait(delay: number, options?: {
+            signal?: AbortSignal;
+        }): Promise<void>;
+        yield(): Promise<void>;
+    }
+    const scheduler: Scheduler;
+}
+declare module "timers/promises" {
+    export * from "node:timers/promises";
+}

package/types/node/timers.d.ts

@@ -0,0 +1,43 @@
+declare module "node:timers" {
+    import { Abortable } from "node:events";
+    import * as promises from "node:timers/promises";
+    export interface TimerOptions extends Abortable {
+        ref?: boolean | undefined;
+    }
+    global {
+        namespace NodeJS {
+            interface Immediate extends RefCounted, Disposable {
+                hasRef(): boolean;
+                ref(): this;
+                unref(): this;
+                [Symbol.dispose](): void;
+                _onImmediate(...args: any[]): void;
+            }
+            interface Timer extends RefCounted {
+                hasRef(): boolean;
+                refresh(): this;
+                [Symbol.toPrimitive](): number;
+            }
+            interface Timeout extends RefCounted, Disposable, Timer {
+                close(): this;
+                hasRef(): boolean;
+                ref(): this;
+                refresh(): this;
+                unref(): this;
+                [Symbol.toPrimitive](): number;
+                [Symbol.dispose](): void;
+                _onTimeout(...args: any[]): void;
+            }
+        }
+    }
+    import clearImmediate = globalThis.clearImmediate;
+    import clearInterval = globalThis.clearInterval;
+    import clearTimeout = globalThis.clearTimeout;
+    import setImmediate = globalThis.setImmediate;
+    import setInterval = globalThis.setInterval;
+    import setTimeout = globalThis.setTimeout;
+    export { clearImmediate, clearInterval, clearTimeout, promises, setImmediate, setInterval, setTimeout };
+}
+declare module "timers" {
+    export * from "node:timers";
+}