oasis-editor 0.0.77 → 0.0.79

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

@@ -0,0 +1,209 @@
+import { EditorPosition, EditorState } from '../../core/model.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { createEditorCommandsController } from '../../app/controllers/EditorCommandsController.js';
+import { createEditorDocumentRuntime } from './createEditorDocumentRuntime.js';
+
+type DocRuntime = ReturnType<typeof createEditorDocumentRuntime>;
+type CommandsController = ReturnType<typeof createEditorCommandsController>;
+export interface EditorInteractionRuntimeDeps {
+    state: EditorState;
+    logger: EditorLogger;
+    isReadOnly: () => boolean;
+    applyState: (next: EditorState) => void;
+    cloneState: (state: EditorState) => EditorState;
+    focusInput: () => void;
+    focusInputAfterPointerSelection: () => void;
+    surfaceRef: () => HTMLDivElement | undefined;
+    viewportRef: () => HTMLDivElement | undefined;
+    zoomFactor: () => number;
+    insertImageFromFile: DocRuntime["docIO"]["insertImageFromFile"];
+    getForcePlainTextPaste: () => boolean;
+    setForcePlainTextPaste: (value: boolean) => void;
+    /** Back-edge to the command runtime (phase C); read lazily at command time. */
+    getCommandsController: () => CommandsController;
+    applyTransactionalState: DocRuntime["applyTransactionalState"];
+    clearPreferredColumn: DocRuntime["clearPreferredColumn"];
+    resetTransactionGrouping: DocRuntime["resetTransactionGrouping"];
+    updateHistoryState: DocRuntime["updateHistoryState"];
+    caretBox: DocRuntime["caretBox"];
+    preferredColumnX: DocRuntime["preferredColumnX"];
+    setPreferredColumnX: DocRuntime["setPreferredColumnX"];
+    measuredBlockHeights: DocRuntime["measuredBlockHeights"];
+    measuredParagraphLayouts: DocRuntime["measuredParagraphLayouts"];
+}
+/**
+ * Phase B of the editor runtime: selection queries, the hit resolver, find &
+ * replace, the table/image/text-box operations, the style controller and the
+ * interaction-wiring cluster (gesture / input / clipboard / navigation). Runs
+ * synchronously after the document runtime, preserving the original creation
+ * order. The only forward cross-phase edge — style controller -> commands — is
+ * read lazily via getCommandsController. Extracted from `OasisEditorApp` (S1).
+ */
+export declare function createEditorInteractionRuntime(deps: EditorInteractionRuntimeDeps): {
+    selectedImageRun: () => import('../../core/commands/selectedObjectRun.js').SelectedObjectRun | null;
+    selectedTextBoxRun: () => import('../../core/commands/selectedObjectRun.js').SelectedObjectRun | null;
+    layoutOptionsOverlay: import('../editorUiTypes.js').LayoutOptionsOverlay;
+    fr: import('../../app/controllers/useEditorFindReplace.js').UseEditorFindReplaceResult;
+    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
+        forDrag?: boolean;
+        pierce?: boolean;
+    }) => import('../canvas/CanvasHitTestService.js').SurfaceHit | null;
+    resolvePositionAtSurfacePoint: (clientX: number, clientY: number) => EditorPosition | null;
+    tableOps: {
+        resolveTableCellRangeSelection: (current: EditorState) => EditorState["selection"] | null;
+        resolveHorizontalTableCellRange: (current: EditorState) => import('../../app/controllers/tableOpsSelectionRanges.js').HorizontalTableCellRange | null;
+        resolveVerticalTableCellRange: (current: EditorState) => import('../../app/controllers/tableOpsSelectionRanges.js').VerticalTableCellRange | null;
+        canMergeSelectedTableCells: (current: EditorState) => boolean;
+        canSplitSelectedTableCell: (current: EditorState) => boolean;
+        canMergeSelectedTableRows: (current: EditorState) => boolean;
+        canMergeSelectedTable: (current: EditorState) => boolean;
+        canSplitSelectedTableCellVertically: (current: EditorState) => boolean;
+        canSplitSelectedTable: (current: EditorState) => boolean;
+        canEditSelectedTableRow: (current: EditorState) => boolean;
+        canEditSelectedTableColumn: (current: EditorState) => boolean;
+        mergeSelectedTableCells: (current: EditorState) => EditorState;
+        mergeSelectedTableRows: (current: EditorState) => EditorState;
+        mergeSelectedTable: (current: EditorState) => EditorState;
+        splitSelectedTableCellVertically: (current: EditorState) => EditorState;
+        splitSelectedTableCell: (current: EditorState) => EditorState;
+        splitSelectedTable: (current: EditorState) => EditorState;
+        insertSelectedTableRow: (current: EditorState, direction: -1 | 1) => EditorState;
+        deleteSelectedTableRow: (current: EditorState) => EditorState;
+        insertSelectedTableColumn: (current: EditorState, direction: -1 | 1) => EditorState;
+        deleteSelectedTableColumn: (current: EditorState) => EditorState;
+        getRowVisualWidth: (row: import('../../core/model.js').EditorTableRowNode) => number;
+        getTableVisualWidth: (table: import('../../core/model.js').EditorTableNode) => number;
+        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: import('../../core/model.js').EditorBlockNode[], zone?: import('../../core/model.js').EditorEditingZone) => EditorState;
+        resolveAdjacentTableCellPosition: (document: import('../../core/model.js').EditorDocument, paragraphId: string, delta: -1 | 1) => EditorPosition | null;
+        applyTableAwareParagraphEdit: (current: EditorState, edit: (tempState: EditorState) => EditorState) => EditorState;
+        withExpandedTableCellSelection: (current: EditorState) => EditorState;
+        applySelectionAwareTextCommand: (command: (current: EditorState) => EditorState) => void;
+        applySelectionAwareParagraphCommand: (command: (current: EditorState) => EditorState) => void;
+        insertTableCommand: (rows: number, cols: number) => void;
+    };
+    imageOps: {
+        dragging: import('solid-js').Accessor<boolean>;
+        draggedImageInfo: import('solid-js').Accessor<import('../../app/controllers/useEditorImageOperations.js').ActiveImageDrag | null>;
+        mousePos: import('solid-js').Accessor<{
+            x: number;
+            y: number;
+        }>;
+        dropTargetPos: import('solid-js').Accessor<EditorPosition | null>;
+        getSelectedImageInfo: (current: EditorState) => {
+            paragraph: import('../../core/model.js').EditorParagraphNode;
+            run: import('../../core/model.js').EditorTextRun;
+            startOffset: number;
+            width: number;
+            height: number;
+            src: string;
+        } | null;
+        startImageDrag: (paragraphId: string, paragraphOffset: number, event: MouseEvent, pointerBounds?: import('../../app/controllers/useEditorImageOperations.js').ImagePointerBounds) => void;
+        stopImageDrag: () => void;
+        stopImageResize: () => void;
+        stopImageRotate: () => void;
+        handleImageMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+            currentTarget: HTMLElement;
+        }) => void;
+        handleImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: import('../resizeGeometry.js').ResizeHandleDirection, event: MouseEvent & {
+            currentTarget: HTMLElement;
+        }) => void;
+        handleImageRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+            currentTarget: HTMLElement;
+        }) => void;
+    };
+    textBoxOps: {
+        handleTextBoxResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: import('../resizeGeometry.js').ResizeHandleDirection, event: MouseEvent & {
+            currentTarget: HTMLElement;
+        }) => void;
+        handleTextBoxRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+            currentTarget: HTMLElement;
+        }) => void;
+        stopTextBoxResize: () => void;
+        stopTextBoxRotate: () => void;
+    };
+    styleController: {
+        pendingCaretTextStyle: import('solid-js').Accessor<import('../../core/model.js').EditorTextStyle | undefined>;
+        clearPendingCaretTextStyle: () => void;
+        toolbarStyleState: () => import('../toolbarStyleState.js').ToolbarStyleState;
+        applyToolbarValueStyleCommand: <K extends "link" | "underlineStyle" | "textEffect" | "fontFamily" | "fontSize" | "color" | "highlight" | "shading" | "language">(key: K, value: import('../../core/model.js').EditorTextStyle[K] | null) => void;
+        applyToolbarBooleanStyleCommand: (key: import('../toolbarStyleState.js').BooleanStyleKey) => void;
+    };
+    onEditorMouseDown: (event: MouseEvent) => void;
+    tableResize: import('../../app/controllers/useEditorTableResize.js').TableResizeOps;
+    tableDrag: {
+        dragging: import('solid-js').Accessor<boolean>;
+        draggedTableInfo: import('solid-js').Accessor<{
+            tableId: string;
+            width: number;
+            height: number;
+            offsetX: number;
+            offsetY: number;
+        } | null>;
+        mousePos: import('solid-js').Accessor<{
+            x: number;
+            y: number;
+        }>;
+        dropTargetPos: import('solid-js').Accessor<EditorPosition | null>;
+        handleMouseDown: (tableId: string, event: MouseEvent) => void;
+    };
+    revisionController: {
+        hoveredRevision: import('solid-js').Accessor<import('../editorUiTypes.js').RevisionBox | null>;
+        handleRevisionMouseEnter: (revisionId: string, event: MouseEvent) => void;
+        handleRevisionMouseLeave: () => void;
+    };
+    textDrag: {
+        dragging: import('solid-js').Accessor<boolean>;
+        dropTargetPos: import('solid-js').Accessor<EditorPosition | null>;
+        copyMode: import('solid-js').Accessor<boolean>;
+        pointerPos: import('solid-js').Accessor<{
+            x: number;
+            y: number;
+        } | null>;
+        caretViewport: import('solid-js').Accessor<{
+            left: number;
+            top: number;
+            height: number;
+        } | null>;
+        tryStartTextDrag: (event: MouseEvent, hit: import('../canvas/CanvasHitTestService.js').SurfaceHit | null) => boolean;
+        stopDrag: () => void;
+    };
+    surfaceEventsWithTextDrag: {
+        handleSurfaceMouseDown: (event: MouseEvent) => void;
+        handleSurfaceClick: (event: MouseEvent) => void;
+        handleSurfaceDblClick: (event: MouseEvent) => void;
+        handleParagraphMouseDown: (_paragraphId: string, event: MouseEvent & {
+            currentTarget: HTMLParagraphElement;
+        }) => void;
+        stopDragging: () => void;
+    };
+    textInput: {
+        handleTextInput: (event: InputEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => void;
+        handleCompositionStart: () => void;
+        handleCompositionEnd: (event: CompositionEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => void;
+        composing: import('solid-js').Accessor<boolean>;
+    };
+    navigation: {
+        moveSelectionToParagraphBoundary: (boundary: "start" | "end", extend: boolean) => boolean;
+        moveSelectionToDocumentBoundary: (boundary: "start" | "end", extend: boolean) => boolean;
+        moveSelectionByWord: (direction: "left" | "right", extend: boolean) => boolean;
+        moveVerticalByBlock: (direction: -1 | 1) => boolean;
+        moveVerticalSelection: (direction: -1 | 1, extend: boolean) => boolean;
+    };
+    handleCopy: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    handleCut: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    handlePaste: (event: ClipboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    handleDrop: (event: DragEvent) => void;
+};
+export {};

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

@@ -0,0 +1,51 @@
+import { EditorState } from '../../core/model.js';
+import { SelectedImageRun } from '../../core/commands/image.js';
+import { EditorLogger } from '../../utils/logger.js';
+import { EditorTransactionPort } from '../../app/controllers/controllerPorts.js';
+import { EditorKeyboardDeps } from '../../app/controllers/EditorKeyboardDeps.js';
+import { createEditorTableOperations } from '../../app/controllers/useEditorTableOperations.js';
+import { createEditorNavigation } from '../../app/controllers/useEditorNavigation.js';
+import { createEditorHistoryActions } from '../../app/controllers/useEditorHistoryActions.js';
+import { useEditorRuntimeBootstrap } from './useEditorRuntimeBootstrap.js';
+
+type EditorTableOperations = ReturnType<typeof createEditorTableOperations>;
+type EditorNavigation = ReturnType<typeof createEditorNavigation>;
+type EditorHistoryActions = ReturnType<typeof createEditorHistoryActions>;
+type RuntimeEditorAccessor = ReturnType<typeof useEditorRuntimeBootstrap>["runtimeEditor"];
+export interface EditorKeyboardBindingDeps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    logger: EditorLogger;
+    focusInput: () => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyState: (next: EditorState) => void;
+    applyTransactionalState: EditorTransactionPort["applyTransactionalState"];
+    setForcePlainTextPaste: (value: boolean) => void;
+    selectedImageRun: () => SelectedImageRun | null;
+    commandsController: EditorKeyboardDeps["commandsController"];
+    tableOps: EditorTableOperations;
+    navigation: EditorNavigation;
+    historyActions: EditorHistoryActions;
+    styleController: {
+        clearPendingCaretTextStyle: () => void;
+    };
+    findReplace: {
+        isOpen: () => boolean;
+        setIsOpen: (open: boolean) => void;
+    };
+    runtimeEditor: RuntimeEditorAccessor;
+}
+/**
+ * Assembles the keyboard controller dependency bag from the editor's cohesive
+ * collaborators (transaction, navigation, history, table, find/replace, command
+ * runtime) and wraps the raw handler with caret-style reset, structured logging
+ * and the input-to-layout perf mark. Extracted from `OasisEditorApp` so the
+ * composition root no longer hand-wires 26 keyboard callbacks inline (S1).
+ */
+export declare function createEditorKeyboardBinding(deps: EditorKeyboardBindingDeps): {
+    handleKeyDown: (event: KeyboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+};
+export {};

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

@@ -22,6 +22,11 @@ export interface TablePropertiesDialogBridgeDeps {
     }) => void;
     focusInput: () => void;
 }
+/**
+ * UI bridge for the table properties dialog: opens/closes it and returns focus.
+ * All model knowledge (active-table resolution, value mapping, mutation) lives
+ * in `@/app/services/tablePropertiesService` (F1).
+ */
 export declare function createTablePropertiesDialogBridge(deps: TablePropertiesDialogBridgeDeps): {
     isInsideTable: () => boolean;
     openTablePropertiesDialog: (activeTab?: TablePropertiesDialogInitialValues["activeTab"]) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis-editor",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "type": "module",
   "repository": {
     "type": "git",