@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.488 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.js

@@ -0,0 +1,171 @@
+'use strict';
+
+var unpromise = require('../../../vendor/unpromise/unpromise.js');
+var disposable = require('./disposable.js');
+var timerResource = require('./timerResource.js');
+
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+function iteratorResource(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return disposable.makeAsyncResource(iterator, async ()=>{
+        await iterator.return?.();
+    });
+}
+/**
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */ async function* withMaxDuration(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        const timer = _ts_add_disposable_resource(env, timerResource.timerResource(opts.maxDurationMs), false);
+        ;
+        const timerPromise = timer.start();
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        while(true){
+            result = await unpromise.Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === timerResource.disposablePromiseTimerResult) {
+                // cancelled due to timeout
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result;
+            }
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+ * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+ * values may still come through. After this period, the generator stops.
+ */ async function* takeWithGrace(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        const timer = _ts_add_disposable_resource(env, timerResource.timerResource(opts.gracePeriodMs), false);
+        ;
+        let count = opts.count;
+        let timerPromise = new Promise(()=>{
+        // never resolves
+        });
+        while(true){
+            result = await unpromise.Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === timerResource.disposablePromiseTimerResult) {
+                // cancelled
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result.value;
+            }
+            yield result.value;
+            if (--count === 0) {
+                timerPromise = timer.start();
+            }
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+
+exports.iteratorResource = iteratorResource;
+exports.takeWithGrace = takeWithGrace;
+exports.withMaxDuration = withMaxDuration;

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs

@@ -0,0 +1,167 @@
+import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
+import { makeAsyncResource } from './disposable.mjs';
+import { timerResource, disposablePromiseTimerResult } from './timerResource.mjs';
+
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+function iteratorResource(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return makeAsyncResource(iterator, async ()=>{
+        await iterator.return?.();
+    });
+}
+/**
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */ async function* withMaxDuration(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.maxDurationMs), false);
+        ;
+        const timerPromise = timer.start();
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        while(true){
+            result = await Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === disposablePromiseTimerResult) {
+                // cancelled due to timeout
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result;
+            }
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+ * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+ * values may still come through. After this period, the generator stops.
+ */ async function* takeWithGrace(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.gracePeriodMs), false);
+        ;
+        let count = opts.count;
+        let timerPromise = new Promise(()=>{
+        // never resolves
+        });
+        while(true){
+            result = await Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === disposablePromiseTimerResult) {
+                // cancelled
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result.value;
+            }
+            yield result.value;
+            if (--count === 0) {
+                timerPromise = timer.start();
+            }
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+
+export { iteratorResource, takeWithGrace, withMaxDuration };

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.ts

@@ -4,15 +4,4 @@ export declare function createDeferred<TValue>(): {
     reject: (error: unknown) => void;
 };
 export type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
-export declare const createTimeoutPromise: <TValue>(timeoutMs: number, value: TValue) => {
-    promise: Promise<TValue>;
-    /**
-     * Clear the timeout without resolving the promise
-     */
-    clear: () => void;
-    /**
-     * Resolve the promise with the value
-     */
-    resolve: () => void;
-};
 //# sourceMappingURL=createDeferred.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createDeferred.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"names":[],"mappings":"AACA,wBAAgB,cAAc,CAAC,MAAM;;qBACd,MAAM,KAAK,IAAI;oBAChB,OAAO,KAAK,IAAI;EAOrC;AACD,MAAM,MAAM,QAAQ,CAAC,MAAM,IAAI,UAAU,CAAC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzE,eAAO,MAAM,oBAAoB,GAAI,MAAM,aAC9B,MAAM,SACV,MAAM;;IAuBX;;OAEG;;IAEH;;OAEG;;CAGN,CAAC"}
+{"version":3,"file":"createDeferred.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"names":[],"mappings":"AACA,wBAAgB,cAAc,CAAC,MAAM;;qBACd,MAAM,KAAK,IAAI;oBAChB,OAAO,KAAK,IAAI;EAOrC;AACD,MAAM,MAAM,QAAQ,CAAC,MAAM,IAAI,UAAU,CAAC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.js

@@ -13,34 +13,5 @@
         reject: reject
     };
 }
-const createTimeoutPromise = (timeoutMs, value)=>{
-    let deferred = createDeferred();
-    deferred = deferred;
-    let timeout = null;
-    const clear = ()=>{
-        if (timeout) {
-            clearTimeout(timeout);
-            timeout = null;
-        }
-    };
-    const resolve = ()=>{
-        deferred.resolve(value);
-        clear();
-    };
-    if (timeoutMs !== Infinity) {
-        timeout = setTimeout(resolve, timeoutMs);
-        timeout.unref?.();
-    }
-    return {
-        promise: deferred.promise,
-        /**
-     * Clear the timeout without resolving the promise
-     */ clear,
-        /**
-     * Resolve the promise with the value
-     */ resolve
-    };
-};
 
 exports.createDeferred = createDeferred;
-exports.createTimeoutPromise = createTimeoutPromise;

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.mjs

@@ -11,33 +11,5 @@
         reject: reject
     };
 }
-const createTimeoutPromise = (timeoutMs, value)=>{
-    let deferred = createDeferred();
-    deferred = deferred;
-    let timeout = null;
-    const clear = ()=>{
-        if (timeout) {
-            clearTimeout(timeout);
-            timeout = null;
-        }
-    };
-    const resolve = ()=>{
-        deferred.resolve(value);
-        clear();
-    };
-    if (timeoutMs !== Infinity) {
-        timeout = setTimeout(resolve, timeoutMs);
-        timeout.unref?.();
-    }
-    return {
-        promise: deferred.promise,
-        /**
-     * Clear the timeout without resolving the promise
-     */ clear,
-        /**
-     * Resolve the promise with the value
-     */ resolve
-    };
-};
 
