@starrykit/slides-editor 0.1.26

package/dist/components/block-manipulation-overlay.d.ts

@@ -0,0 +1,36 @@
+import type { MouseEvent as ReactMouseEvent } from "react";
+import type { ResizeHandleCorner, ResizeHandlePosition } from "../lib/block-snap-types";
+interface Point {
+    x: number;
+    y: number;
+}
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface SnapGuide {
+    orientation: "vertical" | "horizontal";
+    start: Point;
+    end: Point;
+    variant: "alignment" | "spacing";
+}
+interface BlockManipulationOverlayProps {
+    selectionBounds: Rect;
+    snapGuides: SnapGuide[];
+    resizeHandles: Array<{
+        position: ResizeHandlePosition;
+        x: number;
+        y: number;
+    }>;
+    rotationZones: Array<{
+        corner: ResizeHandleCorner;
+        x: number;
+        y: number;
+    }>;
+    onResizeHandleMouseDown: (position: ResizeHandlePosition, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCornerRotationZoneMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+declare function BlockManipulationOverlay({ selectionBounds: _selectionBounds, snapGuides, resizeHandles, rotationZones, onResizeHandleMouseDown, onCornerRotationZoneMouseDown, }: BlockManipulationOverlayProps): import("react/jsx-runtime").JSX.Element;
+export { BlockManipulationOverlay };

package/dist/components/color-picker.d.ts

@@ -0,0 +1,10 @@
+interface ColorPickerProps {
+    ariaLabelPrefix?: string;
+    value: string;
+    includeGradients?: boolean;
+    includeOpacity?: boolean;
+    onChange: (value: string) => void;
+    onCommit?: () => void;
+}
+declare function ColorPicker({ ariaLabelPrefix, value, includeGradients, includeOpacity, onChange, onCommit, }: ColorPickerProps): import("react/jsx-runtime").JSX.Element;
+export { ColorPicker };

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

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+import type { SelectionCommandAvailability } from "./floating-toolbar";
+interface SelectionContextMenuProps {
+    children: ReactNode;
+    selectionCommandAvailability: SelectionCommandAvailability;
+    onAlignToSlide: (action: string) => void;
+    onDelete: () => void;
+    onDistribute: (action: string) => void;
+    onDuplicate: () => void;
+    onGroup: () => void;
+    onLayerOrder: (action: string) => void;
+    onUngroup: () => void;
+}
+interface SelectionContextMenuContentProps {
+    selectionCommandAvailability: SelectionCommandAvailability;
+    onAlignToSlide: (action: string) => void;
+    onDelete: () => void;
+    onDistribute: (action: string) => void;
+    onDuplicate: () => void;
+    onGroup: () => void;
+    onLayerOrder: (action: string) => void;
+    onUngroup: () => void;
+}
+declare function SelectionContextMenu({ children, selectionCommandAvailability, onAlignToSlide, onDelete, onDistribute, onDuplicate, onGroup, onLayerOrder, onUngroup, }: SelectionContextMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function SelectionContextMenuContent({ selectionCommandAvailability, onAlignToSlide, onDelete, onDistribute, onDuplicate, onGroup, onLayerOrder, onUngroup, }: SelectionContextMenuContentProps): import("react/jsx-runtime").JSX.Element;
+export { SelectionContextMenu, SelectionContextMenuContent };

package/dist/components/editor-header.d.ts

@@ -0,0 +1,19 @@
+import type { PdfExportSelection } from "@starrykit/slides-core";
+export interface PdfExportSlideOption {
+    id: string;
+    title: string;
+    file?: string;
+}
+interface EditorHeaderProps {
+    title: string;
+    onTitleChange?: (t: string) => void;
+    onPresent?: () => void;
+    onExportPdf?: (selection: PdfExportSelection) => void;
+    onExportHtml?: () => void;
+    onExportSourceFiles?: () => void;
+    pdfSlides?: PdfExportSlideOption[];
+    pdfThumbnails?: Record<string, string>;
+    isSaving: boolean;
+}
+export declare function EditorHeader({ title, onTitleChange, onPresent, onExportPdf, onExportHtml, onExportSourceFiles, pdfSlides, pdfThumbnails, isSaving, }: EditorHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/editor-workspace.d.ts

@@ -0,0 +1,88 @@
+import type { EditableType, PdfExportSelection, SlideModel, StageRect } from "@starrykit/slides-core";
+import type { MouseEvent as ReactMouseEvent, RefObject } from "react";
+import type { BlockManipulationOverlay as BlockManipulationOverlayModel } from "../hooks/block-manipulation-types";
+import type { ImageCropOverlay as ImageCropOverlayModel } from "../hooks/use-image-crop";
+import type { ResizeHandleCorner, ResizeHandlePosition } from "../lib/block-snap-types";
+import type { CssPropertyRow } from "../lib/collect-css-properties";
+import type { SelectionCommandAvailability } from "./floating-toolbar";
+interface EditorWorkspaceProps {
+    slides: SlideModel[];
+    activeSlide: SlideModel;
+    deckTitle: string;
+    isSaving: boolean;
+    isPresenting: boolean;
+    thumbnails: Record<string, string>;
+    slideWidth: number;
+    slideHeight: number;
+    offsetX: number;
+    offsetY: number;
+    scale: number;
+    preselectionOverlay: StageRect | null;
+    marqueeOverlay: StageRect | null;
+    selectionOverlay: StageRect | null;
+    toolbarKey: string | null;
+    inspectedStyles: CssPropertyRow[];
+    selectedElementType: EditableType | "multi";
+    selectionCommandAvailability: SelectionCommandAvailability;
+    isSelectedElementLocked: boolean;
+    groupScopeOverlayPassive: boolean;
+    isEditingText: boolean;
+    isCropMode: boolean;
+    cropOverlay: ImageCropOverlayModel | null;
+    manipulationOverlay: BlockManipulationOverlayModel | null;
+    attributeValues: {
+        locked: 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;
+    onDeckTitleChange?: (title: string) => void;
+    onExportPdf?: (selection: PdfExportSelection) => void;
+    onExportHtml?: () => void;
+    onExportSourceFiles?: () => void;
+    onPresent: () => void;
+    onExitPresenting: () => void;
+    onSelectSlide: (slideId: string) => void;
+    onSidebarSlideFocusChange: (isFocused: boolean) => void;
+    onAddSlide: () => void;
+    onAddSlideAbove: (slideId: string) => void;
+    onAddSlideBelow: (slideId: string) => void;
+    onDuplicateSlide: (slideId: string) => void;
+    onDeleteSlide: (slideId: string) => void;
+    onToggleSlideHidden: (slideId: string) => void;
+    onRenameSlide: (slideId: string, nextTitle: string) => void;
+    onReorderSlide: (slideId: string, targetIndex: number) => void;
+    onSidebarFocusChange?: (focused: boolean) => void;
+    onSelectionOverlayMouseDown: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseUp: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayMouseMove: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onSelectionOverlayContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onStageMouseLeave: () => void;
+    onResizeHandleMouseDown: (position: ResizeHandlePosition, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCornerRotationZoneMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCropHandleMouseDown: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onSelectionOverlayDoubleClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onBackgroundClick: () => void;
+    onStyleChange: (propertyName: string, nextValue: string) => void;
+    onStyleChanges: (changes: Array<{
+        propertyName: string;
+        nextValue: string;
+    }>) => void;
+    onStylePreview: (propertyName: string, nextValue: string | null) => void;
+    onAttributeChange: (attributeName: string, nextValue: string) => void;
+    onAlignToSlide: (action: string) => void;
+    onCropImage: () => void;
+    onDistribute: (action: string) => void;
+    onGroup: () => void;
+    onLayerOrder: (action: string) => void;
+    onUngroup: () => void;
+    onDuplicateElement: () => void;
+    onDeleteElement: () => void;
+}
+declare function EditorWorkspace({ slides, activeSlide, deckTitle, isSaving, isPresenting, thumbnails, slideWidth, slideHeight, offsetX, offsetY, scale, preselectionOverlay, marqueeOverlay, selectionOverlay, toolbarKey, inspectedStyles, selectedElementType, selectionCommandAvailability, isSelectedElementLocked, groupScopeOverlayPassive, isEditingText, isCropMode, cropOverlay, manipulationOverlay, attributeValues, iframeRef, stageViewportRef, selectionOverlayRef, selectionContextMenuTriggerRef, isManipulating, isToolbarSuppressed, onDeckTitleChange, onExportPdf, onExportHtml, onExportSourceFiles, onPresent, onExitPresenting, onSelectSlide, onSidebarSlideFocusChange, onAddSlide, onAddSlideAbove, onAddSlideBelow, onDuplicateSlide, onDeleteSlide, onToggleSlideHidden, onRenameSlide, onReorderSlide, onSidebarFocusChange, onSelectionOverlayMouseDown, onSelectionOverlayMouseUp, onSelectionOverlayMouseMove, onSelectionOverlayContextMenu, onStageMouseLeave, onResizeHandleMouseDown, onCornerRotationZoneMouseDown, onCropHandleMouseDown, onSelectionOverlayDoubleClick, onBackgroundClick, onStyleChange, onStyleChanges, onStylePreview, onAttributeChange, onAlignToSlide, onCropImage, onDistribute, onGroup, onLayerOrder, onUngroup, onDuplicateElement, onDeleteElement, }: EditorWorkspaceProps): import("react/jsx-runtime").JSX.Element;
+export { EditorWorkspace };

package/dist/components/floating-toolbar-attribute-dialog.d.ts

@@ -0,0 +1,9 @@
+import type { ElementToolFeature } from "../lib/element-tool-model";
+import type { AttributeValues, EditableAttributeId } from "./floating-toolbar-types";
+declare function AttributeDialog({ attributeValues, dialogId, onCommitFeature, onOpenChange, }: {
+    attributeValues: AttributeValues;
+    dialogId: EditableAttributeId | null;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    onOpenChange: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export { AttributeDialog };

package/dist/components/floating-toolbar-feature.d.ts

@@ -0,0 +1,8 @@
+import type { ElementToolFeature } from "../lib/element-tool-model";
+export declare function renderFloatingToolbarFeature({ currentValue, feature, onClosePanel, onCommitFeature, operationAvailability, }: {
+    currentValue: string;
+    feature: ElementToolFeature;
+    onClosePanel: () => void;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    operationAvailability?: Partial<Record<ElementToolFeature["id"], boolean>>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/floating-toolbar-fields.d.ts

@@ -0,0 +1,37 @@
+import type { ElementToolFeature } from "../lib/element-tool-model";
+declare function FontFamilyCombobox({ currentValue, onCommit, onOpen, onPreview, }: {
+    currentValue: string;
+    onCommit: (nextValue: string) => void;
+    onOpen: () => void;
+    onPreview: (nextValue: string | null) => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function NumericCommitControl({ feature, label, onCommitFeature, onPreview, unit, }: {
+    feature: ElementToolFeature;
+    label: string;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    onPreview?: (nextValue: string | null) => void;
+    unit?: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DebouncedStyleNumberControl({ currentValue, feature, formatValue, getDraftValue, label, max, min, onCommitFeature, onPreviewStyle, unit, }: {
+    currentValue: string;
+    feature: ElementToolFeature;
+    formatValue: (numericValue: number) => string;
+    getDraftValue: (currentValue: string) => string;
+    label: string;
+    max?: number;
+    min?: number;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    onPreviewStyle: (propertyName: string, nextValue: string | null) => void;
+    unit: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function TextCommitControl({ feature, label, onCommitFeature, }: {
+    feature: ElementToolFeature;
+    label: string;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function FontSizeControl({ currentValue, feature, onCommitFeature, }: {
+    currentValue: string;
+    feature: ElementToolFeature;
+    onCommitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export { DebouncedStyleNumberControl, FontFamilyCombobox, FontSizeControl, NumericCommitControl, TextCommitControl, };

package/dist/components/floating-toolbar-parts.d.ts

@@ -0,0 +1,47 @@
+import type { LucideIcon } from "lucide-react";
+import type { MouseEvent as ReactMouseEvent, ReactNode } from "react";
+import type { ElementToolSubgroup } from "../lib/element-tool-model";
+export declare function ToolbarTrigger({ children, active, className, label, onClick, }: {
+    children: ReactNode;
+    active?: boolean;
+    className?: string;
+    label: string;
+    onClick: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function IconButton({ children, active, className, label, onClick, }: {
+    children: ReactNode;
+    active?: boolean;
+    className?: string;
+    label: string;
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ToolbarPanel({ children, left, width, }: {
+    children: ReactNode;
+    left: number;
+    width?: "default" | "medium" | "wide";
+}): import("react/jsx-runtime").JSX.Element;
+export declare function getPanelWidth(subgroup: ElementToolSubgroup): "default" | "medium" | "wide";
+export declare function shouldUpdateOffset(current: number, next: number): boolean;
+export declare function Divider(): import("react/jsx-runtime").JSX.Element;
+export declare function PanelTitle({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function FieldLabel({ children, htmlFor }: {
+    children: ReactNode;
+    htmlFor?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ToolbarIcon({ icon: Icon, strokeWidth, }: {
+    icon: LucideIcon;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ToolbarValueButton({ children, label, onClick, }: {
+    children: ReactNode;
+    label: string;
+    onClick: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ToolbarOption({ children, disabled, onClick, title, }: {
+    children: ReactNode;
+    disabled?: boolean;
+    onClick: () => void;
+    title?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/floating-toolbar-popovers.d.ts

@@ -0,0 +1,44 @@
+import { type Dispatch, type ReactNode, type SetStateAction } from "react";
+import type { ElementToolFeature, ElementToolOption } from "../lib/element-tool-model";
+import type { SelectionCommandAvailability } from "./floating-toolbar-types";
+export interface PopoverSectionProps {
+    activePopoverId: string | null;
+    commitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    getCurrentValue: (feature: ElementToolFeature) => string;
+    getFeature: (featureId: ElementToolFeature["id"]) => ElementToolFeature;
+    onStylePreview: (propertyName: string, nextValue: string | null) => void;
+    setActivePopoverId: Dispatch<SetStateAction<string | null>>;
+}
+export interface OptionsSectionProps extends PopoverSectionProps {
+    selectionCommandAvailability: SelectionCommandAvailability;
+}
+declare function ColorPopover({ activePopoverId, commitFeature, feature, getCurrentValue, icon, includeGradients, label, popoverId, setActivePopoverId, }: PopoverSectionProps & {
+    feature: ElementToolFeature;
+    icon: ReactNode;
+    includeGradients: boolean;
+    label: string;
+    popoverId: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function OptionsPopover({ activePopoverId, commitFeature, custom, feature, getCurrentValue, icon, label, options, popoverId, selectionCommandAvailability, setActivePopoverId, onStylePreview, }: OptionsSectionProps & {
+    custom?: ReactNode;
+    feature: ElementToolFeature;
+    icon: ReactNode;
+    label: string;
+    options: ElementToolOption[];
+    popoverId: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function LineHeightPopover({ activePopoverId, commitFeature, feature, getCurrentValue, icon, label, popoverId, setActivePopoverId, onStylePreview, }: PopoverSectionProps & {
+    feature: ElementToolFeature;
+    icon: ReactNode;
+    label: string;
+    popoverId: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function AttributeMenuButton({ icon, label, onClick, }: {
+    icon: ReactNode;
+    label: string;
+    onClick: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToolbarSection({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export { AttributeMenuButton, ColorPopover, LineHeightPopover, OptionsPopover, ToolbarSection };

package/dist/components/floating-toolbar-sections.d.ts

@@ -0,0 +1,19 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type ElementToolFeature } from "../lib/element-tool-model";
+import type { EditableAttributeId, SelectionCommandAvailability } from "./floating-toolbar-types";
+interface FloatingToolbarSectionsProps {
+    activePopoverId: string | null;
+    isSelectedElementLocked: boolean;
+    selectionCommandAvailability: SelectionCommandAvailability;
+    selectedElementType: "text" | "image" | "block" | "group" | "multi";
+    showGroupTool: boolean;
+    showMultiTools: boolean;
+    commitFeature: (feature: ElementToolFeature, nextValue: string) => void;
+    getCurrentValue: (feature: ElementToolFeature) => string;
+    getFeature: (featureId: ElementToolFeature["id"]) => ElementToolFeature;
+    onStylePreview: (propertyName: string, nextValue: string | null) => void;
+    setActiveAttributeDialog: Dispatch<SetStateAction<EditableAttributeId | null>>;
+    setActivePopoverId: Dispatch<SetStateAction<string | null>>;
+}
+declare function FloatingToolbarSections({ activePopoverId, isSelectedElementLocked, selectionCommandAvailability, selectedElementType, showGroupTool, showMultiTools, commitFeature, getCurrentValue, getFeature, onStylePreview, setActiveAttributeDialog, setActivePopoverId, }: FloatingToolbarSectionsProps): import("react/jsx-runtime").JSX.Element;
+export { FloatingToolbarSections };

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

@@ -0,0 +1,41 @@
+import type { EditableType } from "@starrykit/slides-core";
+import type { CssPropertyRow } from "../lib/collect-css-properties";
+import type { ElementToolFeature } from "../lib/element-tool-model";
+export interface FloatingToolbarProps {
+    inspectedStyles: CssPropertyRow[];
+    selectedElementType: EditableType | "multi";
+    selectionCommandAvailability: SelectionCommandAvailability;
+    isSelectedElementLocked: boolean;
+    attributeValues: AttributeValues;
+    onStyleChange: (propertyName: string, nextValue: string) => void;
+    onStyleChanges: (changes: Array<{
+        propertyName: string;
+        nextValue: string;
+    }>) => void;
+    onStylePreview: (propertyName: string, nextValue: string | null) => void;
+    onAttributeChange: (attributeName: string, nextValue: string) => void;
+    onAlignToSlide: (action: string) => void;
+    onCropImage: () => void;
+    onDistribute: (action: string) => void;
+    onGroup: () => void;
+    onLayerOrder: (action: string) => void;
+    onUngroup: () => void;
+}
+export interface AttributeValues {
+    locked: string;
+    ariaLabel: string;
+    linkUrl: string;
+}
+export interface SelectionCommandAvailability {
+    group: boolean;
+    ungroup: boolean;
+}
+export type EditableAttributeId = "other-link" | "other-aria-label";
+export declare const OTHER_FEATURES: Record<EditableAttributeId, ElementToolFeature>;
+export declare const toolbarIconClassName = "size-3.5";
+export declare const toolbarIconMutedClassName = "size-3.5 text-foreground/55";
+export declare const toolbarIconDropShadowClassName = "size-3.5 drop-shadow";
+export declare const ICON_STROKE_WIDTH = 2.5;
+export declare const menuItemClassName = "flex min-h-7 w-full items-center justify-between gap-2 rounded-md px-2 py-1 text-left text-[12px] text-foreground/70 outline-none transition-colors hover:bg-foreground/[0.05] hover:text-foreground focus-visible:bg-foreground/[0.06] focus-visible:text-foreground focus-visible:ring-[2px] focus-visible:ring-ring/25 disabled:pointer-events-none disabled:opacity-40";
+export declare const toolbarIconButtonClassName = "size-7.5 rounded-xl text-foreground/60 transition-colors hover:bg-foreground/[0.05] hover:text-foreground active:scale-[0.98]";
+export declare const toolbarIconButtonActiveClassName = "bg-foreground/[0.07] text-foreground shadow-[inset_0_1px_2px_rgba(0,0,0,0.08)] hover:bg-foreground/[0.08]";

package/dist/components/floating-toolbar.d.ts

@@ -0,0 +1,4 @@
+import type { FloatingToolbarProps } from "./floating-toolbar-types";
+export type { SelectionCommandAvailability } from "./floating-toolbar-types";
+declare function FloatingToolbar({ inspectedStyles, selectedElementType, selectionCommandAvailability, isSelectedElementLocked, attributeValues, onStyleChange, onStyleChanges, onStylePreview, onAttributeChange, onAlignToSlide, onCropImage, onDistribute, onGroup, onLayerOrder, onUngroup, }: FloatingToolbarProps): import("react/jsx-runtime").JSX.Element;
+export { FloatingToolbar };

package/dist/components/image-crop-overlay.d.ts

@@ -0,0 +1,9 @@
+import type { MouseEvent as ReactMouseEvent } from "react";
+import type { ImageCropOverlay as ImageCropOverlayModel } from "../hooks/use-image-crop";
+import type { ResizeHandleCorner } from "../lib/block-snap-types";
+interface ImageCropOverlayProps {
+    overlay: ImageCropOverlayModel;
+    onCropHandleMouseDown: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+declare function ImageCropOverlay({ overlay, onCropHandleMouseDown }: ImageCropOverlayProps): import("react/jsx-runtime").JSX.Element;
+export { ImageCropOverlay };

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

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

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

@@ -0,0 +1,20 @@
+import type { SlideModel } from "@starrykit/slides-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;
+    onSlideFocusChange?: (isFocused: boolean) => void;
+    onSidebarFocusChange?: (focused: boolean) => void;
+}
+declare function SlideSidebar({ slides, activeSlideId, slideCount, thumbnails, onSelectSlide, onAdd, onAddSlideAbove, onAddSlideBelow, onDuplicate, onDelete, onToggleHidden, onRename, onReorder, onSlideFocusChange, onSidebarFocusChange, }: SlideSidebarProps): import("react/jsx-runtime").JSX.Element;
+export { SlideSidebar };

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

@@ -0,0 +1,88 @@
+import type { EditableType, StageRect } from "@starrykit/slides-core";
+import type { MouseEvent as ReactMouseEvent, RefObject } from "react";
+import type { ImageCropOverlay as ImageCropOverlayModel } from "../hooks/use-image-crop";
+import type { ResizeHandleCorner, ResizeHandlePosition } from "../lib/block-snap-types";
+import type { CssPropertyRow } from "../lib/collect-css-properties";
+import { type SelectionCommandAvailability } from "./floating-toolbar";
+interface StageCanvasProps {
+    slideWidth: number;
+    slideHeight: number;
+    offsetX: number;
+    offsetY: number;
+    scale: number;
+    preselectionOverlay: StageRect | null;
+    marqueeOverlay: StageRect | null;
+    selectionOverlay: StageRect | null;
+    toolbarKey: string | null;
+    inspectedStyles: CssPropertyRow[];
+    selectedElementType: EditableType | "multi";
+    selectionCommandAvailability: SelectionCommandAvailability;
+    isSelectedElementLocked: boolean;
+    groupScopeOverlayPassive: boolean;
+    isEditingText: boolean;
+    isCropMode: boolean;
+    cropOverlay: ImageCropOverlayModel | null;
+    manipulationOverlay: {
+        selectionBounds: StageRect;
+        snapGuides: Array<{
+            orientation: "vertical" | "horizontal";
+            start: {
+                x: number;
+                y: number;
+            };
+            end: {
+                x: number;
+                y: number;
+            };
+            variant: "alignment" | "spacing";
+        }>;
+        resizeHandles: Array<{
+            position: ResizeHandlePosition;
+            x: number;
+            y: number;
+        }>;
+        rotationZones: Array<{
+            corner: ResizeHandleCorner;
+            x: number;
+            y: number;
+        }>;
+    } | null;
+    attributeValues: {
+        locked: 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: (position: ResizeHandlePosition, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCornerRotationZoneMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onCropHandleMouseDown: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onSelectionOverlayDoubleClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onBackgroundClick: () => void;
+    onStyleChange: (propertyName: string, nextValue: string) => void;
+    onStyleChanges: (changes: Array<{
+        propertyName: string;
+        nextValue: string;
+    }>) => void;
+    onStylePreview: (propertyName: string, nextValue: string | null) => void;
+    onAttributeChange: (attributeName: string, nextValue: string) => void;
+    onAlignToSlide: (action: string) => void;
+    onCropImage: () => 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, marqueeOverlay, selectionOverlay, toolbarKey, inspectedStyles, selectedElementType, selectionCommandAvailability, isSelectedElementLocked, groupScopeOverlayPassive, isEditingText, isCropMode, cropOverlay, manipulationOverlay, attributeValues, iframeRef, stageViewportRef, selectionOverlayRef, selectionContextMenuTriggerRef, isManipulating, isToolbarSuppressed, onSelectionOverlayMouseDown, onSelectionOverlayMouseUp, onSelectionOverlayMouseMove, onSelectionOverlayContextMenu, onStageMouseLeave, onResizeHandleMouseDown, onCornerRotationZoneMouseDown, onCropHandleMouseDown, onSelectionOverlayDoubleClick, onBackgroundClick, onStyleChange, onStyleChanges, onStylePreview, onAttributeChange, onAlignToSlide, onCropImage, onDistribute, onGroup, onLayerOrder, onUngroup, onDuplicate, onDelete, }: StageCanvasProps): import("react/jsx-runtime").JSX.Element;
+export { StageCanvas };

package/dist/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/components/ui/button.d.ts

@@ -0,0 +1,13 @@
+import { type VariantProps } from "class-variance-authority";
+import * 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 const Button: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<(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> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/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/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/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/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/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 };