@comapeo/map-server 1.0.0-pre.0

package/node_modules/@whatwg-node/promise-helpers/cjs/index.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = isPromise;
+exports.isActualPromise = isActualPromise;
+exports.handleMaybePromise = handleMaybePromise;
+exports.fakePromise = fakePromise;
+exports.createDeferredPromise = createDeferredPromise;
+exports.iterateAsync = iterateAsync;
+exports.iterateAsyncVoid = iterateAsync;
+exports.fakeRejectPromise = fakeRejectPromise;
+exports.mapMaybePromise = mapMaybePromise;
+exports.mapAsyncIterator = mapAsyncIterator;
+exports.promiseLikeFinally = promiseLikeFinally;
+exports.unfakePromise = unfakePromise;
+const kFakePromise = Symbol.for('@whatwg-node/promise-helpers/FakePromise');
+function isPromise(value) {
+    return value?.then != null;
+}
+function isActualPromise(value) {
+    const maybePromise = value;
+    return maybePromise && maybePromise.then && maybePromise.catch && maybePromise.finally;
+}
+function handleMaybePromise(inputFactory, outputSuccessFactory, outputErrorFactory, finallyFactory) {
+    let result$ = fakePromise().then(inputFactory).then(outputSuccessFactory, outputErrorFactory);
+    if (finallyFactory) {
+        result$ = result$.finally(finallyFactory);
+    }
+    return unfakePromise(result$);
+}
+function fakePromise(value) {
+    if (value && isActualPromise(value)) {
+        return value;
+    }
+    if (isPromise(value)) {
+        return {
+            then: (resolve, reject) => fakePromise(value.then(resolve, reject)),
+            catch: reject => fakePromise(value.then(res => res, reject)),
+            finally: cb => fakePromise(cb ? promiseLikeFinally(value, cb) : value),
+            [Symbol.toStringTag]: 'Promise',
+        };
+    }
+    // Write a fake promise to avoid the promise constructor
+    // being called with `new Promise` in the browser.
+    return {
+        then(resolve) {
+            if (resolve) {
+                try {
+                    return fakePromise(resolve(value));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                try {
+                    return fakePromise(cb()).then(() => value, () => value);
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+        __fakePromiseValue: value,
+        [kFakePromise]: 'resolved',
+    };
+}
+function createDeferredPromise() {
+    if (Promise.withResolvers) {
+        return Promise.withResolvers();
+    }
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise(function deferredPromiseExecutor(resolve, reject) {
+        resolveFn = resolve;
+        rejectFn = reject;
+    });
+    return {
+        promise,
+        get resolve() {
+            return resolveFn;
+        },
+        get reject() {
+            return rejectFn;
+        },
+    };
+}
+function iterateAsync(iterable, callback, results) {
+    if (iterable?.length === 0) {
+        return;
+    }
+    const iterator = iterable[Symbol.iterator]();
+    let index = 0;
+    function iterate() {
+        const { done: endOfIterator, value } = iterator.next();
+        if (endOfIterator) {
+            return;
+        }
+        let endedEarly = false;
+        function endEarly() {
+            endedEarly = true;
+        }
+        return handleMaybePromise(function handleCallback() {
+            return callback(value, endEarly, index++);
+        }, function handleCallbackResult(result) {
+            if (result) {
+                results?.push(result);
+            }
+            if (endedEarly) {
+                return;
+            }
+            return iterate();
+        });
+    }
+    return iterate();
+}
+function fakeRejectPromise(error) {
+    return {
+        then(_resolve, reject) {
+            if (reject) {
+                try {
+                    return fakePromise(reject(error));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        catch(reject) {
+            if (reject) {
+                try {
+                    return fakePromise(reject(error));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                try {
+                    cb();
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        __fakeRejectError: error,
+        [Symbol.toStringTag]: 'Promise',
+        [kFakePromise]: 'rejected',
+    };
+}
+function mapMaybePromise(input, onSuccess, onError) {
+    return handleMaybePromise(() => input, onSuccess, onError);
+}
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+function mapAsyncIterator(iterator, onNext, onError, onEnd) {
+    if (Symbol.asyncIterator in iterator) {
+        iterator = iterator[Symbol.asyncIterator]();
+    }
+    let $return;
+    let abruptClose;
+    let onEndWithValue;
+    if (onEnd) {
+        let onEndWithValueResult /** R in onEndWithValue */;
+        onEndWithValue = value => {
+            onEndWithValueResult ||= handleMaybePromise(onEnd, () => value, () => value);
+            return onEndWithValueResult;
+        };
+    }
+    if (typeof iterator.return === 'function') {
+        $return = iterator.return;
+        abruptClose = (error) => {
+            const rethrow = () => {
+                throw error;
+            };
+            return $return.call(iterator).then(rethrow, rethrow);
+        };
+    }
+    function mapResult(result) {
+        if (result.done) {
+            return onEndWithValue ? onEndWithValue(result) : result;
+        }
+        return handleMaybePromise(() => result.value, value => handleMaybePromise(() => onNext(value), iteratorResult, abruptClose));
+    }
+    let mapReject;
+    if (onError) {
+        let onErrorResult;
+        // Capture rejectCallback to ensure it cannot be null.
+        const reject = onError;
+        mapReject = (error) => {
+            onErrorResult ||= handleMaybePromise(() => error, error => handleMaybePromise(() => reject(error), iteratorResult, abruptClose));
+            return onErrorResult;
+        };
+    }
+    return {
+        next() {
+            return iterator.next().then(mapResult, mapReject);
+        },
+        return() {
+            const res$ = $return
+                ? $return.call(iterator).then(mapResult, mapReject)
+                : fakePromise({ value: undefined, done: true });
+            return onEndWithValue ? res$.then(onEndWithValue) : res$;
+        },
+        throw(error) {
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(error).then(mapResult, mapReject);
+            }
+            if (abruptClose) {
+                return abruptClose(error);
+            }
+            return fakeRejectPromise(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+function iteratorResult(value) {
+    return { value, done: false };
+}
+function isFakePromise(value) {
+    return value?.[kFakePromise] === 'resolved';
+}
+function isFakeRejectPromise(value) {
+    return value?.[kFakePromise] === 'rejected';
+}
+function promiseLikeFinally(value, onFinally) {
+    if ('finally' in value) {
+        return value.finally(onFinally);
+    }
+    return value.then(res => {
+        const finallyRes = onFinally();
+        return isPromise(finallyRes) ? finallyRes.then(() => res) : res;
+    }, err => {
+        const finallyRes = onFinally();
+        if (isPromise(finallyRes)) {
+            return finallyRes.then(() => {
+                throw err;
+            });
+        }
+        else {
+            throw err;
+        }
+    });
+}
+function unfakePromise(promise) {
+    if (isFakePromise(promise)) {
+        return promise.__fakePromiseValue;
+    }
+    if (isFakeRejectPromise(promise)) {
+        throw promise.__fakeRejectError;
+    }
+    return promise;
+}

package/node_modules/@whatwg-node/promise-helpers/cjs/package.json

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

package/node_modules/@whatwg-node/promise-helpers/esm/index.js

@@ -0,0 +1,257 @@
+const kFakePromise = Symbol.for('@whatwg-node/promise-helpers/FakePromise');
+export function isPromise(value) {
+    return value?.then != null;
+}
+export function isActualPromise(value) {
+    const maybePromise = value;
+    return maybePromise && maybePromise.then && maybePromise.catch && maybePromise.finally;
+}
+export function handleMaybePromise(inputFactory, outputSuccessFactory, outputErrorFactory, finallyFactory) {
+    let result$ = fakePromise().then(inputFactory).then(outputSuccessFactory, outputErrorFactory);
+    if (finallyFactory) {
+        result$ = result$.finally(finallyFactory);
+    }
+    return unfakePromise(result$);
+}
+export function fakePromise(value) {
+    if (value && isActualPromise(value)) {
+        return value;
+    }
+    if (isPromise(value)) {
+        return {
+            then: (resolve, reject) => fakePromise(value.then(resolve, reject)),
+            catch: reject => fakePromise(value.then(res => res, reject)),
+            finally: cb => fakePromise(cb ? promiseLikeFinally(value, cb) : value),
+            [Symbol.toStringTag]: 'Promise',
+        };
+    }
+    // Write a fake promise to avoid the promise constructor
+    // being called with `new Promise` in the browser.
+    return {
+        then(resolve) {
+            if (resolve) {
+                try {
+                    return fakePromise(resolve(value));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                try {
+                    return fakePromise(cb()).then(() => value, () => value);
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+        __fakePromiseValue: value,
+        [kFakePromise]: 'resolved',
+    };
+}
+export function createDeferredPromise() {
+    if (Promise.withResolvers) {
+        return Promise.withResolvers();
+    }
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise(function deferredPromiseExecutor(resolve, reject) {
+        resolveFn = resolve;
+        rejectFn = reject;
+    });
+    return {
+        promise,
+        get resolve() {
+            return resolveFn;
+        },
+        get reject() {
+            return rejectFn;
+        },
+    };
+}
+export { iterateAsync as iterateAsyncVoid };
+export function iterateAsync(iterable, callback, results) {
+    if (iterable?.length === 0) {
+        return;
+    }
+    const iterator = iterable[Symbol.iterator]();
+    let index = 0;
+    function iterate() {
+        const { done: endOfIterator, value } = iterator.next();
+        if (endOfIterator) {
+            return;
+        }
+        let endedEarly = false;
+        function endEarly() {
+            endedEarly = true;
+        }
+        return handleMaybePromise(function handleCallback() {
+            return callback(value, endEarly, index++);
+        }, function handleCallbackResult(result) {
+            if (result) {
+                results?.push(result);
+            }
+            if (endedEarly) {
+                return;
+            }
+            return iterate();
+        });
+    }
+    return iterate();
+}
+export function fakeRejectPromise(error) {
+    return {
+        then(_resolve, reject) {
+            if (reject) {
+                try {
+                    return fakePromise(reject(error));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        catch(reject) {
+            if (reject) {
+                try {
+                    return fakePromise(reject(error));
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                try {
+                    cb();
+                }
+                catch (err) {
+                    return fakeRejectPromise(err);
+                }
+            }
+            return this;
+        },
+        __fakeRejectError: error,
+        [Symbol.toStringTag]: 'Promise',
+        [kFakePromise]: 'rejected',
+    };
+}
+export function mapMaybePromise(input, onSuccess, onError) {
+    return handleMaybePromise(() => input, onSuccess, onError);
+}
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+export function mapAsyncIterator(iterator, onNext, onError, onEnd) {
+    if (Symbol.asyncIterator in iterator) {
+        iterator = iterator[Symbol.asyncIterator]();
+    }
+    let $return;
+    let abruptClose;
+    let onEndWithValue;
+    if (onEnd) {
+        let onEndWithValueResult /** R in onEndWithValue */;
+        onEndWithValue = value => {
+            onEndWithValueResult ||= handleMaybePromise(onEnd, () => value, () => value);
+            return onEndWithValueResult;
+        };
+    }
+    if (typeof iterator.return === 'function') {
+        $return = iterator.return;
+        abruptClose = (error) => {
+            const rethrow = () => {
+                throw error;
+            };
+            return $return.call(iterator).then(rethrow, rethrow);
+        };
+    }
+    function mapResult(result) {
+        if (result.done) {
+            return onEndWithValue ? onEndWithValue(result) : result;
+        }
+        return handleMaybePromise(() => result.value, value => handleMaybePromise(() => onNext(value), iteratorResult, abruptClose));
+    }
+    let mapReject;
+    if (onError) {
+        let onErrorResult;
+        // Capture rejectCallback to ensure it cannot be null.
+        const reject = onError;
+        mapReject = (error) => {
+            onErrorResult ||= handleMaybePromise(() => error, error => handleMaybePromise(() => reject(error), iteratorResult, abruptClose));
+            return onErrorResult;
+        };
+    }
+    return {
+        next() {
+            return iterator.next().then(mapResult, mapReject);
+        },
+        return() {
+            const res$ = $return
+                ? $return.call(iterator).then(mapResult, mapReject)
+                : fakePromise({ value: undefined, done: true });
+            return onEndWithValue ? res$.then(onEndWithValue) : res$;
+        },
+        throw(error) {
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(error).then(mapResult, mapReject);
+            }
+            if (abruptClose) {
+                return abruptClose(error);
+            }
+            return fakeRejectPromise(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+function iteratorResult(value) {
+    return { value, done: false };
+}
+function isFakePromise(value) {
+    return value?.[kFakePromise] === 'resolved';
+}
+function isFakeRejectPromise(value) {
+    return value?.[kFakePromise] === 'rejected';
+}
+export function promiseLikeFinally(value, onFinally) {
+    if ('finally' in value) {
+        return value.finally(onFinally);
+    }
+    return value.then(res => {
+        const finallyRes = onFinally();
+        return isPromise(finallyRes) ? finallyRes.then(() => res) : res;
+    }, err => {
+        const finallyRes = onFinally();
+        if (isPromise(finallyRes)) {
+            return finallyRes.then(() => {
+                throw err;
+            });
+        }
+        else {
+            throw err;
+        }
+    });
+}
+export function unfakePromise(promise) {
+    if (isFakePromise(promise)) {
+        return promise.__fakePromiseValue;
+    }
+    if (isFakeRejectPromise(promise)) {
+        throw promise.__fakeRejectError;
+    }
+    return promise;
+}

package/node_modules/@whatwg-node/promise-helpers/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@whatwg-node/promise-helpers",
+  "version": "1.3.2",
+  "description": "Promise helpers",
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/promise-helpers"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.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/promise-helpers/typings/index.d.cts

@@ -0,0 +1,31 @@
+export type MaybePromise<T> = Promise<T> | T;
+export type MaybePromiseLike<T> = PromiseLike<T> | T;
+export declare function isPromise<T>(value: MaybePromise<T>): value is Promise<T>;
+export declare function isPromise<T>(value: MaybePromiseLike<T>): value is PromiseLike<T>;
+export declare function isActualPromise<T>(value: MaybePromiseLike<T>): value is Promise<T>;
+export declare function handleMaybePromise<TInput, TOutput>(inputFactory: () => MaybePromise<TInput>, outputSuccessFactory: (value: TInput) => MaybePromise<TOutput>, outputErrorFactory?: (err: any) => MaybePromise<TOutput>, finallyFactory?: () => MaybePromise<void>): MaybePromise<TOutput>;
+export declare function handleMaybePromise<TInput, TOutput>(inputFactory: () => MaybePromiseLike<TInput>, outputSuccessFactory: (value: TInput) => MaybePromiseLike<TOutput>, outputErrorFactory?: (err: any) => MaybePromiseLike<TOutput>, finallyFactory?: () => MaybePromiseLike<void>): MaybePromiseLike<TOutput>;
+export declare function fakePromise<T>(value: MaybePromise<T>): Promise<T>;
+export declare function fakePromise<T>(value: MaybePromiseLike<T>): Promise<T>;
+export declare function fakePromise(value: void): Promise<void>;
+export interface DeferredPromise<T = void> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+}
+export declare function createDeferredPromise<T = void>(): DeferredPromise<T>;
+export { iterateAsync as iterateAsyncVoid };
+export declare function iterateAsync<TInput, TOutput>(iterable: Iterable<TInput>, callback: (input: TInput, endEarly: () => void, index: number) => MaybePromise<TOutput | undefined | null | void>, results?: TOutput[]): MaybePromise<void>;
+export declare function fakeRejectPromise<T>(error: unknown): Promise<T>;
+/**
+ * @deprecated Use `handleMaybePromise` instead.
+ */
+export declare function mapMaybePromise<TInput, TOutput>(input: MaybePromise<TInput>, onSuccess: (value: TInput) => MaybePromise<TOutput>, onError?: (err: any) => MaybePromise<TOutput>): MaybePromise<TOutput>;
+export declare function mapMaybePromise<TInput, TOutput>(input: MaybePromiseLike<TInput>, onSuccess: (value: TInput) => MaybePromiseLike<TOutput>, onError?: (err: any) => MaybePromiseLike<TOutput>): MaybePromiseLike<TOutput>;
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+export declare function mapAsyncIterator<T, U>(iterator: AsyncIterable<T> | AsyncIterator<T>, onNext: (value: T) => MaybePromise<U>, onError?: any, onEnd?: () => MaybePromise<void>): AsyncIterableIterator<U>;
+export declare function promiseLikeFinally<T>(value: PromiseLike<T> | Promise<T>, onFinally: () => MaybePromiseLike<void>): PromiseLike<T>;
+export declare function unfakePromise<T>(promise: Promise<T>): MaybePromise<T>;

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

@@ -0,0 +1,31 @@
+export type MaybePromise<T> = Promise<T> | T;
+export type MaybePromiseLike<T> = PromiseLike<T> | T;
+export declare function isPromise<T>(value: MaybePromise<T>): value is Promise<T>;
+export declare function isPromise<T>(value: MaybePromiseLike<T>): value is PromiseLike<T>;
+export declare function isActualPromise<T>(value: MaybePromiseLike<T>): value is Promise<T>;
+export declare function handleMaybePromise<TInput, TOutput>(inputFactory: () => MaybePromise<TInput>, outputSuccessFactory: (value: TInput) => MaybePromise<TOutput>, outputErrorFactory?: (err: any) => MaybePromise<TOutput>, finallyFactory?: () => MaybePromise<void>): MaybePromise<TOutput>;
+export declare function handleMaybePromise<TInput, TOutput>(inputFactory: () => MaybePromiseLike<TInput>, outputSuccessFactory: (value: TInput) => MaybePromiseLike<TOutput>, outputErrorFactory?: (err: any) => MaybePromiseLike<TOutput>, finallyFactory?: () => MaybePromiseLike<void>): MaybePromiseLike<TOutput>;
+export declare function fakePromise<T>(value: MaybePromise<T>): Promise<T>;
+export declare function fakePromise<T>(value: MaybePromiseLike<T>): Promise<T>;
+export declare function fakePromise(value: void): Promise<void>;
+export interface DeferredPromise<T = void> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+}
+export declare function createDeferredPromise<T = void>(): DeferredPromise<T>;
+export { iterateAsync as iterateAsyncVoid };
+export declare function iterateAsync<TInput, TOutput>(iterable: Iterable<TInput>, callback: (input: TInput, endEarly: () => void, index: number) => MaybePromise<TOutput | undefined | null | void>, results?: TOutput[]): MaybePromise<void>;
+export declare function fakeRejectPromise<T>(error: unknown): Promise<T>;
+/**
+ * @deprecated Use `handleMaybePromise` instead.
+ */
+export declare function mapMaybePromise<TInput, TOutput>(input: MaybePromise<TInput>, onSuccess: (value: TInput) => MaybePromise<TOutput>, onError?: (err: any) => MaybePromise<TOutput>): MaybePromise<TOutput>;
+export declare function mapMaybePromise<TInput, TOutput>(input: MaybePromiseLike<TInput>, onSuccess: (value: TInput) => MaybePromiseLike<TOutput>, onError?: (err: any) => MaybePromiseLike<TOutput>): MaybePromiseLike<TOutput>;
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+export declare function mapAsyncIterator<T, U>(iterator: AsyncIterable<T> | AsyncIterator<T>, onNext: (value: T) => MaybePromise<U>, onError?: any, onEnd?: () => MaybePromise<void>): AsyncIterableIterator<U>;
+export declare function promiseLikeFinally<T>(value: PromiseLike<T> | Promise<T>, onFinally: () => MaybePromiseLike<void>): PromiseLike<T>;
+export declare function unfakePromise<T>(promise: Promise<T>): MaybePromise<T>;