@kritzel/engine 0.4.31

package/dist/stencil/stencil.esm.js

@@ -0,0 +1,21 @@
+import { p as promiseResolve, b as bootstrapLazy } from './p-BU9Mv7y0.js';
+export { s as setNonce } from './p-BU9Mv7y0.js';
+import { g as globalScripts } from './p-DQuL1Twl.js';
+
+/*
+ Stencil Client Patch Browser v4.44.2 | MIT Licensed | https://stenciljs.com
+ */
+
+var patchBrowser = () => {
+  const importMeta = import.meta.url;
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await globalScripts();
+  return bootstrapLazy([["p-f0a8b7af",[[513,"kritzel-engine",{"workspaces":[16],"editorId":[1,"editor-id"],"activeWorkspaceId":[1,"active-workspace-id"],"syncConfig":[16],"assetStorageConfig":[16],"user":[16],"globalContextMenuItems":[16],"objectContextMenuItems":[16],"scaleMax":[1026,"scale-max"],"scaleMin":[1026,"scale-min"],"cursorTarget":[16],"lockDrawingScale":[4,"lock-drawing-scale"],"theme":[1],"licenseKey":[1,"license-key"],"themes":[16],"locale":[1],"locales":[16],"fallbackLocale":[1,"fallback-locale"],"viewportBoundaryLeft":[2,"viewport-boundary-left"],"viewportBoundaryRight":[2,"viewport-boundary-right"],"viewportBoundaryTop":[2,"viewport-boundary-top"],"viewportBoundaryBottom":[2,"viewport-boundary-bottom"],"debugInfo":[16],"isPanningEnabled":[4,"is-panning-enabled"],"isZoomingEnabled":[4,"is-zooming-enabled"],"forceUpdate":[32],"triggerSelectionChange":[64],"beginSceneBootstrap":[64],"endSceneBootstrap":[64],"registerTool":[64],"changeActiveTool":[64],"disable":[64],"enable":[64],"delete":[64],"copy":[64],"cut":[64],"paste":[64],"bringForward":[64],"sendBackward":[64],"bringToFront":[64],"sendToBack":[64],"alignObjects":[64],"group":[64],"ungroup":[64],"undo":[64],"redo":[64],"hideContextMenu":[64],"openContextMenu":[64],"getObjectById":[64],"getAllObjects":[64],"findObjects":[64],"getObjectsTotalCount":[64],"addObject":[64],"addObjects":[64],"updateObject":[64],"removeObject":[64],"removeObjects":[64],"getSelectedObjects":[64],"getDisplayableShortcuts":[64],"selectObjects":[64],"selectAllObjectsInViewport":[64],"clearSelection":[64],"centerObjectInViewport":[64],"panToObject":[64],"backToContent":[64],"centerAllObjects":[64],"centerObjects":[64],"setViewport":[64],"panTo":[64],"zoomTo":[64],"zoomIn":[64],"zoomOut":[64],"getViewport":[64],"screenToWorld":[64],"worldToScreen":[64],"getObjectsInViewport":[64],"getScreenshot":[64],"exportViewportAsPng":[64],"exportViewportAsSvg":[64],"getSelectedObjectSupportedExportFormats":[64],"canExportSelectedObjectAs":[64],"exportSelectedObject":[64],"exportAsJson":[64],"importFromJson":[64],"loadObjectsFromJson":[64],"downloadAsJson":[64],"importFromFile":[64],"cancelImportFromFile":[64],"setActiveWorkspace":[64],"createWorkspace":[64],"updateWorkspace":[64],"deleteWorkspace":[64],"getWorkspaces":[64],"getActiveWorkspace":[64],"getIsPublic":[64],"loadSharedWorkspace":[64],"reinitSync":[64],"saveSettings":[64],"loadSettings":[64],"registerLocales":[64],"configureLocales":[64],"setLocale":[64],"getLocale":[64],"getAvailableLocales":[64],"getAvailableLocaleOptions":[64],"t":[64],"getResolvedTerms":[64]},[[1,"wheel","handleWheel"],[0,"pointerdown","handlePointerDown"],[0,"pointermove","handlePointerMove"],[0,"pointerup","handlePointerUp"],[0,"pointercancel","handlePointerCancel"],[1,"pointerleave","handlePointerLeave"],[1,"longpress","handleLongPress"],[0,"contextmenu","handleContextMenu"],[9,"resize","handleResize"],[8,"keydown","handleKeyDown"],[8,"keyup","handleKeyUp"],[8,"copy","handleCopy"],[8,"cut","handleCut"],[8,"paste","handlePaste"],[4,"dblclick","preventDoubleTapZoomOnTouchDevices"]],{"workspaces":[{"onWorkspacesPropChange":0}],"activeWorkspaceId":[{"onActiveWorkspaceIdChange":0}],"syncConfig":[{"onSyncConfigChange":0}],"assetStorageConfig":[{"onAssetStorageConfigChange":0}],"user":[{"onUserChange":0}],"globalContextMenuItems":[{"onGlobalContextMenuItemsChange":0}],"objectContextMenuItems":[{"onObjectContextMenuItemsChange":0}],"scaleMax":[{"validateScaleMax":0}],"scaleMin":[{"validateScaleMin":0}],"cursorTarget":[{"onCursorTargetChange":0}],"lockDrawingScale":[{"onLockDrawingScaleChange":0}],"theme":[{"onThemeChange":0}],"licenseKey":[{"onLicenseKeyChange":0}],"themes":[{"onThemesChange":0}],"locale":[{"onLocaleChange":0}],"locales":[{"onLocalesChange":0}],"fallbackLocale":[{"onFallbackLocaleChange":0}],"viewportBoundaryLeft":[{"onViewportBoundaryLeftChange":0}],"viewportBoundaryRight":[{"onViewportBoundaryRightChange":0}],"viewportBoundaryTop":[{"onViewportBoundaryTopChange":0}],"viewportBoundaryBottom":[{"onViewportBoundaryBottomChange":0}],"debugInfo":[{"onDebugInfoChange":0}]}],[513,"kritzel-awareness-cursors",{"core":[16],"showEdgeIndicators":[4,"show-edge-indicators"],"edgeIndicatorPadding":[2,"edge-indicator-padding"],"remoteCursors":[32],"objectVersion":[32]}],[513,"kritzel-cursor-trail",{"core":[16],"cursorTrailPoints":[32],"isLeftButtonDown":[32]},[[9,"pointerdown","handleMouseDown"],[9,"pointermove","handlePointerMove"],[9,"pointerup","handlePointerUp"]]],[513,"kritzel-icon",{"name":[1],"label":[1],"size":[2]}],[513,"kritzel-watermark",{"core":[16],"label":[1]}]]]], options);
+});

