@evolu/common 8.0.0-next.5 → 8.0.0

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();
+        },
+    };
+}