@kritzel/editor 0.4.31

package/dist/types/components/kritzel-notification-card/kritzel-notification-card.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelNotification } from '@kritzel/engine';
+export declare class KritzelNotificationCard {
+    /** Notification data rendered by this card. */
+    notification?: KritzelNotification;
+    /** Whether a formatted timestamp should be displayed when available. */
+    showTimestamp: boolean;
+    /** Locale used for formatting the timestamp. */
+    locale?: string;
+    /** Emitted when the notification should be dismissed manually. */
+    dismiss: EventEmitter<void>;
+    /** Emitted when pointer hover state changes. */
+    hoverChange: EventEmitter<boolean>;
+    private handleDismissClick;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private get type();
+    private get role();
+    private getTypeLabel;
+    private formatTimestamp;
+    render(): any;
+}

package/dist/types/components/kritzel-numeric-input/kritzel-numeric-input.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelNumericInput {
+    /** Current numeric value (undefined when cleared) */
+    value?: number;
+    /** Minimum allowed value */
+    min: number;
+    /** Maximum allowed value */
+    max: number;
+    /** Step increment for the input */
+    step: number;
+    /** Label text displayed above the input */
+    label: string;
+    /** Placeholder text shown when input is empty */
+    placeholder: string;
+    /** Emitted when the value changes (after normalization) */
+    valueChange: EventEmitter<number | undefined>;
+    private inputValue;
+    onValueChange(newValue: number | undefined): void;
+    componentWillLoad(): void;
+    private shouldShowEmpty;
+    private normalizeValue;
+    private getDecimalPlaces;
+    private roundToStep;
+    private handleInput;
+    private handleBlur;
+    private handleKeyDown;
+    private handleInvalid;
+    private commitValue;
+    private handleIncrement;
+    private handleDecrement;
+    render(): any;
+}

package/dist/types/components/kritzel-opacity-slider/kritzel-opacity-slider.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelOpacitySlider {
+    /** Current opacity value (0 to 1) */
+    value: number;
+    /** Minimum opacity value */
+    min: number;
+    /** Maximum opacity value */
+    max: number;
+    /** Step increment */
+    step: number;
+    /** Color to display in the preview (optional) */
+    previewColor: string;
+    valueChange: EventEmitter<number>;
+    private handleInput;
+    private getPercentage;
+    render(): any;
+}

package/dist/types/components/kritzel-pill-tabs/kritzel-pill-tabs.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export interface KritzelPillTab {
+    /** Unique identifier for the tab */
+    id: string;
+    /** Display label for the tab */
+    label: string;
+    /** Optional icon name to display before the label */
+    icon?: string;
+}
+export declare class KritzelPillTabs {
+    /**
+     * Array of tab definitions to render
+     */
+    tabs: KritzelPillTab[];
+    /**
+     * Currently selected tab ID
+     */
+    value: string;
+    /**
+     * Emitted when the selected tab changes
+     */
+    valueChange: EventEmitter<string>;
+    private handleTabClick;
+    private handleKeyDown;
+    render(): any;
+}

package/dist/types/components/kritzel-portal/kritzel-portal.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelPortal {
+    host: HTMLElement;
+    anchor: HTMLElement;
+    anchorChanged(newValue: HTMLElement): void;
+    offsetX: number;
+    offsetY: number;
+    autoFocus: boolean;
+    close: EventEmitter<void>;
+    handleDismissMenus(): void;
+    handleOutsideClick(event: MouseEvent): void;
+    handleOutsidePointerDown(event: PointerEvent): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleResize(): void;
+    handleWindowScroll(): void;
+    private portal;
+    private id;
+    private defaultOffset;
+    private minLeft;
+    private themeObserver;
+    private focusFirstElement;
+    private getDeepActiveElement;
+    private trapFocus;
+    private get firstFocusableElement();
+    private get lastAddedPortal();
+    private calculateLeft;
+    private calculateTop;
+    private getThemeProvider;
+    private openPortal;
+    private closePortal;
+    private calculatePosition;
+    render(): any;
+}

package/dist/types/components/kritzel-settings/kritzel-settings.d.ts

