mathlean-canvas 0.3.1 → 0.3.3

package/dist/MathCanvas/core/hooks/useCanvasKeyboardShortcuts.d.ts

@@ -0,0 +1,76 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction } from "react";
+import { PEN_SIZE_OPTIONS } from "../../constants";
+import type { GeometryLabelTarget, GraphDirection, GridSelection, MatrixObject, TableObject, Tool } from "../../types";
+type PenWidth = (typeof PEN_SIZE_OPTIONS)[number];
+type UseCanvasKeyboardShortcutsOptions = {
+    cancelPendingGraphDirectionalCreate: () => void;
+    clearGeometryDraft: () => void;
+    clearGeometrySelection: () => void;
+    clearGridSelectionCells: () => void;
+    copySelectedGraphNodes: () => void;
+    createConnectedGraphNodeInDirection: (direction: "right") => void;
+    cycleSelectedGeometryObject: (direction?: 1 | -1) => void;
+    deleteGridSelectionStructure: () => void;
+    deleteSelectedGeometry: () => void;
+    deleteSelectedGraphEdge: () => void;
+    deleteSelectedGraphNode: () => void;
+    deleteSelectedMatrix: () => void;
+    deleteSelectedTable: () => void;
+    editingGraphNodeId: string | null;
+    editingMatrixId: string | null;
+    editingTableId: string | null;
+    fillIdentityMatrix: (id: string) => void;
+    getGridSelectionClipboardText: () => string;
+    getMatrixById: (id: string | null) => MatrixObject | null;
+    getTableById: (id: string | null) => TableObject | null;
+    graphCreationArrowKeysRef: MutableRefObject<Set<string>>;
+    graphCreationChordActiveRef: MutableRefObject<boolean>;
+    gridSelection: GridSelection | null;
+    handleRedo: () => void;
+    handleUndo: () => void;
+    insertGridSelectionStructure: () => void;
+    moveGridSelectionStructure: (direction: "up" | "down" | "left" | "right") => void;
+    nudgeSelectedGeometry: (dx: number, dy: number) => void;
+    nudgeSelectedGraphNode: (dx: number, dy: number) => void;
+    pasteGraphClipboard: () => void;
+    pasteGridSelectionClipboardText: (text: string) => void;
+    penColorOptions: readonly string[];
+    pushHistoryState: () => void;
+    resizeMatrix: (id: string, rows: number, cols: number) => void;
+    resizeTable: (id: string, rows: number, cols: number) => void;
+    rotateMatrixClockwise: (id: string) => void;
+    rotateMatrixCounterclockwise: (id: string) => void;
+    scheduleGraphDirectionalCreate: (direction: GraphDirection) => void;
+    selectedAngleId: string | null;
+    selectedCircleId: string | null;
+    selectedGeometryLabel: GeometryLabelTarget | null;
+    selectedGraphEdgeId: string | null;
+    selectedGraphNodeId: string | null;
+    selectedGraphNodeIds: string[];
+    selectedMatrixId: string | null;
+    selectedPointId: string | null;
+    selectedPolygonId: string | null;
+    selectedSegmentId: string | null;
+    selectedTableId: string | null;
+    setActiveConstructionStartPointId: (id: string | null) => void;
+    setArmedSourceNodeId: (id: string | null) => void;
+    setCurrentConstructionPathPointIds: (ids: string[]) => void;
+    setPenColor: Dispatch<SetStateAction<string>>;
+    setPenWidth: Dispatch<SetStateAction<PenWidth>>;
+    showPenSizePreviewBriefly: () => void;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    startGraphEditing: (id: string) => void;
+    startMatrixEditing: (id: string) => void;
+    startTableEditing: (id: string) => void;
+    tool: Tool;
+    transformGridSelectionToAntiDiagonal: () => void;
+    transformGridSelectionToDiagonal: () => void;
+    transformGridSelectionToLowerTriangular: () => void;
+    transformGridSelectionToUpperTriangular: () => void;
+    transformSelectedMatrixRegion: (transform: "rotateClockwise" | "rotateCounterclockwise" | "transpose") => void;
+    transposeMatrix: (id: string) => void;
+    traverseConnectedGeoPoint: (direction: "left" | "right" | "up" | "down") => void;
+    traverseGraphNeighbor: (direction: "left" | "right" | "up" | "down", extendSelection?: boolean) => void;
+};
+export declare function useCanvasKeyboardShortcuts({ cancelPendingGraphDirectionalCreate, clearGeometryDraft, clearGeometrySelection, clearGridSelectionCells, copySelectedGraphNodes, createConnectedGraphNodeInDirection, cycleSelectedGeometryObject, deleteGridSelectionStructure, deleteSelectedGeometry, deleteSelectedGraphEdge, deleteSelectedGraphNode, deleteSelectedMatrix, deleteSelectedTable, editingGraphNodeId, editingMatrixId, editingTableId, fillIdentityMatrix, getGridSelectionClipboardText, getMatrixById, getTableById, graphCreationArrowKeysRef, graphCreationChordActiveRef, gridSelection, handleRedo, handleUndo, insertGridSelectionStructure, moveGridSelectionStructure, nudgeSelectedGeometry, nudgeSelectedGraphNode, pasteGraphClipboard, pasteGridSelectionClipboardText, penColorOptions, pushHistoryState, resizeMatrix, resizeTable, rotateMatrixClockwise, rotateMatrixCounterclockwise, scheduleGraphDirectionalCreate, selectedAngleId, selectedCircleId, selectedGeometryLabel, selectedGraphEdgeId, selectedGraphNodeId, selectedGraphNodeIds, selectedMatrixId, selectedPointId, selectedPolygonId, selectedSegmentId, selectedTableId, setActiveConstructionStartPointId, setArmedSourceNodeId, setCurrentConstructionPathPointIds, setPenColor, setPenWidth, showPenSizePreviewBriefly, startGeometryLabelEditing, startGraphEditing, startMatrixEditing, startTableEditing, tool, transformGridSelectionToAntiDiagonal, transformGridSelectionToDiagonal, transformGridSelectionToLowerTriangular, transformGridSelectionToUpperTriangular, transformSelectedMatrixRegion, transposeMatrix, traverseConnectedGeoPoint, traverseGraphNeighbor, }: UseCanvasKeyboardShortcutsOptions): void;
+export {};

