oasis-editor 0.0.1

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

@@ -0,0 +1,50 @@
+import { EditorDocument, EditorPosition, EditorState } from '../../../../core/model.js';
+import { BooleanStyleKey } from '../../../../ui/toolbarStyleState.js';
+import { EditorCommandRegistry } from '../../EditorCommandRegistry.js';
+import { SelectedImageRun } from '../../../../core/commands/image.js';
+
+export interface EditorKeyboardDeps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyState: (state: EditorState) => void;
+    applyTransactionalState: (transform: (state: EditorState) => EditorState) => void;
+    applyTableAwareParagraphEdit: (state: EditorState, edit: (state: EditorState) => EditorState) => EditorState;
+    applySelectionAwareParagraphCommand: (command: (state: EditorState) => EditorState) => void;
+    focusInput: () => void;
+    commandsController: {
+        promptForImageAlt: () => void;
+        promptForLink: () => void;
+        applyBooleanStyleCommand: (style: BooleanStyleKey) => void;
+        applyParagraphListCommand: (style: "bullet" | "ordered") => void;
+        applyInsertFootnoteCommand: () => void;
+        handleListEnter: () => boolean;
+        handleListBoundaryBackspace: (event: KeyboardEvent & {
+            currentTarget: HTMLTextAreaElement;
+        }) => boolean;
+        handleListTab: (direction: "indent" | "outdent") => boolean;
+    };
+    selectedImageRun: () => SelectedImageRun | null;
+    setForcePlainTextPaste: (value: boolean) => void;
+    moveSelectionByWord: (direction: "left" | "right", extend: boolean) => boolean;
+    moveSelectionToDocumentBoundary: (boundary: "start" | "end", extend: boolean) => boolean;
+    moveSelectionToParagraphBoundary: (boundary: "start" | "end", extend: boolean) => boolean;
+    moveSelectedImageByParagraph: (direction: -1 | 1) => boolean;
+    performUndo: () => void;
+    performRedo: () => void;
+    moveVerticalSelection: (direction: -1 | 1, extend: boolean) => boolean;
+    moveVerticalByBlock: (direction: -1 | 1) => boolean;
+    resolveAdjacentTableCellPosition: (document: EditorDocument, paragraphId: string, delta: -1 | 1) => EditorPosition | null;
+    applySelectionPreservingStructure: (selection: EditorState["selection"]) => void;
+    toggleFindReplace: (open?: boolean) => void;
+    toggleReplace: (open?: boolean) => void;
+    executeCommand?: (commandName: string, payload?: unknown) => unknown;
+    canExecuteCommand?: (commandName: string, payload?: unknown) => boolean;
+}
+export declare function createEditorKeyboardController(deps: EditorKeyboardDeps): {
+    handleKeyDown: (event: KeyboardEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    registry: EditorCommandRegistry;
+};

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

@@ -0,0 +1,42 @@
+import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
+import { CaretBox, InputBox, SelectionBox } from '../../../../ui/editorUiTypes.js';
+import { SelectedImageSelectionBox } 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 {
+    dirtyParagraphIds?: string[];
+    structureChanged?: boolean;
+    dirtyAll?: boolean;
+}
+export declare function useEditorLayout(props: UseEditorLayoutProps): {
+    measuredBlockHeights: import('../../solid-js').Accessor<Record<string, number>>;
+    measuredParagraphLayouts: import('../../solid-js').Accessor<Record<string, EditorLayoutParagraph>>;
+    inputBox: import('../../solid-js').Accessor<InputBox>;
+    selectionBoxes: import('../../solid-js').Accessor<SelectionBox[]>;
+    selectedImageBox: import('../../solid-js').Accessor<SelectedImageSelectionBox | null>;
+    caretBox: import('../../solid-js').Accessor<CaretBox>;
+    preferredColumnX: import('../../solid-js').Accessor<number | null>;
+    setPreferredColumnX: import('../../solid-js').Setter<number | null>;
+    clearPreferredColumn: () => null;
+    requestInputBoxSync: (reason?: LayoutSyncReason) => void;
+    scheduleDeferredLayoutMeasurement: (reason: LayoutSyncReason, options?: {
+        paragraphIds?: string[];
+        resolveWhenDone?: boolean;
+        blockHeightScope?: "all" | "visible";
+    }) => Promise<void> | null;
+    stabilizeLayoutAfterImport: () => Promise<void>;
+    syncMeasuredLayoutMetrics: (reason?: LayoutSyncReason) => boolean;
+    syncInputBox: (_reason?: LayoutSyncReason) => void;
+    setMeasuredBlockHeights: import('../../solid-js').Setter<Record<string, number>>;
+    setMeasuredParagraphLayouts: import('../../solid-js').Setter<Record<string, EditorLayoutParagraph>>;
+    applyInvalidation: (invalidation: LayoutInvalidation) => void;
+    onCleanupHook: () => void;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { EditorState } from '../../../../core/model.js';
+import { CaretBox } from '../../../../ui/editorUiTypes.js';
+
+export interface UseEditorNavigationProps {
+    state: () => EditorState;
+    applyState: (state: EditorState) => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState) => void;
+    surfaceRef: () => HTMLDivElement | null;
+    caretBox: () => CaretBox;
+    preferredColumnX: () => number | null;
+    setPreferredColumnX: (x: number | null) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    focusInput: () => void;
+}
+export declare function createEditorNavigation(deps: UseEditorNavigationProps): {
+    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;
+};

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

@@ -0,0 +1,16 @@
+import { EditorDocument, EditorState } from '../../../../core/model.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+export type PersistenceStatus = "Saved" | "Saving..." | "Error" | "Initial";
+export interface UseEditorPersistenceResult {
+    status: () => PersistenceStatus;
+}
+export interface DocumentPersistence {
+    saveDocument(doc: EditorDocument): Promise<void>;
+    loadDocument(): Promise<EditorDocument | null>;
+}
+export declare function useEditorPersistence(state: EditorState, onLoaded: (doc: EditorDocument) => void, options: {
+    enabled?: boolean;
+    persistence: DocumentPersistence;
+    logger?: Pick<EditorLogger, "error">;
+}): UseEditorPersistenceResult;

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

@@ -0,0 +1,12 @@
+import { EditorState } from '../../../../core/model.js';
+import { RevisionBox } from '../../../../ui/editorUiTypes.js';
+
+export interface UseEditorRevisionProps {
+    state: () => EditorState;
+    surfaceRef: () => HTMLDivElement | null;
+}
+export declare function createEditorRevisionController(deps: UseEditorRevisionProps): {
+    hoveredRevision: import('../../solid-js').Accessor<RevisionBox | null>;
+    handleRevisionMouseEnter: (revisionId: string, event: MouseEvent) => void;
+    handleRevisionMouseLeave: () => void;
+};

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

@@ -0,0 +1,23 @@
+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";
+export interface UseEditorStyleProps {
+    state: () => EditorState;
+    commandsController: () => ReturnType<typeof createEditorCommandsController>;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    focusInput: () => void;
+    logger: {
+        info: (msg: string) => void;
+    };
+}
+export declare function createEditorStyleController(deps: UseEditorStyleProps): {
+    pendingCaretTextStyle: import('../../solid-js').Accessor<EditorTextStyle | undefined>;
+    clearPendingCaretTextStyle: () => void;
+    toolbarStyleState: () => ToolbarStyleState;
+    applyToolbarValueStyleCommand: <K extends ValueStyleKey>(key: K, value: EditorTextStyle[K] | null) => void;
+    applyToolbarBooleanStyleCommand: (key: BooleanStyleKey) => void;
+};
+export {};

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

@@ -0,0 +1,44 @@
+import { EditorState, EditorParagraphNode } from '../../../../core/model.js';
+import { SurfaceHit } from '../../../../ui/canvas/CanvasHitTestService.js';
+
+export interface UseEditorSurfaceEventsProps {
+    state: () => EditorState;
+    applyState: (newState: EditorState) => void;
+    tableResize: {
+        handleMouseDown: (event: MouseEvent) => boolean;
+    };
+    imageOps: {
+        stopImageDrag: () => void;
+        stopImageResize: () => void;
+        startImageDrag: (paragraphId: string, paragraphOffset: number, event: MouseEvent, pointerBounds?: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        }) => void;
+    };
+    clearPendingCaretTextStyle: () => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    focusInputAfterPointerSelection: () => void;
+    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
+        forDrag?: boolean;
+    }) => SurfaceHit | null;
+    getParagraphById: (doc: EditorState["document"], id: string) => EditorParagraphNode | undefined;
+    textDrag?: {
+        tryStartTextDrag: (event: MouseEvent, hit: SurfaceHit | null) => boolean;
+    };
+    logger: {
+        debug: (msg: string) => void;
+        info: (msg: string, payload?: unknown) => void;
+    };
+}
+export declare function createEditorSurfaceEvents(deps: UseEditorSurfaceEventsProps): {
+    handleSurfaceMouseDown: (event: MouseEvent) => void;
+    handleSurfaceClick: (event: MouseEvent) => void;
+    handleSurfaceDblClick: (event: MouseEvent) => void;
+    handleParagraphMouseDown: (_paragraphId: string, event: MouseEvent & {
+        currentTarget: HTMLParagraphElement;
+    }) => void;
+    stopDragging: () => void;
+};

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

