@kritzel/engine 0.4.31

package/dist/types/configs/default-asset-storage.config.d.ts

@@ -0,0 +1,8 @@
+import { KritzelAssetStorageConfig } from '../interfaces/asset-storage-config.interface';
+/**
+ * Default asset storage configuration. Stores bytes in IndexedDB only,
+ * which provides offline-friendly behavior out of the box. Applications
+ * that sync Yjs over the network should also configure a remote provider
+ * (e.g. HttpAssetProvider) so images are available across devices.
+ */
+export declare const DEFAULT_ASSET_STORAGE_CONFIG: KritzelAssetStorageConfig;

package/dist/types/configs/default-brush-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelBrushToolConfig } from '../interfaces/toolbar-item.interface';
+export declare const DEFAULT_BRUSH_CONFIG: KritzelBrushToolConfig;

package/dist/types/configs/default-engine-config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelEngineState } from "../interfaces/engine-state.interface";
+export declare const DEFAULT_ENGINE_CONFIG: KritzelEngineState;

package/dist/types/configs/default-line-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelLineToolConfig } from '../interfaces/toolbar-item.interface';
+export declare const DEFAULT_LINE_TOOL_CONFIG: KritzelLineToolConfig;

package/dist/types/configs/default-shape-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelShapeToolConfig } from "../interfaces/toolbar-item.interface";
+export declare const DEFAULT_SHAPE_CONFIG: KritzelShapeToolConfig;

package/dist/types/configs/default-sync.config.d.ts

@@ -0,0 +1,5 @@
+import { KritzelSyncConfig } from '../interfaces/sync-config.interface';
+/**
+ * Default sync configuration - None
+ */
+export declare const DEFAULT_SYNC_CONFIG: KritzelSyncConfig;

package/dist/types/configs/default-text-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelTextToolConfig } from "../interfaces/toolbar-item.interface";
+export declare const DEFAULT_TEXT_CONFIG: KritzelTextToolConfig;

package/dist/types/constants/color-palette.constants.d.ts

@@ -0,0 +1,31 @@
+import { ThemeName } from '../interfaces/theme.interface';
+/**
+ * Supported theme modes for color variations
+ */
+/**
+ * Color definition with different values per theme
+ */
+export interface ThemeAwareColor {
+    /** Color value for light theme */
+    light: string;
+    /** Color value for dark theme */
+    dark: string;
+    /** Custom colors based on new themes */
+    [key: string]: string | undefined;
+    /** Optional semantic label for the color */
+    label?: string;
+}
+/**
+ * Type for a color palette with theme-aware colors only
+ */
+export type ColorPalette = readonly ThemeAwareColor[];
+/**
+ * Helper function to resolve a color value for a specific theme
+ */
+export declare function resolveColor(color: ThemeAwareColor, theme: ThemeName): string;
+/**
+ * Default color palette shared across all tool configurations.
+ * This ensures consistency in color options throughout the application.
+ * All colors support theme-specific variations.
+ */
+export declare const DEFAULT_COLOR_PALETTE: ColorPalette;

package/dist/types/constants/engine.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ABSOLUTE_SCALE_MAX = 1000;
+export declare const ABSOLUTE_SCALE_MIN = 0.0001;
+/** Destination opened when the "Powered by Kritzel" watermark is clicked. */
+export declare const KRITZEL_WEBSITE_URL = "https://kritzel.io";

package/dist/types/constants/license.constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * License verification constants.
+ *
+ * Kritzel licenses are offline Ed25519 signed tokens. The owner signs each
+ * customer's token with a private key that never leaves their machine
+ * (see scripts/license/); the library verifies tokens against the public key
+ * below. The public key is safe to ship — it can only *verify* signatures,
+ * never forge them.
+ */
+/**
+ * Token format version prefix. A valid license key looks like:
+ *
+ *   KRTZL1.<base64url(payload JSON)>.<base64url(ed25519 signature)>
+ *
+ * Bump the version (and this prefix) if the token scheme ever changes.
+ */
+export declare const KRITZEL_LICENSE_TOKEN_PREFIX = "KRTZL1.";
+/**
+ * Raw 32-byte Ed25519 public key (base64url) used to verify license tokens.
+ *
+ * Generate the matching key pair with `npm run license:keygen` and paste the
+ * printed public key here. Replacing this value invalidates every license
+ * signed with the previous key.
+ */
+export declare const KRITZEL_LICENSE_PUBLIC_KEY = "2IwZDin-qV3kOt8SEQCqdaJsGT9S7tAGapUYJVnVGQo";

package/dist/types/constants/schema.constants.d.ts

@@ -0,0 +1,4 @@
+/** Current schema version for the app-state Y.Doc (workspace list & settings). */
+export declare const CURRENT_APP_STATE_SCHEMA_VERSION = 2;
+/** Current schema version for workspace Y.Docs (drawable objects). */
+export declare const CURRENT_WORKSPACE_SCHEMA_VERSION = 3;

