oasis-editor 0.0.1

package/dist/plugins/internal/createEssentialsPlugin.d.ts

@@ -0,0 +1,135 @@
+import { OasisPlugin } from '../../../../core/plugin.js';
+import { ToolbarStyleState } from '../../../../ui/toolbarStyleState.js';
+
+export interface EssentialsFeatureGate {
+    isCommandEnabled: (commandName: string) => boolean;
+}
+export interface EssentialsStyleCapability {
+    state: () => ToolbarStyleState;
+}
+export interface EssentialsHistoryCapability {
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    undo: () => boolean;
+    redo: () => boolean;
+}
+export interface EssentialsFormattingCapability {
+    selectAll: () => boolean;
+    insertFootnote: () => boolean;
+    pastePlainText: () => boolean;
+    bold: () => boolean;
+    italic: () => boolean;
+    underline: () => boolean;
+    strike: () => boolean;
+    superscript: () => boolean;
+    subscript: () => boolean;
+    alignLeft: () => boolean;
+    alignCenter: () => boolean;
+    alignRight: () => boolean;
+    alignJustify: () => boolean;
+    orderedList: () => boolean;
+    bulletList: () => boolean;
+    find: () => boolean;
+    replace: () => boolean;
+    toggleTrackChanges: () => boolean;
+    acceptRevisions: () => boolean;
+    rejectRevisions: () => boolean;
+    toggleShowMargins: () => boolean;
+    toggleShowParagraphMarks: () => boolean;
+    pageBreak: () => boolean;
+    lineBreak: () => boolean;
+    splitBlock: () => boolean;
+    setFontFamily: (value: string | null) => boolean;
+    setFontSize: (value: number | null) => boolean;
+    setColor: (value: string | null) => boolean;
+    setHighlight: (value: string | null) => boolean;
+    setStyleId: (value: string) => boolean;
+    setUnderlineStyle: (value: string | null) => void;
+}
+export interface EssentialsDocumentStyleDescriptor {
+    id: string;
+    name: string;
+    fontFamily?: string;
+    fontSize?: number;
+}
+export interface EssentialsDocumentCapability {
+    documentStyles: () => EssentialsDocumentStyleDescriptor[];
+    exportDocx: () => void;
+    exportPdf: () => void;
+    importDocx: () => void;
+    insertImage: () => void;
+}
+export interface EssentialsLinkCapability {
+    prompt: () => void;
+    remove: () => void;
+    canPrompt: () => boolean;
+}
+export interface EssentialsImageCapability {
+    promptAlt: () => void;
+    isSelected: () => boolean;
+}
+export interface EssentialsBrowserCapability {
+    print: () => void;
+    copy: () => void;
+}
+export interface EssentialsParagraphCapability {
+    togglePageBreakBefore: () => void;
+    toggleKeepWithNext: () => void;
+    setSpacingAfter: (value: number | null) => void;
+    setSpacingBefore: (value: number | null) => void;
+    setIndentLeft: (value: number | null) => void;
+    setIndentFirstLine: (value: number | null) => void;
+    setIndentHanging: (value: number | null) => void;
+    setShading: (value: string | null) => void;
+    applyBorders: () => void;
+    setLineHeight: (value: number | null) => void;
+    setListFormat: (format: string) => void;
+    setListStartAt: (value: number | null) => void;
+    outdent: () => void;
+    indent: () => void;
+}
+export interface EssentialsSectionCapability {
+    isLandscape: () => boolean;
+    toggleOrientation: () => void;
+    breakNextPage: () => void;
+    breakContinuous: () => void;
+}
+export interface EssentialsTableCapability {
+    insideTable: () => boolean;
+    selectionLabel: () => string | null;
+    canMerge: () => boolean;
+    canSplit: () => boolean;
+    canEditColumn: () => boolean;
+    canEditRow: () => boolean;
+    merge: () => void;
+    split: () => void;
+    insertColumnBefore: () => void;
+    insertColumnAfter: () => void;
+    deleteColumn: () => void;
+    insertRowBefore: () => void;
+    insertRowAfter: () => void;
+    deleteRow: () => void;
+    cellShading: (color: string | null) => void;
+    cellBorders: () => void;
+    cellNoBorders: () => void;
+    width100: () => void;
+    alignLeft: () => void;
+    alignCenter: () => void;
+    alignRight: () => void;
+    setCellWidth: (width: string) => void;
+    insert: (rows: number, cols: number) => void;
+}
+export interface EssentialsPluginDeps {
+    gate: EssentialsFeatureGate;
+    style: EssentialsStyleCapability;
+    history: EssentialsHistoryCapability;
+    formatting: EssentialsFormattingCapability;
+    document: EssentialsDocumentCapability;
+    link: EssentialsLinkCapability;
+    image: EssentialsImageCapability;
+    browser: EssentialsBrowserCapability;
+    paragraph: EssentialsParagraphCapability;
+    section: EssentialsSectionCapability;
+    table: EssentialsTableCapability;
+}
+export declare function createEssentialsPlugin(deps: EssentialsPluginDeps): OasisPlugin;

