starry-slides 0.1.0

package/dist/cli/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/deck-slide-operations.d.ts

@@ -0,0 +1,5 @@
+import type { SlideModel } from "./slide-contract";
+export declare function createUniqueSlideId(slides: SlideModel[], preferredId: string): string;
+export declare function createUniqueSlideSourceFile(slides: SlideModel[], preferredFile: string): string;
+export declare function createBlankSlide(slides: SlideModel[], insertIndex: number): SlideModel;
+export declare function createDuplicatedSlide(slides: SlideModel[], sourceSlide: SlideModel): SlideModel;

package/dist/core/generated-deck.d.ts

@@ -0,0 +1,8 @@
+import type { ImportedSlideDeck } from "./slide-contract";
+export interface LoadSlidesFromManifestOptions {
+    manifestUrl: string;
+    fetchImpl?: typeof fetch;
+    requestInit?: RequestInit;
+    slideIdPrefix?: string;
+}
+export declare function loadSlidesFromManifest({ manifestUrl, fetchImpl, requestInit, slideIdPrefix, }: LoadSlidesFromManifestOptions): Promise<ImportedSlideDeck | null>;

package/dist/core/generated-deck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/group-operations.d.ts

@@ -0,0 +1,24 @@
+import type { GroupCreateOperation, GroupUngroupOperation } from "./slide-operation-types";
+export type GroupElementRectMap = Record<string, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export type ElementPresentationStyleMap = Record<string, Partial<Record<"color" | "fontSize" | "fontWeight" | "fontStyle" | "lineHeight" | "textAlign" | "paddingTop" | "paddingRight" | "paddingBottom" | "paddingLeft" | "listStylePosition" | "listStyleType", string>>>;
+export declare function createGroupCreateOperation({ html, slideId, groupElementId, elementIds, elementRects, timestamp, }: {
+    html: string;
+    slideId: string;
+    groupElementId: string;
+    elementIds: string[];
+    elementRects?: GroupElementRectMap;
+    timestamp?: number;
+}): GroupCreateOperation | null;
+export declare function createGroupUngroupOperation({ html, slideId, groupElementId, elementRects, elementPresentationStyles, timestamp, }: {
+    html: string;
+    slideId: string;
+    groupElementId: string;
+    elementRects?: GroupElementRectMap;
+    elementPresentationStyles?: ElementPresentationStyleMap;
+    timestamp?: number;
+}): GroupUngroupOperation | null;

package/dist/core/history.d.ts

@@ -0,0 +1,20 @@
+import type { SlideModel } from "./slide-contract";
+import { type SlideOperation } from "./slide-operations";
+export interface HistoryState {
+    slides: SlideModel[];
+    undoStack: SlideOperation[];
+    redoStack: SlideOperation[];
+}
+export type HistoryAction = {
+    type: "history.reset";
+    slides: SlideModel[];
+} | {
+    type: "history.commit";
+    operation: SlideOperation;
+} | {
+    type: "history.undo";
+} | {
+    type: "history.redo";
+};
+export declare function createHistoryState(slides: SlideModel[]): HistoryState;
+export declare function reduceHistory(state: HistoryState, action: HistoryAction): HistoryState;

package/dist/core/history.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/html-export.d.ts

@@ -0,0 +1,20 @@
+import { type SlideDeckManifestEntry } from "./slide-contract";
+export interface HtmlExportSlide extends SlideDeckManifestEntry {
+    htmlSource: string;
+    width?: number;
+    height?: number;
+}
+export interface ResolvedHtmlExportSlide {
+    file: string;
+    title?: string;
+    htmlSource: string;
+    width: number;
+    height: number;
+}
+export interface HtmlExportDocumentOptions {
+    title?: string;
+    slides: HtmlExportSlide[];
+}
+export declare function planHtmlExportSlides(slides: HtmlExportSlide[]): HtmlExportSlide[];
+export declare function resolveHtmlExportSlides(slides: HtmlExportSlide[]): ResolvedHtmlExportSlide[];
+export declare function createSingleHtmlExportDocument({ title, slides, }: HtmlExportDocumentOptions): string;

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./slide-contract";
+export * from "./slide-document";
+export * from "./slide-html-document";
+export * from "./layout";
+export * from "./slide-operations";
+export * from "./deck-slide-operations";
+export * from "./history";
+export * from "./generated-deck";
+export * from "./pdf-export";
+export * from "./html-export";
+export * from "./presentation";

