kritzel-stencil 0.3.30 → 0.3.32

package/dist/cjs/index.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var schema_constants = require('./schema.constants-TiseVL4a.js');
+var schema_constants = require('./schema.constants-DItwOm2z.js');
 var Y = require('yjs');
 var yIndexeddb = require('y-indexeddb');
 var yWebsocket = require('y-websocket');

package/dist/cjs/kritzel-active-users_45.cjs.entry.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var index = require('./index-Xav9JFHg.js');
-var schema_constants = require('./schema.constants-TiseVL4a.js');
+var schema_constants = require('./schema.constants-DItwOm2z.js');
 var Y = require('yjs');
 require('y-indexeddb');
 require('y-websocket');
@@ -21918,6 +21918,20 @@ class KritzelQuadtree {
         }
         return false;
     }
+    /**
+     * Reindexes an existing object by removing it from its current node and
+     * reinserting it based on its latest bounding box.
+     *
+     * @param object - The updated object to reindex
+     * @returns `true` if the object was found and reinserted, `false` otherwise
+     */
+    reindex(object) {
+        const removed = this.remove(o => o.id === object.id);
+        if (removed === 0) {
+            return false;
+        }
+        return this.insert(object);
+    }
     /**
      * Removes objects from the quadtree that match the given predicate.
      * Recursively searches through all nodes and removes matching objects.
@@ -22489,10 +22503,19 @@ class KritzelObjectMap {
         const objectsToUpdate = [];
         const selectionGroupsToUpdate = [];
         const objectsToDelete = [];
+        // The reverse anchor index (targetObjectId -> anchored lines) is derived runtime
+        // state that is NOT synced via Yjs. When line anchor connections arrive through a
+        // remote change it must be rebuilt, otherwise getLinesAnchoredTo/updateAnchorsForObject
+        // return stale/empty results on this client (e.g. anchored lines fail to follow a
+        // locally-moved target, leaving selection UI and anchors visually offset).
+        let anchorIndexNeedsRebuild = false;
         changedKeys.forEach(key => {
             const change = event.changes.keys.get(key);
             if (change && change.action === 'delete') {
                 objectsToDelete.push(key);
+                if (this._idMap.get(key) instanceof schema_constants.KritzelLine) {
+                    anchorIndexNeedsRebuild = true;
+                }
             }
             else {
                 const serialized = this._objectsMap?.get(key);
@@ -22504,6 +22527,9 @@ class KritzelObjectMap {
                     }
                     else {
                         objectsToUpdate.push(object);
+                        if (object instanceof schema_constants.KritzelLine) {
+                            anchorIndexNeedsRebuild = true;
+                        }
                     }
                 }
             }
@@ -22530,7 +22556,7 @@ class KritzelObjectMap {
                 if (previous && typeof object.adoptTransientStateFrom === 'function') {
                     object.adoptTransientStateFrom(previous);
                 }
-                this.quadtree.update(object);
+                this.quadtree.reindex(object);
                 this._idMap.set(object.id, object);
                 updatedObjects.push(object);
             }
@@ -22549,7 +22575,7 @@ class KritzelObjectMap {
                 if (previous && typeof object.adoptTransientStateFrom === 'function') {
                     object.adoptTransientStateFrom(previous);
                 }
-                this.quadtree.update(object);
+                this.quadtree.reindex(object);
                 this._idMap.set(object.id, object);
             }
             else {
@@ -22566,7 +22592,7 @@ class KritzelObjectMap {
             object.refreshObjectDimensions(undefined, true);
             object.captureUnchangedSnapshots();
             // Update quadtree again with corrected dimensions
-            this.quadtree.update(object);
+            this.quadtree.reindex(object);
         });
         // If regular objects were changed but their SelectionGroup wasn't explicitly updated,
         // we still need to refresh that SelectionGroup's dimensions
@@ -22584,10 +22610,16 @@ class KritzelObjectMap {
                     selectionGroup.refreshObjectDimensions(undefined, true);
                     selectionGroup.captureUnchangedSnapshots();
                     // Update quadtree with corrected dimensions
-                    this.quadtree.update(selectionGroup);
+                    this.quadtree.reindex(selectionGroup);
                 }
             }
         }
+        // Rebuild the anchor index if any line anchor connections may have changed, so that
+        // subsequent local operations (moving a target, refreshing selection UI) resolve the
+        // correct anchored lines on this client.
+        if (anchorIndexNeedsRebuild) {
+            this._core?.anchorManager.rebuildIndex();
+        }
         // Invalidate the store's selection cache so it fetches the updated SelectionGroup
         this._core?.store.invalidateSelectionCache();
         this._core?.rerender();
@@ -22829,7 +22861,12 @@ class KritzelObjectMap {
         if (!existed) {
             return false;
         }
-        this.quadtree.update(object);
+        if (this._localOnlyMode || options.skipReindex) {
+            this.quadtree.update(object);
+        }
+        else {
+            this.quadtree.reindex(object);
+        }
         this._idMap.set(object.id, object);
         if (!this._localOnlyMode && this._objectsMap && this.isPersistable(object)) {
             const serialized = object.serialize();
@@ -24018,17 +24055,17 @@ class KritzelBrowserPermissionManager {
      */
     constructor(_core) {
         this.registerRequestPermissionHandler('clipboard-read', async () => {
-            // Firefox and Safari open native paste menus when readText() is called
+            // Firefox and Safari open native paste menus when the clipboard is read
             // proactively, so rely on the permission state instead of an eager read.
             if (this._isFirefox || this._isSafari) {
                 return 'granted';
             }
             try {
-                await navigator.clipboard.readText();
-                return 'granted';
+                const status = await navigator.permissions.query({ name: 'clipboard-read' });
+                return status.state === 'denied' ? 'denied' : 'granted';
             }
             catch {
-                return 'denied';
+                return 'granted';
             }
         });
     }
