@dabble/patches 0.4.5 → 0.4.7

package/dist/client/PatchesDoc.js

@@ -1,155 +1,148 @@
-import { createStateFromSnapshot } from '../algorithms/client/createStateFromSnapshot.js';
-import { makeChange } from '../algorithms/client/makeChange.js';
-import { applyChanges } from '../algorithms/shared/applyChanges.js';
-import { signal } from '../event-signal.js';
-/**
- * Represents a document synchronized using JSON patches.
- * Manages committed state, pending (local-only) changes, and
- * changes currently being sent to the server.
- */
-export class PatchesDoc {
-    _id = null;
-    _state;
-    _snapshot;
-    _changeMetadata = {};
-    _syncing = null;
-    _maxPayloadBytes;
-    /** Subscribe to be notified before local state changes. */
-    onBeforeChange = signal();
-    /** Subscribe to be notified after local state changes are applied. */
-    onChange = signal();
-    /** Subscribe to be notified whenever state changes from any source. */
-    onUpdate = signal();
-    /** Subscribe to be notified when syncing state changes. */
-    onSyncing = signal();
-    /**
-     * Creates an instance of PatchesDoc.
-     * @param initialState Optional initial state.
-     * @param initialMetadata Optional metadata to add to generated changes.
-     * @param options Additional options for the document.
-     */
-    constructor(initialState = {}, initialMetadata = {}, options = {}) {
-        this._state = structuredClone(initialState);
-        this._snapshot = { state: this._state, rev: 0, changes: [] };
-        this._changeMetadata = initialMetadata;
-        this._maxPayloadBytes = options.maxPayloadBytes;
-    }
-    /** The unique identifier for this document, once assigned. */
-    get id() {
-        return this._id;
-    }
-    /** Current local state (committed + pending). */
-    get state() {
-        return this._state;
-    }
-    /** Are we currently syncing this document? */
-    get syncing() {
-        return this._syncing;
-    }
-    /** Last committed revision number from the server. */
-    get committedRev() {
-        return this._snapshot.rev;
-    }
-    /** Are there local changes that haven't been sent yet? */
-    get hasPending() {
-        return this._snapshot.changes.length > 0;
-    }
-    /** Subscribe to be notified whenever the state changes. */
-    subscribe(onUpdate) {
-        const unsub = this.onUpdate(onUpdate);
-        onUpdate(this._state);
-        return unsub;
-    }
-    /**
-     * Exports the document state for persistence.
-     * NOTE: Any changes currently marked as `sending` are included in the
-     * `changes` array alongside `pending` changes. On import, all changes
-     * are treated as pending.
-     */
-    export() {
-        return structuredClone(this._snapshot);
-    }
-    /**
-     * Imports previously exported document state.
-     * Resets sending state and treats all imported changes as pending.
-     */
-    import(snapshot) {
-        this._snapshot = structuredClone(snapshot);
-        this._state = createStateFromSnapshot(snapshot);
-        this.onUpdate.emit(this._state);
-    }
-    /**
-     * Sets metadata to be added to future changes.
-     */
-    setChangeMetadata(metadata) {
-        this._changeMetadata = metadata;
-    }
-    /**
-     * Applies an update to the local state, generating a patch and adding it to pending changes.
-     * @param mutator Function that uses JSONPatch methods with type-safe paths.
-     * @returns The generated Change objects.
-     */
-    change(mutator) {
-        const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxPayloadBytes);
-        if (changes.length === 0) {
-            return changes;
-        }
-        this._state = applyChanges(this._state, changes);
-        this._snapshot.changes.push(...changes);
-        this.onChange.emit(changes);
-        this.onUpdate.emit(this._state);
-        return changes;
-    }
-    /**
-     * Returns the pending changes for this document.
-     * @returns The pending changes.
-     */
-    getPendingChanges() {
-        return this._snapshot.changes;
-    }
-    /**
-     * Applies committed changes to the document. Should only be called from a sync provider.
-     * @param serverChanges The changes to apply.
-     * @param rebasedPendingChanges The rebased pending changes to apply.
-     */
-    applyCommittedChanges(serverChanges, rebasedPendingChanges) {
-        // Ensure server changes are sequential to the current committed revision
-        if (this._snapshot.rev !== serverChanges[0].rev - 1) {
-            throw new Error('Cannot apply committed changes to a doc that is not at the correct revision');
-        }
-        // Track IDs of pending changes for debugging
-        // const pendingIds = new Set(rebasedPendingChanges.map(c => c.id));
-        // Apply server changes to the base state of the snapshot
-        this._snapshot.state = applyChanges(this._snapshot.state, serverChanges);
-        this._snapshot.rev = serverChanges[serverChanges.length - 1].rev;
-        // The rebasedPendingChanges are the new complete set of pending changes
-        this._snapshot.changes = rebasedPendingChanges;
-        // Recalculate the live state from the updated snapshot
-        this._state = createStateFromSnapshot(this._snapshot);
-        this.onUpdate.emit(this._state);
-    }
-    /**
-     * Assigns an identifier to this document. Can only be set once.
-     * @param id The unique identifier for the document.
-     * @throws Error if the ID has already been set.
-     */
-    setId(id) {
-        if (this._id !== null && this._id !== id) {
-            throw new Error(`Document ID cannot be changed once set. Current: ${this._id}, Attempted: ${id}`);
-        }
-        if (this._id === null) {
-            this._id = id;
-        }
-    }
-    /**
-     * Updates the syncing state of the document.
-     * @param newSyncing The new syncing state.
-     */
-    updateSyncing(newSyncing) {
-        this._syncing = newSyncing;
-        this.onSyncing.emit(newSyncing);
-    }
-    toJSON() {
-        return this.export();
-    }
+import "../chunk-IZ2YBCUP.js";
+import { createStateFromSnapshot } from "../algorithms/client/createStateFromSnapshot.js";
+import { makeChange } from "../algorithms/client/makeChange.js";
+import { applyChanges } from "../algorithms/shared/applyChanges.js";
+import { signal } from "../event-signal.js";
+class PatchesDoc {
+  _id = null;
+  _state;
+  _snapshot;
+  _changeMetadata = {};
+  _syncing = null;
+  _maxPayloadBytes;
+  /** Subscribe to be notified before local state changes. */
+  onBeforeChange = signal();
+  /** Subscribe to be notified after local state changes are applied. */
+  onChange = signal();
+  /** Subscribe to be notified whenever state changes from any source. */
+  onUpdate = signal();
+  /** Subscribe to be notified when syncing state changes. */
+  onSyncing = signal();
+  /**
+   * Creates an instance of PatchesDoc.
+   * @param initialState Optional initial state.
+   * @param initialMetadata Optional metadata to add to generated changes.
+   * @param options Additional options for the document.
+   */
+  constructor(initialState = {}, initialMetadata = {}, options = {}) {
+    this._state = structuredClone(initialState);
+    this._snapshot = { state: this._state, rev: 0, changes: [] };
+    this._changeMetadata = initialMetadata;
+    this._maxPayloadBytes = options.maxPayloadBytes;
+  }
+  /** The unique identifier for this document, once assigned. */
+  get id() {
+    return this._id;
+  }
+  /** Current local state (committed + pending). */
+  get state() {
+    return this._state;
+  }
+  /** Are we currently syncing this document? */
+  get syncing() {
+    return this._syncing;
+  }
+  /** Last committed revision number from the server. */
+  get committedRev() {
+    return this._snapshot.rev;
+  }
+  /** Are there local changes that haven't been sent yet? */
+  get hasPending() {
+    return this._snapshot.changes.length > 0;
+  }
+  /** Subscribe to be notified whenever the state changes. */
+  subscribe(onUpdate) {
+    const unsub = this.onUpdate(onUpdate);
+    onUpdate(this._state);
+    return unsub;
+  }
+  /**
+   * Exports the document state for persistence.
+   * NOTE: Any changes currently marked as `sending` are included in the
+   * `changes` array alongside `pending` changes. On import, all changes
+   * are treated as pending.
+   */
+  export() {
+    return structuredClone(this._snapshot);
+  }
+  /**
+   * Imports previously exported document state.
+   * Resets sending state and treats all imported changes as pending.
+   */
+  import(snapshot) {
+    this._snapshot = structuredClone(snapshot);
+    this._state = createStateFromSnapshot(snapshot);
+    this.onUpdate.emit(this._state);
+  }
+  /**
+   * Sets metadata to be added to future changes.
+   */
+  setChangeMetadata(metadata) {
+    this._changeMetadata = metadata;
+  }
+  /**
+   * Applies an update to the local state, generating a patch and adding it to pending changes.
+   * @param mutator Function that uses JSONPatch methods with type-safe paths.
+   * @returns The generated Change objects.
+   */
+  change(mutator) {
+    const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxPayloadBytes);
+    if (changes.length === 0) {
+      return changes;
+    }
+    this._state = applyChanges(this._state, changes);
+    this._snapshot.changes.push(...changes);
+    this.onChange.emit(changes);
+    this.onUpdate.emit(this._state);
+    return changes;
+  }
+  /**
+   * Returns the pending changes for this document.
+   * @returns The pending changes.
+   */
+  getPendingChanges() {
+    return this._snapshot.changes;
+  }
+  /**
+   * Applies committed changes to the document. Should only be called from a sync provider.
+   * @param serverChanges The changes to apply.
+   * @param rebasedPendingChanges The rebased pending changes to apply.
+   */
+  applyCommittedChanges(serverChanges, rebasedPendingChanges) {
+    if (this._snapshot.rev !== serverChanges[0].rev - 1) {
+      throw new Error("Cannot apply committed changes to a doc that is not at the correct revision");
+    }
+    this._snapshot.state = applyChanges(this._snapshot.state, serverChanges);
+    this._snapshot.rev = serverChanges[serverChanges.length - 1].rev;
+    this._snapshot.changes = rebasedPendingChanges;
+    this._state = createStateFromSnapshot(this._snapshot);
+    this.onUpdate.emit(this._state);
+  }
+  /**
+   * Assigns an identifier to this document. Can only be set once.
+   * @param id The unique identifier for the document.
+   * @throws Error if the ID has already been set.
+   */
+  setId(id) {
+    if (this._id !== null && this._id !== id) {
+      throw new Error(`Document ID cannot be changed once set. Current: ${this._id}, Attempted: ${id}`);
+    }
+    if (this._id === null) {
+      this._id = id;
+    }
+  }
+  /**
+   * Updates the syncing state of the document.
+   * @param newSyncing The new syncing state.
+   */
+  updateSyncing(newSyncing) {
+    this._syncing = newSyncing;
+    this.onSyncing.emit(newSyncing);
+  }
+  toJSON() {
+    return this.export();
+  }
 }
