@comapeo/map-server 1.0.0-pre.0

package/node_modules/@whatwg-node/disposablestack/cjs/AsyncDisposableStack.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillAsyncDisposableStack = void 0;
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const SupressedError_js_1 = require("./SupressedError.js");
+const symbols_js_1 = require("./symbols.js");
+const utils_js_1 = require("./utils.js");
+const SuppressedError = globalThis.SuppressedError || SupressedError_js_1.PonyfillSuppressedError;
+class PonyfillAsyncDisposableStack {
+    callbacks = [];
+    get disposed() {
+        return this.callbacks.length === 0;
+    }
+    use(value) {
+        if ((0, utils_js_1.isAsyncDisposable)(value)) {
+            this.callbacks.push(() => value[symbols_js_1.DisposableSymbols.asyncDispose]());
+        }
+        else if ((0, utils_js_1.isSyncDisposable)(value)) {
+            this.callbacks.push(() => value[symbols_js_1.DisposableSymbols.dispose]());
+        }
+        return value;
+    }
+    adopt(value, onDisposeAsync) {
+        if (onDisposeAsync) {
+            this.callbacks.push(() => onDisposeAsync(value));
+        }
+        return value;
+    }
+    defer(onDisposeAsync) {
+        if (onDisposeAsync) {
+            this.callbacks.push(onDisposeAsync);
+        }
+    }
+    move() {
+        const stack = new PonyfillAsyncDisposableStack();
+        stack.callbacks = this.callbacks;
+        this.callbacks = [];
+        return stack;
+    }
+    disposeAsync() {
+        return this[symbols_js_1.DisposableSymbols.asyncDispose]();
+    }
+    _error;
+    _iterateCallbacks() {
+        const cb = this.callbacks.pop();
+        if (cb) {
+            return (0, promise_helpers_1.handleMaybePromise)(cb, () => this._iterateCallbacks(), error => {
+                this._error = this._error ? new SuppressedError(error, this._error) : error;
+                return this._iterateCallbacks();
+            });
+        }
+    }
+    [symbols_js_1.DisposableSymbols.asyncDispose]() {
+        const res$ = this._iterateCallbacks();
+        if (res$?.then) {
+            return res$.then(() => {
+                if (this._error) {
+                    const error = this._error;
+                    this._error = undefined;
+                    throw error;
+                }
+            });
+        }
+        if (this._error) {
+            const error = this._error;
+            this._error = undefined;
+            throw error;
+        }
+        return undefined;
+    }
+    [Symbol.toStringTag] = 'AsyncDisposableStack';
+}
+exports.PonyfillAsyncDisposableStack = PonyfillAsyncDisposableStack;

package/node_modules/@whatwg-node/disposablestack/cjs/DisposableStack.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillDisposableStack = void 0;
+const SupressedError_js_1 = require("./SupressedError.js");
+const symbols_js_1 = require("./symbols.js");
+const utils_js_1 = require("./utils.js");
+const SuppressedError = globalThis.SuppressedError || SupressedError_js_1.PonyfillSuppressedError;
+class PonyfillDisposableStack {
+    callbacks = [];
+    get disposed() {
+        return this.callbacks.length === 0;
+    }
+    use(value) {
+        if ((0, utils_js_1.isSyncDisposable)(value)) {
+            this.callbacks.push(() => value[symbols_js_1.DisposableSymbols.dispose]());
+        }
+        return value;
+    }
+    adopt(value, onDispose) {
+        if (onDispose) {
+            this.callbacks.push(() => onDispose(value));
+        }
+        return value;
+    }
+    defer(onDispose) {
+        if (onDispose) {
+            this.callbacks.push(onDispose);
+        }
+    }
+    move() {
+        const stack = new PonyfillDisposableStack();
+        stack.callbacks = this.callbacks;
+        this.callbacks = [];
+        return stack;
+    }
+    dispose() {
+        return this[symbols_js_1.DisposableSymbols.dispose]();
+    }
+    _error;
+    _iterateCallbacks() {
+        const cb = this.callbacks.pop();
+        if (cb) {
+            try {
+                cb();
+            }
+            catch (error) {
+                this._error = this._error ? new SuppressedError(error, this._error) : error;
+            }
+            return this._iterateCallbacks();
+        }
+    }
+    [symbols_js_1.DisposableSymbols.dispose]() {
+        this._iterateCallbacks();
+        if (this._error) {
+            const error = this._error;
+            this._error = undefined;
+            throw error;
+        }
+    }
+    [Symbol.toStringTag] = 'DisposableStack';
+}
+exports.PonyfillDisposableStack = PonyfillDisposableStack;

