@snowcone-app/canvas 0.1.0

package/dist/components/Drawer.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+export interface DrawerProps {
+    /** Whether the drawer is open */
+    isOpen: boolean;
+    /** Callback when drawer should close */
+    onClose: () => void;
+    /** Drawer title (for accessibility and header) */
+    title: string;
+    /** Optional description (for accessibility) */
+    description?: string;
+    /** Drawer content */
+    children: React.ReactNode;
+    /** Placement of drawer */
+    placement?: 'bottom' | 'right' | 'left';
+    /** Fixed height (for bottom drawer) */
+    height?: string;
+    /** Maximum height (for bottom drawer) */
+    maxHeight?: string;
+    /** Fixed width (for side drawers) */
+    width?: string;
+    /** Maximum width (for side drawers) */
+    maxWidth?: string;
+    /** Show close button in header */
+    showCloseButton?: boolean;
+    /** Additional header content (placed next to title) */
+    headerActions?: React.ReactNode;
+    /** Hide the visible title (keeps sr-only title for accessibility) */
+    hideVisibleTitle?: boolean;
+    /** Hide the drag handle (bottom drawer only) */
+    hideHandle?: boolean;
+    /** Disable built-in overflow-y-auto wrapper (for custom scroll containers) */
+    disableScrollWrapper?: boolean;
+    /** Disable overflow-hidden on drawer content (needed for backdrop-filter to work properly) */
+    disableOverflowHidden?: boolean;
+    /** Test ID for the drawer content element */
+    'data-testid'?: string;
+}
+export declare const Drawer: React.FC<DrawerProps>;
+export default Drawer;

package/dist/components/EffectsPanel.d.ts

@@ -0,0 +1,14 @@
+import { TextElement } from '../core/TextElement.js';
+import { ImageElement } from '../core/ImageElement.js';
+import { GroupElement } from '../core/GroupElement.js';
+import { ShapeElement } from '../core/ShapeElement.js';
+import { PathElement } from '../core/PathElement.js';
+type EditorElement = TextElement | ImageElement | GroupElement | ShapeElement | PathElement;
+interface EffectsPanelProps {
+    element: EditorElement | null;
+    onElementUpdate: (element: EditorElement) => void;
+    isOpen: boolean;
+    onClose: () => void;
+}
+declare const EffectsPanel: ({ element, onElementUpdate, isOpen, onClose }: EffectsPanelProps) => import("react/jsx-runtime").JSX.Element | null;
+export default EffectsPanel;

package/dist/components/ExportTestPanel.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { ArtboardElement } from '../core/ArtboardElement';
+import { TextElement } from '../core/TextElement';
+import { ImageElement } from '../core/ImageElement';
+import { GroupElement } from '../core/GroupElement';
+import { ShapeElement } from '../core/ShapeElement';
+import { PathElement } from '../core/PathElement';
+interface ExportTestPanelProps {
+    artboards: ArtboardElement[];
+    elements: (TextElement | ImageElement | GroupElement | ShapeElement | PathElement)[];
+    isInteracting?: boolean;
+    isOpen: boolean;
+    onClose: () => void;
+}
+declare const ExportTestPanel: React.FC<ExportTestPanelProps>;
+export default ExportTestPanel;

