vue3-math-editor 0.1.0 → 0.2.0

package/dist/types/renderers/layoutLatex.d.ts

@@ -0,0 +1,17 @@
+import type { Row, RowPath } from '../editor/layout';
+export interface LayoutLatexOptions {
+    activeRow?: RowPath | null;
+    shownUnits?: ReadonlySet<string>;
+    greekNames?: boolean;
+}
+export declare function encodeRowPath(path: RowPath): string;
+export declare function decodeRowPath(encoded: string | null | undefined): RowPath | null;
+export declare function rowToLatex(row: Row, options?: LayoutLatexOptions): string;
+export declare const KATEX_EDITOR_OPTIONS: {
+    displayMode: boolean;
+    throwOnError: boolean;
+    strict: "ignore";
+    trust: (context: {
+        command: string;
+    }) => boolean;
+};

package/dist/types/renderers/mathjson.d.ts

@@ -0,0 +1,6 @@
+import type { AstNode } from '../types/ast';
+export type MathJsonValue = number | string | null | MathJsonValue[] | {
+    [key: string]: MathJsonValue;
+};
+export declare function astToMathJson(node: AstNode): MathJsonValue;
+export declare function renderMathJson(node: AstNode): string;

package/dist/types/renderers/mathml.d.ts

@@ -0,0 +1,6 @@
+import type { AstNode } from '../types/ast';
+export interface ContentMathMLOptions {
+    cellml?: boolean;
+}
+export declare const DEFAULT_NUMBER_UNITS = "dimensionless";
+export declare function astToContentMathML(node: AstNode, options?: ContentMathMLOptions): string;

package/dist/types/types/ast.d.ts

@@ -0,0 +1,97 @@
+export type AstNode = NumberNode | IdentifierNode | ConstantNode | AddNode | MultiplyNode | SubtractNode | NegateNode | AbsNode | RootNode | FunctionCallNode | EqualNode | ComparisonNode | LogicNode | NotNode | PiecewiseNode | DivideNode | PowerNode | DerivativeNode | GroupNode | PlaceholderNode;
+export interface NumberNode {
+    type: 'Number';
+    value: number;
+    scientific?: {
+        mantissa: string;
+        exponent: number;
+    };
+    units?: string;
+}
+export interface PlaceholderNode {
+    type: 'Placeholder';
+}
+export interface ConstantNode {
+    type: 'Constant';
+    name: string;
+}
+export interface IdentifierNode {
+    type: 'Identifier';
+    name: string;
+}
+export interface AddNode {
+    type: 'Add';
+    children: AstNode[];
+}
+export interface MultiplyNode {
+    type: 'Multiply';
+    children: AstNode[];
+}
+export interface SubtractNode {
+    type: 'Subtract';
+    minuend: AstNode;
+    subtrahend: AstNode;
+}
+export interface NegateNode {
+    type: 'Negate';
+    value: AstNode;
+}
+export interface AbsNode {
+    type: 'Abs';
+    value: AstNode;
+}
+export interface RootNode {
+    type: 'Root';
+    radicand: AstNode;
+    degree: AstNode | null;
+}
+export interface FunctionCallNode {
+    type: 'FunctionCall';
+    name: string;
+    args: AstNode[];
+}
+export interface EqualNode {
+    type: 'Equal';
+    left: AstNode;
+    right: AstNode;
+}
+export interface ComparisonNode {
+    type: 'Less' | 'Greater' | 'LessEqual' | 'GreaterEqual' | 'NotEqual';
+    left: AstNode;
+    right: AstNode;
+}
+export interface LogicNode {
+    type: 'And' | 'Or' | 'Xor';
+    children: AstNode[];
+}
+export interface NotNode {
+    type: 'Not';
+    value: AstNode;
+}
+export interface PiecewiseNode {
+    type: 'Piecewise';
+    pieces: Array<{
+        value: AstNode;
+        condition: AstNode;
+    }>;
+    otherwise: AstNode | null;
+}
+export interface DivideNode {
+    type: 'Divide';
+    numerator: AstNode;
+    denominator: AstNode;
+}
+export interface PowerNode {
+    type: 'Power';
+    base: AstNode;
+    exponent: AstNode;
+}
+export interface GroupNode {
+    type: 'Group';
+    value: AstNode;
+}
+export interface DerivativeNode {
+    type: 'Derivative';
+    expression: AstNode;
+    variable: AstNode;
+}

