@dabble/patches 0.5.6 → 0.5.7

package/dist/vue/doc-manager.d.ts

@@ -0,0 +1,88 @@
+import { Patches } from '../client/Patches.js';
+import { PatchesDoc } from '../client/PatchesDoc.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesStore.js';
+import '../algorithms/shared/changeBatching.js';
+
+/**
+ * Reference counting manager for PatchesDoc instances.
+ *
+ * Tracks how many Vue components are using each document and only opens/closes
+ * documents when the reference count goes to/from zero.
+ *
+ * This prevents the footgun where multiple components open the same doc but the
+ * first one to unmount closes it for everyone else.
+ */
+declare class DocManager {
+    private refCounts;
+    private pendingOps;
+    /**
+     * Opens a document with reference counting.
+     *
+     * - If this is the first reference, calls patches.openDoc()
+     * - If doc is already open, returns existing instance and increments count
+     * - Handles concurrent opens to the same doc safely
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to open
+     * @returns Promise resolving to PatchesDoc instance
+     */
+    openDoc<T extends object>(patches: Patches, docId: string): Promise<PatchesDoc<T>>;
+    /**
+     * Closes a document with reference counting.
+     *
+     * - Decrements the reference count
+     * - Only calls patches.closeDoc() when count reaches zero
+     * - Safe to call even if doc was never opened
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to close
+     */
+    closeDoc(patches: Patches, docId: string): Promise<void>;
+    /**
+     * Increments the reference count for a document without opening it.
+     *
+     * Used in explicit mode to track usage and prevent premature closes
+     * from autoClose mode.
+     *
+     * @param docId - Document ID
+     */
+    incrementRefCount(docId: string): void;
+    /**
+     * Decrements the reference count for a document without closing it.
+     *
+     * Used in explicit mode to release usage tracking.
+     *
+     * @param docId - Document ID
+     */
+    decrementRefCount(docId: string): void;
+    /**
+     * Gets the current reference count for a document.
+     *
+     * Useful for debugging or advanced use cases.
+     *
+     * @param docId - Document ID
+     * @returns Current reference count (0 if not tracked)
+     */
+    getRefCount(docId: string): number;
+    /**
+     * Clears all reference counts without closing documents.
+     *
+     * Use with caution - this is mainly for testing or cleanup scenarios
+     * where you want to reset the manager state.
+     */
+    reset(): void;
+}
+/**
+ * Gets or creates a DocManager for a Patches instance.
+ *
+ * @param patches - Patches instance
+ * @returns DocManager for this Patches instance
+ */
+declare function getDocManager(patches: Patches): DocManager;
+
+export { DocManager, getDocManager };

package/dist/vue/doc-manager.js

@@ -0,0 +1,125 @@
+import "../chunk-IZ2YBCUP.js";
+class DocManager {
+  refCounts = /* @__PURE__ */ new Map();
+  pendingOps = /* @__PURE__ */ new Map();
+  /**
+   * Opens a document with reference counting.
+   *
+   * - If this is the first reference, calls patches.openDoc()
+   * - If doc is already open, returns existing instance and increments count
+   * - Handles concurrent opens to the same doc safely
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to open
+   * @returns Promise resolving to PatchesDoc instance
+   */
+  async openDoc(patches, docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0 && this.pendingOps.has(docId)) {
+      const doc = await this.pendingOps.get(docId);
+      this.refCounts.set(docId, (this.refCounts.get(docId) || 0) + 1);
+      return doc;
+    }
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount + 1);
+      const doc = patches.getOpenDoc(docId);
+      if (!doc) {
+        throw new Error(`Document ${docId} has ref count ${currentCount} but is not open in Patches`);
+      }
+      return doc;
+    }
+    const openPromise = patches.openDoc(docId);
+    this.pendingOps.set(docId, openPromise);
+    try {
+      const doc = await openPromise;
+      this.refCounts.set(docId, 1);
+      return doc;
+    } catch (error) {
+      this.refCounts.delete(docId);
+      throw error;
+    } finally {
+      this.pendingOps.delete(docId);
+    }
+  }
+  /**
+   * Closes a document with reference counting.
+   *
+   * - Decrements the reference count
+   * - Only calls patches.closeDoc() when count reaches zero
+   * - Safe to call even if doc was never opened
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to close
+   */
+  async closeDoc(patches, docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0) {
+      return;
+    }
+    if (currentCount === 1) {
+      this.refCounts.delete(docId);
+      await patches.closeDoc(docId);
+    } else {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Increments the reference count for a document without opening it.
+   *
+   * Used in explicit mode to track usage and prevent premature closes
+   * from autoClose mode.
+   *
+   * @param docId - Document ID
+   */
+  incrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    this.refCounts.set(docId, currentCount + 1);
+  }
+  /**
+   * Decrements the reference count for a document without closing it.
+   *
+   * Used in explicit mode to release usage tracking.
+   *
+   * @param docId - Document ID
+   */
+  decrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Gets the current reference count for a document.
+   *
+   * Useful for debugging or advanced use cases.
+   *
+   * @param docId - Document ID
+   * @returns Current reference count (0 if not tracked)
+   */
+  getRefCount(docId) {
+    return this.refCounts.get(docId) || 0;
+  }
+  /**
+   * Clears all reference counts without closing documents.
+   *
+   * Use with caution - this is mainly for testing or cleanup scenarios
+   * where you want to reset the manager state.
+   */
+  reset() {
+    this.refCounts.clear();
+    this.pendingOps.clear();
+  }
+}
+const managers = /* @__PURE__ */ new WeakMap();
+function getDocManager(patches) {
+  let manager = managers.get(patches);
+  if (!manager) {
+    manager = new DocManager();
+    managers.set(patches, manager);
+  }
+  return manager;
+}
+export {
+  DocManager,
+  getDocManager
+};