package/dist/types/classes/core/core.class.d.ts

@@ -0,0 +1,532 @@
+import { KritzelEngine } from '../../components/kritzel-engine/kritzel-engine';
+import { KritzelAlignment } from '../../enums/alignment.enum';
+import { KritzelBaseObject } from '../objects/base-object.class';
+import { KritzelSelectionGroup } from '../objects/selection-group.class';
+import { KritzelToolRegistry } from '../registries/tool.registry';
+import { KritzelStore } from './store.class';
+import { KritzelWorkspace } from './workspace.class';
+import { KritzelSyncConfig } from '../../interfaces/sync-config.interface';
+import { KritzelAssetStorageConfig } from '../../interfaces/asset-storage-config.interface';
+import { KritzelAssetResolver } from '../providers/assets/asset-resolver.class';
+import { KritzelAppStateMap } from '../structures/app-state-map.structure';
+import { KritzelAnchorManager } from '../managers/anchor.manager';
+import { KritzelCursorManager } from '../managers/cursor.manager';
+import { KritzelThemeManager } from '../managers/theme.manager';
+import { KritzelLocalizationManager } from '../managers/localization.manager';
+import { KritzelLicenseManager } from '../managers/license.manager';
+import { KritzelBrowserPermissionManager } from '../managers/browser-permission.manager';
+import { KritzelClipboardManager } from '../managers/clipboard.manager';
+import { IKritzelUser } from '../../interfaces/user.interface';
+interface InitializeWorkspaceOptions {
+    /**
+     * When true, no fallback workspace will be created if there is no provided workspace,
+     * no last active workspace, and no recent workspace.
+     */
+    skipFallbackCreation?: boolean;
+}
+/** Objects affected by reconciling a workspace's declared object set. */
+export interface KritzelWorkspaceObjectsDiff {
+    added: KritzelBaseObject<any>[];
+    updated: KritzelBaseObject<any>[];
+    removed: KritzelBaseObject<any>[];
+}
+/**
+ * Central orchestrator class for the Kritzel canvas system.
+ * Manages workspaces, objects, selection, clipboard operations, and coordinates
+ * between the engine, store, and various managers.
+ */
+export declare class KritzelCore {
+    /** The underlying Kritzel engine component */
+    private readonly _kritzelEngine;
+    /** State management store */
+    private readonly _store;
+    /** Optional sync configuration for collaborative features */
+    private _syncConfig?;
+    /** Optional asset storage configuration for image / binary payloads */
+    private _assetStorageConfig?;
+    /** Resolves and stores binary assets referenced by canvas objects */
+    private readonly _assetResolver;
+    /** App state map for persistent workspace storage */
+    private readonly _appStateMap;
+    /** Manager for line anchor points and connections */
+    private readonly _anchorManager;
+    /** Manager for cursor states and appearance */
+    private readonly _cursorManager;
+    /** Manager for theme styling */
+    private readonly _themeManager;
+    /** Manager for localization / translated UI strings */
+    private readonly _localizationManager;
+    /** Manager for license validation and watermark gating */
+    private readonly _licenseManager;
+    /** Manager for browser permission checks and permission prompts */
+    private readonly _permissionManager;
+    /** Manager for clipboard copy/cut/paste orchestration */
+    private readonly _clipboardManager;
+    /** Per-core registry of drawing tools (one instance per editor). */
+    private readonly _toolRegistry;
+    /** Optional unique identifier for namespacing storage keys across multiple editor instances */
+    private _editorId?;
+    /** Current user for awareness broadcasting */
+    private _user?;
+    /**
+     * Gets the Kritzel engine instance.
+     * @returns The KritzelEngine managing rendering and events
+     */
+    get engine(): KritzelEngine;
+    /**
+     * Gets the state store instance.
+     * @returns The KritzelStore managing application state
+     */
+    get store(): KritzelStore;
+    /**
+     * Gets the app state map for workspace persistence.
+     * @returns The KritzelAppStateMap for storing workspace data
+     */
+    get appStateMap(): KritzelAppStateMap;
+    /**
+     * Gets the anchor manager for line connections.
+     * @returns The KritzelAnchorManager for managing line anchors
+     */
+    get anchorManager(): KritzelAnchorManager;
+    /**
+     * Gets the cursor manager.
+     * @returns The KritzelCursorManager for managing cursor states
+     */
+    get cursorManager(): KritzelCursorManager;
+    /**
+     * Gets the theme manager.
+     * @returns The KritzelThemeManager for managing visual themes
+     */
+    get themeManager(): KritzelThemeManager;
+    /**
+     * Gets the localization manager.
+     * @returns The KritzelLocalizationManager for resolving translated UI strings
+     */
+    get localizationManager(): KritzelLocalizationManager;
+    /**
+     * Gets the license manager.
+     * @returns The KritzelLicenseManager for validating licenses and gating the watermark
+     */
+    get licenseManager(): KritzelLicenseManager;
+    /**
+     * Gets the browser permission manager.
+     * @returns The KritzelBrowserPermissionManager for browser permission checks and requests
+     */
+    get permissionManager(): KritzelBrowserPermissionManager;
+    /**
+     * Gets the tool registry scoped to this core instance.
+     * @returns The KritzelToolRegistry owned by this core
+     */
+    get toolRegistry(): KritzelToolRegistry;
+    /**
+     * Gets the clipboard manager scoped to this core instance.
+     * @returns The KritzelClipboardManager owned by this core
+     */
+    get clipboardManager(): KritzelClipboardManager;
+    /**
+     * Gets the editor ID used for namespacing storage keys.
+     * @returns The editor ID or undefined if not set
+     */
+    get editorId(): string | undefined;
+    /**
+     * Builds a namespaced storage key.
+     * When editorId is set, appends it after the base prefix:
+     * e.g. 'kritzel-settings' → 'kritzel-settings-homepage'
+     * @param base - The base key name (e.g. 'kritzel-settings')
+     * @returns The namespaced key
+     */
+    getStorageKey(base: string): string;
+    /**
+     * Gets the current user.
+     */
+    get user(): IKritzelUser | undefined;
+    /**
+     * Sets the current user and propagates to the active object map's awareness.
+     */
+    setUser(user?: IKritzelUser): void;
+    /**
+     * Creates a new KritzelCore instance.
+     * Initializes the store with default configuration and sets up all managers.
+     * @param kritzelEngine - The KritzelEngine component to orchestrate
+     * @param editorId - Optional unique identifier for namespacing storage keys
+     */
+    constructor(kritzelEngine: KritzelEngine, editorId?: string);
+    /**
+     * Gets the asset resolver responsible for storing and resolving
+     * binary payloads (images, etc.) referenced by canvas objects.
+     */
+    get assetResolver(): KritzelAssetResolver;
+    /**
+     * Sets the synchronization configuration for collaborative features.
+     * @param config - The sync configuration or undefined to disable sync
+     */
+    setSyncConfig(config?: KritzelSyncConfig): void;
+    /**
+     * Sets the asset storage configuration used for image / binary payloads.
+     * Takes effect on the next `initializeYjs` call (or on explicit
+     * `initializeAssets` if invoked directly).
+     */
+    setAssetStorageConfig(config?: KritzelAssetStorageConfig): void;
+    /**
+     * Sets the editor ID for namespacing storage keys.
+     * Must be called before any storage initialization (e.g., in componentWillLoad).
+     * Re-initializes the theme manager to pick up the new storage key.
+     * @param editorId - The unique identifier for this editor instance
+     */
+    setEditorId(editorId?: string): void;
+    /**
+     * Initializes the Yjs document for collaborative editing.
+     * Sets up the app state map with the current sync configuration.
+     *
+     * Asset storage is initialized separately via {@link initializeAssetStorage}
+     * so that it can be deferred until the `assetStorageConfig` prop arrives,
+     * mirroring the lazy-init pattern used for sync config.
+     */
+    initializeYjs(): Promise<void>;
+    /**
+     * Initializes the asset storage layer with the current asset storage
+     * configuration. Safe to call multiple times: subsequent calls are
+     * no-ops because {@link KritzelAssetResolver.init} is idempotent.
+     * To apply a new configuration after initialization, destroy the
+     * resolver first or use {@link KritzelEngine.reinitSync}.
+     */
+    initializeAssetStorage(): Promise<void>;
+    /**
+     * Emits a single warning when the sync config declares at least one
+     * network provider but the asset storage config has none. In that
+     * scenario images added on this device will not be available to
+     * other devices, yielding a broken cross-device experience.
+     */
+    private warnIfAssetStorageMismatched;
+    /**
+     * Load all workspaces from app state map
+     */
+    private loadWorkspacesFromAppState;
+    /**
+     * Save a workspace to app state map
+     */
+    private saveWorkspaceToAppState;
+    /**
+     * Delete a workspace from app state map
+     */
+    private deleteWorkspaceFromAppState;
+    /**
+     * Initializes or switches to a workspace.
+     * Handles workspace loading from app state, localStorage preferences,
+     * viewport state restoration, and ObjectMap initialization.
+     * @param workspace - Optional workspace to switch to; if not provided, uses last active or most recent
+      * @param options - Optional initialization behavior flags
+     */
+    initializeWorkspace(workspace?: KritzelWorkspace, options?: InitializeWorkspaceOptions): Promise<void>;
+    private seedWorkspaceObjects;
+    /**
+     * Mirrors engine.addObject() runtime initialization for consumer-constructed objects.
+     */
+    private prepareObjectForWorkspace;
+    /**
+     * Applies `desiredObjects` as the complete object set of an object map.
+     * Objects are matched by ID: unknown IDs are added, known IDs are updated (replacing the live
+     * instance when a different one is passed), and objects absent from the list are removed.
+     * @param objectsMap - The map to reconcile
+     * @param workspaceId - The workspace the objects belong to
+     * @param desiredObjects - The desired object set
+     * @param nextZIndex - Supplies the z-index for newly added objects
+     * @param scaleFallback - Scale applied to objects that do not define one
+     * @returns The objects that were added, updated and removed
+     */
+    private reconcileWorkspaceObjects;
+    /**
+     * Releases runtime resources held by an object that is about to leave the canvas.
+     * Unlike removeObject() this never cascades into group children, so the reconciled
+     * object set stays exactly what the caller declared.
+     */
+    private detachObject;
+    /**
+     * Returns the next free z-index within an object map.
+     */
+    private nextZIndexOf;
+    /**
+     * Loads a shared workspace by token.
+     * If the workspace exists locally, it switches to it.
+     * If it doesn't exist, it adds it to the local workspaces list and then switches to it.
+     * @param token - The connection token identifying the shared workspace
+     */
+    loadSharedWorkspace(token: string): Promise<void>;
+    /**
+     * Gets all objects currently visible within the viewport bounds.
+     * Excludes selection-related objects and sorts by z-index.
+     * @returns Array of visible objects sorted by z-index ascending
+     */
+    getObjectsInViewport(): KritzelBaseObject<any>[];
+    /**
+     * Forces a rerender of the engine component.
+     * Increments forceUpdate counter to trigger Stencil's reactivity.
+     */
+    rerender(): void;
+    /**
+     * Finds an object in the store by its unique identifier.
+     * @param id - The unique ID of the object to find
+     * @returns The found object or null if not found
+     */
+    findObjectById(id: string): KritzelBaseObject<any> | null;
+    /**
+     * Gets all workspaces from the app state map.
+     * @returns Array of all available workspaces
+     */
+    getWorkspaces(): KritzelWorkspace[];
+    /**
+     * Switches the active workspace in the editor by ID.
+     * @param workspaceId - The unique ID of the workspace to activate
+     */
+    setActiveWorkspace(workspaceId: string): Promise<void>;
+    /**
+     * Creates a new workspace and saves it to the app state.
+     * @param workspace - The workspace instance to create
+     * @returns The created workspace instance
+     */
+    createWorkspace(workspace: KritzelWorkspace): Promise<KritzelWorkspace>;
+    /**
+     * Applies a workspace as declared: metadata, viewport, and — when `workspace.objects` is set —
+     * the complete object set. A `undefined` object list leaves existing objects untouched, an empty
+     * list removes them all. Objects of non-active workspaces are written through a background
+     * object map and therefore require a configured sync provider.
+     * @param workspace - The workspace describing the desired state
+     * @returns The object changes that were applied, or null if objects were not touched
+     */
+    updateWorkspace(workspace: KritzelWorkspace): Promise<KritzelWorkspaceObjectsDiff | null>;
+    /**
+     * Moves the live viewport to the workspace's declared viewport.
+     * Compared against the persisted viewport rather than the live one, so a workspace that was
+     * read and passed back unchanged (e.g. a rename) never snaps the canvas.
+     */
+    private applyWorkspaceViewport;
+    private applyObjectsToActiveWorkspace;
+    /**
+     * Applies objects to a workspace that is not currently open by loading its document into a
+     * background object map, reconciling, and disposing it again.
+     */
+    private applyObjectsToInactiveWorkspace;
+    /**
+     * Deletes a workspace and its associated data.
+     * Handles cleanup of active workspace ObjectMap if deleting the current workspace.
+     * Also deletes the workspace's IndexedDB database.
+     * @param workspace - The workspace to delete
+     */
+    deleteWorkspace(workspace: KritzelWorkspace): void;
+    /**
+     * Persists the current viewport state to the active workspace.
+     * Converts screen-space translate values to device-independent world-space center coordinates.
+     * Validates that the workspace still exists before saving.
+     * @param translateX - The X translation of the viewport
+     * @param translateY - The Y translation of the viewport
+     * @param scale - The zoom scale of the viewport
+     */
+    updateWorkspaceViewport(translateX: number, translateY: number, scale: number): void;
+    /**
+     * Gets whether the active workspace is publicly accessible.
+     * @returns True if the workspace is public, false otherwise
+     */
+    getIsPublic(): boolean;
+    /**
+     * Adds an object to the current workspace's object map.
+     * @param object - The object to add to the canvas
+     */
+    addObject(object: KritzelBaseObject<any>): void;
+    /**
+     * Removes an object from the workspace.
+     * Handles recursive deletion of group children (unless preserved),
+     * cleans up line anchors, and removes from the object map.
+     * @param object - The object to remove
+     * @param preserveChildren - If true and object is a group, children are kept; defaults to false
+     */
+    removeObject(object: KritzelBaseObject<any>, preserveChildren?: boolean): void;
+    /**
+     * Updates properties on an object and persists the changes.
+     * Calls the object's onAfterUpdate hook with changed property keys.
+     * @typeParam T - The type of the object being updated
+     * @param object - The object to update
+     * @param updatedProperties - Partial object containing properties to update
+     */
+    updateObject<T extends KritzelBaseObject<any>>(object: T, updatedProperties: Partial<T>): void;
+    /**
+     * Adds a selection group to the canvas.
+     * Removes any existing selection group and selection box first.
+     * Triggers the selection change event.
+     * @param selectionGroup - The selection group to add
+     */
+    addSelectionGroup(selectionGroup: KritzelSelectionGroup): void;
+    /**
+     * Returns whether the provided selection group belongs to the local user context.
+     * Local groups are either explicitly owned by the current user or have no user ID.
+     */
+    private isLocalSelectionGroup;
+    /**
+     * Applies deselection teardown side effects to a selection group before removal.
+     */
+    private teardownSelectionGroup;
+    /**
+     * Removes all local selection groups from the store, including orphaned groups
+     * that are no longer referenced by store.selectionGroup.
+     * @returns True when at least one local selection group was removed
+     */
+    private removeLocalSelectionGroups;
+    /**
+     * Removes the current selection group from the canvas.
+     * Clears the cached reference and triggers the selection change event.
+     */
+    removeSelectionGroup(): void;
+    /**
+     * Removes the current selection box from the canvas.
+     * Clears the cached reference.
+     */
+    removeSelectionBox(): void;
+    /**
+     * Deselects all objects by removing the selection group.
+     * Triggers a rerender.
+     */
+    deselectAllObjects(): void;
+    /**
+     * Deletes all objects in the current selection group.
+     * Removes the selection group and emits viewport change event.
+     */
+    delete(): void;
+    /**
+     * Undoes the last action in the history stack.
+     */
+    undo(): void;
+    /**
+     * Redoes the last undone action from the history stack.
+     */
+    redo(): void;
+    /**
+     * Deletes a specific object by its ID.
+     * Emits viewport change event and triggers rerender.
+     * @param id - The unique ID of the object to delete
+     */
+    deleteObject(id: string): void;
+    /**
+     * Moves objects one step forward in the z-order stack.
+     * @param object - Optional specific object to move; defaults to all selected objects
+     */
+    bringForward(object?: KritzelBaseObject<any>): void;
+    /**
+     * Moves objects one step backward in the z-order stack.
+     * @param object - Optional specific object to move; defaults to all selected objects
+     */
+    sendBackward(object?: KritzelBaseObject<any>): void;
+    /**
+     * Moves objects to the very front of the z-order stack.
+     * @param object - Optional specific object to move; defaults to all selected objects
+     */
+    bringToFront(object?: KritzelBaseObject<any>): void;
+    /**
+     * Moves objects to the very back of the z-order stack.
+     * @param object - Optional specific object to move; defaults to all selected objects
+     */
+    sendToBack(object?: KritzelBaseObject<any>): void;
+    /**
+     * Aligns objects within the current selection group based on the specified alignment type.
+     * Requires at least 2 objects to be selected.
+     * @param alignment The alignment type to apply
+     */
+    alignObjects(alignment: KritzelAlignment): void;
+    /**
+     * Groups the currently selected objects into a KritzelGroup.
+     * Requires at least 2 objects to be selected.
+     */
+    group(): void;
+    /**
+     * Ungroups any KritzelGroup objects in the current selection.
+     * Children are extracted and become top-level objects.
+     */
+    ungroup(): void;
+    /**
+     * Creates a selection from the given objects.
+     * Clears existing selection, creates a selection group, and marks objects as selected.
+     * @param objects - Array of objects to select; no-op if empty
+     */
+    selectObjects(objects: KritzelBaseObject<any>[]): void;
+    /**
+     * Selects all objects in the workspace.
+     * Excludes selection-related objects.
+     * Switches to selection tool.
+     */
+    selectAllObjects(): void;
+    /**
+     * Selects all objects currently visible in the viewport.
+     * Excludes selection-related objects.
+     * Switches to selection tool.
+     */
+    selectAllObjectsInViewport(): void;
+    /**
+     * Clears all selection state.
+     * Removes selection group and box, resets selection-related flags.
+     */
+    clearSelection(): void;
+    /**
+     * Resets the active text object.
+     * Deletes empty text objects or saves non-empty ones.
+     */
+    resetActiveText(): void;
+    /**
+     * Resets the active shape object by saving it.
+     */
+    resetActiveShape(): void;
+    /**
+     * Gets the topmost object at a pointer event location that matches a selector.
+     * Performs hit testing to verify the object is actually under the pointer.
+     * @param event - The pointer event with client coordinates
+     * @param selector - CSS selector to match elements; defaults to '.object'
+     * @returns The matched object or null if none found or hit test fails
+     */
+    getObjectFromPointerEvent(event: PointerEvent, selector?: string): KritzelBaseObject<any> | null;
+    /**
+     * Gets all objects at a pointer event location that match a selector.
+     * Returns objects sorted by z-index (highest first) for proper layering.
+     * @param event - The pointer event with client coordinates
+     * @param selector - CSS selector to match elements; defaults to '.object'
+     * @returns Array of matched objects sorted by z-index descending
+     */
+    getObjectsFromPointerEvent(event: PointerEvent, selector?: string): KritzelBaseObject<any>[];
+    /**
+     * Get all elements at a pointer position that match a given selector.
+     * Uses elementsFromPoint to find overlapped elements.
+     */
+    getElementsAtPoint(event: PointerEvent, selector: string): Element[];
+    /**
+     * Check if any element at the pointer position matches the given selector.
+     * Useful for detecting hover states on overlapped elements.
+     */
+    isPointerOverElement(event: PointerEvent, selector: string): boolean;
+    /**
+     * Converts a pointer event to canvas (world) coordinates.
+     * Accounts for host element offset and viewport transform.
+     * @param event - The pointer event with client coordinates
+     * @returns Object with x and y in canvas coordinates
+     */
+    getCanvasPoint(event: PointerEvent): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Prepares the engine for a workspace change.
+     * Cancels pending viewport updates, saves current viewport state,
+     * resets active text, clears selection, and switches to selection tool.
+     */
+    beforeWorkspaceChange(): void;
+    /**
+     * Determines whether to display the selection group UI for an object.
+     * Hides UI for single KritzelLine selections (they have their own UI).
+     * @param object - The object to check
+     * @returns True if selection group UI should be displayed
+     */
+    displaySelectionGroupUI(object: KritzelBaseObject<any>): boolean;
+    /**
+     * Determines whether to display the line-specific selection UI for an object.
+     * Shows line UI only for single KritzelLine selections.
+     * @param object - The object to check
+     * @returns True if line selection UI should be displayed
+     */
+    displaySelectionLineUI(object: KritzelBaseObject<any>): boolean;
+}
+export {};

