@dabble/patches 0.2.8 → 0.2.10

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

@@ -1,5 +0,0 @@
-import type { State } from '../types.js';
-export declare const EMPTY: {};
-export declare function pluck(state: State, keys: string[]): any;
-export declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
-export declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;

package/dist/json-patch/utils/pluck.js

@@ -1,30 +0,0 @@
-import { shallowCopy } from './shallowCopy.js';
-export const EMPTY = {};
-export function pluck(state, keys) {
-    let object = state.root;
-    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
-        const key = keys[i];
-        if (!object[key]) {
-            return null;
-        }
-        object = object[key];
-    }
-    return object;
-}
-export function pluckWithShallowCopy(state, keys, createMissingObjects) {
-    let object = state.root;
-    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
-        const key = keys[i];
-        object = object[key] = createMissingObjects && !object[key] ? getValue(state, EMPTY) : getValue(state, object[key]);
-    }
-    return object;
-}
-export function getValue(state, value, addKey, addValue) {
-    if (!state.cache?.has(value)) {
-        value = shallowCopy(value);
-        state.cache?.add(value);
-    }
-    if (addKey)
-        value[addKey] = addValue;
-    return value;
-}

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

@@ -1 +0,0 @@
-export declare function shallowCopy(obj: any): any;

package/dist/json-patch/utils/shallowCopy.js

@@ -1,20 +0,0 @@
-export function shallowCopy(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        const len = obj.length;
-        const ary = new Array(len);
-        for (let i = 0; i < len; i++) {
-            ary[i] = obj[i];
-        }
-        return ary;
-    }
-    const keys = Object.keys(obj);
-    const copy = {};
-    for (let j = 0, jmax = keys.length; j < jmax; j++) {
-        const key = keys[j];
-        copy[key] = obj[key];
-    }
-    return copy;
-}

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

@@ -1,7 +0,0 @@
-import type { JSONPatchOp } from '../types.js';
-export declare function isEmptyObject(value: any): boolean;
-/**
- * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
- * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
- */
-export declare function updateSoftWrites(overPath: string, ops: JSONPatchOp[]): JSONPatchOp[];

package/dist/json-patch/utils/softWrites.js

@@ -1,18 +0,0 @@
-import { log } from './log.js';
-import { mapAndFilterOps } from './ops.js';
-export function isEmptyObject(value) {
-    return Boolean(value && typeof value === 'object' && Object.keys(value).length === 0);
-}
-/**
- * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
- * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
- */
-export function updateSoftWrites(overPath, ops) {
-    return mapAndFilterOps(ops, op => {
-        if (op.op === 'add' && op.path === overPath && isEmptyObject(op.value)) {
-            log('Removing empty object', op);
-            return null;
-        }
-        return op;
-    });
-}

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

@@ -1 +0,0 @@
-export declare function toArrayIndex(array: any[], str: string): number;

package/dist/json-patch/utils/toArrayIndex.js

@@ -1,12 +0,0 @@
-export function toArrayIndex(array, str) {
-    if (str === '-') {
-        return array.length;
-    }
-    for (let i = 0, imax = str.length; i < imax; i++) {
-        const ch = str.charCodeAt(i);
-        if (57 < ch || ch < 48) {
-            return Infinity;
-        }
-    }
-    return +str;
-}

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

@@ -1 +0,0 @@
-export declare function toKeys(path: string): string[];

package/dist/json-patch/utils/toKeys.js

@@ -1,15 +0,0 @@
-function esc(m) {
-    return m === '~0' ? '~' : '/';
-}
-export function toKeys(path) {
-    const keys = path.split('/');
-    if (!path.includes('~')) {
-        return keys;
-    }
-    for (let i = 0, imax = keys.length; i < imax; i++) {
-        if (keys[i].includes('~')) {
-            keys[i] = keys[i].replace(/~[01]/g, esc);
-        }
-    }
-    return keys;
-}

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

@@ -1,5 +0,0 @@
-import type { JSONPatchOp, State } from '../types.js';
-/**
- * Update array indexes to account for values being added or removed from an array.
- */
-export declare function updateArrayIndexes(state: State, thisPath: string, otherOps: JSONPatchOp[], modifier: 1 | -1, isRemove?: boolean): JSONPatchOp[];

