@dabble/patches 0.8.0 → 0.8.1

package/dist/json-patch/utils/getType.d.ts

@@ -1,6 +1,6 @@
 import { State, JSONPatchOp, JSONPatchOpHandler } from '../types.js';
 
 declare function getType(state: State, patch: JSONPatchOp): JSONPatchOpHandler;
-declare function getTypeLike(state: State, patch: JSONPatchOp): "test" | "add" | "remove" | "replace" | "copy" | "move";
+declare function getTypeLike(state: State, patch: JSONPatchOp): "add" | "remove" | "replace" | "move" | "copy" | "test";
 
 export { getType, getTypeLike };

package/dist/micro/client.d.ts

@@ -0,0 +1,44 @@
+import { Signal } from 'easy-signal';
+import { MicroDoc } from './doc.js';
+import '@dabble/delta';
+import './types.js';
+
+interface ClientOptions {
+    /** Base URL for REST API, e.g. "https://api.example.com" */
+    url: string;
+    /** If provided, persists state to IndexedDB with this database name. */
+    dbName?: string;
+    /** Debounce delay in ms before flushing pending ops. Default: 300 */
+    debounce?: number;
+}
+declare class MicroClient {
+    private _url;
+    private _dbName?;
+    private _debounce;
+    private _docs;
+    private _ws;
+    private _wsBackoff;
+    private _wsTimer;
+    private _db;
+    readonly onConnection: Signal<(connected: boolean) => void>;
+    constructor(opts: ClientOptions);
+    /** Open a document. Fetches from server (or IDB cache), subscribes via WS. */
+    open<T = Record<string, any>>(docId: string): Promise<MicroDoc<T>>;
+    /** Close a document subscription. */
+    close(docId: string): void;
+    /** Force flush pending ops for a document immediately. */
+    flush(docId: string): Promise<void>;
+    /** Disconnect WebSocket and clean up. */
+    destroy(): void;
+    private _scheduleFlush;
+    private _doFlush;
+    private _ensureWS;
+    private _reconnectWS;
+    private _wsSend;
+    private _fetch;
+    private _idbOpen;
+    private _idbLoad;
+    private _idbSave;
+}
+
+export { type ClientOptions, MicroClient };

package/dist/micro/client.js

