@loro-dev/flock-sqlite 0.1.0

package/src/key-encoding.ts

@@ -0,0 +1,106 @@
+import { decode_key, encode_key } from "./memcomparable";
+import type { KeyPart } from "./types";
+
+type EncodedKey = Uint8Array;
+
+type KeyJsPart =
+  | { $tag: 0; _0: number }
+  | { $tag: 1; _0: string }
+  | { $tag: 2; _0: unknown }
+  | { $tag: 3 }
+  | { $tag: 4 };
+
+function assertValidKeyPart(part: KeyPart): KeyJsPart {
+  if (typeof part === "number") {
+    if (!Number.isFinite(part)) {
+      throw new TypeError("Key parts must be finite numbers");
+    }
+    return { $tag: 0, _0: part };
+  }
+  if (typeof part === "string") {
+    return { $tag: 1, _0: part };
+  }
+  if (part === true) {
+    return { $tag: 3 };
+  }
+  if (part === false) {
+    return { $tag: 4 };
+  }
+  throw new TypeError("Key parts must be strings, numbers, or booleans");
+}
+
+function parseBytesLike(value: unknown): Uint8Array {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const buf = (value as { buf?: unknown }).buf;
+    if (buf instanceof Uint8Array) {
+      const start = (value as { start?: number }).start ?? 0;
+      const end = (value as { end?: number }).end ?? buf.length;
+      return buf.subarray(start, end);
+    }
+  }
+  throw new TypeError("Invalid bytes payload in memcomparable decode");
+}
+
+function fromJsPart(part: unknown): KeyPart {
+  const tag = (part as { $tag?: number } | null)?.$tag;
+  switch (tag) {
+    case 0:
+      return (part as { _0: number })._0;
+    case 1:
+      return (part as { _0: string })._0;
+    case 3:
+      return true;
+    case 4:
+      return false;
+    case 2:
+      // Bytes are not part of the public key surface; surface them as a binary blob for diagnostics.
+      return parseBytesLike((part as { _0: unknown })._0) as unknown as KeyPart;
+    default:
+      throw new TypeError("Unsupported memcomparable key part");
+  }
+}
+
+export function encodeKeyParts(parts: KeyPart[]): EncodedKey {
+  const normalized = parts.map(assertValidKeyPart);
+  return encode_key(normalized) as EncodedKey;
+}
+
+export function decodeKeyParts(bytes: EncodedKey): KeyPart[] {
+  const decoded = decode_key(bytes as unknown as Uint8Array) as Array<unknown>;
+  return decoded.map((part) => fromJsPart(part));
+}
+
+export function compareBytes(a: Uint8Array, b: Uint8Array): number {
+  const min = Math.min(a.length, b.length);
+  for (let i = 0; i < min; i += 1) {
+    if (a[i] !== b[i]) {
+      return a[i] < b[i] ? -1 : 1;
+    }
+  }
+  if (a.length === b.length) {
+    return 0;
+  }
+  return a.length < b.length ? -1 : 1;
+}
+
+export function prefixUpperBound(bytes: Uint8Array): Uint8Array | undefined {
+  if (bytes.length === 0) {
+    return undefined;
+  }
+  const data = Array.from(bytes);
+  for (let i = data.length - 1; i >= 0; i -= 1) {
+    const current = data[i];
+    if (current < 0xff) {
+      data[i] = current + 1;
+      return new Uint8Array(data.slice(0, i + 1));
+    }
+  }
+  return undefined;
+}
+
+export function keyToString(parts: KeyPart[]): string {
+  return JSON.stringify(parts);
+}

package/src/memcomparable.d.ts

@@ -0,0 +1,5 @@
+import type * as MoonBit from "./moonbit.d.ts";
+
+export function decode_key(bytes: MoonBit.Bytes): any;
+
+export function encode_key(parts: any): MoonBit.Bytes;