@liveblocks/core 1.0.6-test2 → 1.0.6

package/dist/index.d.ts

@@ -1236,20 +1236,10 @@ declare function errorIf(condition: unknown, message: string): void;
  */
 declare const freeze: typeof Object.freeze;
 
-declare function makePosition(before?: string, after?: string): string;
-declare function comparePosition(posA: string, posB: string): number;
-
-/**
- * Shallowly compares two given values.
- *
- * - Two simple values are considered equal if they're strictly equal
- * - Two arrays are considered equal if their members are strictly equal
- * - Two objects are considered equal if their values are strictly equal
- *
- * Testing goes one level deep.
- */
-declare function shallow(a: unknown, b: unknown): boolean;
-
+declare const brand: unique symbol;
+declare type Brand<T, TBrand extends string> = T & {
+    [brand]: TBrand;
+};
 declare function isPlainObject(blob: unknown): blob is {
     [key: string]: unknown;
 };
@@ -1263,6 +1253,78 @@ declare function tryParseJson(rawMessage: string): Json | undefined;
  */
 declare function b64decode(b64value: string): string;
 
+/**
+ * Positions, aka the Pos type, are efficient encodings of "positions" in
+ * a list, using the following printable subset of the ASCII alphabet:
+ *
+ *    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+ *   ^                                                                                             ^
+ *   Lowest digit                                                                      Highest digit
+ *
+ * Each Pos is a sequence of characters from the above alphabet, conceptually
+ * codifying a floating point number 0 < n < 1. For example, the string "31007"
+ * would be used to represent the number 0.31007, except that this
+ * representation uses base 96.
+ *
+ *   0 ≃ ' '  (lowest digit)
+ *   1 ≃ '!'
+ *   2 ≃ '"'
+ *   ...
+ *   9 ≃ '~'  (highest digit)
+ *
+ * So think:
+ *   '!'    ≃ 0.1
+ *   '"'    ≃ 0.2
+ *   '!"~'  ≃ 0.129
+ *
+ * Three rules:
+ * - All "characters" in the string should be valid digits (from the above
+ *   alphabet)
+ * - The value 0.0 is not a valid Pos value
+ * - A Pos cannot have trailing "zeroes"
+ *
+ * This representation has the following benefits:
+ *
+ * 1. It's always possible to get a number that lies before, after, or between
+ *    two arbitrary Pos values.
+ * 2. Pos values can be compared using normal string comparison.
+ *
+ * Some examples:
+ * - '!'  < '"'   (like how .1  < .2)
+ * - '!'  < '~'   (like how .1  < .9)
+ * - '!!' < '!~'  (like how .11 < .19)
+ * - '~!' < '~~'  (like how .91 < .99)
+ * - '~'  < '~!'  (like how .9  < .91)
+ * - '!!' < '!O'  (like how .1  < .5)
+ * - '!O' < '!~'  (like how .5  < .9)
+ *
+ */
+
+/**
+ * A valid/verified "position" string. These values are used as "parentKey"s by
+ * LiveList children, and define their relative ordering.
+ */
+declare type Pos = Brand<string, "Pos">;
+/**
+ * Given two positions, returns the position value that lies in the middle.
+ * When given only a high bound, computes the canonical position "before" it.
+ * When given only a low bound, computes the canonical position "after" it.
+ * When given no bounds at all, returns the "first" canonical position.
+ */
+declare function makePosition(x?: Pos, y?: Pos): Pos;
+declare function comparePosition(posA: Pos, posB: Pos): number;
+
+/**
+ * Shallowly compares two given values.
+ *
+ * - Two simple values are considered equal if they're strictly equal
+ * - Two arrays are considered equal if their members are strictly equal
+ * - Two objects are considered equal if their values are strictly equal
+ *
+ * Testing goes one level deep.
+ */
+declare function shallow(a: unknown, b: unknown): boolean;
+
 declare type IdTuple<T> = [id: string, value: T];
 declare enum CrdtType {
     OBJECT = 0,

package/dist/index.js

@@ -117,7 +117,7 @@ var onMessageFromPanel = eventSource.observable;
 // src/devtools/index.ts
 var VERSION = true ? (
   /* istanbul ignore next */
-  "1.0.6-test2"
+  "1.0.6"
 ) : "dev";
 var _devtoolsSetupHasRun = false;
 function setupDevTools(getAllRooms) {
@@ -345,6 +345,132 @@ function nn(value, errmsg = "Expected value to be non-nullable") {
   return value;
 }
 
+// src/lib/position.ts
+var MIN_CODE = 32;
+var MAX_CODE = 126;
+var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
+var ZERO = nthDigit(0);
+var ONE = nthDigit(1);
+var ZERO_NINE = ZERO + nthDigit(-1);
+function nthDigit(n) {
+  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
+  if (code < MIN_CODE || code > MAX_CODE) {
+    throw new Error(`Invalid n value: ${n}`);
+  }
+  return String.fromCharCode(code);
+}
+function makePosition(x, y) {
+  if (x !== void 0 && y !== void 0) {
+    return between(x, y);
+  } else if (x !== void 0) {
+    return after(x);
+  } else if (y !== void 0) {
+    return before(y);
+  } else {
+    return ONE;
+  }
+}
+function before(pos) {
+  const lastIndex = pos.length - 1;
+  for (let i = 0; i <= lastIndex; i++) {
+    const code = pos.charCodeAt(i);
+    if (code <= MIN_CODE) {
+      continue;
+    }
+    if (i === lastIndex) {
+      if (code === MIN_CODE + 1) {
+        return pos.substring(0, i) + ZERO_NINE;
+      } else {
+        return pos.substring(0, i) + String.fromCharCode(code - 1);
+      }
+    } else {
+      return pos.substring(0, i + 1);
+    }
+  }
+  return ONE;
+}
+function after(pos) {
+  for (let i = 0; i <= pos.length - 1; i++) {
+    const code = pos.charCodeAt(i);
+    if (code >= MAX_CODE) {
+      continue;
+    }
+    return pos.substring(0, i) + String.fromCharCode(code + 1);
+  }
+  return pos + ONE;
+}
+function between(lo, hi) {
+  if (lo < hi) {
+    return _between(lo, hi);
+  } else if (lo > hi) {
+    return _between(hi, lo);
+  } else {
+    throw new Error("Cannot compute value between two equal positions");
+  }
+}
+function _between(lo, hi) {
+  let index = 0;
+  const loLen = lo.length;
+  const hiLen = hi.length;
+  while (true) {
+    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
+    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
+    if (loCode === hiCode) {
+      index++;
+      continue;
+    }
+    if (hiCode - loCode === 1) {
+      const prefix = lo.substring(0, index + 1);
+      const suffix = lo.substring(index + 1);
+      const nines = "";
+      return prefix + _between(suffix, nines);
+    } else {
+      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
+    }
+  }
+}
+function takeN(pos, n) {
+  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
+}
+var MIN_NON_ZERO_CODE = MIN_CODE + 1;
+function isPos(str) {
+  if (str === "") {
+    return false;
+  }
+  const lastIdx = str.length - 1;
+  const last = str.charCodeAt(lastIdx);
+  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
+    return false;
+  }
+  for (let i = 0; i < lastIdx; i++) {
+    const code = str.charCodeAt(i);
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return false;
+    }
+  }
+  return true;
+}
+function convertToPos(str) {
+  const codes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
+  }
+  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
+    codes.length--;
+  }
+  return codes.length > 0 ? String.fromCharCode(...codes) : (
+    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
+    ONE
+  );
+}
+function asPos(str) {
+  return isPos(str) ? str : convertToPos(str);
+}
+function comparePosition(posA, posB) {
+  return posA === posB ? 0 : posA < posB ? -1 : 1;
+}
+
 // src/protocol/Op.ts
 var OpCode = /* @__PURE__ */ ((OpCode2) => {
   OpCode2[OpCode2["INIT"] = 0] = "INIT";
@@ -366,12 +492,12 @@ function isAckOp(op) {
 function crdtAsLiveNode(value) {
   return value;
 }
-function HasParent(node, key) {
-  return Object.freeze({ type: "HasParent", node, key });
+function HasParent(node, key, pos = asPos(key)) {
+  return Object.freeze({ type: "HasParent", node, key, pos });
 }
 var NoParent = Object.freeze({ type: "NoParent" });
-function Orphaned(oldKey) {
-  return Object.freeze({ type: "Orphaned", oldKey });
+function Orphaned(oldKey, oldPos = asPos(oldKey)) {
+  return Object.freeze({ type: "Orphaned", oldKey, oldPos });
 }
 var AbstractCrdt = class {
   constructor() {
@@ -392,6 +518,19 @@ var AbstractCrdt = class {
     }
   }
   /** @internal */
+  get _parentPos() {
+    switch (this.parent.type) {
+      case "HasParent":
+        return this.parent.pos;
+      case "NoParent":
+        throw new Error("Parent key is missing");
+      case "Orphaned":
+        return this.parent.oldPos;
+      default:
+        return assertNever(this.parent, "Unknown state");
+    }
+  }
+  /** @internal */
   get _pool() {
     return this.__pool;
   }
@@ -407,19 +546,6 @@ var AbstractCrdt = class {
     return this._parent;
   }
   /** @internal */
-  get _parentNode() {
-    switch (this.parent.type) {
-      case "HasParent":
-        return this.parent.node;
-      case "NoParent":
-        return null;
-      case "Orphaned":
-        return null;
-      default:
-        return assertNever(this.parent, "Unknown state");
-    }
-  }
-  /** @internal */
   get _parentKey() {
     switch (this.parent.type) {
       case "HasParent":
@@ -479,7 +605,7 @@ var AbstractCrdt = class {
     }
     switch (this.parent.type) {
       case "HasParent": {
-        this._parent = Orphaned(this.parent.key);
+        this._parent = Orphaned(this.parent.key, this.parent.pos);
         break;
       }
       case "NoParent": {
@@ -487,7 +613,6 @@ var AbstractCrdt = class {
         break;
       }
       case "Orphaned": {
-        this._parent = Orphaned(this.parent.oldKey);
         break;
       }
       default:
@@ -609,110 +734,6 @@ function nanoid(length = 7) {
   ).join("");
 }
 
-// src/lib/position.ts
-var min = 32;
-var max = 126;
-function makePosition(before, after) {
-  if (before !== void 0 && after !== void 0) {
-    return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
-  } else if (before !== void 0) {
-    return getNextPosition(before);
-  } else if (after !== void 0) {
-    return getPreviousPosition(after);
-  }
-  return pos([min + 1]);
-}
-function getPreviousPosition(after) {
-  const result = [];
-  const afterCodes = posCodes(after);
-  for (let i = 0; i < afterCodes.length; i++) {
-    const code = afterCodes[i];
-    if (code <= min + 1) {
-      result.push(min);
-      if (afterCodes.length - 1 === i) {
-        result.push(max);
-        break;
-      }
-    } else {
-      result.push(code - 1);
-      break;
-    }
-  }
-  return pos(result);
-}
-function getNextPosition(before) {
-  const result = [];
-  const beforeCodes = posCodes(before);
-  for (let i = 0; i < beforeCodes.length; i++) {
-    const code = beforeCodes[i];
-    if (code === max) {
-      result.push(code);
-      if (beforeCodes.length - 1 === i) {
-        result.push(min + 1);
-        break;
-      }
-    } else {
-      result.push(code + 1);
-      break;
-    }
-  }
-  return pos(result);
-}
-function makePositionFromCodes(before, after) {
-  let index = 0;
-  const result = [];
-  while (true) {
-    const beforeDigit = before[index] || min;
-    const afterDigit = after[index] || max;
-    if (beforeDigit > afterDigit) {
-      throw new Error(
-        `Impossible to generate position between ${before} and ${after}`
-      );
-    }
-    if (beforeDigit === afterDigit) {
-      result.push(beforeDigit);
-      index++;
-      continue;
-    }
-    if (afterDigit - beforeDigit === 1) {
-      result.push(beforeDigit);
-      result.push(...makePositionFromCodes(before.slice(index + 1), []));
-      break;
-    }
-    const mid = afterDigit + beforeDigit >> 1;
-    result.push(mid);
-    break;
-  }
-  return result;
-}
-function posCodes(str) {
-  const codes = [];
-  for (let i = 0; i < str.length; i++) {
-    codes.push(str.charCodeAt(i));
-  }
-  return codes;
-}
-function pos(codes) {
-  return String.fromCharCode(...codes);
-}
-function comparePosition(posA, posB) {
-  const aCodes = posCodes(posA);
-  const bCodes = posCodes(posB);
-  const maxLength = Math.max(aCodes.length, bCodes.length);
-  for (let i = 0; i < maxLength; i++) {
-    const a = aCodes[i] === void 0 ? min : aCodes[i];
-    const b = bCodes[i] === void 0 ? min : bCodes[i];
-    if (a === b) {
-      continue;
-    } else {
-      return a - b;
-    }
-  }
-  throw new Error(
-    `Impossible to compare similar position "${posA}" and "${posB}"`
-  );
-}
-
 // src/crdts/LiveRegister.ts
 var LiveRegister = class extends AbstractCrdt {
   constructor(data) {
@@ -788,10 +809,7 @@ var LiveRegister = class extends AbstractCrdt {
 
 // src/crdts/LiveList.ts
 function compareNodePosition(itemA, itemB) {
-  return comparePosition(
-    itemA._getParentKeyOrThrow(),
-    itemB._getParentKeyOrThrow()
-  );
+  return comparePosition(itemA._parentPos, itemB._parentPos);
 }
 var LiveList = class extends AbstractCrdt {
   constructor(items = []) {
@@ -1033,7 +1051,7 @@ var LiveList = class extends AbstractCrdt {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
-    const key = op.parentKey;
+    const key = asPos(op.parentKey);
     const existingItemIndex = this._indexOfPosition(key);
     if (existingItemIndex !== -1) {
       this._shiftItemPosition(existingItemIndex, key);
@@ -1047,7 +1065,7 @@ var LiveList = class extends AbstractCrdt {
   /** @internal */
   _applyInsertAck(op) {
     const existingItem = this._items.find((item) => item._id === op.id);
-    const key = op.parentKey;
+    const key = asPos(op.parentKey);
     const itemIndexAtPosition = this._indexOfPosition(key);
     if (existingItem) {
       if (existingItem._parentKey === key) {
@@ -1108,9 +1126,9 @@ var LiveList = class extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before = (_b = this._items[existingItemIndex]) == null ? void 0 : _b._getParentKeyOrThrow();
-      const after = (_c = this._items[existingItemIndex + 1]) == null ? void 0 : _c._getParentKeyOrThrow();
-      newKey = makePosition(before, after);
+      const before2 = (_b = this._items[existingItemIndex]) == null ? void 0 : _b._parentPos;
+      const after2 = (_c = this._items[existingItemIndex + 1]) == null ? void 0 : _c._parentPos;
+      newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
     this._insertAndSort(child);
@@ -1248,10 +1266,7 @@ var LiveList = class extends AbstractCrdt {
     } else {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(
-          newKey,
-          (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._getParentKeyOrThrow()
-        )
+        makePosition(newKey, (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._parentPos)
       );
       const previousIndex = this._items.indexOf(child);
       child._setParentLink(this, newKey);
@@ -1278,10 +1293,7 @@ var LiveList = class extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(
-            newKey,
-            (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._getParentKeyOrThrow()
-          )
+          makePosition(newKey, (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._parentPos)
         );
       }
       child._setParentLink(this, newKey);
@@ -1300,10 +1312,7 @@ var LiveList = class extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(
-            newKey,
-            (_b = this._items[existingItemIndex + 1]) == null ? void 0 : _b._getParentKeyOrThrow()
-          )
+          makePosition(newKey, (_b = this._items[existingItemIndex + 1]) == null ? void 0 : _b._parentPos)
         );
       }
       child._setParentLink(this, newKey);
@@ -1332,10 +1341,7 @@ var LiveList = class extends AbstractCrdt {
     if (existingItemIndex !== -1) {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(
-          newKey,
-          (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._getParentKeyOrThrow()
-        )
+        makePosition(newKey, (_a = this._items[existingItemIndex + 1]) == null ? void 0 : _a._parentPos)
       );
     }
     child._setParentLink(this, newKey);
@@ -1410,9 +1416,9 @@ var LiveList = class extends AbstractCrdt {
         `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
       );
     }
-    const before = this._items[index - 1] ? this._items[index - 1]._getParentKeyOrThrow() : void 0;
-    const after = this._items[index] ? this._items[index]._getParentKeyOrThrow() : void 0;
-    const position = makePosition(before, after);
+    const before2 = this._items[index - 1] ? this._items[index - 1]._parentPos : void 0;
+    const after2 = this._items[index] ? this._items[index]._parentPos : void 0;
+    const position = makePosition(before2, after2);
     const value = lsonToLiveNode(element);
     value._setParentLink(this, position);
     this._insertAndSort(value);
@@ -1453,11 +1459,11 @@ var LiveList = class extends AbstractCrdt {
     let beforePosition = null;
     let afterPosition = null;
     if (index < targetIndex) {
-      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._getParentKeyOrThrow();
-      beforePosition = this._items[targetIndex]._getParentKeyOrThrow();
+      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._parentPos;
+      beforePosition = this._items[targetIndex]._parentPos;
     } else {
-      afterPosition = this._items[targetIndex]._getParentKeyOrThrow();
-      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._getParentKeyOrThrow();
+      afterPosition = this._items[targetIndex]._parentPos;
+      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._parentPos;
     }
     const position = makePosition(beforePosition, afterPosition);
     const item = this._items[index];
@@ -1712,7 +1718,7 @@ var LiveList = class extends AbstractCrdt {
     var _a;
     const shiftedPosition = makePosition(
       key,
-      this._items.length > index + 1 ? (_a = this._items[index + 1]) == null ? void 0 : _a._getParentKeyOrThrow() : void 0
+      this._items.length > index + 1 ? (_a = this._items[index + 1]) == null ? void 0 : _a._parentPos : void 0
     );
     this._items[index]._setParentLink(this, shiftedPosition);
   }
@@ -3592,7 +3598,11 @@ function makeStateMachine(config, initialPresence, initialStorage) {
           return { modified: false };
         }
         if (node.parent.type === "HasParent" && isLiveList(node.parent.node)) {
-          return node.parent.node._setChildKey(op.parentKey, node, source);
+          return node.parent.node._setChildKey(
+            asPos(op.parentKey),
+            node,
+            source
+          );
         }
         return { modified: false };
       }
@@ -4501,7 +4511,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
       // @ts-ignore (__PACKAGE_VERSION__ will be injected by the build script)
       true ? (
         /* istanbul ignore next */
-        "1.0.6-test2"
+        "1.0.6"
       ) : "dev"}`
     );
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/core",
-  "version": "1.0.6-test2",
+  "version": "1.0.6",
   "description": "Shared code and foundational internals for Liveblocks",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",