starry-slides 0.1.0

package/dist/editor/components/presenter-view.d.ts

@@ -0,0 +1,13 @@
+export interface PresenterViewProps {
+    slides: {
+        hidden?: boolean;
+        id: string;
+        width: number;
+        height: number;
+        htmlSource: string;
+    }[];
+    startSlideId?: string;
+    onExit: () => void;
+}
+declare function PresenterView({ slides, startSlideId, onExit }: PresenterViewProps): import("react/jsx-runtime").JSX.Element | null;
+export { PresenterView };

package/dist/editor/components/slide-sidebar.d.ts

@@ -0,0 +1,18 @@
+import type { SlideModel } from "../../core";
+interface SlideSidebarProps {
+    slides: SlideModel[];
+    activeSlideId: string;
+    slideCount: number;
+    thumbnails: Record<string, string>;
+    onSelectSlide: (slideId: string) => void;
+    onAdd?: () => void;
+    onAddSlideAbove?: (slideId: string) => void;
+    onAddSlideBelow?: (slideId: string) => void;
+    onDuplicate?: (slideId: string) => void;
+    onDelete?: (slideId: string) => void;
+    onToggleHidden?: (slideId: string) => void;
+    onRename?: (slideId: string, nextTitle: string) => void;
+    onReorder?: (slideId: string, targetIndex: number) => void;
+}
+declare function SlideSidebar({ slides, activeSlideId, slideCount, thumbnails, onSelectSlide, onAdd, onAddSlideAbove, onAddSlideBelow, onDuplicate, onDelete, onToggleHidden, onRename, onReorder, }: SlideSidebarProps): import("react/jsx-runtime").JSX.Element;
+export { SlideSidebar };

package/dist/editor/components/stage-canvas.d.ts