package/dist/MathCanvas/core/hooks/useCanvasSnapshot.d.ts

@@ -0,0 +1,23 @@
+import type { CanvasState, CoordinatePlaneMode, GeoAngle, GeoCircle, GeoHelperSegment, GeoPoint, GeoPolygon, GeoRightAngleMarker, GeoSegment, GraphEdge, GraphNode, MatrixObject, RenderMode, Stroke, TableObject, TextBlock } from "../../types";
+type UseCanvasSnapshotOptions = {
+    blocks: TextBlock[];
+    coordinatePlaneMode: CoordinatePlaneMode;
+    geoAngles: GeoAngle[];
+    geoCircles: GeoCircle[];
+    geoHelperSegments: GeoHelperSegment[];
+    geoPoints: GeoPoint[];
+    geoPolygons: GeoPolygon[];
+    geoRightAngleMarkers: GeoRightAngleMarker[];
+    geoSegments: GeoSegment[];
+    graphEdges: GraphEdge[];
+    graphNodes: GraphNode[];
+    matrices: MatrixObject[];
+    onStateChange?: (state: CanvasState) => void;
+    renderMode: RenderMode;
+    strokes: Stroke[];
+    tables: TableObject[];
+};
+export declare function useCanvasSnapshot({ blocks, coordinatePlaneMode, geoAngles, geoCircles, geoHelperSegments, geoPoints, geoPolygons, geoRightAngleMarkers, geoSegments, graphEdges, graphNodes, matrices, onStateChange, renderMode, strokes, tables, }: UseCanvasSnapshotOptions): {
+    getCanvasState: () => CanvasState;
+};
+export {};

package/dist/MathCanvas/core/hooks/useCanvasStageInteractions.d.ts

