kritzel-stencil 0.1.76 → 0.1.78

package/dist/esm/{index-MV-81ybv.js → index-BbOHefEf.js}

@@ -2,7 +2,7 @@ const NAMESPACE = 'stencil';
 const BUILD = /* stencil */ { hotModuleReplacement: false, hydratedSelectorName: "hydrated", lazyLoad: true, propChangeCallback: true, state: true, updatable: true};
 
 /*
- Stencil Client Platform v4.43.2 | MIT Licensed | https://stenciljs.com
+ Stencil Client Platform v4.43.3 | MIT Licensed | https://stenciljs.com
  */
 
 

package/dist/esm/index.js

@@ -1,5 +1,4 @@
-import { H as HocuspocusProvider, a as HocuspocusProviderWebsocket } from './workspace.migrations-D48_Bqvh.js';
-export { A as APP_STATE_MIGRATIONS, C as CURRENT_APP_STATE_SCHEMA_VERSION, w as CURRENT_WORKSPACE_SCHEMA_VERSION, D as DEFAULT_BRUSH_CONFIG, s as DEFAULT_LINE_TOOL_CONFIG, r as DEFAULT_TEXT_CONFIG, I as IndexedDBSyncProvider, v as KritzelAlignment, p as KritzelAnchorManager, g as KritzelBrushTool, m as KritzelCursorHelper, i as KritzelEraserTool, e as KritzelGroup, c as KritzelImage, j as KritzelImageTool, d as KritzelLine, h as KritzelLineTool, b as KritzelPath, n as KritzelSelectionTool, f as KritzelShape, l as KritzelShapeTool, K as KritzelText, k as KritzelTextTool, q as KritzelThemeManager, o as KritzelWorkspace, S as ShapeType, W as WORKSPACE_EXPORT_VERSION, y as WORKSPACE_MIGRATIONS, u as darkTheme, t as lightTheme, x as runMigrations } from './workspace.migrations-D48_Bqvh.js';
+export { A as APP_STATE_MIGRATIONS, C as CURRENT_APP_STATE_SCHEMA_VERSION, v as CURRENT_WORKSPACE_SCHEMA_VERSION, D as DEFAULT_BRUSH_CONFIG, r as DEFAULT_LINE_TOOL_CONFIG, q as DEFAULT_TEXT_CONFIG, H as HocuspocusSyncProvider, I as IndexedDBSyncProvider, u as KritzelAlignment, o as KritzelAnchorManager, f as KritzelBrushTool, l as KritzelCursorHelper, h as KritzelEraserTool, d as KritzelGroup, b as KritzelImage, i as KritzelImageTool, c as KritzelLine, g as KritzelLineTool, a as KritzelPath, m as KritzelSelectionTool, e as KritzelShape, k as KritzelShapeTool, K as KritzelText, j as KritzelTextTool, p as KritzelThemeManager, n as KritzelWorkspace, S as ShapeType, W as WORKSPACE_EXPORT_VERSION, x as WORKSPACE_MIGRATIONS, t as darkTheme, s as lightTheme, w as runMigrations } from './workspace.migrations-NhRgr2_H.js';
 import * as Y from 'yjs';
 import { WebsocketProvider } from 'y-websocket';
 import 'y-indexeddb';
@@ -536,332 +535,4 @@ 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 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 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 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';
-    }
-}
-
-export { BroadcastSyncProvider, HocuspocusSyncProvider, WebSocketSyncProvider };
+export { BroadcastSyncProvider, WebSocketSyncProvider };