@draftably/editor 0.0.0-stage → 0.2.0

package/dist/types/src/state/active-session.d.ts

@@ -0,0 +1,479 @@
+import type { DiagramSession } from './session';
+export declare function activeSession(): DiagramSession;
+export declare const setActiveSession: (session: DiagramSession) => {
+    dispose: () => void;
+} & {
+    selectedText: import("solid-js").Accessor<string | null>;
+    setSelectedText: import("solid-js").Setter<string | null>;
+} & {
+    options: import("./session").SessionOptions;
+    doc: import("../model/types").Diagram;
+    setDoc: import("solid-js/store").SetStoreFunction<import("../model/types").Diagram>;
+    saveStatus: import("solid-js").Accessor<"saved" | "saving" | "preview" | "failed">;
+    undoStack: import("solid-js").Accessor<import("./session/document").HistoryEntry[]>;
+    redoStack: import("solid-js").Accessor<import("./session/document").HistoryEntry[]>;
+    revision: import("solid-js").Accessor<number>;
+    snapshotDoc: () => import("../model/types").Diagram;
+    snapshot: () => string;
+    selection: import("solid-js").Accessor<ReadonlySet<string>>;
+    selectedIds: () => string[];
+    isSelected: (id: string) => boolean;
+    singleSelection: () => string | undefined;
+    setSelection: (ids: Iterable<string>) => void;
+    selectItems: (ids: string[], { add, toggle }?: {
+        add?: boolean | undefined;
+        toggle?: boolean | undefined;
+    }) => void;
+    clearSelection: () => void;
+    selectText: (id: string) => void;
+    onBeforeEdit: (handler: () => void) => void;
+    prepareForEdit: () => void;
+    onSourceIdMap: (handler: (mapId: (id: string) => string) => void) => void;
+    mapSourceIds: (mapId: (id: string) => string) => void;
+    setCommitHandler: (handler: ((before: string, label: string, kind: import("./session/document").EditKind) => boolean) | null) => ((before: string, label: string, kind: import("./session/document").EditKind) => boolean) | null;
+    editsGoToFile: () => boolean;
+    commit: (before: string, label?: string, kind?: import("./session/document").EditKind) => boolean;
+    pushUndo: (entry: import("./session/document").HistoryEntry) => void;
+    annotateLastUndo: (holds: import("./session/document").HistoryEntry["holds"]) => void;
+    transact: (label: string, fn: (draft: import("../model/types").Diagram) => void, kind?: import("./session/document").EditKind) => boolean;
+    mutate: (fn: (draft: import("../model/types").Diagram) => void) => void;
+    restoreDocument: (next: import("../model/types").Diagram, { keepCamera }?: {
+        keepCamera?: boolean | undefined;
+    }) => void;
+    onHistoryStep: (handler: (entry: import("./session/document").HistoryEntry, direction: "undo" | "redo") => void) => void;
+    setHistoryHandler: (handler: import("./session/document").HistoryHandler | null) => import("./session/document").HistoryHandler | null;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    setCamera: (camera: import("../model/types").Camera) => void;
+    disableBrowserStorage: () => boolean;
+    setPersistenceBlocked: (blocked: boolean) => void;
+    persist: () => void;
+    persistNow: () => void;
+    restoreSavedDocument: () => {
+        restored: boolean;
+        notice?: string;
+    };
+    watchOtherTabs: () => () => void;
+} & {
+    openSource: (source: string, onChange?: (source: string) => void) => Promise<void>;
+    receiveSource: (source: string) => Promise<void>;
+    liveSource: import("solid-js").Accessor<string>;
+    sourceDraft: import("solid-js").Accessor<string | null>;
+    fileSession: import("solid-js").Accessor<import("./session/file-session").FileSessionInfo | null>;
+    fileMode: () => boolean;
+    exampleMode: () => boolean;
+    scratchName: () => "Draft" | "Example";
+    exampleEdited: () => boolean;
+    leaveAgreed: () => boolean;
+    agreeToLeave: () => undefined;
+    fileStatus: import("solid-js").Accessor<import("./session/file-session").FileStatus>;
+    sourceError: import("solid-js").Accessor<{
+        message: string;
+        line: number;
+    } | null>;
+    fileScene: import("solid-js").Accessor<import("../dsl/compile").Scene | null>;
+    fileDiagnostics: () => import("../dsl/compile").Diagnostic[];
+    conflictProposal: import("solid-js").Accessor<string | null>;
+    movedByChange: import("solid-js").Accessor<string[]>;
+    fileCompiling: import("solid-js").Accessor<boolean>;
+    exampleRestored: () => boolean;
+    currentSource: () => string;
+    setRouteSink: (sink: {
+        adopt: (routes: {
+            fingerprint: string;
+            result: import("../engines/routing-engine").RoutingResult;
+        }) => void;
+        quick: (on: boolean) => void;
+        awaiting: (on: boolean) => void;
+    }) => {
+        adopt: (routes: {
+            fingerprint: string;
+            result: import("../engines/routing-engine").RoutingResult;
+        }) => void;
+        quick: (on: boolean) => void;
+        awaiting: (on: boolean) => void;
+    };
+    showSource: (source: string, selection?: string[] | (() => string[]), mapId?: (id: string) => string) => Promise<import("../dsl/compile").Scene | null>;
+    keepDiskVersion: () => void;
+    saveProposalOverDisk: () => void;
+    retrySave: () => undefined;
+    typeSource: (next: string, burst: number) => Promise<null | undefined>;
+    commitSource: (next: string, label: string, message: string) => Promise<boolean>;
+    fileBlocked: () => string | null;
+    sourceWithRecipe: (scope: string, settings: import("../model/types").LayoutSettings, direction?: "right" | "down") => {
+        source: string;
+        removed: number;
+    };
+    sourceWithShape: (scope: string, change: import("../dsl/layout-edits").ShapeChange) => {
+        source: string;
+        removed: number;
+    };
+    changedLines: (source: string) => string[];
+    changedLine: (source: string) => string;
+    sourceWithRouting: (routing: import("../model/types").RoutingSettings, base?: string) => string;
+    projectSource: (source: string) => Promise<import("../model/types").Diagram>;
+    reflowSelectedGroup: (id: string) => void;
+    openFileSession: (file: string) => Promise<boolean>;
+    prefetchFile: (file: string) => Promise<void>;
+    settleSave: () => Promise<void>;
+    closeFileSession: () => void;
+    openExampleSession: (id: string, title: string, source: string, key?: string) => Promise<void>;
+    resetExample: () => void;
+    markExampleSaved: () => void;
+    fileStatusText: () => string;
+} & {
+    sculptGeometry: import("solid-js").Accessor<import("./session/editor").NodeGeometry | null>;
+    setSculptGeometry: import("solid-js").Setter<import("./session/editor").NodeGeometry | null>;
+    animationGeometry: import("solid-js").Accessor<import("./session/editor").NodeGeometry | null>;
+    setAnimationGeometry: import("solid-js").Setter<import("./session/editor").NodeGeometry | null>;
+    setQuickRouting: import("solid-js").Setter<boolean>;
+    routePrior: import("solid-js").Accessor<import("../engines/routing-engine").PriorRoute[] | null>;
+    setRoutePrior: import("solid-js").Setter<import("../engines/routing-engine").PriorRoute[] | null>;
+    setAdoptedRoutes: import("solid-js").Setter<{
+        fingerprint: string;
+        result: import("../engines/routing-engine").RoutingResult;
+    } | null>;
+    geometry: (id: string) => import("../model/types").NodeLayout;
+    visibleScene: import("solid-js").Accessor<import("../model/graph").VisibleGraph>;
+    nodeIds: import("solid-js").Accessor<string[]>;
+    groupIds: import("solid-js").Accessor<string[]>;
+    edgeIds: import("solid-js").Accessor<string[]>;
+    sceneRects: import("solid-js").Accessor<Map<string, import("../model/types").Rect>>;
+    routing: import("solid-js").Accessor<import("../model/routes").SceneRoutes>;
+    routesById: import("solid-js").Accessor<Map<string, import("../model/routes").DrawnRoute>>;
+    routeIds: import("solid-js").Accessor<string[]>;
+    routesPending: () => boolean;
+    resetRoutes: () => void;
+    routeInputFor: () => {
+        nodes: ({
+            shape: import("../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            wasShape?: import("../model/types").ShapeKind;
+            wasCount?: number | string;
+            href?: string;
+            count?: number | string;
+            span?: number | "var";
+            parentId?: string;
+            image?: string;
+            lifeline?: number;
+        } | {
+            parentId?: string | undefined;
+            frame?: boolean | undefined;
+            shape: import("../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+        })[];
+        groups: {
+            titleHeight?: number | undefined;
+            collapsed: boolean;
+            titleWidth: number;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            href?: string;
+            parentId?: string;
+            frame?: "soft" | "none";
+            titleLines?: number;
+            hull?: import("../model/types").Rect[];
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            cfg: import("../model/types").EdgeLayout;
+            a: string;
+            b: string;
+            id: string;
+            label: string;
+            was?: string;
+            directed: boolean;
+            head?: import("../model/markers").EndMarker;
+            tail?: import("../model/markers").EndMarker;
+            emphasis: boolean;
+            dashed: boolean;
+            status?: import("../model/status").Status;
+            spot?: import("../model/status").Spot;
+        }[];
+    };
+    routes: () => import("../model/routes").DrawnRoute[];
+    routingReport: () => import("../engines/routing-engine").RoutingReport;
+    blockedRouteIds: () => string[];
+    sceneBounds: () => import("../model/types").Rect;
+    viewerFrame: () => {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        natural: number;
+        head: {
+            w: number;
+            h: number;
+        };
+        key: {
+            w: number;
+            h: number;
+            row: number;
+            items: {
+                x: number;
+                y: number;
+                legend?: import("../model/appearance").LegendEntry;
+                status?: import("../model/status").StatusCount;
+                label: string;
+            }[];
+        };
+        heading: {
+            x: number;
+            y: number;
+            wrap: number;
+        };
+        legend: {
+            x: number;
+            y: number;
+        };
+        foot: {
+            x: number;
+            y: number;
+            type: import("../model/fonts").TypeProfile;
+            gutter: number;
+            items: {
+                note: import("../model/footnote").Footnote;
+                lines: import("../model/rich-text").Run[][];
+                y: number;
+            }[];
+            h: number;
+        };
+        notes: import("../model/note").PlacedNote[];
+    };
+} & {
+    states: () => import("../model/appearance").EmphasisState[];
+    activeState: () => string | null;
+    gridOpen: import("solid-js").Accessor<boolean>;
+    setGridOpen: import("solid-js").Setter<boolean>;
+    showState: (id: string | null) => void;
+    stepState: (by: 1 | -1) => boolean;
+    drawnDoc: () => import("../model/types").Diagram;
+} & {
+    tool: import("solid-js").Accessor<import("./session/editor").Tool>;
+    setToolSignal: import("solid-js").Setter<import("./session/editor").Tool>;
+    connectFrom: import("solid-js").Accessor<{
+        id: string;
+        side: import("../model/types").PortSide;
+    } | null>;
+    setConnectFrom: import("solid-js").Setter<{
+        id: string;
+        side: import("../model/types").PortSide;
+    } | null>;
+    pointer: import("solid-js").Accessor<import("../model/types").Point | null>;
+    setPointer: import("solid-js").Setter<import("../model/types").Point | null>;
+    drag: import("solid-js").Accessor<import("./session/editor").DragFeedback | null>;
+    setDrag: import("solid-js").Setter<import("./session/editor").DragFeedback | null>;
+    inlineEditId: import("solid-js").Accessor<string | null>;
+    setInlineEditId: import("solid-js").Setter<string | null>;
+    spaceHeld: import("solid-js").Accessor<boolean>;
+    setSpaceHeld: import("solid-js").Setter<boolean>;
+    measuredStageSize: import("solid-js").Accessor<{
+        width: number;
+        height: number;
+    }>;
+    setMeasuredStageSize: import("solid-js").Setter<{
+        width: number;
+        height: number;
+    }>;
+    reducedMotion: import("solid-js").Accessor<boolean>;
+    setReducedMotion: import("solid-js").Setter<boolean>;
+    registerCanvas: (el: SVGSVGElement) => SVGSVGElement;
+    canvasElement: () => SVGSVGElement | undefined;
+    focusCanvas: () => void | undefined;
+    stageSize: () => {
+        width: number;
+        height: number;
+    };
+    screenToWorld: (clientX: number, clientY: number) => import("../model/types").Point;
+    canvasCenter: () => import("../model/types").Point;
+    zoomAt: (factor: number, clientX?: number, clientY?: number) => void;
+    panBy: (dx: number, dy: number) => void;
+    setStageSize: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    fitView: () => void;
+    diagramClipped: () => boolean;
+    fitRects: (rects: import("../model/types").Rect[], reservedBottom?: number) => void;
+    revealObject: (id: string) => void;
+    centerSelection: () => void;
+} & {
+    layoutBusy: import("solid-js").Accessor<boolean>;
+    layoutReport: import("solid-js").Accessor<import("../engines/layout-engine").LayoutReport | null>;
+    setLayoutReport: import("solid-js").Setter<import("../engines/layout-engine").LayoutReport | null>;
+    layoutPreview: import("solid-js").Accessor<import("./session/layout").LayoutPreview | null>;
+    labScope: import("solid-js").Accessor<import("./session/layout").LabScope>;
+    setLabScope: import("solid-js").Setter<import("./session/layout").LabScope>;
+    labEngine: import("solid-js").Accessor<import("../model/types").LayoutAlgorithmId | null>;
+    setLabEngine: import("solid-js").Setter<import("../model/types").LayoutAlgorithmId | null>;
+    layoutCheckpoint: import("solid-js").Accessor<import("../model/types").Diagram | null>;
+    currentScope: () => {
+        scope: import("../engines/layout-engine").LayoutScope;
+        containerId?: string;
+    };
+    layoutTarget: () => "the whole diagram" | "the selection and its neighbours" | "this group" | "the selection";
+    setFixedIdsProvider: (provider: () => string[]) => () => string[];
+    fixedIds: () => string[];
+    cancelLayout: () => void;
+    runLayout: (options?: import("./session/layout").RunLayoutOptions) => Promise<import("./session/layout").LayoutOutcome>;
+    runLabLayout: (mode?: "pass" | "rebuild", preview?: boolean, settings?: import("../engines/layout-engine").LayoutOptions) => Promise<import("./session/layout").LayoutOutcome>;
+    previewSettings: (patch: Partial<Pick<import("../engines/layout-engine").LayoutOptions, "direction" | "aspect">>) => Promise<void>;
+    arrangeScope: () => string | null;
+    movesBlocked: () => string | null;
+    rebuildBlocked: () => string | null;
+    routesBlocked: () => string | null;
+    previewShape: (change: import("../dsl/layout-edits").ShapeChange) => Promise<import("./session/layout").LayoutOutcome>;
+    previewRouting: (routing: import("../model/types").RoutingSettings) => Promise<import("./session/layout").LayoutOutcome>;
+    acceptPreview: () => void;
+    discardPreview: () => void;
+    holdPreviewBefore: (held: boolean) => void;
+    updateLayoutSettings: (patch: Partial<import("../model/types").Diagram["settings"]>) => void;
+    captureCheckpoint: () => void;
+    setDocumentOpener: (open: (doc: import("../model/types").Diagram, label: string) => void) => (doc: import("../model/types").Diagram, label: string) => void;
+    restoreCheckpoint: () => void;
+} & {
+    inlineDraft: import("solid-js").Accessor<string>;
+    setInlineDraft: import("solid-js").Setter<string>;
+    setToolInterceptor: (fn: (tool: import("./session/editor").Tool) => boolean) => (tool: import("./session/editor").Tool) => boolean;
+    setTool: (next: import("./session/editor").Tool) => void;
+    startInlineEdit: (id: string) => void;
+    finishInlineEdit: (save?: boolean) => void;
+    addNode: (partial?: import("../model/edits").NewNode, at?: import("../model/types").Point, edit?: boolean) => string;
+    addEdge: (partial: import("../model/edits").NewEdge) => string;
+    completeConnection: (targetId: string, side?: import("../model/types").Side | "auto") => void;
+    quickExtend: ({ side, sibling, at, from, }?: {
+        side?: import("../model/types").Side | null;
+        sibling?: boolean;
+        at?: import("../model/types").Point | null;
+        from?: string | null;
+    }) => string | undefined;
+    insertStep: (edgeId: string, at?: import("../model/types").Point | null) => string | undefined;
+    buildFromList: (lines: string[], options?: {
+        mode?: import("../model/edits").BuildMode;
+        title?: string;
+        source?: string | null;
+        parentId?: string | null;
+    }) => string[];
+    wrapSelection: () => string;
+    drawContainer: (rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }) => void;
+    deleteSelection: (deep?: boolean) => void;
+    ungroupSelection: () => void;
+    togglePin: () => void;
+    clearManualMarkers: () => void;
+    alignSelection: (kind: import("../model/edits").AlignKind) => void;
+    nudgeSelection: (dx: number, dy: number) => boolean;
+    setColor: (color: import("../model/types").Diagram["styles"][string]["color"]) => void;
+    chooseTheme: (theme: import("../model/appearance").ThemeId) => void;
+    setAppearanceOverrides: (patch: Partial<import("../model/appearance").AppearanceOverrides>, label?: string) => void;
+    setShade: (shade: import("../model/appearance").Shade | undefined) => void;
+    fitSelectedContainer: () => void;
+    toggleCollapse: (id?: string | undefined) => void;
+    reverseSelectedEdge: () => void;
+    resetSelectedBends: () => void;
+    setLayoutIntent: (role: import("../model/types").IntentRole, id: string | null, placement?: import("../model/types").IntentPlacement) => void;
+    markSelectedAs: (role: import("../model/types").IntentRole) => void;
+    addWaypointAt: (edgeId: string, point?: import("../model/types").Point) => void;
+    removeWaypoint: (edgeId: string, index: number) => void;
+    reroute: ({ auto }?: {
+        auto?: boolean | undefined;
+    }) => void;
+    toggleTheme: () => void;
+    copySelection: () => import("../model/edits").ClipboardFragment | null;
+    hasClipboard: () => boolean;
+    pasteFragment: (part?: import("../model/edits").ClipboardFragment | null) => void;
+    duplicateSelection: () => void;
+    openDocument: (input: unknown, { fit, label }?: {
+        fit?: boolean | undefined;
+        label?: string | undefined;
+    }) => import("../model/types").Diagram;
+    newDocument: () => void;
+    openSample: (id: string) => import("../model/types").Diagram | undefined;
+} & {
+    setRouting: (patch: Partial<import("../model/types").RoutingSettings>, label: string) => void;
+    applyRoutePreset: (preset: import("./session/routing").RoutePreset) => void;
+    activeRoutePreset: () => "Balanced" | "Fewer crossings" | null;
+} & {
+    importTimeline: (input: unknown) => void;
+    timeline: import("solid-js").Accessor<import("./session/sculpt").TimelineState | null>;
+    playing: import("solid-js").Accessor<boolean>;
+    brushActive: import("solid-js").Accessor<boolean>;
+    brushSettings: import("solid-js").Accessor<import("../engines/sculpt-engine").BrushSettings>;
+    brushPoint: import("solid-js").Accessor<import("../model/types").Point | null>;
+    brushHover: import("solid-js").Accessor<import("../engines/sculpt-engine").DabResult | null>;
+    stroking: import("solid-js").Accessor<boolean>;
+    restoreKey: import("solid-js").Accessor<boolean>;
+    referenceLabel: import("solid-js").Accessor<string>;
+    timelineOpen: () => boolean;
+    sculptInteracting: () => boolean;
+    heldIds: () => string[];
+    restoreArchive: () => void;
+    openTimeline: (options?: Record<string, unknown>) => Promise<void>;
+    closeTimeline: () => void;
+    scrub: (index: number, { peek }?: {
+        peek?: boolean | undefined;
+    }) => number | undefined;
+    endPeek: () => void;
+    setGhost: (ghost: import("./session/sculpt").GhostMode) => void;
+    bookmarkStep: () => void;
+    keepStep: ({ brush }?: {
+        brush?: boolean | undefined;
+    }) => boolean;
+    stopPlayback: () => void;
+    togglePlayback: () => void;
+    fitTimelinePath: (reservedBottom: number) => void;
+    reopenTimeline: () => void;
+    saveTimelineFile: () => void;
+    activateBrush: (options?: Partial<import("../engines/sculpt-engine").BrushSettings>) => void;
+    deactivateBrush: () => void;
+    toggleBrush: () => void;
+    updateBrushSettings: (patch: Partial<import("../engines/sculpt-engine").BrushSettings>) => void;
+    useCurrentAsReference: () => void;
+    brushPointerDown: (e: PointerEvent, target: Element) => boolean;
+    brushPointerMove: (e: PointerEvent) => boolean;
+    brushPointerUp: (e?: PointerEvent) => boolean;
+    brushPointerLeave: () => void;
+    cancelStroke: () => boolean;
+    brushDab: (point?: import("../model/types").Point) => import("../engines/sculpt-engine").DabResult;
+    clearHolds: () => void;
+    sculptUndo: () => boolean;
+    sculptKey: (e: KeyboardEvent) => boolean;
+    sculptBlur: () => void;
+    sculptBeforeUnload: () => void;
+    hasArchivedTimeline: import("solid-js").Accessor<boolean>;
+    setComparisonCloser: (fn: () => void) => () => void;
+} & {
+    isDragging: () => boolean;
+    cancelGesture: () => void;
+    resetModifiers: () => void;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent | null) => void;
+    onDoubleClick: (e: MouseEvent) => void;
+    selectForContextMenu: (e: MouseEvent) => void;
+    dragKind: () => string | undefined;
+};

package/dist/types/src/state/canvas-commands.d.ts

@@ -0,0 +1,169 @@
+export interface Command {
+    label: string;
+    /** Shortcut shown in menus. */
+    keys?: string;
+    icon?: string;
+    /** What it does, in a sentence: shown in tooltips and the palette. */
+    hint?: string;
+    run: () => unknown;
+    /** Allowed while a timeline preview is open. */
+    duringTimeline?: boolean;
+    /** Exits the brush before running. */
+    endsBrush?: boolean;
+    enabled?: () => boolean;
+    /** Why this cannot work here, shown instead of running it. */
+    blocked?: () => string | null;
+}
+declare function undoCommand(): void;
+declare function redoCommand(): void;
+export declare const hasSelection: () => boolean;
+export declare const canvasCommands: {
+    undo: {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: typeof undoCommand;
+        duringTimeline: true;
+        enabled: () => boolean;
+    };
+    redo: {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: typeof redoCommand;
+        enabled: () => boolean;
+    };
+    'add-node': {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+    };
+    'add-connected': {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => string | undefined;
+    };
+    duplicate: {
+        hint: string;
+        enabled: () => boolean;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+    };
+    group: {
+        hint: string;
+        enabled: () => boolean;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => string;
+    };
+    ungroup: {
+        hint: string;
+        enabled: () => boolean;
+        label: string;
+        keys: string;
+        run: () => void;
+    };
+    pin: {
+        hint: string;
+        enabled: () => boolean;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+    };
+    delete: {
+        hint: string;
+        label: string;
+        enabled: () => boolean;
+        keys: string;
+        icon: string;
+        run: () => void;
+    };
+    'delete-deep': {
+        label: string;
+        keys: string;
+        run: () => void;
+    };
+    layout: {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => Promise<import("./session/layout").LayoutOutcome>;
+        blocked: () => string | null;
+        endsBrush: true;
+    };
+    'layout-rebuild': {
+        hint: string;
+        label: string;
+        keys: string;
+        run: () => Promise<import("./session/layout").LayoutOutcome>;
+        blocked: () => string | null;
+        endsBrush: true;
+    };
+    'layout-accept': {
+        label: string;
+        run: () => void;
+    };
+    'layout-discard': {
+        label: string;
+        run: () => void;
+    };
+    reroute: {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+    };
+    'auto-ports': {
+        hint: string;
+        label: string;
+        keys: string;
+        run: () => void;
+    };
+    fit: {
+        hint: string;
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+        duringTimeline: true;
+    };
+    'zoom-in': {
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+        duringTimeline: true;
+    };
+    'zoom-out': {
+        label: string;
+        keys: string;
+        icon: string;
+        run: () => void;
+        duringTimeline: true;
+    };
+    'reset-camera': {
+        label: string;
+        keys: string;
+        run: () => void;
+        duringTimeline: true;
+    };
+};
+export type CanvasCommandId = keyof typeof canvasCommands;
+/** Run `command` unless a timeline preview or its own check blocks it, reporting failures. */
+export declare function runChecked(id: string, command: Command): undefined;
+export declare const checkedEnabled: (command: Command) => boolean;
+export declare const runCanvasCommand: (id: CanvasCommandId) => undefined;
+export declare const canvasCommandEnabled: (id: CanvasCommandId) => boolean;
+export {};

package/dist/types/src/state/canvas-keyboard.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Canvas shortcuts and shape copy and paste for the active session. The app runs its own keys
+ * around these in `keyboard.ts`; an embedded editor uses them as they are.
+ */
+export declare const isEditable: (el: EventTarget | null) => boolean;
+/**
+ * Run the canvas shortcut for `e`. True when the key was used, or belongs to a field, so the host
+ * should not act on it. `closeMenu` lets Escape close the host's open menu, before it clears the
+ * selection; it returns true when it closed one.
+ */
+export declare function handleCanvasKey(e: KeyboardEvent, closeMenu?: () => boolean): boolean;
+export declare function handleKeyUp(e: KeyboardEvent): void;
+export declare function copyShapes(e: ClipboardEvent): void;
+/** Paste copied shapes: from the clipboard text, or the session's own copy when it is empty. */
+export declare function pasteShapes(e: ClipboardEvent): void;

package/dist/types/src/state/keys.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The lower-case key for a shortcut. With Alt (Option on a Mac) the typed character changes,
+ * e.g. Option+L types "¬", so letter and digit shortcuts use the physical key instead.
+ */
+export declare function shortcutKey(e: KeyboardEvent): string;