package/dist/types/constants/storage.constants.d.ts

@@ -0,0 +1 @@
+export declare const APP_STATE_INSTANCE_ID_STORAGE_KEY = "kritzel-app-state-instance-id";

package/dist/types/constants/stroke-size.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_STROKE_SIZES: number[];
+export declare const DEFAULT_FONT_SIZES: number[];

package/dist/types/constants/text-tool-fonts.constants.d.ts

@@ -0,0 +1,3 @@
+import { KritzelFontRegistration } from '../interfaces/font.interface';
+export declare const DEFAULT_TEXT_TOOL_AVAILABLE_FONTS: KritzelFontRegistration[];
+export declare const resolveTextToolAvailableFonts: (availableFonts?: KritzelFontRegistration[]) => KritzelFontRegistration[];

package/dist/types/constants/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The current version of the Kritzel library.
+ * This file is auto-generated by the version bump scripts.
+ * Do not modify manually.
+ */
+export declare const KRITZEL_VERSION = "0.4.31";

package/dist/types/enums/alignment.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum KritzelAlignment {
+    StartHorizontal = "start-horizontal",
+    CenterHorizontal = "center-horizontal",
+    EndHorizontal = "end-horizontal",
+    StartVertical = "start-vertical",
+    CenterVertical = "center-vertical",
+    EndVertical = "end-vertical"
+}

package/dist/types/enums/event-button.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum KritzelMouseButton {
+    Left = 0,
+    Middle = 1,
+    Right = 2
+}

package/dist/types/enums/handle-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum KritzelHandleType {
+    TopLeft = "top-left",
+    TopRight = "top-right",
+    BottomLeft = "bottom-left",
+    BottomRight = "bottom-right"
+}

package/dist/types/enums/shape-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ShapeType {
+    Rectangle = "rectangle",
+    Ellipse = "ellipse",
+    Triangle = "triangle"
+}

package/dist/types/events/active-workspace-change.event.d.ts