package/dist/json-patch/utils/updateArrayIndexes.js

@@ -1,38 +0,0 @@
-import { getTypeLike } from './getType.js';
-import { log } from './log.js';
-import { isAdd, mapAndFilterOps, transformRemove } from './ops.js';
-import { getPrefixAndProp } from './paths.js';
-import { updateArrayPath } from './updateArrayPath.js';
-/**
- * Update array indexes to account for values being added or removed from an array.
- */
-export function updateArrayIndexes(state, thisPath, otherOps, modifier, isRemove) {
-    const [arrayPrefix, indexStr] = getPrefixAndProp(thisPath);
-    const index = parseInt(indexStr);
-    log('Shifting array indexes', thisPath, modifier);
-    // Check ops for any that need to be replaced
-    return mapAndFilterOps(otherOps, (op, i, breakAfter) => {
-        if (isRemove && thisPath === op.from) {
-            const opLike = getTypeLike(state, op);
-            if (opLike === 'move') {
-                // We need the rest of the otherOps to be adjusted against this "move"
-                breakAfter();
-                return transformRemove(state, op.path, otherOps.slice(i + 1));
-            }
-            else if (opLike === 'copy') {
-                // We need future ops on the copied object to be removed
-                breakAfter();
-                let rest = transformRemove(state, thisPath, otherOps.slice(i + 1));
-                rest = transformRemove(state, op.path, rest);
-                return rest;
-            }
-        }
-        if (op.soft && isAdd(state, op, 'path') && op.path === thisPath) {
-            breakAfter(true);
-            return null;
-        }
-        // check for items from the same array that will be affected
-        op = updateArrayPath(state, op, 'from', arrayPrefix, index, modifier);
-        return op && updateArrayPath(state, op, 'path', arrayPrefix, index, modifier);
-    });
-}

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

@@ -1,5 +0,0 @@
-import type { JSONPatchOp, State } from '../types.js';
-/**
- * Adjust ops within an array
- */
-export declare function updateArrayPath(state: State, otherOp: JSONPatchOp, pathName: 'from' | 'path', thisPrefix: string, thisIndex: number, modifier: 1 | -1): JSONPatchOp | [JSONPatchOp, JSONPatchOp] | null;

package/dist/json-patch/utils/updateArrayPath.js

@@ -1,45 +0,0 @@
-import { getTypeLike } from './getType.js';
-import { isAdd } from './ops.js';
-import { getIndexAndEnd } from './paths.js';
-import { getValue } from './pluck.js';
-/**
- * Adjust ops within an array
- */
-export function updateArrayPath(state, otherOp, pathName, thisPrefix, thisIndex, modifier) {
-    const path = otherOp[pathName];
-    if (!path || !path.startsWith(thisPrefix))
-        return otherOp;
-    const [otherIndex, end] = getIndexAndEnd(state, path, thisPrefix.length);
-    const opLike = getTypeLike(state, otherOp);
-    // A bit of complex logic to handle moves upwards in an array. Since an item is removed earier in the array and added later, the other index is like it was one less (or this index was one more), so we correct it
-    if (opLike === 'move' &&
-        pathName === 'path' &&
-        otherOp.from?.startsWith(thisPrefix) &&
-        getIndexAndEnd(state, otherOp.from, thisPrefix.length)[0] < otherIndex) {
-        thisIndex -= 1;
-    }
-    if (otherIndex < thisIndex)
-        return otherOp;
-    // When this is a removed item and the op is a subpath or a non-add, remove it.
-    if (otherIndex === thisIndex && modifier === -1) {
-        if (end === path.length) {
-            // If we are adding to the location something got removed, continue adding it.
-            if (isAdd(state, otherOp, pathName))
-                return otherOp;
-            if (otherOp.op === 'replace')
-                return getValue(state, otherOp, 'op', 'add');
-            // If we are replacing an item which was removed, add it (don't replace something else in the array)
-            if (opLike === 'replace')
-                return [{ op: 'add', path: otherOp.path, value: null }, otherOp];
-        }
-        return null;
-    }
-    else if (isAdd(state, otherOp, pathName) && otherIndex === thisIndex && end === path.length) {
-        if (otherOp.soft)
-            return null;
-        return otherOp;
-    }
-    const newPath = thisPrefix + (otherIndex + modifier) + path.slice(end);
-    otherOp = getValue(state, otherOp, pathName, newPath);
-    return otherOp;
-}

