mathlean-canvas 0.3.2 → 0.3.4

package/dist/MathCanvas/features/grid/hooks/useGridObjectState.d.ts

@@ -0,0 +1,147 @@
+import { type MutableRefObject } from "react";
+import type { CanvasState, GridSelection, MatrixObject, TableObject } from "../../../types";
+type UseGridObjectStateOptions = {
+    initialState?: Pick<CanvasState, "matrices" | "tables">;
+    pushHistoryStateRef: MutableRefObject<() => void>;
+};
+export declare function useGridObjectState({ initialState, pushHistoryStateRef, }: UseGridObjectStateOptions): {
+    beginGridSelection: (kind: "matrix" | "table", id: string, row: number, col: number, mode?: "cell" | "row" | "column") => void;
+    beginGridStructureDrag: (kind: "matrix" | "table", id: string, mode: "row" | "column", index: number) => void;
+    beginMatrixEditing: (id: string, cell?: {
+        row: number;
+        col: number;
+    }) => void;
+    beginTableEditing: (id: string, cell?: {
+        row: number;
+        col: number;
+    }) => void;
+    clearGridSelectionCells: () => void;
+    clearMatrixEditing: () => void;
+    clearMatrixSelection: () => void;
+    clearTableEditing: () => void;
+    clearTableSelection: () => void;
+    commitMatrixEditing: () => void;
+    commitTableEditing: () => void;
+    createMatrixObject: (id: string, x: number, y: number, rows: number, cols: number) => void;
+    createTableObject: (id: string, x: number, y: number, rows: number, cols: number) => void;
+    editingMatrixCell: {
+        row: number;
+        col: number;
+    } | null;
+    editingMatrixId: string | null;
+    editingTableCell: {
+        row: number;
+        col: number;
+    } | null;
+    editingTableId: string | null;
+    endGridSelectionDrag: () => void;
+    extendGridSelection: (kind: "matrix" | "table", id: string, row: number, col: number) => void;
+    extendGridSelectionWithKeyboard: (kind: "matrix" | "table", id: string, row: number, col: number, nextRow: number, nextCol: number) => void;
+    deleteSelectedMatrix: () => void;
+    deleteSelectedTable: () => void;
+    deleteGridSelectionStructure: () => void;
+    fillIdentityMatrix: (id: string) => void;
+    findMatrixAtPoint: (x: number, y: number) => MatrixObject | null;
+    findTableAtPoint: (x: number, y: number) => TableObject | null;
+    getMatrixById: (id: string | null) => MatrixObject | null;
+    getGridSelectionClipboardText: () => string;
+    getMatrixColSeparatorIndexForCell: (colIndex: number, colCount: number) => number | null;
+    getMatrixRowSeparatorIndexForCell: (rowIndex: number, rowCount: number) => number | null;
+    getTableById: (id: string | null) => TableObject | null;
+    gridKeyboardSelectionAnchorRef: import("react").RefObject<{
+        kind: "matrix" | "table";
+        id: string;
+        row: number;
+        col: number;
+    } | null>;
+    gridMoveDragRef: import("react").RefObject<{
+        kind: "matrix" | "table";
+        id: string;
+        mode: "row" | "column";
+        startIndex: number;
+        endIndex: number;
+        targetIndex: number;
+    } | null>;
+    gridMovePreview: {
+        kind: "matrix" | "table";
+        id: string;
+        mode: "row" | "column";
+        targetIndex: number;
+    } | null;
+    gridSelection: GridSelection | null;
+    gridSelectionDragRef: import("react").RefObject<{
+        kind: "matrix" | "table";
+        id: string;
+        anchorRow: number;
+        anchorCol: number;
+        mode: "cell" | "row" | "column";
+    } | null>;
+    isCellInGridSelection: (kind: "matrix" | "table", id: string, row: number, col: number) => boolean;
+    insertGridSelectionStructure: () => void;
+    matrixInputRefs: import("react").RefObject<Record<string, HTMLInputElement | null>>;
+    matrixLatexPopover: {
+        matrixId: string;
+        left: number;
+        top: number;
+    } | null;
+    matrixNodeRefs: import("react").RefObject<Record<string, import("konva/lib/shapes/Rect").Rect | null>>;
+    matrixOverlayRefs: import("react").RefObject<Record<string, HTMLDivElement | null>>;
+    matrices: MatrixObject[];
+    matrixTransformerRef: import("react").RefObject<import("konva/lib/shapes/Transformer").Transformer | null>;
+    selectedMatrixId: string | null;
+    selectedTableId: string | null;
+    selectWholeMatrix: (id: string) => void;
+    moveGridSelectionRangeToIndex: (kind: "matrix" | "table", id: string, mode: "row" | "column", startIndex: number, endIndex: number, targetIndex: number) => void;
+    moveGridSelectionStructure: (direction: "up" | "down" | "left" | "right") => void;
+    pasteGridSelectionClipboardText: (text: string) => void;
+    resizeMatrix: (id: string, nextRows: number, nextCols: number) => void;
+    resizeTable: (id: string, nextRows: number, nextCols: number) => void;
+    rotateMatrixClockwise: (id: string) => void;
+    rotateMatrixCounterclockwise: (id: string) => void;
+    setEditingMatrixCell: import("react").Dispatch<import("react").SetStateAction<{
+        row: number;
+        col: number;
+    } | null>>;
+    setEditingMatrixId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setEditingTableCell: import("react").Dispatch<import("react").SetStateAction<{
+        row: number;
+        col: number;
+    } | null>>;
+    setEditingTableId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setGridMovePreview: import("react").Dispatch<import("react").SetStateAction<{
+        kind: "matrix" | "table";
+        id: string;
+        mode: "row" | "column";
+        targetIndex: number;
+    } | null>>;
+    setGridSelection: import("react").Dispatch<import("react").SetStateAction<GridSelection | null>>;
+    setMatrices: import("react").Dispatch<import("react").SetStateAction<MatrixObject[]>>;
+    setMatrixLatexPopover: import("react").Dispatch<import("react").SetStateAction<{
+        matrixId: string;
+        left: number;
+        top: number;
+    } | null>>;
+    setSelectedMatrixId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSelectedTableId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setTables: import("react").Dispatch<import("react").SetStateAction<TableObject[]>>;
+    skipNextMatrixCreationRef: import("react").RefObject<boolean>;
+    tableInputRefs: import("react").RefObject<Record<string, HTMLInputElement | null>>;
+    tableNodeRefs: import("react").RefObject<Record<string, import("konva/lib/shapes/Rect").Rect | null>>;
+    tableOverlayRefs: import("react").RefObject<Record<string, HTMLDivElement | null>>;
+    tables: TableObject[];
+    tableTransformerRef: import("react").RefObject<import("konva/lib/shapes/Transformer").Transformer | null>;
+    toggleMatrixColSeparator: (id: string, colIndex: number, useSelectionRange?: boolean) => void;
+    toggleMatrixRowSeparator: (id: string, rowIndex: number, useSelectionRange?: boolean) => void;
+    transformGridSelectionToAntiDiagonal: () => void;
+    transformGridSelectionToDiagonal: () => void;
+    transformGridSelectionToLowerTriangular: () => void;
+    transformGridSelectionToUpperTriangular: () => void;
+    transformSelectedMatrixRegion: (transform: "rotateClockwise" | "rotateCounterclockwise" | "transpose") => void;
+    transposeMatrix: (id: string) => void;
+    updateMatrix: (id: string, updater: (matrix: MatrixObject) => MatrixObject) => void;
+    updateGridStructureDragTarget: (kind: "matrix" | "table", id: string, mode: "row" | "column", index: number) => void;
+    updateMatrixSelectionCells: (id: string, row: number, col: number, value: string) => void;
+    updateTable: (id: string, updater: (table: TableObject) => TableObject) => void;
+    updateTableSelectionCells: (id: string, row: number, col: number, value: string) => void;
+};
+export {};

