@dabble/patches 0.4.4 → 0.4.6

package/dist/client/Patches.d.ts

@@ -1,8 +1,12 @@
-import { type Unsubscriber } from '../event-signal.js';
-import type { Change } from '../types.js';
-import { PatchesDoc, type PatchesDocOptions } from './PatchesDoc.js';
-import type { PatchesStore } from './PatchesStore.js';
-export interface PatchesOptions {
+import { Unsubscriber, Signal } from '../event-signal.js';
+import { Change } from '../types.js';
+import { PatchesDocOptions, PatchesDoc } from './PatchesDoc.js';
+import { PatchesStore } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
+interface PatchesOptions {
     /** Persistence layer instance (e.g., new IndexedDBStore('my-db') or new InMemoryStore()). */
     store: PatchesStore;
     /** Initial metadata to attach to changes from this client (merged with per-doc metadata). */
@@ -19,20 +23,20 @@ interface ManagedDoc<T extends object> {
  * Manages document instances (`PatchesDoc`) and persistence (`PatchesStore`).
  * Can be used standalone or with PatchesSync for network synchronization.
  */
-export declare class Patches {
+declare class Patches {
     protected options: PatchesOptions;
     protected docs: Map<string, ManagedDoc<any>>;
     readonly docOptions: PatchesDocOptions;
     readonly store: PatchesStore;
     readonly trackedDocs: Set<string>;
-    readonly onError: import("../event-signal.js").Signal<(error: Error, context?: {
+    readonly onError: Signal<(error: Error, context?: {
         docId?: string;
     }) => void>;
-    readonly onServerCommit: import("../event-signal.js").Signal<(docId: string, changes: Change[]) => void>;
-    readonly onTrackDocs: import("../event-signal.js").Signal<(docIds: string[]) => void>;
-    readonly onUntrackDocs: import("../event-signal.js").Signal<(docIds: string[]) => void>;
-    readonly onDeleteDoc: import("../event-signal.js").Signal<(docId: string) => void>;
-    readonly onChange: import("../event-signal.js").Signal<(docId: string, changes: Change[]) => void>;
+    readonly onServerCommit: Signal<(docId: string, changes: Change[]) => void>;
+    readonly onTrackDocs: Signal<(docIds: string[]) => void>;
+    readonly onUntrackDocs: Signal<(docIds: string[]) => void>;
+    readonly onDeleteDoc: Signal<(docId: string) => void>;
+    readonly onChange: Signal<(docId: string, changes: Change[]) => void>;
     constructor(opts: PatchesOptions);
     /**
      * Tracks the given document IDs, adding them to the set of tracked documents and notifying listeners.
@@ -91,4 +95,5 @@ export declare class Patches {
      */
     protected _savePendingChanges(docId: string, changes: Change[]): Promise<void>;
 }
-export {};
+
+export { Patches, type PatchesOptions };

package/dist/client/Patches.js

@@ -1,210 +1,155 @@
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+import {
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __publicField,
+  __runInitializers
+} from "../chunk-IZ2YBCUP.js";
+var _openDoc_dec, _init;
+import { signal } from "../event-signal.js";
+import { singleInvocation } from "../utils/concurrency.js";
+import { PatchesDoc } from "./PatchesDoc.js";
+_openDoc_dec = [singleInvocation(true)];
+class Patches {
+  constructor(opts) {
+    __runInitializers(_init, 5, this);
+    __publicField(this, "options");
+    __publicField(this, "docs", /* @__PURE__ */ new Map());
+    __publicField(this, "docOptions");
+    __publicField(this, "store");
+    __publicField(this, "trackedDocs", /* @__PURE__ */ new Set());
+    // Public signals
+    __publicField(this, "onError", signal());
+    __publicField(this, "onServerCommit", signal());
+    __publicField(this, "onTrackDocs", signal());
+    __publicField(this, "onUntrackDocs", signal());
+    __publicField(this, "onDeleteDoc", signal());
+    __publicField(this, "onChange", signal());
+    this.options = opts;
+    this.store = opts.store;
+    this.docOptions = opts.docOptions ?? {};
+    this.store.listDocs().then((docs) => {
+      this.trackDocs(docs.map(({ docId }) => docId));
+    });
+  }
+  // --- Public API Methods ---
+  /**
+   * Tracks the given document IDs, adding them to the set of tracked documents and notifying listeners.
+   * Tracked docs are kept in sync with the server, even when not open locally.
+   * This allows for background syncing and updates of unopened documents.
+   * @param docIds - Array of document IDs to track.
+   */
+  async trackDocs(docIds) {
+    docIds = docIds.filter((id) => !this.trackedDocs.has(id));
+    if (!docIds.length) return;
+    docIds.forEach(this.trackedDocs.add, this.trackedDocs);
+    this.onTrackDocs.emit(docIds);
+    await this.store.trackDocs(docIds);
+  }
+  /**
+   * Untracks the given document IDs, removing them from the set of tracked documents and notifying listeners.
+   * Untracked docs will no longer be kept in sync with the server, even if not open locally.
+   * Closes any open docs and removes them from the store.
+   * @param docIds - Array of document IDs to untrack.
+   */
+  async untrackDocs(docIds) {
+    docIds = docIds.filter((id) => this.trackedDocs.has(id));
+    if (!docIds.length) return;
+    docIds.forEach(this.trackedDocs.delete, this.trackedDocs);
+    this.onUntrackDocs.emit(docIds);
+    const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
+    await Promise.all(closedPromises);
+    await this.store.untrackDocs(docIds);
+  }
+  // ensure a second call to openDoc with the same docId returns the same promise while opening
+  async openDoc(docId, opts = {}) {
+    const existing = this.docs.get(docId);
+    if (existing) return existing.doc;
+    await this.trackDocs([docId]);
+    const snapshot = await this.store.getDoc(docId);
+    const initialState = snapshot?.state ?? {};
+    const mergedMetadata = { ...this.options.metadata, ...opts.metadata };
+    const doc = new PatchesDoc(initialState, mergedMetadata, this.docOptions);
+    doc.setId(docId);
+    if (snapshot) {
+      doc.import(snapshot);
     }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
+    const unsubscribe = doc.onChange((changes) => this._savePendingChanges(docId, changes));
+    this.docs.set(docId, { doc, unsubscribe });
+    return doc;
+  }
+  /**
+   * Closes an open document by ID, removing listeners and optionally untracking it.
+   * @param docId - The document ID to close.
+   * @param options - Optional: set untrack to true to also untrack the doc.
+   */
+  async closeDoc(docId, { untrack = false } = {}) {
+    const managed = this.docs.get(docId);
+    if (managed) {
+      managed.unsubscribe();
+      this.docs.delete(docId);
+      if (untrack) {
+        await this.untrackDocs([docId]);
+      }
+    }
+  }
+  /**
+   * Deletes a document by ID, closing it if open, untracking it, and removing it from the store.
+   * Emits the onDeleteDoc signal.
+   * @param docId - The document ID to delete.
+   */
+  async deleteDoc(docId) {
+    if (this.docs.has(docId)) {
+      await this.closeDoc(docId);
+    }
+    if (this.trackedDocs.has(docId)) {
+      await this.untrackDocs([docId]);
+    }
+    await this.store.deleteDoc(docId);
+    this.onDeleteDoc.emit(docId);
+  }
+  /**
+   * Gets an open document instance by ID, if it exists.
+   * Used by PatchesSync for applying server changes to open docs.
+   * @param docId - The document ID to get.
+   * @returns The PatchesDoc instance or undefined if not open.
+   */
+  getOpenDoc(docId) {
+    return this.docs.get(docId)?.doc;
+  }
+  /**
+   * Closes all open documents and cleans up listeners and store connections.
+   * Should be called when shutting down the client.
+   */
+  close() {
+    this.docs.forEach((managed) => managed.unsubscribe());
+    this.docs.clear();
+    this.store.close();
+    this.onChange.clear();
+    this.onDeleteDoc.clear();
+    this.onUntrackDocs.clear();
+    this.onTrackDocs.clear();
+    this.onServerCommit.clear();
+    this.onError.clear();
+  }
+  /**
+   * Internal handler for saving pending changes to the store.
+   * @param docId - The document ID to save the changes for.
+   * @param changes - The changes to save.
+   */
+  async _savePendingChanges(docId, changes) {
+    try {
+      await this.store.savePendingChanges(docId, changes);
+      this.onChange.emit(docId, changes);
+    } catch (err) {
+      console.error(`Error saving pending changes for doc ${docId}:`, err);
+      this.onError.emit(err, { docId });
     }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
+  }
+}
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "openDoc", _openDoc_dec, Patches);
+__decoratorMetadata(_init, Patches);
+export {
+  Patches
 };
-import { signal } from '../event-signal.js';
-import { singleInvocation } from '../utils/concurrency.js';
-import { PatchesDoc } from './PatchesDoc.js';
-/**
- * Main client-side entry point for the Patches library.
- * Manages document instances (`PatchesDoc`) and persistence (`PatchesStore`).
- * Can be used standalone or with PatchesSync for network synchronization.
- */
-let Patches = (() => {
-    let _instanceExtraInitializers = [];
-    let _openDoc_decorators;
-    return class Patches {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _openDoc_decorators = [singleInvocation(true)];
-            __esDecorate(this, null, _openDoc_decorators, { kind: "method", name: "openDoc", static: false, private: false, access: { has: obj => "openDoc" in obj, get: obj => obj.openDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        options = __runInitializers(this, _instanceExtraInitializers);
-        docs = new Map();
-        docOptions;
-        store;
-        trackedDocs = new Set();
-        // Public signals
-        onError = signal();
-        onServerCommit = signal();
-        onTrackDocs = signal();
-        onUntrackDocs = signal();
-        onDeleteDoc = signal();
-        onChange = signal();
-        constructor(opts) {
-            this.options = opts;
-            this.store = opts.store;
-            this.docOptions = opts.docOptions ?? {};
-            this.store.listDocs().then(docs => {
-                this.trackDocs(docs.map(({ docId }) => docId));
-            });
-        }
-        // --- Public API Methods ---
-        /**
-         * Tracks the given document IDs, adding them to the set of tracked documents and notifying listeners.
-         * Tracked docs are kept in sync with the server, even when not open locally.
-         * This allows for background syncing and updates of unopened documents.
-         * @param docIds - Array of document IDs to track.
-         */
-        async trackDocs(docIds) {
-            docIds = docIds.filter(id => !this.trackedDocs.has(id));
-            if (!docIds.length)
-                return;
-            docIds.forEach(this.trackedDocs.add, this.trackedDocs);
-            this.onTrackDocs.emit(docIds);
-            await this.store.trackDocs(docIds);
-        }
-        /**
-         * Untracks the given document IDs, removing them from the set of tracked documents and notifying listeners.
-         * Untracked docs will no longer be kept in sync with the server, even if not open locally.
-         * Closes any open docs and removes them from the store.
-         * @param docIds - Array of document IDs to untrack.
-         */
-        async untrackDocs(docIds) {
-            docIds = docIds.filter(id => this.trackedDocs.has(id));
-            if (!docIds.length)
-                return;
-            docIds.forEach(this.trackedDocs.delete, this.trackedDocs);
-            this.onUntrackDocs.emit(docIds);
-            // Close any open PatchesDoc instances first
-            const closedPromises = docIds.filter(id => this.docs.has(id)).map(id => this.closeDoc(id)); // closeDoc removes from this.docs map
-            await Promise.all(closedPromises);
-            // Remove from store
-            await this.store.untrackDocs(docIds);
-        }
-        /**
-         * Opens a document by ID, loading its state from the store and setting up change listeners.
-         * If the doc is already open, returns the existing instance.
-         * @param docId - The document ID to open.
-         * @param opts - Optional metadata to merge with the doc's metadata.
-         * @returns The opened PatchesDoc instance.
-         */
-        async openDoc(docId, opts = {}) {
-            const existing = this.docs.get(docId);
-            if (existing)
-                return existing.doc;
-            // Ensure the doc is tracked before proceeding
-            await this.trackDocs([docId]);
-            // Load initial state from store
-            const snapshot = await this.store.getDoc(docId);
-            const initialState = (snapshot?.state ?? {});
-            const mergedMetadata = { ...this.options.metadata, ...opts.metadata };
-            const doc = new PatchesDoc(initialState, mergedMetadata, this.docOptions);
-            doc.setId(docId);
-            if (snapshot) {
-                doc.import(snapshot);
-            }
-            // Set up local listener -> store
-            const unsubscribe = doc.onChange(changes => this._savePendingChanges(docId, changes));
-            this.docs.set(docId, { doc, unsubscribe });
-            return doc;
-        }
-        /**
-         * Closes an open document by ID, removing listeners and optionally untracking it.
-         * @param docId - The document ID to close.
-         * @param options - Optional: set untrack to true to also untrack the doc.
-         */
-        async closeDoc(docId, { untrack = false } = {}) {
-            const managed = this.docs.get(docId);
-            if (managed) {
-                managed.unsubscribe();
-                this.docs.delete(docId);
-                if (untrack) {
-                    await this.untrackDocs([docId]);
-                }
-            }
-        }
-        /**
-         * Deletes a document by ID, closing it if open, untracking it, and removing it from the store.
-         * Emits the onDeleteDoc signal.
-         * @param docId - The document ID to delete.
-         */
-        async deleteDoc(docId) {
-            // Close if open locally
-            if (this.docs.has(docId)) {
-                await this.closeDoc(docId);
-            }
-            // Unsubscribe from server if tracked (deletes the doc from the store before the next step adds a tombstone)
-            if (this.trackedDocs.has(docId)) {
-                await this.untrackDocs([docId]);
-            }
-            // Mark document as deleted in store (adds a tombstone until sync commits it)
-            await this.store.deleteDoc(docId);
-            this.onDeleteDoc.emit(docId);
-        }
-        /**
-         * Gets an open document instance by ID, if it exists.
-         * Used by PatchesSync for applying server changes to open docs.
-         * @param docId - The document ID to get.
-         * @returns The PatchesDoc instance or undefined if not open.
-         */
-        getOpenDoc(docId) {
-            return this.docs.get(docId)?.doc;
-        }
-        /**
-         * Closes all open documents and cleans up listeners and store connections.
-         * Should be called when shutting down the client.
-         */
-        close() {
-            // Clean up local PatchesDoc listeners
-            this.docs.forEach(managed => managed.unsubscribe());
-            this.docs.clear();
-            // Close store connection
-            this.store.close();
-            this.onChange.clear();
-            this.onDeleteDoc.clear();
-            this.onUntrackDocs.clear();
-            this.onTrackDocs.clear();
-            this.onServerCommit.clear();
-            this.onError.clear();
-        }
-        /**
-         * Internal handler for saving pending changes to the store.
-         * @param docId - The document ID to save the changes for.
-         * @param changes - The changes to save.
-         */
-        async _savePendingChanges(docId, changes) {
-            try {
-                await this.store.savePendingChanges(docId, changes);
-                // Only after it is persisted, emit the change (for PatchesSync to flush)
-                this.onChange.emit(docId, changes);
-            }
-            catch (err) {
-                console.error(`Error saving pending changes for doc ${docId}:`, err);
-                this.onError.emit(err, { docId });
-            }
-        }
-    };
-})();
-export { Patches };

package/dist/client/PatchesDoc.d.ts

@@ -1,9 +1,13 @@
-import { type Unsubscriber } from '../event-signal.js';
-import type { Change, ChangeMutator, PatchesSnapshot, SyncingState } from '../types.js';
+import { Signal, Unsubscriber } from '../event-signal.js';
+import { PatchesSnapshot, SyncingState, Change, ChangeMutator } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
 /**
  * Options for creating a PatchesDoc instance
  */
-export interface PatchesDocOptions {
+interface PatchesDocOptions {
     /**
      * Maximum size in bytes for a single payload (network message).
      * Changes exceeding this will be split into multiple smaller changes.
@@ -15,7 +19,7 @@ export interface PatchesDocOptions {
  * Manages committed state, pending (local-only) changes, and
  * changes currently being sent to the server.
  */
-export declare class PatchesDoc<T extends object = object> {
+declare class PatchesDoc<T extends object = object> {
     protected _id: string | null;
     protected _state: T;
     protected _snapshot: PatchesSnapshot<T>;
@@ -23,13 +27,13 @@ export declare class PatchesDoc<T extends object = object> {
     protected _syncing: SyncingState;
     protected readonly _maxPayloadBytes?: number;
     /** Subscribe to be notified before local state changes. */
-    readonly onBeforeChange: import("../event-signal.js").Signal<(change: Change) => void>;
+    readonly onBeforeChange: Signal<(change: Change) => void>;
     /** Subscribe to be notified after local state changes are applied. */
-    readonly onChange: import("../event-signal.js").Signal<(changes: Change[]) => void>;
+    readonly onChange: Signal<(changes: Change[]) => void>;
     /** Subscribe to be notified whenever state changes from any source. */
-    readonly onUpdate: import("../event-signal.js").Signal<(newState: T) => void>;
+    readonly onUpdate: Signal<(newState: T) => void>;
     /** Subscribe to be notified when syncing state changes. */
-    readonly onSyncing: import("../event-signal.js").Signal<(newSyncing: SyncingState) => void>;
+    readonly onSyncing: Signal<(newSyncing: SyncingState) => void>;
     /**
      * Creates an instance of PatchesDoc.
      * @param initialState Optional initial state.
@@ -95,3 +99,5 @@ export declare class PatchesDoc<T extends object = object> {
     updateSyncing(newSyncing: SyncingState): void;
     toJSON(): PatchesSnapshot<T>;
 }
+
+export { PatchesDoc, type PatchesDocOptions };