package/dist/core/layout.d.ts

@@ -0,0 +1,36 @@
+export interface RectLike {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface StageRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface StageGeometry {
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+    slideWidth: number;
+    slideHeight: number;
+}
+export declare const ELEMENT_LAYOUT_STYLE_KEYS: readonly ["position", "left", "top", "width", "height", "transform", "transformOrigin", "margin", "zIndex"];
+export type ElementLayoutStyleKey = (typeof ELEMENT_LAYOUT_STYLE_KEYS)[number];
+export type ElementLayoutStyleSnapshot = Record<ElementLayoutStyleKey, string | null>;
+export declare function createEmptyElementLayoutStyleSnapshot(): ElementLayoutStyleSnapshot;
+export declare function captureElementLayoutStyleSnapshot(node: HTMLElement): ElementLayoutStyleSnapshot;
+export declare function normalizeElementLayoutStyleSnapshot(snapshot: Partial<ElementLayoutStyleSnapshot>): ElementLayoutStyleSnapshot;
+export declare function parseTransformParts(transformValue: string | null | undefined): {
+    translateX: number;
+    translateY: number;
+    rotate: number;
+};
+export declare function composeTransform(translateX: number, translateY: number, rotate: number): string | null;
+export declare function elementRectToStageRect(elementRect: RectLike, rootRect: RectLike, geometry: StageGeometry): StageRect;
+export declare function stageDeltaToSlideDelta(deltaX: number, deltaY: number, geometry: StageGeometry): {
+    x: number;
+    y: number;
+};

package/dist/core/layout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/pdf-export.d.ts

@@ -0,0 +1,20 @@
+import type { SlideDeckManifestEntry } from "./slide-contract";
+export type PdfExportSelection = {
+    mode?: "all";
+} | {
+    mode: "slide";
+    slideFile?: string;
+} | {
+    mode: "slides";
+    slideFiles?: string[];
+};
+export type ResolvedPdfExportMode = "all" | "single" | "slides";
+export interface ResolvedPdfExportSelection {
+    mode: ResolvedPdfExportMode;
+    slides: SlideDeckManifestEntry[];
+}
+export declare function planPdfExport({ slides, selection, }: {
+    slides: SlideDeckManifestEntry[];
+    selection?: PdfExportSelection;
+}): ResolvedPdfExportSelection;
+export declare function planPdfExportSlides(slides: SlideDeckManifestEntry[], selection?: PdfExportSelection): SlideDeckManifestEntry[];

package/dist/core/presentation.d.ts

@@ -0,0 +1,7 @@
+export type PresentationTool = "none" | "laser" | "pen";
+export declare const PRESENTATION_PEN_COLORS: string[];
+export interface PresentableSlide {
+    hidden?: boolean;
+}
+export declare function planPresentationSlides<TSlide extends PresentableSlide>(slides: TSlide[]): TSlide[];
+export declare function clampPresentationIndex(index: number, slideCount: number): number;

package/dist/core/slide-contract.d.ts

@@ -0,0 +1,41 @@
+export type EditableType = "text" | "image" | "block" | "group";
+export interface EditableElement {
+    id: string;
+    selector: string;
+    type: EditableType;
+    content: string;
+    tagName: string;
+}
+export interface SlideModel {
+    id: string;
+    title: string;
+    htmlSource: string;
+    rootSelector: string;
+    width: number;
+    height: number;
+    elements: EditableElement[];
+    sourceFile?: string;
+    hidden?: boolean;
+}
+export interface SlideDeckManifestEntry {
+    file: string;
+    title?: string;
+    hidden?: boolean;
+}
+export interface SlideDeckManifest {
+    topic?: string;
+    slides?: SlideDeckManifestEntry[];
+}
+export interface ImportedSlideDeck {
+    manifest: SlideDeckManifest;
+    slides: SlideModel[];
+}
+export declare const SELECTOR_ATTR = "data-editor-id";
+export declare const SLIDE_ROOT_ATTR = "data-slide-root";
+export declare const DEFAULT_SLIDE_WIDTH = 1920;
+export declare const DEFAULT_SLIDE_HEIGHT = 1080;
+export declare function getSlideElementSelector(elementId: string): string;
+export declare function getSlideRootSelector(rootId: string): string;
+export declare function createElementId(index: number, type: EditableType): string;
+export declare function parseDimension(value: string | null, fallback: number): number;
+export declare function normalizeSlideId(slideId: string): string;

package/dist/core/slide-document.d.ts

@@ -0,0 +1,5 @@
+import { type SlideModel } from "./slide-contract";
+export declare function ensureEditableSelectors(html: string): string;
+export declare function parseSlide(html: string, slideId?: string): SlideModel;
+export declare function querySlideElement<T extends Element = HTMLElement>(doc: ParentNode, elementId: string): T | null;
+export declare function getSlideInlineStyleValue(slide: SlideModel, elementId: string, propertyName: string): string;

package/dist/core/slide-document.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/slide-html-document.d.ts

@@ -0,0 +1,3 @@
+export declare function parseHtmlDocument(html: string): Document | null;
+export declare function serializeHtmlDocument(doc: Document): string;
+export declare function updateHtmlSource(html: string, updater: (doc: Document) => void): string;

package/dist/core/slide-operation-reducer.d.ts

@@ -0,0 +1,4 @@
+import type { SlideModel } from "./slide-contract";
+import type { SlideOperation } from "./slide-operation-types";
+export declare function applySlideOperation(slide: SlideModel, operation: SlideOperation): SlideModel;
+export declare function invertSlideOperation(operation: SlideOperation): SlideOperation;

package/dist/core/slide-operation-reducer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/slide-operation-types.d.ts

@@ -0,0 +1,123 @@
+import type { ElementLayoutStyleSnapshot } from "./layout";
+import type { SlideModel } from "./slide-contract";
+export interface TextUpdateOperation {
+    type: "text.update";
+    slideId: string;
+    elementId: string;
+    previousText: string;
+    nextText: string;
+    timestamp: number;
+}
+export interface StyleUpdateOperation {
+    type: "style.update";
+    slideId: string;
+    elementId: string;
+    propertyName: string;
+    previousValue: string;
+    nextValue: string;
+    timestamp: number;
+}
+export interface AttributeUpdateOperation {
+    type: "attribute.update";
+    slideId: string;
+    elementId: string;
+    attributeName: string;
+    previousValue: string;
+    nextValue: string;
+    timestamp: number;
+}
+export interface ElementLayoutUpdateOperation {
+    type: "element.layout.update";
+    slideId: string;
+    elementId: string;
+    previousStyle: ElementLayoutStyleSnapshot;
+    nextStyle: ElementLayoutStyleSnapshot;
+    timestamp: number;
+}
+export interface ElementInsertOperation {
+    type: "element.insert";
+    slideId: string;
+    elementId: string;
+    parentElementId: string | null;
+    previousSiblingElementId: string | null;
+    nextSiblingElementId: string | null;
+    html: string;
+    timestamp: number;
+}
+export interface ElementRemoveOperation {
+    type: "element.remove";
+    slideId: string;
+    elementId: string;
+    parentElementId: string | null;
+    previousSiblingElementId: string | null;
+    nextSiblingElementId: string | null;
+    html: string;
+    timestamp: number;
+}
+export interface GroupCreateOperation {
+    type: "group.create";
+    slideId: string;
+    groupElementId: string;
+    elementIds: string[];
+    previousHtmlSource: string;
+    nextHtmlSource: string;
+    timestamp: number;
+}
+export interface GroupUngroupOperation {
+    type: "group.ungroup";
+    slideId: string;
+    groupElementId: string;
+    childElementIds: string[];
+    previousHtmlSource: string;
+    nextHtmlSource: string;
+    timestamp: number;
+}
+export type AtomicSlideOperation = TextUpdateOperation | StyleUpdateOperation | AttributeUpdateOperation | ElementLayoutUpdateOperation | ElementInsertOperation | ElementRemoveOperation | GroupCreateOperation | GroupUngroupOperation;
+export interface SlideBatchOperation {
+    type: "operation.batch";
+    slideId: string;
+    operations: AtomicSlideOperation[];
+    timestamp: number;
+}
+export interface SlideCreateOperation {
+    type: "slide.create";
+    slide: SlideModel;
+    index: number;
+    timestamp: number;
+}
+export interface SlideDeleteOperation {
+    type: "slide.delete";
+    slide: SlideModel;
+    index: number;
+    timestamp: number;
+}
+export interface SlideDuplicateOperation {
+    type: "slide.duplicate";
+    sourceSlideId: string;
+    slide: SlideModel;
+    index: number;
+    timestamp: number;
+}
+export interface SlideReorderOperation {
+    type: "slide.reorder";
+    slideId: string;
+    fromIndex: number;
+    toIndex: number;
+    timestamp: number;
+}
+export interface SlideVisibilityUpdateOperation {
+    type: "slide.visibility.update";
+    slideId: string;
+    previousHidden: boolean;
+    nextHidden: boolean;
+    timestamp: number;
+}
+export interface SlideTitleUpdateOperation {
+    type: "slide.title.update";
+    slideId: string;
+    previousTitle: string;
+    nextTitle: string;
+    timestamp: number;
+}
+export type DeckSlideOperation = SlideCreateOperation | SlideDeleteOperation | SlideDuplicateOperation | SlideReorderOperation | SlideVisibilityUpdateOperation | SlideTitleUpdateOperation;
+export type SlideOperation = AtomicSlideOperation | SlideBatchOperation | DeckSlideOperation;

package/dist/core/slide-operations-helpers.d.ts

@@ -0,0 +1,14 @@
+import { type ElementLayoutStyleSnapshot } from "./layout";
+import type { ElementInsertOperation } from "./slide-operation-types";
+export declare function updateSlideText(html: string, elementId: string, value: string): string;
+export declare function updateSlideStyle(html: string, elementId: string, propertyName: string, value: string): string;
+export declare function updateSlideAttribute(html: string, elementId: string, attributeName: string, value: string): string;
+export declare function duplicateSlideElement(html: string, sourceElementId: string, nextElementId: string): string;
+export declare function updateSlideElementLayout(html: string, elementId: string, snapshot: ElementLayoutStyleSnapshot): string;
+export declare function createElementPlacement(html: string, elementId: string): Pick<ElementInsertOperation, "parentElementId" | "previousSiblingElementId" | "nextSiblingElementId"> | null;
+export declare function getSlideElementHtml(html: string, elementId: string): string | null;
+export declare function updateSlideElementHtmlIds(elementHtml: string, idMap: Record<string, string>): string;
+export declare function createUniqueElementId(html: string, preferredId: string): string;
+export declare function insertSlideElement(html: string, operation: Pick<ElementInsertOperation, "elementId" | "parentElementId" | "previousSiblingElementId" | "nextSiblingElementId" | "html">): string;
+export declare function removeSlideElement(html: string, elementId: string): string;
+export declare function updateSlideElementTransform(html: string, elementId: string, deltaX: number, deltaY: number): string;

package/dist/core/slide-operations.d.ts

@@ -0,0 +1,5 @@
+export type { AtomicSlideOperation, AttributeUpdateOperation, ElementInsertOperation, ElementLayoutUpdateOperation, ElementRemoveOperation, GroupCreateOperation, GroupUngroupOperation, SlideBatchOperation, SlideTitleUpdateOperation, SlideOperation, StyleUpdateOperation, TextUpdateOperation, } from "./slide-operation-types";
+export type { GroupElementRectMap, ElementPresentationStyleMap } from "./group-operations";
+export { createGroupCreateOperation, createGroupUngroupOperation, } from "./group-operations";
+export { createElementPlacement, createUniqueElementId, duplicateSlideElement, getSlideElementHtml, insertSlideElement, removeSlideElement, updateSlideAttribute, updateSlideElementHtmlIds, updateSlideElementLayout, updateSlideElementTransform, updateSlideStyle, updateSlideText, } from "./slide-operations-helpers";
+export { applySlideOperation, invertSlideOperation } from "./slide-operation-reducer";

package/dist/core/slide-operations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/verify-deck.d.ts

@@ -0,0 +1,48 @@
+export type VerifyMode = "static" | "complete";
+export type VerifyCheck = "structure" | "static-overflow" | "rendered-overflow";
+export interface VerifyIssue {
+    severity: "error" | "warning";
+    code: string;
+    message: string;
+    slideFile?: string;
+    selector?: string;
+    details?: Record<string, unknown>;
+}
+export interface VerifySummary {
+    errorCount: number;
+    warningCount: number;
+}
+export interface VerifyResult {
+    ok: boolean;
+    deck: string;
+    mode: VerifyMode;
+    checks: VerifyCheck[];
+    issues: VerifyIssue[];
+    summary: VerifySummary;
+}
+export interface VerifyDeckSourceResult {
+    deck: string;
+    manifestPath: string;
+    manifest: {
+        topic?: string;
+        slides?: Array<{
+            file?: unknown;
+            title?: unknown;
+            hidden?: unknown;
+        }>;
+    } | null;
+    slideFiles: string[];
+    issues: VerifyIssue[];
+}
+export declare function createVerifyIssue(severity: VerifyIssue["severity"], code: string, message: string, details?: VerifyIssue["details"]): VerifyIssue;
+export declare function loadVerifyDeckSource(deckPath: string): VerifyDeckSourceResult;
+export declare function createVerifyResult({ deck, mode, checks, issues, }: {
+    deck: string;
+    mode: VerifyMode;
+    checks: VerifyCheck[];
+    issues: VerifyIssue[];
+}): VerifyResult;
+export declare function verifyDeck(deckPath: string, options?: {
+    mode?: VerifyMode;
+    renderedIssues?: VerifyIssue[];
+}): VerifyResult;

package/dist/core/verify-deck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/editor/app/App.d.ts

@@ -0,0 +1,2 @@
+declare function App(): import("react/jsx-runtime").JSX.Element;
+export default App;

package/dist/editor/app/main.d.ts

@@ -0,0 +1 @@
+import "../styles/index.css";

package/dist/editor/app/use-slides-data.d.ts

@@ -0,0 +1,14 @@
+import { type PdfExportSelection, type SlideModel } from "../../core";
+interface SlidesDataResult {
+    deckTitle: string;
+    slides: SlideModel[];
+    errorMessage: string | null;
+    isLoading: boolean;
+    isSaving: boolean;
+    saveSlides: (slides: SlideModel[]) => void;
+    saveDeckTitle: (title: string) => void;
+    exportPdf: (selection: PdfExportSelection) => Promise<void>;
+    exportHtml: () => Promise<void>;
+}
+export declare function useSlidesData(): SlidesDataResult;
+export {};

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

@@ -0,0 +1,32 @@
+import type { MouseEvent as ReactMouseEvent } from "react";
+interface Point {
+    x: number;
+    y: number;
+}
+type ResizeHandleCorner = "top-left" | "top-right" | "bottom-right" | "bottom-left";
+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<{
+        corner: ResizeHandleCorner;
+        x: number;
+        y: number;
+    }>;
+    rotationHandle: Point;
+    onResizeHandleMouseDown: (corner: ResizeHandleCorner, event: ReactMouseEvent<HTMLButtonElement>) => void;
+    onRotateHandleMouseDown: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+declare function BlockManipulationOverlay({ selectionBounds: _selectionBounds, snapGuides, resizeHandles, rotationHandle, onResizeHandleMouseDown, onRotateHandleMouseDown, }: BlockManipulationOverlayProps): import("react/jsx-runtime").JSX.Element;
+export { BlockManipulationOverlay };

package/dist/editor/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/editor/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/editor/components/editor-header.d.ts

@@ -0,0 +1,18 @@
+import type { PdfExportSelection } from "../../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;
+    pdfSlides?: PdfExportSlideOption[];
+    pdfThumbnails?: Record<string, string>;
+    isSaving: boolean;
+}
+export declare function EditorHeader({ title, onTitleChange, onPresent, onExportPdf, onExportHtml, pdfSlides, pdfThumbnails, isSaving, }: EditorHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor/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/editor/components/floating-toolbar-parts.d.ts

@@ -0,0 +1,46 @@
+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 }: {
+    icon: LucideIcon;
+}): 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/editor/components/floating-toolbar.d.ts

@@ -0,0 +1,27 @@
+import type { EditableType } from "../../core";
+import type { CssPropertyRow } from "../lib/collect-css-properties";
+interface FloatingToolbarProps {
+    inspectedStyles: CssPropertyRow[];
+    selectedElementType: EditableType | "multi";
+    selectionCommandAvailability: SelectionCommandAvailability;
+    attributeValues: AttributeValues;
+    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;
+}
+interface AttributeValues {
+    locked: string;
+    altText: string;
+    ariaLabel: string;
+    linkUrl: string;
+}
+export interface SelectionCommandAvailability {
+    group: boolean;
+    ungroup: boolean;
+}
+declare function FloatingToolbar({ inspectedStyles, selectedElementType, selectionCommandAvailability, attributeValues, onStyleChange, onAttributeChange, onAlignToSlide, onDistribute, onGroup, onLayerOrder, onUngroup, }: FloatingToolbarProps): import("react/jsx-runtime").JSX.Element;
+export { FloatingToolbar };