package/dist/MathCanvas/features/grid/index.d.ts

@@ -0,0 +1,5 @@
+export { default as GridObjectOverlays } from "./components/GridObjectOverlays";
+export { default as MatrixLayer } from "./components/MatrixLayer";
+export { useGridCanvasActions } from "./hooks/useGridCanvasActions";
+export { useGridObjectState } from "./hooks/useGridObjectState";
+export { getMatrixWidth, getTableWidth, matrixToLatex } from "./utils/matrixOps";

package/dist/MathCanvas/features/grid/utils/matrixOps.d.ts

@@ -0,0 +1,36 @@
+import type { GridSelection, MatrixObject, MatrixSeparator, MatrixSeparatorSegment, TableObject, TextBlock } from "../../../types";
+export declare function createEmptyMatrixCells(rows: number, cols: number): string[][];
+export declare function resizeMatrixCells(cells: string[][], nextRows: number, nextCols: number, fillValue?: string): string[][];
+export declare function matrixSeparatorToSegment(separator: MatrixSeparator, maxEnd: number): MatrixSeparatorSegment;
+export declare function normalizeMatrixSeparatorSegment(segment: MatrixSeparatorSegment, maxEnd: number): MatrixSeparatorSegment;
+export declare function resizeSeparatorSegments(separators: MatrixSeparator[], maxExclusive: number, maxEnd: number): MatrixSeparatorSegment[];
+export declare const resizeSeparatorIndices: typeof resizeSeparatorSegments;
+export declare function getMatrixRowSeparatorSegments(matrix: MatrixObject): MatrixSeparatorSegment[];
+export declare function getMatrixColSeparatorSegments(matrix: MatrixObject): MatrixSeparatorSegment[];
+export declare function hasAnyMatrixSeparatorAtIndex(separators: MatrixSeparator[], index: number, maxEnd: number): boolean;
+export declare function toggleMatrixSeparatorSegment(separators: MatrixSeparator[], index: number, start: number, end: number, maxEnd: number): MatrixSeparatorSegment[];
+export declare function getMatrixColumnWidths(matrix: MatrixObject): number[];
+export declare function getMatrixContentWidth(matrix: MatrixObject): number;
+export declare function getMatrixColumnOffset(columnWidths: number[], colIndex: number): number;
+export declare function getMatrixColumnSpanWidth(columnWidths: number[], startCol: number, endCol: number): number;
+export declare function getMatrixRowOffset(rowIndex: number): number;
+export declare function getMatrixRowSpanHeight(startRow: number, endRow: number): number;
+export declare function matrixToLatex(matrix: MatrixObject): string;
+export declare function getMatrixWidth(matrix: MatrixObject): number;
+export declare function getMatrixHeight(matrix: MatrixObject): number;
+export declare function getMatrixAxisY(matrix: MatrixObject): number;
+export declare function getTableColumnWidths(table: TableObject): number[];
+export declare function getTableWidth(table: TableObject): number;
+export declare function getTableHeight(table: TableObject): number;
+export declare function getTableAxisY(table: TableObject): number;
+export declare function snapMatrixPositionToAxes(matrix: MatrixObject, x: number, y: number, matrices: MatrixObject[], blocks: TextBlock[], getTextMathAxisY: (block: TextBlock) => number | null): {
+    x: number;
+    y: number;
+};
+export declare function snapTablePositionToAxes(table: TableObject, x: number, y: number, tables: TableObject[], matrices: MatrixObject[], blocks: TextBlock[], getTextMathAxisY: (block: TextBlock) => number | null): {
+    x: number;
+    y: number;
+};
+export declare function normalizeGridSelection(selection: GridSelection): GridSelection;
+export declare function getGridCellKey(row: number, col: number): string;
+export declare function isCellSelectedByGridSelection(selection: GridSelection, kind: "matrix" | "table", id: string, row: number, col: number): boolean;

