@loro-dev/flock 2.1.2 → 3.0.0

package/src/index.ts

@@ -81,8 +81,7 @@ export type ExportBundle = { version: number, entries: Record<string, ExportReco
 export type EntryClock = {
   physicalTime: number;
   logicalCounter: number;
-  peerIdHex: string;
-  peerId: Uint8Array;
+  peerId: string;
 };
 
 export type ExportPayload = {
@@ -181,30 +180,17 @@ export type EventBatch = {
   events: Event[];
 };
 
-function bytesToHex(bytes: Uint8Array): string {
-  let hex = "";
-  for (let i = 0; i < bytes.length; i += 1) {
-    hex += bytes[i].toString(16).padStart(2, "0");
-  }
-  return hex;
+const textEncoder = new TextEncoder();
+
+function utf8ByteLength(value: string): number {
+  return textEncoder.encode(value).length;
 }
 
-function hexToBytes(hex: string): Uint8Array {
-  if (hex.length % 2 !== 0) {
-    throw new TypeError("peerId hex must have even length");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < bytes.length; i += 1) {
-    const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    if (Number.isNaN(byte)) {
-      throw new TypeError("peerId hex contains invalid characters");
-    }
-    bytes[i] = byte;
-  }
-  return bytes;
+function isValidPeerId(peerId: unknown): peerId is string {
+  return typeof peerId === "string" && utf8ByteLength(peerId) < 128;
 }
 
-function createRandomPeerId(): Uint8Array {
+function createRandomPeerId(): string {
   const id = new Uint8Array(32);
   if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
     crypto.getRandomValues(id);
@@ -213,17 +199,17 @@ function createRandomPeerId(): Uint8Array {
       id[i] = Math.floor(Math.random() * 256);
     }
   }
-  return id;
+  return Array.from(id, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 
-function normalizePeerId(peerId?: Uint8Array): Uint8Array {
+function normalizePeerId(peerId?: string): string {
   if (peerId === undefined) {
     return createRandomPeerId();
   }
-  if (!(peerId instanceof Uint8Array)) {
-    throw new TypeError("peerId must be a Uint8Array");
+  if (!isValidPeerId(peerId)) {
+    throw new TypeError("peerId must be a UTF-8 string under 128 bytes");
   }
-  return new Uint8Array(peerId);
+  return peerId;
 }
 
 function encodeVersionVector(vv?: VersionVector): RawVersionVector | undefined {
@@ -235,6 +221,9 @@ function encodeVersionVector(vv?: VersionVector): RawVersionVector | undefined {
     if (!entry) {
       continue;
     }
+    if (!isValidPeerId(peer)) {
+      continue;
+    }
     const { physicalTime, logicalCounter } = entry;
     if (typeof physicalTime !== "number" || Number.isNaN(physicalTime)) {
       continue;
@@ -266,6 +255,9 @@ function decodeVersionVector(raw: unknown): VersionVector {
     if (!Array.isArray(value) || value.length < 2) {
       continue;
     }
+    if (!isValidPeerId(peer)) {
+      continue;
+    }
     const [physicalTime, logicalCounter] = value;
     if (typeof physicalTime !== "number" || !Number.isFinite(physicalTime)) {
       continue;
@@ -375,22 +367,21 @@ function cloneMetadata(metadata: unknown): MetadataMap | undefined {
 }
 
 function decodeClock(record: ExportRecord): EntryClock {
-  const [physicalRaw, logicalRaw, peerHexRaw] = record.c.split(",");
-  const physicalTime = Number(physicalRaw);
-  const logicalCounter = Number(logicalRaw);
-  const peerIdHex = peerHexRaw ?? "";
-  let peerId: Uint8Array;
-  try {
-    peerId = hexToBytes(peerIdHex);
-  } catch {
-    peerId = new Uint8Array();
-  }
+  const rawClock = typeof record.c === "string" ? record.c : "";
+  const firstComma = rawClock.indexOf(",");
+  const secondComma = firstComma === -1 ? -1 : rawClock.indexOf(",", firstComma + 1);
+  if (firstComma === -1 || secondComma === -1) {
+    return { physicalTime: 0, logicalCounter: 0, peerId: "" };
+  }
+  const physicalTime = Number(rawClock.slice(0, firstComma));
+  const logicalCounter = Number(rawClock.slice(firstComma + 1, secondComma));
+  const peerIdRaw = rawClock.slice(secondComma + 1);
+  const peerId = isValidPeerId(peerIdRaw) ? peerIdRaw : "";
   return {
     physicalTime: Number.isFinite(physicalTime) ? physicalTime : 0,
     logicalCounter: Number.isFinite(logicalCounter)
       ? Math.trunc(logicalCounter)
       : 0,
-    peerIdHex,
     peerId,
   };
 }
@@ -537,7 +528,7 @@ function isImportOptions(value: unknown): value is ImportOptions {
 export class Flock {
   private inner: ReturnType<typeof newFlock>;
 
-  constructor(peerId?: Uint8Array) {
+  constructor(peerId?: string) {
     this.inner = newFlock(normalizePeerId(peerId));
   }
 
@@ -547,8 +538,8 @@ export class Flock {
     return flock;
   }
 
-  static fromJson(bundle: ExportBundle, peerId: Uint8Array): Flock {
-    const inner = from_json_ffi(bundle, bytesToHex(normalizePeerId(peerId)));
+  static fromJson(bundle: ExportBundle, peerId: string): Flock {
+    const inner = from_json_ffi(bundle, normalizePeerId(peerId));
     return Flock.fromInner(inner as ReturnType<typeof newFlock>);
   }
 
@@ -560,7 +551,7 @@ export class Flock {
     check_invariants_ffi(this.inner);
   }
 
-  setPeerId(peerId: Uint8Array): void {
+  setPeerId(peerId: string): void {
     set_peer_id(this.inner, normalizePeerId(peerId));
   }
 
@@ -754,12 +745,15 @@ export class Flock {
     return Number(get_max_physical_time_ffi(this.inner));
   }
 
-  peerId(): Uint8Array {
-    const hex = peer_id_ffi(this.inner);
-    if (typeof hex !== "string") {
+  peerId(): string {
+    const id = peer_id_ffi(this.inner);
+    if (typeof id !== "string") {
       throw new TypeError("peerId ffi returned unexpected value");
     }
-    return hexToBytes(hex);
+    if (!isValidPeerId(id)) {
+      throw new TypeError("peerId ffi returned an invalid string");
+    }
+    return id;
   }
 
   digest(): string {