@@ -0,0 +1,7 @@
+export interface ActiveWorkspaceChangeEvent {
+    id: string;
+    name: string;
+    isPublic: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/types/events/editor-is-ready.event.d.ts

@@ -0,0 +1,18 @@
+import { KritzelAssetStorageConfig } from '../interfaces/asset-storage-config.interface';
+import { KritzelLoginConfig } from '../interfaces/login-config.interface';
+import { KritzelSyncConfig } from '../interfaces/sync-config.interface';
+import { ThemeName } from '../interfaces/theme.interface';
+export interface EditorIsReadyEvent {
+    host: HTMLElement;
+    activeWorkspace: {
+        id: string;
+        name: string;
+        isPublic: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    syncConfig: KritzelSyncConfig;
+    assetStorageConfig?: KritzelAssetStorageConfig;
+    loginConfig: KritzelLoginConfig;
+    theme: ThemeName;
+}

package/dist/types/events/login.event.d.ts

@@ -0,0 +1,3 @@
+export interface LoginEvent {
+    provider: string;
+}

package/dist/types/helpers/alignment.helper.d.ts

@@ -0,0 +1,21 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+import { KritzelAlignment } from '../enums/alignment.enum';
+/**
+ * Helper class for aligning objects within a selection group.
+ */
+export declare class AlignmentHelper {
+    /**
+     * Calculates the selection bounds from all objects' rotated bounding boxes.
+     */
+    private static calculateSelectionBounds;
+    /**
+     * Calculates the new translate positions for each object based on the alignment type.
+     * @param objects The objects to align
+     * @param alignment The alignment type
+     * @returns A map of object IDs to their new translateX and translateY values
+     */
+    static calculateAlignedPositions(objects: KritzelBaseObject[], alignment: KritzelAlignment): Map<string, {
+        translateX: number;
+        translateY: number;
+    }>;
+}

package/dist/types/helpers/class.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class KritzelClassHelper {
+    static isInstanceOf<T>(object: any, className: string): object is T;
+}

package/dist/types/helpers/color.helper.d.ts

@@ -0,0 +1,34 @@
+import { ThemeAwareColor } from '../constants/color-palette.constants';
+import { ThemeName } from '../interfaces/theme.interface';
+export declare class KritzelColorHelper {
+    /**
+     * Resolves a color value based on the current theme.
+     * Handles both simple string colors and theme-aware color objects.
+     * @param color - The color to resolve (string or ThemeAwareColor)
+     * @param theme - Optional theme to use. If not provided, uses current theme from ThemeManager
+     * @returns The resolved hex color string, or empty string if color is undefined
+     */
+    static resolveThemeColor(color: ThemeAwareColor | undefined, theme?: ThemeName): string;
+    /**
+     * Applies opacity to a theme-aware color and returns an rgba string.
+     * @param color - The theme-aware color object or a hex color string
+     * @param opacity - The opacity value between 0 and 1
+     * @param theme - Optional theme to use. If not provided, uses current theme from ThemeManager
+     * @returns The color as an rgba string, or the resolved hex if opacity is 1
+     */
+    static applyOpacity(color: ThemeAwareColor | string | undefined, opacity: number, theme?: ThemeName): string;
+    /**
+     * Determines the appropriate contrast color (black or white) based on the luminance of the given hex color.
+     * Uses the relative luminance formula: 0.299*R + 0.587*G + 0.114*B
+     * @param hexColor - The hex color string (with or without #)
+     * @returns '#000000' for light backgrounds, '#ffffff' for dark backgrounds
+     */
+    static getContrastColor(hexColor: string): string;
+    /**
+     * Determines the appropriate text color for both light and dark themes based on the fill color.
+     * Returns default theme-appropriate colors if the fill is transparent.
+     * @param fillColor - The theme-aware fill color
+     * @returns A theme-aware color object with appropriate text colors for both themes
+     */
+    static determineTextColor(fillColor: ThemeAwareColor): ThemeAwareColor;
+}

package/dist/types/helpers/cursor.helper.d.ts

@@ -0,0 +1,22 @@
+export declare class KritzelCursorHelper {
+    private static _pointerCursor;
+    /**
+     * Returns the custom pointer cursor CSS value.
+     * This can be used instead of `cursor: pointer` for consistent styling.
+     */
+    static getPointerCursor(): string;
+    /**
+     * Returns a custom cursor CSS value with support for rotation.
+     * The icon is retrieved from the KritzelIconRegistry.
+     */
+    static getCursor(options: {
+        iconName: string;
+        rotation?: number;
+        color?: string;
+        size?: number;
+        hotspot?: {
+            x: number;
+            y: number;
+        };
+    }): string;
+}

package/dist/types/helpers/devices.helper.d.ts

@@ -0,0 +1,8 @@
+export declare class KritzelDevicesHelper {
+    static isTouchDevice(): boolean;
+    static isAndroid(): boolean;
+    static isIOS(): boolean;
+    static detectOS(): 'iOS' | 'Android' | 'Other';
+    static isMobile(): boolean;
+    static isFirefox(): boolean;
+}

package/dist/types/helpers/event.helper.d.ts

@@ -0,0 +1,6 @@
+export declare class KritzelEventHelper {
+    static isRightClick(ev: MouseEvent): boolean;
+    static isLeftClick(ev: MouseEvent): boolean;
+    static isPointerEventOnContextMenu(event: PointerEvent): boolean;
+    static onLongPress(event: PointerEvent, onSuccess: (event: PointerEvent) => void, onCancel?: () => void): () => void;
+}

package/dist/types/helpers/geometry.helper.d.ts

@@ -0,0 +1,38 @@
+import { KritzelPoint } from "../interfaces/point.interface";
+import { KritzelPolygon } from "../interfaces/polygon.interface";
+export declare class KritzelGeometryHelper {
+    static doPolygonsIntersect(polygon1: KritzelPolygon, polygon2: KritzelPolygon): boolean;
+    static isPointInPolygon(point: KritzelPoint, polygon: KritzelPoint[]): boolean;
+    static intersectLines(p1a: KritzelPoint, p1b: KritzelPoint, p2a: KritzelPoint, p2b: KritzelPoint): boolean;
+    /**
+     * Finds the intersection point between a line segment and a line segment.
+     * Returns the intersection point or null if no intersection.
+     */
+    static getLineIntersectionPoint(p1a: KritzelPoint, p1b: KritzelPoint, p2a: KritzelPoint, p2b: KritzelPoint): KritzelPoint | null;
+    /**
+     * Finds the closest intersection point between a line segment (from lineStart to lineEnd)
+     * and a polygon. Returns the intersection point closest to lineStart, or null if no intersection.
+     */
+    static getLinePolygonIntersection(lineStart: KritzelPoint, lineEnd: KritzelPoint, polygon: KritzelPolygon): KritzelPoint | null;
+    /**
+     * Generates a polygon approximation of an ellipse.
+     * @param centerX - X coordinate of ellipse center
+     * @param centerY - Y coordinate of ellipse center
+     * @param rx - Horizontal radius
+     * @param ry - Vertical radius
+     * @param segments - Number of segments (more = smoother approximation)
+     * @param rotation - Optional rotation angle in radians
+     */
+    static getEllipsePolygonApproximation(centerX: number, centerY: number, rx: number, ry: number, segments?: number, rotation?: number): KritzelPoint[];
+    /**
+     * Finds the closest intersection point between a line segment and a polygon
+     * defined as an array of points. Returns the intersection closest to lineStart,
+     * or null if no intersection.
+     */
+    static getLinePointsArrayIntersection(lineStart: KritzelPoint, lineEnd: KritzelPoint, polygonPoints: KritzelPoint[]): KritzelPoint | null;
+    /**
+     * Checks if a point is inside a polygon defined as an array of points.
+     * This is a convenience wrapper that works with arbitrary polygon point arrays.
+     */
+    static isPointInPolygonPoints(point: KritzelPoint, polygonPoints: KritzelPoint[]): boolean;
+}

package/dist/types/helpers/html.helper.d.ts

@@ -0,0 +1,8 @@
+export declare class KritzelHTMLHelper {
+    static getNumericValueFromStyle(element: HTMLElement, property: string): number;
+    static isScrollableElement(element: Element): element is HTMLElement;
+    static findScrollableElement(root: Element | null | undefined): HTMLElement | null;
+    static getScrollableParent(element: HTMLElement): HTMLElement | Window;
+    static isElementInViewport(element: HTMLElement): boolean;
+    static getFocusableElements(root: HTMLElement): HTMLElement[];
+}

package/dist/types/helpers/image-file.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class KritzelImageFileHelper {
+    static isGifFile(file: Pick<File, 'name' | 'type'>): boolean;
+}

package/dist/types/helpers/keyboard.helper.d.ts

@@ -0,0 +1,6 @@
+export declare class KritzelKeyboardHelper {
+    static forceHideKeyboard(): void;
+    static enableInteractiveWidget(): void;
+    static disableInteractiveWidget(): void;
+    static onKeyboardVisibleChanged(callback: (isOpen: boolean) => void): () => void;
+}

package/dist/types/helpers/localization.helper.d.ts

@@ -0,0 +1,18 @@
+import { KritzelTermVars } from '../interfaces/localization.interface';
+/**
+ * Pure static utilities for localization term resolution.
+ */
+export declare class LocalizationHelper {
+    /**
+     * Interpolates `{placeholder}` tokens in a term template with the provided
+     * variables. Tokens without a matching variable are left untouched.
+     *
+     * @param template - The raw term string, e.g. `'Expires {date}'`
+     * @param vars - Map of placeholder names to replacement values
+     * @returns The interpolated string
+     *
+     * @example
+     * LocalizationHelper.interpolate('Hello {name}', { name: 'Ada' }); // 'Hello Ada'
+     */
+    static interpolate(template: string, vars?: KritzelTermVars): string;
+}

package/dist/types/helpers/math.helper.d.ts

@@ -0,0 +1,4 @@
+export declare class KritzelMathHelper {
+    static average(a: number, b: number): number;
+    static degreesToRadians(degrees: number): number;
+}

package/dist/types/helpers/migration.helper.d.ts

@@ -0,0 +1,30 @@
+import * as Y from 'yjs';
+import { KritzelMigration } from '../interfaces/migration.interface';
+export interface KritzelMigrationResult {
+    migrated: boolean;
+    fromVersion: number;
+    toVersion: number;
+}
+export interface KritzelMigrationOptions {
+    quiet?: boolean;
+}
+/**
+ * Runs pending schema migrations on a Y.Doc.
+ *
+ * Reads the current `schemaVersion` from the metadata map (defaults to 0 for
+ * documents that predate the migration system), filters and sorts pending
+ * migrations, and executes them in a single `'migration'`-origin transaction.
+ *
+ * The `'migration'` origin is:
+ * - NOT tracked by the UndoManager (which only tracks `'local'` and `'temporary'`)
+ * - Distinguishable in observers so they can skip re-processing migration writes
+ *
+ * @param ydoc - The Y.Doc to migrate
+ * @param metadataMap - The metadata Y.Map that stores the schemaVersion
+ * @param maps - Named Y.Maps available for migration logic (e.g. `{ workspaces }` or `{ objects }`)
+ * @param migrations - The ordered array of migration definitions
+ * @param currentVersion - The target schema version defined in code
+ * @param options - Optional configuration (e.g. `{ quiet: true }` to suppress console logs)
+ * @returns A result object indicating whether migrations ran and the version range
+ */
+export declare function runMigrations(ydoc: Y.Doc, metadataMap: Y.Map<any>, maps: Record<string, Y.Map<any>>, migrations: KritzelMigration[], currentVersion: number, options?: KritzelMigrationOptions): KritzelMigrationResult;

package/dist/types/helpers/object.helper.d.ts

@@ -0,0 +1,9 @@
+export declare class ObjectHelper {
+    static generateUUID(length?: number): string;
+    static isEmpty(obj: any): boolean;
+    static isClass<T>(object: unknown, className: string): object is T;
+    static isKritzelExportable(object: unknown): object is {
+        getSupportedExportFormats(): string[];
+        exportAs(format: string, context: unknown): Promise<string | null>;
+    };
+}