@@ -0,0 +1,103 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import type Konva from "konva";
+import type { GeoPoint, GeoSegment, GeometryLabelTarget, GeometryMode, GraphNode, MatrixObject, RenderMode, StageActivationEvent, StagePointerEvent, TableObject, TextBlock, Tool } from "../../types";
+type ScenePoint = {
+    x: number;
+    y: number;
+};
+type SnapPoint = ScenePoint & {
+    kind: "point" | "grid" | "midpoint";
+};
+type UseCanvasStageInteractionsOptions = {
+    beginGraphSelectionDrag: (point: ScenePoint) => void;
+    clearEraserPreview: () => void;
+    clearGeometryDraft: () => void;
+    clearGeometrySelection: () => void;
+    clearGraphSelection: () => void;
+    clearMatrixSelection: () => void;
+    clearTableSelection: () => void;
+    commitEditing: () => void;
+    commitGeometryLabelEditing: () => void;
+    commitGraphEditing: () => void;
+    commitMatrixEditing: () => void;
+    commitTableEditing: () => void;
+    createGraphNode: (x: number, y: number) => void;
+    createId: () => string;
+    createMatrix: (x: number, y: number) => void;
+    createTable: (x: number, y: number) => void;
+    createTextBlock: (x: number, y: number) => void;
+    editingBlockId: string | null;
+    editingGeometryLabel: GeometryLabelTarget | null;
+    editingGraphNodeId: string | null;
+    editingMatrixId: string | null;
+    editingTableId: string | null;
+    eraseAtPointState: (x: number, y: number, radius: number, createId: () => string) => void;
+    extendStroke: (x: number, y: number) => void;
+    findGeoPointNear: (x: number, y: number) => GeoPoint | null;
+    findGeoSegmentNear: (x: number, y: number) => GeoSegment | null;
+    findGeometryLabelTargetNear: (x: number, y: number) => GeometryLabelTarget | null;
+    findGraphNodeAtPoint: (x: number, y: number) => GraphNode | null;
+    findMatrixAtPoint: (x: number, y: number) => MatrixObject | null;
+    findTableAtPoint: (x: number, y: number) => TableObject | null;
+    findTextBlockBlockingCreation: (x: number, y: number) => TextBlock | null;
+    finishGraphSelectionDrag: () => boolean;
+    getDefaultMatrixPosition: (x: number, y: number) => ScenePoint;
+    getDefaultTablePosition: (x: number, y: number) => ScenePoint;
+    getGeoSnap: (x: number, y: number) => SnapPoint;
+    getScenePoint: (stage: Konva.Stage | null) => ScenePoint | null;
+    geometryMode: GeometryMode;
+    handleGeometryCanvasPoint: (x: number, y: number) => void;
+    handleGeometryPointChoice: (pointId: string) => void;
+    isDrawing: MutableRefObject<boolean>;
+    isErasing: MutableRefObject<boolean>;
+    isPanning: MutableRefObject<boolean>;
+    lastPanPoint: MutableRefObject<ScenePoint | null>;
+    penColor: string;
+    penWidth: number;
+    pushHistoryState: () => void;
+    selectedGraphNodeId: string | null;
+    selectedMatrixId: string | null;
+    selectedPointId: string | null;
+    selectedTableId: string | null;
+    selectOnlyGeoSegment: (id: string) => void;
+    selectOnlyGraphNode: (id: string) => void;
+    setArmedSourceNodeId: (id: string | null) => void;
+    setGeometryDraftPointIds: (ids: string[]) => void;
+    setGeometryPointer: (point: ScenePoint) => void;
+    setMatrixLatexPopover: (popover: {
+        matrixId: string;
+        left: number;
+        top: number;
+    } | null) => void;
+    setRenderMode: Dispatch<SetStateAction<RenderMode>>;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    setSelectedGraphEdgeId: Dispatch<SetStateAction<string | null>>;
+    setSelectedMatrixId: Dispatch<SetStateAction<string | null>>;
+    setSelectedTableId: Dispatch<SetStateAction<string | null>>;
+    setSnapPreview: (preview: SnapPoint | null) => void;
+    setTextBlockMenu: (menu: {
+        blockId: string;
+        panel: "color" | "format" | null;
+    } | null) => void;
+    setViewport: Dispatch<SetStateAction<ScenePoint>>;
+    skipNextMatrixCreationRef: MutableRefObject<boolean>;
+    skipNextTextCreationRef: MutableRefObject<boolean>;
+    skipNextTextCreationResetRef: MutableRefObject<number | null>;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    startGraphEditing: (id: string) => void;
+    startMatrixEditing: (id: string) => void;
+    startStrokeState: (x: number, y: number, tool: Tool, strokeWidth: number, color: string, createId: () => string) => void;
+    startTableEditing: (id: string) => void;
+    suppressNextGraphActivationRef: MutableRefObject<boolean>;
+    toggleEqualSideMarker: (segmentId: string) => void;
+    tool: Tool;
+    updateEraserPreview: (x: number, y: number) => number;
+    updateGraphSelectionDrag: (point: ScenePoint) => boolean;
+};
+export declare function useCanvasStageInteractions({ beginGraphSelectionDrag, clearEraserPreview, clearGeometryDraft, clearGeometrySelection, clearGraphSelection, clearMatrixSelection, clearTableSelection, commitEditing, commitGeometryLabelEditing, commitGraphEditing, commitMatrixEditing, commitTableEditing, createGraphNode, createId, createMatrix, createTable, createTextBlock, editingBlockId, editingGeometryLabel, editingGraphNodeId, editingMatrixId, editingTableId, eraseAtPointState, extendStroke, findGeoPointNear, findGeoSegmentNear, findGeometryLabelTargetNear, findGraphNodeAtPoint, findMatrixAtPoint, findTableAtPoint, findTextBlockBlockingCreation, finishGraphSelectionDrag, getDefaultMatrixPosition, getDefaultTablePosition, getGeoSnap, getScenePoint, geometryMode, handleGeometryCanvasPoint, handleGeometryPointChoice, isDrawing, isErasing, isPanning, lastPanPoint, penColor, penWidth, pushHistoryState, selectedGraphNodeId, selectedMatrixId, selectedPointId, selectedTableId, selectOnlyGeoSegment, selectOnlyGraphNode, setArmedSourceNodeId, setGeometryDraftPointIds, setGeometryPointer, setMatrixLatexPopover, setRenderMode, setSelectedBlockId, setSelectedGraphEdgeId, setSelectedMatrixId, setSelectedTableId, setSnapPreview, setTextBlockMenu, setViewport, skipNextMatrixCreationRef, skipNextTextCreationRef, skipNextTextCreationResetRef, startGeometryLabelEditing, startGraphEditing, startMatrixEditing, startStrokeState, startTableEditing, suppressNextGraphActivationRef, toggleEqualSideMarker, tool, updateEraserPreview, updateGraphSelectionDrag, }: UseCanvasStageInteractionsOptions): {
+    handleCanvasActivation: (e: StageActivationEvent) => void;
+    handlePointerDown: (e: StagePointerEvent) => void;
+    handlePointerMove: (e: StagePointerEvent) => void;
+    handlePointerUp: () => void;
+};
+export {};