package/dist/vue/index.d.ts

@@ -0,0 +1,19 @@
+export { PATCHES_KEY, PATCHES_SYNC_KEY, PatchesContext, providePatches, providePatchesContext, usePatchesContext } from './provider.js';
+export { UsePatchesDocOptions, UsePatchesDocReturn, UsePatchesSyncReturn, providePatchesDoc, useCurrentDoc, usePatchesDoc, usePatchesSync } from './composables.js';
+export { DocManager, getDocManager } from './doc-manager.js';
+import 'vue';
+import '../client/Patches.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesDoc.js';
+import '../algorithms/shared/changeBatching.js';
+import '../client/PatchesStore.js';
+import '../net/PatchesSync.js';
+import '../net/protocol/JSONRPCClient.js';
+import '../net/protocol/types.js';
+import '../net/websocket/PatchesWebSocket.js';
+import '../net/PatchesClient.js';
+import '../net/websocket/WebSocketTransport.js';

package/dist/vue/index.js

@@ -0,0 +1,28 @@
+import "../chunk-IZ2YBCUP.js";
+import {
+  PATCHES_KEY,
+  PATCHES_SYNC_KEY,
+  providePatchesContext,
+  providePatches,
+  usePatchesContext
+} from "./provider.js";
+import {
+  usePatchesDoc,
+  usePatchesSync,
+  providePatchesDoc,
+  useCurrentDoc
+} from "./composables.js";
+import { DocManager, getDocManager } from "./doc-manager.js";
+export {
+  DocManager,
+  PATCHES_KEY,
+  PATCHES_SYNC_KEY,
+  getDocManager,
+  providePatches,
+  providePatchesContext,
+  providePatchesDoc,
+  useCurrentDoc,
+  usePatchesContext,
+  usePatchesDoc,
+  usePatchesSync
+};

package/dist/vue/provider.d.ts

