@trpc/server 11.0.0-rc.621 → 11.0.0-rc.632

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAIA;;;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,CAkBnB;AAED,UAAU,oBAAoB;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,EAAE,oBAAoB,GACvD,cAAc,CAAC,CAAC,CAAC,CA0BnB"}
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,eAAe,CAAA;CAAE,GAC1D,cAAc,CAAC,CAAC,CAAC,CA8BnB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,eAAe,CAAC;CAC5B,GACA,cAAc,CAAC,CAAC,CAAC,CAoCnB"}

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

@@ -1,68 +1,81 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
-var utils = require('../../utils.js');
-var promiseTimer = require('./promiseTimer.js');
+var disposablePromiseTimer = require('./disposablePromiseTimer.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);
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */ async function* withMaxDuration(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    while(true){
-        result = await unpromise.Unpromise.race([
-            iterator.next(),
-            cancelPromise
-        ]);
-        if (result == null) {
-            await iterator.return?.();
-            break;
-        }
-        if (result.done) {
-            break;
+    const timer = disposablePromiseTimer.disposablePromiseTimer(opts.maxDurationMs);
+    try {
+        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 === disposablePromiseTimer.disposablePromiseTimerResult) {
+                // cancelled due to timeout
+                opts.abortCtrl.abort();
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result;
+            }
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
         }
-        yield result.value;
-        // free up reference for garbage collection
-        result = null;
+    } finally{
+        // dispose timer
+        // Shouldn't be needed, but build breaks with `using` keyword
+        timer[Symbol.dispose]();
     }
 }
 /**
  * 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 , onCancel  }) {
+ */ async function* takeWithGrace(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const timer = promiseTimer.createPromiseTimer(gracePeriodMs);
+    // declaration outside the loop for garbage collection reasons
+    let result;
+    const timer = disposablePromiseTimer.disposablePromiseTimer(opts.gracePeriodMs);
     try {
-        // declaration outside the loop for garbage collection reasons
-        let result;
+        let count = opts.count;
+        let timerPromise = new Promise(()=>{
+        // never resolves
+        });
         while(true){
             result = await unpromise.Unpromise.race([
                 iterator.next(),
-                timer.promise
+                timerPromise
             ]);
-            if (result == null) {
+            if (result === disposablePromiseTimer.disposablePromiseTimerResult) {
                 // cancelled
-                await iterator.return?.();
-                break;
+                const res = await iterator.return?.();
+                return res?.value;
             }
             if (result.done) {
-                break;
+                return result.value;
             }
             yield result.value;
             if (--count === 0) {
-                timer.start().promise.then(onCancel, utils.noop);
+                timerPromise = timer.start();
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                timerPromise.then(()=>opts.abortCtrl.abort());
             }
             // free up reference for garbage collection
             result = null;
         }
     } finally{
-        timer.clear();
+        timer[Symbol.dispose]();
     }
 }
 
 exports.takeWithGrace = takeWithGrace;
-exports.withCancel = withCancel;
+exports.withMaxDuration = withMaxDuration;

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

@@ -1,65 +1,78 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { noop } from '../../utils.mjs';
-import { createPromiseTimer } from './promiseTimer.mjs';
+import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposablePromiseTimer.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);
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */ async function* withMaxDuration(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    while(true){
-        result = await Unpromise.race([
-            iterator.next(),
-            cancelPromise
-        ]);
-        if (result == null) {
-            await iterator.return?.();
-            break;
-        }
-        if (result.done) {
-            break;
+    const timer = disposablePromiseTimer(opts.maxDurationMs);
+    try {
+        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
+                opts.abortCtrl.abort();
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result;
+            }
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
         }
-        yield result.value;
-        // free up reference for garbage collection
-        result = null;
+    } finally{
+        // dispose timer
+        // Shouldn't be needed, but build breaks with `using` keyword
+        timer[Symbol.dispose]();
     }
 }
 /**
  * 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 , onCancel  }) {
+ */ async function* takeWithGrace(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const timer = createPromiseTimer(gracePeriodMs);
+    // declaration outside the loop for garbage collection reasons
+    let result;
+    const timer = disposablePromiseTimer(opts.gracePeriodMs);
     try {
-        // declaration outside the loop for garbage collection reasons
-        let result;
+        let count = opts.count;
+        let timerPromise = new Promise(()=>{
+        // never resolves
+        });
         while(true){
             result = await Unpromise.race([
                 iterator.next(),
-                timer.promise
+                timerPromise
             ]);
-            if (result == null) {
+            if (result === disposablePromiseTimerResult) {
                 // cancelled
-                await iterator.return?.();
-                break;
+                const res = await iterator.return?.();
+                return res?.value;
             }
             if (result.done) {
-                break;
+                return result.value;
             }
             yield result.value;
             if (--count === 0) {
-                timer.start().promise.then(onCancel, noop);
+                timerPromise = timer.start();
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                timerPromise.then(()=>opts.abortCtrl.abort());
             }
             // free up reference for garbage collection
             result = null;
         }
     } finally{
-        timer.clear();
+        timer[Symbol.dispose]();
     }
 }
 
-export { takeWithGrace, withCancel };
+export { takeWithGrace, withMaxDuration };

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

@@ -1,13 +1,9 @@
-declare const cancelledStreamSymbol: unique symbol;
 /**
  * One-off readable stream
  */
 export declare function createReadableStream<TValue = unknown>(): {
     readonly readable: ReadableStream<TValue>;
     readonly controller: ReadableStreamDefaultController<TValue>;
-    readonly cancelledPromise: Promise<typeof cancelledStreamSymbol>;
     readonly cancelled: () => boolean;
 };
-export declare function isCancelledStreamResult(v: unknown): v is typeof cancelledStreamSymbol;
-export {};
 //# sourceMappingURL=createReadableStream.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createReadableStream.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/createReadableStream.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,qBAAqB,eAAW,CAAC;AACvC;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAG,OAAO;;;;;EAwBpD;AACD,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,OAAO,qBAAqB,CAEnC"}
+{"version":3,"file":"createReadableStream.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/createReadableStream.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAG,OAAO;;;;EAqBpD"}

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

@@ -1,36 +1,25 @@
 'use strict';
 
-var createDeferred = require('./createDeferred.js');
-
-// ---------- utils
-const cancelledStreamSymbol = Symbol();
 /**
  * One-off readable stream
  */ function createReadableStream() {
     let controller = null;
-    const deferred = createDeferred.createDeferred();
     let cancelled = false;
     const readable = new ReadableStream({
         start (c) {
             controller = c;
         },
         cancel () {
-            deferred.resolve(cancelledStreamSymbol);
             cancelled = true;
         }
     });
     return {
         readable,
         controller,
-        cancelledPromise: deferred.promise,
         cancelled () {
             return cancelled;
         }
     };
 }
-function isCancelledStreamResult(v) {
-    return v === cancelledStreamSymbol;
-}
 
 exports.createReadableStream = createReadableStream;
-exports.isCancelledStreamResult = isCancelledStreamResult;

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

@@ -1,33 +1,23 @@
-import { createDeferred } from './createDeferred.mjs';
-
-// ---------- utils
-const cancelledStreamSymbol = Symbol();
 /**
  * One-off readable stream
  */ function createReadableStream() {
     let controller = null;
-    const deferred = createDeferred();
     let cancelled = false;
     const readable = new ReadableStream({
         start (c) {
             controller = c;
         },
         cancel () {
-            deferred.resolve(cancelledStreamSymbol);
             cancelled = true;
         }
     });
     return {
         readable,
         controller,
-        cancelledPromise: deferred.promise,
         cancelled () {
             return cancelled;
         }
     };
 }
-function isCancelledStreamResult(v) {
-    return v === cancelledStreamSymbol;
-}
 
-export { createReadableStream, isCancelledStreamResult };
+export { createReadableStream };

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

@@ -0,0 +1,6 @@
+export declare const disposablePromiseTimerResult: unique symbol;
+export declare function disposablePromiseTimer(ms: number): {
+    start(): Promise<typeof disposablePromiseTimerResult>;
+    [Symbol.dispose]: () => void;
+};
+//# sourceMappingURL=disposablePromiseTimer.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+'use strict';
+
+// @ts-expect-error polyfill
+var _Symbol;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+const disposablePromiseTimerResult = Symbol();
+function disposablePromiseTimer(ms) {
+    let timer = null;
+    return {
+        start () {
+            if (timer) {
+                throw new Error('Timer already started');
+            }
+            const promise = new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
+            });
+            return promise;
+        },
+        [Symbol.dispose]: ()=>{
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    };
+}
+
+exports.disposablePromiseTimer = disposablePromiseTimer;
+exports.disposablePromiseTimerResult = disposablePromiseTimerResult;

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

@@ -0,0 +1,25 @@
+// @ts-expect-error polyfill
+var _Symbol;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+const disposablePromiseTimerResult = Symbol();
+function disposablePromiseTimer(ms) {
+    let timer = null;
+    return {
+        start () {
+            if (timer) {
+                throw new Error('Timer already started');
+            }
+            const promise = new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
+            });
+            return promise;
+        },
+        [Symbol.dispose]: ()=>{
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    };
+}
+
+export { disposablePromiseTimer, disposablePromiseTimerResult };

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