@@ -24067,37 +24104,141 @@ class KritzelBrowserPermissionManager {
     }
 }
 
-const CLIPBOARD_PAYLOAD_PREFIX = 'kritzel-clipboard/v1:';
-/**
- * Manages clipboard operations (copy/cut/paste) for a core instance.
- *
- * The system clipboard is the single source of truth: copy serializes the current
- * selection into a Kritzel payload, paste reads + revives it. No copied objects are
- * cached on the engine state.
- */
-class KritzelClipboardManager {
+class KritzelPasteIntentProviderRegistry {
     _core;
-    /**
-     * In-memory cascade offset (world units) applied to successive pastes of the same
-     * clipboard content so they don't stack exactly on top of each other. Reset on copy/cut.
-     */
-    _pasteOffset = 0;
-    constructor(core) {
-        this._core = core;
+    _providers = [];
+    constructor(_core) {
+        this._core = _core;
     }
-    /**
-     * Serializes an object for the clipboard payload. Groups additionally embed their
-     * (recursively serialized) children under `__children__` so the payload is self-contained.
-     */
-    serializeForClipboard(object) {
-        const serialized = (typeof object.serialize === 'function' ? object.serialize() : object);
-        if (schema_constants.KritzelClassHelper.isInstanceOf(object, 'KritzelGroup')) {
-            serialized.__children__ = object.children.map(child => this.serializeForClipboard(child));
+    register(provider) {
+        this._providers.push(provider);
+    }
+    async resolve(event) {
+        const context = {
+            core: this._core,
+            event,
+        };
+        for (const provider of this._providers) {
+            if (!provider.canHandle(context)) {
+                continue;
+            }
+            const intent = await provider.getPasteIntent(context);
+            if (intent.type !== 'unknown') {
+                return intent;
+            }
         }
-        return serialized;
+        return { type: 'unknown' };
     }
-    serializeClipboardPayload(payload) {
-        return `${CLIPBOARD_PAYLOAD_PREFIX}${JSON.stringify(payload)}`;
+}
+
+const CLIPBOARD_PAYLOAD_PREFIX = 'kritzel-clipboard/v1:';
+
+class KritzelEventPasteIntentProvider {
+    canHandle(context) {
+        return !!context.event?.clipboardData;
+    }
+    async getPasteIntent(context) {
+        const data = context.event?.clipboardData;
+        if (!data) {
+            return { type: 'unknown' };
+        }
+        const imageFiles = Array.from(data.files ?? []).filter(file => file.type.startsWith('image/'));
+        if (imageFiles.length > 0) {
+            return { type: 'image_files', files: imageFiles };
+        }
+        if (data.types.includes('text/plain')) {
+            const textIntent = this.determineTextPasteIntent(data.getData('text/plain'));
+            if (textIntent) {
+                return textIntent;
+            }
+        }
+        return { type: 'unknown' };
+    }
+    parseClipboardPayload(text) {
+        if (!text || !text.startsWith(CLIPBOARD_PAYLOAD_PREFIX)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(text.slice(CLIPBOARD_PAYLOAD_PREFIX.length));
+            if (parsed?.version !== 1 || !Array.isArray(parsed.objects)) {
+                return null;
+            }
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    determineTextPasteIntent(text) {
+        const payload = this.parseClipboardPayload(text);
+        if (payload) {
+            return { type: 'kritzel_objects', payload };
+        }
+        if (text && text.trim().length > 0) {
+            return { type: 'plain_text', text };
+        }
+        return null;
+    }
+}
+
+class KritzelNavigatorPasteIntentProvider {
+    canHandle(context) {
+        return !context.event?.clipboardData && typeof navigator !== 'undefined' && !!navigator.clipboard;
+    }
+    async getPasteIntent(context) {
+        if (typeof navigator === 'undefined' || !navigator.clipboard) {
+            return { type: 'unknown' };
+        }
+        const { clipboard } = navigator;
+        const permissionState = await context.core.permissionManager.checkPermission('clipboard-read');
+        if (permissionState !== 'granted') {
+            const requestedState = await context.core.permissionManager.requestPermission('clipboard-read');
+            if (requestedState !== 'granted') {
+                return { type: 'unknown' };
+            }
+        }
+        if (clipboard.read) {
+            try {
+                const items = await clipboard.read();
+                const { imageFiles, text } = await this.processClipboardItems(items);
+                if (imageFiles.length > 0) {
+                    return { type: 'image_files', files: imageFiles };
+                }
+                if (text !== null) {
+                    const textIntent = this.determineTextPasteIntent(text);
+                    if (textIntent) {
+                        return textIntent;
+                    }
+                }
+            }
+            catch {
+                // Fall back to readText below when read() is denied or unavailable at runtime.
+            }
+        }
+        if (clipboard.readText) {
+            const textIntent = this.determineTextPasteIntent(await clipboard.readText());
+            if (textIntent) {
+                return textIntent;
+            }
+        }
+        return { type: 'unknown' };
+    }
+    async processClipboardItems(items) {
+        const imageFiles = [];
+        let text = null;
+        await Promise.all(items.map(async (item) => {
+            const imageType = item.types.find(type => type.startsWith('image/'));
+            if (imageType) {
+                const blob = await item.getType(imageType);
+                imageFiles.push(new File([blob], 'pasted-image', { type: imageType }));
+                return;
+            }
+            if (text === null && item.types.includes('text/plain')) {
+                const blob = await item.getType('text/plain');
+                text = await blob.text();
+            }
+        }));
+        return { imageFiles, text };
     }
     parseClipboardPayload(text) {
         if (!text || !text.startsWith(CLIPBOARD_PAYLOAD_PREFIX)) {
@@ -24124,6 +24265,79 @@ class KritzelClipboardManager {
         }
         return null;
     }
+}
+
+class KritzelIosPasteIntentProvider {
+    canHandle(context) {
+        return !context.event?.clipboardData && schema_constants.KritzelDevicesHelper.isIOS();
+    }
+    async getPasteIntent(context) {
+        // On iOS Safari, eventless programmatic clipboard reads are commonly unavailable
+        // (e.g. the context-menu paste calls engine.paste() without a native ClipboardEvent).
+        // Fall back to the in-memory session buffer so internal object copy/paste still works.
+        const payload = context.core.clipboardManager.sessionClipboardPayload;
+        if (payload) {
+            return { type: 'kritzel_objects', payload };
+        }
+        return { type: 'unknown' };
+    }
+}
+
+/**
+ * Manages clipboard operations (copy/cut/paste) for a core instance.
+ *
+ * The system clipboard is the preferred source of truth: copy serializes the current
+ * selection into a Kritzel payload, paste reads + revives it.
+ *
+ * A copy also mirrors the payload into an in-memory session buffer. On platforms where
+ * eventless programmatic clipboard access is unavailable (notably iOS Safari, where the
+ * context menu triggers copy/paste without a native ClipboardEvent), the session buffer
+ * is used as the fallback source so internal object copy/paste keeps working.
+ */
+class KritzelClipboardManager {
+    _core;
+    _pasteIntentRegistry;
+    /**
+     * In-memory mirror of the most recent copy payload. Acts as the fallback clipboard
+     * source when the system clipboard cannot be read programmatically (e.g. iOS Safari
+     * context-menu paste). Reset is not required; a new copy overwrites it.
+     */
+    _sessionClipboardPayload = null;
+    /**
+     * In-memory cascade offset (world units) applied to successive pastes of the same
+     * clipboard content so they don't stack exactly on top of each other. Reset on copy/cut.
+     */
+    _pasteOffset = 0;
+    constructor(core) {
+        this._core = core;
+        this._pasteIntentRegistry = new KritzelPasteIntentProviderRegistry(this._core);
+        // Provider order is intentional: iOS eventless path should short-circuit,
+        // native paste events remain preferred, and async navigator APIs are fallback.
+        this._pasteIntentRegistry.register(new KritzelIosPasteIntentProvider());
+        this._pasteIntentRegistry.register(new KritzelEventPasteIntentProvider());
+        this._pasteIntentRegistry.register(new KritzelNavigatorPasteIntentProvider());
+    }
+    /**
+     * The most recent copy payload mirrored in memory, used as a fallback clipboard
+     * source when the system clipboard cannot be read programmatically.
+     */
+    get sessionClipboardPayload() {
+        return this._sessionClipboardPayload;
+    }
+    /**
+     * Serializes an object for the clipboard payload. Groups additionally embed their
+     * (recursively serialized) children under `__children__` so the payload is self-contained.
+     */
+    serializeForClipboard(object) {
+        const serialized = (typeof object.serialize === 'function' ? object.serialize() : object);
+        if (schema_constants.KritzelClassHelper.isInstanceOf(object, 'KritzelGroup')) {
+            serialized.__children__ = object.children.map(child => this.serializeForClipboard(child));
+        }
+        return serialized;
+    }
+    serializeClipboardPayload(payload) {
+        return `${CLIPBOARD_PAYLOAD_PREFIX}${JSON.stringify(payload)}`;
+    }
     async writeBrowserClipboardPayload(payload, event) {
         const serialized = this.serializeClipboardPayload(payload);
         if (event?.clipboardData) {
@@ -24203,80 +24417,6 @@ class KritzelClipboardManager {
             }
         }
     }
-    /**
-     * Evaluates the clipboard event to determine exactly what the user is trying to paste.
-     * Returns a PasteIntent covering the 3 main cases: Kritzel objects, Images, or Plain text.
-     */
-    async determinePasteIntent(event) {
-        if (event?.clipboardData) {
-            const data = event.clipboardData;
-            const imageFiles = Array.from(data.files ?? []).filter(file => file.type.startsWith('image/'));
-            if (imageFiles.length > 0) {
-                return { type: 'image_files', files: imageFiles };
-            }
-            if (data.types.includes('text/plain')) {
-                const textIntent = this.determineTextPasteIntent(data.getData('text/plain'));
-                if (textIntent)
-                    return textIntent;
-            }
-            return { type: 'unknown' };
-        }
-        if (typeof navigator === 'undefined' || !navigator.clipboard) {
-            return { type: 'unknown' };
-        }
-        const { clipboard } = navigator;
-        const permissionState = await this._core.permissionManager.checkPermission('clipboard-read');
-        if (permissionState !== 'granted') {
-            const requestedState = await this._core.permissionManager.requestPermission('clipboard-read');
-            if (requestedState !== 'granted') {
-                return { type: 'unknown' };
-            }
-        }
-        if (clipboard.read) {
-            try {
-                const items = await clipboard.read();
-                const { imageFiles, text } = await this.processClipboardItems(items);
-                if (imageFiles.length > 0) {
-                    return { type: 'image_files', files: imageFiles };
-                }
-                if (text !== null) {
-                    const textIntent = this.determineTextPasteIntent(text);
-                    if (textIntent)
-                        return textIntent;
-                }
-            }
-            catch {
-                // Fall back to readText below when read() is denied or unavailable at runtime.
-            }
-        }
-        if (clipboard.readText) {
-            const textIntent = this.determineTextPasteIntent(await clipboard.readText());
-            if (textIntent)
-                return textIntent;
-        }
-        return { type: 'unknown' };
-    }
-    /**
-     * Helper to parse clipboard items in parallel
-     */
-    async processClipboardItems(items) {
-        const imageFiles = [];
-        let text = null;
-        // Process items concurrently
-        await Promise.all(items.map(async (item) => {
-            const imageType = item.types.find(type => type.startsWith('image/'));
-            if (imageType) {
-                const blob = await item.getType(imageType);
-                imageFiles.push(new File([blob], 'pasted-image', { type: imageType }));
-                return;
-            }
-            if (text === null && item.types.includes('text/plain')) {
-                const blob = await item.getType('text/plain');
-                text = await blob.text();
-            }
-        }));
-        return { imageFiles, text };
-    }
     /**
      * Copies currently selected objects into internal clipboard state.
      */
@@ -24292,6 +24432,9 @@ class KritzelClipboardManager {
         };
         // A fresh copy resets the cascade so the first paste lands at the default offset.
         this._pasteOffset = 0;
+        // Mirror the payload in memory so eventless paste still works where the system
+        // clipboard is not programmatically accessible (e.g. iOS Safari context menu).
+        this._sessionClipboardPayload = payload;
         void this.writeBrowserClipboardPayload(payload, event);
     }
     /**
@@ -24350,7 +24493,7 @@ class KritzelClipboardManager {
      * Pastes objects from clipboard with optional explicit world coordinates.
      */
     async paste(x, y, event) {
-        const pasteIntent = await this.determinePasteIntent(event);
+        const pasteIntent = await this._pasteIntentRegistry.resolve(event);
         let objects = null;
         if (pasteIntent.type === 'kritzel_objects') {
             objects = this.materializeKritzelObjects(pasteIntent);
@@ -31259,7 +31402,7 @@ const KritzelPortal = class {
  * This file is auto-generated by the version bump scripts.
  * Do not modify manually.
  */
-const KRITZEL_VERSION = '0.3.30';
+const KRITZEL_VERSION = '0.3.32';
 
 const kritzelSettingsCss = () => `:host{display:contents}kritzel-dialog{--kritzel-dialog-body-padding:0;--kritzel-dialog-width-large:800px;--kritzel-dialog-height-large:500px}.footer-button{padding:8px 16px;border-radius:6px;cursor:pointer;font-size:14px}.cancel-button{border:1px solid #ebebeb;background:#fff;color:inherit}.cancel-button:hover{background:#f5f5f5}.settings-content{padding:0}.settings-content h3{margin:0 0 16px 0;font-size:18px;font-weight:600;color:var(--kritzel-settings-content-heading-color, #333333)}.settings-content p{margin:0;font-size:14px;color:var(--kritzel-settings-content-text-color, #666666);line-height:1.5}.settings-group{display:flex;flex-direction:column;gap:24px}.settings-item{display:flex;flex-direction:column;gap:8px}.settings-row{display:flex;align-items:center;justify-content:space-between;gap:16px}.settings-label{font-size:14px;font-weight:600;color:var(--kritzel-settings-label-color, #333333);margin:0 0 4px 0}.settings-description{font-size:12px;color:var(--kritzel-settings-description-color, #888888);margin:0;line-height:1.4}.shortcuts-list{display:flex;flex-direction:column;gap:24px}.shortcuts-category{display:flex;flex-direction:column;gap:8px}.shortcuts-category-title{font-size:14px;font-weight:600;color:var(--kritzel-settings-label-color, #333333);margin:0 0 4px 0}.shortcuts-group{display:flex;flex-direction:column;gap:4px}.shortcut-item{display:flex;justify-content:space-between;align-items:center;padding:6px 8px;border-radius:4px;background:var(--kritzel-settings-shortcut-item-bg, rgba(0, 0, 0, 0.02))}.shortcut-label{font-size:14px;color:var(--kritzel-settings-content-text-color, #666666)}.shortcut-key{font-family:monospace;font-size:12px;padding:2px 8px;border-radius:4px;background:var(--kritzel-settings-shortcut-key-bg, #f0f0f0);color:var(--kritzel-settings-shortcut-key-color, #333333);border:1px solid var(--kritzel-settings-shortcut-key-border, #ddd)}`;
 

package/dist/cjs/{schema.constants-TiseVL4a.js → schema.constants-DItwOm2z.js}

@@ -571,6 +571,13 @@ class KritzelBaseObject {
         this.resizing = false;
         this.markedForRemoval = false;
         this.isVisible = true;
+        // Reset known transient geometry caches if present on subclasses.
+        if ('_adjustedPoints' in this) {
+            this._adjustedPoints = null;
+        }
+        if ('_clipInfo' in this) {
+            this._clipInfo = null;
+        }
         return this;
     }
     /**
@@ -18393,6 +18400,27 @@ class KritzelLine extends KritzelBaseObject {
     calculateBoundingBox() {
         return KritzelLine.calculateBoundingBox(this.startX, this.startY, this.endX, this.endY, this.controlX, this.controlY, this.strokeWidth);
     }
+    /**
+     * Serializes the line while excluding transient cache fields.
+     * @returns A serializable line object without runtime caches
+     */
+    serialize() {
+        const serialized = super.serialize();
+        delete serialized._adjustedPoints;
+        delete serialized._clipInfo;
+        return serialized;
+    }
+    /**
+     * Deserializes and resets transient caches so geometry is recomputed lazily.
+     * @param object - The serialized line object
+     * @returns This instance cast to type T
+     */
+    deserialize(object) {
+        const result = super.deserialize(object);
+        this._adjustedPoints = null;
+        this._clipInfo = null;
+        return result;
+    }
     /**
      * Recalculates and updates the width, height, x, y, and translation properties
      * based on the current endpoint positions and stroke width.
@@ -24327,8 +24355,10 @@ class KritzelLineHandleHandler extends KritzelBaseHandler {
         // Adjust translateX/Y to compensate for the bounding box shift
         line.translateX = newTranslateX;
         line.translateY = newTranslateY;
-        // Clear cached adjusted points
-        line._adjustedPoints = null;
+        // Clear transient caches so geometry and anchor clipping recompute on demand.
+        const linePrivate = line;
+        linePrivate._adjustedPoints = null;
+        linePrivate._clipInfo = null;
         this._core.store.objects.update(line);
     }
     /**

package/dist/collection/classes/handlers/line-handle.handler.js

@@ -395,8 +395,10 @@ export class KritzelLineHandleHandler extends KritzelBaseHandler {
         // Adjust translateX/Y to compensate for the bounding box shift
         line.translateX = newTranslateX;
         line.translateY = newTranslateY;
-        // Clear cached adjusted points
-        line._adjustedPoints = null;
+        // Clear transient caches so geometry and anchor clipping recompute on demand.
+        const linePrivate = line;
+        linePrivate._adjustedPoints = null;
+        linePrivate._clipInfo = null;
         this._core.store.objects.update(line);
     }
     /**

package/dist/collection/classes/managers/browser-permission.manager.js

@@ -14,17 +14,17 @@ export class KritzelBrowserPermissionManager {
      */
     constructor(_core) {
         this.registerRequestPermissionHandler('clipboard-read', async () => {
-            // Firefox and Safari open native paste menus when readText() is called
+            // Firefox and Safari open native paste menus when the clipboard is read
             // proactively, so rely on the permission state instead of an eager read.
             if (this._isFirefox || this._isSafari) {
                 return 'granted';
             }
             try {
-                await navigator.clipboard.readText();
-                return 'granted';
+                const status = await navigator.permissions.query({ name: 'clipboard-read' });
+                return status.state === 'denied' ? 'denied' : 'granted';
             }
             catch {
-                return 'denied';
+                return 'granted';
             }
         });
     }