package/node_modules/@whatwg-node/disposablestack/cjs/SupressedError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillSuppressedError = void 0;
+class PonyfillSuppressedError extends Error {
+    error;
+    suppressed;
+    // eslint-disable-next-line n/handle-callback-err
+    constructor(error, suppressed, message) {
+        super(message);
+        this.error = error;
+        this.suppressed = suppressed;
+        this.name = 'SuppressedError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.PonyfillSuppressedError = PonyfillSuppressedError;

package/node_modules/@whatwg-node/disposablestack/cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuppressedError = exports.AsyncDisposableStack = exports.DisposableStack = void 0;
+const tslib_1 = require("tslib");
+const AsyncDisposableStack_js_1 = require("./AsyncDisposableStack.js");
+const DisposableStack_js_1 = require("./DisposableStack.js");
+const SupressedError_js_1 = require("./SupressedError.js");
+exports.DisposableStack = globalThis.DisposableStack || DisposableStack_js_1.PonyfillDisposableStack;
+exports.AsyncDisposableStack = globalThis.AsyncDisposableStack || AsyncDisposableStack_js_1.PonyfillAsyncDisposableStack;
+exports.SuppressedError = globalThis.SuppressedError || SupressedError_js_1.PonyfillSuppressedError;
+tslib_1.__exportStar(require("./symbols.js"), exports);

package/node_modules/@whatwg-node/disposablestack/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/node_modules/@whatwg-node/disposablestack/cjs/symbols.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisposableSymbols = void 0;
+exports.patchSymbols = patchSymbols;
+exports.DisposableSymbols = {
+    get dispose() {
+        return Symbol.dispose || Symbol.for('dispose');
+    },
+    get asyncDispose() {
+        return Symbol.asyncDispose || Symbol.for('asyncDispose');
+    },
+};
+function patchSymbols() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - we ponyfill these symbols
+    Symbol.dispose ||= Symbol.for('dispose');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - we ponyfill these symbols
+    Symbol.asyncDispose ||= Symbol.for('asyncDispose');
+}

package/node_modules/@whatwg-node/disposablestack/cjs/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSyncDisposable = isSyncDisposable;
+exports.isAsyncDisposable = isAsyncDisposable;
+const symbols_js_1 = require("./symbols.js");
+function isSyncDisposable(obj) {
+    return obj?.[symbols_js_1.DisposableSymbols.dispose] != null;
+}
+function isAsyncDisposable(obj) {
+    return obj?.[symbols_js_1.DisposableSymbols.asyncDispose] != null;
+}

package/node_modules/@whatwg-node/disposablestack/esm/AsyncDisposableStack.js

@@ -0,0 +1,69 @@
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
+import { PonyfillSuppressedError } from './SupressedError.js';
+import { DisposableSymbols } from './symbols.js';
+import { isAsyncDisposable, isSyncDisposable } from './utils.js';
+const SuppressedError = globalThis.SuppressedError || PonyfillSuppressedError;
+export class PonyfillAsyncDisposableStack {
+    callbacks = [];
+    get disposed() {
+        return this.callbacks.length === 0;
+    }
+    use(value) {
+        if (isAsyncDisposable(value)) {
+            this.callbacks.push(() => value[DisposableSymbols.asyncDispose]());
+        }
+        else if (isSyncDisposable(value)) {
+            this.callbacks.push(() => value[DisposableSymbols.dispose]());
+        }
+        return value;
+    }
+    adopt(value, onDisposeAsync) {
+        if (onDisposeAsync) {
+            this.callbacks.push(() => onDisposeAsync(value));
+        }
+        return value;
+    }
+    defer(onDisposeAsync) {
+        if (onDisposeAsync) {
+            this.callbacks.push(onDisposeAsync);
+        }
+    }
+    move() {
+        const stack = new PonyfillAsyncDisposableStack();
+        stack.callbacks = this.callbacks;
+        this.callbacks = [];
+        return stack;
+    }
+    disposeAsync() {
+        return this[DisposableSymbols.asyncDispose]();
+    }
+    _error;
+    _iterateCallbacks() {
+        const cb = this.callbacks.pop();
+        if (cb) {
+            return handleMaybePromise(cb, () => this._iterateCallbacks(), error => {
+                this._error = this._error ? new SuppressedError(error, this._error) : error;
+                return this._iterateCallbacks();
+            });
+        }
+    }
+    [DisposableSymbols.asyncDispose]() {
+        const res$ = this._iterateCallbacks();
+        if (res$?.then) {
+            return res$.then(() => {
+                if (this._error) {
+                    const error = this._error;
+                    this._error = undefined;
+                    throw error;
+                }
+            });
+        }
+        if (this._error) {
+            const error = this._error;
+            this._error = undefined;
+            throw error;
+        }
+        return undefined;
+    }
+    [Symbol.toStringTag] = 'AsyncDisposableStack';
+}

package/node_modules/@whatwg-node/disposablestack/esm/DisposableStack.js

@@ -0,0 +1,58 @@
+import { PonyfillSuppressedError } from './SupressedError.js';
+import { DisposableSymbols } from './symbols.js';
+import { isSyncDisposable } from './utils.js';
+const SuppressedError = globalThis.SuppressedError || PonyfillSuppressedError;
+export class PonyfillDisposableStack {
+    callbacks = [];
+    get disposed() {
+        return this.callbacks.length === 0;
+    }
+    use(value) {
+        if (isSyncDisposable(value)) {
+            this.callbacks.push(() => value[DisposableSymbols.dispose]());
+        }
+        return value;
+    }
+    adopt(value, onDispose) {
+        if (onDispose) {
+            this.callbacks.push(() => onDispose(value));
+        }
+        return value;
+    }
+    defer(onDispose) {
+        if (onDispose) {
+            this.callbacks.push(onDispose);
+        }
+    }
+    move() {
+        const stack = new PonyfillDisposableStack();
+        stack.callbacks = this.callbacks;
+        this.callbacks = [];
+        return stack;
+    }
+    dispose() {
+        return this[DisposableSymbols.dispose]();
+    }
+    _error;
+    _iterateCallbacks() {
+        const cb = this.callbacks.pop();
+        if (cb) {
+            try {
+                cb();
+            }
+            catch (error) {
+                this._error = this._error ? new SuppressedError(error, this._error) : error;
+            }
+            return this._iterateCallbacks();
+        }
+    }
+    [DisposableSymbols.dispose]() {
+        this._iterateCallbacks();
+        if (this._error) {
+            const error = this._error;
+            this._error = undefined;
+            throw error;
+        }
+    }
+    [Symbol.toStringTag] = 'DisposableStack';
+}

package/node_modules/@whatwg-node/disposablestack/esm/SupressedError.js

@@ -0,0 +1,12 @@
+export class PonyfillSuppressedError extends Error {
+    error;
+    suppressed;
+    // eslint-disable-next-line n/handle-callback-err
+    constructor(error, suppressed, message) {
+        super(message);
+        this.error = error;
+        this.suppressed = suppressed;
+        this.name = 'SuppressedError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/node_modules/@whatwg-node/disposablestack/esm/index.js

@@ -0,0 +1,7 @@
+import { PonyfillAsyncDisposableStack } from './AsyncDisposableStack.js';
+import { PonyfillDisposableStack } from './DisposableStack.js';
+import { PonyfillSuppressedError } from './SupressedError.js';
+export const DisposableStack = globalThis.DisposableStack || PonyfillDisposableStack;
+export const AsyncDisposableStack = globalThis.AsyncDisposableStack || PonyfillAsyncDisposableStack;
+export const SuppressedError = globalThis.SuppressedError || PonyfillSuppressedError;
+export * from './symbols.js';

package/node_modules/@whatwg-node/disposablestack/esm/symbols.js

@@ -0,0 +1,16 @@
+export const DisposableSymbols = {
+    get dispose() {
+        return Symbol.dispose || Symbol.for('dispose');
+    },
+    get asyncDispose() {
+        return Symbol.asyncDispose || Symbol.for('asyncDispose');
+    },
+};
+export function patchSymbols() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - we ponyfill these symbols
+    Symbol.dispose ||= Symbol.for('dispose');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - we ponyfill these symbols
+    Symbol.asyncDispose ||= Symbol.for('asyncDispose');
+}

package/node_modules/@whatwg-node/disposablestack/esm/utils.js

@@ -0,0 +1,7 @@
+import { DisposableSymbols } from './symbols.js';
+export function isSyncDisposable(obj) {
+    return obj?.[DisposableSymbols.dispose] != null;
+}
+export function isAsyncDisposable(obj) {
+    return obj?.[DisposableSymbols.asyncDispose] != null;
+}

package/node_modules/@whatwg-node/disposablestack/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@whatwg-node/disposablestack",
+  "version": "0.0.6",
+  "description": "Cross Platform Smart DisposableStack API Ponyfill",
+  "sideEffects": false,
+  "dependencies": {
+    "@whatwg-node/promise-helpers": "^1.0.0",
+    "tslib": "^2.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/disposablestack"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/node_modules/@whatwg-node/disposablestack/typings/AsyncDisposableStack.d.cts

@@ -0,0 +1,15 @@
+import { type MaybePromiseLike } from '@whatwg-node/promise-helpers';
+import { DisposableSymbols } from './symbols.cjs';
+export declare class PonyfillAsyncDisposableStack implements AsyncDisposableStack {
+    private callbacks;
+    get disposed(): boolean;
+    use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDisposeAsync: (value: T) => MaybePromiseLike<void>): T;
+    defer(onDisposeAsync: () => MaybePromiseLike<void>): void;
+    move(): AsyncDisposableStack;
+    disposeAsync(): Promise<void>;
+    private _error?;
+    private _iterateCallbacks;
+    [DisposableSymbols.asyncDispose](): Promise<void>;
+    readonly [Symbol.toStringTag]: string;
+}

package/node_modules/@whatwg-node/disposablestack/typings/AsyncDisposableStack.d.ts

@@ -0,0 +1,15 @@
+import { type MaybePromiseLike } from '@whatwg-node/promise-helpers';
+import { DisposableSymbols } from './symbols.js';
+export declare class PonyfillAsyncDisposableStack implements AsyncDisposableStack {
+    private callbacks;
+    get disposed(): boolean;
+    use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDisposeAsync: (value: T) => MaybePromiseLike<void>): T;
+    defer(onDisposeAsync: () => MaybePromiseLike<void>): void;
+    move(): AsyncDisposableStack;
+    disposeAsync(): Promise<void>;
+    private _error?;
+    private _iterateCallbacks;
+    [DisposableSymbols.asyncDispose](): Promise<void>;
+    readonly [Symbol.toStringTag]: string;
+}

package/node_modules/@whatwg-node/disposablestack/typings/DisposableStack.d.cts

@@ -0,0 +1,14 @@
+import { DisposableSymbols } from './symbols.cjs';
+export declare class PonyfillDisposableStack implements DisposableStack {
+    private callbacks;
+    get disposed(): boolean;
+    use<T extends Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDispose: (value: T) => void): T;
+    defer(onDispose: () => void): void;
+    move(): DisposableStack;
+    dispose(): void;
+    private _error?;
+    private _iterateCallbacks;
+    [DisposableSymbols.dispose](): void;
+    readonly [Symbol.toStringTag]: string;
+}

