@evolu/common 8.0.0-next.4 → 8.0.0

package/dist/src/RefCount.js

@@ -55,87 +55,40 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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 { assert } from "./Assert.js";
+import { disposable, identity } from "./Function.js";
 import { createLookupMap } from "./Lookup.js";
 import { NonNegativeInt, PositiveInt, zeroNonNegativeInt } from "./Type.js";
 /** Creates {@link RefCount}. */
 export const createRefCount = () => {
-    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);
-    }
+    let count = zeroNonNegativeInt;
+    return disposable({
+        increment: () => {
+            const nextCount = PositiveInt.orThrow(count + 1);
+            count = nextCount;
+            return nextCount;
+        },
+        decrement: () => {
+            assert(count > 0, "RefCount must not be decremented below zero.");
+            count = NonNegativeInt.orThrow(count - 1);
+            return count;
+        },
+        getCount: () => count,
+    });
 };
 export function createRefCountByKey({ lookup = identity, } = {}) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_1 = { 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);
-                }
-            }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
-            }
-            finally {
-                __disposeResources(env_3);
-            }
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const refCountByKey = createLookupMap({ lookup });
+        disposer.defer(() => {
+            refCountByKey.clear();
         });
-        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();
-            },
+        return disposable({
+            increment: (key) => refCountByKey.getOrInsertComputed(key, createRefCount).increment(),
             decrement: (key) => {
-                assertNotDisposed(disposables);
-                const refCount = getRefCount(key);
+                const refCount = refCountByKey.get(key);
+                assert(refCount, "RefCount must not be decremented for an untracked key.");
                 const nextCount = refCount.decrement();
                 if (nextCount === 0) {
                     refCountByKey.delete(key);
@@ -143,26 +96,16 @@ export function createRefCountByKey({ lookup = identity, } = {}) {
                 }
                 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(),
-        };
+            getCount: (key) => refCountByKey.get(key)?.getCount() ?? zeroNonNegativeInt,
+            has: (key) => refCountByKey.has(key),
+            keys: () => new Set(refCountByKey.keys()),
+        }, disposer);
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        __disposeResources(env_2);
+        __disposeResources(env_1);
     }
 }

package/dist/src/Relation.d.ts

@@ -3,7 +3,8 @@
  *
  * @module
  */
-import { type Lookup } from "./Lookup.js";
+import { type Lookup } from "./Lookup.ts";
+import { NonNegativeInt, PositiveInt } from "./Type.ts";
 /**
  * Bidirectional relation between two types.
  *
@@ -34,20 +35,33 @@ import { type Lookup } from "./Lookup.js";
  * The input parameter types of `lookupA` and `lookupB` determine which values
  * the returned relation accepts on each side.
  *
- * ### Example
+ * ### Reference identity
  *
  * Use the default identity semantics.
  *
  * ```ts
- * const relation = createRelation<WebSocket, string>();
+ * import { createRelation } from "@evolu/common";
+ *
+ * interface Socket {
+ *   readonly id: string;
+ * }
+ *
+ * const relation = createRelation<Socket, string>();
+ * const socket = { id: "socket-1" };
+ *
  * relation.add(socket, "owner-1");
+ *
+ * expect(relation.has(socket, "owner-1")).toBe(true);
+ * expect(relation.has({ id: "socket-1" }, "owner-1")).toBe(false);
  * ```
  *
- * ### Example
+ * ### Lookup-derived equality
  *
  * Use lookup-derived equality.
  *
  * ```ts
+ * import { createRelation } from "@evolu/common";
+ *
  * interface Person {
  *   readonly id: string;
  *   readonly name: string;
@@ -59,7 +73,10 @@ import { type Lookup } from "./Lookup.js";
  * });
  *
  * relation.add({ id: "1", name: "Ada" }, { id: "admins" });
- * relation.has({ id: "1", name: "Grace" }, { id: "admins" }); // true
+ *
+ * expect(relation.has({ id: "1", name: "Grace" }, { id: "admins" })).toBe(
+ *   true,
+ * );
  * ```
  *
  * @see {@link createRelation}
@@ -131,4 +148,52 @@ export interface CreateRelationOptions<A, B, LA = A, LB = B> {
 /** Creates a {@link Relation}. */
 export declare function createRelation<A, B>(): Relation<A, B>;
 export declare function createRelation<A, B, LA, LB>(options: CreateRelationOptions<A, B, LA, LB>): Relation<A, B>;
