@trpc/server 11.0.0-rc.571 → 11.0.0-rc.577

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

@@ -3,8 +3,11 @@
 var TRPCError = require('../error/TRPCError.js');
 var utils = require('../utils.js');
 var tracked = require('./tracked.js');
+var asyncIterable = require('./utils/asyncIterable.js');
 var createDeferred = require('./utils/createDeferred.js');
 var createReadableStream = require('./utils/createReadableStream.js');
+var promiseTimer = require('./utils/promiseTimer.js');
+var withPing = require('./utils/withPing.js');
 
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
@@ -15,83 +18,68 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
     stream.controller.enqueue({
         comment: 'connected'
     });
-    const { serialize =(v)=>v  } = opts;
+    const { serialize =utils.identity  } = opts;
     const ping = {
         enabled: opts.ping?.enabled ?? false,
         intervalMs: opts.ping?.intervalMs ?? 1000
     };
     utils.run(async ()=>{
-        const iterator = opts.data[Symbol.asyncIterator]();
-        const closedPromise = stream.cancelledPromise.then(()=>'closed');
-        const maxDurationPromise = createDeferred.createTimeoutPromise(opts.maxDurationMs ?? Infinity, 'maxDuration');
-        let nextPromise = iterator.next();
-        while(true){
-            const pingPromise = createDeferred.createTimeoutPromise(ping.enabled ? ping.intervalMs : Infinity, 'ping');
-            const next = await Promise.race([
-                nextPromise.catch((err)=>{
-                    if (err instanceof Error && err.name === 'AbortError') {
-                        // Ensures that aborting the request doesn't throw an error
-                        return 'aborted';
-                    }
-                    return TRPCError.getTRPCErrorFromUnknown(err);
-                }),
-                pingPromise.promise,
-                closedPromise,
-                maxDurationPromise.promise
-            ]);
-            pingPromise.clear();
-            if (next === 'aborted') {
-                break;
-            }
-            if (next === 'closed') {
-                break;
-            }
-            if (next === 'maxDuration') {
-                break;
-            }
-            if (next === 'ping') {
-                stream.controller.enqueue({
-                    comment: 'ping'
-                });
-                continue;
+        let iterable = opts.data;
+        iterable = asyncIterable.withCancel(iterable, stream.cancelledPromise);
+        if (opts.emitAndEndImmediately) {
+            iterable = asyncIterable.takeWithGrace(iterable, {
+                count: 1,
+                gracePeriodMs: 1
+            });
+        }
+        let maxDurationTimer = null;
+        if (opts.maxDurationMs != null && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            maxDurationTimer = promiseTimer.createPromiseTimer(opts.maxDurationMs).start();
+            iterable = asyncIterable.withCancel(iterable, maxDurationTimer.promise);
+        }
+        if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+            iterable = withPing.withPing(iterable, ping.intervalMs);
+        }
+        try {
+            for await (const value of iterable){
+                if (value === withPing.PING_SYM) {
+                    stream.controller.enqueue({
+                        comment: 'ping'
+                    });
+                    continue;
+                }
+                const chunk = tracked.isTrackedEnvelope(value) ? {
+                    id: value[0],
+                    data: value[1]
+                } : {
+                    data: value
+                };
+                if ('data' in chunk) {
+                    chunk.data = JSON.stringify(serialize(chunk.data));
+                }
+                stream.controller.enqueue(chunk);
             }
-            if (next instanceof Error) {
-                const data = opts.formatError ? opts.formatError({
-                    error: next
-                }) : null;
+        } catch (err) {
+            // ignore abort errors, send any other errors
+            if (!(err instanceof Error) || err.name !== 'AbortError') {
+                // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
+                // So, a user error in any case.
+                const error = TRPCError.getTRPCErrorFromUnknown(err);
+                const data = opts.formatError?.({
+                    error
+                }) ?? null;
                 stream.controller.enqueue({
                     event: SERIALIZED_ERROR_EVENT,
                     data: JSON.stringify(serialize(data))
                 });
-                break;
             }
-            if (next.done) {
-                break;
-            }
-            const value = next.value;
-            const chunk = tracked.isTrackedEnvelope(value) ? {
-                id: value[0],
-                data: value[1]
-            } : {
-                data: value
-            };
-            if ('data' in chunk) {
-                chunk.data = JSON.stringify(serialize(chunk.data));
-            }
-            stream.controller.enqueue(chunk);
-            if (opts.emitAndEndImmediately) {
-                // end the stream in the next tick so that we can send a few more events from the queue
-                setTimeout(maxDurationPromise.resolve, 1);
-            }
-            nextPromise = iterator.next();
-        }
-        maxDurationPromise.clear();
-        await iterator.return?.();
-        try {
+        } finally{
+            maxDurationTimer?.clear();
             stream.controller.close();
-        } catch  {}
-    }).catch((error)=>{
-        return stream.controller.error(error);
+        }
+    }).catch((err)=>{
+        // should not be reached; just in case...
+        stream.controller.error(err);
     });
     return stream.readable.pipeThrough(new TransformStream({
         transform (chunk, controller) {

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

@@ -1,8 +1,11 @@
 import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
-import { run } from '../utils.mjs';
+import { run, identity } from '../utils.mjs';
 import { isTrackedEnvelope } from './tracked.mjs';
-import { createTimeoutPromise, createDeferred } from './utils/createDeferred.mjs';
+import { withCancel, takeWithGrace } from './utils/asyncIterable.mjs';
+import { createDeferred } from './utils/createDeferred.mjs';
 import { createReadableStream } from './utils/createReadableStream.mjs';
+import { createPromiseTimer } from './utils/promiseTimer.mjs';
+import { withPing, PING_SYM } from './utils/withPing.mjs';
 
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
 /**
@@ -13,83 +16,68 @@ const SERIALIZED_ERROR_EVENT = 'serialized-error';
     stream.controller.enqueue({
         comment: 'connected'
     });
-    const { serialize =(v)=>v  } = opts;
+    const { serialize =identity  } = opts;
     const ping = {
         enabled: opts.ping?.enabled ?? false,
         intervalMs: opts.ping?.intervalMs ?? 1000
     };
     run(async ()=>{
-        const iterator = opts.data[Symbol.asyncIterator]();
-        const closedPromise = stream.cancelledPromise.then(()=>'closed');
-        const maxDurationPromise = createTimeoutPromise(opts.maxDurationMs ?? Infinity, 'maxDuration');
-        let nextPromise = iterator.next();
-        while(true){
-            const pingPromise = createTimeoutPromise(ping.enabled ? ping.intervalMs : Infinity, 'ping');
-            const next = await Promise.race([
-                nextPromise.catch((err)=>{
-                    if (err instanceof Error && err.name === 'AbortError') {
-                        // Ensures that aborting the request doesn't throw an error
-                        return 'aborted';
-                    }
-                    return getTRPCErrorFromUnknown(err);
-                }),
-                pingPromise.promise,
-                closedPromise,
-                maxDurationPromise.promise
-            ]);
-            pingPromise.clear();
-            if (next === 'aborted') {
-                break;
-            }
-            if (next === 'closed') {
-                break;
-            }
-            if (next === 'maxDuration') {
-                break;
-            }
-            if (next === 'ping') {
-                stream.controller.enqueue({
-                    comment: 'ping'
-                });
-                continue;
+        let iterable = opts.data;
+        iterable = withCancel(iterable, stream.cancelledPromise);
+        if (opts.emitAndEndImmediately) {
+            iterable = takeWithGrace(iterable, {
+                count: 1,
+                gracePeriodMs: 1
+            });
+        }
+        let maxDurationTimer = null;
+        if (opts.maxDurationMs != null && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            maxDurationTimer = createPromiseTimer(opts.maxDurationMs).start();
+            iterable = withCancel(iterable, maxDurationTimer.promise);
+        }
+        if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+            iterable = withPing(iterable, ping.intervalMs);
+        }
+        try {
+            for await (const value of iterable){
+                if (value === PING_SYM) {
+                    stream.controller.enqueue({
+                        comment: 'ping'
+                    });
+                    continue;
+                }
+                const chunk = isTrackedEnvelope(value) ? {
+                    id: value[0],
+                    data: value[1]
+                } : {
+                    data: value
+                };
+                if ('data' in chunk) {
+                    chunk.data = JSON.stringify(serialize(chunk.data));
+                }
+                stream.controller.enqueue(chunk);
             }
-            if (next instanceof Error) {
-                const data = opts.formatError ? opts.formatError({
-                    error: next
-                }) : null;
+        } catch (err) {
+            // ignore abort errors, send any other errors
+            if (!(err instanceof Error) || err.name !== 'AbortError') {
+                // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
+                // So, a user error in any case.
+                const error = getTRPCErrorFromUnknown(err);
+                const data = opts.formatError?.({
+                    error
+                }) ?? null;
                 stream.controller.enqueue({
                     event: SERIALIZED_ERROR_EVENT,
                     data: JSON.stringify(serialize(data))
                 });
-                break;
             }
-            if (next.done) {
-                break;
-            }
-            const value = next.value;
-            const chunk = isTrackedEnvelope(value) ? {
-                id: value[0],
-                data: value[1]
-            } : {
-                data: value
-            };
-            if ('data' in chunk) {
-                chunk.data = JSON.stringify(serialize(chunk.data));
-            }
-            stream.controller.enqueue(chunk);
-            if (opts.emitAndEndImmediately) {
-                // end the stream in the next tick so that we can send a few more events from the queue
-                setTimeout(maxDurationPromise.resolve, 1);
-            }
-            nextPromise = iterator.next();
-        }
-        maxDurationPromise.clear();
-        await iterator.return?.();
-        try {
+        } finally{
+            maxDurationTimer?.clear();
             stream.controller.close();
-        } catch  {}
-    }).catch((error)=>{
-        return stream.controller.error(error);
+        }
+    }).catch((err)=>{
+        // should not be reached; just in case...
+        stream.controller.error(err);
     });
     return stream.readable.pipeThrough(new TransformStream({
         transform (chunk, controller) {

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

@@ -0,0 +1,17 @@
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
+ * passed {@link cancel} promise.
+ */
+export declare function withCancel<T>(iterable: AsyncIterable<T>, cancel: Promise<unknown>): AsyncGenerator<T>;
+interface TakeWithGraceOptions {
+    count: number;
+    gracePeriodMs: number;
+}
+/**
+ * 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.
+ */
+export declare function takeWithGrace<T>(iterable: AsyncIterable<T>, { count, gracePeriodMs }: TakeWithGraceOptions): AsyncGenerator<T>;
+export {};
+//# sourceMappingURL=asyncIterable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAuB,UAAU,CAAC,CAAC,EACjC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GACvB,cAAc,CAAC,CAAC,CAAC,CAcnB;AAED,UAAU,oBAAoB;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,oBAAoB,GAC7C,cAAc,CAAC,CAAC,CAAC,CAsBnB"}

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

@@ -0,0 +1,59 @@
+'use strict';
+
+var utils = require('../../utils.js');
+var promiseTimer = require('./promiseTimer.js');
+
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
+ * passed {@link cancel} promise.
+ */ async function* withCancel(iterable, cancel) {
+    const cancelPromise = cancel.then(utils.noop);
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const result = await Promise.race([
+            iterator.next(),
+            cancelPromise
+        ]);
+        if (result == null) {
+            await iterator.return?.();
+            break;
+        }
+        if (result.done) {
+            break;
+        }
+        yield result.value;
+    }
+}
+/**
+ * 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, { count , gracePeriodMs  }) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    const timer = promiseTimer.createPromiseTimer(gracePeriodMs);
+    try {
+        while(true){
+            const result = await Promise.race([
+                iterator.next(),
+                timer.promise
+            ]);
+            if (result == null) {
+                // cancelled
+                await iterator.return?.();
+                break;
+            }
+            if (result.done) {
+                break;
+            }
+            yield result.value;
+            if (--count === 0) {
+                timer.start();
+            }
+        }
+    } finally{
+        timer.clear();
+    }
+}
+
+exports.takeWithGrace = takeWithGrace;
+exports.withCancel = withCancel;

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

@@ -0,0 +1,56 @@
+import { noop } from '../../utils.mjs';
+import { createPromiseTimer } from './promiseTimer.mjs';
+
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
+ * passed {@link cancel} promise.
+ */ async function* withCancel(iterable, cancel) {
+    const cancelPromise = cancel.then(noop);
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const result = await Promise.race([
+            iterator.next(),
+            cancelPromise
+        ]);
+        if (result == null) {
+            await iterator.return?.();
+            break;
+        }
+        if (result.done) {
+            break;
+        }
+        yield result.value;
+    }
+}
+/**
+ * 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, { count , gracePeriodMs  }) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    const timer = createPromiseTimer(gracePeriodMs);
+    try {
+        while(true){
+            const result = await Promise.race([
+                iterator.next(),
+                timer.promise
+            ]);
+            if (result == null) {
+                // cancelled
+                await iterator.return?.();
+                break;
+            }
+            if (result.done) {
+                break;
+            }
+            yield result.value;
+            if (--count === 0) {
+                timer.start();
+            }
+        }
+    } finally{
+        timer.clear();
+    }
+}
+
+export { takeWithGrace, withCancel };

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/promiseTimer.d.ts

@@ -0,0 +1,8 @@
+export declare function createPromiseTimer(ms: number): {
+    readonly promise: Promise<void>;
+    start: () => PromiseTimer;
+    reset: () => PromiseTimer;
+    clear: () => PromiseTimer;
+};
+export type PromiseTimer = ReturnType<typeof createPromiseTimer>;
+//# sourceMappingURL=promiseTimer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promiseTimer.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/promiseTimer.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM;;iBAezB,YAAY;iBAQZ,YAAY;iBAMZ,YAAY;EAO/B;AACD,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

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

@@ -0,0 +1,38 @@
+'use strict';
+
+var createDeferred = require('./createDeferred.js');
+
+function createPromiseTimer(ms) {
+    let deferred = createDeferred.createDeferred();
+    let timeout = null;
+    const timer = {
+        get promise () {
+            return deferred.promise;
+        },
+        start,
+        reset,
+        clear
+    };
+    return timer;
+    function start() {
+        if (timeout != null) {
+            throw new Error("PromiseTimer already started.");
+        }
+        timeout = setTimeout(deferred.resolve, ms);
+        return timer;
+    }
+    function reset() {
+        clear();
+        deferred = createDeferred.createDeferred();
+        return timer;
+    }
+    function clear() {
+        if (timeout != null) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+        return timer;
+    }
+}
+
+exports.createPromiseTimer = createPromiseTimer;

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

@@ -0,0 +1,36 @@
+import { createDeferred } from './createDeferred.mjs';
+
+function createPromiseTimer(ms) {
+    let deferred = createDeferred();
+    let timeout = null;
+    const timer = {
+        get promise () {
+            return deferred.promise;
+        },
+        start,
+        reset,
+        clear
+    };
+    return timer;
+    function start() {
+        if (timeout != null) {
+            throw new Error("PromiseTimer already started.");
+        }
+        timeout = setTimeout(deferred.resolve, ms);
+        return timer;
+    }
+    function reset() {
+        clear();
+        deferred = createDeferred();
+        return timer;
+    }
+    function clear() {
+        if (timeout != null) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+        return timer;
+    }
+}
+
+export { createPromiseTimer };

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":"AAEA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAOvC;;;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,CAkB1C"}

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

@@ -0,0 +1,37 @@
+'use strict';
+
+var promiseTimer = require('./promiseTimer.js');
+
+const PING_SYM = Symbol('ping');
+const PING_RESULT = {
+    value: PING_SYM,
+    done: false
+};
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
+ * whenever no value has been yielded for {@link pingIntervalMs}.
+ */ async function* withPing(iterable, pingIntervalMs) {
+    const timer = promiseTimer.createPromiseTimer(pingIntervalMs);
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const nextPromise = iterator.next();
+        const pingPromise = timer.start().promise.then(()=>PING_RESULT);
+        let result;
+        try {
+            result = await Promise.race([
+                nextPromise,
+                pingPromise
+            ]);
+        } finally{
+            timer.clear();
+        }
+        if (result.done) {
+            return result.value;
+        }
+        yield result.value;
+        timer.reset();
+    }
+}
+
+exports.PING_SYM = PING_SYM;
+exports.withPing = withPing;