oasis-editor 0.0.1 → 0.0.2

package/dist/app/bootstrap/createOasisEditorApp.d.ts

@@ -1,6 +1,5 @@
 import { OasisEditorAppProps } from '../../../../ui/OasisEditorApp.js';
+import { OasisEditorClient } from '../../../client/OasisEditorClient.js';
 
-export interface OasisEditorInstance {
-    dispose: () => void;
-}
+export type OasisEditorInstance = OasisEditorClient;
 export declare function createOasisEditor(container: HTMLElement, props?: OasisEditorAppProps): OasisEditorInstance;

package/dist/app/bootstrap/createOasisEditorContainer.d.ts

@@ -1,6 +1,5 @@
 import { OasisEditorContainerProps } from '../../../../ui/OasisEditorContainer.js';
+import { OasisEditorClient } from '../../../client/OasisEditorClient.js';
 
-export interface OasisEditorContainerInstance {
-    dispose: () => void;
-}
+export type OasisEditorContainerInstance = OasisEditorClient;
 export declare function createOasisEditorContainer(container: HTMLElement, props?: OasisEditorContainerProps): OasisEditorContainerInstance;

package/dist/app/client/OasisEditorClient.d.ts

@@ -0,0 +1,97 @@
+import { EditorDocument, EditorSelection, EditorState } from '../../../../core/model.js';
+import { Editor } from '../../../../core/Editor.js';
+import { ToolbarCommandState } from '../../../../ui/components/Toolbar/schema/items.js';
+import { TypedCommandBus } from '../../../../core/commands/publicCommandTypes.js';
+
+export type OasisEditorClientEvent = "ready" | "change" | "documentChange" | "selectionChange" | "error";
+export interface OasisEditorClientEvents {
+    ready: Editor;
+    change: EditorState;
+    documentChange: EditorDocument;
+    selectionChange: EditorSelection;
+    error: unknown;
+}
+export type OasisEditorClientEventHandler<TEvent extends OasisEditorClientEvent = OasisEditorClientEvent> = (payload: OasisEditorClientEvents[TEvent]) => void;
+export interface OasisEditorDocumentApi {
+    get(): EditorDocument;
+    set(document: EditorDocument): void;
+    load(document: EditorDocument): void;
+    update(updater: (document: EditorDocument) => EditorDocument): void;
+    reset(): void;
+    save(): Promise<void>;
+    isDirty(): boolean;
+    markClean(): void;
+}
+export interface OasisEditorSelectionApi {
+    get(): EditorSelection;
+    set(selection: EditorSelection): void;
+}
+export interface OasisEditorFocusApi {
+    focus(): void;
+    blur(): void;
+}
+export interface OasisEditorHistoryApi {
+    undo(): unknown;
+    redo(): unknown;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+}
+export interface OasisEditorImportApi {
+    docx(file: File): Promise<void>;
+}
+export interface OasisEditorExportApi {
+    docx(): Promise<unknown>;
+    pdf(): Promise<unknown>;
+}
+export interface OasisEditorClient {
+    readonly ready: Promise<Editor>;
+    readonly commands: TypedCommandBus<ToolbarCommandState>;
+    readonly document: OasisEditorDocumentApi;
+    readonly selection: OasisEditorSelectionApi;
+    readonly focus: OasisEditorFocusApi;
+    readonly history: OasisEditorHistoryApi;
+    readonly import: OasisEditorImportApi;
+    readonly export: OasisEditorExportApi;
+    dispose(): void | Promise<void>;
+    getState(): EditorState;
+    getDocument(): EditorDocument;
+    setDocument(document: EditorDocument): void;
+    loadDocument(document: EditorDocument): void;
+    updateDocument(updater: (document: EditorDocument) => EditorDocument): void;
+    resetDocument(): void;
+    save(): Promise<void>;
+    isDirty(): boolean;
+    markClean(): void;
+    getSelection(): EditorSelection;
+    setSelection(selection: EditorSelection): void;
+    focusEditor(): void;
+    blurEditor(): void;
+    on<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): () => void;
+    once<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): () => void;
+    off<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): void;
+}
+export interface OasisEditorClientHost {
+    getRuntimeEditor(): Editor | null;
+    getState(): EditorState;
+    getDocument(): EditorDocument;
+    setDocument(document: EditorDocument): void;
+    resetDocument(): void;
+    saveDocument(): Promise<void>;
+    getSelection(): EditorSelection;
+    setSelection(selection: EditorSelection): void;
+    focus(): void;
+    blur(): void;
+    clearHistory(): void;
+    importDocx(file: File): Promise<void>;
+    exportDocx(): Promise<unknown>;
+    exportPdf(): Promise<unknown>;
+}
+export interface OasisEditorClientController extends OasisEditorClient {
+    connectHost(host: OasisEditorClientHost): void;
+    setDispose(dispose: () => void | Promise<void>): void;
+    resolveReady(editor: Editor): void;
+    rejectReady(error: unknown): void;
+    emit<TEvent extends OasisEditorClientEvent>(event: TEvent, payload: OasisEditorClientEvents[TEvent]): void;
+}
+export declare function createOasisEditorClient(): OasisEditorClientController;