@@ -0,0 +1,64 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelSettingsConfig } from '@kritzel/engine';
+import { KritzelDebugInfo } from '@kritzel/engine';
+import { ThemeName } from '@kritzel/engine';
+import { KritzelShortcut } from '@kritzel/engine';
+import { LocaleCode, KritzelTermKey } from '@kritzel/engine';
+export declare class KritzelSettings {
+    host: HTMLElement;
+    /** Keyboard shortcuts to display in the settings dialog */
+    availableThemes: string[];
+    /** Available locales as `{ code, label }` options for the language selector. */
+    availableLocales: {
+        code: LocaleCode;
+        label: string;
+    }[];
+    shortcuts: Omit<KritzelShortcut, 'action' | 'condition'>[];
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    /** Current settings values. Used to initialize and sync the component's internal state. */
+    settings?: Partial<KritzelSettingsConfig>;
+    onSettingsPropChange(newSettings?: Partial<KritzelSettingsConfig>): void;
+    isDialogOpen: boolean;
+    selectedCategoryId: string;
+    scaleMin: number;
+    scaleMax: number;
+    lockDrawingScale: boolean;
+    theme: ThemeName;
+    locale: LocaleCode;
+    viewportBoundaryLeft: number;
+    viewportBoundaryRight: number;
+    viewportBoundaryTop: number;
+    viewportBoundaryBottom: number;
+    debugInfo: KritzelDebugInfo;
+    /** Emitted when settings change */
+    settingsChange: EventEmitter<KritzelSettingsConfig>;
+    componentWillLoad(): void;
+    private applySettings;
+    private emitSettings;
+    private handleScaleMinChange;
+    private handleScaleMaxChange;
+    private handleLockDrawingScaleChange;
+    private handleThemeChange;
+    private handleLocaleChange;
+    private handleViewportBoundaryLeftChange;
+    private handleViewportBoundaryRightChange;
+    private handleViewportBoundaryTopChange;
+    private handleViewportBoundaryBottomChange;
+    private handleDebugInfoChange;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    private closeDialog;
+    private handleCategorySelect;
+    private formatKeyCombo;
+    private formatKey;
+    private groupShortcutsByCategory;
+    /**
+     * Resolves a localized string from the supplied {@link terms} map, falling
+     * back to the provided English default when the key is missing.
+     */
+    private t;
+    private get categories();
+    private renderCategoryContent;
+    render(): any;
+}

package/dist/types/components/kritzel-shape-fill/kritzel-shape-fill.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export type ShapeFillType = 'transparent' | 'filled';
+export declare class KritzelShapeFill {
+    /** Current fill type */
+    value: ShapeFillType;
+    valueChange: EventEmitter<ShapeFillType>;
+    private handleFillChange;
+    private renderFillIcon;
+    render(): any;
+}

package/dist/types/components/kritzel-share-dialog/kritzel-share-dialog.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelTermKey } from '@kritzel/engine';
+/**
+ * Share dialog component for managing workspace link sharing.
+ * This is a presentational component that emits events for all actions.
+ * The parent component (kritzel-editor) handles the business logic.
+ */
+export declare class KritzelShareDialog {
+    host: HTMLElement;
+    /**
+     * Whether the workspace is currently public.
+     */
+    isPublic: boolean;
+    /**
+     * The ID of the workspace being shared. Used to build the share URL.
+     */
+    workspaceId: string | undefined;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    onIsPublicChange(newValue: boolean): void;
+    onWorkspaceIdChange(): void;
+    isDialogOpen: boolean;
+    internalIsPublic: boolean;
+    copySuccess: boolean;
+    qrCodeDataUrl: string;
+    private qrCodeUpdateSequence;
+    /**
+     * Emitted when the user toggles the public sharing state.
+     */
+    toggleIsPublic: EventEmitter<boolean>;
+    /**
+     * Emitted when the dialog is closed.
+     */
+    dialogClosed: EventEmitter<void>;
+    /**
+     * Opens the share dialog.
+     */
+    open(): Promise<void>;
+    /**
+     * Closes the share dialog.
+     */
+    close(): Promise<void>;
+    private handleToggleChange;
+    private updateQrCodeDataUrl;
+    private getShareUrl;
+    private handleCopyUrl;
+    private closeDialog;
+    render(): any;
+}

package/dist/types/components/kritzel-slide-toggle/kritzel-slide-toggle.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelSlideToggle {
+    /** Whether the toggle is checked/on */
+    checked: boolean;
+    /** Whether the toggle is disabled */
+    disabled: boolean;
+    /** Label text for accessibility (screen readers) */
+    label?: string;
+    /** Emitted when the toggle state changes */
+    checkedChange: EventEmitter<boolean>;
+    private handleToggle;
+    private handleKeyDown;
+    render(): any;
+}