package/node_modules/@whatwg-node/disposablestack/typings/DisposableStack.d.ts

@@ -0,0 +1,14 @@
+import { DisposableSymbols } from './symbols.js';
+export declare class PonyfillDisposableStack implements DisposableStack {
+    private callbacks;
+    get disposed(): boolean;
+    use<T extends Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDispose: (value: T) => void): T;
+    defer(onDispose: () => void): void;
+    move(): DisposableStack;
+    dispose(): void;
+    private _error?;
+    private _iterateCallbacks;
+    [DisposableSymbols.dispose](): void;
+    readonly [Symbol.toStringTag]: string;
+}

package/node_modules/@whatwg-node/disposablestack/typings/SupressedError.d.cts

@@ -0,0 +1,5 @@
+export declare class PonyfillSuppressedError extends Error implements SuppressedError {
+    error: any;
+    suppressed: any;
+    constructor(error: any, suppressed: any, message?: string);
+}

package/node_modules/@whatwg-node/disposablestack/typings/SupressedError.d.ts

@@ -0,0 +1,5 @@
+export declare class PonyfillSuppressedError extends Error implements SuppressedError {
+    error: any;
+    suppressed: any;
+    constructor(error: any, suppressed: any, message?: string);
+}

package/node_modules/@whatwg-node/disposablestack/typings/index.d.cts