package/dist/MathCanvas/core/hooks/useCanvasTransformers.d.ts

@@ -0,0 +1,28 @@
+import { type MutableRefObject } from "react";
+import type Konva from "konva";
+import type { GraphNode, MatrixObject, TableObject, TextBlock, Tool } from "../../types";
+type UseCanvasTransformersOptions = {
+    blockHeights: Record<string, number>;
+    blockNodeRefs: MutableRefObject<Record<string, Konva.Rect | null>>;
+    blockWidths: Record<string, number>;
+    blocks: TextBlock[];
+    editingBlockId: string | null;
+    graphNodeRefs: MutableRefObject<Record<string, Konva.Group | null>>;
+    graphNodes: GraphNode[];
+    graphTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    matrices: MatrixObject[];
+    matrixNodeRefs: MutableRefObject<Record<string, Konva.Rect | null>>;
+    matrixTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    selectedBlockId: string | null;
+    selectedGraphNodeId: string | null;
+    selectedGraphNodeIds: string[];
+    selectedMatrixId: string | null;
+    selectedTableId: string | null;
+    tables: TableObject[];
+    tableNodeRefs: MutableRefObject<Record<string, Konva.Rect | null>>;
+    tableTransformerRef: MutableRefObject<Konva.Transformer | null>;
+    tool: Tool;
+    transformerRef: MutableRefObject<Konva.Transformer | null>;
+};
+export declare function useCanvasTransformers({ blockHeights, blockNodeRefs, blockWidths, blocks, editingBlockId, graphNodeRefs, graphNodes, graphTransformerRef, matrices, matrixNodeRefs, matrixTransformerRef, selectedBlockId, selectedGraphNodeId, selectedGraphNodeIds, selectedMatrixId, selectedTableId, tables, tableNodeRefs, tableTransformerRef, tool, transformerRef, }: UseCanvasTransformersOptions): void;
+export {};

package/dist/MathCanvas/core/hooks/useCanvasViewport.d.ts

@@ -0,0 +1,25 @@
+import type Konva from "konva";
+export declare function useCanvasViewport(): {
+    containerRef: import("react").RefObject<HTMLDivElement | null>;
+    getScenePoint: (stage: Konva.Stage | null) => {
+        x: number;
+        y: number;
+    } | null;
+    isPanning: import("react").RefObject<boolean>;
+    lastPanPoint: import("react").RefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    setViewport: import("react").Dispatch<import("react").SetStateAction<{
+        x: number;
+        y: number;
+    }>>;
+    size: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        x: number;
+        y: number;
+    };
+};

package/dist/MathCanvas/core/index.d.ts

@@ -0,0 +1,9 @@
+export { useCanvasEditorFocus } from "./hooks/useCanvasEditorFocus";
+export { useCanvasGlobalActions } from "./hooks/useCanvasGlobalActions";
+export { useCanvasGlobalDragEffects } from "./hooks/useCanvasGlobalDragEffects";
+export { useCanvasHistory } from "./hooks/useCanvasHistory";
+export { useCanvasKeyboardShortcuts } from "./hooks/useCanvasKeyboardShortcuts";
+export { useCanvasSnapshot } from "./hooks/useCanvasSnapshot";
+export { useCanvasStageInteractions } from "./hooks/useCanvasStageInteractions";
+export { useCanvasTransformers } from "./hooks/useCanvasTransformers";
+export { useCanvasViewport } from "./hooks/useCanvasViewport";

package/dist/MathCanvas/features/geometry/components/CoordinatePlaneLayer.d.ts