package/dist/net/AbstractTransport.d.ts

@@ -1,47 +0,0 @@
-import type { ConnectionState, Transport } from '../net/protocol/types.js';
-/**
- * Abstract base class that implements common functionality for various transport implementations.
- * Provides state management and event signaling for connection state changes and message reception.
- * Concrete transport implementations must extend this class and implement the abstract methods.
- */
-export declare abstract class AbstractTransport implements Transport {
-    private _state;
-    /**
-     * Signal that emits when the connection state changes.
-     * Subscribers will receive the new connection state as an argument.
-     */
-    readonly onStateChange: import("../event-signal.js").Signal<(state: ConnectionState) => void>;
-    /**
-     * Signal that emits when a message is received from the transport.
-     * Subscribers will receive the message data as a string.
-     */
-    readonly onMessage: import("../event-signal.js").Signal<(data: string) => void>;
-    /**
-     * Gets the current connection state of the transport.
-     * @returns The current connection state ('connecting', 'connected', 'disconnected', or 'error')
-     */
-    get state(): ConnectionState;
-    /**
-     * Sets the connection state and emits a state change event.
-     * This method is protected and should only be called by subclasses.
-     * @param state - The new connection state
-     */
-    protected set state(state: ConnectionState);
-    /**
-     * Establishes the connection for this transport.
-     * Must be implemented by concrete subclasses.
-     * @returns A promise that resolves when the connection is established
-     */
-    abstract connect(): Promise<void>;
-    /**
-     * Terminates the connection for this transport.
-     * Must be implemented by concrete subclasses.
-     */
-    abstract disconnect(): void;
-    /**
-     * Sends data through this transport.
-     * Must be implemented by concrete subclasses.
-     * @param data - The string data to send
-     */
-    abstract send(data: string): void;
-}

package/dist/net/AbstractTransport.js

@@ -1,39 +0,0 @@
-import { signal } from '../event-signal.js';
-/**
- * Abstract base class that implements common functionality for various transport implementations.
- * Provides state management and event signaling for connection state changes and message reception.
- * Concrete transport implementations must extend this class and implement the abstract methods.
- */
-export class AbstractTransport {
-    constructor() {
-        this._state = 'disconnected';
-        /**
-         * Signal that emits when the connection state changes.
-         * Subscribers will receive the new connection state as an argument.
-         */
-        this.onStateChange = signal();
-        /**
-         * Signal that emits when a message is received from the transport.
-         * Subscribers will receive the message data as a string.
-         */
-        this.onMessage = signal();
-    }
-    /**
-     * Gets the current connection state of the transport.
-     * @returns The current connection state ('connecting', 'connected', 'disconnected', or 'error')
-     */
-    get state() {
-        return this._state;
-    }
-    /**
-     * Sets the connection state and emits a state change event.
-     * This method is protected and should only be called by subclasses.
-     * @param state - The new connection state
-     */
-    set state(state) {
-        if (state === this._state)
-            return;
-        this._state = state;
-        this.onStateChange.emit(state);
-    }
-}

package/dist/net/PatchesSync.d.ts

@@ -1,47 +0,0 @@
-import { Patches } from '../client/Patches.js';
-import type { WebSocketOptions } from './websocket/WebSocketTransport.js';
-export interface PatchesSyncOptions {
-    wsOptions?: WebSocketOptions;
-    maxBatchSize?: number;
-}
-export interface PatchesSyncState {
-    online: boolean;
-    connected: boolean;
-    syncing: 'initial' | 'updating' | null | Error;
-}
-/**
- * Handles WebSocket connection, document subscriptions, and syncing logic between
- * the Patches instance and the server.
- */
-export declare class PatchesSync {
-    private ws;
-    private patches;
-    private store;
-    private options;
-    private trackedDocs;
-    private isFlushing;
-    private globalSyncTimeout;
-    private _state;
-    readonly onStateChange: import("../event-signal.js").Signal<(state: PatchesSyncState) => void>;
-    readonly onError: import("../event-signal.js").Signal<(error: Error, context?: {
-        docId?: string;
-    }) => void>;
-    constructor(url: string, patches: Patches, options?: PatchesSyncOptions);
-    get state(): PatchesSyncState;
-    private setState;
-    connect(): Promise<void>;
-    disconnect(): void;
-    private scheduleGlobalSync;
-    syncAllKnownDocs(): Promise<void>;
-    syncDoc(docId: string): Promise<void>;
-    flushDoc(docId: string): Promise<void>;
-    /**
-     * Initiates the deletion process for a document both locally and on the server.
-     * This now delegates the local tombstone marking to Patches.
-     */
-    _handleDocDeleted(docId: string): Promise<void>;
-    private _handleOnlineChange;
-    private _handleConnectionChange;
-    private _handleDocsTracked;
-    private _handleDocsUntracked;
-}