-export { createDeferred, createTimeoutPromise };
+export { createDeferred };

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */
+export declare function makeResource<T>(thing: T, dispose: () => void): T & Disposable;
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */
+export declare function makeAsyncResource<T>(thing: T, dispose: () => Promise<void>): T & AsyncDisposable;
+//# sourceMappingURL=disposable.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,CAAC,GAAG,UAAU,CAY7E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,CAAC,GAAG,eAAe,CAYrB"}

package/dist/unstable-core-do-not-import/stream/utils/disposable.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+var _Symbol, // @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+_Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */ function makeResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.dispose]) {
+        throw new Error('Symbol.dispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.dispose] = dispose;
+    return it;
+}
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */ function makeAsyncResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.asyncDispose]) {
+        throw new Error('Symbol.asyncDispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.asyncDispose] = dispose;
+    return it;
+}
+
+exports.makeAsyncResource = makeAsyncResource;
+exports.makeResource = makeResource;

package/dist/unstable-core-do-not-import/stream/utils/disposable.mjs

@@ -0,0 +1,41 @@
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+var _Symbol, // @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+_Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */ function makeResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.dispose]) {
+        throw new Error('Symbol.dispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.dispose] = dispose;
+    return it;
+}
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */ function makeAsyncResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.asyncDispose]) {
+        throw new Error('Symbol.asyncDispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.asyncDispose] = dispose;
+    return it;
+}
+
+export { makeAsyncResource, makeResource };

package/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a ReadableStream from an AsyncIterable.
+ *
+ * @param iterable - The source AsyncIterable to stream from
+ * @returns A ReadableStream that yields values from the AsyncIterable
+ */
+export declare function readableStreamFrom<TYield>(iterable: AsyncIterable<TYield, void>): ReadableStream<TYield>;
+//# sourceMappingURL=readableStreamFrom.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readableStreamFrom.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/readableStreamFrom.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EACvC,QAAQ,EAAE,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,GACpC,cAAc,CAAC,MAAM,CAAC,CAmBxB"}

package/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * Creates a ReadableStream from an AsyncIterable.
+ *
+ * @param iterable - The source AsyncIterable to stream from
+ * @returns A ReadableStream that yields values from the AsyncIterable
+ */ function readableStreamFrom(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async cancel () {
+            await iterator.return?.();
+        },
+        async pull (controller) {
+            const result = await iterator.next();
+            if (result.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(result.value);
+        }
+    });
+}
+
+exports.readableStreamFrom = readableStreamFrom;

package/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.mjs

@@ -0,0 +1,23 @@
+/**
+ * Creates a ReadableStream from an AsyncIterable.
+ *
+ * @param iterable - The source AsyncIterable to stream from
+ * @returns A ReadableStream that yields values from the AsyncIterable
+ */ function readableStreamFrom(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async cancel () {
+            await iterator.return?.();
+        },
+        async pull (controller) {
+            const result = await iterator.next();
+            if (result.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(result.value);
+        }
+    });
+}
+
+export { readableStreamFrom };

package/dist/unstable-core-do-not-import/stream/utils/timerResource.d.ts

@@ -0,0 +1,5 @@
+export declare const disposablePromiseTimerResult: unique symbol;
+export declare function timerResource(ms: number): {
+    start(): Promise<typeof disposablePromiseTimerResult>;
+} & Disposable;
+//# sourceMappingURL=timerResource.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/timerResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timerResource.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/timerResource.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B,eAAW,CAAC;AAErD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM;;eAwBvC"}

package/dist/unstable-core-do-not-import/stream/utils/timerResource.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var disposable = require('./disposable.js');
+
+const disposablePromiseTimerResult = Symbol();
+function timerResource(ms) {
+    let timer = null;
+    return disposable.makeResource({
+        start () {
+            if (timer) {
+                throw new Error('Timer already started');
+            }
+            const promise = new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
+            });
+            return promise;
+        }
+    }, ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
+}
+
+exports.disposablePromiseTimerResult = disposablePromiseTimerResult;
+exports.timerResource = timerResource;

package/dist/unstable-core-do-not-import/stream/utils/timerResource.mjs

@@ -0,0 +1,23 @@
+import { makeResource } from './disposable.mjs';
+
+const disposablePromiseTimerResult = Symbol();
+function timerResource(ms) {
+    let timer = null;
+    return makeResource({
+        start () {
+            if (timer) {
+                throw new Error('Timer already started');
+            }
+            const promise = new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
+            });
+            return promise;
+        }
+    }, ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
+}
+
+export { disposablePromiseTimerResult, timerResource };

package/dist/unstable-core-do-not-import/stream/utils/withPing.d.ts

@@ -0,0 +1,7 @@
+export declare const PING_SYM: unique symbol;
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
+ * whenever no value has been yielded for {@link pingIntervalMs}.
+ */
+export declare function withPing<TValue>(iterable: AsyncIterable<TValue>, pingIntervalMs: number): AsyncGenerator<TValue | typeof PING_SYM>;
+//# sourceMappingURL=withPing.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/withPing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAuB,QAAQ,CAAC,MAAM,EACpC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,MAAM,GACrB,cAAc,CAAC,MAAM,GAAG,OAAO,QAAQ,CAAC,CAiC1C"}