+export {
+  PatchesDoc
+};

package/dist/client/PatchesHistoryClient.d.ts

@@ -1,17 +1,22 @@
-import type { PatchesAPI } from '../net/protocol/types.js';
-import type { Change, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../types.js';
+import { Signal } from '../event-signal.js';
+import { PatchesAPI } from '../net/protocol/types.js';
+import { VersionMetadata, ListVersionsOptions, EditableVersionMetadata, Change } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
 /**
  * Client-side history/scrubbing interface for a document.
  * Read-only: allows listing versions, loading states/changes, and scrubbing.
  */
-export declare class PatchesHistoryClient<T = any> {
+declare class PatchesHistoryClient<T = any> {
     private readonly api;
     /** Document ID */
     readonly id: string;
     /** Event signal for versions changes */
-    readonly onVersionsChange: import("../event-signal.js").Signal<(versions: VersionMetadata[]) => void>;
+    readonly onVersionsChange: Signal<(versions: VersionMetadata[]) => void>;
     /** Event signal for state changes */
-    readonly onStateChange: import("../event-signal.js").Signal<(state: T) => void>;
+    readonly onStateChange: Signal<(state: T) => void>;
     private _versions;
     private _state;
     private cache;
@@ -35,3 +40,5 @@ export declare class PatchesHistoryClient<T = any> {
     /** Clear caches and listeners */
     clear(): void;
 }
+
+export { PatchesHistoryClient };

package/dist/client/PatchesHistoryClient.js

@@ -1,125 +1,118 @@
-import { applyChanges } from '../algorithms/shared/applyChanges.js';
-import { signal } from '../event-signal.js';
+import "../chunk-IZ2YBCUP.js";
+import { applyChanges } from "../algorithms/shared/applyChanges.js";
+import { signal } from "../event-signal.js";
 class LRUCache {
-    maxSize;
-    cache = new Map();
-    constructor(maxSize) {
-        this.maxSize = maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
     }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            // Move to end (most recently used)
-            this.cache.delete(key);
-            this.cache.set(key, value);
-        }
-        return value;
-    }
-    set(key, value) {
-        if (this.cache.has(key))
-            this.cache.delete(key);
-        this.cache.set(key, value);
-        if (this.cache.size > this.maxSize) {
-            // Remove least recently used
-            const firstKeyIter = this.cache.keys().next();
-            if (!firstKeyIter.done) {
-                const firstKey = firstKeyIter.value;
-                this.cache.delete(firstKey);
-            }
-        }
-    }
-    clear() {
-        this.cache.clear();
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) this.cache.delete(key);
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const firstKeyIter = this.cache.keys().next();
+      if (!firstKeyIter.done) {
+        const firstKey = firstKeyIter.value;
+        this.cache.delete(firstKey);
+      }
     }
+  }
+  clear() {
+    this.cache.clear();
+  }
 }