package/dist/net/PatchesSync.js

@@ -1,289 +0,0 @@
-import { signal } from '../event-signal.js';
-import { breakIntoBatches } from '../utils/batching.js';
-import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
-import { onlineState } from './websocket/onlineState.js';
-/**
- * Handles WebSocket connection, document subscriptions, and syncing logic between
- * the Patches instance and the server.
- */
-export class PatchesSync {
-    constructor(url, patches, options = {}) {
-        this.isFlushing = new Set();
-        this.globalSyncTimeout = null;
-        this._state = { online: false, connected: false, syncing: null };
-        // Signals
-        this.onStateChange = signal();
-        this.onError = signal();
-        // --- Event Handlers ---
-        this._handleOnlineChange = (isOnline) => {
-            this.setState({ online: isOnline });
-            if (isOnline && this.state.connected) {
-                this.scheduleGlobalSync();
-            }
-        };
-        this._handleConnectionChange = (connectionState) => {
-            const isConnected = connectionState === 'connected';
-            const isConnecting = connectionState === 'connecting';
-            // Preserve syncing state if moving from connecting -> connected
-            // Reset syncing if disconnected or errored
-            const newSyncingState = isConnected
-                ? this._state.syncing // Preserve
-                : isConnecting
-                    ? this._state.syncing // Preserve during connecting phase too
-                    : null; // Reset
-            this.setState({ connected: isConnected, syncing: newSyncingState });
-            if (isConnected) {
-                // Sync everything on connect/reconnect
-                void this.syncAllKnownDocs();
-            }
-        };
-        this._handleDocsTracked = async (docIds) => {
-            const newIds = docIds.filter(id => !this.trackedDocs.has(id));
-            if (!newIds.length)
-                return;
-            newIds.forEach(id => this.trackedDocs.add(id));
-            if (this.state.connected) {
-                try {
-                    await this.ws.subscribe(newIds);
-                    // Trigger sync for newly tracked docs immediately
-                    await Promise.all(newIds.map(id => this.syncDoc(id)));
-                }
-                catch (err) {
-                    console.warn(`Failed to subscribe/sync newly tracked docs: ${newIds.join(', ')}`, err);
-                    this.onError.emit(err);
-                    // State remains tracked locally, will retry on next sync
-                }
-            }
-        };
-        this._handleDocsUntracked = async (docIds) => {
-            const existingIds = docIds.filter(id => this.trackedDocs.has(id));
-            if (!existingIds.length)
-                return;
-            existingIds.forEach(id => this.trackedDocs.delete(id));
-            if (this.state.connected) {
-                try {
-                    await this.ws.unsubscribe(existingIds);
-                }
-                catch (err) {
-                    console.warn(`Failed to unsubscribe docs: ${existingIds.join(', ')}`, err);
-                    // Continue with local untrack
-                }
-            }
-        };
-        this.patches = patches;
-        this.store = patches.store;
-        this.options = options;
-        this.ws = new PatchesWebSocket(url, options.wsOptions);
-        this._state.online = onlineState.isOnline;
-        this.trackedDocs = new Set(patches.trackedDocs);
-        // --- Event Listeners ---
-        onlineState.onOnlineChange(this._handleOnlineChange);
-        this.ws.onStateChange(this._handleConnectionChange);
-        this.ws.onChangesCommitted(({ docId, changes }) => {
-            // Persist first, then notify Patches instance to update PatchesDoc
-            this.store
-                .saveCommittedChanges(docId, changes)
-                .then(() => this.patches.applyServerChanges(docId, changes))
-                .catch((err) => this.onError.emit(err, { docId }));
-        });
-        // Forward errors to Patches error signal
-        this.onError((err, context) => {
-            patches.onError.emit(err, context);
-        });
-        // Listen to Patches for tracking changes
-        patches.onTrackDocs(this._handleDocsTracked);
-        patches.onUntrackDocs(this._handleDocsUntracked);
-        patches.onDeleteDoc(this._handleDocDeleted);
-    }
-    get state() {
-        return this._state;
-    }
-    setState(update) {
-        const newState = { ...this._state, ...update };
-        if (JSON.stringify(this._state) !== JSON.stringify(newState)) {
-            this._state = newState;
-            this.onStateChange.emit(this._state);
-        }
-    }
-    // --- Connection & Lifecycle ---
-    async connect() {
-        try {
-            await this.ws.connect();
-            // _handleConnectionChange handles state update and sync trigger
-        }
-        catch (err) {
-            console.error('PatchesSync connection failed:', err);
-            this.setState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
-            this.onError.emit(err);
-            throw err;
-        }
-    }
-    disconnect() {
-        if (this.globalSyncTimeout)
-            clearTimeout(this.globalSyncTimeout);
-        this.ws.disconnect();
-        this.setState({ connected: false, syncing: null });
-    }
-    // --- Doc Tracking & Subscription (Now handled via signals) ---
-    // --- Syncing Logic ---
-    scheduleGlobalSync() {
-        if (this.globalSyncTimeout)
-            clearTimeout(this.globalSyncTimeout);
-        this.globalSyncTimeout = setTimeout(() => {
-            this.globalSyncTimeout = null;
-            void this.syncAllKnownDocs();
-        }, 300);
-    }
-    async syncAllKnownDocs() {
-        if (!this.state.connected)
-            return;
-        this.setState({ syncing: 'updating' });
-        try {
-            const tracked = await this.store.listDocs(true); // Include deleted docs
-            const activeDocs = tracked.filter(t => !t.deleted);
-            const deletedDocs = tracked.filter(t => t.deleted);
-            const activeDocIds = activeDocs.map((t) => t.docId);
-            // Ensure tracked set reflects only active docs for subscription purposes
-            this.trackedDocs = new Set(activeDocIds);
-            // Subscribe to active docs
-            if (activeDocIds.length > 0) {
-                try {
-                    await this.ws.subscribe(activeDocIds);
-                }
-                catch (err) {
-                    console.warn('Error subscribing to active docs during sync:', err);
-                    this.onError.emit(err);
-                }
-            }
-            // Sync each active doc
-            const activeSyncPromises = activeDocIds.map((id) => this.syncDoc(id));
-            // Attempt to delete docs marked with tombstones
-            const deletePromises = deletedDocs.map(async ({ docId }) => {
-                try {
-                    console.info(`Attempting server delete for tombstoned doc: ${docId}`);
-                    await this.ws.deleteDoc(docId);
-                    // If server delete succeeds, remove tombstone and all data locally
-                    await this.store.confirmDeleteDoc(docId);
-                    console.info(`Successfully deleted and untracked doc: ${docId}`);
-                }
-                catch (err) {
-                    // If server delete fails (e.g., offline, already deleted), keep tombstone for retry
-                    console.warn(`Server delete failed for ${docId}, keeping tombstone:`, err);
-                    this.onError.emit(err, { docId });
-                }
-            });
-            // Wait for all sync and delete operations
-            await Promise.all([...activeSyncPromises, ...deletePromises]);
-            this.setState({ syncing: null });
-        }
-        catch (error) {
-            console.error('Error during global sync:', error);
-            this.setState({ syncing: error instanceof Error ? error : new Error(String(error)) });
-            this.onError.emit(error);
-        }
-    }
-    async syncDoc(docId) {
-        if (this.isFlushing.has(docId))
-            return; // Already flushing
-        if (!this.state.connected)
-            return;
-        try {
-            const pending = await this.store.getPendingChanges(docId);
-            if (pending.length > 0) {
-                await this.flushDoc(docId); // flushDoc handles setting flushing state
-            }
-            else {
-                // No pending, just check for server changes
-                const [committedRev] = await this.store.getLastRevs(docId);
-                const serverChanges = await this.ws.getChangesSince(docId, committedRev);
-                if (serverChanges.length > 0) {
-                    await this.store.saveCommittedChanges(docId, serverChanges);
-                    this.patches.applyServerChanges(docId, serverChanges);
-                }
-            }
-        }
-        catch (err) {
-            console.error(`Error syncing doc ${docId}:`, err);
-            this.onError.emit(err, { docId });
-            // Don't let one doc failure stop others in global sync
-        }
-    }
-    async flushDoc(docId) {
-        if (!this.trackedDocs.has(docId)) {
-            throw new Error(`Document ${docId} is not tracked`);
-        }
-        if (this.isFlushing.has(docId)) {
-            throw new Error(`Document ${docId} is already being flushed`);
-        }
-        if (!this.state.connected) {
-            throw new Error('Not connected to server');
-        }
-        this.isFlushing.add(docId);
-        if (this.state.syncing !== 'updating') {
-            this.setState({ syncing: 'updating' });
-        }
-        try {
-            // Get changes from Patches for this doc
-            let pending = await this.store.getPendingChanges(docId);
-            if (!pending.length) {
-                // Try to get from memory if available
-                pending = this.patches.getDocChanges(docId);
-                if (!pending.length) {
-                    this.isFlushing.delete(docId);
-                    return; // Nothing to flush
-                }
-            }
-            const batches = breakIntoBatches(pending, this.options.maxBatchSize);
-            for (const batch of batches) {
-                if (!this.state.connected) {
-                    throw new Error('Disconnected during flush');
-                }
-                const range = [batch[0].rev, batch[batch.length - 1].rev];
-                const committed = await this.ws.commitChanges(docId, batch);
-                // Persist committed + remove pending in store
-                await this.store.saveCommittedChanges(docId, committed, range);
-                // Notify Patches to update PatchesDoc
-                this.patches.applyServerChanges(docId, committed);
-                // Fetch remaining pending for next batch or check completion
-                pending = await this.store.getPendingChanges(docId);
-            }
-        }
-        catch (err) {
-            console.error(`Flush failed for doc ${docId}:`, err);
-            this.onError.emit(err, { docId });
-            // Let Patches know about the failure
-            this.patches.handleSendFailure(docId);
-            // Don't clear flushing flag, let next sync attempt retry
-            throw err; // Re-throw so caller (like syncAll) knows it failed
-        }
-        finally {
-            this.isFlushing.delete(docId);
-            // Update global sync state if nothing else is flushing
-            if (this.isFlushing.size === 0 && this.state.syncing === 'updating') {
-                this.setState({ syncing: null });
-            }
-        }
-    }
-    // --- Server Operations ---
-    /**
-     * Initiates the deletion process for a document both locally and on the server.
-     * This now delegates the local tombstone marking to Patches.
-     */
-    async _handleDocDeleted(docId) {
-        // Attempt server delete if online
-        if (this.state.connected) {
-            try {
-                await this.ws.deleteDoc(docId);
-                await this.store.confirmDeleteDoc(docId);
-            }
-            catch (err) {
-                console.error(`Server delete failed for doc ${docId}, will retry on reconnect/resync.`, err);
-                this.onError.emit(err, { docId });
-                throw err;
-            }
-        }
-        else {
-            console.warn(`Offline: Server delete for doc ${docId} deferred.`);
-        }
-    }
-}

package/dist/net/index.d.ts

@@ -1,9 +0,0 @@
-export * from './AbstractTransport.js';
-export * from './PatchesSync.js';
-export * from './protocol/JSONRPCClient.js';
-export type * from './protocol/types';
-export type * from './types';
-export * from './webrtc/WebRTCAwareness.js';
-export * from './webrtc/WebRTCTransport.js';
-export * from './websocket/PatchesWebSocket.js';
-export * from './websocket/WebSocketTransport.js';

package/dist/net/index.js

@@ -1,7 +0,0 @@
-export * from './AbstractTransport.js';
-export * from './PatchesSync.js';
-export * from './protocol/JSONRPCClient.js';
-export * from './webrtc/WebRTCAwareness.js';
-export * from './webrtc/WebRTCTransport.js';
-export * from './websocket/PatchesWebSocket.js';
-export * from './websocket/WebSocketTransport.js';