@@ -0,0 +1,206 @@
+import "../chunk-IZ2YBCUP.js";
+import { signal } from "easy-signal";
+import { MicroDoc } from "./doc.js";
+class MicroClient {
+  _url;
+  _dbName;
+  _debounce;
+  _docs = /* @__PURE__ */ new Map();
+  _ws = null;
+  _wsBackoff = 0;
+  _wsTimer = null;
+  _db = null;
+  onConnection = signal();
+  constructor(opts) {
+    this._url = opts.url.replace(/\/$/, "");
+    this._dbName = opts.dbName;
+    this._debounce = opts.debounce ?? 300;
+  }
+  /** Open a document. Fetches from server (or IDB cache), subscribes via WS. */
+  async open(docId) {
+    if (this._docs.has(docId)) return this._docs.get(docId).doc;
+    let state = { rev: 0, fields: {} };
+    let pending = {};
+    if (this._dbName) {
+      const cached = await this._idbLoad(docId);
+      if (cached) {
+        state = { rev: cached.rev, fields: cached.fields };
+        pending = cached.pending;
+      }
+    }
+    try {
+      const remote = await this._fetch(`/docs/${docId}`);
+      if (remote.rev > state.rev) {
+        state = remote;
+        pending = {};
+      }
+    } catch {
+    }
+    const doc = new MicroDoc(state.fields, pending, state.rev);
+    const entry = { doc, timer: null };
+    this._docs.set(docId, entry);
+    doc._onUpdate = () => this._scheduleFlush(docId);
+    this._ensureWS();
+    this._wsSend({ type: "sub", docId });
+    return doc;
+  }
+  /** Close a document subscription. */
+  close(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry) return;
+    if (entry.timer) clearTimeout(entry.timer);
+    this._docs.delete(docId);
+    this._wsSend({ type: "unsub", docId });
+  }
+  /** Force flush pending ops for a document immediately. */
+  async flush(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry) return;
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+      entry.timer = null;
+    }
+    await this._doFlush(docId, entry);
+  }
+  /** Disconnect WebSocket and clean up. */
+  destroy() {
+    for (const [id, entry] of this._docs) {
+      if (entry.timer) clearTimeout(entry.timer);
+      this._docs.delete(id);
+    }
+    if (this._wsTimer) clearTimeout(this._wsTimer);
+    this._ws?.close();
+    this._ws = null;
+    this._db?.close();
+    this._db = null;
+  }
+  // --- Sync ---
+  _scheduleFlush(docId) {
+    const entry = this._docs.get(docId);
+    if (!entry || entry.timer) return;
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      this._doFlush(docId, entry);
+    }, this._debounce);
+  }
+  async _doFlush(docId, entry) {
+    const change = entry.doc._flush();
+    if (!change) return;
+    if (this._dbName) this._idbSave(docId, entry.doc);
+    try {
+      const result = await this._fetch(`/docs/${docId}/changes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(change)
+      });
+      entry.doc._confirmSend(result.rev);
+      if (this._dbName) this._idbSave(docId, entry.doc);
+      if (Object.keys(entry.doc.pending).length) this._scheduleFlush(docId);
+    } catch {
+      entry.doc._failSend();
+      entry.timer = setTimeout(() => {
+        entry.timer = null;
+        this._doFlush(docId, entry);
+      }, 2e3);
+    }
+  }
+  // --- WebSocket ---
+  _ensureWS() {
+    if (this._ws && this._ws.readyState <= WebSocket.OPEN) return;
+    const wsUrl = this._url.replace(/^http/, "ws") + "/ws";
+    const ws = new WebSocket(wsUrl);
+    this._ws = ws;
+    ws.onopen = () => {
+      this._wsBackoff = 0;
+      this.onConnection.emit(true);
+      for (const docId of this._docs.keys()) {
+        this._wsSend({ type: "sub", docId });
+      }
+    };
+    ws.onmessage = (e) => {
+      try {
+        const msg = JSON.parse(e.data);
+        if (msg.type === "change" && msg.docId) {
+          const entry = this._docs.get(msg.docId);
+          if (entry) entry.doc.applyRemote(msg.fields, msg.rev);
+        }
+      } catch {
+      }
+    };
+    ws.onclose = () => {
+      this.onConnection.emit(false);
+      this._reconnectWS();
+    };
+    ws.onerror = () => ws.close();
+  }
+  _reconnectWS() {
+    if (this._wsTimer) return;
+    const delay = Math.min(1e3 * 2 ** this._wsBackoff, 3e4);
+    this._wsBackoff++;
+    this._wsTimer = setTimeout(() => {
+      this._wsTimer = null;
+      if (this._docs.size > 0) this._ensureWS();
+    }, delay);
+  }
+  _wsSend(msg) {
+    if (this._ws?.readyState === WebSocket.OPEN) {
+      this._ws.send(JSON.stringify(msg));
+    }
+  }
+  // --- REST ---
+  async _fetch(path, init) {
+    const res = await fetch(this._url + path, init);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.json();
+  }
+  // --- IndexedDB ---
+  async _idbOpen() {
+    if (this._db) return this._db;
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains("docs")) db.createObjectStore("docs");
+        if (!db.objectStoreNames.contains("pending")) db.createObjectStore("pending");
+      };
+      req.onsuccess = () => {
+        this._db = req.result;
+        resolve(req.result);
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async _idbLoad(docId) {
+    try {
+      const db = await this._idbOpen();
+      const tx = db.transaction(["docs", "pending"], "readonly");
+      const [docData, pendingData] = await Promise.all([
+        idbGet(tx.objectStore("docs"), docId),
+        idbGet(tx.objectStore("pending"), docId)
+      ]);
+      if (!docData) return null;
+      return { fields: docData.fields, rev: docData.rev, pending: pendingData?.ops ?? {} };
+    } catch {
+      return null;
+    }
+  }
+  async _idbSave(docId, doc) {
+    try {
+      const db = await this._idbOpen();
+      const tx = db.transaction(["docs", "pending"], "readwrite");
+      tx.objectStore("docs").put({ fields: doc.confirmed, rev: doc.rev }, docId);
+      tx.objectStore("pending").put({ ops: doc.pending }, docId);
+    } catch {
+    }
+  }
+}
+function idbGet(store, key) {
+  return new Promise((resolve, reject) => {
+    const req = store.get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+export {
+  MicroClient
+};

package/dist/micro/doc.d.ts

@@ -0,0 +1,51 @@
+import { Delta } from '@dabble/delta';
+import { Subscriber, Unsubscriber } from 'easy-signal';
+import { FieldMap, Change } from './types.js';
+
+interface BaseUpdates<T> {
+    set(val: T): void;
+    del(): void;
+}
+interface NumberUpdates extends BaseUpdates<number> {
+    inc(val?: number): void;
+    bit(val: number): void;
+    max(val: number): void;
+}
+interface StringUpdates extends BaseUpdates<string> {
+    max(val: string): void;
+}
+interface DeltaUpdates extends BaseUpdates<Delta> {
+    txt(delta: Delta): void;
+}
+type Updatable<T> = T extends Delta ? DeltaUpdates : T extends number ? NumberUpdates : T extends string ? StringUpdates : T extends object ? {
+    [K in keyof T]-?: Updatable<NonNullable<T[K]>>;
+} & BaseUpdates<T> : BaseUpdates<T>;
+declare class MicroDoc<T = Record<string, any>> {
+    rev: number;
+    private _store;
+    private _confirmed;
+    private _sending;
+    private _sendingId;
+    private _pending;
+    /** Called by client when ops are queued. */
+    _onUpdate?: () => void;
+    constructor(confirmed?: FieldMap, pending?: FieldMap, rev?: number);
+    get state(): T;
+    get pending(): FieldMap;
+    get confirmed(): FieldMap;
+    get isSending(): boolean;
+    subscribe(cb: Subscriber<T>, noInit?: false): Unsubscriber;
+    /** Apply changes via proxy-based updater. */
+    update(fn: (doc: Updatable<T>) => void): void;
+    /** Move pending to sending, return the Change to POST. Returns null if nothing to send. */
+    _flush(): Change | null;
+    /** Confirm a successful send. Merge sending into confirmed. */
+    _confirmSend(rev: number): void;
+    /** Roll sending back into pending on failure. */
+    _failSend(): void;
+    /** Apply remote fields from another client (via WS push). */
+    applyRemote(fields: FieldMap, rev: number): void;
+    private _rebuild;
+}
+
+export { MicroDoc, type Updatable };

package/dist/micro/doc.js

@@ -0,0 +1,138 @@
+import "../chunk-IZ2YBCUP.js";
+import { Delta } from "@dabble/delta";
+import { batch, store } from "easy-signal";
+import { buildState, consolidateOps, effectiveFields, generateId, mergeField } from "./ops.js";
+import { TXT, parseSuffix } from "./types.js";
+function createUpdater(emit, path = "") {
+  return new Proxy({}, {
+    get(_, prop) {
+      const p = path ? `${path}.${prop}` : prop;
+      switch (prop) {
+        case "set":
+          return (val) => emit(path, "", val);
+        case "del":
+          return () => emit(path, "", null);
+        case "inc":
+          return (val = 1) => emit(path, "+", val);
+        case "bit":
+          return (val) => emit(path, "~", val);
+        case "max":
+          return (val) => emit(path, "^", val);
+        case "txt":
+          return (delta) => emit(path, "#", delta.ops);
+        default:
+          return createUpdater(emit, p);
+      }
+    }
+  });
+}
+class MicroDoc {
+  constructor(confirmed = {}, pending = {}, rev = 0) {
+    this.rev = rev;
+    this._confirmed = { ...confirmed };
+    this._pending = { ...pending };
+    this._store = store(this._rebuild());
+  }
+  _store;
+  _confirmed;
+  _sending = null;
+  _sendingId = null;
+  _pending = {};
+  /** Called by client when ops are queued. */
+  _onUpdate;
+  get state() {
+    return this._store.state;
+  }
+  get pending() {
+    return this._pending;
+  }
+  get confirmed() {
+    return this._confirmed;
+  }
+  get isSending() {
+    return this._sending !== null;
+  }
+  subscribe(cb, noInit) {
+    return this._store.subscribe(cb, noInit);
+  }
+  /** Apply changes via proxy-based updater. */
+  update(fn) {
+    const ops = {};
+    const ts = Date.now();
+    const emit = (path, suffix, val) => {
+      ops[suffix ? path + suffix : path] = { val, ts };
+    };
+    fn(createUpdater(emit));
+    if (!Object.keys(ops).length) return;
+    this._pending = consolidateOps(this._pending, ops);
+    this._store.state = this._rebuild();
+    this._onUpdate?.();
+  }
+  /** Move pending to sending, return the Change to POST. Returns null if nothing to send. */
+  _flush() {
+    if (this._sending || !Object.keys(this._pending).length) return null;
+    this._sending = this._pending;
+    this._sendingId = generateId();
+    this._pending = {};
+    return { id: this._sendingId, rev: this.rev, fields: this._sending };
+  }
+  /** Confirm a successful send. Merge sending into confirmed. */
+  _confirmSend(rev) {
+    if (!this._sending) return;
+    for (const [key, field] of Object.entries(this._sending)) {
+      const { suffix } = parseSuffix(key);
+      if (suffix === TXT) {
+        const base = this._confirmed[key]?.val ? new Delta(this._confirmed[key].val) : new Delta();
+        this._confirmed[key] = { val: base.compose(new Delta(field.val)).ops, ts: field.ts };
+      } else {
+        this._confirmed[key] = mergeField(this._confirmed[key], field, suffix);
+      }
+    }
+    this._sending = null;
+    this._sendingId = null;
+    this.rev = rev;
+    this._store.state = this._rebuild();
+  }
+  /** Roll sending back into pending on failure. */
+  _failSend() {
+    if (!this._sending) return;
+    this._pending = consolidateOps(this._sending, this._pending);
+    this._sending = null;
+    this._sendingId = null;
+  }
+  /** Apply remote fields from another client (via WS push). */
+  applyRemote(fields, rev) {
+    batch(() => {
+      for (const [key, field] of Object.entries(fields)) {
+        const { suffix } = parseSuffix(key);
+        if (suffix === TXT) {
+          const remote = new Delta(field.val);
+          if (this._sending?.[key]) {
+            const s = new Delta(this._sending[key].val);
+            this._sending[key] = { val: s.transform(remote, false).ops, ts: this._sending[key].ts };
+            const rPrime = remote.transform(s, true);
+            if (this._pending[key]) {
+              const p = new Delta(this._pending[key].val);
+              this._pending[key] = { val: p.transform(rPrime, false).ops, ts: this._pending[key].ts };
+            }
+          } else if (this._pending[key]) {
+            const p = new Delta(this._pending[key].val);
+            this._pending[key] = { val: p.transform(remote, false).ops, ts: this._pending[key].ts };
+          }
+          const base = this._confirmed[key]?.val ? new Delta(this._confirmed[key].val) : new Delta();
+          this._confirmed[key] = { val: base.compose(remote).ops, ts: field.ts };
+        } else {
+          this._confirmed[key] = field;
+        }
+      }
+      this.rev = rev;
+      this._store.state = this._rebuild();
+    });
+  }
+  _rebuild() {
+    return buildState(effectiveFields(this._confirmed, this._sending, this._pending));
+  }
+}
+export {
+  MicroDoc
+};

package/dist/micro/index.d.ts

@@ -0,0 +1,7 @@
+export { ClientOptions, MicroClient } from './client.js';
+export { MicroDoc, Updatable } from './doc.js';
+export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField } from './ops.js';
+export { MemoryDbBackend, MicroServer } from './server.js';
+export { BIT, Change, ChangeLogEntry, CommitResult, DbBackend, DocState, Field, FieldMap, INC, MAX, ObjectStore, REF_THRESHOLD, TXT, TextLogEntry, parseSuffix } from './types.js';
+import 'easy-signal';
+import '@dabble/delta';

package/dist/micro/index.js

@@ -0,0 +1,26 @@
+import "../chunk-IZ2YBCUP.js";
+import { MicroClient } from "./client.js";
+import { MicroDoc } from "./doc.js";
+import { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField } from "./ops.js";
+import { MemoryDbBackend, MicroServer } from "./server.js";
+import { BIT, INC, MAX, parseSuffix, REF_THRESHOLD, TXT } from "./types.js";
+export {
+  BIT,
+  INC,
+  MAX,
+  MemoryDbBackend,
+  MicroClient,
+  MicroDoc,
+  MicroServer,
+  REF_THRESHOLD,
+  TXT,
+  applyBitmask,
+  bitmask,
+  buildState,
+  combineBitmasks,
+  consolidateOps,
+  effectiveFields,
+  generateId,
+  mergeField,
+  parseSuffix
+};

package/dist/micro/ops.d.ts

@@ -0,0 +1,20 @@
+import { FieldMap, Field } from './types.js';
+
+/** Create a bitmask value. Bottom 15 bits = on, top 15 bits = off. */
+declare function bitmask(index: number, value: boolean): number;
+/** Apply a bitmask to a number. */
+declare function applyBitmask(num: number, mask: number): number;
+/** Combine two bitmasks into one. */
+declare function combineBitmasks(a: number, b: number): number;
+/** Generate a random ID. */
+declare function generateId(): string;
+/** Merge a single incoming field with an existing value, based on suffix type. */
+declare function mergeField(existing: Field | undefined, incoming: Field, suffix: string): Field;
+/** Consolidate new ops into existing pending ops (client-side batching). */
+declare function consolidateOps(pending: FieldMap, newOps: FieldMap): FieldMap;
+/** Convert flat dot-notation FieldMap to a nested object. Strips suffixes from keys. */
+declare function buildState<T = Record<string, any>>(fields: FieldMap): T;
+/** Compute effective fields by layering confirmed + sending + pending. */
+declare function effectiveFields(confirmed: FieldMap, sending: FieldMap | null, pending: FieldMap): FieldMap;
+
+export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField };

package/dist/micro/ops.js

@@ -0,0 +1,100 @@
+import "../chunk-IZ2YBCUP.js";
+import { Delta } from "@dabble/delta";
+import { BIT, INC, MAX, parseSuffix, TXT } from "./types.js";
+function bitmask(index, value) {
+  if (index < 0 || index > 14) throw new Error("Index must be between 0 and 14");
+  return value ? 1 << index : 1 << index + 15;
+}
+function applyBitmask(num, mask) {
+  return num & ~(mask >> 15 & 32767) | mask & 32767;
+}
+function combineBitmasks(a, b) {
+  const aOff = a >> 15 & 32767, aOn = a & 32767;
+  const bOff = b >> 15 & 32767, bOn = b & 32767;
+  return (aOff & ~bOn | bOff) << 15 | (aOn & ~bOff | bOn);
+}
+function generateId() {
+  return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+function mergeField(existing, incoming, suffix) {
+  const ev = existing?.val ?? 0;
+  switch (suffix) {
+    case INC:
+      return { val: ev + incoming.val, ts: incoming.ts };
+    case BIT:
+      return { val: applyBitmask(ev, incoming.val), ts: incoming.ts };
+    case MAX:
+      return incoming.val >= ev ? incoming : existing;
+    case TXT:
+      return incoming;
+    // text composed separately
+    default:
+      return incoming.ts >= (existing?.ts ?? 0) ? incoming : existing;
+  }
+}
+function consolidateOps(pending, newOps) {
+  const result = { ...pending };
+  for (const [key, field] of Object.entries(newOps)) {
+    const ex = result[key];
+    if (!ex) {
+      result[key] = field;
+      continue;
+    }
+    const { suffix } = parseSuffix(key);
+    switch (suffix) {
+      case INC:
+        result[key] = { val: ex.val + field.val, ts: field.ts };
+        break;
+      case BIT:
+        result[key] = { val: combineBitmasks(ex.val, field.val), ts: field.ts };
+        break;
+      case MAX:
+        result[key] = field.val >= ex.val ? field : ex;
+        break;
+      case TXT:
+        result[key] = { val: new Delta(ex.val).compose(new Delta(field.val)).ops, ts: field.ts };
+        break;
+      default:
+        result[key] = field;
+    }
+  }
+  return result;
+}
+function buildState(fields) {
+  const obj = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.val == null) continue;
+    const { path } = parseSuffix(key);
+    const parts = path.split(".");
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) cur = cur[parts[i]] ??= {};
+    cur[parts[parts.length - 1]] = field.val;
+  }
+  return obj;
+}
+function effectiveFields(confirmed, sending, pending) {
+  const result = { ...confirmed };
+  const layers = sending ? [sending, pending] : [pending];
+  for (const layer of layers) {
+    for (const [key, field] of Object.entries(layer)) {
+      const { suffix } = parseSuffix(key);
+      if (suffix === TXT) {
+        const base = result[key]?.val ? new Delta(result[key].val) : new Delta();
+        result[key] = { val: base.compose(new Delta(field.val)).ops, ts: field.ts };
+      } else {
+        result[key] = mergeField(result[key], field, suffix);
+      }
+    }
+  }
+  return result;
+}
+export {
+  applyBitmask,
+  bitmask,
+  buildState,
+  combineBitmasks,
+  consolidateOps,
+  effectiveFields,
+  generateId,
+  mergeField
+};

package/dist/micro/server.d.ts

@@ -0,0 +1,44 @@
+import { DbBackend, FieldMap, Field, TextLogEntry, ChangeLogEntry, ObjectStore, DocState, CommitResult, Change } from './types.js';
+
+type Subscriber = (fields: FieldMap, rev: number) => void;
+declare class MicroServer {
+    private _db;
+    private _objects?;
+    private _subs;
+    constructor(_db: DbBackend, _objects?: ObjectStore | undefined);
+    /** Get full document state. */
+    getDoc(docId: string): Promise<DocState>;
+    /** Get fields changed since a given revision (for reconnection). */
+    getChangesSince(docId: string, sinceRev: number): Promise<CommitResult>;
+    /** Process an incoming change from a client. */
+    commitChanges(docId: string, change: Change): Promise<CommitResult>;
+    /** Compact text log entries up to a revision. */
+    compactTextLog(docId: string, key: string, throughRev: number): Promise<void>;
+    /** Prune old change log entries. */
+    pruneChanges(docId: string, beforeTs: number): Promise<void>;
+    /** Subscribe to changes for a document. */
+    subscribe(docId: string, cb: Subscriber): () => void;
+    /** Get subscriber count for a document. */
+    subscriberCount(docId: string): number;
+    private _broadcast;
+    private _handleLargeValue;
+}
+declare class MemoryDbBackend implements DbBackend {
+    private _fields;
+    private _textLog;
+    private _changeLog;
+    private _revs;
+    getFields(docId: string): Promise<FieldMap>;
+    getField(docId: string, key: string): Promise<Field | null>;
+    setFields(docId: string, fields: FieldMap): Promise<void>;
+    getTextLog(docId: string, key: string, sinceRev?: number): Promise<TextLogEntry[]>;
+    appendTextLog(docId: string, entry: TextLogEntry): Promise<void>;
+    compactTextLog(docId: string, key: string, throughRev: number, composedDelta: any): Promise<void>;
+    hasChange(docId: string, changeId: string): Promise<boolean>;
+    addChange(docId: string, entry: ChangeLogEntry): Promise<void>;
+    pruneChanges(docId: string, beforeTs: number): Promise<void>;
+    getRev(docId: string): Promise<number>;
+    setRev(docId: string, rev: number): Promise<void>;
+}
+
+export { MemoryDbBackend, MicroServer };

package/dist/micro/server.js

@@ -0,0 +1,195 @@
+import "../chunk-IZ2YBCUP.js";
+import { Delta } from "@dabble/delta";
+import { applyBitmask } from "./ops.js";
+import { BIT, INC, MAX, parseSuffix, REF_THRESHOLD, TXT } from "./types.js";
+class MicroServer {
+  constructor(_db, _objects) {
+    this._db = _db;
+    this._objects = _objects;
+  }
+  _subs = /* @__PURE__ */ new Map();
+  /** Get full document state. */
+  async getDoc(docId) {
+    const [fields, rev] = await Promise.all([this._db.getFields(docId), this._db.getRev(docId)]);
+    return { fields, rev };
+  }
+  /** Get fields changed since a given revision (for reconnection). */
+  async getChangesSince(docId, sinceRev) {
+    const { fields, rev } = await this.getDoc(docId);
+    if (sinceRev === 0) return { fields, rev };
+    return { fields, rev };
+  }
+  /** Process an incoming change from a client. */
+  async commitChanges(docId, change) {
+    if (await this._db.hasChange(docId, change.id)) {
+      const rev2 = await this._db.getRev(docId);
+      return { rev: rev2, fields: {} };
+    }
+    const resultFields = {};
+    let rev = await this._db.getRev(docId);
+    let hasCombinableOps = false;
+    for (const [key, incoming] of Object.entries(change.fields)) {
+      const { suffix } = parseSuffix(key);
+      const existing = await this._db.getField(docId, key);
+      let resolved;
+      switch (suffix) {
+        case INC: {
+          const ev = existing?.val ?? 0;
+          resolved = { val: ev + incoming.val, ts: incoming.ts };
+          hasCombinableOps = true;
+          break;
+        }
+        case BIT: {
+          const ev = existing?.val ?? 0;
+          resolved = { val: applyBitmask(ev, incoming.val), ts: incoming.ts };
+          hasCombinableOps = true;
+          break;
+        }
+        case MAX: {
+          const ev = existing?.val ?? 0;
+          resolved = incoming.val >= ev ? incoming : existing;
+          if (resolved === existing) continue;
+          break;
+        }
+        case TXT: {
+          hasCombinableOps = true;
+          const log = await this._db.getTextLog(docId, key, change.rev);
+          let delta = new Delta(incoming.val);
+          for (const entry of log) {
+            const serverDelta = new Delta(entry.delta);
+            delta = serverDelta.transform(delta, true);
+          }
+          const base = existing?.val ? new Delta(existing.val) : new Delta();
+          resolved = { val: base.compose(delta).ops, ts: incoming.ts };
+          await this._db.appendTextLog(docId, { key, delta: delta.ops, rev: rev + 1 });
+          resultFields[key] = { val: delta.ops, ts: incoming.ts };
+          await this._handleLargeValue(docId, key, resolved);
+          const toSave2 = {};
+          toSave2[key] = resolved;
+          await this._db.setFields(docId, toSave2);
+          continue;
+        }
+        default: {
+          if (existing && incoming.ts < existing.ts) continue;
+          resolved = incoming;
+        }
+      }
+      await this._handleLargeValue(docId, key, resolved);
+      resultFields[key] = resolved;
+      const toSave = {};
+      toSave[key] = resolved;
+      await this._db.setFields(docId, toSave);
+    }
+    if (hasCombinableOps) {
+      await this._db.addChange(docId, { changeId: change.id, ts: Date.now() });
+    }
+    rev++;
+    await this._db.setRev(docId, rev);
+    if (Object.keys(resultFields).length) {
+      this._broadcast(docId, resultFields, rev);
+    }
+    return { rev, fields: resultFields };
+  }
+  /** Compact text log entries up to a revision. */
+  async compactTextLog(docId, key, throughRev) {
+    const entries = await this._db.getTextLog(docId, key, 0);
+    if (entries.length < 2) return;
+    const toCompose = entries.filter((e) => e.rev <= throughRev);
+    if (toCompose.length < 2) return;
+    let composed = new Delta(toCompose[0].delta);
+    for (let i = 1; i < toCompose.length; i++) {
+      composed = composed.compose(new Delta(toCompose[i].delta));
+    }
+    await this._db.compactTextLog(docId, key, throughRev, composed.ops);
+  }
+  /** Prune old change log entries. */
+  async pruneChanges(docId, beforeTs) {
+    await this._db.pruneChanges(docId, beforeTs);
+  }
+  /** Subscribe to changes for a document. */
+  subscribe(docId, cb) {
+    let subs = this._subs.get(docId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this._subs.set(docId, subs);
+    }
+    subs.add(cb);
+    return () => {
+      subs.delete(cb);
+      if (!subs.size) this._subs.delete(docId);
+    };
+  }
+  /** Get subscriber count for a document. */
+  subscriberCount(docId) {
+    return this._subs.get(docId)?.size ?? 0;
+  }
+  _broadcast(docId, fields, rev, exclude) {
+    const subs = this._subs.get(docId);
+    if (!subs) return;
+    for (const cb of subs) {
+      if (cb !== exclude) cb(fields, rev);
+    }
+  }
+  async _handleLargeValue(docId, key, field) {
+    if (!this._objects) return;
+    const json = JSON.stringify(field.val);
+    if (json.length > REF_THRESHOLD) {
+      const ref = await this._objects.put(`${docId}/${key}`, field.val);
+      field.val = { __ref: ref, __rev: field.ts };
+    }
+  }
+}
+class MemoryDbBackend {
+  _fields = /* @__PURE__ */ new Map();
+  _textLog = /* @__PURE__ */ new Map();
+  _changeLog = /* @__PURE__ */ new Map();
+  _revs = /* @__PURE__ */ new Map();
+  async getFields(docId) {
+    return { ...this._fields.get(docId) ?? {} };
+  }
+  async getField(docId, key) {
+    return this._fields.get(docId)?.[key] ?? null;
+  }
+  async setFields(docId, fields) {
+    const existing = this._fields.get(docId) ?? {};
+    this._fields.set(docId, { ...existing, ...fields });
+  }
+  async getTextLog(docId, key, sinceRev = 0) {
+    return (this._textLog.get(`${docId}:${key}`) ?? []).filter((e) => e.rev > sinceRev);
+  }
+  async appendTextLog(docId, entry) {
+    const k = `${docId}:${entry.key}`;
+    const log = this._textLog.get(k) ?? [];
+    log.push(entry);
+    this._textLog.set(k, log);
+  }
+  async compactTextLog(docId, key, throughRev, composedDelta) {
+    const k = `${docId}:${key}`;
+    const log = this._textLog.get(k) ?? [];
+    const remaining = log.filter((e) => e.rev > throughRev);
+    remaining.unshift({ key, delta: composedDelta, rev: throughRev });
+    this._textLog.set(k, remaining);
+  }
+  async hasChange(docId, changeId) {
+    return (this._changeLog.get(docId) ?? []).some((e) => e.changeId === changeId);
+  }
+  async addChange(docId, entry) {
+    const log = this._changeLog.get(docId) ?? [];
+    log.push(entry);
+    this._changeLog.set(docId, log);
+  }
+  async pruneChanges(docId, beforeTs) {
+    const log = this._changeLog.get(docId) ?? [];
+    this._changeLog.set(docId, log.filter((e) => e.ts >= beforeTs));
+  }
+  async getRev(docId) {
+    return this._revs.get(docId) ?? 0;
+  }
+  async setRev(docId, rev) {
+    this._revs.set(docId, rev);
+  }
+}
+export {
+  MemoryDbBackend,
+  MicroServer
+};

package/dist/micro/types.d.ts

@@ -0,0 +1,68 @@
+/** A field value with LWW timestamp. */
+interface Field {
+    val: any;
+    ts: number;
+}
+/** Map of dot-notation field keys (with optional suffix) to values. */
+type FieldMap = Record<string, Field>;
+/** A change sent from client to server. */
+interface Change {
+    id: string;
+    rev: number;
+    fields: FieldMap;
+}
+/** Result from server after committing a change. */
+interface CommitResult {
+    rev: number;
+    fields: FieldMap;
+}
+/** Full document state. */
+interface DocState {
+    rev: number;
+    fields: FieldMap;
+}
+/** Suffix constants for special field types. */
+declare const INC = "+";
+declare const BIT = "~";
+declare const TXT = "#";
+declare const MAX = "^";
+/** Parse a field key into its path and suffix (if any). */
+declare function parseSuffix(key: string): {
+    path: string;
+    suffix: string;
+};
+/** Server-side text log entry for OT. */
+interface TextLogEntry {
+    key: string;
+    delta: any;
+    rev: number;
+}
+/** Server-side change log entry for idempotency. */
+interface ChangeLogEntry {
+    changeId: string;
+    ts: number;
+}
+/** Pluggable server-side database backend. */
+interface DbBackend {
+    getFields(docId: string): Promise<FieldMap>;
+    getField(docId: string, key: string): Promise<Field | null>;
+    setFields(docId: string, fields: FieldMap): Promise<void>;
+    getTextLog(docId: string, key: string, sinceRev?: number): Promise<TextLogEntry[]>;
+    appendTextLog(docId: string, entry: TextLogEntry): Promise<void>;
+    compactTextLog(docId: string, key: string, throughRev: number, composedDelta: any): Promise<void>;
+    hasChange(docId: string, changeId: string): Promise<boolean>;
+    addChange(docId: string, entry: ChangeLogEntry): Promise<void>;
+    pruneChanges(docId: string, beforeTs: number): Promise<void>;
+    getRev(docId: string): Promise<number>;
+    setRev(docId: string, rev: number): Promise<void>;
+}
+/** Pluggable object storage for large values (S3/R2). */
+interface ObjectStore {
+    put(key: string, value: any): Promise<string>;
+    get(ref: string): Promise<any>;
+    del(ref: string): Promise<void>;
+}
+/** Large value threshold in bytes (64KB). */
+declare const REF_THRESHOLD = 65536;
+
+export { BIT, type Change, type ChangeLogEntry, type CommitResult, type DbBackend, type DocState, type Field, type FieldMap, INC, MAX, type ObjectStore, REF_THRESHOLD, TXT, type TextLogEntry, parseSuffix };

package/dist/micro/types.js

@@ -0,0 +1,16 @@
+import "../chunk-IZ2YBCUP.js";
+const INC = "+", BIT = "~", TXT = "#", MAX = "^";
+const SUFFIXES = /* @__PURE__ */ new Set([INC, BIT, TXT, MAX]);
+function parseSuffix(key) {
+  const last = key[key.length - 1];
+  return SUFFIXES.has(last) ? { path: key.slice(0, -1), suffix: last } : { path: key, suffix: "" };
+}
+const REF_THRESHOLD = 65536;
+export {
+  BIT,
+  INC,
+  MAX,
+  REF_THRESHOLD,
+  TXT,
+  parseSuffix
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {
@@ -41,6 +41,10 @@
     "./solid": {
       "import": "./dist/solid/index.js",
       "types": "./dist/solid/index.d.ts"
+    },
+    "./micro": {
+      "import": "./dist/micro/index.js",
+      "types": "./dist/micro/index.d.ts"
     }
   },
   "files": [