+/**
+ * Bidirectional relation with a positive retain count for every active pair.
+ *
+ * Logical equality and canonical representatives follow the same lookup rules
+ * as {@link Relation}. The first active representative on each side remains
+ * canonical until that value has no active pairs. Increment and decrement
+ * return those representatives so callers can reliably handle pair transitions
+ * without repeating lookup or canonicalization logic.
+ *
+ * Unlike {@link Relation}'s live iterators, directional and entry reads return
+ * snapshots so callers can mutate this relation while iterating. Their order
+ * follows first insertion of the current canonical representatives and pairs.
+ */
+export interface RefCountedRelation<A, B> {
+    /** Increments a pair count and returns its canonical values and new count. */
+    readonly increment: (a: A, b: B) => {
+        readonly a: A;
+        readonly b: B;
+        readonly count: PositiveInt;
+    };
+    /**
+     * Decrements a pair count and returns its canonical values and new count.
+     * Decrementing a missing pair is a programmer error checked with
+     * {@link assert}.
+     */
+    readonly decrement: (a: A, b: B) => {
+        readonly a: A;
+        readonly b: B;
+        readonly count: NonNegativeInt;
+    };
+    /** Returns the pair count, or zero when the pair is absent. */
+    readonly getCount: (a: A, b: B) => NonNegativeInt;
+    /** Returns a snapshot of canonical A values related to `b`. */
+    readonly getAs: (b: B) => ReadonlyArray<A>;
+    /** Returns a snapshot of canonical B values related to `a`. */
+    readonly getBs: (a: A) => ReadonlyArray<B>;
+    /** Returns whether an A value has at least one active pair. */
+    readonly hasA: (a: A) => boolean;
+    /** Returns whether a B value has at least one active pair. */
+    readonly hasB: (b: B) => boolean;
+    /** Returns a snapshot of every canonical pair and its positive count. */
+    readonly getEntries: () => ReadonlyArray<readonly [a: A, b: B, count: PositiveInt]>;
+    /** Removes all pair counts and both directional indexes. */
+    readonly clear: () => void;
+}
+/** Creates a {@link RefCountedRelation}. */
+export declare function createRefCountedRelation<A, B>(): RefCountedRelation<A, B>;
+export declare function createRefCountedRelation<A, B, LA, LB>(options: CreateRelationOptions<A, B, LA, LB>): RefCountedRelation<A, B>;
 //# sourceMappingURL=Relation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Relation.d.ts","sourceRoot":"","sources":["../../src/Relation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEtC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEzC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEtC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEtC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAEjD;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAEjD;;;OAGG;IACH,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,gBAAgB,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAEpE,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEtC,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEjC,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAEjC,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAE3B,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;IAE9B,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;IAE9B,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;IAEtC,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;IAEtC,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC;IACzD,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAEjC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;CAClC;AAED,kCAAkC;AAClC,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACzC,OAAO,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC3C,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"Relation.d.ts","sourceRoot":"","sources":["../../src/Relation.ts"],"names":[],"mappings":"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"}

package/dist/src/Relation.js

@@ -7,13 +7,13 @@ import { emptyArray } from "./Array.js";
 import { assert } from "./Assert.js";
 import { identity } from "./Function.js";
 import { createLookupMap, createLookupSet, } from "./Lookup.js";
