@absolutejs/sync 0.12.0 → 0.14.0

package/dist/client/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,12 +322,14 @@ 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) {
-    const list = children.get(element.after);
+    const anchor = element.after !== null && !present.has(element.after) ? null : element.after;
+    const list = children.get(anchor);
     if (list === undefined) {
-      children.set(element.after, [element]);
+      children.set(anchor, [element]);
     } else {
       list.push(element);
     }
@@ -152,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]) {
@@ -161,6 +360,28 @@ var mergeTextState = (a, b) => {
   }
   return { elements: [...byId.values()] };
 };
+var tombstoneCount = (state) => state.elements.reduce((total, element) => element.deleted ? total + 1 : total, 0);
+var compact = (state) => {
+  const byId = new Map(state.elements.map((element) => [element.id, element]));
+  const keep = new Set;
+  for (const element of state.elements) {
+    if (element.deleted) {
+      continue;
+    }
+    let anchor = element.after;
+    while (anchor !== null && !keep.has(anchor)) {
+      const target = byId.get(anchor);
+      if (target === undefined || !target.deleted) {
+        break;
+      }
+      keep.add(anchor);
+      anchor = target.after;
+    }
+  }
+  return {
+    elements: state.elements.filter((element) => !element.deleted || keep.has(element.id))
+  };
+};
 var createTextCrdt = (replica, initial) => {
   const elements = new Map;
   const pending = new Map;
@@ -171,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;
@@ -247,6 +468,7 @@ var createTextCrdt = (replica, initial) => {
   };
 };
 var rgaText = {
+  compact,
   create: createTextCrdt,
   empty: () => ({ elements: [] }),
   merge: mergeTextState,
@@ -1473,5 +1695,5 @@ export {
   createCollaborativeText
 };
 
-//# debugId=17AE25481DC98CA064756E2164756E21
+//# debugId=CD9E6DE1205D7F3664756E2164756E21
 //# sourceMappingURL=index.js.map