@starrykit/slides-editor 0.1.26

package/dist/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/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/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/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/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/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/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-operations.d.ts

@@ -0,0 +1,17 @@
+import { type AttributeUpdateOperation, type SlideModel, type StyleUpdateOperation } from "@starrykit/slides-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 getLockedSlideElementId(slide: SlideModel, elementId: string): string | null | undefined;
+export declare function isSlideElementLocked(slide: SlideModel, elementId: string): boolean;
+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/hooks/block-manipulation-geometry.d.ts

@@ -0,0 +1,27 @@
+import { type EditableElement, type SlideModel, type StageGeometry, type StageRect } from "@starrykit/slides-core";
+import type { ResizeHandlePosition } from "../lib/block-snap-types";
+import type { ManipulationSession } from "./block-manipulation-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({ resizeHandle, scale, stageDeltaX, stageDeltaY, startStageRect, }: {
+    resizeHandle: ResizeHandlePosition | null;
+    scale: number;
+    stageDeltaX: number;
+    stageDeltaY: number;
+    startStageRect: StageRect;
+}): StageRect;
+export declare function getManipulationElementIds({ activeSlide, doc, mode, selectedElementId, selectedElementIds, }: {
+    activeSlide: SlideModel;
+    doc: Document;
+    mode: "move" | "resize" | "rotate";
+    selectedElementId: string;
+    selectedElementIds: string[];
+}): string[];
+export declare function getResizeParentElementId(node: HTMLElement, targetNodes: Record<string, HTMLElement>): string | null;
+export declare function applyGeometryScaledResize(session: ManipulationSession, nextSelectionRect: StageRect, geometry: StageGeometry): void;
+export declare function getParentStageRectKey(node: HTMLElement | null): string;

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

@@ -0,0 +1,10 @@
+import { type AtomicSlideOperation, type ElementLayoutStyleSnapshot, type ElementLayoutUpdateOperation } from "@starrykit/slides-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/hooks/block-manipulation-overlay.d.ts

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

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