@@ -0,0 +1,4 @@
+export declare const DisposableStack: DisposableStackConstructor;
+export declare const AsyncDisposableStack: AsyncDisposableStackConstructor;
+export declare const SuppressedError: SuppressedErrorConstructor;
+export * from './symbols.cjs';

package/node_modules/@whatwg-node/disposablestack/typings/index.d.ts

@@ -0,0 +1,4 @@
+export declare const DisposableStack: DisposableStackConstructor;
+export declare const AsyncDisposableStack: AsyncDisposableStackConstructor;
+export declare const SuppressedError: SuppressedErrorConstructor;
+export * from './symbols.js';

package/node_modules/@whatwg-node/disposablestack/typings/symbols.d.cts

@@ -0,0 +1,5 @@
+export declare const DisposableSymbols: {
+    readonly dispose: typeof Symbol.dispose;
+    readonly asyncDispose: typeof Symbol.asyncDispose;
+};
+export declare function patchSymbols(): void;

package/node_modules/@whatwg-node/disposablestack/typings/symbols.d.ts

@@ -0,0 +1,5 @@
+export declare const DisposableSymbols: {
+    readonly dispose: typeof Symbol.dispose;
+    readonly asyncDispose: typeof Symbol.asyncDispose;
+};
+export declare function patchSymbols(): void;

package/node_modules/@whatwg-node/disposablestack/typings/utils.d.cts

@@ -0,0 +1,2 @@
+export declare function isSyncDisposable(obj: any): obj is Disposable;
+export declare function isAsyncDisposable(obj: any): obj is AsyncDisposable;

package/node_modules/@whatwg-node/disposablestack/typings/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isSyncDisposable(obj: any): obj is Disposable;
+export declare function isAsyncDisposable(obj: any): obj is AsyncDisposable;