package/dist/MathCanvas/features/plot/components/PlotControls.d.ts

@@ -0,0 +1,28 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { MathCanvasTheme, PlotFunction } from "../../../types";
+type PlotControlsProps = {
+    colors: MathCanvasTheme;
+    editingPlot: PlotFunction | null;
+    editingPlotEquationId: string | null;
+    editingPlotLatex: string;
+    plotColorOptions: readonly string[];
+    plotMenuPanel: "actions" | "color" | null;
+    copySelectedPlot: (plot: PlotFunction) => Promise<void>;
+    createPlotEquation: (plotId: string) => void;
+    deletePlotEquation: (plotId: string, equationId: string) => void;
+    deleteSelectedPlot: () => void;
+    commitPlotEditing: () => boolean;
+    pushHistoryState: () => void;
+    setEditingPlotEquationId: Dispatch<SetStateAction<string | null>>;
+    setEditingPlotId: Dispatch<SetStateAction<string | null>>;
+    setEditingPlotLatex: Dispatch<SetStateAction<string>>;
+    setPlotMenuPanel: (panel: "actions" | "color" | null) => void;
+    setPlots: Dispatch<SetStateAction<PlotFunction[]>>;
+    updatePlotEquationColor: (plotId: string, equationId: string, color: string) => void;
+    viewport: {
+        x: number;
+        y: number;
+    };
+};
+export default function PlotControls({ colors, editingPlot, editingPlotEquationId, editingPlotLatex, plotColorOptions, plotMenuPanel, copySelectedPlot, createPlotEquation, deletePlotEquation, deleteSelectedPlot, commitPlotEditing, pushHistoryState, setEditingPlotEquationId, setEditingPlotId, setEditingPlotLatex, setPlotMenuPanel, setPlots, updatePlotEquationColor, viewport, }: PlotControlsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/MathCanvas/features/plot/components/PlotLayer.d.ts

@@ -0,0 +1,30 @@
+import type Konva from "konva";
+import type { MutableRefObject } from "react";
+import type { MathCanvasTheme, PlotFunction, Tool } from "../../../types";
+type PlotLayerProps = {
+    plots: PlotFunction[];
+    colors: MathCanvasTheme;
+    darkMode: boolean;
+    size: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        x: number;
+        y: number;
+    };
+    plotNodeRefs: MutableRefObject<Record<string, Konva.Group | null>>;
+    selectedPlotId: string | null;
+    tool: Tool;
+    clearGraphSelection: () => void;
+    clearMatrixSelection: () => void;
+    clearTableSelection: () => void;
+    pushHistoryState: () => void;
+    setSelectedBlockId: (id: string | null) => void;
+    setSelectedPlotId: (id: string | null) => void;
+    openPlotActions: (id: string) => void;
+    startPlotEditing: (id: string) => void;
+    updatePlot: (id: string, updater: (plot: PlotFunction) => PlotFunction) => void;
+};
+export default function PlotLayer({ plots, colors, darkMode, size, viewport, plotNodeRefs, selectedPlotId, tool, clearGraphSelection, clearMatrixSelection, clearTableSelection, pushHistoryState, setSelectedBlockId, setSelectedPlotId, openPlotActions, startPlotEditing, updatePlot, }: PlotLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/plot/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PlotControls } from "./components/PlotControls";
+export { default as PlotLayer } from "./components/PlotLayer";