@@ -0,0 +1,29 @@
+import { EditorState, EditorPosition } from '../../../../core/model.js';
+
+export interface TableDragOps {
+    dragging: () => boolean;
+    startClientY: () => number;
+    handleMouseDown: (tableId: string, event: MouseEvent) => void;
+    dropTargetPos: () => EditorPosition | null;
+}
+export declare function createEditorTableDrag(deps: {
+    state: () => EditorState;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState) => void;
+    resolvePositionAtSurfacePoint: (clientX: number, clientY: number) => EditorPosition | null;
+    focusInput: () => void;
+}): {
+    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;
+};

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

@@ -0,0 +1,45 @@
+import { EditorBlockNode, EditorDocument, EditorPosition, EditorState, EditorEditingZone } from '../../../../core/model.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+export interface EditorTableOperationsDeps {
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    applySelectionToStatePreservingStructure: (current: EditorState, nextSelection: EditorState["selection"]) => EditorState;
+    focusInput: () => void;
+    logger?: EditorLogger;
+}
+export declare function createEditorTableOperations(deps: EditorTableOperationsDeps): {
+    resolveTableCellRangeSelection: (current: EditorState) => EditorState["selection"] | null;
+    resolveHorizontalTableCellRange: (current: EditorState) => import('../../tableOpsSelectionRanges.js').HorizontalTableCellRange | null;
+    resolveVerticalTableCellRange: (current: EditorState) => import('../../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: EditorBlockNode[], zone?: EditorEditingZone) => EditorState;
+    resolveAdjacentTableCellPosition: (document: 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;
+};

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

@@ -0,0 +1,32 @@
+import { EditorState } from '../../../../core/model.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 declare function createEditorTableResize(deps: {
+    state: () => EditorState;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState) => void;
+    surfaceRef: () => HTMLElement | undefined;
+    viewportRef: () => HTMLElement | undefined;
+}): TableResizeOps;

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