@@ -0,0 +1,77 @@
+import type { MouseEvent as ReactMouseEvent, RefObject } from "react";
+import type { EditableType, StageRect } from "../../core";
+import type { CssPropertyRow } from "../lib/collect-css-properties";
+import { type SelectionCommandAvailability } from "./floating-toolbar";
+type ResizeHandleCorner = "top-left" | "top-right" | "bottom-right" | "bottom-left";
+interface StageCanvasProps {
+    slideWidth: number;
+    slideHeight: number;
+    offsetX: number;
+    offsetY: number;
+    scale: number;
+    preselectionOverlay: StageRect | null;
+    selectionOverlay: StageRect | null;
+    toolbarKey: string | null;
+    inspectedStyles: CssPropertyRow[];
+    selectedElementType: EditableType | "multi";
+    selectionCommandAvailability: SelectionCommandAvailability;
+    groupScopeOverlayPassive: boolean;
+    isEditingText: boolean;
+    manipulationOverlay: {
+        selectionBounds: StageRect;
+        snapGuides: Array<{
+            orientation: "vertical" | "horizontal";
+            start: {
+                x: number;
+                y: number;
+            };
+            end: {
+                x: number;
+                y: number;
+            };
+            variant: "alignment" | "spacing";
+        }>;
+        resizeHandles: Array<{
+            corner: ResizeHandleCorner;
+            x: number;
+            y: number;
+        }>;
+        rotationHandle: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    attributeValues: {
+        locked: string;
+        altText: string;
+        ariaLabel: string;
+        linkUrl: string;
+    };
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    stageViewportRef: RefObject<HTMLDivElement | null>;
+    selectionOverlayRef: RefObject<HTMLDivElement | null>;
+    selectionContextMenuTriggerRef: RefObject<HTMLSpanElement | null>;
+    isManipulating: boolean;
+    isToolbarSuppressed: boolean;
+    onSelectionOverlayMouseDown: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseUp: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseMove: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onStageMouseLeave: () => void;
+    onResizeHandleMouseDown: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onRotateHandleMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onSelectionOverlayDoubleClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onBackgroundClick: () => void;
+    onStageWheel: (event: WheelEvent) => void;
+    onStyleChange: (propertyName: string, nextValue: string) => void;
+    onAttributeChange: (attributeName: string, nextValue: string) => void;
+    onAlignToSlide: (action: string) => void;
+    onDistribute: (action: string) => void;
+    onGroup: () => void;
+    onLayerOrder: (action: string) => void;
+    onUngroup: () => void;
+    onDuplicate: () => void;
+    onDelete: () => void;
+}
+declare function StageCanvas({ slideWidth, slideHeight, offsetX, offsetY, scale, preselectionOverlay, selectionOverlay, toolbarKey, inspectedStyles, selectedElementType, selectionCommandAvailability, groupScopeOverlayPassive, isEditingText, manipulationOverlay, attributeValues, iframeRef, stageViewportRef, selectionOverlayRef, selectionContextMenuTriggerRef, isManipulating, isToolbarSuppressed, onSelectionOverlayMouseDown, onSelectionOverlayMouseUp, onSelectionOverlayMouseMove, onSelectionOverlayContextMenu, onStageMouseLeave, onResizeHandleMouseDown, onRotateHandleMouseDown, onSelectionOverlayDoubleClick, onBackgroundClick, onStageWheel, onStyleChange, onAttributeChange, onAlignToSlide, onDistribute, onGroup, onLayerOrder, onUngroup, onDuplicate, onDelete, }: StageCanvasProps): import("react/jsx-runtime").JSX.Element;
+export { StageCanvas };

package/dist/editor/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import { Accordion as AccordionPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Accordion({ ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/editor/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/editor/components/ui/context-menu.d.ts

@@ -0,0 +1,25 @@
+import { ContextMenu as ContextMenuPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function ContextMenu({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuTrigger({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuPortal({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSub({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, };

package/dist/editor/components/ui/dialog.d.ts

@@ -0,0 +1,10 @@
+import { Dialog as DialogPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DialogContent({ children, className, ...props }: React.ComponentProps<typeof DialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, };

package/dist/editor/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import type * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+export { Input };

package/dist/editor/components/ui/popover.d.ts

@@ -0,0 +1,10 @@
+import { Popover as PopoverPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor, PopoverHeader, PopoverTitle, PopoverDescription, };

package/dist/editor/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import { ScrollArea as ScrollAreaPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): import("react/jsx-runtime").JSX.Element;
+export { ScrollArea, ScrollBar };

package/dist/editor/components/ui/select.d.ts

@@ -0,0 +1,15 @@
+import { Select as SelectPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, align, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/editor/components/ui/separator.d.ts

@@ -0,0 +1,4 @@
+import { Separator as SeparatorPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Separator };

package/dist/editor/components/ui/tabs.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+import { Tabs as TabsPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Tabs({ className, orientation, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "line" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, ...props }: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/dist/editor/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import type * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/dist/editor/components/ui/toggle-group.d.ts

@@ -0,0 +1,9 @@
+import type { VariantProps } from "class-variance-authority";
+import { ToggleGroup as ToggleGroupPrimitive } from "radix-ui";
+import * as React from "react";
+import { toggleVariants } from "./toggle";
+declare function ToggleGroup({ className, variant, size, spacing, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { ToggleGroup, ToggleGroupItem };

package/dist/editor/components/ui/toggle.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from "class-variance-authority";
+import { Toggle as TogglePrimitive } from "radix-ui";
+import type * as React from "react";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { Toggle, toggleVariants };

package/dist/editor/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/editor/editor-operations.d.ts

@@ -0,0 +1,15 @@
+import { type AttributeUpdateOperation, type SlideModel, type StyleUpdateOperation } from "../core";
+export declare function getInlineStyleValue(slide: SlideModel, elementId: string, propertyName: string): string;
+export declare function getHtmlAttributeValue(slide: SlideModel, elementId: string, attributeName: string): string;
+export declare function createStyleUpdateOperation({ elementId, nextValue, propertyName, slide, }: {
+    elementId: string;
+    nextValue: string;
+    propertyName: string;
+    slide: SlideModel;
+}): StyleUpdateOperation | null;
+export declare function createAttributeUpdateOperation({ attributeName, elementId, nextValue, slide, }: {
+    attributeName: string;
+    elementId: string;
+    nextValue: string;
+    slide: SlideModel;
+}): AttributeUpdateOperation | null;

package/dist/editor/hooks/block-manipulation-geometry.d.ts

@@ -0,0 +1,16 @@
+import type { EditableElement, StageRect } from "../../core";
+import type { ResizeHandleCorner } from "../lib/block-snap-types";
+export declare function px(value: number): string;
+export declare function clampSize(value: number): number;
+export declare function clampStageSize(value: number, scale: number): number;
+export declare function isLayoutEditable(element: EditableElement | undefined): boolean;
+export declare function isManipulable(element: EditableElement | undefined): boolean;
+export declare function unionStageRects(rects: StageRect[]): StageRect;
+export declare function getRotationDeltaDegrees(pointerX: number, pointerY: number, centerX: number, centerY: number): number;
+export declare function createResizedStageRect({ resizeCorner, scale, stageDeltaX, stageDeltaY, startStageRect, }: {
+    resizeCorner: ResizeHandleCorner | null;
+    scale: number;
+    stageDeltaX: number;
+    stageDeltaY: number;
+    startStageRect: StageRect;
+}): StageRect;

package/dist/editor/hooks/block-manipulation-operations.d.ts

@@ -0,0 +1,10 @@
+import { type AtomicSlideOperation, type ElementLayoutStyleSnapshot, type ElementLayoutUpdateOperation } from "../../core";
+import type { ManipulationSession } from "./block-manipulation-types";
+export declare function applyLayoutSnapshot(node: HTMLElement, snapshot: ElementLayoutStyleSnapshot): void;
+export declare function createLayoutUpdateOperations(session: ManipulationSession): ElementLayoutUpdateOperation[];
+export declare function toLayoutCommitOperation(session: ManipulationSession, operations: ElementLayoutUpdateOperation[]): ElementLayoutUpdateOperation | {
+    type: "operation.batch";
+    slideId: string;
+    operations: AtomicSlideOperation[];
+    timestamp: number;
+};

package/dist/editor/hooks/block-manipulation-overlay.d.ts

@@ -0,0 +1,11 @@
+import type { EditableElement, StageRect } from "../../core";
+import type { SnapGuide } from "../lib/block-snap-types";
+import type { BlockManipulationOverlay } from "./block-manipulation-types";
+export declare function createBlockManipulationOverlay({ isEditingText, isManipulating, selectedElement, selectedElementId, snapGuides, stageRect, }: {
+    isEditingText: boolean;
+    isManipulating: boolean;
+    selectedElement: EditableElement | undefined;
+    selectedElementId: string | null;
+    snapGuides: SnapGuide[];
+    stageRect: StageRect | null;
+}): BlockManipulationOverlay | null;

package/dist/editor/hooks/block-manipulation-types.d.ts

@@ -0,0 +1,73 @@
+import type { RefObject } from "react";
+import type { EditableElement, ElementLayoutStyleSnapshot, ElementLayoutUpdateOperation, SlideBatchOperation, SlideModel, StageGeometry, StageRect } from "../../core";
+import type { ResizeHandleCorner, SnapGuide, SnapTarget } from "../lib/block-snap-types";
+export type ManipulationMode = "move" | "resize" | "rotate";
+export interface BlockManipulationOverlay {
+    selectionBounds: StageRect;
+    snapGuides: SnapGuide[];
+    resizeHandles: Array<{
+        corner: ResizeHandleCorner;
+        x: number;
+        y: number;
+    }>;
+    rotationHandle: {
+        x: number;
+        y: number;
+    };
+}
+export interface ManipulationSession {
+    slideId: string;
+    elementId: string;
+    elementIds: string[];
+    mode: ManipulationMode;
+    resizeCorner: ResizeHandleCorner | null;
+    startPointer: {
+        x: number;
+        y: number;
+    };
+    startStageRect: StageRect;
+    centerPoint: {
+        x: number;
+        y: number;
+    };
+    previousStyle: ElementLayoutStyleSnapshot;
+    previousStyles: Record<string, ElementLayoutStyleSnapshot>;
+    startElementStageRects: Record<string, StageRect>;
+    resizeParentElementIds: Record<string, string | null>;
+    startParentStageRects: Record<string, StageRect>;
+    targetNodes: Record<string, HTMLElement>;
+    snapTargets: {
+        vertical: SnapTarget[];
+        horizontal: SnapTarget[];
+    };
+}
+export interface UseBlockManipulationOptions {
+    activeSlide: SlideModel | undefined;
+    selectedElement: EditableElement | undefined;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    selectedStageRect: StageRect | null;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    stageGeometry: StageGeometry;
+    isEditingText: boolean;
+    onCommitOperation: (operation: ElementLayoutUpdateOperation | SlideBatchOperation) => void;
+}
+export interface UseBlockManipulationResult {
+    manipulationOverlay: BlockManipulationOverlay | null;
+    isManipulating: boolean;
+    suppressBackgroundClear: boolean;
+    beginMove: (event: PointerStartLike, targetElementId?: string) => void;
+    beginResize: (corner: ResizeHandleCorner, event: PointerStartLike) => void;
+    beginRotate: (event: PointerStartLike) => void;
+}
+export interface PointerStartLike {
+    clientX: number;
+    clientY: number;
+    sourceWindow?: Window | null;
+    toStagePoint?: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    };
+    preventDefault: () => void;
+    stopPropagation: () => void;
+}

package/dist/editor/hooks/editor-keyboard-geometry.d.ts

@@ -0,0 +1,22 @@
+import type { RefObject } from "react";
+import type { SlideModel } from "../../core";
+import type { SlideRect } from "./editor-keyboard-types";
+export declare function roundCssNumber(value: number): number;
+export declare function placeCopiedElement(elementHtml: string, rect: SlideRect): string;
+export declare function elementRectToSlideRect(elementRect: DOMRect, rootRect: DOMRect): SlideRect;
+export declare function getSlideBounds(iframeRef: RefObject<HTMLIFrameElement | null>, activeSlide: SlideModel, fallback: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+};
+export declare function offsetSlideRect(rect: SlideRect, offsetX: number, offsetY: number): SlideRect;
+export declare function getUnionRect(rects: SlideRect[]): SlideRect | null;
+export declare function getClampedPasteDelta(sourceRect: SlideRect, preferredOffset: number, slide: {
+    width: number;
+    height: number;
+}): {
+    x: number;
+    y: number;
+};

package/dist/editor/hooks/editor-keyboard-operations.d.ts

@@ -0,0 +1,10 @@
+import type { AtomicSlideOperation, EditableElement, SlideOperation } from "../../core";
+export declare const ARROW_DELTAS: Record<string, {
+    x: number;
+    y: number;
+}>;
+export declare function isEditableElementTarget(target: EventTarget | null): boolean;
+export declare function isLayoutEditable(element: EditableElement | undefined): boolean;
+export declare function getShortcutStep(event: KeyboardEvent): number;
+export declare function createIdMapForCopiedElement(html: string, sourceElementId: string, nextElementId: string): Record<string, string>;
+export declare function commitOperations(slideId: string, operations: AtomicSlideOperation[], onCommitOperation: (operation: SlideOperation) => void): boolean;

package/dist/editor/hooks/editor-keyboard-types.d.ts

@@ -0,0 +1,35 @@
+import type { RefObject } from "react";
+import type { ElementInsertOperation, ElementLayoutUpdateOperation, ElementRemoveOperation, SlideModel, SlideOperation } from "../../core";
+export interface ClipboardPayload {
+    elements: Array<{
+        sourceElementId: string;
+        html: string;
+        rect: SlideRect;
+        parentElementId: string | null;
+        previousSiblingElementId: string | null;
+        nextSiblingElementId: string | null;
+    }>;
+    unionRect: SlideRect;
+}
+export interface SlideRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface UseEditorKeyboardShortcutsOptions {
+    activeSlide: SlideModel | undefined;
+    selectedElementIds: string[];
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    slideWidth: number;
+    slideHeight: number;
+    isEditingText: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onEscapeSelection: () => boolean;
+    onNavigateSlide: (direction: "previous" | "next") => boolean;
+    onCommitOperation: (operation: ElementInsertOperation | ElementLayoutUpdateOperation | ElementRemoveOperation | SlideOperation) => void;
+    onSelectElementIds: (elementIds: string[]) => void;
+    onUndo: () => void;
+    onRedo: () => void;
+}

package/dist/editor/hooks/iframe-editing-session.d.ts

@@ -0,0 +1,10 @@
+export declare function nextSingleSelection(value: string | null): string[];
+export declare function ensureSelectionContainsTarget(currentIds: string[], targetId: string): string[];
+export declare function clearSelectionForEscape({ selectedElementIds, activeGroupScopeId, }: {
+    selectedElementIds: string[];
+    activeGroupScopeId: string | null;
+}): {
+    handled: boolean;
+    nextSelection: string[];
+    exitGroupScope: boolean;
+};

package/dist/editor/hooks/iframe-text-editing-dom.d.ts

@@ -0,0 +1,6 @@
+export declare function getEditableSelectionTarget(target: Element): HTMLElement | null;
+export declare function getDeepestEditableElementFromPoint(doc: Document, x: number, y: number, activeGroupScopeId: string | null): HTMLElement | null;
+export declare function applyGroupScopeFocus(doc: Document, activeGroupScopeId: string | null): void;
+export declare function getEditableSelectionTargetInScope(target: Element, activeGroupScopeId: string | null): HTMLElement | null;
+export declare function ensureEditingTextStyle(doc: Document): void;
+export declare function selectEditableNodeEnd(editableNode: HTMLElement): void;

package/dist/editor/hooks/iframe-text-editing-types.d.ts

@@ -0,0 +1,38 @@
+import type { Dispatch, RefObject, SetStateAction } from "react";
+import type { SlideModel, TextUpdateOperation } from "../../core";
+export interface TextEditingState {
+    slideId: string;
+    elementId: string;
+    initialText: string;
+}
+export interface UseIframeTextEditingOptions {
+    activeSlide: SlideModel | undefined;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    onCommitOperation: (operation: TextUpdateOperation) => void;
+    onOpenSelectionContextMenu?: (clientX: number, clientY: number) => void;
+    onStageWheel?: (event: WheelEvent) => void;
+    onBeginPointerMove?: (elementId: string, clientX: number, clientY: number, pointerOptions?: {
+        sourceWindow?: Window | null;
+        toStagePoint?: (clientX: number, clientY: number) => {
+            x: number;
+            y: number;
+        };
+    }) => void;
+}
+export interface UseIframeTextEditingResult {
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    preselectedElementId: string | null;
+    activeGroupScopeId: string | null;
+    isEditingText: boolean;
+    setSelectedElementId: Dispatch<SetStateAction<string | null>>;
+    setSelectedElementIds: Dispatch<SetStateAction<string[]>>;
+    beginTextEditing: (elementId: string) => void;
+    beginGroupEditingScope: (elementId: string) => void;
+    exitGroupEditingScope: () => void;
+    clearSelection: () => boolean;
+    clearPreselection: () => void;
+    updatePointerPreselection: (clientX: number, clientY: number) => string | null;
+    retargetPointerSelection: (clientX: number, clientY: number, additive: boolean) => string | null;
+    openPointerSelectionContextMenu: (clientX: number, clientY: number) => boolean;
+}

package/dist/editor/hooks/object-clipboard-commands.d.ts

@@ -0,0 +1,28 @@
+import type { RefObject } from "react";
+import { type ElementInsertOperation, type ElementRemoveOperation, type SlideModel } from "../../core";
+import { commitOperations } from "./editor-keyboard-operations";
+import type { ClipboardPayload } from "./editor-keyboard-types";
+export declare function copyObjectSelection({ slide, selectedElementIds, iframeRef, }: {
+    slide: SlideModel | undefined;
+    selectedElementIds: string[];
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+}): ClipboardPayload | null;
+export declare function createRemoveObjectSelectionOperations({ slide, selectedElementIds, }: {
+    slide: SlideModel | undefined;
+    selectedElementIds: string[];
+}): ElementRemoveOperation[];
+export declare function createPasteObjectSelection({ slide, payload, iframeRef, slideSize, }: {
+    slide: SlideModel | undefined;
+    payload: ClipboardPayload | null;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    slideSize: {
+        width: number;
+        height: number;
+    };
+}): {
+    operations: ElementInsertOperation[];
+    selectedElementIds: string[];
+    nextClipboard: ClipboardPayload;
+    nextHtmlSource: string;
+} | null;
+export declare function commitObjectOperations(slideId: string, operations: ElementInsertOperation[] | ElementRemoveOperation[], onCommitOperation: Parameters<typeof commitOperations>[2]): boolean;

package/dist/editor/hooks/use-block-manipulation.d.ts

@@ -0,0 +1,3 @@
+import type { UseBlockManipulationOptions, UseBlockManipulationResult } from "./block-manipulation-types";
+declare function useBlockManipulation({ activeSlide, selectedElement, selectedElementId, selectedElementIds, selectedStageRect, iframeRef, stageGeometry, isEditingText, onCommitOperation, }: UseBlockManipulationOptions): UseBlockManipulationResult;
+export { useBlockManipulation };

package/dist/editor/hooks/use-editor-keyboard-shortcuts.d.ts

@@ -0,0 +1,3 @@
+import type { UseEditorKeyboardShortcutsOptions } from "./editor-keyboard-types";
+declare function useEditorKeyboardShortcuts({ activeSlide, selectedElementIds, iframeRef, slideWidth, slideHeight, isEditingText, canUndo, canRedo, onEscapeSelection, onNavigateSlide, onCommitOperation, onSelectElementIds, onUndo, onRedo, }: UseEditorKeyboardShortcutsOptions): void;
+export { useEditorKeyboardShortcuts };

package/dist/editor/hooks/use-iframe-text-editing.d.ts

@@ -0,0 +1,3 @@
+import type { UseIframeTextEditingOptions, UseIframeTextEditingResult } from "./iframe-text-editing-types";
+declare function useIframeTextEditing({ activeSlide, iframeRef, onCommitOperation, onOpenSelectionContextMenu, onStageWheel, onBeginPointerMove, }: UseIframeTextEditingOptions): UseIframeTextEditingResult;
+export { useIframeTextEditing };

package/dist/editor/hooks/use-slide-history.d.ts

@@ -0,0 +1,17 @@
+import { type SlideModel, type SlideOperation } from "../../core";
+interface SlideHistoryResult {
+    slides: SlideModel[];
+    activeSlide: SlideModel | undefined;
+    activeSlideId: string;
+    undoDepth: number;
+    redoDepth: number;
+    setActiveSlideId: (slideId: string) => void;
+    commitOperation: (operation: SlideOperation) => SlideModel[];
+    runUndo: () => void;
+    runRedo: () => void;
+}
+interface UseSlideHistoryOptions {
+    onSlidesChange?: (slides: SlideModel[]) => void;
+}
+declare function useSlideHistory(loadedSlides: SlideModel[], options?: UseSlideHistoryOptions): SlideHistoryResult;
+export { useSlideHistory };

package/dist/editor/hooks/use-slide-inspector.d.ts

@@ -0,0 +1,24 @@
+import type { RefObject } from "react";
+import { type EditableElement, type SlideModel, type StageRect } from "../../core";
+import { type CssPropertyRow } from "../lib/collect-css-properties";
+interface UseSlideInspectorOptions {
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    activeSlide: SlideModel | undefined;
+    selectedElement: EditableElement | undefined;
+    selectedElementIds: string[];
+    preselectedElementId: string | null;
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+    slideWidth: number;
+    slideHeight: number;
+}
+interface SlideInspectorResult {
+    selectedStageRect: StageRect | null;
+    preselectionOverlay: StageRect | null;
+    selectionOverlay: StageRect | null;
+    selectionLabel: string;
+    inspectedStyles: CssPropertyRow[];
+}
+declare function useSlideInspector({ iframeRef, activeSlide, selectedElement, selectedElementIds, preselectedElementId, scale, offsetX, offsetY, slideWidth, slideHeight, }: UseSlideInspectorOptions): SlideInspectorResult;
+export { useSlideInspector };

package/dist/editor/hooks/use-slide-thumbnails.d.ts

@@ -0,0 +1,2 @@
+import type { SlideModel } from "../../core";
+export declare function useSlideThumbnails(slides: SlideModel[]): Record<string, string>;