package/dist/MathCanvas/features/plot/utils/plotCompiler.d.ts

@@ -0,0 +1,18 @@
+import type { MathJsonExpression } from "@cortex-js/compute-engine/math-json";
+export type PlotCompileResult = {
+    ok: true;
+    latex: string;
+    mathJson: MathJsonExpression;
+} | {
+    ok: false;
+    error: string;
+};
+export type CompiledPlotFunction = {
+    kind: "explicit";
+    evaluate: (x: number) => number;
+} | {
+    kind: "implicit";
+    evaluate: (x: number, y: number) => number;
+};
+export declare function compilePlotLatex(latex: string): PlotCompileResult;
+export declare function compilePlotMathJson(mathJson: MathJsonExpression | null): CompiledPlotFunction | null;

package/dist/MathCanvas/features/plot/utils/plotModel.d.ts

@@ -0,0 +1,16 @@
+import type { PlotEquation, PlotFunction } from "../../../types";
+export declare const PLOT_EQUATION_ROW_HEIGHT = 42;
+export declare const PLOT_EQUATION_TOP_PADDING = 8;
+export declare const PLOT_EQUATION_BOTTOM_PADDING = 8;
+export declare const PLOT_EQUATION_MIN_HEIGHT = 52;
+export declare const PLOT_EQUATION_PANEL_WIDTH = 190;
+export declare const PLOT_EQUATION_PANEL_MAX_WIDTH = 440;
+export declare const PLOT_EQUATION_PANEL_GAP = 8;
+export declare const PLOT_EQUATION_PANEL_DEFAULT_TOP = 10;
+export declare function getPlotEquations(plot: PlotFunction): PlotEquation[];
+export declare function getPlotEquationAreaHeight(plot: PlotFunction): number;
+export declare function getPlotEquationPanelWidth(plot: PlotFunction): number;
+export declare function getPlotEquationTextWidth(panelWidth: number): number;
+export declare function getPlotEquationRowHeight(equation: PlotEquation, panelWidth: number): number;
+export declare function getPlotEquationRowTop(plot: PlotFunction, index: number): number;
+export declare function normalizePlot(plot: PlotFunction): PlotFunction;

package/dist/MathCanvas/features/stroke/components/StrokeLayer.d.ts