@@ -0,0 +1,89 @@
+import { InjectionKey, App } from 'vue';
+import { Patches } from '../client/Patches.js';
+import { PatchesSync } from '../net/PatchesSync.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesDoc.js';
+import '../algorithms/shared/changeBatching.js';
+import '../client/PatchesStore.js';
+import '../net/protocol/JSONRPCClient.js';
+import '../net/protocol/types.js';
+import '../net/websocket/PatchesWebSocket.js';
+import '../net/PatchesClient.js';
+import '../net/websocket/WebSocketTransport.js';
+
+/**
+ * Injection key for Patches instance.
+ */
+declare const PATCHES_KEY: InjectionKey<Patches>;
+/**
+ * Injection key for PatchesSync instance (optional).
+ */
+declare const PATCHES_SYNC_KEY: InjectionKey<PatchesSync | undefined>;
+/**
+ * Context containing Patches and optional PatchesSync instances.
+ */
+interface PatchesContext {
+    patches: Patches;
+    sync?: PatchesSync;
+}
+/**
+ * Provides Patches context to the Vue app.
+ *
+ * Call this in your app setup to make Patches available to all components via inject.
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue'
+ * import { Patches, InMemoryStore } from '@dabble/patches/client'
+ * import { PatchesSync } from '@dabble/patches/net'
+ * import { providePatchesContext } from '@dabble/patches/vue'
+ *
+ * const patches = new Patches({ store: new InMemoryStore() })
+ * const sync = new PatchesSync(patches, 'wss://your-server.com')
+ *
+ * const app = createApp(App)
+ * providePatchesContext(app, patches, sync)
+ * app.mount('#app')
+ * ```
+ *
+ * @param app - Vue app instance
+ * @param patches - Patches instance
+ * @param sync - Optional PatchesSync instance for network synchronization
+ */
+declare function providePatchesContext(app: App, patches: Patches, sync?: PatchesSync): void;
+/**
+ * Provides Patches context within a component setup function.
+ *
+ * Use this instead of providePatchesContext when providing from a component
+ * rather than at the app level.
+ *
+ * @example
+ * ```typescript
+ * // In a component setup
+ * providePatches(patches, sync)
+ * ```
+ */
+declare function providePatches(patches: Patches, sync?: PatchesSync): void;
+/**
+ * Gets the injected Patches context.
+ *
+ * Throws an error if Patches has not been provided.
+ *
+ * @returns The Patches context
+ * @throws Error if Patches context has not been provided
+ *
+ * @example
+ * ```typescript
+ * const { patches, sync } = usePatchesContext()
+ *
+ * // Use patches to open/close docs
+ * await patches.openDoc('doc-123')
+ * ```
+ */
+declare function usePatchesContext(): PatchesContext;
+
+export { PATCHES_KEY, PATCHES_SYNC_KEY, type PatchesContext, providePatches, providePatchesContext, usePatchesContext };

package/dist/vue/provider.js

@@ -0,0 +1,27 @@
+import "../chunk-IZ2YBCUP.js";
+import { inject, provide } from "vue";
+const PATCHES_KEY = Symbol("patches");
+const PATCHES_SYNC_KEY = Symbol("patches-sync");
+function providePatchesContext(app, patches, sync) {
+  app.provide(PATCHES_KEY, patches);
+  app.provide(PATCHES_SYNC_KEY, sync);
+}
+function providePatches(patches, sync) {
+  provide(PATCHES_KEY, patches);
+  provide(PATCHES_SYNC_KEY, sync);
+}
+function usePatchesContext() {
+  const patches = inject(PATCHES_KEY);
+  const sync = inject(PATCHES_SYNC_KEY);
+  if (!patches) {
+    throw new Error("Patches context not found. Did you forget to call providePatchesContext() in your app setup?");
+  }
+  return { patches, sync };
+}
+export {
+  PATCHES_KEY,
+  PATCHES_SYNC_KEY,
+  providePatches,
+  providePatchesContext,
+  usePatchesContext
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {
@@ -33,6 +33,14 @@
     "./compression": {
       "import": "./dist/compression/index.js",
       "types": "./dist/compression/index.d.ts"
+    },
+    "./vue": {
+      "import": "./dist/vue/index.js",
+      "types": "./dist/vue/index.d.ts"
+    },
+    "./solid": {
+      "import": "./dist/solid/index.js",
+      "types": "./dist/solid/index.d.ts"
     }
   },
   "files": [
@@ -60,8 +68,8 @@
     "prepare": "npm run build",
     "test": "vitest run",
     "tdd": "vitest",
-    "format": "prettier --write src/",
-    "format:check": "prettier --check src/",
+    "format": "prettier --write src/ tests/ docs/",
+    "format:check": "prettier --check src/ tests/ docs/",
     "type:check": "tsc --noEmit",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix"
@@ -79,9 +87,25 @@
     "@typescript-eslint/parser": "^8.48.0",
     "eslint": "^9.39.1",
     "fake-indexeddb": "^6.2.5",
+    "happy-dom": "^20.1.0",
     "prettier": "^3.7.3",
+    "solid-js": "^1.9.3",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.14"
+    "vite-plugin-solid": "^2.11.10",
+    "vitest": "^4.0.14",
+    "vue": "^3.5.26"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.8.0",
+    "vue": "^3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
   }
-}
+}