package/dist/types/components/kritzel-split-button/kritzel-split-button.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { IKritzelMenuItem, IKritzelMenuItemSelectEvent, IKritzelMenuItemToggleChildMenuEvent } from '@kritzel/engine';
+export declare class KritzelSplitButton {
+    host: HTMLElement;
+    buttonIcon: string;
+    dropdownIcon: string;
+    items: IKritzelMenuItem[];
+    mainButtonDisabled: boolean;
+    menuButtonDisabled: boolean;
+    mainButtonClick: EventEmitter<void>;
+    itemSelect: EventEmitter<IKritzelMenuItemSelectEvent>;
+    itemSave: EventEmitter<IKritzelMenuItem>;
+    itemCancel: EventEmitter<IKritzelMenuItem>;
+    itemToggleChildMenu: EventEmitter<IKritzelMenuItemToggleChildMenuEvent>;
+    itemCloseChildMenu: EventEmitter<IKritzelMenuItem>;
+    menuOpen: EventEmitter<void>;
+    menuClose: EventEmitter<void>;
+    isMenuOpen: boolean;
+    isTouchDevice: boolean;
+    anchorElement: HTMLElement;
+    menuScrollTop: number;
+    splitMenuButtonRef: HTMLButtonElement;
+    menuRef: HTMLKritzelMenuElement;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    focusMenu(): Promise<void>;
+    private handleButtonClick;
+    private toggleMenu;
+    private openMenu;
+    private closeMenu;
+    private handleItemSelect;
+    private handleItemSave;
+    private handleItemCancel;
+    private handleItemToggleChildMenu;
+    private handleItemCloseChildMenu;
+    private handleScroll;
+    render(): any;
+}

package/dist/types/components/kritzel-stroke-size/kritzel-stroke-size.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelStrokeSize {
+    sizes: number[];
+    selectedSize: number | null;
+    sizeChange: EventEmitter<number>;
+    private handleSizeClick;
+    render(): any;
+}

package/dist/types/components/kritzel-tool-config/kritzel-tool-config.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ConfigurableTool, ToolConfigDefinition, ToolDisplayValues } from '@kritzel/engine';
+import { ThemeAwareColor } from '@kritzel/engine';
+import { ThemeName } from '@kritzel/engine';
+import { KritzelTermKey } from '@kritzel/engine';
+export declare class KritzelToolConfig {
+    tool: ConfigurableTool;
+    handleToolChange(newTool: ConfigurableTool, oldTool: ConfigurableTool): void;
+    isExpanded: boolean;
+    theme: ThemeName;
+    engine: HTMLElement;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    private handleSelectionChangeBound;
+    onThemeChange(): void;
+    handleEngineChange(newEngine: HTMLElement, oldEngine: HTMLElement): void;
+    toolChange: EventEmitter<ConfigurableTool>;
+    displayValuesChange: EventEmitter<ToolDisplayValues>;
+    config: ToolConfigDefinition;
+    palette: ThemeAwareColor[];
+    sizes: number[];
+    currentOpacity: number;
+    private updateTrigger;
+    private getFontOptionsFromTool;
+    handleSelectionChange(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    private emitDisplayValues;
+    private updatePalette;
+    private updateSizes;
+    private handleToggleExpand;
+    private handleColorChange;
+    private handleSizeChange;
+    private handleOpacityChange;
+    private handlePropertyChange;
+    private getShapeFillValue;
+    private renderControl;
+    render(): any;
+}

package/dist/types/components/kritzel-toolbar/kritzel-toolbar.d.ts

@@ -0,0 +1,76 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelBrushTool } from '@kritzel/engine';
+import { KritzelLineTool } from '@kritzel/engine';
+import { KritzelShapeTool } from '@kritzel/engine';
+import { KritzelTextTool } from '@kritzel/engine';
+import { KritzelToolbarItem, KritzelToolbarSubOption } from '@kritzel/engine';
+import { KritzelUndoState } from '@kritzel/engine';
+import { ToolDisplayValues } from '@kritzel/engine';
+import { ThemeName } from '@kritzel/engine';
+import { KritzelTermKey } from '@kritzel/engine';
+type ToolConfig = Record<string, any>;
+export declare class KritzelToolbar {
+    host: HTMLElement;
+    visible: boolean;
+    toolbarItems: KritzelToolbarItem[];
+    activeControl: KritzelToolbarItem | null;
+    isUtilityPanelVisible: boolean;
+    undoState: KritzelUndoState;
+    theme: ThemeName;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    isToolbarReady: EventEmitter<void>;
+    firstConfig: ToolConfig | null;
+    isTouchDevice: boolean;
+    selectedSubOptions: Map<string, KritzelToolbarSubOption>;
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+    needsScrolling: boolean;
+    displayValues: ToolDisplayValues | null;
+    internalToolbar: KritzelToolbarItem[];
+    resolvedDisabled: Map<string, boolean>;
+    private handleActiveToolChangeBound;
+    private handleSelectionChangeBound;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleActiveToolChange(event: CustomEvent): Promise<void>;
+    handleSelectionChange(): void;
+    onToolbarItemsChange(): Promise<void>;
+    onThemeChange(): void;
+    closeTooltip(): Promise<void>;
+    kritzelEngine: HTMLKritzelEngineElement | null;
+    toolsScrollRef: HTMLDivElement | null;
+    private configTriggerRef;
+    get activeToolAsTextTool(): KritzelTextTool;
+    get activeToolAsBrushTool(): KritzelBrushTool;
+    get activeToolAsLineTool(): KritzelLineTool;
+    get activeToolAsShapeTool(): KritzelShapeTool;
+    private handleDisplayValuesChange;
+    private updateDisplayValues;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): void;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    private updateScrollIndicators;
+    private handleToolsScroll;
+    private initializeEngine;
+    private initializeTools;
+    /**
+     * Resolves each tool's `isDisabled` (boolean or sync/async function) into `resolvedDisabled`.
+     */
+    private resolveDisabledStates;
+    private evaluateDisabled;
+    private isControlDisabled;
+    private handleControlClick;
+    private handleToolChange;
+    /**
+     * Get the currently selected sub-option for a control.
+     * Returns the first sub-option as default if none is selected.
+     */
+    private getSelectedSubOption;
+    /**
+     * Select a sub-option and update the tool property
+     */
+    private selectSubOption;
+    render(): any;
+}
+export {};