package/dist/app/controllers/EditorCommandsController.d.ts

@@ -23,7 +23,7 @@ export interface EditorCommandsControllerDeps {
 }
 export declare function createEditorCommandsController(deps: EditorCommandsControllerDeps): {
     applyBooleanStyleCommand: (key: BooleanStyleKey) => void;
-    applyValueStyleCommand: <K extends "fontFamily" | "fontSize" | "color" | "highlight" | "link" | "underlineStyle">(key: K, value: EditorTextStyle[K] | null) => void;
+    applyValueStyleCommand: <K extends "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language" | "textEffect" | "link" | "underlineStyle">(key: K, value: EditorTextStyle[K] | null) => void;
     applyParagraphStyleCommand: <K extends ParagraphStyleKey>(key: K, value: EditorParagraphStyle[K] | null) => void;
     toggleParagraphFlagCommand: (key: "pageBreakBefore" | "keepWithNext") => void;
     applyParagraphListCommand: (kind: NonNullable<EditorParagraphListStyle["kind"]>) => void;

package/dist/app/controllers/createResizeSession.d.ts

@@ -0,0 +1,43 @@
+import { EditorState } from '../../../../core/model.js';
+import { ResizeHandleDirection } from '../../../../ui/resizeGeometry.js';
+import { EditorHistoryState } from '../../../../ui/editorHistory.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+export interface ResizeSessionSelection {
+    width: number;
+    height: number;
+}
+/**
+ * Object-type-specific behaviour for a resize session. Images and text boxes
+ * differ only in how the selected object's size is read and how a new size is
+ * committed; the pointer/lifecycle machinery is shared.
+ */
+export interface ResizeSessionAdapter {
+    /** Read the selected object's current size, or `null` to abort the session. */
+    getSelected: (state: EditorState) => ResizeSessionSelection | null;
+    /** Commit a new size for the dragged handle, returning the next state. */
+    applyResize: (state: EditorState, width: number, height: number, direction: ResizeHandleDirection) => EditorState;
+    /** Maximum width (px) the object may grow to in its paragraph context. */
+    getMaxWidth: (state: EditorState, paragraphId: string) => number;
+    /** Short label used in diagnostic logs (e.g. "image", "text box"). */
+    label: string;
+}
+export interface ResizeSessionDeps {
+    state: EditorState;
+    applyState: (next: EditorState) => void;
+    updateHistoryState: (updater: (current: EditorHistoryState) => EditorHistoryState) => void;
+    cloneState: (source: EditorState) => EditorState;
+    focusInput: () => void;
+    logger: EditorLogger;
+}
+/**
+ * Drives a handle-based resize: it tracks the pointer, resolves the next size
+ * via {@link resolveResizedDimensions}, re-applies the resize from the captured
+ * dimensions each move (so EMU rounding never accumulates), and snapshots the
+ * pre-resize state onto the undo stack on release. The object-specific bits are
+ * supplied by {@link ResizeSessionAdapter}.
+ */
+export declare function createResizeSession(adapter: ResizeSessionAdapter, deps: ResizeSessionDeps): {
+    start: (paragraphId: string, paragraphOffset: number, handleDirection: ResizeHandleDirection, event: MouseEvent, initialState: EditorState) => void;
+    stop: () => void;
+};

package/dist/app/controllers/createRotateSession.d.ts

