kritzel-stencil 0.1.75 → 0.1.77

package/dist/cjs/index.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var workspace_migrations = require('./workspace.migrations-DkmVO6dE.js');
+var workspace_migrations = require('./workspace.migrations-OULs44dI.js');
 var Y = require('yjs');
 var yWebsocket = require('y-websocket');
 require('y-indexeddb');
@@ -557,340 +557,13 @@ class WebSocketSyncProvider {
     }
 }
 
-/**
- * Hocuspocus sync provider for real-time collaboration
- * Supports multiplexing - multiple documents can share the same WebSocket connection
- */
-class HocuspocusSyncProvider {
-    type = 'network';
-    provider;
-    isConnected = false;
-    isSynced = false;
-    usesSharedSocket = false;
-    isDestroyed = false;
-    connectTimeout = null;
-    pendingConnectReject = null;
-    connectionTimeoutMs;
-    _connectionStatus = 'disconnected';
-    visibilityHandler = null;
-    onlineHandler = null;
-    get awareness() {
-        return this.provider.awareness;
-    }
-    get connectionStatus() {
-        return this._connectionStatus;
-    }
-    // Static shared WebSocket instance for multiplexing
-    static sharedWebSocketProvider = null;
-    constructor(docName, doc, options) {
-        const name = options?.name || docName;
-        const url = options?.url || 'ws://localhost:1234';
-        this.connectionTimeoutMs = options?.connectionTimeout ?? 10000;
-        // Use provided websocketProvider or the static shared one
-        const websocketProvider = options?.websocketProvider || HocuspocusSyncProvider.sharedWebSocketProvider;
-        // Build reconnect config from options
-        const reconnectConfig = {};
-        if (options?.delay !== undefined)
-            reconnectConfig.delay = options.delay;
-        if (options?.factor !== undefined)
-            reconnectConfig.factor = options.factor;
-        if (options?.maxAttempts !== undefined)
-            reconnectConfig.maxAttempts = options.maxAttempts;
-        if (options?.minDelay !== undefined)
-            reconnectConfig.minDelay = options.minDelay;
-        if (options?.maxDelay !== undefined)
-            reconnectConfig.maxDelay = options.maxDelay;
-        const onConnect = () => {
-            if (this.isDestroyed) {
-                return;
-            }
-            this.isConnected = true;
-            this._connectionStatus = 'connected';
-            if (!options?.quiet) {
-                console.info(`Hocuspocus connected: ${name}`);
-            }
-            if (options?.onConnect) {
-                options.onConnect();
-            }
-        };
-        const onDisconnect = () => {
-            if (this.isDestroyed) {
-                return;
-            }
-            this.isConnected = false;
-            this.isSynced = false;
-            this._connectionStatus = 'disconnected';
-            if (!options?.quiet) {
-                console.info(`Hocuspocus disconnected: ${name}`);
-            }
-            if (options?.onDisconnect) {
-                options.onDisconnect();
-            }
-        };
-        const onSynced = () => {
-            if (this.isDestroyed) {
-                return;
-            }
-            this.isSynced = true;
-            this._connectionStatus = 'synced';
-            if (!options?.quiet) {
-                console.info(`Hocuspocus synced: ${name}`);
-            }
-            if (options?.onSynced) {
-                options.onSynced();
-            }
-        };
-        const onStatus = (data) => {
-            if (this.isDestroyed) {
-                return;
-            }
-            if (data.status === 'connecting') {
-                this._connectionStatus = 'connecting';
-            }
-            if (options?.onStatus) {
-                options.onStatus(data);
-            }
-        };
-        if (websocketProvider) {
-            // Multiplexing mode - use shared WebSocket connection
-            this.usesSharedSocket = true;
-            const config = {
-                websocketProvider,
-                name,
-                document: doc,
-                token: options?.token || null,
-                onStatus,
-                onConnect,
-                onDisconnect,
-                onSynced,
-                ...reconnectConfig,
-            };
-            // Add optional settings
-            if (options?.forceSyncInterval !== undefined) {
-                config.forceSyncInterval = options.forceSyncInterval;
-            }
-            if (options?.onAuthenticationFailed) {
-                config.onAuthenticationFailed = options.onAuthenticationFailed;
-            }
-            this.provider = new workspace_migrations.HocuspocusProvider(config);
-            // Must call attach() explicitly when using shared socket
-            this.provider.attach();
-            if (!options?.quiet) {
-                console.info(`Hocuspocus Provider initialized (multiplexed): ${name}`);
-            }
-        }
-        else {
-            // Standalone mode - create own WebSocket connection
-            this.usesSharedSocket = false;
-            const config = {
-                url,
-                name,
-                document: doc,
-                token: options?.token || null,
-                autoConnect: false,
-                onStatus,
-                onConnect,
-                onDisconnect,
-                onSynced,
-                ...reconnectConfig,
-            };
-            // Add optional settings
-            if (options?.forceSyncInterval !== undefined) {
-                config.forceSyncInterval = options.forceSyncInterval;
-            }
-            if (options?.onAuthenticationFailed) {
-                config.onAuthenticationFailed = options.onAuthenticationFailed;
-            }
-            if (options?.WebSocketPolyfill) {
-                config.WebSocketPolyfill = options.WebSocketPolyfill;
-            }
-            this.provider = new workspace_migrations.HocuspocusProvider(config);
-            if (!options?.quiet) {
-                console.info(`Hocuspocus Provider initialized: ${url}/${name}`);
-            }
-        }
-        this.setupBrowserEventListeners();
-    }
-    setupBrowserEventListeners() {
-        if (typeof document !== 'undefined') {
-            this.visibilityHandler = () => {
-                if (document.visibilityState === 'visible' && !this.isConnected && !this.isDestroyed) {
-                    this.provider.connect();
-                }
-            };
-            document.addEventListener('visibilitychange', this.visibilityHandler);
-        }
-        if (typeof window !== 'undefined') {
-            this.onlineHandler = () => {
-                if (!this.isConnected && !this.isDestroyed) {
-                    this.provider.connect();
-                }
-            };
-            window.addEventListener('online', this.onlineHandler);
-        }
-    }
-    removeBrowserEventListeners() {
-        if (this.visibilityHandler && typeof document !== 'undefined') {
-            document.removeEventListener('visibilitychange', this.visibilityHandler);
-            this.visibilityHandler = null;
-        }
-        if (this.onlineHandler && typeof window !== 'undefined') {
-            window.removeEventListener('online', this.onlineHandler);
-            this.onlineHandler = null;
-        }
-    }
-    /**
-     * Create a shared WebSocket connection for multiplexing
-     * Call this once to create a shared connection that multiple providers can use
-     */
-    static createSharedWebSocket(options) {
-        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
-            console.warn('Shared WebSocket already exists. Returning existing instance.');
-            return HocuspocusSyncProvider.sharedWebSocketProvider;
-        }
-        const config = {
-            url: options.url,
-        };
-        if (options.WebSocketPolyfill) {
-            config.WebSocketPolyfill = options.WebSocketPolyfill;
-        }
-        if (options.onConnect) {
-            config.onConnect = options.onConnect;
-        }
-        if (options.onDisconnect) {
-            config.onDisconnect = options.onDisconnect;
-        }
-        if (options.onStatus) {
-            config.onStatus = options.onStatus;
-        }
-        HocuspocusSyncProvider.sharedWebSocketProvider = new workspace_migrations.HocuspocusProviderWebsocket(config);
-        console.info(`Shared Hocuspocus WebSocket created: ${options.url}`);
-        return HocuspocusSyncProvider.sharedWebSocketProvider;
-    }
-    /**
-     * Destroy the shared WebSocket connection
-     * Call this when you're done with all multiplexed providers
-     */
-    static destroySharedWebSocket() {
-        if (HocuspocusSyncProvider.sharedWebSocketProvider) {
-            HocuspocusSyncProvider.sharedWebSocketProvider.destroy();
-            HocuspocusSyncProvider.sharedWebSocketProvider = null;
-            console.info('Shared Hocuspocus WebSocket destroyed');
-        }
-    }
-    /**
-     * Get the shared WebSocket provider instance (if it exists)
-     */
-    static getSharedWebSocket() {
-        return HocuspocusSyncProvider.sharedWebSocketProvider;
-    }
-    /**
-     * Static factory method for creating HocuspocusSyncProvider with configuration options
-     * Returns a ProviderFactory that can be used in sync configuration
-     */
-    static with(options) {
-        return {
-            create: (docName, doc, runtimeOptions) => {
-                const mergedOptions = runtimeOptions ? { ...options, ...runtimeOptions } : options;
-                return new HocuspocusSyncProvider(docName, doc, mergedOptions);
-            },
-        };
-    }
-    async connect() {
-        if (this.isSynced || this.isDestroyed) {
-            return;
-        }
-        this._connectionStatus = 'connecting';
-        return new Promise((resolve, reject) => {
-            // Store reject function so we can cancel the connection if destroyed
-            this.pendingConnectReject = reject;
-            this.connectTimeout = setTimeout(() => {
-                this.pendingConnectReject = null;
-                this.connectTimeout = null;
-                reject(new Error('Hocuspocus connection timeout'));
-            }, this.connectionTimeoutMs);
-            const syncHandler = () => {
-                if (this.connectTimeout) {
-                    clearTimeout(this.connectTimeout);
-                    this.connectTimeout = null;
-                }
-                this.pendingConnectReject = null;
-                this.provider.off('synced', syncHandler);
-                if (!this.isDestroyed) {
-                    resolve();
-                }
-            };
-            this.provider.on('synced', syncHandler);
-            // If already synced, resolve immediately
-            if (this.provider.isSynced) {
-                if (this.connectTimeout) {
-                    clearTimeout(this.connectTimeout);
-                    this.connectTimeout = null;
-                }
-                this.pendingConnectReject = null;
-                this.provider.off('synced', syncHandler);
-                resolve();
-                return;
-            }
-            // Connect if not already connected (standalone mode only)
-            if (!this.isConnected && !this.usesSharedSocket) {
-                this.provider.connect();
-            }
-        });
-    }
-    async reconnect() {
-        this.disconnect();
-        return this.connect();
-    }
-    disconnect() {
-        // Cancel any pending connection attempt
-        if (this.connectTimeout) {
-            clearTimeout(this.connectTimeout);
-            this.connectTimeout = null;
-        }
-        if (this.pendingConnectReject) {
-            this.pendingConnectReject = null; // Don't reject, just abandon the promise
-        }
-        if (this.provider) {
-            if (this.usesSharedSocket) {
-                // Detach from shared socket instead of disconnecting
-                this.provider.detach();
-            }
-            else {
-                this.provider.disconnect();
-            }
-        }
-        this.isConnected = false;
-        this.isSynced = false;
-        this._connectionStatus = 'disconnected';
-    }
-    destroy() {
-        // Mark as destroyed first to prevent any callbacks from doing work
-        this.isDestroyed = true;
-        // Cancel any pending connection attempt
-        if (this.connectTimeout) {
-            clearTimeout(this.connectTimeout);
-            this.connectTimeout = null;
-        }
-        if (this.pendingConnectReject) {
-            this.pendingConnectReject = null; // Don't reject, just abandon the promise
-        }
-        this.removeBrowserEventListeners();
-        if (this.provider) {
-            this.provider.destroy();
-        }
-        this.isConnected = false;
-        this.isSynced = false;
-        this._connectionStatus = 'disconnected';
-    }
-}
-
 exports.APP_STATE_MIGRATIONS = workspace_migrations.APP_STATE_MIGRATIONS;
 exports.CURRENT_APP_STATE_SCHEMA_VERSION = workspace_migrations.CURRENT_APP_STATE_SCHEMA_VERSION;
 exports.CURRENT_WORKSPACE_SCHEMA_VERSION = workspace_migrations.CURRENT_WORKSPACE_SCHEMA_VERSION;
 exports.DEFAULT_BRUSH_CONFIG = workspace_migrations.DEFAULT_BRUSH_CONFIG;
 exports.DEFAULT_LINE_TOOL_CONFIG = workspace_migrations.DEFAULT_LINE_TOOL_CONFIG;
 exports.DEFAULT_TEXT_CONFIG = workspace_migrations.DEFAULT_TEXT_CONFIG;
+exports.HocuspocusSyncProvider = workspace_migrations.HocuspocusSyncProvider;
 exports.IndexedDBSyncProvider = workspace_migrations.IndexedDBSyncProvider;
 Object.defineProperty(exports, "KritzelAlignment", {
   enumerable: true,
@@ -923,5 +596,4 @@ exports.darkTheme = workspace_migrations.darkTheme;
 exports.lightTheme = workspace_migrations.lightTheme;
 exports.runMigrations = workspace_migrations.runMigrations;
 exports.BroadcastSyncProvider = BroadcastSyncProvider;
-exports.HocuspocusSyncProvider = HocuspocusSyncProvider;
 exports.WebSocketSyncProvider = WebSocketSyncProvider;