oasis-editor 0.0.76 → 0.0.78

package/dist/ui/app/EditorWorkspace.d.ts

@@ -8,15 +8,18 @@ import { EditorLayoutParagraph, EditorState } from '../../core/model.js';
 import { ToolbarLayoutMode, ToolbarViewMode } from '../OasisEditorAppProps.js';
 import { OasisEditor } from '../../core/plugin.js';
 
-export interface EditorWorkspaceProps {
-    useComposedShell: () => boolean;
-    shellComponent: () => (props: ShellProps) => ReturnType<typeof OasisEditorEditor>;
+/** Runtime facade the workspace forwards to the editor surface and shell. */
+export interface EditorWorkspaceRuntime {
     state: Accessor<EditorState>;
     toolbarHost: () => ToolbarHost;
     runtimeEditor: Accessor<OasisEditor>;
     persistenceStatus: () => string;
     toolbarRegistry: ToolbarRegistry;
     menuRegistry: MenuRegistry;
+    showFloatingTableToolbar: Accessor<boolean>;
+}
+/** Chrome visibility / toolbar-mode flags. */
+export interface EditorWorkspaceChrome {
     showChrome: () => boolean;
     showTitleBar: () => boolean;
     showMenubar: () => boolean;
@@ -24,11 +27,13 @@ export interface EditorWorkspaceProps {
     showOutline: () => boolean;
     toolbarView: () => ToolbarViewMode;
     toolbarLayout: () => ToolbarLayoutMode;
+}
+/** The document-view props: read-only/sizing plus the assembled prop bundles. */
+export interface EditorWorkspaceView {
     isReadOnly: () => boolean;
     viewportHeight: () => number | string | undefined;
     measuredBlockHeights: Accessor<Record<string, number>>;
     measuredParagraphLayouts: Accessor<Record<string, EditorLayoutParagraph>>;
-    showFloatingTableToolbar: Accessor<boolean>;
     layout: OasisEditorEditorLayoutProps;
     overlays: OasisEditorEditorOverlayProps;
     refs: OasisEditorEditorRefProps;
@@ -36,6 +41,13 @@ export interface EditorWorkspaceProps {
     inputHandlers: OasisEditorEditorInputHandlers;
     fileHandlers: OasisEditorEditorFileHandlers;
 }
+export interface EditorWorkspaceProps {
+    useComposedShell: () => boolean;
+    shellComponent: () => (props: ShellProps) => ReturnType<typeof OasisEditorEditor>;
+    runtime: EditorWorkspaceRuntime;
+    chrome: EditorWorkspaceChrome;
+    view: EditorWorkspaceView;
+}
 /**
  * Renders the editor body, choosing between the composed shell (docs/inline/
  * balloon chrome) and the bare canvas editor. Pure binding: it forwards the

package/dist/ui/app/connectEditorClientHost.d.ts

@@ -0,0 +1,31 @@
+import { EditorDocument, EditorState } from '../../core/model.js';
+import { OasisEditorClientController } from '../../app/client/OasisEditorClient.js';
+import { createEditorDocumentIO } from '../../app/controllers/useEditorDocumentIO.js';
+import { useEditorRuntimeBootstrap } from './useEditorRuntimeBootstrap.js';
+
+type RuntimeEditorAccessor = ReturnType<typeof useEditorRuntimeBootstrap>["runtimeEditor"];
+type EditorDocumentIO = ReturnType<typeof createEditorDocumentIO>;
+export interface ConnectEditorClientHostDeps {
+    runtimeReady: () => boolean;
+    runtimeEditor: RuntimeEditorAccessor;
+    getStateSnapshot: () => EditorState;
+    cloneState: (state: EditorState) => EditorState;
+    applyState: (next: EditorState) => void;
+    resetEditorChromeState: () => void;
+    focusInput: () => void;
+    setFocused: (focused: boolean) => void;
+    clearHistory: () => void;
+    getPersistence: () => {
+        saveDocument: (document: EditorDocument) => Promise<void> | void;
+    };
+    docIO: Pick<EditorDocumentIO, "handleImportFile" | "handleExportDocx" | "handleExportPdf">;
+}
+/**
+ * Wires the imperative `OasisEditorClient` host surface (get/set document,
+ * selection, save, focus, import/export) onto the editor's state and IO
+ * controllers. Pure callback wiring with no reactive ownership, extracted from
+ * `OasisEditorApp` so the composition root no longer hosts the public client
+ * adapter inline (S1).
+ */
+export declare function connectEditorClientHost(controller: OasisEditorClientController, deps: ConnectEditorClientHostDeps): void;
+export {};

package/dist/ui/app/createAppCommandsController.d.ts

@@ -0,0 +1,112 @@
+import { EditorState } from '../../core/model.js';
+import { SelectedImageRun } from '../../core/commands/image.js';
+import { BooleanStyleKey, ToolbarStyleState } from '../toolbarStyleState.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { EditorTransactionPort } from '../../app/controllers/controllerPorts.js';
+import { createEditorTableOperations } from '../../app/controllers/useEditorTableOperations.js';
+
+type EditorTableOperations = ReturnType<typeof createEditorTableOperations>;
+export interface AppCommandsControllerDeps {
+    state: EditorState;
+    logger: EditorLogger;
+    applyState: EditorTransactionPort["applyState"];
+    applyTransactionalState: EditorTransactionPort["applyTransactionalState"];
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    focusInput: () => void;
+    selectedImageRun: () => SelectedImageRun | null;
+    tableOps: Pick<EditorTableOperations, "applySelectionAwareTextCommand" | "applySelectionAwareParagraphCommand" | "applyTableAwareParagraphEdit">;
+    toolbarStyleState: () => ToolbarStyleState;
+    applyBooleanStyleCommand: (style: BooleanStyleKey) => void;
+    locale: () => string;
+    setLinkDialog: (state: {
+        isOpen: boolean;
+        initialHref: string;
+    }) => void;
+    setImageAltDialog: (state: {
+        isOpen: boolean;
+        initialAlt: string;
+    }) => void;
+    setImageCaptionDialog: (state: {
+        isOpen: boolean;
+        initialCaption: string;
+    }) => void;
+}
+/**
+ * Builds the command controller (and its keyboard-flavoured variant that adds
+ * `applyBooleanStyleCommand`) from the editor's collaborators, owning the inline
+ * dialog-opener closures and the locale-derived caption label. Extracted from
+ * `OasisEditorApp` so the composition root no longer maps these payload/dialog
+ * callbacks by hand (S1).
+ */
+export declare function createAppCommandsController(deps: AppCommandsControllerDeps): {
+    commandsController: {
+        applyBooleanStyleCommand: (key: BooleanStyleKey) => void;
+        applyValueStyleCommand: <K extends "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language" | "textEffect" | "link" | "underlineStyle">(key: K, value: import('../../core/model.js').EditorTextStyle[K] | null) => void;
+        applyChangeTextCaseCommand: (mode: import('../../core/commands/textCase').TextCaseMode) => void;
+        applyClearFormattingCommand: () => void;
+        applyParagraphStyleCommand: <K extends import('../toolbarStyleState.js').ParagraphStyleKey>(key: K, value: import('../../core/model.js').EditorParagraphStyle[K] | null) => void;
+        toggleParagraphFlagCommand: (key: "pageBreakBefore" | "keepWithNext") => void;
+        applyParagraphListCommand: (kind: NonNullable<import('../../core/model.js').EditorParagraphListStyle["kind"]>) => void;
+        handleListFormatChange: (format: import('../../core/model.js').EditorParagraphListStyle["format"]) => void;
+        handleListStartAtChange: (startAt: number | null) => void;
+        applyInsertSectionBreakCommand: (breakType: "nextPage" | "continuous") => void;
+        applyInsertPageBreakCommand: () => void;
+        canInsertFootnoteCommand: () => boolean;
+        applyInsertFootnoteCommand: () => void;
+        handleStyleChange: (styleId: string) => void;
+        applyUpdateSectionSettingsCommand: (sectionIndex: number, settings: Partial<import('../../core/model.js').EditorSection>) => void;
+        applyToggleTrackChangesCommand: () => void;
+        applyToggleShowMarginsCommand: () => void;
+        applyToggleShowParagraphMarksCommand: () => void;
+        applyAcceptRevisionsCommand: () => void;
+        applyRejectRevisionsCommand: () => void;
+        applyLinkCommand: (href: string | null) => void;
+        promptForLink: () => void;
+        removeLinkCommand: () => void;
+        applyImageAltCommand: (alt: string) => void;
+        promptForImageAlt: () => void;
+        applyImageCaptionCommand: (caption: string) => void;
+        promptForImageCaption: () => void;
+        handleListTab: (direction: "indent" | "outdent") => boolean;
+        handleListEnter: () => boolean;
+        handleListBoundaryBackspace: (event: KeyboardEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => boolean;
+    };
+    keyboardCommandsController: {
+        applyBooleanStyleCommand: (style: BooleanStyleKey) => void;
+        applyValueStyleCommand: <K extends "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language" | "textEffect" | "link" | "underlineStyle">(key: K, value: import('../../core/model.js').EditorTextStyle[K] | null) => void;
+        applyChangeTextCaseCommand: (mode: import('../../core/commands/textCase').TextCaseMode) => void;
+        applyClearFormattingCommand: () => void;
+        applyParagraphStyleCommand: <K extends import('../toolbarStyleState.js').ParagraphStyleKey>(key: K, value: import('../../core/model.js').EditorParagraphStyle[K] | null) => void;
+        toggleParagraphFlagCommand: (key: "pageBreakBefore" | "keepWithNext") => void;
+        applyParagraphListCommand: (kind: NonNullable<import('../../core/model.js').EditorParagraphListStyle["kind"]>) => void;
+        handleListFormatChange: (format: import('../../core/model.js').EditorParagraphListStyle["format"]) => void;
+        handleListStartAtChange: (startAt: number | null) => void;
+        applyInsertSectionBreakCommand: (breakType: "nextPage" | "continuous") => void;
+        applyInsertPageBreakCommand: () => void;
+        canInsertFootnoteCommand: () => boolean;
+        applyInsertFootnoteCommand: () => void;
+        handleStyleChange: (styleId: string) => void;
+        applyUpdateSectionSettingsCommand: (sectionIndex: number, settings: Partial<import('../../core/model.js').EditorSection>) => void;
+        applyToggleTrackChangesCommand: () => void;
+        applyToggleShowMarginsCommand: () => void;
+        applyToggleShowParagraphMarksCommand: () => void;
+        applyAcceptRevisionsCommand: () => void;
+        applyRejectRevisionsCommand: () => void;
+        applyLinkCommand: (href: string | null) => void;
+        promptForLink: () => void;
+        removeLinkCommand: () => void;
+        applyImageAltCommand: (alt: string) => void;
+        promptForImageAlt: () => void;
+        applyImageCaptionCommand: (caption: string) => void;
+        promptForImageCaption: () => void;
+        handleListTab: (direction: "indent" | "outdent") => boolean;
+        handleListEnter: () => boolean;
+        handleListBoundaryBackspace: (event: KeyboardEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => boolean;
+    };
+};
+export {};

package/dist/ui/app/createEditorChangeBroadcast.d.ts

@@ -0,0 +1,19 @@
+import { EditorState } from '../../core/model.js';
+import { OasisEditorClientController } from '../../app/client/OasisEditorClient.js';
+
+export interface EditorChangeBroadcastDeps {
+    state: EditorState;
+    isImportInProgress: () => boolean;
+    cloneState: (state: EditorState) => EditorState;
+    getStateSnapshot: () => EditorState;
+    getOnStateChange: () => ((snapshot: EditorState) => void) | undefined;
+    emit: OasisEditorClientController["emit"];
+}
+/**
+ * Sets up the reactive effect that mirrors document/selection changes out to the
+ * host: records the canvas-debug selection, then (when not mid-import) notifies
+ * `onStateChange` and emits the client `change`/`documentChange`/`selectionChange`
+ * events. Must be called synchronously within the component owner so the effect
+ * is tracked. Extracted from `OasisEditorApp` (S1).
+ */
+export declare function createEditorChangeBroadcast(deps: EditorChangeBroadcastDeps): void;

package/dist/ui/app/createEditorChrome.d.ts

@@ -0,0 +1,57 @@
+import { EditorSelection, EditorState } from '../../core/model.js';
+import { ToolbarStyleState } from '../toolbarStyleState.js';
+import { TranslateFn } from '../../i18n/index.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { createEditorTableOperations } from '../../app/controllers/useEditorTableOperations.js';
+import { FontDialogInitialValues } from '../components/Dialogs/FontDialog.js';
+import { ParagraphDialogInitialValues } from '../components/Dialogs/ParagraphDialog.js';
+import { TablePropertiesDialogInitialValues } from '../components/Dialogs/TablePropertiesDialog.js';
+
+type EditorTableOperations = ReturnType<typeof createEditorTableOperations>;
+interface DialogState<TInitial> {
+    isOpen: boolean;
+    initial: TInitial;
+}
+interface ContextMenuState {
+    isOpen: boolean;
+    x: number;
+    y: number;
+}
+export interface EditorChromeDeps {
+    state: () => EditorState;
+    selection: () => EditorSelection;
+    toolbarStyleState: () => ToolbarStyleState;
+    isReadOnly: () => boolean;
+    t: TranslateFn;
+    logger: EditorLogger;
+    setFontDialog: (state: DialogState<FontDialogInitialValues>) => void;
+    setParagraphDialog: (state: DialogState<ParagraphDialogInitialValues>) => void;
+    setTablePropertiesDialog: (state: DialogState<TablePropertiesDialogInitialValues>) => void;
+    setContextMenu: (state: ContextMenuState) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    applyTableAwareParagraphEdit: (state: EditorState, edit: (state: EditorState) => EditorState) => EditorState;
+    focusInput: () => void;
+    promptForLink: () => void;
+    tableOps: EditorTableOperations;
+}
+/**
+ * Owns the editor "chrome": font option catalogues, the font/paragraph/table
+ * dialog bridges and the context-menu clipboard wiring. Extracted from
+ * `OasisEditorApp` so the composition root only creates and renders contexts
+ * instead of mapping every dialog/menu callback by hand (S1).
+ */
+export declare function createEditorChrome(deps: EditorChromeDeps): {
+    computeFontFamilyOptions: () => string[];
+    computeFontSizeOptions: () => number[];
+    applyFontDialogValues: (values: import('../components/Dialogs/FontDialog.js').FontDialogApplyValues, original: FontDialogInitialValues) => void;
+    applyParagraphDialogValues: (values: import('../components/Dialogs/ParagraphDialog.js').ParagraphDialogApplyValues, original: ParagraphDialogInitialValues) => void;
+    applyTablePropertiesDialogValues: (values: import('../components/Dialogs/TablePropertiesDialog.js').TablePropertiesDialogApplyValues) => void;
+    buildContextMenuItems: () => import('../components/ContextMenu/ContextMenu.jsx').ContextMenuItem[];
+    handleEditorContextMenu: (event: MouseEvent) => void;
+    closeContextMenu: () => void;
+};
+export {};

package/dist/ui/app/createEditorCommandRuntime.d.ts

@@ -0,0 +1,106 @@
+import { BooleanStyleKey } from '../toolbarStyleState.js';
+import { EditorState } from '../../core/model.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { OasisEditorClientController } from '../../app/client/OasisEditorClient.js';
+import { TranslateFn } from '../../i18n/index.js';
+import { createEditorDocumentRuntime } from './createEditorDocumentRuntime.js';
+import { createEditorInteractionRuntime } from './createEditorInteractionRuntime.js';
+import { OasisEditorAppDocumentProps, OasisEditorAppRuntimeProps } from '../OasisEditorAppProps.js';
+
+type DocumentRuntime = ReturnType<typeof createEditorDocumentRuntime>;
+type InteractionRuntime = ReturnType<typeof createEditorInteractionRuntime>;
+interface LinkDialogSetter {
+    (state: {
+        isOpen: boolean;
+        initialHref: string;
+    }): void;
+}
+export interface EditorCommandRuntimeDeps {
+    document: DocumentRuntime;
+    interaction: InteractionRuntime;
+    state: EditorState;
+    logger: EditorLogger;
+    isReadOnly: () => boolean;
+    focusInput: () => void;
+    applyState: (next: EditorState) => void;
+    getStateSnapshot: () => EditorState;
+    cloneState: (state: EditorState) => EditorState;
+    setFocused: (focused: boolean) => void;
+    setInitialLoading: (loading: boolean) => void;
+    getForcePlainTextPaste: () => boolean;
+    setForcePlainTextPaste: (value: boolean) => void;
+    locale: () => string;
+    translator: TranslateFn;
+    runtimeClient: OasisEditorClientController;
+    runtimeOptions: () => OasisEditorAppRuntimeProps;
+    documentOptions: () => OasisEditorAppDocumentProps;
+    importInputRef: () => HTMLInputElement | undefined;
+    imageInputRef: () => HTMLInputElement | undefined;
+    setLinkDialog: LinkDialogSetter;
+    setImageAltDialog: (state: {
+        isOpen: boolean;
+        initialAlt: string;
+    }) => void;
+    setImageCaptionDialog: (state: {
+        isOpen: boolean;
+        initialCaption: string;
+    }) => void;
+}
+/**
+ * Phase C of the editor runtime: the command controller, the public runtime
+ * bootstrap (plugins/toolbar/menu), the imperative client host wiring, the
+ * runtime dispatch effect and the keyboard binding. Runs synchronously after
+ * the document and interaction runtimes, preserving creation order. Reads the
+ * earlier phases through their returned bags. Extracted from `OasisEditorApp`
+ * (S1).
+ */
+export declare function createEditorCommandRuntime(deps: EditorCommandRuntimeDeps): {
+    commandsController: {
+        applyBooleanStyleCommand: (key: BooleanStyleKey) => void;
+        applyValueStyleCommand: <K extends "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language" | "textEffect" | "link" | "underlineStyle">(key: K, value: import('../../core/model.js').EditorTextStyle[K] | null) => void;
+        applyChangeTextCaseCommand: (mode: import('../../core/commands/textCase.js').TextCaseMode) => void;
+        applyClearFormattingCommand: () => void;
+        applyParagraphStyleCommand: <K extends import('../toolbarStyleState.js').ParagraphStyleKey>(key: K, value: import('../../core/model.js').EditorParagraphStyle[K] | null) => void;
+        toggleParagraphFlagCommand: (key: "pageBreakBefore" | "keepWithNext") => void;
+        applyParagraphListCommand: (kind: NonNullable<import('../../core/model.js').EditorParagraphListStyle["kind"]>) => void;
+        handleListFormatChange: (format: import('../../core/model.js').EditorParagraphListStyle["format"]) => void;
+        handleListStartAtChange: (startAt: number | null) => void;
+        applyInsertSectionBreakCommand: (breakType: "nextPage" | "continuous") => void;
+        applyInsertPageBreakCommand: () => void;
+        canInsertFootnoteCommand: () => boolean;
+        applyInsertFootnoteCommand: () => void;
+        handleStyleChange: (styleId: string) => void;
+        applyUpdateSectionSettingsCommand: (sectionIndex: number, settings: Partial<import('../../core/model.js').EditorSection>) => void;
+        applyToggleTrackChangesCommand: () => void;
+        applyToggleShowMarginsCommand: () => void;
+        applyToggleShowParagraphMarksCommand: () => void;
+        applyAcceptRevisionsCommand: () => void;
+        applyRejectRevisionsCommand: () => void;
+        applyLinkCommand: (href: string | null) => void;
+        promptForLink: () => void;
+        removeLinkCommand: () => void;
+        applyImageAltCommand: (alt: string) => void;
+        promptForImageAlt: () => void;
+        applyImageCaptionCommand: (caption: string) => void;
+        promptForImageCaption: () => void;
+        handleListTab: (direction: "indent" | "outdent") => boolean;
+        handleListEnter: () => boolean;
+        handleListBoundaryBackspace: (event: KeyboardEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => boolean;
+    };
+    runtimeReady: import('solid-js').Accessor<boolean>;
+    runtimeEditor: import('solid-js').Accessor<import('../../index.js').Editor>;
+    commandStateOf: (commandRef: import('../../index.js').CommandRef) => {
+        isEnabled: boolean;
+        isActive: boolean;
+        value: unknown;
+    };
+    toolbarHost: () => import('../components/Toolbar/state/createToolbarApi.js').ToolbarHost;
+    toolbarRegistry: import('../../index.js').ToolbarRegistry;
+    menuRegistry: import('../../index.js').MenuRegistry;
+    handleKeyDown: (event: KeyboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+};
+export {};

package/dist/ui/app/createEditorDocumentRuntime.d.ts

@@ -0,0 +1,85 @@
+import { EditorState } from '../../core/model.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { OasisEditorClientController } from '../../app/client/OasisEditorClient.js';
+import { createEditorImageOperations } from '../../app/controllers/useEditorImageOperations.js';
+import { OasisEditorAppDocumentProps } from '../OasisEditorAppProps.js';
+
+type EditorImageOperations = ReturnType<typeof createEditorImageOperations>;
+export interface EditorDocumentRuntimeDeps {
+    documentOptions: () => OasisEditorAppDocumentProps;
+    logger: EditorLogger;
+    runtimeClient: OasisEditorClientController;
+    /**
+     * Document state, created by the app before this runtime so its store signal
+     * keeps its original creation position (no signal reordering).
+     */
+    state: EditorState;
+    commitState: (next: EditorState) => void;
+    getStateSnapshot: () => EditorState;
+    applyState: (next: EditorState) => void;
+    cloneState: (state: EditorState) => EditorState;
+    isReadOnly: () => boolean;
+    focusInput: () => void;
+    surfaceRef: () => HTMLDivElement | undefined;
+    viewportRef: () => HTMLDivElement | undefined;
+    zoomFactor: () => number;
+    /**
+     * Back-edge to the interaction runtime: history's image-move actions read the
+     * image operations, which are created after this runtime. Read lazily so the
+     * synchronous creation order is preserved (the getter is only invoked at
+     * command time). [[i1-controller-ports]]
+     */
+    getImageOps: () => EditorImageOperations;
+}
+/**
+ * Phase A of the editor runtime: document state, IO, layout measurement,
+ * persistence, the transaction/history machinery and the change-broadcast
+ * effect. Runs synchronously within the component owner, in the original
+ * creation order, so every signal/effect stays bound exactly as before.
+ * Extracted from `OasisEditorApp` (S1).
+ */
+export declare function createEditorDocumentRuntime(deps: EditorDocumentRuntimeDeps): {
+    docIO: {
+        importProgress: import('solid-js').Accessor<import('../../app/controllers/useEditorDocumentIO.js').ImportProgressState | null>;
+        handleImportFile: (file: File | null) => Promise<void>;
+        handleExportDocx: () => Promise<void>;
+        handleExportPdf: () => Promise<void>;
+        insertImageFromFile: (file: File, position?: import('../../core/model.js').EditorPosition | null) => Promise<void>;
+        handleInsertImage: (file: File | null) => Promise<void>;
+    };
+    isImportInProgress: () => boolean;
+    measuredBlockHeights: import('solid-js').Accessor<Record<string, number>>;
+    measuredParagraphLayouts: import('solid-js').Accessor<Record<string, import('../../core/model.js').EditorLayoutParagraph>>;
+    inputBox: import('solid-js').Accessor<import('../editorUiTypes.js').InputBox>;
+    selectionBoxes: import('solid-js').Accessor<import('../editorUiTypes.js').SelectionBox[]>;
+    commentHighlights: import('solid-js').Accessor<import('../editorUiTypes.js').CommentHighlightBox[]>;
+    selectedImageBox: import('solid-js').Accessor<import('../canvas/CanvasSelectionGeometry.js').SelectedImageSelectionBox | null>;
+    selectedTextBoxBox: import('solid-js').Accessor<import('../canvas/CanvasSelectionGeometry.js').SelectedTextBoxSelectionBox | null>;
+    caretBox: import('solid-js').Accessor<import('../editorUiTypes.js').CaretBox>;
+    preferredColumnX: import('solid-js').Accessor<number | null>;
+    setPreferredColumnX: import('solid-js').Setter<number | null>;
+    clearPreferredColumn: () => null;
+    stabilizeLayoutAfterImport: () => Promise<void>;
+    setMeasuredBlockHeights: import('solid-js').Setter<Record<string, number>>;
+    setMeasuredParagraphLayouts: import('solid-js').Setter<Record<string, import('../../core/model.js').EditorLayoutParagraph>>;
+    applyLayoutInvalidation: (invalidation: import('../../app/controllers/useEditorLayout.js').LayoutInvalidation) => void;
+    onCleanupHook: () => void;
+    fallbackPersistence: import('../../app/services/indexedDbPersistence.js').IndexedDbPersistence;
+    persistenceStatus: () => import('../../app/controllers/useEditorPersistence.js').PersistenceStatus;
+    undoStack: import('solid-js').Accessor<EditorState[]>;
+    redoStack: import('solid-js').Accessor<EditorState[]>;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: import('../editorHistory.js').EditorTransactionOptions) => void;
+    applyHistoryState: (nextState: EditorState) => void;
+    resetTransactionGrouping: () => void;
+    updateHistoryState: (updater: (current: import('../editorHistory.js').EditorHistoryState) => import('../editorHistory.js').EditorHistoryState) => void;
+    getHistoryState: () => import('../editorHistory.js').EditorHistoryState;
+    clearHistory: () => void;
+    historyActions: {
+        performUndo: () => void;
+        performRedo: () => void;
+        moveSelectedImageByParagraph: (direction: -1 | 1) => boolean;
+        applySelectionPreservingStructure: (nextSelection: EditorState["selection"]) => void;
+    };
+    resetEditorChromeState: () => void;
+};
+export {};