@@ -0,0 +1,36 @@
+import { EditorState } from '../../../../core/model.js';
+import { EditorHistoryState } from '../../../../ui/editorHistory.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+/**
+ * Object-type-specific behaviour for a rotate session. Images and text boxes
+ * differ only in how a new rotation is committed; the pointer/center machinery
+ * is shared.
+ */
+export interface RotateSessionAdapter {
+    /** Commit a new rotation (degrees) for the selected object. */
+    applyRotate: (state: EditorState, rotation: number) => EditorState;
+    /** Short label used in diagnostic logs (e.g. "image", "text box"). */
+    label: string;
+}
+export interface RotateSessionDeps {
+    state: EditorState;
+    applyState: (next: EditorState) => void;
+    updateHistoryState: (updater: (current: EditorHistoryState) => EditorHistoryState) => void;
+    cloneState: (source: EditorState) => EditorState;
+    focusInput: () => void;
+    logger: EditorLogger;
+}
+/**
+ * Drives a knob-based rotation: it measures the pointer angle relative to the
+ * object's center (captured from the selection overlay's bounding box on start),
+ * normalizes it so the knob — which sits due north — maps to 0°, optionally
+ * snaps to {@link ROTATION_SNAP_DEGREES} while Shift is held, and snapshots the
+ * pre-rotation state onto the undo stack on release.
+ */
+export declare function createRotateSession(adapter: RotateSessionAdapter, deps: RotateSessionDeps): {
+    start: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }, initialState: EditorState) => void;
+    stop: () => void;
+};

package/dist/app/controllers/documentIO/DocumentImporter.d.ts

@@ -13,5 +13,5 @@ export interface DocumentImporterDeps {
     logger: EditorLogger;
 }
 export declare function createDocumentImporter(deps: DocumentImporterDeps): {
-    handleImportDocx: (file: File | null) => Promise<void>;
+    handleImportFile: (file: File | null) => Promise<void>;
 };

package/dist/app/controllers/tableResize/tableResizeApply.d.ts

@@ -0,0 +1,5 @@
+import { EditorState } from '../../../../../../core/model.js';
+import { TableResizeState } from '../../../tableResizeTypes.js';
+
+export declare function applyRowResize(state: EditorState, resize: TableResizeState, delta: number): EditorState;
+export declare function applyColumnResize(state: EditorState, resize: TableResizeState, delta: number): EditorState;

package/dist/app/controllers/tableResize/tableResizeConstraints.d.ts

@@ -0,0 +1,17 @@
+import { EditorTableNode, EditorState } from '../../../../../../core/model.js';
+import { TableCellLayoutEntry } from '../../../../../../core/tableLayout.js';
+import { TableGeometry } from '../../../tableResizeTypes.js';
+
+export declare function resolveHorizontalCellChromePx(cell: EditorTableNode["rows"][number]["cells"][number]): number;
+export declare function resolveRowHeightsPx(tableNode: EditorTableNode, tableLayout: TableCellLayoutEntry[], geometry: TableGeometry): number[];
+export declare function resolveColumnWidthsPt(tableNode: EditorTableNode, tableLayout: TableCellLayoutEntry[], geometry: TableGeometry): {
+    widthsPt: Record<number, number>;
+    maxColumnIndex: number;
+};
+export declare function resolveMinRowHeightPx(tableNode: EditorTableNode, tableLayout: TableCellLayoutEntry[], geometry: TableGeometry, targetRowIndex: number): number;
+export declare function resolveMinColumnWidthsPx(state: EditorState, tableNode: EditorTableNode, tableLayout: TableCellLayoutEntry[], geometry: TableGeometry): Record<number, number>;
+/** Convenience: builds layout and calls resolveColumnWidthsPt */
+export declare function buildResolvedColumnWidthsPt(tableNode: EditorTableNode, geometry: TableGeometry): {
+    widthsPt: Record<number, number>;
+    maxColumnIndex: number;
+};

package/dist/app/controllers/tableResize/tableResizeDom.d.ts

@@ -0,0 +1,9 @@
+export declare function getGuideBounds(viewportRef: () => HTMLElement | undefined): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function clearResizeCursorClasses(): void;
+export declare function setHoverCursorClass(isCol: boolean): void;
+export declare function setActiveCursorClass(isCol: boolean): void;

package/dist/app/controllers/tableResize/tableResizeGeometry.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, EditorTableNode } from '../../../../../../core/model.js';
+import { TableGeometry } from '../../../tableResizeTypes.js';
+
+export declare function getTableById(state: EditorState, tableId: string): EditorTableNode | null;
+export declare function buildTableGeometries(surface: HTMLElement, state: EditorState): TableGeometry[];

