kritzel-stencil 0.1.62 → 0.1.63

package/dist/cjs/{alignment.enum-BhN7ih5b.js → alignment.enum-CCaamYTo.js}

@@ -25132,280 +25132,6 @@ class HocuspocusProvider extends EventEmitter {
     }
 }
 
-/**
- * Hocuspocus sync provider for real-time collaboration
- * Supports multiplexing - multiple documents can share the same WebSocket connection
- */
-class HocuspocusSyncProvider {
-    provider;
-    isConnected = false;
-    isSynced = false;
-    usesSharedSocket = false;
-    _statusCallbacks = [];
-    get awareness() {
-        return this.provider.awareness;
-    }
-    onStatusChange(callback) {
-        this._statusCallbacks.push(callback);
-    }
-    emitStatus(status, detail) {
-        for (const cb of this._statusCallbacks) {
-            cb(status, detail);
-        }
-    }
-    // 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';
-        // Use provided websocketProvider or the static shared one
-        const websocketProvider = options?.websocketProvider || HocuspocusSyncProvider.sharedWebSocketProvider;
-        if (websocketProvider) {
-            // Multiplexing mode - use shared WebSocket connection
-            this.usesSharedSocket = true;
-            const config = {
-                websocketProvider,
-                name,
-                document: doc,
-                token: options?.token || null,
-                onConnect: () => {
-                    if (this.isConnected) {
-                        return;
-                    }
-                    this.isConnected = true;
-                    this.emitStatus('connected');
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus connected: ${name}`);
-                    }
-                    if (options?.onConnect) {
-                        options.onConnect();
-                    }
-                },
-                onDisconnect: () => {
-                    if (!this.isConnected && !this.isSynced) {
-                        return;
-                    }
-                    this.isConnected = false;
-                    this.isSynced = false;
-                    this.emitStatus('disconnected');
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus disconnected: ${name}`);
-                    }
-                    if (options?.onDisconnect) {
-                        options.onDisconnect();
-                    }
-                },
-                onSynced: () => {
-                    if (this.isSynced) {
-                        return;
-                    }
-                    this.isSynced = true;
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus synced: ${name}`);
-                    }
-                    if (options?.onSynced) {
-                        options.onSynced();
-                    }
-                },
-            };
-            // Add optional settings
-            if (options?.forceSyncInterval !== undefined) {
-                config.forceSyncInterval = options.forceSyncInterval;
-            }
-            if (options?.onAuthenticationFailed) {
-                const originalHandler = options.onAuthenticationFailed;
-                config.onAuthenticationFailed = (data) => {
-                    this.emitStatus('error', { message: 'Authentication failed' });
-                    originalHandler(data);
-                };
-            }
-            if (options?.onStatus) {
-                config.onStatus = options.onStatus;
-            }
-            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,
-                onConnect: () => {
-                    if (this.isConnected) {
-                        return;
-                    }
-                    this.isConnected = true;
-                    this.emitStatus('connected');
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus connected: ${name}`);
-                    }
-                    if (options?.onConnect) {
-                        options.onConnect();
-                    }
-                },
-                onDisconnect: () => {
-                    if (!this.isConnected && !this.isSynced) {
-                        return;
-                    }
-                    this.isConnected = false;
-                    this.isSynced = false;
-                    this.emitStatus('disconnected');
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus disconnected: ${name}`);
-                    }
-                    if (options?.onDisconnect) {
-                        options.onDisconnect();
-                    }
-                },
-                onSynced: () => {
-                    if (this.isSynced) {
-                        return;
-                    }
-                    this.isSynced = true;
-                    if (!options?.quiet) {
-                        console.info(`Hocuspocus synced: ${name}`);
-                    }
-                    if (options?.onSynced) {
-                        options.onSynced();
-                    }
-                },
-            };
-            // Add optional settings
-            if (options?.forceSyncInterval !== undefined) {
-                config.forceSyncInterval = options.forceSyncInterval;
-            }
-            if (options?.onAuthenticationFailed) {
-                const originalHandler = options.onAuthenticationFailed;
-                config.onAuthenticationFailed = (data) => {
-                    this.emitStatus('error', { message: 'Authentication failed' });
-                    originalHandler(data);
-                };
-            }
-            if (options?.onStatus) {
-                config.onStatus = options.onStatus;
-            }
-            if (options?.WebSocketPolyfill) {
-                config.WebSocketPolyfill = options.WebSocketPolyfill;
-            }
-            this.provider = new HocuspocusProvider(config);
-            if (!options?.quiet) {
-                console.info(`Hocuspocus Provider initialized: ${url}/${name}`);
-            }
-        }
-    }
-    /**
-     * 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) {
-            return;
-        }
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Hocuspocus connection timeout'));
-            }, 10000); // 10 second timeout
-            const syncHandler = () => {
-                clearTimeout(timeout);
-                this.provider.off('synced', syncHandler);
-                resolve();
-            };
-            this.provider.on('synced', syncHandler);
-            // If already synced, resolve immediately
-            if (this.provider.isSynced) {
-                clearTimeout(timeout);
-                this.provider.off('synced', syncHandler);
-                resolve();
-                return;
-            }
-            // Connect if not already connected (standalone mode only)
-            if (!this.isConnected && !this.usesSharedSocket) {
-                this.provider.connect();
-            }
-        });
-    }
-    disconnect() {
-        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;
-    }
-    destroy() {
-        if (this.provider) {
-            this.provider.destroy();
-        }
-        this.isConnected = false;
-        this.isSynced = false;
-    }
-}
-
 /** Current version of the workspace export format */
 const WORKSPACE_EXPORT_VERSION = '1.1.0';
 /**
@@ -25495,8 +25221,6 @@ class KritzelWorkspace {
         Object.assign(this, object);
         this.createdAt = new Date(object.createdAt);
         this.updatedAt = new Date(object.updatedAt);
-        // Backward compatibility: infer isPublic from old linkShare/visibility fields
-        this.isPublic = object.isPublic ?? object.linkShare?.enabled ?? (object.visibility === 'shared');
         return this;
     }
 }
@@ -26880,7 +26604,8 @@ exports.DEFAULT_BRUSH_CONFIG = DEFAULT_BRUSH_CONFIG;
 exports.DEFAULT_COLOR_PALETTE = DEFAULT_COLOR_PALETTE;
 exports.DEFAULT_LINE_TOOL_CONFIG = DEFAULT_LINE_TOOL_CONFIG;
 exports.DEFAULT_TEXT_CONFIG = DEFAULT_TEXT_CONFIG;
-exports.HocuspocusSyncProvider = HocuspocusSyncProvider;
+exports.HocuspocusProvider = HocuspocusProvider;
+exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
 exports.IndexedDBSyncProvider = IndexedDBSyncProvider;
 exports.KritzelAnchorManager = KritzelAnchorManager;
 exports.KritzelBaseHandler = KritzelBaseHandler;

package/dist/cjs/index.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var alignment_enum = require('./alignment.enum-BhN7ih5b.js');
+var alignment_enum = require('./alignment.enum-CCaamYTo.js');
 var Y = require('yjs');
 var yWebsocket = require('y-websocket');
 require('y-indexeddb');
@@ -547,10 +547,262 @@ class WebSocketSyncProvider {
     }
 }
 
+/**
+ * Hocuspocus sync provider for real-time collaboration
+ * Supports multiplexing - multiple documents can share the same WebSocket connection
+ */
+class HocuspocusSyncProvider {
+    provider;
+    isConnected = false;
+    isSynced = false;
+    usesSharedSocket = false;
+    get awareness() {
+        return this.provider.awareness;
+    }
+    // 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';
+        // Use provided websocketProvider or the static shared one
+        const websocketProvider = options?.websocketProvider || HocuspocusSyncProvider.sharedWebSocketProvider;
+        if (websocketProvider) {
+            // Multiplexing mode - use shared WebSocket connection
+            this.usesSharedSocket = true;
+            const config = {
+                websocketProvider,
+                name,
+                document: doc,
+                token: options?.token || null,
+                onConnect: () => {
+                    if (this.isConnected) {
+                        return;
+                    }
+                    this.isConnected = true;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus connected: ${name}`);
+                    }
+                    if (options?.onConnect) {
+                        options.onConnect();
+                    }
+                },
+                onDisconnect: () => {
+                    if (!this.isConnected && !this.isSynced) {
+                        return;
+                    }
+                    this.isConnected = false;
+                    this.isSynced = false;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus disconnected: ${name}`);
+                    }
+                    if (options?.onDisconnect) {
+                        options.onDisconnect();
+                    }
+                },
+                onSynced: () => {
+                    if (this.isSynced) {
+                        return;
+                    }
+                    this.isSynced = true;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus synced: ${name}`);
+                    }
+                    if (options?.onSynced) {
+                        options.onSynced();
+                    }
+                },
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            if (options?.onStatus) {
+                config.onStatus = options.onStatus;
+            }
+            this.provider = new alignment_enum.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,
+                onConnect: () => {
+                    if (this.isConnected) {
+                        return;
+                    }
+                    this.isConnected = true;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus connected: ${name}`);
+                    }
+                    if (options?.onConnect) {
+                        options.onConnect();
+                    }
+                },
+                onDisconnect: () => {
+                    if (!this.isConnected && !this.isSynced) {
+                        return;
+                    }
+                    this.isConnected = false;
+                    this.isSynced = false;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus disconnected: ${name}`);
+                    }
+                    if (options?.onDisconnect) {
+                        options.onDisconnect();
+                    }
+                },
+                onSynced: () => {
+                    if (this.isSynced) {
+                        return;
+                    }
+                    this.isSynced = true;
+                    if (!options?.quiet) {
+                        console.info(`Hocuspocus synced: ${name}`);
+                    }
+                    if (options?.onSynced) {
+                        options.onSynced();
+                    }
+                },
+            };
+            // Add optional settings
+            if (options?.forceSyncInterval !== undefined) {
+                config.forceSyncInterval = options.forceSyncInterval;
+            }
+            if (options?.onAuthenticationFailed) {
+                config.onAuthenticationFailed = options.onAuthenticationFailed;
+            }
+            if (options?.onStatus) {
+                config.onStatus = options.onStatus;
+            }
+            if (options?.WebSocketPolyfill) {
+                config.WebSocketPolyfill = options.WebSocketPolyfill;
+            }
+            this.provider = new alignment_enum.HocuspocusProvider(config);
+            if (!options?.quiet) {
+                console.info(`Hocuspocus Provider initialized: ${url}/${name}`);
+            }
+        }
+    }
+    /**
+     * 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 alignment_enum.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) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Hocuspocus connection timeout'));
+            }, 10000); // 10 second timeout
+            const syncHandler = () => {
+                clearTimeout(timeout);
+                this.provider.off('synced', syncHandler);
+                resolve();
+            };
+            this.provider.on('synced', syncHandler);
+            // If already synced, resolve immediately
+            if (this.provider.isSynced) {
+                clearTimeout(timeout);
+                this.provider.off('synced', syncHandler);
+                resolve();
+                return;
+            }
+            // Connect if not already connected (standalone mode only)
+            if (!this.isConnected && !this.usesSharedSocket) {
+                this.provider.connect();
+            }
+        });
+    }
+    disconnect() {
+        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;
+    }
+    destroy() {
+        if (this.provider) {
+            this.provider.destroy();
+        }
+        this.isConnected = false;
+        this.isSynced = false;
+    }
+}
+
 exports.DEFAULT_BRUSH_CONFIG = alignment_enum.DEFAULT_BRUSH_CONFIG;
 exports.DEFAULT_LINE_TOOL_CONFIG = alignment_enum.DEFAULT_LINE_TOOL_CONFIG;
 exports.DEFAULT_TEXT_CONFIG = alignment_enum.DEFAULT_TEXT_CONFIG;
-exports.HocuspocusSyncProvider = alignment_enum.HocuspocusSyncProvider;
 exports.IndexedDBSyncProvider = alignment_enum.IndexedDBSyncProvider;
 Object.defineProperty(exports, "KritzelAlignment", {
   enumerable: true,
@@ -581,4 +833,5 @@ exports.WORKSPACE_EXPORT_VERSION = alignment_enum.WORKSPACE_EXPORT_VERSION;
 exports.darkTheme = alignment_enum.darkTheme;
 exports.lightTheme = alignment_enum.lightTheme;
 exports.BroadcastSyncProvider = BroadcastSyncProvider;
+exports.HocuspocusSyncProvider = HocuspocusSyncProvider;
 exports.WebSocketSyncProvider = WebSocketSyncProvider;