@trpc/server 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

package/dist/vendor/unpromise/unpromise.mjs

@@ -1,289 +1,243 @@
-/* eslint-disable @typescript-eslint/unbound-method */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-var _computedKey;
+//#region src/vendor/unpromise/unpromise.ts
 /** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
- * which is retained for the lifetime of the original Promise.
- */ const subscribableCache = new WeakMap();
+* which is retained for the lifetime of the original Promise.
+*/
+const subscribableCache = new WeakMap();
 /** A NOOP function allowing a consistent interface for settled
- * SubscribedPromises (settled promises are not subscribed - they resolve
- * immediately). */ const NOOP = ()=>{
-// noop
-};
-_computedKey = Symbol.toStringTag;
-let _computedKey1 = _computedKey;
+* SubscribedPromises (settled promises are not subscribed - they resolve
+* immediately). */
+const NOOP = () => {};
 /**
- * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
- * created once, cached and reused throughout the lifetime of the Promise. Get a
- * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
- *
- * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
- * `.then()` and `.catch()` just once. Promises derived from it use a
- * subscription- (and unsubscription-) based mechanism that monitors these
- * handlers.
- *
- * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
- * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
- * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
- * from the original, potentially long-lived Promise, eliminating memory leaks.
- *
- * This approach can eliminate the memory leaks that otherwise come about from
- * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
- * times on the same long-lived native Promise (subscriptions which can never be
- * cleaned up).
- *
- * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
- * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
- * the scenes, `resolve` is implemented simply as
- * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
- * to tidy up!
- *
- */ class Unpromise {
-    /** Create a promise that mitigates uncontrolled subscription to a long-lived
-   * Promise via .then() and .catch() - otherwise a source of memory leaks.
-   *
-   * The returned promise has an `unsubscribe()` method which can be called when
-   * the Promise is no longer being tracked by application logic, and which
-   * ensures that there is no reference chain from the original promise to the
-   * new one, and therefore no memory leak.
-   *
-   * If original promise has not yet settled, this adds a new unique promise
-   * that listens to then/catch events, along with an `unsubscribe()` method to
-   * detach it.
-   *
-   * If original promise has settled, then creates a new Promise.resolve() or
-   * Promise.reject() and provided unsubscribe is a noop.
-   *
-   * If you call `unsubscribe()` before the returned Promise has settled, it
-   * will never settle.
-   */ subscribe() {
-        // in all cases we will combine some promise with its unsubscribe function
-        let promise;
-        let unsubscribe;
-        const { settlement } = this;
-        if (settlement === null) {
-            // not yet settled - subscribe new promise. Expect eventual settlement
-            if (this.subscribers === null) {
-                // invariant - it is not settled, so it must have subscribers
-                throw new Error("Unpromise settled but still has subscribers");
-            }
-            const subscriber = withResolvers();
-            this.subscribers = listWithMember(this.subscribers, subscriber);
-            promise = subscriber.promise;
-            unsubscribe = ()=>{
-                if (this.subscribers !== null) {
-                    this.subscribers = listWithoutMember(this.subscribers, subscriber);
-                }
-            };
-        } else {
-            // settled - don't create subscribed promise. Just resolve or reject
-            const { status } = settlement;
-            if (status === "fulfilled") {
-                promise = Promise.resolve(settlement.value);
-            } else {
-                promise = Promise.reject(settlement.reason);
-            }
-            unsubscribe = NOOP;
-        }
-        // extend promise signature with the extra method
-        return Object.assign(promise, {
-            unsubscribe
-        });
-    }
-    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */ then(onfulfilled, onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.then(onfulfilled, onrejected), {
-            unsubscribe
-        });
-    }
-    catch(onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.catch(onrejected), {
-            unsubscribe
-        });
-    }
-    finally(onfinally) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.finally(onfinally), {
-            unsubscribe
-        });
-    }
-    /** Unpromise STATIC METHODS */ /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
-   * of the provided Promise reference) */ static proxy(promise) {
-        const cached = Unpromise.getSubscribablePromise(promise);
-        return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
-    }
-    /** Create and store an Unpromise keyed by an original Promise. */ static createSubscribablePromise(promise) {
-        const created = new Unpromise(promise);
-        subscribableCache.set(promise, created); // resolve promise to unpromise
-        subscribableCache.set(created, created); // resolve the unpromise to itself
-        return created;
-    }
-    /** Retrieve a previously-created Unpromise keyed by an original Promise. */ static getSubscribablePromise(promise) {
-        return subscribableCache.get(promise);
-    }
-    /** Promise STATIC METHODS */ /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
-   * it (that can be later unsubscribed to eliminate Memory leaks) */ static resolve(value) {
-        const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
-        return Unpromise.proxy(promise).subscribe();
-    }
-    static async any(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.any(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    static async race(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.race(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    /** Create a race of SubscribedPromises that will fulfil to a single winning
-   * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
-   * accumulating .then() and .catch() subscribers. Allows simple logic to
-   * consume the result, like...
-   * ```ts
-   * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
-   * if(winner === promiseB){
-   *   const result = await promiseB;
-   *   // do the thing
-   * }
-   * ```
-   * */ static async raceReferences(promises) {
-        // map each promise to an eventual 1-tuple containing itself
-        const selfPromises = promises.map(resolveSelfTuple);
-        // now race them. They will fulfil to a readonly [P] or reject.
-        try {
-            return await Promise.race(selfPromises);
-        } finally{
-            for (const promise of selfPromises){
-                // unsubscribe proxy promises when the race is over to mitigate memory leaks
-                promise.unsubscribe();
-            }
-        }
-    }
-    constructor(arg){
-        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property(this, "promise", void 0);
-        /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-   * after the original promise settles - no further notifications will be issued. */ _define_property(this, "subscribers", []);
-        /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
-   * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-   * can be returned, and therefore subscription can be bypassed. */ _define_property(this, "settlement", null);
-        /** TOSTRING SUPPORT */ _define_property(this, _computedKey1, "Unpromise");
-        // handle either a Promise or a Promise executor function
-        if (typeof arg === "function") {
-            this.promise = new Promise(arg);
-        } else {
-            this.promise = arg;
-        }
-        // subscribe for eventual fulfilment and rejection
-        // handle PromiseLike objects (that at least have .then)
-        const thenReturn = this.promise.then((value)=>{
-            // atomically record fulfilment and detach subscriber list
-            const { subscribers } = this;
-            this.subscribers = null;
-            this.settlement = {
-                status: "fulfilled",
-                value
-            };
-            // notify fulfilment to subscriber list
-            subscribers?.forEach(({ resolve })=>{
-                resolve(value);
-            });
-        });
-        // handle Promise (that also have a .catch behaviour)
-        if ("catch" in thenReturn) {
-            thenReturn.catch((reason)=>{
-                // atomically record rejection and detach subscriber list
-                const { subscribers } = this;
-                this.subscribers = null;
-                this.settlement = {
-                    status: "rejected",
-                    reason
-                };
-                // notify rejection to subscriber list
-                subscribers?.forEach(({ reject })=>{
-                    reject(reason);
-                });
-            });
-        }
-    }
-}
+* Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
+* created once, cached and reused throughout the lifetime of the Promise. Get a
+* Promise's ProxyPromise using `Unpromise.proxy(promise)`.
+*
+* The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
+* `.then()` and `.catch()` just once. Promises derived from it use a
+* subscription- (and unsubscription-) based mechanism that monitors these
+* handlers.
+*
+* Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
+* `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
+* `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
+* from the original, potentially long-lived Promise, eliminating memory leaks.
+*
+* This approach can eliminate the memory leaks that otherwise come about from
+* repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
+* times on the same long-lived native Promise (subscriptions which can never be
+* cleaned up).
+*
+* `Unpromise.race(promises)` is a reference implementation of `Promise.race`
+* avoiding memory leaks when using long-lived unsettled Promises.
+*
+* `Unpromise.any(promises)` is a reference implementation of `Promise.any`
+* avoiding memory leaks when using long-lived unsettled Promises.
+*
+* `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
+* any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
+* the scenes, `resolve` is implemented simply as
+* `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
+* to tidy up!
+*
+*/
+var Unpromise = class Unpromise {
+	/** INSTANCE IMPLEMENTATION */
+	/** The promise shadowed by this Unpromise<T>  */
+	promise;
+	/** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
+	* after the original promise settles - no further notifications will be issued. */
+	subscribers = [];
+	/** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
+	* calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
+	* can be returned, and therefore subscription can be bypassed. */
+	settlement = null;
+	constructor(arg) {
+		if (typeof arg === "function") this.promise = new Promise(arg);
+		else this.promise = arg;
+		const thenReturn = this.promise.then((value) => {
+			const { subscribers } = this;
+			this.subscribers = null;
+			this.settlement = {
+				status: "fulfilled",
+				value
+			};
+			subscribers?.forEach(({ resolve }) => {
+				resolve(value);
+			});
+		});
+		if ("catch" in thenReturn) thenReturn.catch((reason) => {
+			const { subscribers } = this;
+			this.subscribers = null;
+			this.settlement = {
+				status: "rejected",
+				reason
+			};
+			subscribers?.forEach(({ reject }) => {
+				reject(reason);
+			});
+		});
+	}
+	/** Create a promise that mitigates uncontrolled subscription to a long-lived
+	* Promise via .then() and .catch() - otherwise a source of memory leaks.
+	*
+	* The returned promise has an `unsubscribe()` method which can be called when
+	* the Promise is no longer being tracked by application logic, and which
+	* ensures that there is no reference chain from the original promise to the
+	* new one, and therefore no memory leak.
+	*
+	* If original promise has not yet settled, this adds a new unique promise
+	* that listens to then/catch events, along with an `unsubscribe()` method to
+	* detach it.
+	*
+	* If original promise has settled, then creates a new Promise.resolve() or
+	* Promise.reject() and provided unsubscribe is a noop.
+	*
+	* If you call `unsubscribe()` before the returned Promise has settled, it
+	* will never settle.
+	*/
+	subscribe() {
+		let promise;
+		let unsubscribe;
+		const { settlement } = this;
+		if (settlement === null) {
+			if (this.subscribers === null) throw new Error("Unpromise settled but still has subscribers");
+			const subscriber = withResolvers();
+			this.subscribers = listWithMember(this.subscribers, subscriber);
+			promise = subscriber.promise;
+			unsubscribe = () => {
+				if (this.subscribers !== null) this.subscribers = listWithoutMember(this.subscribers, subscriber);
+			};
+		} else {
+			const { status } = settlement;
+			if (status === "fulfilled") promise = Promise.resolve(settlement.value);
+			else promise = Promise.reject(settlement.reason);
+			unsubscribe = NOOP;
+		}
+		return Object.assign(promise, { unsubscribe });
+	}
+	/** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */
+	then(onfulfilled, onrejected) {
+		const subscribed = this.subscribe();
+		const { unsubscribe } = subscribed;
+		return Object.assign(subscribed.then(onfulfilled, onrejected), { unsubscribe });
+	}
+	catch(onrejected) {
+		const subscribed = this.subscribe();
+		const { unsubscribe } = subscribed;
+		return Object.assign(subscribed.catch(onrejected), { unsubscribe });
+	}
+	finally(onfinally) {
+		const subscribed = this.subscribe();
+		const { unsubscribe } = subscribed;
+		return Object.assign(subscribed.finally(onfinally), { unsubscribe });
+	}
+	/** TOSTRING SUPPORT */
+	[Symbol.toStringTag] = "Unpromise";
+	/** Unpromise STATIC METHODS */
+	/** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
+	* of the provided Promise reference) */
+	static proxy(promise) {
+		const cached = Unpromise.getSubscribablePromise(promise);
+		return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
+	}
+	/** Create and store an Unpromise keyed by an original Promise. */
+	static createSubscribablePromise(promise) {
+		const created = new Unpromise(promise);
+		subscribableCache.set(promise, created);
+		subscribableCache.set(created, created);
+		return created;
+	}
+	/** Retrieve a previously-created Unpromise keyed by an original Promise. */
+	static getSubscribablePromise(promise) {
+		return subscribableCache.get(promise);
+	}
+	/** Promise STATIC METHODS */
+	/** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
+	* it (that can be later unsubscribed to eliminate Memory leaks) */
+	static resolve(value) {
+		const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
+		return Unpromise.proxy(promise).subscribe();
+	}
+	static async any(values) {
+		const valuesArray = Array.isArray(values) ? values : [...values];
+		const subscribedPromises = valuesArray.map(Unpromise.resolve);
+		try {
+			return await Promise.any(subscribedPromises);
+		} finally {
+			subscribedPromises.forEach(({ unsubscribe }) => {
+				unsubscribe();
+			});
+		}
+	}
+	static async race(values) {
+		const valuesArray = Array.isArray(values) ? values : [...values];
+		const subscribedPromises = valuesArray.map(Unpromise.resolve);
+		try {
+			return await Promise.race(subscribedPromises);
+		} finally {
+			subscribedPromises.forEach(({ unsubscribe }) => {
+				unsubscribe();
+			});
+		}
+	}
+	/** Create a race of SubscribedPromises that will fulfil to a single winning
+	* Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
+	* accumulating .then() and .catch() subscribers. Allows simple logic to
+	* consume the result, like...
+	* ```ts
+	* const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
+	* if(winner === promiseB){
+	*   const result = await promiseB;
+	*   // do the thing
+	* }
+	* ```
+	* */
+	static async raceReferences(promises) {
+		const selfPromises = promises.map(resolveSelfTuple);
+		try {
+			return await Promise.race(selfPromises);
+		} finally {
+			for (const promise of selfPromises) promise.unsubscribe();
+		}
+	}
+};
 /** Promises a 1-tuple containing the original promise when it resolves. Allows
- * awaiting the eventual Promise ***reference*** (easy to destructure and
- * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
- * may be ambiguous and therefore hard to identify as the winner of a race).
- * You can call unsubscribe on the Promise to mitigate memory leaks.
- * */ function resolveSelfTuple(promise) {
-    return Unpromise.proxy(promise).then(()=>[
-            promise
-        ]);
+* awaiting the eventual Promise ***reference*** (easy to destructure and
+* exactly compare with ===). Avoids resolving to the Promise ***value*** (which
+* may be ambiguous and therefore hard to identify as the winner of a race).
+* You can call unsubscribe on the Promise to mitigate memory leaks.
+* */
+function resolveSelfTuple(promise) {
+	return Unpromise.proxy(promise).then(() => [promise]);
 }
-/** VENDORED (Future) PROMISE UTILITIES */ /** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */ function withResolvers() {
-    let resolve;
-    let reject;
-    const promise = new Promise((_resolve, _reject)=>{
-        resolve = _resolve;
-        reject = _reject;
-    });
-    return {
-        promise,
-        resolve,
-        reject
-    };
+/** VENDORED (Future) PROMISE UTILITIES */
+/** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */
+function withResolvers() {
+	let resolve;
+	let reject;
+	const promise = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	return {
+		promise,
+		resolve,
+		reject
+	};
 }
-/** IMMUTABLE LIST OPERATIONS */ function listWithMember(arr, member) {
-    return [
-        ...arr,
-        member
-    ];
+/** IMMUTABLE LIST OPERATIONS */
+function listWithMember(arr, member) {
+	return [...arr, member];
 }
 function listWithoutIndex(arr, index) {
-    return [
-        ...arr.slice(0, index),
-        ...arr.slice(index + 1)
-    ];
+	return [...arr.slice(0, index), ...arr.slice(index + 1)];
 }
 function listWithoutMember(arr, member) {
-    const index = arr.indexOf(member);
-    if (index !== -1) {
-        return listWithoutIndex(arr, index);
-    }
-    return arr;
+	const index = arr.indexOf(member);
+	if (index !== -1) return listWithoutIndex(arr, index);
+	return arr;
 }
 
-export { Unpromise, resolveSelfTuple };
+//#endregion
+export { Unpromise };
+//# sourceMappingURL=unpromise.mjs.map

package/dist/vendor/unpromise/unpromise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpromise.mjs","names":["arg: Promise<T> | PromiseLike<T> | PromiseExecutor<T>","promise: Promise<T>","unsubscribe: () => void","onfulfilled?:\n      | ((value: T) => TResult1 | PromiseLike<TResult1>)\n      | null","onrejected?:\n      | ((reason: any) => TResult2 | PromiseLike<TResult2>)\n      | null","onrejected?:\n      | ((reason: any) => TResult | PromiseLike<TResult>)\n      | null","onfinally?: (() => void) | null","promise: PromiseLike<T>","value: T | PromiseLike<T>","values: Iterable<T | PromiseLike<T>>","promises: readonly TPromise[]","promise: TPromise","resolve!: PromiseWithResolvers<T>[\"resolve\"]","reject!: PromiseWithResolvers<T>[\"reject\"]","arr: readonly T[]","member: T","index: number","member: unknown"],"sources":["../../../src/vendor/unpromise/unpromise.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\n \n \n\nimport type {\n  PromiseExecutor,\n  PromiseWithResolvers,\n  ProxyPromise,\n  SubscribedPromise,\n} from \"./types\";\n\n/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,\n * which is retained for the lifetime of the original Promise.\n */\nconst subscribableCache = new WeakMap<\n  PromiseLike<unknown>,\n  ProxyPromise<unknown>\n>();\n\n/** A NOOP function allowing a consistent interface for settled\n * SubscribedPromises (settled promises are not subscribed - they resolve\n * immediately). */\nconst NOOP = () => {\n  // noop\n};\n\n/**\n * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is\n * created once, cached and reused throughout the lifetime of the Promise. Get a\n * Promise's ProxyPromise using `Unpromise.proxy(promise)`.\n *\n * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`\n * `.then()` and `.catch()` just once. Promises derived from it use a\n * subscription- (and unsubscription-) based mechanism that monitors these\n * handlers.\n *\n * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a\n * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional\n * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains\n * from the original, potentially long-lived Promise, eliminating memory leaks.\n *\n * This approach can eliminate the memory leaks that otherwise come about from\n * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple\n * times on the same long-lived native Promise (subscriptions which can never be\n * cleaned up).\n *\n * `Unpromise.race(promises)` is a reference implementation of `Promise.race`\n * avoiding memory leaks when using long-lived unsettled Promises.\n *\n * `Unpromise.any(promises)` is a reference implementation of `Promise.any`\n * avoiding memory leaks when using long-lived unsettled Promises.\n *\n * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for\n * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind\n * the scenes, `resolve` is implemented simply as\n * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`\n * to tidy up!\n *\n */\nexport class Unpromise<T> implements ProxyPromise<T> {\n  /** INSTANCE IMPLEMENTATION */\n\n  /** The promise shadowed by this Unpromise<T>  */\n  protected readonly promise: Promise<T> | PromiseLike<T>;\n\n  /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted\n   * after the original promise settles - no further notifications will be issued. */\n  protected subscribers: ReadonlyArray<PromiseWithResolvers<T>> | null = [];\n\n  /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when\n   * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise\n   * can be returned, and therefore subscription can be bypassed. */\n  protected settlement: PromiseSettledResult<T> | null = null;\n\n  /** Constructor accepts a normal Promise executor function like `new\n   * Unpromise((resolve, reject) => {...})` or accepts a pre-existing Promise\n   * like `new Unpromise(existingPromise)`. Adds `.then()` and `.catch()`\n   * handlers to the Promise. These handlers pass fulfilment and rejection\n   * notifications to downstream subscribers and maintains records of value\n   * or error if the Promise ever settles. */\n  protected constructor(promise: Promise<T>);\n  protected constructor(promise: PromiseLike<T>);\n  protected constructor(executor: PromiseExecutor<T>);\n  protected constructor(arg: Promise<T> | PromiseLike<T> | PromiseExecutor<T>) {\n    // handle either a Promise or a Promise executor function\n    if (typeof arg === \"function\") {\n      this.promise = new Promise(arg);\n    } else {\n      this.promise = arg;\n    }\n\n    // subscribe for eventual fulfilment and rejection\n\n    // handle PromiseLike objects (that at least have .then)\n    const thenReturn = this.promise.then((value) => {\n      // atomically record fulfilment and detach subscriber list\n      const { subscribers } = this;\n      this.subscribers = null;\n      this.settlement = {\n        status: \"fulfilled\",\n        value,\n      };\n      // notify fulfilment to subscriber list\n      subscribers?.forEach(({ resolve }) => {\n        resolve(value);\n      });\n    });\n\n    // handle Promise (that also have a .catch behaviour)\n    if (\"catch\" in thenReturn) {\n      thenReturn.catch((reason) => {\n        // atomically record rejection and detach subscriber list\n        const { subscribers } = this;\n        this.subscribers = null;\n        this.settlement = {\n          status: \"rejected\",\n          reason,\n        };\n        // notify rejection to subscriber list\n        subscribers?.forEach(({ reject }) => {\n          reject(reason);\n        });\n      });\n    }\n  }\n\n  /** Create a promise that mitigates uncontrolled subscription to a long-lived\n   * Promise via .then() and .catch() - otherwise a source of memory leaks.\n   *\n   * The returned promise has an `unsubscribe()` method which can be called when\n   * the Promise is no longer being tracked by application logic, and which\n   * ensures that there is no reference chain from the original promise to the\n   * new one, and therefore no memory leak.\n   *\n   * If original promise has not yet settled, this adds a new unique promise\n   * that listens to then/catch events, along with an `unsubscribe()` method to\n   * detach it.\n   *\n   * If original promise has settled, then creates a new Promise.resolve() or\n   * Promise.reject() and provided unsubscribe is a noop.\n   *\n   * If you call `unsubscribe()` before the returned Promise has settled, it\n   * will never settle.\n   */\n  subscribe(): SubscribedPromise<T> {\n    // in all cases we will combine some promise with its unsubscribe function\n    let promise: Promise<T>;\n    let unsubscribe: () => void;\n\n    const { settlement } = this;\n    if (settlement === null) {\n      // not yet settled - subscribe new promise. Expect eventual settlement\n      if (this.subscribers === null) {\n        // invariant - it is not settled, so it must have subscribers\n        throw new Error(\"Unpromise settled but still has subscribers\");\n      }\n      const subscriber = withResolvers<T>();\n      this.subscribers = listWithMember(this.subscribers, subscriber);\n      promise = subscriber.promise;\n      unsubscribe = () => {\n        if (this.subscribers !== null) {\n          this.subscribers = listWithoutMember(this.subscribers, subscriber);\n        }\n      };\n    } else {\n      // settled - don't create subscribed promise. Just resolve or reject\n      const { status } = settlement;\n      if (status === \"fulfilled\") {\n        promise = Promise.resolve(settlement.value);\n      } else {\n        promise = Promise.reject(settlement.reason);\n      }\n      unsubscribe = NOOP;\n    }\n\n    // extend promise signature with the extra method\n    return Object.assign(promise, { unsubscribe });\n  }\n\n  /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?:\n      | ((value: T) => TResult1 | PromiseLike<TResult1>)\n      | null\n       ,\n    onrejected?:\n      | ((reason: any) => TResult2 | PromiseLike<TResult2>)\n      | null\n       \n  ): SubscribedPromise<TResult1 | TResult2> {\n    const subscribed = this.subscribe();\n    const { unsubscribe } = subscribed;\n    return Object.assign(subscribed.then(onfulfilled, onrejected), {\n      unsubscribe,\n    });\n  }\n\n  catch<TResult = never>(\n    onrejected?:\n      | ((reason: any) => TResult | PromiseLike<TResult>)\n      | null\n       \n  ): SubscribedPromise<T | TResult> {\n    const subscribed = this.subscribe();\n    const { unsubscribe } = subscribed;\n    return Object.assign(subscribed.catch(onrejected), {\n      unsubscribe,\n    });\n  }\n\n  finally(onfinally?: (() => void) | null  ): SubscribedPromise<T> {\n    const subscribed = this.subscribe();\n    const { unsubscribe } = subscribed;\n    return Object.assign(subscribed.finally(onfinally), {\n      unsubscribe,\n    });\n  }\n\n  /** TOSTRING SUPPORT */\n\n  readonly [Symbol.toStringTag] = \"Unpromise\";\n\n  /** Unpromise STATIC METHODS */\n\n  /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime\n   * of the provided Promise reference) */\n  static proxy<T>(promise: PromiseLike<T>): ProxyPromise<T> {\n    const cached = Unpromise.getSubscribablePromise(promise);\n    return typeof cached !== \"undefined\"\n      ? cached\n      : Unpromise.createSubscribablePromise(promise);\n  }\n\n  /** Create and store an Unpromise keyed by an original Promise. */\n  protected static createSubscribablePromise<T>(promise: PromiseLike<T>) {\n    const created = new Unpromise<T>(promise);\n    subscribableCache.set(promise, created as Unpromise<unknown>); // resolve promise to unpromise\n    subscribableCache.set(created, created as Unpromise<unknown>); // resolve the unpromise to itself\n    return created;\n  }\n\n  /** Retrieve a previously-created Unpromise keyed by an original Promise. */\n  protected static getSubscribablePromise<T>(promise: PromiseLike<T>) {\n    return subscribableCache.get(promise) as ProxyPromise<T> | undefined;\n  }\n\n  /** Promise STATIC METHODS */\n\n  /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from\n   * it (that can be later unsubscribed to eliminate Memory leaks) */\n  static resolve<T>(value: T | PromiseLike<T>) {\n    const promise: PromiseLike<T> =\n      typeof value === \"object\" &&\n      value !== null &&\n      \"then\" in value &&\n      typeof value.then === \"function\"\n        ? value\n        : Promise.resolve(value);\n    return Unpromise.proxy(promise).subscribe() as SubscribedPromise<\n      Awaited<T>\n    >;\n  }\n\n  /** Perform Promise.any() via SubscribedPromises, then unsubscribe them.\n   * Equivalent to Promise.any but eliminates memory leaks from long-lived\n   * promises accumulating .then() and .catch() subscribers. */\n  static async any<T extends readonly unknown[] | []>(\n    values: T\n  ): Promise<Awaited<T[number]>>;\n  static async any<T>(\n    values: Iterable<T | PromiseLike<T>>\n  ): Promise<Awaited<T>> {\n    const valuesArray = Array.isArray(values) ? values : [...values];\n    const subscribedPromises = valuesArray.map(Unpromise.resolve);\n    try {\n      return await Promise.any(subscribedPromises);\n    } finally {\n      subscribedPromises.forEach(({ unsubscribe }) => {\n        unsubscribe();\n      });\n    }\n  }\n\n  /** Perform Promise.race via SubscribedPromises, then unsubscribe them.\n   * Equivalent to Promise.race but eliminates memory leaks from long-lived\n   * promises accumulating .then() and .catch() subscribers. */\n  static async race<T extends readonly unknown[] | []>(\n    values: T\n  ): Promise<Awaited<T[number]>>;\n  static async race<T>(\n    values: Iterable<T | PromiseLike<T>>\n  ): Promise<Awaited<T>> {\n    const valuesArray = Array.isArray(values) ? values : [...values];\n    const subscribedPromises = valuesArray.map(Unpromise.resolve);\n    try {\n      return await Promise.race(subscribedPromises);\n    } finally {\n      subscribedPromises.forEach(({ unsubscribe }) => {\n        unsubscribe();\n      });\n    }\n  }\n\n  /** Create a race of SubscribedPromises that will fulfil to a single winning\n   * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises\n   * accumulating .then() and .catch() subscribers. Allows simple logic to\n   * consume the result, like...\n   * ```ts\n   * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);\n   * if(winner === promiseB){\n   *   const result = await promiseB;\n   *   // do the thing\n   * }\n   * ```\n   * */\n  static async raceReferences<TPromise extends Promise<unknown>>(\n    promises: readonly TPromise[]\n  ) {\n    // map each promise to an eventual 1-tuple containing itself\n    const selfPromises = promises.map(resolveSelfTuple);\n\n    // now race them. They will fulfil to a readonly [P] or reject.\n    try {\n      return await Promise.race(selfPromises);\n    } finally {\n      for (const promise of selfPromises) {\n        // unsubscribe proxy promises when the race is over to mitigate memory leaks\n        promise.unsubscribe();\n      }\n    }\n  }\n}\n\n/** Promises a 1-tuple containing the original promise when it resolves. Allows\n * awaiting the eventual Promise ***reference*** (easy to destructure and\n * exactly compare with ===). Avoids resolving to the Promise ***value*** (which\n * may be ambiguous and therefore hard to identify as the winner of a race).\n * You can call unsubscribe on the Promise to mitigate memory leaks.\n * */\nexport function resolveSelfTuple<TPromise extends Promise<unknown>>(\n  promise: TPromise\n): SubscribedPromise<readonly [TPromise]> {\n  return Unpromise.proxy(promise).then(() => [promise] as const);\n}\n\n/** VENDORED (Future) PROMISE UTILITIES */\n\n/** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */\nfunction withResolvers<T>(): PromiseWithResolvers<T> {\n  let resolve!: PromiseWithResolvers<T>[\"resolve\"];\n  let reject!: PromiseWithResolvers<T>[\"reject\"];\n  const promise = new Promise<T>((_resolve, _reject) => {\n    resolve = _resolve;\n    reject = _reject;\n  });\n  return {\n    promise,\n    resolve,\n    reject,\n  };\n}\n\n/** IMMUTABLE LIST OPERATIONS */\n\nfunction listWithMember<T>(arr: readonly T[], member: T): readonly T[] {\n  return [...arr, member];\n}\n\nfunction listWithoutIndex<T>(arr: readonly T[], index: number) {\n  return [...arr.slice(0, index), ...arr.slice(index + 1)];\n}\n\nfunction listWithoutMember<T>(arr: readonly T[], member: unknown) {\n  const index = arr.indexOf(member as T);\n  if (index !== -1) {\n    return listWithoutIndex(arr, index);\n  }\n  return arr;\n}\n"],"mappings":"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"}

package/http/package.json

@@ -0,0 +1 @@
+{"main":"../dist/http.js","module":"../dist/http.mjs","types":"../dist/http.d.ts"}

package/observable/package.json

@@ -0,0 +1 @@
+{"main":"../dist/observable/index.js","module":"../dist/observable/index.mjs","types":"../dist/observable/index.d.ts"}