package/dist/components/FontBrowserDrawer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * FontBrowserDrawer - Drawer for selecting font family with search and category filters
+ * Refactored to use HeroUI design system
+ */
+export interface FontBrowserDrawerProps {
+    value: string;
+    onChange: (event: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    fontFamilies?: string[];
+    isOpen: boolean;
+    onToggle: (open: boolean) => void;
+    showLabel?: boolean;
+    previewText?: string;
+    elements?: Array<Record<string, unknown>>;
+}
+declare const FontBrowserDrawer: ({ value, onChange, fontFamilies: _fontFamilies, isOpen, onToggle, showLabel: _, previewText, elements, }: FontBrowserDrawerProps) => import("react/jsx-runtime").JSX.Element;
+export default FontBrowserDrawer;

package/dist/components/FontSizeDropdown.d.ts

@@ -0,0 +1,12 @@
+/**
+ * FontSizeDropdown - Dropdown for selecting font size
+ */
+export interface FontSizeDropdownProps {
+    value: number;
+    onChange: (size: number) => void;
+    fontSizes: number[];
+    isOpen: boolean;
+    onToggle: (open: boolean) => void;
+}
+declare const FontSizeDropdown: import('react').MemoExoticComponent<({ value, onChange, fontSizes, isOpen, onToggle }: FontSizeDropdownProps) => import("react/jsx-runtime").JSX.Element>;
+export default FontSizeDropdown;

package/dist/components/GlyphBrowserDrawer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GlyphBrowserDrawer - Browse and insert all glyphs from the current font
+ * Opens as a bottom drawer and inserts glyphs at cursor position or appends to text
+ */
+interface GlyphBrowserDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    fontFamily: string;
+    fontWeight?: number;
+    onInsertGlyph: (unicode: string) => void;
+}
+export declare const GlyphBrowserDrawer: ({ isOpen, onClose, fontFamily, fontWeight, onInsertGlyph, }: GlyphBrowserDrawerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/GlyphPicker.d.ts

@@ -0,0 +1,14 @@
+import { GlyphOverride } from '../types';
+interface GlyphPickerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    character: string;
+    charIndex: number;
+    fontFamily: string;
+    fontWeight?: number;
+    currentGlyphOverride?: GlyphOverride;
+    onSelectGlyph: (override: GlyphOverride | null) => void;
+    browseAll?: boolean;
+}
+export declare const GlyphPicker: ({ isOpen, onClose, character, charIndex, fontFamily, fontWeight, currentGlyphOverride, onSelectGlyph, browseAll, }: GlyphPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/IconMatchTest.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const IconMatchTest: React.FC;
+export default IconMatchTest;

package/dist/components/IconSizeTest.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const IconSizeTest: React.FC;
+export default IconSizeTest;

package/dist/components/ImageBrowserDrawer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ImageBrowserDrawer - Drawer for browsing and selecting images
+ *
+ * Features:
+ * - Dual-source image search: Fetches from both Unsplash and Pixabay APIs in parallel
+ * - Seamless integration: Results are interleaved so users don't realize we're using multiple sources
+ * - Graceful fallback: Works with 0, 1, or 2 API keys configured
+ * - Custom URL/upload: Supports uploading images from computer or pasting URLs
+ *
+ * API Keys (optional, set via environment variables):
+ * - VITE_UNSPLASH_ACCESS_KEY - Get from https://unsplash.com/developers
+ * - VITE_PIXABAY_API_KEY - Get from https://pixabay.com/api/docs/
+ *
+ * Image Quality:
+ * - Unsplash: 'regular' size (~1080px width)
+ * - Pixabay: 'largeImageURL' size (~1280px width)
+ */
+interface ImageBrowserPanelProps {
+    isOpen: boolean;
+    onToggle: (open: boolean) => void;
+    onImageSelect: (imageUrl: string) => void;
+    currentImageUrl?: string;
+    /** Placement of drawer - defaults to 'bottom' */
+    placement?: 'bottom' | 'left' | 'right';
+}
+declare const ImageBrowserPanel: ({ isOpen, onToggle, onImageSelect, currentImageUrl, placement, }: ImageBrowserPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default ImageBrowserPanel;

package/dist/components/ImageToolbar.d.ts

@@ -0,0 +1,47 @@
+import { default as React } from 'react';
+import { ImageElement } from '../core/ImageElement';
+interface ImageToolbarProps {
+    element: ImageElement;
+    onElementUpdate: (element: ImageElement) => void;
+    showUngroupButton?: boolean;
+    onUngroup?: () => void;
+    onMoveForward?: () => void;
+    onMoveBackward?: () => void;
+    onChangeImage?: () => void;
+    /** Callback when element should be deleted */
+    onDelete?: () => void;
+    /** Whether the corner radius panel is expanded */
+    cornerRadiusExpanded?: boolean;
+    /** Callback when corner radius panel should be toggled */
+    onCornerRadiusToggle?: () => void;
+    /** Whether the crop panel is expanded */
+    cropExpanded?: boolean;
+    /** Callback when crop panel should be toggled */
+    onCropToggle?: () => void;
+    /** Whether the rotation panel is expanded */
+    rotationExpanded?: boolean;
+    /** Callback when rotation panel should be toggled */
+    onRotationToggle?: () => void;
+    /** Whether the opacity panel is expanded */
+    opacityExpanded?: boolean;
+    /** Callback when opacity panel should be toggled */
+    onOpacityToggle?: () => void;
+    /** Whether the stroke panel is expanded */
+    strokeExpanded?: boolean;
+    /** Callback when stroke panel should be toggled */
+    onStrokeToggle?: () => void;
+    /** Whether the knockout panel is expanded */
+    knockoutExpanded?: boolean;
+    /** Callback when knockout panel should be toggled */
+    onKnockoutToggle?: () => void;
+    /** Whether the distress texture panel is expanded */
+    distressTextureExpanded?: boolean;
+    /** Callback when distress texture panel should be toggled */
+    onDistressTextureToggle?: () => void;
+    /** Whether the image mask panel is expanded */
+    imageMaskExpanded?: boolean;
+    /** Callback when image mask panel should be toggled */
+    onImageMaskToggle?: () => void;
+}
+declare const ImageToolbar: React.FC<ImageToolbarProps>;
+export default ImageToolbar;

package/dist/components/LayerEffects.d.ts

@@ -0,0 +1,11 @@
+import { TextElement } from '../core/TextElement.js';
+import { ImageElement } from '../core/ImageElement.js';
+import { GroupElement } from '../core/GroupElement.js';
+import { ShapeElement } from '../core/ShapeElement.js';
+interface LayerEffectsProps {
+    element: TextElement | ImageElement | GroupElement | ShapeElement;
+    onToggleExpand?: () => void;
+    isExpanded?: boolean;
+}
+declare const LayerEffects: ({ element, onToggleExpand, isExpanded }: LayerEffectsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default LayerEffects;

package/dist/components/LayerLeadingChip.d.ts

@@ -0,0 +1,9 @@
+import { BaseElement } from '../core/BaseElement.js';
+export declare function LayerLeadingChip({ element, onToggleLock, onThumbnailClick, }: {
+    element: BaseElement | null;
+    onToggleLock: () => void;
+    /** Optional click handler for the thumbnail. When provided, the
+     *  thumbnail becomes a button — typical use is to open the
+     *  "Manage Layers" drawer with the current layer focused. */
+    onThumbnailClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/LayersPanel.d.ts

@@ -0,0 +1,30 @@
+import { TextElement } from '../core/TextElement.js';
+import { ImageElement } from '../core/ImageElement.js';
+import { GroupElement } from '../core/GroupElement.js';
+import { ShapeElement } from '../core/ShapeElement.js';
+import { PathElement } from '../core/PathElement.js';
+import { ArtboardElement } from '../core/ArtboardElement.js';
+type LayerElement = TextElement | ImageElement | GroupElement | ShapeElement | PathElement;
+interface LayersPanelProps {
+    elements: LayerElement[];
+    selectedId: string | null;
+    multiSelection: string[];
+    activeChildElement?: LayerElement | null;
+    hoveredElementId?: string | null;
+    activeArtboard?: ArtboardElement | null;
+    isVisible?: boolean;
+    onToggleVisibility?: () => void;
+    onSelectionChange: (id: string | null) => void;
+    onMultiSelectionChange: (ids: string[]) => void;
+    onElementUpdate: (element: LayerElement) => void;
+    onReorder: (draggedId: string, targetId: string, position: 'before' | 'after') => void;
+    onReorderInGroup?: (draggedId: string, targetId: string, position: 'before' | 'after', groupId: string) => void;
+    onDropIntoGroup?: (draggedId: string, groupId: string) => void;
+    onDropIntoGroupAtPosition?: (draggedId: string, groupId: string, targetChildId: string, position: 'before' | 'after') => void;
+    onDelete?: (id: string) => void;
+    onAddElement?: (type: string) => void;
+    onOpenEffectsPanel?: () => void;
+    onDuplicate?: (id: string) => void;
+}
+declare const LayersPanel: ({ elements, selectedId, multiSelection, activeChildElement, hoveredElementId: _hoveredElementId, activeArtboard, isVisible, onToggleVisibility: _onToggleVisibility, onSelectionChange, onMultiSelectionChange, onElementUpdate, onReorder, onReorderInGroup, onDropIntoGroup, onDropIntoGroupAtPosition, onDelete, onAddElement: _onAddElement, onOpenEffectsPanel, onDuplicate, }: LayersPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default LayersPanel;

package/dist/components/MaskItem.d.ts

@@ -0,0 +1,12 @@
+import { MaskDefinition } from '../types/index.js';
+interface MaskItemProps {
+    mask: MaskDefinition;
+    index: number;
+    isFirst: boolean;
+    isLast: boolean;
+    onUpdate: (updates: Partial<MaskDefinition>) => void;
+    onRemove: () => void;
+    onReorder: (direction: 'up' | 'down') => void;
+}
+declare const MaskItem: ({ mask, index, isFirst, isLast, onUpdate, onRemove, onReorder }: MaskItemProps) => import("react/jsx-runtime").JSX.Element;
+export default MaskItem;

package/dist/components/MasksPanel.d.ts

@@ -0,0 +1,7 @@
+import { MaskDefinition } from '../types/index.js';
+interface MasksPanelProps {
+    masks?: MaskDefinition[];
+    onChange: (masks: MaskDefinition[]) => void;
+}
+declare const MasksPanel: ({ masks, onChange }: MasksPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default MasksPanel;

package/dist/components/MonotypeDemoPage.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const MonotypeDemoPage: React.FC;

package/dist/components/MoreMenu.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MoreMenu - Overflow menu for toolbar items
+ * Shows a "..." menu with items that don't fit or are always hidden
+ */
+interface MoreMenuItem {
+    label: string;
+    icon: React.ReactNode;
+    onClick: () => void;
+    active?: boolean;
+}
+interface MoreMenuProps {
+    items: MoreMenuItem[];
+}
+declare const MoreMenu: ({ items }: MoreMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default MoreMenu;

package/dist/components/OpenTypeFeaturesPanel.d.ts

@@ -0,0 +1,12 @@
+import { OpenTypeFeatures, GlyphOverride } from '../types/index.js';
+interface OpenTypeFeaturesPanelProps {
+    fontFamily?: string;
+    fontWeight?: number;
+    text?: string;
+    openTypeFeatures?: OpenTypeFeatures;
+    glyphOverrides?: GlyphOverride[];
+    onChange: (features: OpenTypeFeatures | undefined) => void;
+    onGlyphOverridesChange?: (overrides: GlyphOverride[] | undefined) => void;
+}
+declare const OpenTypeFeaturesPanel: ({ fontFamily, fontWeight, text, openTypeFeatures, glyphOverrides, onChange, onGlyphOverridesChange, }: OpenTypeFeaturesPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default OpenTypeFeaturesPanel;

package/dist/components/PathToolbar.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { PathElement } from '../core/PathElement';
+interface PathToolbarProps {
+    element: PathElement;
+    onElementUpdate: (element: PathElement) => void;
+    onMoveForward?: () => void;
+    onMoveBackward?: () => void;
+}
+declare const PathToolbar: React.FC<PathToolbarProps>;
+export default PathToolbar;

package/dist/components/PenToolDemo.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const PenToolDemo: React.FC;
+export default PenToolDemo;

package/dist/components/ProgressiveBlur.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+export interface ProgressiveBlurSimpleProps {
+    className?: string;
+    backgroundColor?: string;
+    position?: "top" | "bottom";
+    height?: string;
+    blurAmount?: string;
+}
+/**
+ * ProgressiveBlurSimple - CSS-only progressive blur with single element
+ *
+ * Uses mask-image to fade a single blur effect, creating the "progressive" feel
+ * with minimal DOM. Much simpler than the layered approach.
+ *
+ * Credit: Inspired by Skiper UI / @gurvinder-singh02
+ */
+export declare function ProgressiveBlurSimple({ className, backgroundColor, position, height, blurAmount, }: ProgressiveBlurSimpleProps): import("react/jsx-runtime").JSX.Element;
+export interface ProgressiveBlurProps {
+    className?: string;
+    height?: string;
+    position?: "top" | "bottom" | "both";
+    blurLevels?: number[];
+    children?: React.ReactNode;
+}
+export declare function ProgressiveBlur({ className, height, position, blurLevels, }: ProgressiveBlurProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RotationHandle.d.ts

@@ -0,0 +1,47 @@
+import { default as React } from 'react';
+import { TextElement } from '../core/TextElement.js';
+import { ImageElement } from '../core/ImageElement.js';
+export interface RotationHandleProps {
+    /**
+     * Selected element to show rotation handle for
+     */
+    selectedElement: TextElement | null | undefined;
+    /**
+     * Canvas reference for coordinate transformation
+     */
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    /**
+     * Current zoom level
+     */
+    zoom: number;
+    /**
+     * Whether rotation is currently active
+     */
+    isRotating: boolean;
+    /**
+     * Whether resize is currently active
+     */
+    isResizing: boolean;
+    /**
+     * Whether mouse is down (freezes position during drag)
+     */
+    isMouseDown: boolean;
+    /**
+     * Callback when rotation starts
+     */
+    onRotationStart: (worldX: number, worldY: number, angle: number) => void;
+    /**
+     * Current rotation angle (for tooltip display)
+     */
+    currentRotation?: number;
+    /**
+     * Ref to the currently rotating element (updated during drag for live position)
+     */
+    rotatingElementRef?: React.RefObject<TextElement | ImageElement | null>;
+    /**
+     * Version counter that increments when rotatingElementRef updates (triggers re-calc)
+     */
+    rotatingElementVersion?: number;
+}
+export declare const RotationHandle: React.FC<RotationHandleProps>;
+export default RotationHandle;

package/dist/components/SaveLoadMenu.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { ArtboardElement } from '../core/ArtboardElement';
+import { TextElement } from '../core/TextElement';
+import { ImageElement } from '../core/ImageElement';
+import { GroupElement } from '../core/GroupElement';
+import { ArtboardManager } from '../core/ArtboardManager';
+interface SaveLoadMenuProps {
+    artboards: ArtboardElement[];
+    elements: (TextElement | ImageElement | GroupElement)[];
+    artboardManager: ArtboardManager;
+    onLoad: (artboards: ArtboardElement[], elements: (TextElement | ImageElement | GroupElement)[], activeArtboardId: string | null) => void;
+    canvasRef?: React.RefObject<HTMLCanvasElement>;
+}
+declare const SaveLoadMenu: React.FC<SaveLoadMenuProps>;
+export default SaveLoadMenu;

package/dist/components/ShapeToolbar.d.ts

@@ -0,0 +1,71 @@
+import { default as React } from 'react';
+import { ShapeElement } from '../core/ShapeElement';
+interface ShapeToolbarProps {
+    element: ShapeElement;
+    onElementUpdate: (element: ShapeElement) => void;
+    /**
+     * Colours actually in use elsewhere in the design (text colours,
+     * shape fills, strokes, paths, artboard background). Surfaced in
+     * the colour picker so users can match an existing colour. Pass
+     * `[]` (or omit) to fall back to the artboard-preset palette.
+     */
+    documentColors?: string[];
+    /**
+     * Dominant colours sampled from image elements in the design.
+     * Surfaced as a separate "Image colors" row in the colour picker.
+     */
+    imageColors?: string[];
+    showUngroupButton?: boolean;
+    onUngroup?: () => void;
+    onMoveForward?: () => void;
+    onMoveBackward?: () => void;
+    onOpenShapeTypeDrawer?: () => void;
+    /** Callback when element should be deleted */
+    onDelete?: () => void;
+    /** Whether the rotation panel is expanded */
+    rotationExpanded?: boolean;
+    /** Callback when rotation panel should be toggled */
+    onRotationToggle?: () => void;
+    /** Whether the corner radius panel is expanded */
+    cornerRadiusExpanded?: boolean;
+    /** Callback when corner radius panel should be toggled */
+    onCornerRadiusToggle?: () => void;
+    /** Whether the transparency/opacity panel is expanded */
+    transparencyExpanded?: boolean;
+    /** Callback when transparency panel should be toggled */
+    onTransparencyToggle?: () => void;
+    /** Whether the sides panel is expanded (polygon) */
+    sidesExpanded?: boolean;
+    /** Callback when sides panel should be toggled */
+    onSidesToggle?: () => void;
+    /** Whether the points panel is expanded (star) */
+    pointsExpanded?: boolean;
+    /** Callback when points panel should be toggled */
+    onPointsToggle?: () => void;
+    /** Whether the inner radius panel is expanded (star) */
+    innerRadiusExpanded?: boolean;
+    /** Callback when inner radius panel should be toggled */
+    onInnerRadiusToggle?: () => void;
+    /** Whether the fill color panel is expanded */
+    colorExpanded?: boolean;
+    /** Callback when fill color panel should be toggled */
+    onColorToggle?: () => void;
+    /** Whether the stroke panel is expanded */
+    strokeExpanded?: boolean;
+    /** Callback when stroke panel should be toggled */
+    onStrokeToggle?: () => void;
+    /** Whether the knockout panel is expanded */
+    knockoutExpanded?: boolean;
+    /** Callback when knockout panel should be toggled */
+    onKnockoutToggle?: () => void;
+    /** Whether the distress texture panel is expanded */
+    distressTextureExpanded?: boolean;
+    /** Callback when distress texture panel should be toggled */
+    onDistressTextureToggle?: () => void;
+    /** Whether the image mask panel is expanded */
+    imageMaskExpanded?: boolean;
+    /** Callback when image mask panel should be toggled */
+    onImageMaskToggle?: () => void;
+}
+declare const ShapeToolbar: React.FC<ShapeToolbarProps>;
+export default ShapeToolbar;

package/dist/components/ShapeTypeDrawer.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface ShapeTypeDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelectType: (type: string) => void;
+    /** The currently selected shape type (optional, for highlighting) */
+    currentType?: string;
+}
+export declare const ShapeTypeDrawer: React.FC<ShapeTypeDrawerProps>;
+export default ShapeTypeDrawer;

package/dist/components/StrokePanel.d.ts

@@ -0,0 +1,7 @@
+import { StrokeConfig } from '../types/index.js';
+interface StrokePanelProps {
+    stroke?: StrokeConfig;
+    onChange: (stroke: StrokeConfig | undefined) => void;
+}
+declare const StrokePanel: ({ stroke, onChange }: StrokePanelProps) => import("react/jsx-runtime").JSX.Element;
+export default StrokePanel;

package/dist/components/TailwindDemo.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const TailwindDemo: React.FC;
+export default TailwindDemo;

package/dist/components/TextEffectsDropdown.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { TransformType } from '../types/index.js';
+import { TextElement } from '../core/TextElement.js';
+import { ImageElement } from '../core/ImageElement.js';
+import { ShapeElement } from '../core/ShapeElement.js';
+export interface TextEffectsDropdownProps {
+    element: TextElement;
+    onTransformTypeChange: (newType: TransformType) => void;
+    onElementUpdate: (updatedElement: TextElement | ImageElement | ShapeElement) => void;
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export declare const TextEffectsDropdown: React.FC<TextEffectsDropdownProps>;
+export default TextEffectsDropdown;

package/dist/components/TextToolbar.d.ts

@@ -0,0 +1,47 @@
+import { default as React } from 'react';
+import { UseTextToolbarReturn } from '../hooks/useTextToolbar.js';
+import { EditorElement } from '../contexts/EditorContext.js';
+export interface TextToolbarProps {
+    toolbar: UseTextToolbarReturn;
+    stableElementId?: string;
+    viewportWidth?: number;
+    colorPickerValue: string;
+    isColorActive: boolean;
+    onColorToggle: () => void;
+    onOpenGlyphBrowser?: () => void;
+    hasGlyphs?: boolean;
+    expandedPanel: {
+        type: string;
+    } | null;
+    onRotationToggle: () => void;
+    onOpacityToggle: () => void;
+    onFontSizeToggle: () => void;
+    getMoreMenuItems?: () => Array<{
+        label: string;
+        onClick: () => void;
+        icon: React.ReactNode;
+        active?: boolean;
+    }>;
+    strokeExpanded?: boolean;
+    onStrokeToggle?: () => void;
+    knockoutExpanded?: boolean;
+    onKnockoutToggle?: () => void;
+    distressTextureExpanded?: boolean;
+    onDistressTextureToggle?: () => void;
+    imageMaskExpanded?: boolean;
+    onImageMaskToggle?: () => void;
+    onMoveForward: () => void;
+    onMoveBackward: () => void;
+    onDelete: () => void;
+    elementForProperties: EditorElement;
+    elements: EditorElement[];
+    isTransformMenuOpen: boolean;
+    onTransformMenuOpenChange: (open: boolean) => void;
+    elementUpdateHandler: (updatedElement: EditorElement) => void;
+    showUngroupButton?: boolean;
+    onUngroup?: () => void;
+    isFontBrowserOpen?: boolean;
+    onFontBrowserToggle: (isOpen: boolean) => void;
+    onTextMoreMenuOpenChange?: (open: boolean) => void;
+}
+export declare function TextToolbar({ toolbar, stableElementId, viewportWidth, colorPickerValue, isColorActive, onColorToggle, onOpenGlyphBrowser, hasGlyphs, expandedPanel, onRotationToggle, onOpacityToggle, onFontSizeToggle, strokeExpanded, onStrokeToggle, knockoutExpanded, onKnockoutToggle, distressTextureExpanded, onDistressTextureToggle, imageMaskExpanded, onImageMaskToggle, getMoreMenuItems, onMoveForward, onMoveBackward, onDelete, elementForProperties, elements, isTransformMenuOpen, onTransformMenuOpenChange, elementUpdateHandler, showUngroupButton, onUngroup, isFontBrowserOpen, onFontBrowserToggle, onTextMoreMenuOpenChange, }: TextToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TextTypeDrawer.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface TextTypeDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelectType: (type: string) => void;
+}
+export declare const TextTypeDrawer: React.FC<TextTypeDrawerProps>;
+export default TextTypeDrawer;

package/dist/components/ThemeToggle.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const ThemeToggle: React.FC;

package/dist/components/TransformControlPanel.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { TextElement } from '../core/TextElement';
+import { ImageElement } from '../core/ImageElement';
+import { ShapeElement } from '../core/ShapeElement';
+import { TransformControl } from '../types/index.js';
+interface TransformControlPanelProps {
+    element: TextElement | ImageElement | ShapeElement;
+    controls: TransformControl[];
+    onUpdate: (element: TextElement | ImageElement | ShapeElement) => void;
+}
+export declare const TransformControlPanel: React.FC<TransformControlPanelProps>;
+export default TransformControlPanel;