@@ -0,0 +1,38 @@
+import { EditorPosition, EditorState } from '../../../../core/model.js';
+import { SurfaceHit } from '../../../../ui/canvas/CanvasHitTestService.js';
+
+export interface EditorTextDragDeps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
+        forDrag?: boolean;
+    }) => SurfaceHit | null;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    applyTableAwareParagraphEdit: (state: EditorState, edit: (state: EditorState) => EditorState) => EditorState;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    focusInputAfterPointerSelection: () => void;
+    logger?: {
+        debug: (msg: string, payload?: unknown) => void;
+        info: (msg: string, payload?: unknown) => void;
+        warn?: (msg: string, payload?: unknown) => void;
+    };
+}
+export declare function createEditorTextDrag(deps: EditorTextDragDeps): {
+    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: SurfaceHit | null) => boolean;
+    stopDrag: () => void;
+};

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

@@ -0,0 +1,27 @@
+import { EditorState, EditorTextStyle } from '../../../../core/model.js';
+
+export interface UseEditorTextInputProps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    logger: {
+        debug: (msg: string) => void;
+        info: (msg: string) => void;
+    };
+    clearPreferredColumn: () => void;
+    pendingCaretTextStyle: () => EditorTextStyle | undefined;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    applyTableAwareParagraphEdit: (state: EditorState, edit: (temp: EditorState) => EditorState) => EditorState;
+    focusInput: () => void;
+}
+export declare function createEditorTextInput(deps: UseEditorTextInputProps): {
+    handleTextInput: (event: InputEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    handleCompositionStart: () => void;
+    handleCompositionEnd: (event: CompositionEvent & {
+        currentTarget: HTMLTextAreaElement;
+    }) => void;
+    composing: import('../../solid-js').Accessor<boolean>;
+};

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

@@ -0,0 +1,12 @@
+import { EditorDocument, EditorPosition } from '../../../../core/model.js';
+
+export interface FindReplaceMatch {
+    anchor: EditorPosition;
+    focus: EditorPosition;
+    paragraphIndex: number;
+}
+export interface FindOptions {
+    matchCase?: boolean;
+    wholeWord?: boolean;
+}
+export declare function findMatchesInDocument(doc: EditorDocument, searchTerm: string, options?: FindOptions): FindReplaceMatch[];

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

@@ -0,0 +1,11 @@
+import { EditorDocument } from '../../../../core/model.js';
+
+export declare class PersistenceService {
+    private db;
+    private getDB;
+    saveDocument(doc: EditorDocument): Promise<void>;
+    loadDocument(): Promise<EditorDocument | null>;
+    clearDocument(): Promise<void>;
+    close(): void;
+}
+export declare const persistenceService: PersistenceService;