@kritzel/engine 0.4.31

package/dist/types/interfaces/point.interface.d.ts

@@ -0,0 +1,4 @@
+export interface KritzelPoint {
+    x: number;
+    y: number;
+}

package/dist/types/interfaces/polygon.interface.d.ts

@@ -0,0 +1,7 @@
+import { KritzelPoint } from "./point.interface";
+export interface KritzelPolygon {
+    bottomLeft: KritzelPoint;
+    bottomRight: KritzelPoint;
+    topLeft: KritzelPoint;
+    topRight: KritzelPoint;
+}

package/dist/types/interfaces/remote-cursor.interface.d.ts

@@ -0,0 +1,18 @@
+import { IKritzelUser } from './user.interface';
+export interface KritzelRemoteCursorState {
+    clientId: number;
+    user: IKritzelUser;
+    cursor: {
+        x: number;
+        y: number;
+    } | null;
+    activeObjectId: string | null;
+    selectionBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    lastUpdated: number;
+    lastCursorMove: number;
+}

package/dist/types/interfaces/selection-state.interface.d.ts

@@ -0,0 +1,7 @@
+export interface KritzelSelectionState {
+    isSelecting: boolean;
+    isResizing: boolean;
+    isRotating: boolean;
+    isDragging: boolean;
+    isCtrlKeyPressed: boolean;
+}

package/dist/types/interfaces/serializable.interface.d.ts

@@ -0,0 +1,5 @@
+export interface KritzelSerializable {
+    __class__: string;
+    serialize(): any;
+    deserialize(object: any): KritzelSerializable;
+}

package/dist/types/interfaces/settings.interface.d.ts

@@ -0,0 +1,25 @@
+import { KritzelDebugInfo } from './debug-info.interface';
+import { ThemeName } from './theme.interface';
+import { LocaleCode } from './localization.interface';
+export interface KritzelSettingsConfig {
+    /** Minimum zoom level allowed (0.0001 to 1) */
+    scaleMin: number;
+    /** Maximum zoom level allowed (1 to 1000) */
+    scaleMax: number;
+    /** When true, objects are drawn at a fixed visual size regardless of zoom level */
+    lockDrawingScale: boolean;
+    /** The current theme name */
+    theme: ThemeName;
+    /** The current locale (language) code */
+    locale: LocaleCode;
+    /** Left boundary of the viewport in world coordinates */
+    viewportBoundaryLeft: number;
+    /** Right boundary of the viewport in world coordinates */
+    viewportBoundaryRight: number;
+    /** Top boundary of the viewport in world coordinates */
+    viewportBoundaryTop: number;
+    /** Bottom boundary of the viewport in world coordinates */
+    viewportBoundaryBottom: number;
+    /** Debug info display options */
+    debugInfo: KritzelDebugInfo;
+}

package/dist/types/interfaces/share.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Event payload emitted when the public sharing state changes.
+ */
+export interface IKritzelIsPublicChangeEvent {
+    /** ID of the workspace whose sharing state changed */
+    workspaceId: string;
+    /** Whether the workspace is now publicly accessible */
+    isPublic: boolean;
+}

package/dist/types/interfaces/shortcut.interface.d.ts

@@ -0,0 +1,10 @@
+import { KritzelCore } from '..';
+export interface KritzelShortcut {
+    key: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    label: string;
+    category: string;
+    condition?: (core: KritzelCore) => boolean;
+    action: (core: KritzelCore) => void;
+}

package/dist/types/interfaces/sync-config.interface.d.ts

@@ -0,0 +1,41 @@
+import { ProviderConfig } from './sync-provider.interface';
+/**
+ * Configuration for workspace synchronization providers
+ */
+export interface KritzelSyncConfig {
+    /**
+     * Array of provider configurations to enable for synchronization.
+     * Can include provider classes directly or factory functions with options.
+     *
+     * @example
+     * // Simple providers
+     * providers: [IndexedDBSyncProvider, BroadcastSyncProvider]
+     *
+     * @example
+     * // Provider with options using factory
+     * providers: [
+     *   IndexedDBSyncProvider,
+     *   WebSocketSyncProvider.with({ url: 'wss://example.com' })
+     * ]
+     */
+    providers: ProviderConfig[];
+    /**
+     * Optional shared identifier for the app-state Y.Doc.
+     * When provided, this value is used directly as the app-state document identity
+     * instead of a browser-local persisted instance id. This enables cross-device
+     * synchronization (e.g. via Hocuspocus) where multiple devices must connect
+     * to the same app-state document.
+     *
+     * Derive this from a stable shared identity in your application, such as a
+     * user id, account id, or tenant id.
+     *
+     * When omitted, a locally generated and persisted instance id is used instead,
+     * which is stable across reloads on the same browser but not shared across devices.
+     */
+    appStateId?: string;
+}
+/**
+ * Returns `true` when the given sync configuration contains at least one remote
+ * (network) provider, meaning the share option should be available in the UI.
+ */
+export declare function hasRemoteSyncProvider(syncConfig?: KritzelSyncConfig): boolean;

package/dist/types/interfaces/sync-provider.interface.d.ts

@@ -0,0 +1,66 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+/**
+ * Distinguishes local-only providers (IndexedDB, BroadcastChannel) from
+ * network providers (WebSocket, Hocuspocus) that require a server connection.
+ */
+export type SyncProviderType = 'local' | 'network';
+/**
+ * Interface for sync providers that handle data synchronization across different mediums
+ * (IndexedDB, BroadcastChannel, WebSocket, etc.)
+ */
+export interface ISyncProvider {
+    /**
+     * Whether this provider operates locally or over the network.
+     * Local providers resolve quickly and are awaited during initialization.
+     * Network providers connect in the background so they don't block the editor.
+     */
+    readonly type: SyncProviderType;
+    /**
+     * The Yjs Awareness instance for this provider, if supported.
+     * Network providers (WebSocket, Hocuspocus) return an Awareness instance;
+     * local-only providers (IndexedDB, BroadcastChannel) return null or undefined.
+     */
+    readonly awareness?: Awareness | null;
+    /**
+     * The underlying third-party provider instance (e.g. `WebsocketProvider`, `HocuspocusProvider`)
+     * used as the Yjs transaction origin for updates it applies. Exposed so callers can
+     * distinguish genuine remote-origin transactions from local-only providers (IndexedDB,
+     * BroadcastChannel), which don't tag their transactions with a recognizable origin.
+     */
+    readonly rawProvider?: unknown;
+    /**
+     * Initialize and connect the provider
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the provider (can be reconnected later)
+     */
+    disconnect(): void;
+    /**
+     * Disconnect and reconnect the provider.
+     * Useful for recovering from stale connections after network changes or tab visibility restore.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Destroy the provider and clean up all resources
+     */
+    destroy(): void;
+}
+/**
+ * Factory function type for creating provider instances
+ */
+export interface ProviderFactory {
+    /**
+     * Whether this factory creates local or network providers.
+     * Used to determine UI capabilities such as the share option.
+     */
+    readonly type?: SyncProviderType;
+    create(docName: string, doc: Y.Doc, options?: {
+        quiet?: boolean;
+    }): ISyncProvider;
+}
+/**
+ * Type for provider configuration - either a class constructor or a factory
+ */
+export type ProviderConfig = (new (docName: string, doc: Y.Doc, options?: any) => ISyncProvider) | ProviderFactory;