package/dist/types/units/UnitsDefinitionForm.vue.d.ts

@@ -0,0 +1,16 @@
+import { type UnitsDefinition } from './definitions';
+type __VLS_Props = {
+    definition?: UnitsDefinition | null;
+    others: readonly UnitsDefinition[];
+    known: readonly string[] | null;
+    choices: readonly string[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    save: (definition: UnitsDefinition) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onSave?: ((definition: UnitsDefinition) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/units/UnitsPanel.vue.d.ts

@@ -0,0 +1,56 @@
+import type { EquationLine, UnitsIssue, VariableUnits } from '../editor/units';
+import { type UnitsDefinition } from './definitions';
+import type { UnitsLibraryProblem, UnitsSource } from './library';
+import type { UnitsCheckerStatus } from './useUnitsChecker';
+type __VLS_Props = {
+    status: UnitsCheckerStatus;
+    lines: readonly EquationLine[];
+    files?: readonly {
+        name: string;
+        units: readonly string[];
+    }[];
+    problems?: readonly UnitsLibraryProblem[];
+    unitsNames?: readonly string[];
+    issues?: readonly UnitsIssue[];
+    checking?: boolean;
+};
+type __VLS_ModelProps = {
+    'sources'?: UnitsSource[];
+    'variableUnits'?: VariableUnits;
+    'newUnits'?: UnitsDefinition[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_16: {}, __VLS_32: {
+    definitions: UnitsDefinition[];
+};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_16) => any;
+} & {
+    'new-units-actions'?: (props: typeof __VLS_32) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:sources": (value: UnitsSource[]) => any;
+    "update:variableUnits": (value: Readonly<Record<string, string>>) => any;
+    "update:newUnits": (value: UnitsDefinition[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:sources"?: ((value: UnitsSource[]) => any) | undefined;
+    "onUpdate:variableUnits"?: ((value: Readonly<Record<string, string>>) => any) | undefined;
+    "onUpdate:newUnits"?: ((value: UnitsDefinition[]) => any) | undefined;
+}>, {
+    checking: boolean;
+    issues: readonly UnitsIssue[];
+    problems: readonly UnitsLibraryProblem[];
+    files: readonly {
+        name: string;
+        units: readonly string[];
+    }[];
+    unitsNames: readonly string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/units/check.d.ts

@@ -0,0 +1,16 @@
+import type { EquationLine, UnitsIssue, VariableUnits } from '../editor/units';
+import { type LibCellML } from './libcellml';
+import type { UnitsLibrary } from './library';
+export declare function missingUnits(line: EquationLine, variableUnits: VariableUnits): string[];
+export declare class UnitsChecker {
+    private readonly lc;
+    private readonly library;
+    private readonly cache;
+    constructor(lc: LibCellML, library: UnitsLibrary);
+    check(lines: readonly EquationLine[], variableUnits: VariableUnits): UnitsIssue[];
+    checkLine(line: EquationLine, variableUnits: VariableUnits): UnitsIssue[];
+    private prechecked;
+    private analysed;
+    private analyse;
+    dispose(): void;
+}

package/dist/types/units/definitions.d.ts

@@ -0,0 +1,16 @@
+export interface UnitsPart {
+    units: string;
+    prefix?: string;
+    exponent?: number;
+    multiplier?: number;
+}
+export interface UnitsDefinition {
+    name: string;
+    parts: UnitsPart[];
+}
+export declare const NEW_UNITS_SOURCE = "new units";
+export declare const PREFIXES: readonly ["yotta", "zetta", "exa", "peta", "tera", "giga", "mega", "kilo", "hecto", "deca", "deci", "centi", "milli", "micro", "nano", "pico", "femto", "atto", "zepto", "yocto"];
+export declare function definitionProblems(definition: UnitsDefinition, others: readonly UnitsDefinition[], known: readonly string[] | null): string[];
+export declare function usedBy(name: string, definitions: readonly UnitsDefinition[]): string[];
+export declare function describeDefinition(definition: UnitsDefinition): string;
+export declare function newUnitsFile(definitions: readonly UnitsDefinition[], modelName?: string): string;

package/dist/types/units/libcellml.d.ts

@@ -0,0 +1,81 @@
+export interface Deletable {
+    delete(): void;
+}
+export interface LcEnum {
+    value: number;
+}
+export interface LcIssue extends Deletable {
+    description(): string;
+    level(): LcEnum;
+    referenceRule(): LcEnum | undefined;
+}
+export interface LcLogger extends Deletable {
+    issueCount(): number;
+    issue(index: number): LcIssue;
+}
+export interface LcUnits extends Deletable {
+    name(): string;
+    setName(name: string): void;
+    unitCount(): number;
+    unitAttributeReference(index: number): string;
+    isImport(): boolean;
+    clone(): LcUnits;
+}
+export interface LcVariable extends Deletable {
+    setName(name: string): void;
+    setUnitsByName(name: string): void;
+}
+export interface LcComponent extends Deletable {
+    setName(name: string): void;
+    setMath(math: string): void;
+    addVariable(variable: LcVariable): boolean;
+}
+export interface LcModel extends Deletable {
+    setName(name: string): void;
+    unitsCount(): number;
+    unitsByIndex(index: number): LcUnits;
+    unitsByName(name: string): LcUnits | null;
+    addUnits(units: LcUnits): boolean;
+    addComponent(component: LcComponent): boolean;
+    linkUnits(): boolean;
+}
+export interface LcParser extends LcLogger {
+    parseModel(text: string): LcModel;
+}
+export interface LcValidator extends LcLogger {
+    validateModel(model: LcModel): void;
+}
+export interface LcAnalyser extends LcLogger {
+    analyseModel(model: LcModel): void;
+}
+export interface LcPrinter extends Deletable {
+    printModel(model: LcModel): string;
+}
+export interface LibCellML {
+    Parser: new (strict: boolean) => LcParser;
+    Validator: new () => LcValidator;
+    Analyser: new () => LcAnalyser;
+    Printer: new () => LcPrinter;
+    Model: new () => LcModel;
+    Component: new () => LcComponent;
+    Variable: new () => LcVariable;
+    Units: {
+        new (): LcUnits;
+        equivalent(a: LcUnits, b: LcUnits): boolean;
+        StandardUnit: Record<string, unknown>;
+    };
+}
+export declare const LEVEL_ERROR = 0;
+export declare const LEVEL_WARNING = 1;
+export declare const RULE_ANALYSER_UNITS = 112;
+export declare function loggerIssues(logger: LcLogger): {
+    message: string;
+    level: number;
+    rule: number;
+}[];
+export declare class Handles {
+    private readonly held;
+    track<T extends Deletable | null>(handle: T): T;
+    dispose(): void;
+}
+export declare function standardUnitsNames(lc: LibCellML): string[];

package/dist/types/units/library.d.ts

@@ -0,0 +1,29 @@
+import { Handles, type LcModel, type LibCellML } from './libcellml';
+export interface UnitsSource {
+    name: string;
+    text: string;
+}
+export interface UnitsLibraryProblem {
+    source: string;
+    message: string;
+}
+export declare class UnitsLibrary {
+    private readonly lc;
+    readonly names: readonly string[];
+    readonly sources: readonly {
+        name: string;
+        units: readonly string[];
+    }[];
+    readonly problems: readonly UnitsLibraryProblem[];
+    private readonly standard;
+    private readonly defined;
+    private readonly handles;
+    private constructor();
+    static load(lc: LibCellML, sources: readonly UnitsSource[]): UnitsLibrary;
+    isStandard(name: string): boolean;
+    isKnown(name: string): boolean;
+    requiredBy(names: Iterable<string>): string[];
+    addTo(model: LcModel, names: Iterable<string>, handles: Handles): void;
+    dispose(): void;
+    private parse;
+}

package/dist/types/units/messages.d.ts

@@ -0,0 +1,13 @@
+export interface Operand {
+    text: string;
+    units: string;
+}
+export interface UnitsMessage {
+    kind: 'mismatch' | 'notDimensionless';
+    expression: string;
+    operands: Operand[];
+}
+export declare function readUnitsMessage(message: string): UnitsMessage | null;
+export declare function describeUnitsMessage(parsed: UnitsMessage): string;
+export declare function operandVariables(text: string, variables: readonly string[]): string[];
+export declare function operandNumbers(text: string): number[];

package/dist/types/units/panel.d.ts

@@ -0,0 +1,11 @@
+import type { EquationLine, VariableUnits } from '../editor/units';
+import type { UnitsSource } from './library';
+export interface VariableRow {
+    name: string;
+    units: string;
+    used: boolean;
+    state: 'ok' | 'missing' | 'unknown';
+}
+export declare function variableRows(lines: readonly EquationLine[], variableUnits: VariableUnits, unitsNames: readonly string[] | null): VariableRow[];
+export declare function withUnits(variableUnits: VariableUnits, name: string, units: string): VariableUnits;
+export declare function withSources(sources: readonly UnitsSource[], added: readonly UnitsSource[]): UnitsSource[];

package/dist/types/units/useUnitsChecker.d.ts

@@ -0,0 +1,36 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { EquationLine, UnitsIssue, VariableUnits } from '../editor/units';
+import { type UnitsDefinition } from './definitions';
+import { type LibCellML } from './libcellml';
+import { type UnitsSource } from './library';
+export declare const LIBCELLML_KEY = "$libcellml";
+export interface ProvidedLibCellML {
+    status: string;
+    library: LibCellML | null;
+}
+export type UnitsCheckerStatus = 'unavailable' | 'loading' | 'ready';
+export interface UnitsCheckerOptions {
+    lines: MaybeRefOrGetter<readonly EquationLine[]>;
+    sources: MaybeRefOrGetter<readonly UnitsSource[]>;
+    variableUnits: MaybeRefOrGetter<VariableUnits>;
+    newUnits?: MaybeRefOrGetter<readonly UnitsDefinition[]>;
+    enabled?: MaybeRefOrGetter<boolean>;
+    delay?: number;
+    libcellml?: LibCellML | ProvidedLibCellML | null;
+}
+export declare function useUnitsChecker(options: UnitsCheckerOptions): {
+    available: import("vue").ComputedRef<boolean>;
+    ready: import("vue").ComputedRef<boolean>;
+    status: import("vue").ComputedRef<UnitsCheckerStatus>;
+    checking: import("vue").ComputedRef<boolean>;
+    issues: import("vue").ShallowRef<UnitsIssue[], UnitsIssue[]>;
+    files: import("vue").ComputedRef<readonly {
+        name: string;
+        units: readonly string[];
+    }[]>;
+    problems: import("vue").ComputedRef<readonly import("./library").UnitsLibraryProblem[]>;
+    newUnitsFile: import("vue").ComputedRef<string>;
+    unitsNames: import("vue").ComputedRef<string[]>;
+    missing: import("vue").ComputedRef<string[]>;
+    check: () => void;
+};