@@ -0,0 +1,15 @@
+import type { CoordinatePlaneMode, MathCanvasTheme } from "../../../types";
+type CoordinatePlaneLayerProps = {
+    coordinatePlaneMode: CoordinatePlaneMode;
+    colors: MathCanvasTheme;
+    size: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        x: number;
+        y: number;
+    };
+};
+export default function CoordinatePlaneLayer({ coordinatePlaneMode, colors, size, viewport, }: CoordinatePlaneLayerProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/MathCanvas/features/geometry/components/GeometryLayer.d.ts

@@ -0,0 +1,65 @@
+import type { Dispatch, SetStateAction } from "react";
+import type { GeoAngle, GeoCircle, GeoHelperSegment, GeoPoint, GeoPolygon, GeoRightAngleMarker, GeoSegment, GeometryLabelTarget, GeometryMode, MathCanvasTheme, Tool } from "../../../types";
+type GeometryPreview = {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};
+type SnapPreview = {
+    x: number;
+    y: number;
+    kind: "point" | "grid" | "midpoint";
+};
+type GeometryLayerProps = {
+    geoPoints: GeoPoint[];
+    geoPointMap: Map<string, GeoPoint>;
+    geoSegments: GeoSegment[];
+    geoPolygons: GeoPolygon[];
+    geoAngles: GeoAngle[];
+    geoCircles: GeoCircle[];
+    geoHelperSegments: GeoHelperSegment[];
+    geoRightAngleMarkers: GeoRightAngleMarker[];
+    geometryPreview: GeometryPreview | null;
+    snapPreview: SnapPreview | null;
+    selectedPolygonId: string | null;
+    selectedCircleId: string | null;
+    selectedSegmentId: string | null;
+    selectedAngleId: string | null;
+    selectedPointId: string | null;
+    hoveredPointId: string | null;
+    currentConstructionPathPointIds: string[];
+    angleDraftPointIds: string[];
+    circleDraftCenterId: string | null;
+    tool: Tool;
+    geometryMode: GeometryMode;
+    colors: MathCanvasTheme;
+    darkMode: boolean;
+    clearGeometryDraft: () => void;
+    clearGeometrySelection: () => void;
+    getEqualSideMarkerPoints: (segment: GeoSegment) => number[] | null;
+    getHelperSegmentPoints: (helper: GeoHelperSegment) => number[] | null;
+    getRightAngleMarkerPoints: (marker: GeoRightAngleMarker) => number[] | null;
+    getSegmentPoints: (segment: GeoSegment) => {
+        a: GeoPoint;
+        b: GeoPoint;
+    } | null;
+    handleGeometryPointChoice: (pointId: string) => void;
+    pushHistoryState: () => void;
+    selectOnlyGeoPoint: (id: string) => void;
+    selectOnlyGeoSegment: (id: string) => void;
+    setGeometryDraftPointIds: Dispatch<SetStateAction<string[]>>;
+    setHoveredPointId: Dispatch<SetStateAction<string | null>>;
+    setSelectedAngleId: Dispatch<SetStateAction<string | null>>;
+    setSelectedCircleId: Dispatch<SetStateAction<string | null>>;
+    setSelectedPolygonId: Dispatch<SetStateAction<string | null>>;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    toggleEqualSideMarker: (segmentId: string) => void;
+    updateGeoPoint: (id: string, updater: (point: GeoPoint) => GeoPoint) => void;
+};
+export default function GeometryLayer({ geoPoints, geoPointMap, geoSegments, geoPolygons, geoAngles, geoCircles, geoHelperSegments, geoRightAngleMarkers, geometryPreview, snapPreview, selectedPolygonId, selectedCircleId, selectedSegmentId, selectedAngleId, selectedPointId, hoveredPointId, currentConstructionPathPointIds, angleDraftPointIds, circleDraftCenterId, tool, geometryMode, colors, darkMode, clearGeometryDraft, clearGeometrySelection, getEqualSideMarkerPoints, getHelperSegmentPoints, getRightAngleMarkerPoints, getSegmentPoints, handleGeometryPointChoice, pushHistoryState, selectOnlyGeoPoint, selectOnlyGeoSegment, setGeometryDraftPointIds, setHoveredPointId, setSelectedAngleId, setSelectedCircleId, setSelectedPolygonId, startGeometryLabelEditing, toggleEqualSideMarker, updateGeoPoint, }: GeometryLayerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/geometry/components/GeometryOverlays.d.ts

@@ -0,0 +1,57 @@
+import type { MutableRefObject } from "react";
+import type { GeometryLabelOffset, GeometryLabelTarget, GeometryMode, MathCanvasTheme, Tool } from "../../../types";
+type GeometryLabelOverlay = {
+    key: string;
+    label: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    target: GeometryLabelTarget;
+};
+type GeometryLabelDragRef = MutableRefObject<{
+    target: GeometryLabelTarget;
+    startX: number;
+    startY: number;
+    offset: GeometryLabelOffset;
+    didPushHistory: boolean;
+} | null>;
+type GeometryOverlaysProps = {
+    colors: MathCanvasTheme;
+    tool: Tool;
+    geometryMode: GeometryMode;
+    viewport: {
+        x: number;
+        y: number;
+    };
+    geometryLabelOverlays: GeometryLabelOverlay[];
+    editingGeometryLabel: GeometryLabelTarget | null;
+    selectedGeometryLabel: GeometryLabelTarget | null;
+    editingGeometryLabelPosition: {
+        x: number;
+        y: number;
+    } | null;
+    geometryLabelEditorWidth: number;
+    geometryLabelInputRef: MutableRefObject<HTMLInputElement | null>;
+    geometryLabelValue: string;
+    setGeometryLabelValue: (value: string) => void;
+    commitGeometryLabelEditing: () => void;
+    clearGeometryLabelEditing: () => void;
+    isSameGeometryLabelTarget: (a: GeometryLabelTarget | null, b: GeometryLabelTarget | null) => boolean;
+    selectGeometryLabel: (target: GeometryLabelTarget) => void;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    getGeometryLabelOffset: (target: GeometryLabelTarget) => GeometryLabelOffset;
+    geometryLabelDragRef: GeometryLabelDragRef;
+    fixedLengthStartPoint: {
+        x: number;
+        y: number;
+    } | null;
+    fixedLengthInputWidth: number;
+    fixedLengthInputRef: MutableRefObject<HTMLInputElement | null>;
+    fixedLengthValue: string;
+    setFixedLengthValue: (value: string) => void;
+    commitFixedLengthSegment: () => void;
+    clearGeometryDraft: () => void;
+};
+export default function GeometryOverlays({ colors, tool, geometryMode, viewport, geometryLabelOverlays, editingGeometryLabel, selectedGeometryLabel, editingGeometryLabelPosition, geometryLabelEditorWidth, geometryLabelInputRef, geometryLabelValue, setGeometryLabelValue, commitGeometryLabelEditing, clearGeometryLabelEditing, isSameGeometryLabelTarget, selectGeometryLabel, startGeometryLabelEditing, getGeometryLabelOffset, geometryLabelDragRef, fixedLengthStartPoint, fixedLengthInputWidth, fixedLengthInputRef, fixedLengthValue, setFixedLengthValue, commitFixedLengthSegment, clearGeometryDraft, }: GeometryOverlaysProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/MathCanvas/features/geometry/hooks/useGeometryCanvasActions.d.ts

@@ -0,0 +1,29 @@
+import type { Dispatch, SetStateAction } from "react";
+import type { GeometryDirection, GeometryLabelTarget } from "../../../types";
+type UseGeometryCanvasActionsOptions = {
+    clearGraphSelection: () => void;
+    clearMatrixSelection: () => void;
+    clearTableSelection: () => void;
+    commitFixedLengthSegmentState: (createId: () => string) => void;
+    createId: () => string;
+    cycleSelectedGeometryObjectState: (direction?: 1 | -1) => boolean;
+    handleGeometryCanvasPointState: (x: number, y: number, createId: () => string) => boolean;
+    handleGeometryPointChoiceState: (pointId: string, createId: () => string, shouldPushHistory?: boolean) => boolean;
+    selectGeometryLabelState: (target: GeometryLabelTarget) => void;
+    selectGeometryObjectState: (kind: "point" | "segment", id: string) => void;
+    setSelectedBlockId: Dispatch<SetStateAction<string | null>>;
+    startGeometryLabelEditingState: (target: GeometryLabelTarget) => void;
+    traverseConnectedGeoPointState: (direction: GeometryDirection) => boolean;
+};
+export declare function useGeometryCanvasActions({ clearGraphSelection, clearMatrixSelection, clearTableSelection, commitFixedLengthSegmentState, createId, cycleSelectedGeometryObjectState, handleGeometryCanvasPointState, handleGeometryPointChoiceState, selectGeometryLabelState, selectGeometryObjectState, setSelectedBlockId, startGeometryLabelEditingState, traverseConnectedGeoPointState, }: UseGeometryCanvasActionsOptions): {
+    commitFixedLengthSegment: () => void;
+    cycleSelectedGeometryObject: (direction?: 1 | -1) => void;
+    handleGeometryCanvasPoint: (x: number, y: number) => void;
+    handleGeometryPointChoice: (pointId: string, shouldPushHistory?: boolean) => void;
+    selectGeometryLabel: (target: GeometryLabelTarget) => void;
+    selectOnlyGeoPoint: (id: string) => void;
+    selectOnlyGeoSegment: (id: string) => void;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    traverseConnectedGeoPoint: (direction: GeometryDirection) => void;
+};
+export {};

package/dist/MathCanvas/features/geometry/hooks/useGeometryRenderData.d.ts

@@ -0,0 +1,60 @@
+import type { GeoAngle, GeoCircle, GeoPoint, GeoSegment, GeometryLabelTarget, Tool } from "../../../types";
+type GeometryPoint = {
+    x: number;
+    y: number;
+};
+type UseGeometryRenderDataOptions = {
+    currentConstructionPathPointIds: string[];
+    editingGeometryLabel: GeometryLabelTarget | null;
+    fixedLengthStartPointId: string | null;
+    fixedLengthValue: string;
+    geoAngles: GeoAngle[];
+    geoCircles: GeoCircle[];
+    geoPoints: GeoPoint[];
+    geoSegments: GeoSegment[];
+    geometryLabelValue: string;
+    geometryMode: string;
+    geometryPointer: GeometryPoint | null;
+    getGeoPointById: (id: string | null) => GeoPoint | null;
+    getGeometryLabelPosition: (target: GeometryLabelTarget) => GeometryPoint | null;
+    getGeometryLabelValue: (target: GeometryLabelTarget) => string;
+    selectedPointId: string | null;
+    tool: Tool;
+};
+export declare function useGeometryRenderData({ currentConstructionPathPointIds, editingGeometryLabel, fixedLengthStartPointId, fixedLengthValue, geoAngles, geoCircles, geoPoints, geoSegments, geometryLabelValue, geometryMode, geometryPointer, getGeoPointById, getGeometryLabelPosition, getGeometryLabelValue, selectedPointId, tool, }: UseGeometryRenderDataOptions): {
+    editingGeometryLabelPosition: GeometryPoint | null;
+    fixedLengthInputWidth: number;
+    fixedLengthStartPoint: GeoPoint | null;
+    geoPointMap: Map<string, GeoPoint>;
+    geometryLabelEditorWidth: number;
+    geometryLabelOverlays: ({
+        key: string;
+        label: string;
+        position: GeometryPoint;
+        target: {
+            kind: "segment";
+            id: string;
+        };
+    } | {
+        key: string;
+        label: string;
+        position: GeometryPoint;
+        target: {
+            kind: "angle";
+            id: string;
+        };
+    } | {
+        key: string;
+        label: string;
+        position: GeometryPoint;
+        target: {
+            kind: "circle";
+            id: string;
+        };
+    })[];
+    geometryPreview: {
+        start: GeoPoint;
+        end: GeometryPoint;
+    } | null;
+};
+export {};

package/dist/MathCanvas/features/geometry/hooks/useGeometryState.d.ts

@@ -0,0 +1,147 @@
+import { type MutableRefObject } from "react";
+import type { CanvasState, CoordinatePlaneMode, GeoAngle, GeoCircle, GeoHelperSegment, GeoPoint, GeoPolygon, GeoRightAngleMarker, GeoSegment, GeometryDirection, GeometryObjectKind, GeometryLabelOffset, GeometryLabelTarget, GeometryMode } from "../../../types";
+type UseGeometryStateOptions = {
+    initialState?: Pick<CanvasState, "coordinatePlaneMode" | "geoAngles" | "geoCircles" | "geoHelperSegments" | "geoPoints" | "geoPolygons" | "geoRightAngleMarkers" | "geoSegments">;
+    pushHistoryStateRef: MutableRefObject<() => void>;
+};
+export declare function useGeometryState({ initialState, pushHistoryStateRef }: UseGeometryStateOptions): {
+    activeConstructionStartPointId: string | null;
+    angleDraftPointIds: string[];
+    circleDraftCenterId: string | null;
+    clearGeometryDraft: () => void;
+    clearGeometryLabelEditing: () => void;
+    clearGeometryLabelValue: (target: GeometryLabelTarget) => void;
+    clearGeometrySelection: () => void;
+    commitGeometryLabelEditing: () => void;
+    commitFixedLengthSegment: (createId: () => string) => boolean;
+    coordinatePlaneMode: CoordinatePlaneMode;
+    closeGeoPolygonFromPath: (pathPointIds: string[], createId: () => string) => GeoPolygon | null;
+    createGeoPointAt: (x: number, y: number, createId: () => string) => GeoPoint;
+    createGeoSegment: (a: string, b: string, createId: () => string) => GeoSegment | null;
+    createHelperSegment: (kind: GeoHelperSegment["kind"], baseA: string, baseB: string, through: string, createId: () => string) => boolean;
+    createMidpointFromPoints: (a: string, b: string, createId: () => string) => boolean;
+    createRightAngleMarker: (a: string, b: string, c: string, createId: () => string) => boolean;
+    currentConstructionPathPointIds: string[];
+    cycleSelectedGeometryObject: (direction?: 1 | -1) => boolean;
+    deleteSelectedGeometry: () => boolean;
+    editingGeometryLabel: GeometryLabelTarget | null;
+    fixedLengthStartPointId: string | null;
+    fixedLengthValue: string;
+    findGeoCircleNear: (x: number, y: number) => GeoCircle | null;
+    findGeoPointNear: (x: number, y: number, radius?: number) => GeoPoint | null;
+    findGeoSegmentNear: (x: number, y: number) => GeoSegment | null;
+    findGeometryLabelTargetNear: (x: number, y: number) => GeometryLabelTarget | null;
+    geoAngles: GeoAngle[];
+    geoCircles: GeoCircle[];
+    geoHelperSegments: GeoHelperSegment[];
+    geoPoints: GeoPoint[];
+    geoPolygons: GeoPolygon[];
+    geoRightAngleMarkers: GeoRightAngleMarker[];
+    geoSegments: GeoSegment[];
+    geometryDraftPointIds: string[];
+    geometryLabelValue: string;
+    geometryMode: GeometryMode;
+    geometryPointer: {
+        x: number;
+        y: number;
+    } | null;
+    getCircleGeometry: (circle: GeoCircle) => {
+        center: GeoPoint;
+        radius: number;
+    } | null;
+    getEqualSideMarkerPoints: (segment: GeoSegment) => number[] | null;
+    getGeoPointById: (id: string | null) => GeoPoint | null;
+    getGeometryLabelOffset: (target: GeometryLabelTarget) => GeometryLabelOffset;
+    getGeometryLabelPosition: (target: GeometryLabelTarget) => {
+        x: number;
+        y: number;
+    } | null;
+    getGeometryLabelValue: (target: GeometryLabelTarget) => string;
+    getGeoSnap: (x: number, y: number) => {
+        x: number;
+        y: number;
+        pointId: string;
+        kind: "point";
+    } | {
+        kind: "midpoint";
+        x: number;
+        y: number;
+        pointId?: undefined;
+    } | {
+        kind: "grid";
+        x: number;
+        y: number;
+        pointId?: undefined;
+    };
+    getHelperSegmentPoints: (helper: GeoHelperSegment) => number[] | null;
+    getRightAngleMarkerPoints: (marker: GeoRightAngleMarker) => number[] | null;
+    getSegmentPoints: (segment: GeoSegment) => {
+        a: GeoPoint;
+        b: GeoPoint;
+    } | null;
+    getSelectedGeometryPointIds: () => string[];
+    handleGeometryCanvasPoint: (x: number, y: number, createId: () => string) => boolean;
+    handleGeometryPointChoice: (pointId: string, createId: () => string, shouldPushHistory?: boolean) => boolean;
+    hoveredPointId: string | null;
+    ensureGeoPointAt: (x: number, y: number, createId: () => string) => GeoPoint;
+    isSameGeometryLabelTarget: (a: GeometryLabelTarget | null, b: GeometryLabelTarget | null) => boolean;
+    nudgeSelectedGeometryLabel: (dx: number, dy: number) => void;
+    nudgeSelectedGeometry: (dx: number, dy: number) => boolean;
+    regularPolygonCenterId: string | null;
+    regularPolygonSides: number;
+    selectedAngleId: string | null;
+    selectedCircleId: string | null;
+    selectedGeometryLabel: GeometryLabelTarget | null;
+    selectedPointId: string | null;
+    selectedPolygonId: string | null;
+    selectedSegmentId: string | null;
+    selectGeometryLabel: (target: GeometryLabelTarget) => void;
+    selectGeometryObject: (kind: GeometryObjectKind, id: string) => void;
+    setActiveConstructionStartPointId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setAngleDraftPointIds: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    setCircleDraftCenterId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setCoordinatePlaneMode: import("react").Dispatch<import("react").SetStateAction<CoordinatePlaneMode>>;
+    setCurrentConstructionPathPointIds: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    setEditingGeometryLabel: import("react").Dispatch<import("react").SetStateAction<GeometryLabelTarget | null>>;
+    setFixedLengthStartPointId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setFixedLengthValue: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setGeoAngles: import("react").Dispatch<import("react").SetStateAction<GeoAngle[]>>;
+    setGeoCircles: import("react").Dispatch<import("react").SetStateAction<GeoCircle[]>>;
+    setGeoHelperSegments: import("react").Dispatch<import("react").SetStateAction<GeoHelperSegment[]>>;
+    setGeoPoints: import("react").Dispatch<import("react").SetStateAction<GeoPoint[]>>;
+    setGeoPolygons: import("react").Dispatch<import("react").SetStateAction<GeoPolygon[]>>;
+    setGeoRightAngleMarkers: import("react").Dispatch<import("react").SetStateAction<GeoRightAngleMarker[]>>;
+    setGeoSegments: import("react").Dispatch<import("react").SetStateAction<GeoSegment[]>>;
+    setGeometryDraftPointIds: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    setGeometryLabelValue: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setGeometryMode: import("react").Dispatch<import("react").SetStateAction<GeometryMode>>;
+    setGeometryPointer: import("react").Dispatch<import("react").SetStateAction<{
+        x: number;
+        y: number;
+    } | null>>;
+    setHoveredPointId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setRegularPolygonCenterId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setRegularPolygonSides: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setSelectedAngleId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSelectedCircleId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSelectedGeometryLabel: import("react").Dispatch<import("react").SetStateAction<GeometryLabelTarget | null>>;
+    setSelectedPointId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSelectedPolygonId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSelectedSegmentId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setSnapPreview: import("react").Dispatch<import("react").SetStateAction<{
+        x: number;
+        y: number;
+        kind: "point" | "grid" | "midpoint";
+    } | null>>;
+    snapPreview: {
+        x: number;
+        y: number;
+        kind: "point" | "grid" | "midpoint";
+    } | null;
+    startGeometryLabelEditing: (target: GeometryLabelTarget) => void;
+    toggleEqualSideMarker: (segmentId: string) => void;
+    traverseConnectedGeoPoint: (direction: GeometryDirection) => boolean;
+    updateGeoPoint: (id: string, updater: (point: GeoPoint) => GeoPoint) => void;
+    updateGeometryLabelOffset: (target: GeometryLabelTarget, offset: GeometryLabelOffset) => void;
+};
+export {};