-/**
- * Client-side history/scrubbing interface for a document.
- * Read-only: allows listing versions, loading states/changes, and scrubbing.
- */
-export class PatchesHistoryClient {
-    api;
-    /** Document ID */
-    id;
-    /** Event signal for versions changes */
-    onVersionsChange = signal();
-    /** Event signal for state changes */
-    onStateChange = signal();
-    _versions = [];
-    _state = null;
-    cache = new LRUCache(6);
-    constructor(id, api) {
-        this.api = api;
-        this.id = id;
-    }
-    /** List of loaded versions */
-    get versions() {
-        return this._versions;
-    }
-    /** Current state (for scrubbing) */
-    get state() {
-        return this._state;
-    }
-    /** List version metadata for this document (with options) */
-    async listVersions(options) {
-        this._versions = await this.api.listVersions(this.id, options);
-        this.onVersionsChange.emit(this._versions);
-        return this._versions;
-    }
-    /** Create a new named version snapshot of the document's current state. */
-    async createVersion(metadata) {
-        const versionId = await this.api.createVersion(this.id, metadata);
-        await this.listVersions(); // Refresh the list of versions
-        return versionId;
-    }
-    /** Update the name of a specific version. */
-    async updateVersion(versionId, metadata) {
-        await this.api.updateVersion(this.id, versionId, metadata);
-        await this.listVersions(); // Refresh the list of versions
-    }
-    /** Load the state for a specific version */
-    async getVersionState(versionId) {
-        let data = this.cache.get(versionId);
-        if (!data || data.state === undefined) {
-            const { state } = await this.api.getVersionState(this.id, versionId);
-            data = { ...data, state };
-            this.cache.set(versionId, data);
-        }
-        this._state = data.state;
-        this.onStateChange.emit(this._state);
-        return data.state;
-    }
-    /** Load the changes for a specific version */
-    async getVersionChanges(versionId) {
-        let data = this.cache.get(versionId);
-        if (!data || data.changes === undefined) {
-            const changes = await this.api.getVersionChanges(this.id, versionId);
-            data = { ...data, changes };
-            this.cache.set(versionId, data);
-        }
-        return data.changes;
+class PatchesHistoryClient {
+  constructor(id, api) {
+    this.api = api;
+    this.id = id;
+  }
+  /** Document ID */
+  id;
+  /** Event signal for versions changes */
+  onVersionsChange = signal();
+  /** Event signal for state changes */
+  onStateChange = signal();
+  _versions = [];
+  _state = null;
+  cache = new LRUCache(6);
+  /** List of loaded versions */
+  get versions() {
+    return this._versions;
+  }
+  /** Current state (for scrubbing) */
+  get state() {
+    return this._state;
+  }
+  /** List version metadata for this document (with options) */
+  async listVersions(options) {
+    this._versions = await this.api.listVersions(this.id, options);
+    this.onVersionsChange.emit(this._versions);
+    return this._versions;
+  }
+  /** Create a new named version snapshot of the document's current state. */
+  async createVersion(metadata) {
+    const versionId = await this.api.createVersion(this.id, metadata);
+    await this.listVersions();
+    return versionId;
+  }
+  /** Update the name of a specific version. */
+  async updateVersion(versionId, metadata) {
+    await this.api.updateVersion(this.id, versionId, metadata);
+    await this.listVersions();
+  }
+  /** Load the state for a specific version */
+  async getVersionState(versionId) {
+    let data = this.cache.get(versionId);
+    if (!data || data.state === void 0) {
+      const { state } = await this.api.getVersionState(this.id, versionId);
+      data = { ...data, state };
+      this.cache.set(versionId, data);
     }
-    /** Scrub to a specific change within a version where changeIndex is 1-based and 0 is the parent version */
-    async scrubTo(versionId, changeIndex) {
-        const version = this.versions.find(v => v.id === versionId);
-        // Load state and changes for the version
-        const [state, changes] = await Promise.all([
-            version?.parentId ? this.getVersionState(version.parentId) : undefined,
-            this.getVersionChanges(versionId),
-        ]);
-        // Apply changes up to changeIndex to the state (if needed)
-        if (changeIndex > 0) {
-            this._state = applyChanges(state, changes.slice(0, changeIndex));
-        }
-        this.onStateChange.emit(this._state);
+    this._state = data.state;
+    this.onStateChange.emit(this._state);
+    return data.state;
+  }
+  /** Load the changes for a specific version */
+  async getVersionChanges(versionId) {
+    let data = this.cache.get(versionId);
+    if (!data || data.changes === void 0) {
+      const changes = await this.api.getVersionChanges(this.id, versionId);
+      data = { ...data, changes };
+      this.cache.set(versionId, data);
     }
-    /** Clear caches and listeners */
-    clear() {
-        this._versions = [];
-        this._state = null;
-        this.onVersionsChange.emit(this._versions);
-        this.onStateChange.emit(this._state);
-        this.cache.clear();
-        this.onVersionsChange.clear();
-        this.onStateChange.clear();
+    return data.changes;
+  }
+  /** Scrub to a specific change within a version where changeIndex is 1-based and 0 is the parent version */
+  async scrubTo(versionId, changeIndex) {
+    const version = this.versions.find((v) => v.id === versionId);
+    const [state, changes] = await Promise.all([
+      version?.parentId ? this.getVersionState(version.parentId) : void 0,
+      this.getVersionChanges(versionId)
+    ]);
+    if (changeIndex > 0) {
+      this._state = applyChanges(state, changes.slice(0, changeIndex));
     }
+    this.onStateChange.emit(this._state);
+  }
+  /** Clear caches and listeners */
+  clear() {
+    this._versions = [];
+    this._state = null;
+    this.onVersionsChange.emit(this._versions);
+    this.onStateChange.emit(this._state);
+    this.cache.clear();
+    this.onVersionsChange.clear();
+    this.onStateChange.clear();
+  }
 }
+export {
+  PatchesHistoryClient
+};

package/dist/client/PatchesStore.d.ts

@@ -1,6 +1,10 @@
-import type { Change, PatchesSnapshot, PatchesState } from '../types.js';
+import { PatchesSnapshot, Change, PatchesState } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
 /** Represents metadata for a document tracked by the store. */
-export interface TrackedDoc {
+interface TrackedDoc {
     docId: string;
     /** The last revision number confirmed by the server. */
     committedRev: number;
@@ -11,7 +15,7 @@ export interface TrackedDoc {
  * Pluggable persistence layer contract used by Patches + PatchesSync.
  * It is *not* strictly offline; an in‑memory implementation fulfils the same contract.
  */
-export interface PatchesStore {
+interface PatchesStore {
     /**
      * Registers documents for local tracking and synchronization.
      *
@@ -214,3 +218,5 @@ export interface PatchesStore {
      */
     close(): Promise<void>;
 }
+
+export type { PatchesStore, TrackedDoc };

package/dist/client/PatchesStore.js

@@ -1 +0,0 @@
-export {};

package/dist/client/index.d.ts

@@ -1,6 +1,12 @@
-export * from './IndexedDBStore.js';
-export * from './InMemoryStore.js';
-export * from './Patches.js';
-export * from './PatchesDoc.js';
-export * from './PatchesHistoryClient.js';
-export type * from './PatchesStore.js';
+export { IndexedDBStore } from './IndexedDBStore.js';
+export { InMemoryStore } from './InMemoryStore.js';
+export { Patches, PatchesOptions } from './Patches.js';
+export { PatchesDoc, PatchesDocOptions } from './PatchesDoc.js';
+export { PatchesHistoryClient } from './PatchesHistoryClient.js';
+export { PatchesStore, TrackedDoc } from './PatchesStore.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../event-signal.js';
+import '../net/protocol/types.js';

package/dist/client/index.js

@@ -1,5 +1,5 @@
-export * from './IndexedDBStore.js';
-export * from './InMemoryStore.js';
-export * from './Patches.js';
-export * from './PatchesDoc.js';
-export * from './PatchesHistoryClient.js';
+export * from "./IndexedDBStore.js";
+export * from "./InMemoryStore.js";
+export * from "./Patches.js";
+export * from "./PatchesDoc.js";
+export * from "./PatchesHistoryClient.js";