@absolutejs/sync 0.13.0 → 0.15.0

package/README.md

@@ -418,14 +418,17 @@ mutate({
 
 Conflict-free replicated data types — pure, **zero-dependency**, and isomorphic (same code client and server). They merge concurrent edits from different tabs/devices without a server round-trip per keystroke and without clobbering: every `merge` is commutative, associative, and idempotent, so replicas converge no matter the order. They ride the existing engine with no engine changes — store the CRDT state as a row field. The declarative path is one line each end: server `engine.registerCrdt(table, { field: rgaText })` (auto-merges that field on write), client `useCollaborativeText({ collection, id, field, url })`. The primitives below are also usable directly.
 
-| Export                                       | What it is                                                                                                                                                                                                                                                                                           |
-| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `counter`                                    | PN-counter: `create/value/increment/decrement/merge`. Concurrent increments and decrements across replicas all survive.                                                                                                                                                                              |
-| `lww`                                        | Last-write-wins register: `create/set/merge`. The latest timestamp wins (replica id breaks ties) — for "just take the newest value" fields.                                                                                                                                                          |
-| `createTextCrdt(replica, initial?)`          | Collaborative text (an RGA sequence CRDT): `text/insert/delete/setText/merge/state` + `takeDelta`. Drive it via `setText`; apply remote state via `merge`; `takeDelta()` returns just this client's new ops (a delta-state) so uploads are O(edit), not O(doc). Concurrent edits merge and converge. |
-| `textOf(state)` / `mergeTextState(a, b)`     | Pure helpers for the text state — use them server-side (e.g. a merge-on-write mutation) with no live instance.                                                                                                                                                                                       |
-| `compact(state)` / `tombstoneCount(state)`   | Bound state growth: `compact` drops tombstones no live text anchors to (visible text unchanged); `tombstoneCount` is the metric to decide when. Run server-side on the stored state past a threshold; clients adopt the compacted state on the next broadcast.                                       |
-| `CrdtText<State>` / `TextCrdtAdapter<State>` | The pluggable collaborative-text contract. `rgaText` is the first-party (zero-dep) backend; swap in an adapter from the `sync-adapters` repo (e.g. `@absolutejs/sync-yjs`, which wraps the Yjs staple) behind the same call sites.                                                                   |
+| Export                                       | What it is                                                                                                                                                                                                                                                                                                                                                                                          |
+| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `counter`                                    | PN-counter: `create/value/increment/decrement/merge`. Concurrent increments and decrements across replicas all survive.                                                                                                                                                                                                                                                                             |
+| `lww`                                        | Last-write-wins register: `create/set/merge`. The latest timestamp wins (replica id breaks ties) — for "just take the newest value" fields.                                                                                                                                                                                                                                                         |
+| `orSet`                                      | Observed-remove set: `create/add/remove/has/values/merge`. Concurrent add/remove resolves **add-wins** (each add gets a unique tag; remove retracts only observed tags) — for collaborative tags/labels/memberships.                                                                                                                                                                                |
+| `lwwMap`                                     | Last-write-wins map: `create/set/get/delete/has/keys/entries/merge`. Each key is an independent LWW register; `delete` is a tombstone that can lose to a later concurrent `set` — for collaborative key→value records.                                                                                                                                                                              |
+| `createList(replica, initial?)`              | Ordered list CRDT (the RGA over arbitrary items): `list/insert/delete/merge/state/takeDelta` (+ `listOf`/`mergeListState`). Concurrent inserts/deletes at any position merge and converge — for collaborative reorderable lists.                                                                                                                                                                    |
+| `createTextCrdt(replica, initial?)`          | Collaborative text (an RGA sequence CRDT): `text/insert/delete/setText/merge/state` + `takeDelta` + `anchorAt`/`indexOfAnchor`. `takeDelta()` returns just this client's new ops (delta-state) so uploads are O(edit), not O(doc); `anchorAt`/`indexOfAnchor` give a caret a stable element-id anchor for collaborative cursors that survive concurrent edits. Concurrent edits merge and converge. |
+| `textOf(state)` / `mergeTextState(a, b)`     | Pure helpers for the text state — use them server-side (e.g. a merge-on-write mutation) with no live instance.                                                                                                                                                                                                                                                                                      |
+| `compact(state)` / `tombstoneCount(state)`   | Bound state growth: `compact` drops tombstones no live text anchors to (visible text unchanged); `tombstoneCount` is the metric to decide when. Run server-side on the stored state past a threshold; clients adopt the compacted state on the next broadcast.                                                                                                                                      |
+| `CrdtText<State>` / `TextCrdtAdapter<State>` | The pluggable collaborative-text contract. `rgaText` is the first-party (zero-dep) backend; swap in an adapter from the `sync-adapters` repo (e.g. `@absolutejs/sync-yjs`, which wraps the Yjs staple) behind the same call sites.                                                                                                                                                                  |
 
 ### `@absolutejs/sync/postgres`
 

package/dist/angular/index.js

@@ -68,6 +68,203 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
+// src/crdt/orSet.ts
+var newTag = () => globalThis.crypto.randomUUID();
+var defaultEquals = (a, b) => Object.is(a, b);
+var orSet = {
+  create: () => ({ adds: [], removed: [] }),
+  add: (state, value, tag = newTag()) => ({
+    adds: [...state.adds, { value, tag }],
+    removed: state.removed
+  }),
+  remove: (state, value, equals = defaultEquals) => {
+    const tags = state.adds.filter((entry) => equals(entry.value, value)).map((entry) => entry.tag);
+    return {
+      adds: state.adds,
+      removed: [...new Set([...state.removed, ...tags])]
+    };
+  },
+  has: (state, value, equals = defaultEquals) => {
+    const removed = new Set(state.removed);
+    return state.adds.some((entry) => equals(entry.value, value) && !removed.has(entry.tag));
+  },
+  values: (state, equals = defaultEquals) => {
+    const removed = new Set(state.removed);
+    const out = [];
+    for (const entry of state.adds) {
+      if (!removed.has(entry.tag) && !out.some((value) => equals(value, entry.value))) {
+        out.push(entry.value);
+      }
+    }
+    return out;
+  },
+  merge: (a, b) => {
+    const byTag = new Map;
+    for (const entry of [...a.adds, ...b.adds]) {
+      byTag.set(entry.tag, entry);
+    }
+    return {
+      adds: [...byTag.values()],
+      removed: [...new Set([...a.removed, ...b.removed])]
+    };
+  }
+};
+// src/crdt/lwwMap.ts
+var pick = (a, b) => {
+  if (b.timestamp > a.timestamp) {
+    return b;
+  }
+  if (b.timestamp < a.timestamp) {
+    return a;
+  }
+  return b.replica > a.replica ? b : a;
+};
+var lwwMap = {
+  create: () => ({}),
+  set: (state, key, value, replica, timestamp = Date.now()) => ({
+    ...state,
+    [key]: { value, deleted: false, timestamp, replica }
+  }),
+  delete: (state, key, replica, timestamp = Date.now()) => ({
+    ...state,
+    [key]: { value: state[key]?.value, deleted: true, timestamp, replica }
+  }),
+  get: (state, key) => {
+    const entry = state[key];
+    return entry !== undefined && !entry.deleted ? entry.value : undefined;
+  },
+  has: (state, key) => {
+    const entry = state[key];
+    return entry !== undefined && !entry.deleted;
+  },
+  keys: (state) => Object.keys(state).filter((key) => !state[key]?.deleted),
+  entries: (state) => {
+    const out = [];
+    for (const [key, entry] of Object.entries(state)) {
+      if (!entry.deleted && entry.value !== undefined) {
+        out.push([key, entry.value]);
+      }
+    }
+    return out;
+  },
+  merge: (a, b) => {
+    const out = { ...a };
+    for (const [key, entry] of Object.entries(b)) {
+      const existing = out[key];
+      out[key] = existing === undefined ? entry : pick(existing, entry);
+    }
+    return out;
+  }
+};
+// src/crdt/list.ts
+var order = (a, b) => {
+  if (a.clock !== b.clock) {
+    return b.clock - a.clock;
+  }
+  if (a.replica === b.replica) {
+    return 0;
+  }
+  return a.replica > b.replica ? -1 : 1;
+};
+var linearize = (elements) => {
+  const present = new Set(elements.map((element) => element.id));
+  const children = new Map;
+  for (const element of elements) {
+    const anchor = element.after !== null && !present.has(element.after) ? null : element.after;
+    const list = children.get(anchor);
+    if (list === undefined) {
+      children.set(anchor, [element]);
+    } else {
+      list.push(element);
+    }
+  }
+  for (const list of children.values()) {
+    list.sort(order);
+  }
+  const ordered = [];
+  const stack = [...children.get(null) ?? []].reverse();
+  while (stack.length > 0) {
+    const element = stack.pop();
+    ordered.push(element);
+    const kids = children.get(element.id);
+    if (kids !== undefined) {
+      for (let index = kids.length - 1;index >= 0; index -= 1) {
+        stack.push(kids[index]);
+      }
+    }
+  }
+  return ordered;
+};
+var listOf = (state) => linearize(state.elements).filter((element) => !element.deleted).map((element) => element.value);
+var mergeListState = (a, b) => {
+  const byId = new Map;
+  for (const element of [...a.elements, ...b.elements]) {
+    const existing = byId.get(element.id);
+    byId.set(element.id, existing === undefined ? element : { ...existing, deleted: existing.deleted || element.deleted });
+  }
+  return { elements: [...byId.values()] };
+};
+var createList = (replica, initial) => {
+  const elements = new Map;
+  const pending = new Map;
+  let clock = 0;
+  if (initial !== undefined) {
+    for (const element of initial.elements) {
+      elements.set(element.id, element);
+      clock = Math.max(clock, element.clock);
+    }
+  }
+  const visible = () => linearize([...elements.values()]).filter((element) => !element.deleted);
+  return {
+    list: () => listOf({ elements: [...elements.values()] }),
+    insert: (index, items) => {
+      const seen = visible();
+      let after = index <= 0 ? null : seen[index - 1]?.id ?? null;
+      for (const value of items) {
+        clock += 1;
+        const element = {
+          id: `${replica}:${clock}`,
+          replica,
+          clock,
+          after,
+          value,
+          deleted: false
+        };
+        elements.set(element.id, element);
+        pending.set(element.id, element);
+        after = element.id;
+      }
+    },
+    delete: (index, count) => {
+      const seen = visible();
+      for (let offset = 0;offset < count; offset += 1) {
+        const target = seen[index + offset];
+        if (target !== undefined) {
+          const tombstoned = { ...target, deleted: true };
+          elements.set(target.id, tombstoned);
+          pending.set(target.id, tombstoned);
+        }
+      }
+    },
+    merge: (state) => {
+      for (const element of state.elements) {
+        const existing = elements.get(element.id);
+        elements.set(element.id, existing === undefined ? element : {
+          ...existing,
+          deleted: existing.deleted || element.deleted
+        });
+        clock = Math.max(clock, element.clock);
+      }
+    },
+    state: () => ({ elements: [...elements.values()] }),
+    takeDelta: () => {
+      const delta = { elements: [...pending.values()] };
+      pending.clear();
+      return delta;
+    }
+  };
+};
+
 // src/crdt/index.ts
 var sumValues = (counts) => Object.values(counts).reduce((total, value) => total + value, 0);
 var mergeMax = (a, b) => {
@@ -125,7 +322,7 @@ var compare = (a, b) => {
   }
   return a.replica > b.replica ? -1 : 1;
 };
-var linearize = (elements) => {
+var linearize2 = (elements) => {
   const present = new Set(elements.map((element) => element.id));
   const children = new Map;
   for (const element of elements) {
@@ -154,7 +351,7 @@ var linearize = (elements) => {
   }
   return ordered;
 };
-var textOf = (state) => linearize(state.elements).filter((element) => !element.deleted).map((element) => element.value).join("");
+var textOf = (state) => linearize2(state.elements).filter((element) => !element.deleted).map((element) => element.value).join("");
 var mergeTextState = (a, b) => {
   const byId = new Map;
   for (const element of [...a.elements, ...b.elements]) {
@@ -195,7 +392,7 @@ var createTextCrdt = (replica, initial) => {
       clock = Math.max(clock, element.clock);
     }
   }
-  const visible = () => linearize([...elements.values()]).filter((element) => !element.deleted);
+  const visible = () => linearize2([...elements.values()]).filter((element) => !element.deleted);
   const insert = (index, value) => {
     const seen = visible();
     let after = index <= 0 ? null : seen[index - 1]?.id ?? null;
@@ -267,6 +464,28 @@ var createTextCrdt = (replica, initial) => {
       const delta = { elements: [...pending.values()] };
       pending.clear();
       return delta;
+    },
+    anchorAt: (index) => {
+      if (index <= 0) {
+        return null;
+      }
+      const seen = visible();
+      return seen[Math.min(index, seen.length) - 1]?.id ?? null;
+    },
+    indexOfAnchor: (anchor) => {
+      if (anchor === null) {
+        return 0;
+      }
+      let visibleCount = 0;
+      for (const element of linearize2([...elements.values()])) {
+        if (!element.deleted) {
+          visibleCount += 1;
+        }
+        if (element.id === anchor) {
+          return visibleCount;
+        }
+      }
+      return visibleCount;
     }
   };
 };
@@ -651,6 +870,8 @@ var createCollaborativeText = (options) => {
         name: mutation
       });
     },
+    anchorAt: (index) => crdt.anchorAt?.(index) ?? null,
+    indexOfAnchor: (anchor) => crdt.indexOfAnchor?.(anchor) ?? 0,
     close() {
       unsubscribe();
       collection.close();
@@ -705,7 +926,11 @@ class SyncCollectionService {
       });
     }
     const setText = (next) => controller?.setText(next);
+    const anchorAt = (index) => controller?.anchorAt(index) ?? null;
+    const indexOfAnchor = (anchor) => controller?.indexOfAnchor(anchor) ?? 0;
     return {
+      anchorAt,
+      indexOfAnchor,
       setText,
       status: computed(() => status()),
       text: computed(() => text())
@@ -730,5 +955,5 @@ export {
   SyncCollectionService
 };
 
-//# debugId=1AFF2CFAC69D012F64756E2164756E21
+//# debugId=03E6C1D8E1B49A2864756E2164756E21
 //# sourceMappingURL=index.js.map