package/dist/plugins/internal/essentialsCommandBuilders.d.ts

@@ -0,0 +1,10 @@
+import { CommandState, OasisCommand } from '../../../../core/plugin.js';
+
+export type CommandEnabledResolver = (commandName: string) => boolean;
+export type CommandBuilder = (name: string, execute: () => boolean, state?: () => Partial<CommandState>) => OasisCommand;
+export type ValueCommandBuilder = (name: string, execute: (payload?: unknown) => boolean, value: () => unknown) => OasisCommand;
+export type ActionCommandBuilder = (name: string, execute: (payload?: unknown) => void, state?: () => Partial<CommandState>) => OasisCommand;
+export declare function createCommandBuilder(isCommandEnabled: CommandEnabledResolver): (name: string, execute: () => boolean, state?: () => Partial<CommandState>) => OasisCommand;
+export declare function createValueCommandBuilder(isCommandEnabled: CommandEnabledResolver): (name: string, execute: (payload?: unknown) => boolean, value: () => unknown) => OasisCommand;
+export declare function createActionCommandBuilder(isCommandEnabled: CommandEnabledResolver): (name: string, execute: (payload?: unknown) => void, state?: () => Partial<CommandState>) => OasisCommand;
+export declare function numOrNull(payload: unknown): number | null;

package/dist/plugins/internal/essentialsCommandGroups.d.ts

@@ -0,0 +1,39 @@
+import { OasisPlugin } from '../../../../core/plugin.js';
+import { ActionCommandBuilder, CommandBuilder, ValueCommandBuilder } from '../../essentialsCommandBuilders.js';
+import { EssentialsBrowserCapability, EssentialsDocumentCapability, EssentialsFeatureGate, EssentialsFormattingCapability, EssentialsHistoryCapability, EssentialsImageCapability, EssentialsLinkCapability, EssentialsParagraphCapability, EssentialsSectionCapability, EssentialsStyleCapability, EssentialsTableCapability } from '../../createEssentialsPlugin.js';
+
+interface CoreFormattingGroupDeps {
+    gate: EssentialsFeatureGate;
+    style: EssentialsStyleCapability;
+    history: EssentialsHistoryCapability;
+    formatting: EssentialsFormattingCapability;
+    link: EssentialsLinkCapability;
+    command: CommandBuilder;
+    valueCommand: ValueCommandBuilder;
+}
+interface DocumentAndBrowserGroupDeps {
+    gate: EssentialsFeatureGate;
+    style: EssentialsStyleCapability;
+    document: EssentialsDocumentCapability;
+    link: EssentialsLinkCapability;
+    image: EssentialsImageCapability;
+    browser: EssentialsBrowserCapability;
+    actionCommand: ActionCommandBuilder;
+}
+interface ParagraphAndSectionGroupDeps {
+    style: EssentialsStyleCapability;
+    paragraph: EssentialsParagraphCapability;
+    section: EssentialsSectionCapability;
+    valueCommand: ValueCommandBuilder;
+    actionCommand: ActionCommandBuilder;
+}
+interface TableGroupDeps {
+    gate: EssentialsFeatureGate;
+    table: EssentialsTableCapability;
+    actionCommand: ActionCommandBuilder;
+}
+export declare function buildCoreFormattingCommands({ gate, style, history, formatting, link, command, valueCommand, }: CoreFormattingGroupDeps): NonNullable<OasisPlugin["commands"]>;
+export declare function buildDocumentAndBrowserCommands({ gate, style, document, link, image, browser, actionCommand, }: DocumentAndBrowserGroupDeps): NonNullable<OasisPlugin["commands"]>;
+export declare function buildParagraphAndSectionCommands({ style, paragraph, section, valueCommand, actionCommand, }: ParagraphAndSectionGroupDeps): NonNullable<OasisPlugin["commands"]>;
+export declare function buildTableCommands({ gate, table, actionCommand, }: TableGroupDeps): NonNullable<OasisPlugin["commands"]>;
+export {};