package/dist/app/controllers/tableResize/tableResizeHitTest.d.ts

@@ -0,0 +1,4 @@
+import { EditorState } from '../../../../../../core/model.js';
+import { ResizeHoverInfo } from '../../../tableResizeTypes.js';
+
+export declare function findTableResizeHoverInfo(event: MouseEvent, surface: HTMLElement, state: EditorState): ResizeHoverInfo | null;

package/dist/app/controllers/tableResize/tableResizeTypes.d.ts

@@ -0,0 +1,65 @@
+import { EditorTableNode } from '../../../../../../core/model.js';
+import { TableCellLayoutEntry } from '../../../../../../core/tableLayout.js';
+
+export type ResizeSide = "left" | "right" | "top" | "bottom";
+export interface SnapshotCellRect {
+    tableId: string;
+    rowIndex: number;
+    cellIndex: number;
+    pageIndex: number;
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+    contentMinWidth: number;
+    contentMinHeight: number;
+}
+export interface TableGeometry {
+    tableId: string;
+    cells: SnapshotCellRect[];
+    bounds: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+}
+export interface ResizeHoverInfo {
+    tableId: string;
+    rowIndex: number;
+    cellIndex: number;
+    side: ResizeSide;
+    rect: SnapshotCellRect;
+    tableNode: EditorTableNode;
+    layoutEntry: TableCellLayoutEntry;
+    tableGeometry: TableGeometry;
+}
+export interface TableResizeState {
+    type: "column" | "row";
+    tableId: string;
+    index: number;
+    initialPos: number;
+    currentPos: number;
+    initialRowHeightPx?: number;
+    minRowHeightPx?: number;
+    columnWidthsPt?: Record<number, number>;
+    maxColumnIndex?: number;
+    minColumnWidthsPx?: Record<number, number>;
+    resizeFromLeftEdge?: boolean;
+    initialTableIndentLeftPt?: number;
+    guideBounds: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}
+export interface TableResizeOps {
+    resizing: () => TableResizeState | null;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleMouseDown: (event: MouseEvent) => boolean;
+}

package/dist/app/controllers/tableResize/tableResizeUnits.d.ts

@@ -0,0 +1,6 @@
+export declare const POINTS_PER_PIXEL = 0.75;
+export declare const PIXELS_PER_POINT: number;
+export declare const MIN_TABLE_SIZE_PT = 10;
+export declare function pxToPt(px: number): number;
+export declare function ptToPx(pt: number): number;
+export declare function parseSizeToPt(value: number | string | undefined): number | null;

package/dist/app/controllers/useEditorDocumentIO.d.ts

@@ -1,8 +1,8 @@
 import { EditorState, EditorPosition } from '../../../../core/model.js';
-import { DocxImportStage } from '../../../../import/docx/importDocxToEditorDocument.js';
+import { ImportStage } from '../../../../import/DocumentFormatImporter.js';
 import { EditorLogger } from '../../../../utils/logger.js';
 