@@ -0,0 +1,81 @@
+import type { EditableElement, ElementLayoutStyleSnapshot, ElementLayoutUpdateOperation, SlideBatchOperation, SlideModel, StageGeometry, StageRect } from "@starrykit/slides-core";
+import type { RefObject } from "react";
+import type { ResizeHandleCorner, ResizeHandlePosition, SnapGuide, SnapTarget } from "../lib/block-snap-types";
+export type ManipulationMode = "move" | "resize" | "rotate";
+export interface BlockManipulationOverlay {
+    selectionBounds: StageRect;
+    snapGuides: SnapGuide[];
+    resizeHandles: Array<{
+        position: ResizeHandlePosition;
+        x: number;
+        y: number;
+    }>;
+    rotationZones: Array<{
+        corner: ResizeHandleCorner;
+        x: number;
+        y: number;
+    }>;
+}
+export interface ManipulationSession {
+    slideId: string;
+    elementId: string;
+    elementIds: string[];
+    mode: ManipulationMode;
+    resizeHandle: ResizeHandlePosition | null;
+    startPointer: {
+        x: number;
+        y: number;
+    };
+    startStageRect: StageRect;
+    centerPoint: {
+        x: number;
+        y: number;
+    };
+    previousStyle: ElementLayoutStyleSnapshot;
+    previousStyles: Record<string, ElementLayoutStyleSnapshot>;
+    startComputedMargins: Record<string, {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    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;
+    isElementLocked: (elementId: string) => boolean;
+}
+export interface UseBlockManipulationResult {
+    manipulationOverlay: BlockManipulationOverlay | null;
+    isManipulating: boolean;
+    suppressBackgroundClear: boolean;
+    beginMove: (event: PointerStartLike, targetElementId?: string) => void;
+    beginResize: (position: ResizeHandlePosition, 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/hooks/editor-keyboard-geometry.d.ts

@@ -0,0 +1,22 @@
+import type { SlideModel } from "@starrykit/slides-core";
+import type { RefObject } from "react";
+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/hooks/editor-keyboard-operations.d.ts

@@ -0,0 +1,11 @@
+import { type AtomicSlideOperation, type EditableElement, type SlideOperation } from "@starrykit/slides-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 getAllSelectableElementIds(doc: Document | null | undefined): string[];
+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/hooks/editor-keyboard-types.d.ts

@@ -0,0 +1,38 @@
+import type { ElementInsertOperation, ElementLayoutUpdateOperation, ElementRemoveOperation, SlideModel, SlideOperation } from "@starrykit/slides-core";
+import type { RefObject } from "react";
+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[];
+    lockedElementIds: string[];
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    slideWidth: number;
+    slideHeight: number;
+    isEditingText: boolean;
+    isSidebarFocused: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onEscapeSelection: () => boolean;
+    onNavigateSlide: (direction: "previous" | "next") => boolean;
+    onCommitOperation: (operation: ElementInsertOperation | ElementLayoutUpdateOperation | ElementRemoveOperation | SlideOperation) => void;
+    onSelectElementIds: (elementIds: string[]) => void;
+    onDeleteSlide: (slideId: string) => boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+}

package/dist/hooks/iframe-active-text-session.d.ts

@@ -0,0 +1,12 @@
+import { type SlideModel } from "@starrykit/slides-core";
+import { type RefObject } from "react";
+import type { TextEditingState } from "./iframe-text-editing-types";
+declare function useActiveTextEditingSession({ activeSlide, cancelTextEditRef, commitTextEditRef, iframeRef, textEditing, textEditingRef, }: {
+    activeSlide: SlideModel | undefined;
+    cancelTextEditRef: RefObject<() => void>;
+    commitTextEditRef: RefObject<(elementId: string, nextText: string) => void>;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    textEditing: TextEditingState | null;
+    textEditingRef: RefObject<TextEditingState | null>;
+}): void;
+export { useActiveTextEditingSession };

package/dist/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/hooks/iframe-text-document-events.d.ts

@@ -0,0 +1,26 @@
+import { type SlideModel } from "@starrykit/slides-core";
+import { type RefObject } from "react";
+import type { TextEditingState } from "./iframe-text-editing-types";
+interface UseIframeTextDocumentEventsOptions {
+    activeGroupScopeIdRef: RefObject<string | null>;
+    activeSlide: SlideModel | undefined;
+    beginGroupEditingScope: (elementId: string) => void;
+    beginTextEditing: (elementId: string) => void;
+    clearPreselection: () => void;
+    commitTextEditRef: RefObject<(elementId: string, nextText: string) => void>;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    isElementLocked?: (elementId: string) => boolean;
+    onBeginPointerMove?: (elementId: string, clientX: number, clientY: number, pointerOptions?: {
+        sourceWindow?: Window | null;
+        toStagePoint?: (clientX: number, clientY: number) => {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    openPointerSelectionContextMenu: (clientX: number, clientY: number) => boolean;
+    setPreselectedElementId: (updater: (currentId: string | null) => string | null) => void;
+    setSelectedElementIds: (updater: string[] | ((currentIds: string[]) => string[])) => void;
+    textEditingRef: RefObject<TextEditingState | null>;
+}
+declare function useIframeTextDocumentEvents({ activeGroupScopeIdRef, activeSlide, beginGroupEditingScope, beginTextEditing, clearPreselection, commitTextEditRef, iframeRef, isElementLocked, onBeginPointerMove, openPointerSelectionContextMenu, setPreselectedElementId, setSelectedElementIds, textEditingRef, }: UseIframeTextDocumentEventsOptions): void;
+export { useIframeTextDocumentEvents };

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

@@ -0,0 +1,12 @@
+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 getOutermostSelectedAncestorFromPoint(doc: Document, x: number, y: number, activeGroupScopeId: string | null, selectedElementIds: string[]): 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 setNativeTextSelectionEnabled(doc: Document, enabled: boolean): void;
+export declare function selectEditableNodeEnd(editableNode: HTMLElement): void;
+export declare function getEditableTextTargetFromPoint(doc: Document, point: {
+    x: number;
+    y: number;
+}, activeScopeId: string | null): HTMLElement | null;

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

@@ -0,0 +1,38 @@
+import type { SlideModel, TextUpdateOperation } from "@starrykit/slides-core";
+import type { Dispatch, RefObject, SetStateAction } from "react";
+export interface TextEditingState {
+    slideId: string;
+    elementId: string;
+    initialText: string;
+}
+export interface UseIframeTextEditingOptions {
+    activeSlide: SlideModel | undefined;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    onCommitOperation: (operation: TextUpdateOperation) => void;
+    isElementLocked?: (elementId: string) => boolean;
+    onOpenSelectionContextMenu?: (clientX: number, clientY: number) => 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/hooks/object-clipboard-commands.d.ts

@@ -0,0 +1,28 @@
+import { type ElementInsertOperation, type ElementRemoveOperation, type SlideModel } from "@starrykit/slides-core";
+import type { RefObject } from "react";
+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/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, isElementLocked, }: UseBlockManipulationOptions): UseBlockManipulationResult;
+export { useBlockManipulation };

package/dist/hooks/use-editor-element-actions.d.ts

@@ -0,0 +1,42 @@
+import type { SlideModel, SlideOperation, StageRect } from "@starrykit/slides-core";
+import type { RefObject } from "react";
+interface UseEditorElementActionsOptions {
+    activeSlide: SlideModel | undefined;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    isSelectedElementLocked: boolean;
+    selectionOverlay: StageRect | null;
+    stage: {
+        offsetX: number;
+        offsetY: number;
+        scale: number;
+        width: number;
+        height: number;
+    };
+    onCommitOperation: (operation: SlideOperation) => void;
+    onSelectElementIds: (elementIds: string[]) => void;
+    onLockedElementIdsBySlideIdChange: (updater: (current: Record<string, string[]>) => Record<string, string[]>) => void;
+}
+declare function useEditorElementActions({ activeSlide, iframeRef, selectedElementId, selectedElementIds, isSelectedElementLocked, selectionOverlay, stage, onCommitOperation, onSelectElementIds, onLockedElementIdsBySlideIdChange, }: UseEditorElementActionsOptions): {
+    attributeValues: {
+        locked: string;
+        ariaLabel: string;
+        linkUrl: string;
+    };
+    commitStyleChange: (propertyName: string, nextValue: string) => void;
+    commitStyleChanges: (changes: Array<{
+        propertyName: string;
+        nextValue: string;
+    }>) => void;
+    previewStyleChange: (propertyName: string, nextValue: string | null) => void;
+    commitAttributeChange: (attributeName: string, nextValue: string) => void;
+    commitLayerAction: (action: string) => void;
+    duplicateSelection: () => void;
+    deleteSelection: () => void;
+    groupSelection: () => void;
+    ungroupSelection: () => void;
+    commitArrangeAction: (action: string) => void;
+    distributeSelection: (action: string) => void;
+};
+export { useEditorElementActions };

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

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

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

@@ -0,0 +1,21 @@
+import type { SlideModel, SlideOperation } from "@starrykit/slides-core";
+interface UseEditorSlideActionsOptions {
+    slides: SlideModel[];
+    activeSlide: SlideModel | undefined;
+    activeSlideId: string;
+    onCommitOperation: (operation: SlideOperation) => void;
+    onActiveSlideChange: (slideId: string) => void;
+    onClearSelection: () => void;
+}
+declare function useEditorSlideActions({ slides, activeSlide, activeSlideId, onCommitOperation, onActiveSlideChange, onClearSelection, }: UseEditorSlideActionsOptions): {
+    selectSlideByDirection: (direction: "previous" | "next") => boolean;
+    addSlideAfterActive: () => void;
+    addSlideAbove: (slideId: string) => void;
+    addSlideBelow: (slideId: string) => void;
+    duplicateSlide: (slideId: string) => void;
+    deleteSlide: (slideId: string) => boolean;
+    toggleSlideHidden: (slideId: string) => void;
+    renameSlide: (slideId: string, nextTitle: string) => void;
+    reorderSlide: (slideId: string, targetIndex: number) => void;
+};
+export { useEditorSlideActions };

package/dist/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, isElementLocked, onOpenSelectionContextMenu, onBeginPointerMove, }: UseIframeTextEditingOptions): UseIframeTextEditingResult;
+export { useIframeTextEditing };

package/dist/hooks/use-image-crop.d.ts

@@ -0,0 +1,40 @@
+import type { SlideModel, SlideOperation, StageRect } from "@starrykit/slides-core";
+import type { MouseEvent as ReactMouseEvent, RefObject } from "react";
+import type { ResizeHandleCorner } from "../lib/block-snap-types";
+import { type CropRadii } from "../lib/image-crop";
+interface UseImageCropOptions {
+    activeSlide: SlideModel | undefined;
+    selectedElementId: string | null;
+    selectedElementType: string;
+    selectedStageRect: StageRect | null;
+    stageGeometry: {
+        scale: number;
+        offsetX: number;
+        offsetY: number;
+        slideWidth: number;
+        slideHeight: number;
+    };
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    isEditingText: boolean;
+    isSelectedElementLocked: boolean;
+    onCommitOperation: (operation: SlideOperation) => void;
+}
+interface ImageCropOverlay {
+    cropBounds: StageRect;
+    cropRadii: CropRadii;
+    selectionBounds: StageRect;
+    handles: Array<{
+        corner: ResizeHandleCorner;
+        x: number;
+        y: number;
+    }>;
+}
+declare function useImageCrop({ activeSlide, selectedElementId, selectedElementType, selectedStageRect, stageGeometry, iframeRef, isEditingText, isSelectedElementLocked, onCommitOperation, }: UseImageCropOptions): {
+    beginCropMode: () => void;
+    beginCropResize: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    cropOverlay: ImageCropOverlay | null;
+    exitCropMode: () => void;
+    isCropMode: boolean;
+};
+export { useImageCrop };
+export type { ImageCropOverlay };

package/dist/hooks/use-marquee-selection.d.ts

@@ -0,0 +1,17 @@
+import { type SlideModel, type StageGeometry, type StageRect } from "@starrykit/slides-core";
+import { type Dispatch, type RefObject, type SetStateAction } from "react";
+interface UseMarqueeSelectionOptions {
+    activeGroupScopeId: string | null;
+    activeSlide: SlideModel | undefined;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    isEditingText: boolean;
+    onClearPreselection: () => void;
+    onSelectElementIds: Dispatch<SetStateAction<string[]>>;
+    selectedElementIds: string[];
+    stageGeometry: StageGeometry;
+}
+export declare function useMarqueeSelection({ activeGroupScopeId, activeSlide, iframeRef, isEditingText, onClearPreselection, onSelectElementIds, selectedElementIds, stageGeometry, }: UseMarqueeSelectionOptions): {
+    marqueeOverlay: StageRect | null;
+    isMarqueeSelecting: boolean;
+};
+export {};

package/dist/hooks/use-selection-overlay-actions.d.ts

@@ -0,0 +1,41 @@
+import { type EditableElement } from "@starrykit/slides-core";
+import type { MouseEvent as ReactMouseEvent, RefObject } from "react";
+import type { ResizeHandlePosition } from "../lib/block-snap-types";
+import type { PointerStartLike } from "./block-manipulation-types";
+interface OverlayPointerDown {
+    clientX: number;
+    clientY: number;
+    additive: boolean;
+    targetElementId: string | null;
+}
+interface UseSelectionOverlayActionsOptions {
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    selectedElement: EditableElement | undefined;
+    activeGroupScopeId: string | null;
+    isSelectedElementLocked: boolean;
+    suppressBackgroundClear: boolean;
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    overlayPointerDownRef: RefObject<OverlayPointerDown | null>;
+    onToolbarSuppressedChange: (suppressed: boolean) => void;
+    onPointerPreselectionUpdate: (clientX: number, clientY: number) => string | null;
+    onPointerSelectionRetarget: (clientX: number, clientY: number, additive: boolean) => void;
+    onSelectionContextMenuOpen: (clientX: number, clientY: number) => void;
+    onBeginMove: (event: PointerStartLike, targetElementId?: string) => void;
+    onBeginResize: (position: ResizeHandlePosition, event: PointerStartLike) => void;
+    onBeginRotate: (event: PointerStartLike) => void;
+    onBeginTextEditing: (elementId: string) => void;
+    onBeginGroupEditingScope: (elementId: string) => void;
+    onClearSelection: () => void;
+}
+declare function useSelectionOverlayActions({ selectedElementId, selectedElementIds, selectedElement, activeGroupScopeId, isSelectedElementLocked, suppressBackgroundClear, iframeRef, overlayPointerDownRef, onToolbarSuppressedChange, onPointerPreselectionUpdate, onPointerSelectionRetarget, onSelectionContextMenuOpen, onBeginMove, onBeginResize, onBeginRotate, onBeginTextEditing, onBeginGroupEditingScope, onClearSelection, }: UseSelectionOverlayActionsOptions): {
+    onSelectionOverlayMouseDown: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseMove: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseUp: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onResizeHandleMouseDown: (position: ResizeHandlePosition, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCornerRotationZoneMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onSelectionOverlayDoubleClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onBackgroundClick: () => void;
+};
+export { useSelectionOverlayActions };

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

@@ -0,0 +1,17 @@
+import { type SlideModel, type SlideOperation } from "@starrykit/slides-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 };