package/dist/types/components/kritzel-tooltip/kritzel-tooltip.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelTooltip {
+    host: HTMLElement;
+    isVisible: boolean;
+    anchorElement: HTMLElement;
+    triggerElement: HTMLElement;
+    offsetY: number;
+    tooltipClosed: EventEmitter<void>;
+    tooltipOpened: EventEmitter<void>;
+    positionX: number;
+    positionY: number;
+    handleOutsideClick(event: MouseEvent): void;
+    handleOutsidePointerDown(event: PointerEvent): void;
+    handleCloseAll(event: CustomEvent): void;
+    handleWindowResize(): void;
+    handleTriggerElementChange(newTrigger: HTMLElement, oldTrigger: HTMLElement): void;
+    handleVisibilityChange(newValue: boolean): void;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    toggle(): Promise<void>;
+    focusContent(): Promise<void>;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    componentWillLoad(): void;
+    componentWillUpdate(): void;
+    disconnectedCallback(): void;
+    private handleTriggerClick;
+    private calculateAdjustedPosition;
+    render(): any;
+}

package/dist/types/components/kritzel-utility-panel/kritzel-utility-panel.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelUndoState } from '@kritzel/engine';
+import { KritzelTermKey } from '@kritzel/engine';
+export declare class KritzelUtilityPanel {
+    undoState: KritzelUndoState;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    undo: EventEmitter<void>;
+    redo: EventEmitter<void>;
+    delete: EventEmitter<void>;
+    handleUndo(event: Event): void;
+    handleRedo(event: Event): void;
+    render(): any;
+}

package/dist/types/components/kritzel-workspace-manager/kritzel-workspace-manager.d.ts

@@ -0,0 +1,40 @@
+import { KritzelWorkspace } from '@kritzel/engine';
+import { IKritzelMenuItem } from '@kritzel/engine';
+import { KritzelTermKey } from '@kritzel/engine';
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class KritzelWorkspaceManager {
+    host: HTMLElement;
+    /**
+     * Whether the workspace manager is visible
+     */
+    visible: boolean;
+    activeWorkspace: KritzelWorkspace;
+    workspaces: KritzelWorkspace[];
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    isWorkspaceManagerReady: EventEmitter<void>;
+    workspaceChange: EventEmitter<KritzelWorkspace>;
+    childMenuAnchor: HTMLElement;
+    openChildMenuItem: IKritzelMenuItem;
+    newWorkspace: KritzelWorkspace | null;
+    editingItemId: string | null;
+    handleWheel(event: WheelEvent): void;
+    kritzelEngineRef: HTMLKritzelEngineElement | null;
+    splitButtonRef: HTMLKritzelSplitButtonElement;
+    get sortedWorkspaces(): KritzelWorkspace[];
+    componentWillLoad(): Promise<void>;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    private initializeEngine;
+    private select;
+    private add;
+    private edit;
+    private save;
+    private cancel;
+    private delete;
+    private toggleChildMenu;
+    private closeChildMenu;
+    private handleMenuOpen;
+    private handleMenuClose;
+    render(): any;
+}

package/dist/types/components/kritzel-zoom-panel/kritzel-zoom-panel.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { KritzelTermKey } from '@kritzel/engine';
+export declare class KritzelZoomPanel {
+    /** Whether the zoom panel is visible. */
+    visible: boolean;
+    /** Whether both zoom buttons are disabled. */
+    disabled: boolean;
+    /** Current zoom level in percent. */
+    zoomPercent: number;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms: Partial<Record<KritzelTermKey, string>>;
+    /** Emitted when the zoom-in button is clicked. */
+    zoomIn: EventEmitter<void>;
+    /** Emitted when the zoom-out button is clicked. */
+    zoomOut: EventEmitter<void>;
+    private handleZoomIn;
+    private handleZoomOut;
+    private get normalizedZoomPercent();
+    render(): any;
+}