@dabble/patches 0.2.2 → 0.2.4

package/dist/client/PatchesDoc.d.ts

@@ -5,7 +5,7 @@ import type { Change, PatchesSnapshot } from '../types.js';
  * Manages committed state, pending (local-only) changes, and
  * changes currently being sent to the server.
  */
-export declare class PatchesDoc<T extends object> {
+export declare class PatchesDoc<T extends object = object> {
     protected _id: string | null;
     protected _state: T;
     protected _committedState: T;

package/dist/index.d.ts

@@ -1,3 +1,8 @@
-export { Patches } from './client/Patches.js';
-export { PatchesDoc } from './client/PatchesDoc.js';
+export { Delta } from '@dabble/delta';
+export * from './client/Patches.js';
+export * from './client/PatchesDoc.js';
+export type * from './event-signal';
+export type * from './json-patch/JSONPatch.js';
+export type { ApplyJSONPatchOptions } from './json-patch/types.js';
+export type * from './persist/PatchesStore.js';
 export type * from './types';

package/dist/index.js

@@ -1,2 +1,3 @@
-export { Patches } from './client/Patches.js';
-export { PatchesDoc } from './client/PatchesDoc.js';
+export { Delta } from '@dabble/delta';
+export * from './client/Patches.js';
+export * from './client/PatchesDoc.js';

package/dist/json-patch/JSONPatch.d.ts

@@ -115,12 +115,3 @@ export declare class JSONPatch {
         new (ops?: JSONPatchOp[], types?: JSONPatchOpHandlerMap): T;
     }, ops?: JSONPatchOp[], types?: JSONPatchOpHandlerMap): T;
 }
-export type JSONPath<T> = T extends object ? T extends Array<infer U> ? {
-    readonly [K in keyof T & number]-?: JSONPathValue<U>;
-} : {
-    readonly [K in keyof T as T[K] extends Function ? never : K]-?: JSONPathValue<NonNullable<T[K]>>;
-} : never;
-export type JSONPathValue<T> = {
-    toString(): string;
-} & (T extends object ? JSONPath<T> : {});
-export declare function createJSONPath<T = unknown>(): JSONPath<T>;

package/dist/json-patch/JSONPatch.js

@@ -208,14 +208,3 @@ function checkPath(path) {
         path = `/${path}`;
     return path;
 }
-export function createJSONPath() {
-    const handler = {
-        get(target, prop) {
-            if (prop === 'toString') {
-                return () => target.path ?? '';
-            }
-            return new Proxy({ path: `${target.path}/${prop}` }, handler);
-        },
-    };
-    return new Proxy({ path: '' }, handler);
-}

package/dist/persist/IndexedDBStore.d.ts

@@ -14,13 +14,18 @@ import type { PatchesStore, TrackedDoc } from './PatchesStore.js';
  */
 export declare class IndexedDBStore implements PatchesStore {
     private db;
-    private dbName;
+    private dbName?;
     private dbPromise;
     /** Subscribe to be notified after local state changes are saved to the database. */
     readonly onPendingChanges: import("../event-signal.js").Signal<(docId: string, changes: Change[]) => void>;
-    constructor(dbName: string);
+    constructor(dbName?: string);
     private initDB;
     private getDB;
+    /**
+     * Set the name of the database, loads a new database connection.
+     * @param dbName - The new name of the database.
+     */
+    setName(dbName: string): void;
     /**
      * Closes the database connection. After calling this method, the store
      * will no longer be usable. A new instance must be created to reopen

package/dist/persist/IndexedDBStore.js

@@ -1,6 +1,6 @@
 import { signal } from '../event-signal.js';
 import { transformPatch } from '../json-patch/transformPatch.js';
-import { applyChanges } from '../utils.js';
+import { applyChanges, deferred } from '../utils.js';
 const DB_VERSION = 1;
 const SNAPSHOT_INTERVAL = 200;
 /**
@@ -21,36 +21,52 @@ export class IndexedDBStore {
         /** Subscribe to be notified after local state changes are saved to the database. */
         this.onPendingChanges = signal();
         this.dbName = dbName;
-        this.dbPromise = this.initDB();
+        this.dbPromise = deferred();
+        if (this.dbName) {
+            this.initDB();
+        }
     }
     async initDB() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(this.dbName, DB_VERSION);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve(this.db);
-            };
-            request.onupgradeneeded = event => {
-                const db = event.target.result;
-                // Create stores
-                if (!db.objectStoreNames.contains('snapshots')) {
-                    db.createObjectStore('snapshots', { keyPath: 'docId' });
-                }
-                if (!db.objectStoreNames.contains('committedChanges')) {
-                    db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
-                }
-                if (!db.objectStoreNames.contains('pendingChanges')) {
-                    db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
-                }
-                if (!db.objectStoreNames.contains('docs')) {
-                    db.createObjectStore('docs', { keyPath: 'docId' });
-                }
-            };
-        });
+        if (!this.dbName)
+            return;
+        const request = indexedDB.open(this.dbName, DB_VERSION);
+        request.onerror = () => this.dbPromise.reject(request.error);
+        request.onsuccess = () => {
+            this.db = request.result;
+            this.dbPromise.resolve(this.db);
+        };
+        request.onupgradeneeded = event => {
+            const db = event.target.result;
+            // Create stores
+            if (!db.objectStoreNames.contains('snapshots')) {
+                db.createObjectStore('snapshots', { keyPath: 'docId' });
+            }
+            if (!db.objectStoreNames.contains('committedChanges')) {
+                db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
+            }
+            if (!db.objectStoreNames.contains('pendingChanges')) {
+                db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
+            }
+            if (!db.objectStoreNames.contains('docs')) {
+                db.createObjectStore('docs', { keyPath: 'docId' });
+            }
+        };
     }
     getDB() {
-        return this.dbPromise;
+        return this.dbPromise.promise;
+    }
+    /**
+     * Set the name of the database, loads a new database connection.
+     * @param dbName - The new name of the database.
+     */
+    setName(dbName) {
+        this.dbName = dbName;
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.dbPromise = deferred();
+        }
+        this.initDB();
     }
     /**
      * Closes the database connection. After calling this method, the store
@@ -58,14 +74,17 @@ export class IndexedDBStore {
      * the database.
      */
     async close() {
-        await this.dbPromise;
+        await this.dbPromise.promise;
         if (this.db) {
             this.db.close();
             this.db = null;
-            this.dbPromise = Promise.resolve(null);
+            this.dbPromise = deferred();
+            this.dbPromise.resolve(null);
         }
     }
     async deleteDB() {
+        if (!this.dbName)
+            return;
         await this.close();
         await new Promise((resolve, reject) => {
             const request = indexedDB.deleteDatabase(this.dbName);

package/dist/types.d.ts

@@ -160,4 +160,5 @@ export interface Deferred<T = void> {
     promise: Promise<T>;
     resolve: (value: T) => void;
     reject: (reason?: any) => void;
+    status: 'pending' | 'fulfilled' | 'rejected';
 }

package/dist/utils.js

@@ -81,9 +81,23 @@ export function rebaseChanges(serverChanges, localChanges) {
 export function deferred() {
     let resolve;
     let reject;
+    let _status = 'pending';
     const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
+        resolve = (value) => {
+            _resolve(value);
+            _status = 'fulfilled';
+        };
+        reject = (reason) => {
+            _reject(reason);
+            _status = 'rejected';
+        };
     });
-    return { promise, resolve, reject };
+    return {
+        promise,
+        resolve,
+        reject,
+        get status() {
+            return _status;
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {