@evolu/common 8.0.0-next.2 → 8.0.0-next.4

package/dist/src/Assert.d.ts

@@ -94,11 +94,11 @@ export declare function assertNotAborted<T, E>(result: Result<T, E | AbortError>
  * ### Example
  *
  * ```ts
- * const stack = new globalThis.AsyncDisposableStack();
- * assertNotDisposed(stack); // no-op
- * await stack.disposeAsync();
- * assertNotDisposed(stack); // throws Error
+ * using disposer = new globalThis.AsyncDisposableStack();
+ * assertNotDisposed(disposer); // no-op
+ * await disposer.disposeAsync();
+ * assertNotDisposed(disposer); // throws Error
  * ```
  */
-export declare const assertNotDisposed: (value: globalThis.DisposableStack | globalThis.AsyncDisposableStack) => void;
+export declare const assertNotDisposed: (value: DisposableStack | AsyncDisposableStack) => void;
 //# sourceMappingURL=Assert.d.ts.map

package/dist/src/Assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Assert.d.ts","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAQ,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE,CACnB,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,SAIZ,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAClC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EACb,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAKlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,EAC1C,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EACrB,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAK3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,SAAS,OAAO,EACzC,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC,CAEhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,EAC7B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3B,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EACjC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAYlC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,UAAU,CAAC,eAAe,GAAG,UAAU,CAAC,oBAAoB,KAClE,IAEF,CAAC"}
+{"version":3,"file":"Assert.d.ts","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAQ,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE,CACnB,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,SAIZ,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAClC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EACb,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAKlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,EAC1C,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EACrB,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAK3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,SAAS,OAAO,EACzC,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC,CAEhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,EAC7B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3B,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EACjC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAYlC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,eAAe,GAAG,oBAAoB,KAC5C,IAEF,CAAC"}

package/dist/src/Assert.js

@@ -90,10 +90,10 @@ export function assertNotAborted(result, message = "Expected result to not be ab
  * ### Example
  *
  * ```ts
- * const stack = new globalThis.AsyncDisposableStack();
- * assertNotDisposed(stack); // no-op
- * await stack.disposeAsync();
- * assertNotDisposed(stack); // throws Error
+ * using disposer = new globalThis.AsyncDisposableStack();
+ * assertNotDisposed(disposer); // no-op
+ * await disposer.disposeAsync();
+ * assertNotDisposed(disposer); // throws Error
  * ```
  */
 export const assertNotDisposed = (value) => {

package/dist/src/Identicon.js

@@ -106,15 +106,15 @@ export const createIdenticon = (id, style = "github") => {
         case "sutnar": {
             // Three compositional variants with adaptive colors.
             const hue = (bytes[0] / 255) * 360;
-            const saturation = 50 + (bytes[1] / 255) * 30;
-            const lightness = 50 + (bytes[2] / 255) * 20;
+            const saturation = 60 + (bytes[1] / 255) * 30;
+            const lightness = 35 + (bytes[2] / 255) * 20;
             // Generate palette from base hue with variations
             const toHsl = (h, s, l) => `hsl(${h},${s}%,${l}%)`;
             const color1 = toHsl(hue, saturation, lightness);
             const color2 = toHsl((hue + 120) % 360, saturation, lightness);
             const color3 = toHsl((hue + 240) % 360, saturation, lightness);
-            const color4 = toHsl(hue, saturation * 0.3, lightness * 0.5);
-            const color5 = toHsl(hue, saturation * 0.5, Math.min(lightness * 1.3, 90));
+            const color4 = toHsl(hue, saturation * 0.5, lightness * 0.6);
+            const color5 = toHsl(hue, saturation * 0.5, Math.min(lightness * 1.3, 60));
             const palette = [color1, color2, color3, color4, color5];
             // Layout variant based on first byte.
             const variant = bytes[3] % 3;

package/dist/src/LockManager.d.ts

@@ -0,0 +1,74 @@
+/**
+ * {@link LockManager} helpers.
+ *
+ * @module
+ */
+import { AbortError, type Task } from "./Task.js";
+import type { Callback } from "./Types.js";
+/**
+ * Dependency wrapper for {@link LockManager}.
+ *
+ * For React Native, use the `lockManager` ponyfill from `@evolu/react-native`.
+ * For tests, use {@link testCreateLockManager}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Web or Node.js 24+
+ * import { testCreateLockManager } from "@evolu/common";
+ *
+ * const deps: LockManagerDep = {
+ *   lockManager: testCreateLockManager(),
+ * };
+ * ```
+ *
+ * ### Example
+ *
+ * ```ts
+ * // React Native
+ * import { lockManager } from "@evolu/react-native";
+ *
+ * const deps: LockManagerDep = { lockManager };
+ * ```
+ */
+export interface LockManagerDep {
+    readonly lockManager: LockManager;
+}
+/**
+ * Creates a test {@link LockManager} backed by the native platform
+ * {@link LockManager}.
+ *
+ * Native backing is intentional: tests must observe the same locking behavior
+ * as the platform runtime, and a userland implementation cannot reproduce it.
+ *
+ * The platform `LockManager` cannot be instantiated, so tests cannot create an
+ * isolated native lock per case. This helper isolates lock usage per instance
+ * via internal namespacing, so tests can reuse the same lock names without
+ * contending through the global Web Locks. Query results are filtered to that
+ * private namespace and returned with the original visible names.
+ */
+export declare const testCreateLockManager: (nativeLockManager?: LockManager) => LockManager;
+/**
+ * Competes to become the current leader for `name` using {@link LockManager}.
+ *
+ * Only one caller can lead for a given name at a time, and the returned
+ * {@link AsyncDisposable} represents that leadership.
+ *
+ * Leadership is held until the returned handle is disposed. Once released,
+ * another waiting caller may become the next leader. Waiting for leadership is
+ * abortable via the calling {@link Task}'s signal.
+ */
+export declare const acquireLeaderLock: (name: string) => Task<AsyncDisposable, AbortError, LockManagerDep>;
+/**
+ * Competes to become the current leader for `name` using {@link LockManager}.
+ *
+ * Only one caller can lead for a given name at a time. The callback runs when
+ * leadership is acquired, and the returned {@link Disposable} represents that
+ * leadership request.
+ *
+ * Leadership is held until the returned handle is disposed. Once released,
+ * another waiting caller may become the next leader. Waiting for leadership is
+ * abortable by disposing the returned handle.
+ */
+export declare const acquireLeaderLockCallback: (deps: LockManagerDep) => (name: string, callback: Callback<void>) => Disposable;
+//# sourceMappingURL=LockManager.d.ts.map

package/dist/src/LockManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockManager.d.ts","sourceRoot":"","sources":["../../src/LockManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,GAChC,oBAAmB,WAAwC,KAC1D,WAwCF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC3B,MAAM,MAAM,KAAG,IAAI,CAAC,eAAe,EAAE,UAAU,EAAE,cAAc,CA4B7D,CAAC;AAEN;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GACnC,MAAM,cAAc,MACpB,MAAM,MAAM,EAAE,UAAU,QAAQ,CAAC,IAAI,CAAC,KAAG,UAsBzC,CAAC"}

package/dist/src/LockManager.js

@@ -0,0 +1,103 @@
+/**
+ * {@link LockManager} helpers.
+ *
+ * @module
+ */
+import { createRandomBytes } from "./Crypto.js";
+import { lazyVoid } from "./Function.js";
+import { tryAsync } from "./Result.js";
+import { AbortError } from "./Task.js";
+import { createId } from "./Type.js";
+/**
+ * Creates a test {@link LockManager} backed by the native platform
+ * {@link LockManager}.
+ *
+ * Native backing is intentional: tests must observe the same locking behavior
+ * as the platform runtime, and a userland implementation cannot reproduce it.
+ *
+ * The platform `LockManager` cannot be instantiated, so tests cannot create an
+ * isolated native lock per case. This helper isolates lock usage per instance
+ * via internal namespacing, so tests can reuse the same lock names without
+ * contending through the global Web Locks. Query results are filtered to that
+ * private namespace and returned with the original visible names.
+ */
+export const testCreateLockManager = (nativeLockManager = globalThis.navigator.locks) => {
+    const namespace = createId({ randomBytes: createRandomBytes() });
+    const filterLockInfosByNamespace = (locks) => locks.flatMap((lock) => lock.name?.endsWith(namespace) === true
+        ? [{ ...lock, name: lock.name.slice(0, -namespace.length) }]
+        : []);
+    return {
+        request: (name, optionsOrCallback, maybeCallback) => {
+            const [options, callback] = typeof optionsOrCallback === "function"
+                ? [{}, optionsOrCallback]
+                : [optionsOrCallback, maybeCallback];
+            return nativeLockManager.request(`${name}${namespace}`, options, (lock) => callback(lock && { mode: lock.mode, name }));
+        },
+        query: async () => {
+            const locks = await nativeLockManager.query();
+            return {
+                ...(locks.held && {
+                    held: filterLockInfosByNamespace(locks.held),
+                }),
+                ...(locks.pending && {
+                    pending: filterLockInfosByNamespace(locks.pending),
+                }),
+            };
+        },
+    };
+};
+/**
+ * Competes to become the current leader for `name` using {@link LockManager}.
+ *
+ * Only one caller can lead for a given name at a time, and the returned
+ * {@link AsyncDisposable} represents that leadership.
+ *
+ * Leadership is held until the returned handle is disposed. Once released,
+ * another waiting caller may become the next leader. Waiting for leadership is
+ * abortable via the calling {@link Task}'s signal.
+ */
+export const acquireLeaderLock = (name) => (run) => tryAsync(async () => {
+    const acquisition = Promise.withResolvers();
+    const released = Promise.withResolvers();
+    const request = run.deps.lockManager.request(createLeaderLockName(name), { mode: "exclusive", signal: run.signal }, async () => {
+        acquisition.resolve();
+        await released.promise;
+    });
+    void request.catch(acquisition.reject);
+    await acquisition.promise;
+    return {
+        [Symbol.asyncDispose]: async () => {
+            released.resolve();
+            await request;
+        },
+    };
+}, (error) => AbortError.is(error) ? error : { type: "AbortError", reason: error });
+/**
+ * Competes to become the current leader for `name` using {@link LockManager}.
+ *
+ * Only one caller can lead for a given name at a time. The callback runs when
+ * leadership is acquired, and the returned {@link Disposable} represents that
+ * leadership request.
+ *
+ * Leadership is held until the returned handle is disposed. Once released,
+ * another waiting caller may become the next leader. Waiting for leadership is
+ * abortable by disposing the returned handle.
+ */
+export const acquireLeaderLockCallback = (deps) => (name, callback) => {
+    const abortController = new AbortController();
+    let release = null;
+    const request = deps.lockManager.request(createLeaderLockName(name), { mode: "exclusive", signal: abortController.signal }, async () => {
+        const released = Promise.withResolvers();
+        release = released.resolve;
+        callback();
+        await released.promise;
+    });
+    void request.catch(lazyVoid);
+    return {
+        [Symbol.dispose]: () => {
+            abortController.abort();
+            release?.();
+        },
+    };
+};
+const createLeaderLockName = (name) => `evolu-leaderlock-${name}`;

package/dist/src/Microtask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Microtask.d.ts","sourceRoot":"","sources":["../../src/Microtask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU;IACnD,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAEjC,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED,sCAAsC;AACtC,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,SAAS,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,KACjD,cAAc,CAAC,CAAC,CAgClB,CAAC"}
+{"version":3,"file":"Microtask.d.ts","sourceRoot":"","sources":["../../src/Microtask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGvE;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU;IACnD,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAEjC,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED,sCAAsC;AACtC,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,SAAS,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,KACjD,cAAc,CAAC,CAAC,CAqClB,CAAC"}

package/dist/src/Microtask.js

@@ -3,35 +3,99 @@
  *
  * @module
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (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;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (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();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { appendToArray } from "./Array.js";
+import { assertNotDisposed } from "./Assert.js";
 /** Creates {@link MicrotaskBatch}. */
 export const createMicrotaskBatch = (onFlush) => {
-    let queue = null;
-    let disposed = false;
-    const flushNow = () => {
-        if (disposed || queue == null)
-            return;
-        const queuedItems = queue;
-        queue = null;
-        onFlush(queuedItems);
-    };
-    return {
-        push: (item) => {
-            if (disposed)
-                return;
-            if (queue == null) {
-                queue = [item];
-                queueMicrotask(flushNow);
-                return;
-            }
-            queue = appendToArray(queue, item);
-        },
-        flushNow,
-        [Symbol.dispose]: () => {
-            if (disposed)
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        let queue = null;
+        disposer.defer(() => {
+            queue = null;
+        });
+        const disposables = disposer.move();
+        const flushQueuedItems = () => {
+            if (queue == null)
                 return;
-            disposed = true;
+            const queuedItems = queue;
             queue = null;
-        },
-    };
+            onFlush(queuedItems);
+        };
+        return {
+            push: (item) => {
+                assertNotDisposed(disposables);
+                if (queue == null) {
+                    queue = [item];
+                    queueMicrotask(flushQueuedItems);
+                    return;
+                }
+                queue = appendToArray(queue, item);
+            },
+            flushNow: () => {
+                assertNotDisposed(disposables);
+                flushQueuedItems();
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };

package/dist/src/Object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Object.d.ts","sourceRoot":"","sources":["../../src/Object.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Object.d.ts","sourceRoot":"","sources":["../../src/Object.ts"],"names":[],"mappings":"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"}

package/dist/src/RefCount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RefCount.d.ts","sourceRoot":"","sources":["../../src/RefCount.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,WAAW,EAAsB,MAAM,WAAW,CAAC;AAE5E;;;;GAIG;AACH,MAAM,WAAW,QAAS,SAAQ,UAAU;IAC1C,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,WAAW,CAAC;IAEtC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,cAAc,CAAC;IAEzC,iCAAiC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,cAAc,CAAC;IAExC,uEAAuE;IACvE,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACvC;AAED,gCAAgC;AAChC,eAAO,MAAM,cAAc,QAAO,QA8BjC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI,CAAE,SAAQ,UAAU;IACrD,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,WAAW,CAAC;IAE/C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,cAAc,CAAC;IAElD,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,cAAc,CAAC;IAEjD,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAO,CAAC;IAErC,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC;IAEvC,uEAAuE;IACvE,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACvC;AAED,+CAA+C;AAC/C,MAAM,WAAW,0BAA0B,CACzC,IAAI,EACJ,CAAC,GAAG,IAAI,CACR,SAAQ,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;CAAG;AAElC,qCAAqC;AACrC,wBAAgB,mBAAmB,CAAC,IAAI,GAAG,OAAO,KAAK,aAAa,CAAC,IAAI,CAAC,CAAC;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,EACzC,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,CAAC,CAAC,GAC3C,aAAa,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"RefCount.d.ts","sourceRoot":"","sources":["../../src/RefCount.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,WAAW,EAAsB,MAAM,WAAW,CAAC;AAE5E;;;;GAIG;AACH,MAAM,WAAW,QAAS,SAAQ,UAAU;IAC1C,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,WAAW,CAAC;IAEtC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,cAAc,CAAC;IAEzC,iCAAiC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,cAAc,CAAC;IAExC,uEAAuE;IACvE,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACvC;AAED,gCAAgC;AAChC,eAAO,MAAM,cAAc,QAAO,QA4BjC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI,CAAE,SAAQ,UAAU;IACrD,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,WAAW,CAAC;IAE/C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,cAAc,CAAC;IAElD,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,cAAc,CAAC;IAEjD,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAO,CAAC;IAErC,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC;IAEvC,uEAAuE;IACvE,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACvC;AAED,+CAA+C;AAC/C,MAAM,WAAW,0BAA0B,CACzC,IAAI,EACJ,CAAC,GAAG,IAAI,CACR,SAAQ,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;CAAG;AAElC,qCAAqC;AACrC,wBAAgB,mBAAmB,CAAC,IAAI,GAAG,OAAO,KAAK,aAAa,CAAC,IAAI,CAAC,CAAC;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,EACzC,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,CAAC,CAAC,GAC3C,aAAa,CAAC,IAAI,CAAC,CAAC"}

package/dist/src/RefCount.js

@@ -3,81 +3,166 @@
  *
  * @module
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (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;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (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();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { assert, assertNotDisposed } from "./Assert.js";
 import { identity } from "./Function.js";
 import { createLookupMap } from "./Lookup.js";
 import { NonNegativeInt, PositiveInt, zeroNonNegativeInt } from "./Type.js";
 /** Creates {@link RefCount}. */
 export const createRefCount = () => {
-    let count = zeroNonNegativeInt;
-    const stack = new DisposableStack();
-    stack.defer(() => {
-        count = zeroNonNegativeInt;
-    });
-    const moved = stack.move();
-    return {
-        increment: () => {
-            assertNotDisposed(moved);
-            const nextCount = PositiveInt.orThrow(count + 1);
-            count = nextCount;
-            return nextCount;
-        },
-        decrement: () => {
-            assertNotDisposed(moved);
-            assert(count > 0, "RefCount must not be decremented below zero.");
-            count = NonNegativeInt.orThrow(count - 1);
-            return count;
-        },
-        getCount: () => {
-            assertNotDisposed(moved);
-            return count;
-        },
-        [Symbol.dispose]: () => moved.dispose(),
-    };
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // We use DisposableStack only because of assertNotDisposed.
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        let count = zeroNonNegativeInt;
+        const disposables = disposer.move();
+        return {
+            increment: () => {
+                assertNotDisposed(disposables);
+                const nextCount = PositiveInt.orThrow(count + 1);
+                count = nextCount;
+                return nextCount;
+            },
+            decrement: () => {
+                assertNotDisposed(disposables);
+                assert(count > 0, "RefCount must not be decremented below zero.");
+                count = NonNegativeInt.orThrow(count - 1);
+                return count;
+            },
+            getCount: () => {
+                assertNotDisposed(disposables);
+                return count;
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };
 export function createRefCountByKey({ lookup = identity, } = {}) {
-    const stack = new DisposableStack();
-    const refCountByKey = stack.adopt(createLookupMap({ lookup }), (refCountByKey) => {
-        for (const refCount of refCountByKey.values())
-            refCount[Symbol.dispose]();
-        refCountByKey.clear();
-    });
-    const moved = stack.move();
-    const getRefCount = (key) => {
-        let refCount = refCountByKey.get(key);
-        if (!refCount) {
-            refCount = createRefCount();
-            refCountByKey.set(key, refCount);
-        }
-        return refCount;
-    };
-    return {
-        increment: (key) => {
-            assertNotDisposed(moved);
-            return getRefCount(key).increment();
-        },
-        decrement: (key) => {
-            assertNotDisposed(moved);
-            const refCount = getRefCount(key);
-            const nextCount = refCount.decrement();
-            if (nextCount === 0) {
-                refCount[Symbol.dispose]();
-                refCountByKey.delete(key);
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        // We use DisposableStack only because of assertNotDisposed.
+        const disposer = __addDisposableResource(env_2, new DisposableStack(), false);
+        const refCountByKey = disposer.adopt(createLookupMap({ lookup }), (refCountByKey) => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const disposer = __addDisposableResource(env_3, new DisposableStack(), false);
+                disposer.defer(() => {
+                    refCountByKey.clear();
+                });
+                for (const refCount of refCountByKey.values()) {
+                    disposer.use(refCount);
+                }
             }
-            return nextCount;
-        },
-        getCount: (key) => {
-            assertNotDisposed(moved);
-            return refCountByKey.get(key)?.getCount() ?? zeroNonNegativeInt;
-        },
-        has: (key) => {
-            assertNotDisposed(moved);
-            return refCountByKey.has(key);
-        },
-        keys: () => {
-            assertNotDisposed(moved);
-            return new Set(refCountByKey.keys());
-        },
-        [Symbol.dispose]: () => moved.dispose(),
-    };
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        });
+        const disposables = disposer.move();
+        const getRefCount = (key) => {
+            let refCount = refCountByKey.get(key);
+            if (!refCount) {
+                refCount = createRefCount();
+                refCountByKey.set(key, refCount);
+            }
+            return refCount;
+        };
+        return {
+            increment: (key) => {
+                assertNotDisposed(disposables);
+                return getRefCount(key).increment();
+            },
+            decrement: (key) => {
+                assertNotDisposed(disposables);
+                const refCount = getRefCount(key);
+                const nextCount = refCount.decrement();
+                if (nextCount === 0) {
+                    refCountByKey.delete(key);
+                    refCount[Symbol.dispose]();
+                }
+                return nextCount;
+            },
+            getCount: (key) => {
+                assertNotDisposed(disposables);
+                return refCountByKey.get(key)?.getCount() ?? zeroNonNegativeInt;
+            },
+            has: (key) => {
+                assertNotDisposed(disposables);
+                return refCountByKey.has(key);
+            },
+            keys: () => {
+                assertNotDisposed(disposables);
+                return new Set(refCountByKey.keys());
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 }