-export type ImportProgressPhase = "reading-file" | DocxImportStage | "applying-editor-state" | "stabilizing-layout" | "done" | "error";
+export type ImportProgressPhase = "reading-file" | ImportStage | "applying-editor-state" | "stabilizing-layout" | "done" | "error";
 export interface ImportProgressState {
     phase: ImportProgressPhase;
     progress: number;
@@ -23,7 +23,7 @@ export interface UseEditorDocumentIOProps {
 }
 export declare function createEditorDocumentIO(deps: UseEditorDocumentIOProps): {
     importProgress: import('../../solid-js').Accessor<ImportProgressState | null>;
-    handleImportDocx: (file: File | null) => Promise<void>;
+    handleImportFile: (file: File | null) => Promise<void>;
     handleExportDocx: () => Promise<void>;
     handleExportPdf: () => Promise<void>;
     insertImageFromFile: (file: File, position?: EditorPosition | null) => Promise<void>;

package/dist/app/controllers/useEditorHistoryActions.d.ts

@@ -6,7 +6,9 @@ export interface UseEditorHistoryActionsProps {
     state: () => EditorState;
     stateSnapshot: () => EditorState;
     applyHistoryState: (state: EditorState) => void;
-    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: any) => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
     focusInput: () => void;
     clearPreferredColumn: () => void;
     imageOps: () => ReturnType<typeof createEditorImageOperations>;

package/dist/app/controllers/useEditorImageOperations.d.ts

@@ -1,19 +1,8 @@
 import { EditorPosition, EditorState } from '../../../../core/model.js';
-import { ImageResizeHandleDirection } from '../../../../ui/editorUiTypes.js';
+import { ResizeHandleDirection } from '../../../../ui/resizeGeometry.js';
 import { EditorLogger } from '../../../../utils/logger.js';
 import { EditorHistoryState } from '../../../../ui/editorHistory.js';
 
-export interface ActiveImageResize {
-    paragraphId: string;
-    paragraphOffset: number;
-    handleDirection: ImageResizeHandleDirection;
-    startClientX: number;
-    startClientY: number;
-    startWidth: number;
-    startHeight: number;
-    aspectRatio: number;
-    initialState: EditorState;
-}
 export interface ActiveImageDrag {
     paragraphId: string;
     paragraphOffset: number;
@@ -60,13 +49,16 @@ export declare function createEditorImageOperations(deps: EditorImageOperationsD
         src: string;
     } | null;
     startImageDrag: (paragraphId: string, paragraphOffset: number, event: MouseEvent, pointerBounds?: ImagePointerBounds) => void;
-    startImageResize: (paragraphId: string, paragraphOffset: number, handleDirection: ImageResizeHandleDirection, event: MouseEvent, initialState: EditorState) => void;
     stopImageDrag: () => void;
     stopImageResize: () => void;
+    stopImageRotate: () => void;
     handleImageMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
         currentTarget: HTMLElement;
     }) => void;
-    handleImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ImageResizeHandleDirection, event: MouseEvent & {
+    handleImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    handleImageRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
         currentTarget: HTMLElement;
     }) => void;
 };

package/dist/app/controllers/useEditorLayout.d.ts

@@ -1,13 +1,12 @@
 import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
 import { CaretBox, InputBox, SelectionBox } from '../../../../ui/editorUiTypes.js';
