@nice2dev/ui-math 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,675 @@
+import { default as default_2 } from 'react';
+
+/** Animation state */
+export declare interface AnimationState {
+    isPlaying: boolean;
+    parameter: string;
+    currentValue: number;
+    minValue: number;
+    maxValue: number;
+    speed: number;
+}
+
+/** Axis range */
+export declare interface AxisRange {
+    min: number;
+    max: number;
+}
+
+export declare interface CalculatorConfig {
+    precision?: number;
+    angleUnit?: 'deg' | 'rad';
+}
+
+declare interface CalculatorContextValue {
+    service: CalculatorService;
+    display: string;
+    setDisplay: (val: string) => void;
+    mode: CalculatorMode;
+    setMode: (mode: CalculatorMode) => void;
+    history: HistoryEntry[];
+    calculate: () => void;
+    appendDigit: (digit: string) => void;
+    clear: () => void;
+}
+
+export declare type CalculatorMode = 'standard' | 'scientific' | 'programmer' | 'matrix' | 'calculus' | 'units';
+
+export declare class CalculatorService {
+    private history;
+    private memory;
+    private variables;
+    private config;
+    constructor(config?: CalculatorConfig);
+    /** Evaluate expression */
+    evaluate(expression: string): number;
+    /** Add to history */
+    addHistory(expression: string, result: string, mode: CalculatorMode): void;
+    /** Get history */
+    getHistory(): HistoryEntry[];
+    /** Clear history */
+    clearHistory(): void;
+    /** Memory operations */
+    memoryStore(value: number): void;
+    memoryRecall(): number;
+    memoryAdd(value: number): void;
+    memoryClear(): void;
+    /** Variable operations */
+    setVariable(name: string, value: number): void;
+    getVariable(name: string): number | undefined;
+    /** Convert between number bases */
+    convertBase(value: string, fromBase: NumberBase, toBase: NumberBase): string;
+    /** Convert units */
+    convertUnits(value: number, fromUnit: string, toUnit: string): number;
+    /** Get units by category */
+    getUnitsByCategory(category: string): UnitDef[];
+    /** Get all unit categories */
+    getUnitCategories(): string[];
+    /** Format number with precision */
+    format(value: number): string;
+}
+
+export declare const CalculusOps: {
+    /** Numerical derivative at a point */
+    derivative(f: (x: number) => number, x: number, h?: number): number;
+    /** Second derivative at a point */
+    secondDerivative(f: (x: number) => number, x: number, h?: number): number;
+    /** Numerical integration using Simpson's rule */
+    integrate(f: (x: number) => number, a: number, b: number, n?: number): number;
+    /** Find root using Newton-Raphson method */
+    findRoot(f: (x: number) => number, x0: number, tolerance?: number, maxIterations?: number): number;
+    /** Symbolic differentiation (simple cases) */
+    symbolicDerivative(expr: string): string;
+    /** Symbolic integration (simple cases) */
+    symbolicIntegral(expr: string): string;
+    /** Solve quadratic equation ax² + bx + c = 0 */
+    solveQuadratic(a: number, b: number, c: number): number[];
+};
+
+export declare function createCalculatorService(config?: CalculatorConfig): CalculatorService;
+
+export declare function createGeometryService(): GeometryService;
+
+export declare function createGraphService(config?: GraphServiceConfig): GraphService;
+
+export declare function createMathEditorService(config?: MathEditorConfig): MathEditorService;
+
+export declare type ElementId = string;
+
+/**  Equation entry */
+export declare interface Equation {
+    id: EquationId;
+    latex: string;
+    label?: string;
+    number?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare const EQUATION_TEMPLATES: EquationTemplate[];
+
+export declare type EquationId = string;
+
+export declare interface EquationTemplate {
+    name: string;
+    latex: string;
+    category: string;
+}
+
+/**
+ * Simple expression parser for math expressions.
+ * Supports: +, -, *, /, ^, (), functions, variables
+ */
+export declare class ExpressionParser {
+    private pos;
+    private expr;
+    parse(expression: string): MathFunction;
+    private parseAddSub;
+    private parseMulDiv;
+    private parsePower;
+    private parseUnary;
+    private parsePrimary;
+    private evaluate;
+}
+
+export declare const FUNCTION_PRESETS: FunctionPreset[];
+
+export declare interface FunctionPreset {
+    name: string;
+    expression: string;
+    type: PlotType;
+    expressionY?: string;
+    category: string;
+}
+
+/** Angle element */
+export declare interface GeoAngle extends GeoElementBase {
+    type: 'angle';
+    point1Id: ElementId;
+    vertexId: ElementId;
+    point2Id: ElementId;
+    showArc: boolean;
+    showValue: boolean;
+}
+
+/** Arc element */
+export declare interface GeoArc extends GeoElementBase {
+    type: 'arc';
+    centerId: ElementId;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    width: number;
+}
+
+/** Circle element */
+export declare interface GeoCircle extends GeoElementBase {
+    type: 'circle';
+    centerId: ElementId;
+    radius: number;
+    width: number;
+    fill?: GeoColor;
+}
+
+/** Color */
+export declare interface GeoColor {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+
+export declare type GeoElement = GeoPoint | GeoLine | GeoRay | GeoSegment | GeoCircle | GeoArc | GeoPolygon | GeoAngle | GeoText | GeoMeasurement;
+
+/** Base geometry element */
+export declare interface GeoElementBase {
+    id: ElementId;
+    type: GeoElementType;
+    label?: string;
+    color: GeoColor;
+    visible: boolean;
+    selected: boolean;
+    locked: boolean;
+    dependencies?: ElementId[];
+}
+
+/** Geometry element types */
+export declare type GeoElementType = 'point' | 'line' | 'ray' | 'segment' | 'circle' | 'arc' | 'polygon' | 'angle' | 'text' | 'measurement';
+
+/** Line element (infinite) */
+export declare interface GeoLine extends GeoElementBase {
+    type: 'line';
+    point1Id: ElementId;
+    point2Id: ElementId;
+    width: number;
+}
+
+export declare const GeoMath: {
+    /** Distance between two points */
+    distance(p1: Point, p2: Point): number;
+    /** Midpoint of two points */
+    midpoint(p1: Point, p2: Point): Point;
+    /** Angle between three points (vertex at p2) */
+    angle(p1: Point, vertex: Point, p3: Point): number;
+    /** Angle in degrees */
+    angleDegrees(p1: Point, vertex: Point, p3: Point): number;
+    /** Point on line closest to given point */
+    closestPointOnLine(lineP1: Point, lineP2: Point, point: Point): Point;
+    /** Line-line intersection */
+    lineIntersection(l1p1: Point, l1p2: Point, l2p1: Point, l2p2: Point): Point | null;
+    /** Circle-line intersection */
+    circleLineIntersection(center: Point, radius: number, lineP1: Point, lineP2: Point): Point[];
+    /** Circle-circle intersection */
+    circleCircleIntersection(c1: Point, r1: number, c2: Point, r2: number): Point[];
+    /** Perpendicular line through point */
+    perpendicularThrough(lineP1: Point, lineP2: Point, point: Point): {
+        p1: Point;
+        p2: Point;
+    };
+    /** Parallel line through point */
+    parallelThrough(lineP1: Point, lineP2: Point, point: Point): {
+        p1: Point;
+        p2: Point;
+    };
+    /** Angle bisector */
+    angleBisector(p1: Point, vertex: Point, p3: Point): Point;
+    /** Reflect point over line */
+    reflect(point: Point, lineP1: Point, lineP2: Point): Point;
+    /** Rotate point around center */
+    rotate(point: Point, center: Point, angle: number): Point;
+    /** Translate point */
+    translate(point: Point, dx: number, dy: number): Point;
+    /** Dilate point from center */
+    dilate(point: Point, center: Point, factor: number): Point;
+    /** Polygon area (shoelace formula) */
+    polygonArea(points: Point[]): number;
+    /** Polygon perimeter */
+    polygonPerimeter(points: Point[]): number;
+    /** Triangle circumcenter */
+    circumcenter(a: Point, b: Point, c: Point): Point;
+    /** Triangle incenter */
+    incenter(a: Point, b: Point, c: Point): Point;
+    /** Triangle centroid */
+    centroid(a: Point, b: Point, c: Point): Point;
+};
+
+/** Measurement element */
+export declare interface GeoMeasurement extends GeoElementBase {
+    type: 'measurement';
+    measureType: 'distance' | 'angle' | 'area' | 'perimeter';
+    targetIds: ElementId[];
+    x: number;
+    y: number;
+}
+
+declare interface GeometryContextValue {
+    service: GeometryService;
+    elements: GeoElement[];
+    tool: GeoTool;
+    setTool: (tool: GeoTool) => void;
+    view: GeoViewConfig;
+    setView: (view: Partial<GeoViewConfig>) => void;
+    selectedIds: ElementId[];
+    setSelectedIds: (ids: ElementId[]) => void;
+    refresh: () => void;
+}
+
+export declare class GeometryService {
+    private elements;
+    private nextLabel;
+    /** Add element */
+    addElement<T extends GeoElement>(element: Omit<T, 'id'>): T;
+    /** Get element */
+    getElement(id: ElementId): GeoElement | undefined;
+    /** Get point */
+    getPoint(id: ElementId): GeoPoint | undefined;
+    /** Update element */
+    updateElement(id: ElementId, updates: Partial<GeoElement>): void;
+    /** Delete element */
+    deleteElement(id: ElementId): void;
+    /** Get all elements */
+    getAllElements(): GeoElement[];
+    /** Get elements by type */
+    getElementsByType<T extends GeoElement>(type: GeoElementType): T[];
+    /** Clear all */
+    clear(): void;
+    /** Create point */
+    createPoint(x: number, y: number, label?: string): GeoPoint;
+    /** Create segment */
+    createSegment(point1Id: ElementId, point2Id: ElementId): GeoSegment;
+    /** Create line */
+    createLine(point1Id: ElementId, point2Id: ElementId): GeoLine;
+    /** Create ray */
+    createRay(originId: ElementId, throughId: ElementId): GeoRay;
+    /** Create circle */
+    createCircle(centerId: ElementId, radius: number): GeoCircle;
+    /** Create polygon */
+    createPolygon(pointIds: ElementId[]): GeoPolygon;
+    /** Create midpoint */
+    createMidpoint(point1Id: ElementId, point2Id: ElementId): GeoPoint | null;
+    /** Create perpendicular */
+    createPerpendicular(lineP1Id: ElementId, lineP2Id: ElementId, throughId: ElementId): GeoLine | null;
+    /** Create parallel */
+    createParallel(lineP1Id: ElementId, lineP2Id: ElementId, throughId: ElementId): GeoLine | null;
+    /** Create intersection point */
+    createIntersection(el1Id: ElementId, el2Id: ElementId): GeoPoint[];
+    /** Calculate measurement */
+    calculateMeasurement(type: 'distance' | 'angle' | 'area' | 'perimeter', targetIds: ElementId[]): number;
+    /** Export to SVG */
+    exportSVG(width: number, height: number, view: GeoViewConfig): string;
+    private generateId;
+    private getNextLabel;
+}
+
+/** Point element */
+export declare interface GeoPoint extends GeoElementBase {
+    type: 'point';
+    x: number;
+    y: number;
+    size: number;
+}
+
+/** Polygon element */
+export declare interface GeoPolygon extends GeoElementBase {
+    type: 'polygon';
+    pointIds: ElementId[];
+    width: number;
+    fill?: GeoColor;
+}
+
+/** Ray element */
+export declare interface GeoRay extends GeoElementBase {
+    type: 'ray';
+    originId: ElementId;
+    throughId: ElementId;
+    width: number;
+}
+
+/** Line segment */
+export declare interface GeoSegment extends GeoElementBase {
+    type: 'segment';
+    point1Id: ElementId;
+    point2Id: ElementId;
+    width: number;
+}
+
+/** Text element */
+export declare interface GeoText extends GeoElementBase {
+    type: 'text';
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+}
+
+/** Tool modes */
+export declare type GeoTool = 'select' | 'point' | 'line' | 'ray' | 'segment' | 'circle' | 'arc' | 'polygon' | 'angle' | 'perpendicular' | 'parallel' | 'bisector' | 'midpoint' | 'tangent' | 'intersection' | 'reflect' | 'rotate' | 'translate' | 'dilate' | 'measure' | 'text';
+
+/** Transformation */
+export declare interface GeoTransform {
+    type: 'reflect' | 'rotate' | 'translate' | 'dilate';
+    params: Record<string, number | ElementId>;
+}
+
+/** View configuration */
+export declare interface GeoViewConfig {
+    centerX: number;
+    centerY: number;
+    scale: number;
+    showGrid: boolean;
+    showAxes: boolean;
+    gridSpacing: number;
+    snapToGrid: boolean;
+    snapToPoints: boolean;
+    backgroundColor: GeoColor;
+}
+
+/** Get symbols by category */
+export declare function getSymbolsByCategory(category: SymbolCategory): MathSymbol[];
+
+declare interface GraphContextValue {
+    service: GraphService;
+    plots: Plot[];
+    view: ViewConfig;
+    setView: (view: Partial<ViewConfig>) => void;
+    addPlot: (data: Partial<Plot> & {
+        expression: string;
+        type: PlotType;
+    }) => void;
+    removePlot: (id: PlotId) => void;
+    updatePlot: (id: PlotId, data: Partial<Plot>) => void;
+    animation: AnimationState;
+    setAnimation: (anim: Partial<AnimationState>) => void;
+    refresh: () => void;
+}
+
+export declare class GraphService {
+    private plots;
+    private parser;
+    private config;
+    constructor(config?: GraphServiceConfig);
+    /** Add a plot */
+    addPlot(data: Partial<Plot> & {
+        expression: string;
+        type: PlotType;
+    }): Plot;
+    /** Update a plot */
+    updatePlot(id: PlotId, data: Partial<Plot>): Plot;
+    /** Remove a plot */
+    removePlot(id: PlotId): void;
+    /** Get all plots */
+    getPlots(): Plot[];
+    /** Get plot by ID */
+    getPlot(id: PlotId): Plot | undefined;
+    /** Compute 2D function points */
+    compute2DFunction(expression: string, xRange: AxisRange, resolution: number, animationVars?: Record<string, number>): Point2D[];
+    /** Compute 2D parametric curve */
+    compute2DParametric(expressionX: string, expressionY: string, tRange: AxisRange, resolution: number, animationVars?: Record<string, number>): Point2D[];
+    /** Compute 2D polar curve */
+    compute2DPolar(expression: string, thetaRange: AxisRange, resolution: number, animationVars?: Record<string, number>): Point2D[];
+    /** Compute 3D surface points */
+    compute3DSurface(expression: string, xRange: AxisRange, yRange: AxisRange, resolution: number, animationVars?: Record<string, number>): Point3D[][];
+    /** Export plot data as SVG */
+    exportSVG(plots: Plot[], view: ViewConfig, width: number, height: number): string;
+    /** Export as PNG (data URL) */
+    exportPNG(plots: Plot[], view: ViewConfig, width: number, height: number): Promise<string>;
+    private generateId;
+}
+
+export declare interface GraphServiceConfig {
+    defaultResolution?: number;
+    maxResolution?: number;
+}
+
+export declare interface HandwritingRecognitionResult {
+    latex: string;
+    confidence: number;
+    alternatives: string[];
+}
+
+/** History entry */
+export declare interface HistoryEntry {
+    id: string;
+    expression: string;
+    result: string;
+    timestamp: string;
+    mode: CalculatorMode;
+}
+
+export declare const MATH_SYMBOLS: MathSymbol[];
+
+export declare interface MathEditorConfig {
+    enableNumbering?: boolean;
+    startNumber?: number;
+    renderDelay?: number;
+}
+
+declare interface MathEditorContextValue {
+    service: MathEditorService;
+    latex: string;
+    setLatex: (latex: string) => void;
+    insertSymbol: (latex: string) => void;
+    insertTemplate: (template: EquationTemplate) => void;
+    mode: 'input' | 'handwriting';
+    setMode: (mode: 'input' | 'handwriting') => void;
+}
+
+export declare class MathEditorService {
+    private equations;
+    private config;
+    private nextNumber;
+    constructor(config?: MathEditorConfig);
+    /** Create new equation */
+    createEquation(latex: string, label?: string): Equation;
+    /** Update equation */
+    updateEquation(id: EquationId, latex: string, label?: string): Equation;
+    /** Delete equation */
+    deleteEquation(id: EquationId): void;
+    /** Get equation */
+    getEquation(id: EquationId): Equation | undefined;
+    /** List all equations */
+    listEquations(): Equation[];
+    /** Export to LaTeX document */
+    exportToLatex(): string;
+    /** Parse LaTeX and extract equations */
+    parseLatex(content: string): Equation[];
+    private generateId;
+}
+
+declare type MathFunction = (vars: Record<string, number>) => number;
+
+/** Math symbol definition */
+export declare interface MathSymbol {
+    name: string;
+    latex: string;
+    category: SymbolCategory;
+    preview?: string;
+}
+
+/** Matrix */
+export declare interface Matrix {
+    rows: number;
+    cols: number;
+    data: number[][];
+}
+
+export declare const MatrixOps: {
+    create(rows: number, cols: number, fill?: number): Matrix;
+    identity(size: number): Matrix;
+    add(a: Matrix, b: Matrix): Matrix;
+    subtract(a: Matrix, b: Matrix): Matrix;
+    multiply(a: Matrix, b: Matrix): Matrix;
+    scalar(m: Matrix, s: number): Matrix;
+    transpose(m: Matrix): Matrix;
+    determinant(m: Matrix): number;
+    minor(m: Matrix, row: number, col: number): Matrix;
+    inverse(m: Matrix): Matrix;
+    trace(m: Matrix): number;
+    eigenvalues2x2(m: Matrix): number[];
+    toString(m: Matrix, precision?: number): string;
+};
+
+export declare function NiceCalculator({ service, className, style, }: NiceCalculatorProps): default_2.ReactElement;
+
+export declare interface NiceCalculatorProps {
+    service: CalculatorService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceGeometry({ service, width, height, className, style, }: NiceGeometryProps): default_2.ReactElement;
+
+export declare interface NiceGeometryProps {
+    service: GeometryService;
+    width?: number;
+    height?: number;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceGraphPlotter({ service, width, height, className, style, }: NiceGraphPlotterProps): default_2.ReactElement;
+
+export declare interface NiceGraphPlotterProps {
+    service: GraphService;
+    width?: number;
+    height?: number;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceMathEditor({ service, initialLatex, onChange, className, style, }: NiceMathEditorProps): default_2.ReactElement;
+
+export declare interface NiceMathEditorProps {
+    service: MathEditorService;
+    initialLatex?: string;
+    onChange?: (latex: string) => void;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare type NumberBase = 'BIN' | 'OCT' | 'DEC' | 'HEX';
+
+/** Plot definition */
+export declare interface Plot {
+    id: PlotId;
+    type: PlotType;
+    label?: string;
+    expression: string;
+    expressionY?: string;
+    expressionZ?: string;
+    color: PlotColor;
+    lineWidth?: number;
+    visible: boolean;
+    parameterRange?: AxisRange;
+    parameterRange2?: AxisRange;
+    resolution?: number;
+}
+
+/** Plot color */
+export declare interface PlotColor {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+
+export declare type PlotId = string;
+
+/** Plot types */
+export declare type PlotType = '2d-function' | '2d-parametric' | '2d-implicit' | '2d-polar' | '3d-surface' | '3d-parametric' | '3d-implicit';
+
+/** Point on canvas */
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+/** 2D Point */
+export declare interface Point2D {
+    x: number;
+    y: number;
+}
+
+/** 3D Point */
+export declare interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+}
+
+/**
+ * Recognize handwritten math from strokes.
+ * This is a stub implementation - in production, this would
+ * connect to MyScript, Mathpix, or similar service.
+ */
+export declare function recognizeHandwriting(strokes: Stroke[]): Promise<HandwritingRecognitionResult>;
+
+/** Handwriting stroke */
+export declare interface Stroke {
+    id: string;
+    points: StrokePoint[];
+}
+
+/** Handwriting point */
+export declare interface StrokePoint {
+    x: number;
+    y: number;
+    pressure?: number;
+    timestamp: number;
+}
+
+/** Symbol category */
+export declare type SymbolCategory = 'greek' | 'operators' | 'relations' | 'arrows' | 'functions' | 'accents' | 'delimiters' | 'sets' | 'logic' | 'geometry' | 'calculus' | 'matrices';
+
+/** Unit definition */
+export declare interface UnitDef {
+    name: string;
+    symbol: string;
+    category: string;
+    toBase: (value: number) => number;
+    fromBase: (value: number) => number;
+}
+
+export declare function useCalculator(): CalculatorContextValue;
+
+export declare function useGeometry(): GeometryContextValue;
+
+export declare function useGraph(): GraphContextValue;
+
+export declare function useMathEditor(): MathEditorContextValue;
+
+/** View configuration */
+export declare interface ViewConfig {
+    xRange: AxisRange;
+    yRange: AxisRange;
+    zRange?: AxisRange;
+    showGrid: boolean;
+    showAxes: boolean;
+    showLabels: boolean;
+    backgroundColor: PlotColor;
+    cameraRotationX?: number;
+    cameraRotationY?: number;
+    cameraDistance?: number;
+}
+
+export { }