@@ -1 +1 @@
-{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAGA,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,CAqB1C"}
+{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAMA,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,CAmC1C"}

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

@@ -1,39 +1,39 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
-var promiseTimer = require('./promiseTimer.js');
+var disposablePromiseTimer = require('./disposablePromiseTimer.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]();
     // declaration outside the loop for garbage collection reasons
     let result;
+    let nextPromise = iterator.next();
     while(true){
-        const nextPromise = iterator.next();
-        const pingPromise = timer.start().promise.then(()=>PING_RESULT);
+        const pingPromise = disposablePromiseTimer.disposablePromiseTimer(pingIntervalMs);
         try {
             result = await unpromise.Unpromise.race([
                 nextPromise,
-                pingPromise
+                pingPromise.start()
             ]);
+            if (result === disposablePromiseTimer.disposablePromiseTimerResult) {
+                // cancelled
+                yield PING_SYM;
+                continue;
+            }
+            if (result.done) {
+                return result.value;
+            }
+            nextPromise = iterator.next();
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
         } finally{
-            timer.clear();
+            pingPromise[Symbol.dispose]();
         }
-        if (result.done) {
-            return result.value;
-        }
-        yield result.value;
-        timer.reset();
-        // free up reference for garbage collection
-        result = null;
     }
 }
 

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

@@ -1,37 +1,37 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { createPromiseTimer } from './promiseTimer.mjs';
+import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposablePromiseTimer.mjs';
 
 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 = createPromiseTimer(pingIntervalMs);
     const iterator = iterable[Symbol.asyncIterator]();
     // declaration outside the loop for garbage collection reasons
     let result;
+    let nextPromise = iterator.next();
     while(true){
-        const nextPromise = iterator.next();
-        const pingPromise = timer.start().promise.then(()=>PING_RESULT);
+        const pingPromise = disposablePromiseTimer(pingIntervalMs);
         try {
             result = await Unpromise.race([
                 nextPromise,
-                pingPromise
+                pingPromise.start()
             ]);
+            if (result === disposablePromiseTimerResult) {
+                // cancelled
+                yield PING_SYM;
+                continue;
+            }
+            if (result.done) {
+                return result.value;
+            }
+            nextPromise = iterator.next();
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
         } finally{
-            timer.clear();
+            pingPromise[Symbol.dispose]();
         }
-        if (result.done) {
-            return result.value;
-        }
-        yield result.value;
-        timer.reset();
-        // free up reference for garbage collection
-        result = null;
     }
 }
 

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

@@ -0,0 +1,17 @@
+type OnDrain = () => void;
+export interface RefCount {
+    activate(): void;
+}
+export interface RefCountMap<TKey, TValue> extends Map<TKey, TValue>, RefCount {
+}
+export interface RefCountSet<TValue> extends Set<TValue>, RefCount {
+}
+/**
+ * Adds reference counting capabilities to a Map or Set collection.
+ * The collection can be activated, after which it will trigger a drain callback when emptied.
+ * Once drained, the collection cannot be modified further.
+ */
+export declare function withRefCount<TKey, TValue>(map: Map<TKey, TValue>, onDrain: OnDrain): RefCountMap<TKey, TValue>;
+export declare function withRefCount<TValue>(set: Set<TValue>, onDrain: OnDrain): RefCountSet<TValue>;
+export {};
+//# sourceMappingURL=withRefCount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withRefCount.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withRefCount.ts"],"names":[],"mappings":"AACA,KAAK,OAAO,GAAG,MAAM,IAAI,CAAC;AAG1B,MAAM,WAAW,QAAQ;IACvB,QAAQ,IAAI,IAAI,CAAC;CAClB;AAGD,MAAM,WAAW,WAAW,CAAC,IAAI,EAAE,MAAM,CACvC,SAAQ,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,EACvB,QAAQ;CAAG;AAGf,MAAM,WAAW,WAAW,CAAC,MAAM,CAAE,SAAQ,GAAG,CAAC,MAAM,CAAC,EAAE,QAAQ;CAAG;AAErE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EACvC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,EACtB,OAAO,EAAE,OAAO,GACf,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC7B,wBAAgB,YAAY,CAAC,MAAM,EACjC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,EAChB,OAAO,EAAE,OAAO,GACf,WAAW,CAAC,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,59 @@
+'use strict';
+
+// Callback function type that is called when a collection is drained
+function withRefCount(_obj, onDrain) {
+    const obj = _obj;
+    // Track whether the collection has been drained
+    let drained = false;
+    // Track whether the collection has been activated
+    let active = false;
+    // Check if collection should be drained (empty and active)
+    const checkDrain = ()=>{
+        if (!drained && active && obj.size === 0) {
+            onDrain();
+            drained = true;
+        }
+    };
+    // Create proxy to intercept collection operations
+    return new Proxy(obj, {
+        get (_, prop) {
+            // Handle activation
+            if (prop === 'activate') {
+                return ()=>{
+                    active = true;
+                    checkDrain();
+                };
+            }
+            // Handle adding items - prevent if already drained
+            if (prop === 'set' || prop === 'add') {
+                return (...args)=>{
+                    if (drained) {
+                        throw new Error('Already drained');
+                    }
+                    return obj[prop](...args);
+                };
+            }
+            // Handle removing items - check if should drain after
+            if (prop === 'delete' || prop === 'clear') {
+                return (...args)=>{
+                    try {
+                        return obj[prop](...args);
+                    } finally{
+                        checkDrain();
+                    }
+                };
+            }
+            // Pass through other method calls
+            const target = obj[prop];
+            if (typeof target === 'function') {
+                return (...args)=>{
+                    return obj[prop](...args);
+                };
+            }
+            // Pass through property access
+            return target;
+        }
+    });
+}
+
+exports.withRefCount = withRefCount;