+import { NonNegativeInt, onePositiveInt, PositiveInt, zeroNonNegativeInt, } from "./Type.js";
 export function createRelation({ lookupA = identity, lookupB = identity, } = {}) {
     const bByA = createLookupMap({ lookup: lookupA });
     const aByB = createLookupMap({ lookup: lookupB });
     let sizeInternal = 0;
     const removePair = (a, b) => {
         const relatedB = bByA.get(a);
-        // This should only fail if a leaked view was mutated via an unsafe cast.
         assertRelationMappingConsistency(relatedB);
         assertRelationMappingConsistency(relatedB.has(b));
         relatedB.delete(b);
@@ -21,7 +21,6 @@ export function createRelation({ lookupA = identity, lookupB = identity, } = {})
             bByA.delete(a);
         }
         const relatedA = aByB.get(b);
-        // This should only fail if a leaked view was mutated via an unsafe cast.
         assertRelationMappingConsistency(relatedA);
         assertRelationMappingConsistency(relatedA.has(a));
         relatedA.delete(a);
@@ -100,6 +99,82 @@ export function createRelation({ lookupA = identity, lookupB = identity, } = {})
         size: () => sizeInternal,
     };
 }
+// This can fail if a lookup function violates its pure and stable contract.
 const assertRelationMappingConsistency = (condition) => {
     assert(condition, "Relation mapping inconsistency");
 };
+export function createRefCountedRelation({ lookupA = identity, lookupB = identity, } = {}) {
+    const relatedBsByA = createLookupMap({ lookup: lookupA });
+    const relatedAsByB = createLookupMap({ lookup: lookupB });
+    return {
+        increment: (a, b) => {
+            let relatedBs = relatedBsByA.get(a);
+            const canonicalA = relatedBs ? relatedBs.a : a;
+            const relatedAs = relatedAsByB.get(b);
+            const canonicalB = relatedAs ? relatedAs.b : b;
+            if (!relatedBs) {
+                relatedBs = {
+                    a: canonicalA,
+                    countsByB: createLookupMap({ lookup: lookupB }),
+                };
+                relatedBsByA.set(canonicalA, relatedBs);
+            }
+            const count = relatedBs.countsByB.get(canonicalB);
+            if (count) {
+                const nextCount = PositiveInt.orThrow(count + 1);
+                relatedBs.countsByB.set(canonicalB, nextCount);
+                return { a: canonicalA, b: canonicalB, count: nextCount };
+            }
+            relatedBs.countsByB.set(canonicalB, onePositiveInt);
+            if (relatedAs) {
+                relatedAs.as.add(canonicalA);
+            }
+            else {
+                relatedAsByB.set(canonicalB, {
+                    b: canonicalB,
+                    as: createLookupSet({
+                        lookup: lookupA,
+                        values: [canonicalA],
+                    }),
+                });
+            }
+            return { a: canonicalA, b: canonicalB, count: onePositiveInt };
+        },
+        decrement: (a, b) => {
+            const relatedBs = relatedBsByA.get(a);
+            const relatedAs = relatedAsByB.get(b);
+            const count = relatedBs?.countsByB.get(b);
+            assert(relatedBs && relatedAs && count, "RefCountedRelation pair must exist before decrement.");
+            const nextCount = NonNegativeInt.orThrow(count - 1);
+            if (nextCount > 0) {
+                relatedBs.countsByB.set(relatedAs.b, PositiveInt.orThrow(nextCount));
+            }
+            else {
+                relatedBs.countsByB.delete(relatedAs.b);
+                if (relatedBs.countsByB.size === 0)
+                    relatedBsByA.delete(relatedBs.a);
+                relatedAs.as.delete(relatedBs.a);
+                if (relatedAs.as.size === 0)
+                    relatedAsByB.delete(relatedAs.b);
+            }
+            return { a: relatedBs.a, b: relatedAs.b, count: nextCount };
+        },
+        getCount: (a, b) => relatedBsByA.get(a)?.countsByB.get(b) ?? zeroNonNegativeInt,
+        getAs: (b) => [...(relatedAsByB.get(b)?.as ?? emptyArray)],
+        getBs: (a) => [...(relatedBsByA.get(a)?.countsByB.keys() ?? emptyArray)],
+        hasA: (a) => relatedBsByA.has(a),
+        hasB: (b) => relatedAsByB.has(b),
+        getEntries: () => {
+            const entries = [];
+            for (const { a, countsByB } of relatedBsByA.values()) {
+                for (const [b, count] of countsByB)
+                    entries.push([a, b, count]);
+            }
+            return entries;
+        },
+        clear: () => {
+            relatedBsByA.clear();
+            relatedAsByB.clear();
+        },
+    };
+}