@@ -0,0 +1,8 @@
+import type { MathCanvasTheme, Stroke } from "../../../types";
+type StrokeLayerProps = {
+    strokes: Stroke[];
+    colors: MathCanvasTheme;
+    penWidth: number;
+};
+export default function StrokeLayer({ strokes, colors, penWidth }: StrokeLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/stroke/hooks/useStrokeState.d.ts

@@ -0,0 +1,33 @@
+import { type MutableRefObject } from "react";
+import type { CanvasState, Stroke, Tool } from "../../../types";
+type UseStrokeStateOptions = {
+    initialState?: Pick<CanvasState, "strokes">;
+    defaultPenColor: string;
+    pushHistoryStateRef: MutableRefObject<() => void>;
+};
+export declare function useStrokeState({ initialState, defaultPenColor, pushHistoryStateRef }: UseStrokeStateOptions): {
+    clearEraserPreview: () => void;
+    eraserPreview: {
+        x: number;
+        y: number;
+        radius: number;
+        visible: boolean;
+    };
+    eraseAtPoint: (x: number, y: number, radius: number, createId: () => string) => void;
+    extendStroke: (x: number, y: number) => void;
+    isDrawing: import("react").RefObject<boolean>;
+    isErasing: import("react").RefObject<boolean>;
+    penColor: string;
+    penColorOptions: readonly [string, "#d14343", "#2f6fed", "#2f9e44", "#c89b0e", "#f2d21b"];
+    penWidth: 2 | 12 | 8 | 6 | 4;
+    setStrokes: import("react").Dispatch<import("react").SetStateAction<Stroke[]>>;
+    setPenColor: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setPenWidth: import("react").Dispatch<import("react").SetStateAction<2 | 12 | 8 | 6 | 4>>;
+    setShowPenSizes: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showPenSizes: boolean;
+    showPenSizePreviewBriefly: () => void;
+    startStroke: (x: number, y: number, tool: Tool, strokeWidth: number, color: string, createId: () => string) => boolean;
+    strokes: Stroke[];
+    updateEraserPreview: (x: number, y: number) => number;
+};
+export {};

package/dist/MathCanvas/features/stroke/index.d.ts

@@ -0,0 +1,2 @@
+export { default as StrokeLayer } from "./components/StrokeLayer";
+export { useStrokeState } from "./hooks/useStrokeState";

package/dist/MathCanvas/features/text/components/BlockRenderers.d.ts

@@ -0,0 +1,24 @@
+import type { RenderMode, TextStyleRange } from "../../../types";
+export declare function InlineKatex({ expression, fallback, displayMode, }: {
+    expression: string;
+    fallback: string;
+    displayMode?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RenderKatexExpression({ expression, fallback, displayMode, }: {
+    expression: string;
+    fallback: string;
+    displayMode?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RenderBlockContent({ content, renderMode, styles, }: {
+    content: string;
+    renderMode: RenderMode;
+    styles?: TextStyleRange[];
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RenderEditableBlockContent({ content, renderMode, styles, activeMathStart, caretPosition, hideActiveMath, }: {
+    content: string;
+    renderMode: RenderMode;
+    styles?: TextStyleRange[];
+    activeMathStart?: number | null;
+    caretPosition?: number | null;
+    hideActiveMath?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/MathCanvas/features/text/components/InlineMathBubble.d.ts

@@ -0,0 +1,36 @@
+import type { Dispatch, RefObject, SetStateAction } from "react";
+import type { MathfieldElement } from "mathlive";
+import type { ActiveInlineMathSession, InlineMathPreview } from "../../../../useInlineMathSession";
+import type { MathCanvasTheme, TextBlock } from "../../../types";
+type InlineMathEditorRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+} | null;
+type InlineMathBubbleProps = {
+    activeInlineMathAtomId: string | null;
+    activeInlineMathDraft: string;
+    activeInlineMathSession: ActiveInlineMathSession | null;
+    activateInlineMathFallback: () => void;
+    cancelActiveInlineMathDraft: () => void;
+    colors: MathCanvasTheme;
+    commitActiveInlineMathDraft: () => void;
+    darkMode: boolean;
+    editingBlock: TextBlock | null;
+    editingBlockId: string | null;
+    exitActiveInlineMathDraft: (direction: "before" | "after") => void;
+    handleInlineMathLatexChange: (latex: string) => void;
+    inlineMathBubbleRef: RefObject<HTMLDivElement | null>;
+    inlineMathEditorMode: "mathlive" | "fallback";
+    inlineMathEditorRect: InlineMathEditorRect;
+    inlineMathFieldRef: RefObject<MathfieldElement | null>;
+    latexPreview: InlineMathPreview;
+    markInlineMathEditorReady: () => void;
+    openTextBlockMenu: (block: TextBlock) => void;
+    setActiveInlineMathDraft: Dispatch<SetStateAction<string>>;
+    setRenderMode: Dispatch<SetStateAction<"plain" | "latex">>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+};
+export default function InlineMathBubble({ activeInlineMathAtomId, activeInlineMathDraft, activeInlineMathSession, activateInlineMathFallback, cancelActiveInlineMathDraft, colors, commitActiveInlineMathDraft, darkMode, editingBlock, editingBlockId, exitActiveInlineMathDraft, handleInlineMathLatexChange, inlineMathBubbleRef, inlineMathEditorMode, inlineMathEditorRect, inlineMathFieldRef, latexPreview, markInlineMathEditorReady, openTextBlockMenu, setActiveInlineMathDraft, setRenderMode, setSelectedBlockId, }: InlineMathBubbleProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/MathCanvas/features/text/components/TextBlockEditor.d.ts

@@ -0,0 +1,46 @@
+import type { Dispatch, MouseEvent, MutableRefObject, RefObject, SetStateAction } from "react";
+import type { MathfieldElement } from "mathlive";
+import type { ActiveInlineMathSession } from "../../../../useInlineMathSession";
+import type { MathCanvasTheme, RenderMode, TextBlock, TextboxResizeAnchor } from "../../../types";
+type MathOverlayCaret = {
+    left: number;
+    top: number;
+    height: number;
+} | null;
+type TextBlockEditorProps = {
+    activeInlineMathSession: ActiveInlineMathSession | null;
+    activeInlineMathSessionRef: MutableRefObject<ActiveInlineMathSession | null>;
+    beginTextboxResize: (block: TextBlock, anchor: TextboxResizeAnchor, event: MouseEvent<HTMLDivElement>) => void;
+    clearEditing: () => void;
+    colors: MathCanvasTheme;
+    commitActiveInlineMathDraft: () => void;
+    commitEditing: () => void;
+    editableMirrorContentRef: RefObject<HTMLDivElement | null>;
+    editableMirrorRef: RefObject<HTMLDivElement | null>;
+    editingBlock: TextBlock | null;
+    editingDisplayValue: string;
+    editingHeight: number;
+    editingSelection: number;
+    editingValue: string;
+    editingWidth: number;
+    inlineMathBubbleRef: RefObject<HTMLDivElement | null>;
+    inlineMathFieldRef: RefObject<MathfieldElement | null>;
+    insertInlineMathAtSelection: (start: number, end: number) => void;
+    isOpeningInlineMathSessionRef: MutableRefObject<boolean>;
+    latexPreviewStart: number | null;
+    mathOverlayCaret: MathOverlayCaret;
+    openTextBlockMenu: (block: TextBlock) => void;
+    rememberEditingSelection: (target: HTMLTextAreaElement) => void;
+    reopenInlineMathSessionAtBoundary: (direction: "before" | "after") => boolean;
+    setEditingValue: Dispatch<SetStateAction<string>>;
+    setRenderMode: Dispatch<SetStateAction<RenderMode>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    size: {
+        width: number;
+        height: number;
+    };
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+    toggleLatexMode: () => void;
+};
+export default function TextBlockEditor({ activeInlineMathSession, activeInlineMathSessionRef, beginTextboxResize, clearEditing, colors, commitActiveInlineMathDraft, commitEditing, editableMirrorContentRef, editableMirrorRef, editingBlock, editingDisplayValue, editingHeight, editingSelection, editingValue, editingWidth, inlineMathBubbleRef, inlineMathFieldRef, insertInlineMathAtSelection, isOpeningInlineMathSessionRef, latexPreviewStart, mathOverlayCaret, openTextBlockMenu, rememberEditingSelection, reopenInlineMathSessionAtBoundary, setEditingValue, setRenderMode, setSelectedBlockId, size, textareaRef, toggleLatexMode, }: TextBlockEditorProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/MathCanvas/features/text/components/TextBlockMenu.d.ts

@@ -0,0 +1,25 @@
+import type { Dispatch, SetStateAction } from "react";
+import type { MathCanvasTheme, TextBlock, TextStyleRange } from "../../../types";
+type TextBlockMenuState = {
+    blockId: string;
+    panel: "format" | "color" | null;
+} | null;
+type TextBlockMenuProps = {
+    blockWidths: Record<string, number>;
+    colors: MathCanvasTheme;
+    copyTextBlock: (block: TextBlock) => Promise<void>;
+    deleteTextBlock: (id: string) => void;
+    editingBlockId: string | null;
+    getBlockById: (id: string | null) => TextBlock | null;
+    getResolvedEditingValue: () => string;
+    getTextboxSelectionRange: (blockId: string, contentLength: number) => {
+        start: number;
+        end: number;
+    } | null;
+    penColorOptions: readonly string[];
+    setTextBlockMenu: Dispatch<SetStateAction<TextBlockMenuState>>;
+    textBlockMenu: TextBlockMenuState;
+    updateTextBlockStyle: (blockId: string, patch: Partial<Omit<TextStyleRange, "id" | "start" | "end">>) => void;
+};
+export default function TextBlockMenu({ blockWidths, colors, copyTextBlock, deleteTextBlock, editingBlockId, getBlockById, getResolvedEditingValue, getTextboxSelectionRange, penColorOptions, setTextBlockMenu, textBlockMenu, updateTextBlockStyle, }: TextBlockMenuProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/MathCanvas/features/text/components/TextBlockView.d.ts

@@ -0,0 +1,22 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import type { MathCanvasTheme, RenderMode, TextBlock, Tool } from "../../../types";
+type TextBlockViewProps = {
+    block: TextBlock;
+    blockWidths: Record<string, number>;
+    clearGraphSelection: () => void;
+    clearMatrixSelection: () => void;
+    colors: MathCanvasTheme;
+    openTextBlockMenu: (block: TextBlock) => void;
+    overlayRefs: MutableRefObject<Record<string, HTMLDivElement | null>>;
+    selectedBlockId: string | null;
+    setRenderMode: Dispatch<SetStateAction<RenderMode>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    size: {
+        width: number;
+        height: number;
+    };
+    startEditing: (id: string, selectionOverride?: number | null) => void;
+    tool: Tool;
+};
+export default function TextBlockView({ block, blockWidths, clearGraphSelection, clearMatrixSelection, colors, openTextBlockMenu, overlayRefs, selectedBlockId, setRenderMode, setSelectedBlockId, size, startEditing, tool, }: TextBlockViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/text/components/TextInteractionLayer.d.ts

@@ -0,0 +1,29 @@
+import type Konva from "konva";
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import type { MathCanvasTheme, RenderMode, TextBlock, Tool } from "../../../types";
+type TextInteractionLayerProps = {
+    blocks: TextBlock[];
+    blockWidths: Record<string, number>;
+    blockHeights: Record<string, number>;
+    size: {
+        width: number;
+        height: number;
+    };
+    tool: Tool;
+    colors: MathCanvasTheme;
+    blockNodeRefs: MutableRefObject<Record<string, Konva.Rect | null>>;
+    transformerRef: MutableRefObject<Konva.Transformer | null>;
+    graphTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    matrixTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    tableTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    clearGraphSelection: () => void;
+    clearMatrixSelection: () => void;
+    openTextBlockMenu: (block: TextBlock) => void;
+    pushHistoryState: () => void;
+    setRenderMode: Dispatch<SetStateAction<RenderMode>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    startEditing: (id: string) => void;
+    updateBlock: (id: string, updater: (block: TextBlock) => TextBlock) => void;
+};
+export default function TextInteractionLayer({ blocks, blockWidths, blockHeights, size, tool, colors, blockNodeRefs, transformerRef, graphTransformerRef, matrixTransformerRef, tableTransformerRef, clearGraphSelection, clearMatrixSelection, openTextBlockMenu, pushHistoryState, setRenderMode, setSelectedBlockId, startEditing, updateBlock, }: TextInteractionLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/text/hooks/useTextBlockActions.d.ts

@@ -0,0 +1,40 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import type { TextBlock, TextStyleRange } from "../../../types";
+type TextBlockMenu = {
+    blockId: string;
+    panel: "color" | "format" | null;
+};
+type UseTextBlockActionsOptions = {
+    blocks: TextBlock[];
+    clearEditing: () => void;
+    createId: () => string;
+    editingBlockId: string | null;
+    editingSelection: number;
+    editingSelectionEnd: number;
+    getResolvedEditingValue: () => string;
+    lastEditingSelectionRangeRef: MutableRefObject<{
+        blockId: string;
+        start: number;
+        end: number;
+    } | null>;
+    pushHistoryState: () => void;
+    selectedBlockId: string | null;
+    setBlocks: Dispatch<SetStateAction<TextBlock[]>>;
+    setEditingValue: Dispatch<SetStateAction<string>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    setTextBlockMenu: Dispatch<SetStateAction<TextBlockMenu | null>>;
+    textareaRef: MutableRefObject<HTMLTextAreaElement | null>;
+};
+export declare function useTextBlockActions({ blocks, clearEditing, createId, editingBlockId, editingSelection, editingSelectionEnd, getResolvedEditingValue, lastEditingSelectionRangeRef, pushHistoryState, selectedBlockId, setBlocks, setEditingValue, setSelectedBlockId, setTextBlockMenu, textareaRef, }: UseTextBlockActionsOptions): {
+    copyTextBlock: (block: TextBlock) => Promise<void>;
+    deleteTextBlock: (blockId: string) => void;
+    getBlockById: (id: string | null) => TextBlock | null;
+    getTextboxSelectionRange: (blockId: string, contentLength: number) => {
+        start: number;
+        end: number;
+    } | null;
+    openTextBlockMenu: (block: TextBlock) => void;
+    updateBlock: (id: string, updater: (block: TextBlock) => TextBlock) => void;
+    updateTextBlockStyle: (blockId: string, stylePatch: Omit<TextStyleRange, "id" | "start" | "end">) => void;
+};
+export {};

package/dist/MathCanvas/features/text/hooks/useTextBlockEditingActions.d.ts

@@ -0,0 +1,57 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import { type InlineMathAtom } from "../../../../inlineMathModel";
+import type { RenderMode, TextBlock } from "../../../types";
+type UseTextBlockEditingActionsOptions = {
+    blocks: TextBlock[];
+    clearGraphEditing: () => void;
+    clearGraphSelection: () => void;
+    clearMatrixEditing: () => void;
+    clearMatrixSelection: () => void;
+    createId: () => string;
+    editingBlockId: string | null;
+    editingHeight: number;
+    editingWidth: number;
+    getResolvedEditingValue: () => string;
+    lastEditingSelectionRangeRef: MutableRefObject<{
+        blockId: string;
+        start: number;
+        end: number;
+    } | null>;
+    pushHistoryState: () => void;
+    renderMode: RenderMode;
+    resetInlineMathState: () => void;
+    selectedBlockId: string | null;
+    setBlocks: Dispatch<SetStateAction<TextBlock[]>>;
+    setEditingBlockId: Dispatch<SetStateAction<string | null>>;
+    setEditingHeight: Dispatch<SetStateAction<number>>;
+    setEditingInlineMathAtoms: Dispatch<SetStateAction<InlineMathAtom[]>>;
+    setEditingSelection: Dispatch<SetStateAction<number>>;
+    setEditingSelectionEnd: Dispatch<SetStateAction<number>>;
+    setEditingValue: Dispatch<SetStateAction<string>>;
+    setEditingWidth: Dispatch<SetStateAction<number>>;
+    setInlineMathEditorRect: Dispatch<SetStateAction<{
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | null>>;
+    setMathOverlayCaret: Dispatch<SetStateAction<{
+        left: number;
+        top: number;
+        height: number;
+    } | null>>;
+    setRenderMode: Dispatch<SetStateAction<RenderMode>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    size: {
+        width: number;
+        height: number;
+    };
+};
+export declare function useTextBlockEditingActions({ blocks, clearGraphEditing, clearGraphSelection, clearMatrixEditing, clearMatrixSelection, createId, editingBlockId, editingHeight, editingWidth, getResolvedEditingValue, lastEditingSelectionRangeRef, pushHistoryState, renderMode, resetInlineMathState, selectedBlockId, setBlocks, setEditingBlockId, setEditingHeight, setEditingInlineMathAtoms, setEditingSelection, setEditingSelectionEnd, setEditingValue, setEditingWidth, setInlineMathEditorRect, setMathOverlayCaret, setRenderMode, setSelectedBlockId, size, }: UseTextBlockEditingActionsOptions): {
+    clearEditing: () => void;
+    commitEditing: () => void;
+    createTextBlock: (x: number, y: number) => void;
+    rememberEditingSelection: (target: HTMLTextAreaElement) => void;
+    startEditing: (id: string, selectionOverride?: number | null) => void;
+};
+export {};