package/dist/types/classes/core/reviver.class.d.ts

@@ -0,0 +1,32 @@
+import type { KritzelCore } from "./core.class";
+/**
+ * Handles deserialization/revival of Kritzel objects from plain JavaScript objects.
+ * This class uses a pattern similar to JSON.parse reviver to reconstruct class instances
+ * from their serialized representations, preserving the object's prototype chain and methods.
+ */
+export declare class KritzelReviver {
+    /** Reference to the KritzelCore instance for creating objects */
+    private readonly _core;
+    /**
+     * Creates a new KritzelReviver instance.
+     * @param core - The KritzelCore instance used to create revived objects
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Recursively revives a plain JavaScript object (or array) into typed Kritzel instances.
+     * Uses the `__class__` property to determine the correct class to instantiate.
+     * Objects without `__class__` are recursively processed to revive nested objects.
+     *
+     * Supported classes:
+     * - Objects: KritzelPath, KritzelLine, KritzelText, KritzelShape, KritzelImage,
+     *            KritzelDynamicObject, KritzelSelectionGroup, KritzelGroup
+     * - Workspace: KritzelWorkspace
+     * - Tools: KritzelBrushTool, KritzelEraserTool, KritzelImageTool, KritzelSelectionTool,
+     *          KritzelTextTool, KritzelLineTool, KritzelShapeTool
+     *
+     * @typeParam T - The expected return type after revival
+     * @param obj - The plain object to revive, typically from JSON deserialization
+     * @returns The revived object with proper class instances, or the original value if not an object
+     */
+    revive<T>(obj: any): T;
+}