-import { SelectedImageSelectionBox } from '../../../../ui/canvas/CanvasSelectionGeometry.js';
+import { SelectedImageSelectionBox, SelectedTextBoxSelectionBox } from '../../../../ui/canvas/CanvasSelectionGeometry.js';
 
 interface UseEditorLayoutProps {
     state: EditorState;
     surfaceRef: () => HTMLDivElement | undefined;
     viewportRef: () => HTMLDivElement | undefined;
     isImporting?: () => boolean;
-    layoutMode?: "fast" | "wordParity";
 }
 type LayoutSyncReason = "selection" | "scroll" | "content-change" | "resize" | "import";
 export interface LayoutInvalidation {
@@ -21,6 +20,7 @@ export declare function useEditorLayout(props: UseEditorLayoutProps): {
     inputBox: import('../../solid-js').Accessor<InputBox>;
     selectionBoxes: import('../../solid-js').Accessor<SelectionBox[]>;
     selectedImageBox: import('../../solid-js').Accessor<SelectedImageSelectionBox | null>;
+    selectedTextBoxBox: import('../../solid-js').Accessor<SelectedTextBoxSelectionBox | null>;
     caretBox: import('../../solid-js').Accessor<CaretBox>;
     preferredColumnX: import('../../solid-js').Accessor<number | null>;
     setPreferredColumnX: import('../../solid-js').Setter<number | null>;

package/dist/app/controllers/useEditorStyle.d.ts

@@ -2,7 +2,7 @@ import { EditorState, EditorTextStyle } from '../../../../core/model.js';
 import { ToolbarStyleState, BooleanStyleKey } from '../../../../ui/toolbarStyleState.js';
 import { createEditorCommandsController } from '../../EditorCommandsController.js';
 
-type ValueStyleKey = "fontFamily" | "fontSize" | "color" | "highlight" | "link" | "underlineStyle";
+type ValueStyleKey = "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language" | "textEffect" | "link" | "underlineStyle";
 export interface UseEditorStyleProps {
     state: () => EditorState;
     commandsController: () => ReturnType<typeof createEditorCommandsController>;

package/dist/app/controllers/useEditorSurfaceEvents.d.ts

@@ -23,6 +23,7 @@ export interface UseEditorSurfaceEventsProps {
     focusInputAfterPointerSelection: () => void;
     resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
         forDrag?: boolean;
+        pierce?: boolean;
     }) => SurfaceHit | null;
     getParagraphById: (doc: EditorState["document"], id: string) => EditorParagraphNode | undefined;
     textDrag?: {

package/dist/app/controllers/useEditorTableOperations.d.ts

@@ -1,4 +1,4 @@
-import { EditorBlockNode, EditorDocument, EditorPosition, EditorState, EditorEditingZone } from '../../../../core/model.js';
+import { EditorBlockNode, EditorState, EditorEditingZone } from '../../../../core/model.js';
 import { EditorLogger } from '../../../../utils/logger.js';
 
 export interface EditorTableOperationsDeps {
@@ -36,7 +36,7 @@ export declare function createEditorTableOperations(deps: EditorTableOperationsD
     findCellAtVisualColumn: (row: import('../../../../core/model.js').EditorTableRowNode, visualColumn: number) => import('../../../../core/model.js').EditorTableCellNode | null;
     findFirstNavigableParagraphInTable: (table: import('../../../../core/model.js').EditorTableNode) => import('../../../../core/model.js').EditorParagraphNode | null;
     updateBlocksInCurrentSection: (current: EditorState, blocks: EditorBlockNode[], zone?: EditorEditingZone) => EditorState;
-    resolveAdjacentTableCellPosition: (document: EditorDocument, paragraphId: string, delta: -1 | 1) => EditorPosition | null;
+    resolveAdjacentTableCellPosition: (document: import('../../../../index.js').EditorDocument, paragraphId: string, delta: -1 | 1) => import('../../../../core/model.js').EditorPosition | null;
     applyTableAwareParagraphEdit: (current: EditorState, edit: (tempState: EditorState) => EditorState) => EditorState;
     withExpandedTableCellSelection: (current: EditorState) => EditorState;
     applySelectionAwareTextCommand: (command: (current: EditorState) => EditorState) => void;

package/dist/app/controllers/useEditorTableResize.d.ts

@@ -1,29 +1,7 @@
 import { EditorState } from '../../../../core/model.js';
+import { TableResizeOps } from '../../tableResize/tableResizeTypes.js';
 
-export interface TableResizeOps {
-    resizing: () => {
-        type: "column" | "row";
-        tableId: string;
-        index: number;
-        initialPos: number;
-        currentPos: number;
-        initialRowHeightPx?: number;
-        minRowHeightPx?: number;
-        columnWidthsPt?: Record<number, number>;
-        maxColumnIndex?: number;
-        minColumnWidthsPx?: Record<number, number>;
-        resizeFromLeftEdge?: boolean;
-        initialTableIndentLeftPt?: number;
-        guideBounds: {
-            left: number;
-            top: number;
-            width: number;
-            height: number;
-        };
-    } | null;
-    handleMouseMove: (event: MouseEvent) => void;
-    handleMouseDown: (event: MouseEvent) => boolean;
-}
+export { type TableResizeOps } from '../../tableResize/tableResizeTypes.js';
 export declare function createEditorTableResize(deps: {
     state: () => EditorState;
     applyTransactionalState: (producer: (current: EditorState) => EditorState) => void;

package/dist/app/controllers/useEditorTextBoxOperations.d.ts

@@ -0,0 +1,24 @@
+import { EditorState } from '../../../../core/model.js';
+import { ResizeHandleDirection } from '../../../../ui/resizeGeometry.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+import { EditorHistoryState } from '../../../../ui/editorHistory.js';
+
+export interface EditorTextBoxOperationsDeps {
+    state: EditorState;
+    surfaceRef: () => HTMLDivElement | undefined;
+    applyState: (next: EditorState) => void;
+    updateHistoryState: (updater: (current: EditorHistoryState) => EditorHistoryState) => void;
+    focusInput: () => void;
+    cloneState: (source: EditorState) => EditorState;
+    logger: EditorLogger;
+}
+export declare function createEditorTextBoxOperations(deps: EditorTextBoxOperationsDeps): {
+    handleTextBoxResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    handleTextBoxRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    stopTextBoxResize: () => void;
+    stopTextBoxRotate: () => void;
+};

package/dist/app/services/userPreferences.d.ts

@@ -0,0 +1,4 @@
+export declare function getWelcomeSeen(): boolean;
+export declare function setWelcomeSeen(): void;
+export declare function getPreciseFontPreference(): boolean;
+export declare function setPreciseFontPreference(on: boolean): void;