package/dist/testing/wordLayoutParity.d.ts

@@ -0,0 +1,62 @@
+import { EditorDocument } from '../../core/model.js';
+
+export interface WordLayoutSupportStatus {
+    supported: boolean;
+    reason?: string;
+    wordPath?: string;
+    pythonCommand?: string;
+    pythonArgs?: string[];
+}
+interface WordPdfLine {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface WordPdfPage {
+    width: number;
+    height: number;
+    lines: WordPdfLine[];
+}
+interface WordPdfLayout {
+    pages: WordPdfPage[];
+}
+interface LayoutLineGeometry {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface EditorPageSnapshot {
+    headerLineTexts: string[];
+    bodyLineTexts: string[];
+    footerLineTexts: string[];
+    width: number;
+    height: number;
+    headerTop: number;
+    bodyTop: number;
+    bodyHeight: number;
+    footerTop: number;
+    footerReferenceTop: number;
+    pageHeight: number;
+    firstBodyLineGeometry?: LayoutLineGeometry;
+    lastBodyLineBottom?: number;
+    firstFooterLineTop?: number;
+}
+export interface WordLayoutParityResult {
+    editor: {
+        pages: EditorPageSnapshot[];
+    };
+    word: WordPdfLayout;
+    mismatches: string[];
+}
+export interface WordLayoutParityOptions {
+    geometryTolerancePoints?: number;
+    strictTextAndGeometry?: boolean;
+    layoutMode?: "fast" | "wordParity";
+}
+export declare function detectWordLayoutParitySupport(): WordLayoutSupportStatus;
+export declare function verifyWordLayoutParity(document: EditorDocument, options?: WordLayoutParityOptions): Promise<WordLayoutParityResult>;
+export declare function verifyImportedDocxWordLayoutParity(docxPath: string, options?: WordLayoutParityOptions): Promise<WordLayoutParityResult>;
+export {};

package/dist/ui/OasisEditorApp.d.ts

@@ -0,0 +1,4 @@
+import { OasisEditorAppProps } from '../OasisEditorAppProps.js';
+
+export type { OasisEditorLoadingOptions, OasisEditorAppUiProps, OasisEditorAppDocumentProps, OasisEditorAppRuntimeProps, OasisEditorAppProps, } from '../OasisEditorAppProps.js';
+export declare function OasisEditorApp(props?: OasisEditorAppProps): import("solid-js").JSX.Element;

package/dist/ui/OasisEditorAppProps.d.ts

@@ -0,0 +1,49 @@
+import { JSX } from '../solid-js';
+import { EditorDocument, EditorState } from '../../core/model.js';
+import { ToolbarRegistry } from '../components/Toolbar/registry/ToolbarRegistry.js';
+import { DocumentPersistence } from '../../app/controllers/useEditorPersistence.js';
+import { OasisPlugin } from '../../core/plugin.js';
+
+export interface OasisEditorLoadingOptions {
+    label?: string;
+    class?: string;
+    style?: JSX.CSSProperties;
+}
+export interface OasisEditorAppUiProps {
+    showChrome?: boolean;
+    shell?: "document" | "inline" | "balloon";
+    uiVariant?: "classic" | "docs";
+    showTitleBar?: boolean;
+    showMenubar?: boolean;
+    showToolbar?: boolean;
+    showOutline?: boolean;
+    locale?: "pt-BR" | "en";
+    viewportHeight?: number | string;
+    class?: string;
+    style?: JSX.CSSProperties;
+    loading?: boolean | OasisEditorLoadingOptions;
+}
+export interface OasisEditorAppDocumentProps {
+    initialDocument?: EditorDocument;
+    initialState?: EditorState;
+    onStateChange?: (state: EditorState) => void;
+    readOnly?: boolean;
+    persistenceEnabled?: boolean;
+    persistence?: DocumentPersistence;
+    layoutMode?: "fast" | "wordParity";
+}
+export interface OasisEditorAppRuntimeProps {
+    onReady?: () => void;
+    plugins?: OasisPlugin[];
+    /**
+     * Customize the toolbar after the built-in preset and plugin contributions
+     * load. Use the registry to add/insert/replace/remove/move items. Clients can
+     * tailor the toolbar without forking.
+     */
+    customizeToolbar?: (registry: ToolbarRegistry) => void;
+}
+export interface OasisEditorAppProps {
+    ui?: OasisEditorAppUiProps;
+    document?: OasisEditorAppDocumentProps;
+    runtime?: OasisEditorAppRuntimeProps;
+}

package/dist/ui/OasisEditorContainer.d.ts

@@ -0,0 +1,6 @@
+import { OasisEditorAppProps } from '../OasisEditorApp.js';
+
+export interface OasisEditorContainerProps extends Omit<OasisEditorAppProps, "ui"> {
+    ui?: Omit<NonNullable<OasisEditorAppProps["ui"]>, "showChrome">;
+}
+export declare function OasisEditorContainer(props: OasisEditorContainerProps): import("solid-js").JSX.Element;

package/dist/ui/OasisEditorEditor.d.ts

@@ -0,0 +1,103 @@
+import { Accessor, JSX } from '../solid-js';
+import { ToolbarHost } from '../components/Toolbar/state/createToolbarApi.js';
+import { EditorLayoutParagraph, EditorState } from '../../core/model.js';
+import { CaretBox, InputBox, RevisionBox, SelectedImageBox, SelectionBox, ImageResizeHandleDirection } from '../editorUiTypes.js';
+
+type ImportProgress = {
+    phase: "reading-file" | "opening-docx" | "parsing-document" | "parsing-headers-footers" | "applying-editor-state" | "stabilizing-layout" | "done" | "error";
+    progress: number;
+    subProgress?: number;
+};
+export interface OasisEditorEditorLayoutProps {
+    measuredBlockHeights?: Accessor<Record<string, number>>;
+    measuredParagraphLayouts?: Accessor<Record<string, EditorLayoutParagraph>>;
+    layoutMode?: "fast" | "wordParity";
+    viewportHeight?: number | string;
+    class?: string;
+    style?: JSX.CSSProperties;
+    readOnly?: boolean;
+}
+export interface OasisEditorEditorOverlayProps {
+    selectionBoxes: Accessor<SelectionBox[]>;
+    selectedImageBox: Accessor<SelectedImageBox | null>;
+    caretBox: Accessor<CaretBox>;
+    inputBox: Accessor<InputBox>;
+    hoveredRevision: Accessor<RevisionBox | null>;
+    focused: Accessor<boolean>;
+    showCaret: Accessor<boolean>;
+    importProgress?: Accessor<ImportProgress | null>;
+    toolbarHost?: () => ToolbarHost;
+    persistenceStatus?: () => string;
+    showFloatingTableToolbar?: Accessor<boolean>;
+}
+export interface OasisEditorEditorRefProps {
+    onViewportRef?: (element: HTMLDivElement) => void;
+    onSurfaceRef?: (element: HTMLDivElement) => void;
+    onTextareaRef?: (element: HTMLTextAreaElement) => void;
+    onImportInputRef?: (element: HTMLInputElement) => void;
+    onImageInputRef?: (element: HTMLInputElement) => void;
+}
+export interface OasisEditorEditorSurfaceHandlers {
+    onDragOver: (event: DragEvent) => void;
+    onDrop: (event: DragEvent) => void;
+    onEditorMouseDown: (event: MouseEvent) => void;
+    onSurfaceMouseDown: (event: MouseEvent) => void;
+    onSurfaceClick?: (event: MouseEvent) => void;
+    onSurfaceMouseMove?: (event: MouseEvent) => void;
+    onSurfaceDblClick: (event: MouseEvent) => void;
+    onParagraphMouseDown: (paragraphId: string, event: MouseEvent & {
+        currentTarget: HTMLParagraphElement;
+    }) => void;
+    onImageMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ImageResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onTableDragHandleMouseDown: (tableId: string, event: MouseEvent) => void;
+    onRevisionMouseEnter: (revisionId: string, event: MouseEvent) => void;
+    onRevisionMouseLeave?: (revisionId: string, event: MouseEvent) => void;
+    onEditorContextMenu?: (event: MouseEvent) => void;
+}
+export interface OasisEditorEditorInputHandlers {
+    onInputBlur: () => void;
+    onInputFocus: () => void;
+    onCompositionEnd: (event: CompositionEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    onCompositionStart: () => void;
+    onCopy: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    onCut: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    onInput: (event: InputEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    onKeyDown: (event: KeyboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    onPaste: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+}
+export interface OasisEditorEditorFileHandlers {
+    onImportInputChange: (event: Event & {
+        currentTarget: HTMLInputElement;
+    }) => void;
+    onImageInputChange: (event: Event & {
+        currentTarget: HTMLInputElement;
+    }) => void;
+}
+export interface OasisEditorEditorProps {
+    state: Accessor<EditorState>;
+    layout?: OasisEditorEditorLayoutProps;
+    overlays: OasisEditorEditorOverlayProps;
+    refs?: OasisEditorEditorRefProps;
+    surfaceHandlers: OasisEditorEditorSurfaceHandlers;
+    inputHandlers: OasisEditorEditorInputHandlers;
+    fileHandlers: OasisEditorEditorFileHandlers;
+}
+export declare function OasisEditorEditor(props: OasisEditorEditorProps): JSX.Element;
+export {};

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

@@ -0,0 +1,26 @@
+import { ComponentProps } from '../../solid-js';
+import { FontDialog } from '../../../components/Dialogs/FontDialog.js';
+import { FindReplaceDialog } from '../../../components/FindReplace/FindReplaceDialog.js';
+import { ContextMenu } from '../../../components/ContextMenu/ContextMenu.js';
+import { createEditorDialogs } from '../../useEditorDialogs.js';
+
+type EditorDialogsState = ReturnType<typeof createEditorDialogs>;
+export interface EditorDialogsLayerProps {
+    dialogs: EditorDialogsState;
+    findReplace: ComponentProps<typeof FindReplaceDialog>["fr"];
+    fontFamilyOptions: () => string[];
+    fontSizeOptions: () => number[];
+    contextMenuItems: () => ComponentProps<typeof ContextMenu>["items"];
+    focusInput: () => void;
+    applyLinkCommand: (href: string | null) => void;
+    applyImageAltCommand: (alt: string) => void;
+    applyFontDialogValues: ComponentProps<typeof FontDialog>["onApply"];
+    closeContextMenu: () => void;
+}
+/**
+ * Presentational layer that mounts the editor's modal dialogs and context menu.
+ * Holds no editor logic — it only binds dialog signals and command callbacks to
+ * their respective UI components.
+ */
+export declare function EditorDialogsLayer(props: EditorDialogsLayerProps): import("solid-js").JSX.Element;
+export {};

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

@@ -0,0 +1,20 @@
+import { EditorState } from '../../../../core/model.js';
+import { createEditorImageOperations } from '../../../../app/controllers/useEditorImageOperations.js';
+import { createEditorTableResize } from '../../../../app/controllers/useEditorTableResize.js';
+import { createEditorTableDrag } from '../../../../app/controllers/useEditorTableDrag.js';
+import { createEditorTextDrag } from '../../../../app/controllers/useEditorTextDrag.js';
+
+export interface EditorDragLayersProps {
+    state: EditorState;
+    surfaceRef: HTMLDivElement | undefined;
+    tableResize: ReturnType<typeof createEditorTableResize>;
+    imageOps: ReturnType<typeof createEditorImageOperations>;
+    tableDrag: ReturnType<typeof createEditorTableDrag>;
+    textDrag: ReturnType<typeof createEditorTextDrag>;
+}
+/**
+ * Presentational floating layers that visualize active drag/resize gestures:
+ * the table resize guide, image/table drag ghosts and the various drop carets.
+ * Holds no editor logic — it only binds gesture controller state to DOM.
+ */
+export declare function EditorDragLayers(props: EditorDragLayersProps): import("solid-js").JSX.Element;

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

@@ -0,0 +1,37 @@
+import { Accessor } from '../../solid-js';
+import { OasisEditorEditor, OasisEditorEditorFileHandlers, OasisEditorEditorInputHandlers, OasisEditorEditorLayoutProps, OasisEditorEditorOverlayProps, OasisEditorEditorRefProps, OasisEditorEditorSurfaceHandlers } from '../../../OasisEditorEditor.js';
+import { ShellProps } from '../../../shells/DocumentShell.js';
+import { ToolbarHost } from '../../../components/Toolbar/state/createToolbarApi.js';
+import { ToolbarRegistry } from '../../../components/Toolbar/registry/ToolbarRegistry.js';
+import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
+
+export interface EditorWorkspaceProps {
+    useComposedShell: () => boolean;
+    shellComponent: () => (props: ShellProps) => ReturnType<typeof OasisEditorEditor>;
+    state: Accessor<EditorState>;
+    toolbarHost: () => ToolbarHost;
+    persistenceStatus: () => string;
+    toolbarRegistry: ToolbarRegistry;
+    showChrome: () => boolean;
+    showTitleBar: () => boolean;
+    showMenubar: () => boolean;
+    showToolbar: () => boolean;
+    showOutline: () => boolean;
+    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;
+    surfaceHandlers: OasisEditorEditorSurfaceHandlers;
+    inputHandlers: OasisEditorEditorInputHandlers;
+    fileHandlers: OasisEditorEditorFileHandlers;
+}
+/**
+ * Renders the editor body, choosing between the composed shell (docs/inline/
+ * balloon chrome) and the bare canvas editor. Pure binding: it forwards the
+ * already-assembled view-prop bundles and runtime facade to the right surface.
+ */
+export declare function EditorWorkspace(props: EditorWorkspaceProps): import("solid-js").JSX.Element;

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

@@ -0,0 +1,59 @@
+import { Accessor, JSX } from '../../solid-js';
+import { CaretBox, InputBox, RevisionBox, SelectedImageBox, SelectionBox } from '../../../editorUiTypes.js';
+import { OasisEditorEditorFileHandlers, OasisEditorEditorInputHandlers, OasisEditorEditorLayoutProps, OasisEditorEditorOverlayProps, OasisEditorEditorRefProps, OasisEditorEditorSurfaceHandlers } from '../../../OasisEditorEditor.js';
+import { createEditorFocusController } from '../../useEditorFocus.js';
+import { createEditorSurfaceEvents } from '../../../../app/controllers/useEditorSurfaceEvents.js';
+import { createEditorTableResize } from '../../../../app/controllers/useEditorTableResize.js';
+import { createEditorTableDrag } from '../../../../app/controllers/useEditorTableDrag.js';
+import { createEditorTextInput } from '../../../../app/controllers/useEditorTextInput.js';
+import { createEditorRevisionController } from '../../../../app/controllers/useEditorRevision.js';
+
+type ImportProgress = NonNullable<ReturnType<NonNullable<OasisEditorEditorOverlayProps["importProgress"]>>>;
+/**
+ * Inputs needed to assemble the editor's view-prop bundles. These are already
+ * built controllers, accessors and handlers owned by the composition root; this
+ * module performs only the (logic-free) shaping into the prop objects consumed
+ * by `OasisEditorEditor` and the composed shells.
+ */
+export interface EditorViewPropsContext {
+    layoutMode: NonNullable<OasisEditorEditorLayoutProps["layoutMode"]>;
+    viewportHeight: number | string | undefined;
+    className: string | undefined;
+    style: JSX.CSSProperties | undefined;
+    selectionBoxes: Accessor<SelectionBox[]>;
+    selectedImageBox: Accessor<SelectedImageBox | null>;
+    caretBox: Accessor<CaretBox>;
+    inputBox: Accessor<InputBox>;
+    hoveredRevision: Accessor<RevisionBox | null>;
+    focused: Accessor<boolean>;
+    showCaret: Accessor<boolean>;
+    importProgress: Accessor<ImportProgress | null>;
+    focusController: ReturnType<typeof createEditorFocusController>;
+    handleImportDocx: (file: File | null) => void;
+    handleInsertImage: (file: File | null) => void;
+    surfaceEvents: ReturnType<typeof createEditorSurfaceEvents>;
+    tableResize: ReturnType<typeof createEditorTableResize>;
+    tableDrag: ReturnType<typeof createEditorTableDrag>;
+    revisionController: ReturnType<typeof createEditorRevisionController>;
+    handleDrop: OasisEditorEditorSurfaceHandlers["onDrop"];
+    onEditorMouseDown: OasisEditorEditorSurfaceHandlers["onEditorMouseDown"];
+    handleImageMouseDown: OasisEditorEditorSurfaceHandlers["onImageMouseDown"];
+    handleImageResizeHandleMouseDown: OasisEditorEditorSurfaceHandlers["onImageResizeHandleMouseDown"];
+    handleEditorContextMenu: (event: MouseEvent) => void;
+    textInput: ReturnType<typeof createEditorTextInput>;
+    setFocused: (value: boolean) => void;
+    handleCopy: OasisEditorEditorInputHandlers["onCopy"];
+    handleCut: OasisEditorEditorInputHandlers["onCut"];
+    handlePaste: OasisEditorEditorInputHandlers["onPaste"];
+    handleKeyDown: OasisEditorEditorInputHandlers["onKeyDown"];
+}
+export interface EditorViewProps {
+    layout: OasisEditorEditorLayoutProps;
+    overlays: OasisEditorEditorOverlayProps;
+    refs: OasisEditorEditorRefProps;
+    surfaceHandlers: OasisEditorEditorSurfaceHandlers;
+    inputHandlers: OasisEditorEditorInputHandlers;
+    fileHandlers: OasisEditorEditorFileHandlers;
+}
+export declare function buildEditorViewProps(ctx: EditorViewPropsContext): EditorViewProps;
+export {};

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

@@ -0,0 +1,42 @@
+import { EditorState } from '../../../../core/model.js';
+import { SelectedImageRun } from '../../../../core/commands/image.js';
+import { createEditorCommandsController } from '../../../../app/controllers/EditorCommandsController.js';
+import { createEditorHistoryActions } from '../../../../app/controllers/useEditorHistoryActions.js';
+import { createEditorStyleController } from '../../../../app/controllers/useEditorStyle.js';
+import { createEditorTableOperations } from '../../../../app/controllers/useEditorTableOperations.js';
+
+interface CreateEditorEssentialsPluginOptions {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    forcePlainTextPaste: {
+        get: () => boolean;
+        set: (value: boolean) => void;
+    };
+    undoStack: () => EditorState[];
+    redoStack: () => EditorState[];
+    commandsController: ReturnType<typeof createEditorCommandsController>;
+    keyboardCommandsController: ReturnType<typeof createEditorCommandsController> & {
+        applyBooleanStyleCommand: ReturnType<typeof createEditorStyleController>["applyToolbarBooleanStyleCommand"];
+    };
+    historyActions: ReturnType<typeof createEditorHistoryActions>;
+    styleController: ReturnType<typeof createEditorStyleController>;
+    tableOps: ReturnType<typeof createEditorTableOperations>;
+    docIO: {
+        handleExportDocx: () => Promise<void>;
+        handleExportPdf: () => Promise<void>;
+    };
+    importInputRef: () => HTMLInputElement | undefined;
+    imageInputRef: () => HTMLInputElement | undefined;
+    selectedImageRun: () => SelectedImageRun | null;
+    selectionBoxes: () => Array<unknown>;
+    focusInput: () => void;
+    applyState: (nextState: EditorState) => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    findReplace: {
+        setIsOpen: (open: boolean) => void;
+    };
+}
+export declare function createEditorEssentialsRuntimePlugin(options: CreateEditorEssentialsPluginOptions): import('../../../../index.js').OasisPlugin;
+export {};

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

@@ -0,0 +1,29 @@
+import { Accessor } from '../../solid-js';
+import { Editor } from '../../../../core/Editor.js';
+import { CommandRef } from '../../../../core/commands/CommandRef.js';
+import { EditorDocument } from '../../../../core/model.js';
+import { OasisPlugin } from '../../../../core/plugin.js';
+import { ToolbarHost } from '../../../components/Toolbar/state/createToolbarApi.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+interface CreateRuntimeCommandHostOptions {
+    initialDocument: EditorDocument;
+    runtimePlugins: OasisPlugin[];
+    focusEditor: () => void;
+    logger: EditorLogger;
+    onReady?: () => void;
+    onSettled?: () => void;
+}
+export declare function createRuntimeCommandHost(options: CreateRuntimeCommandHostOptions): {
+    runtimeReady: Accessor<boolean>;
+    runtimeEditor: Accessor<Editor>;
+    commandStateOf: (commandRef: CommandRef) => {
+        isEnabled: boolean;
+        isActive: boolean;
+        value: unknown;
+    };
+    toolbarHost: () => ToolbarHost;
+    initialize: () => Promise<void>;
+    dispose: () => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import { EditorDocument } from '../../../../core/model.js';
+import { ToolbarStyleState } from '../../../toolbarStyleState.js';
+
+export declare function computeFontFamilyOptions(document: EditorDocument | undefined, toolbarStyleState: Pick<ToolbarStyleState, "fontFamily">, localFontFamilies?: string[]): string[];
+export declare function computeFontSizeOptions(document: EditorDocument | undefined, toolbarStyleState: Pick<ToolbarStyleState, "fontSize">): number[];

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

@@ -0,0 +1,9 @@
+import { EditorState } from '../../../../core/model.js';
+import { CaretBox } from '../../../editorUiTypes.js';
+
+/**
+ * Decides whether the text caret should be painted: only for a visible, collapsed
+ * selection that is not a cross-cell table selection (where the caret would be
+ * ambiguous between cells).
+ */
+export declare function computeShouldShowCaret(state: EditorState, caretBox: CaretBox): boolean;