@danielsimonjr/mathts-expression 0.7.1 → 0.8.0

package/dist/node/FunctionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionNode.d.ts","sourceRoot":"","sources":["../../src/node/FunctionNode.ts"],"names":[],"mappings":"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"}

package/dist/node/IndexNode.d.ts

@@ -0,0 +1,193 @@
+interface Node {
+    _compile: (math: Record<string, unknown>, argNames: Record<string, boolean>) => CompileFunction;
+    _ifNode: (node: unknown) => Node;
+    filter: (callback: (node: Node) => boolean) => Node[];
+    isSymbolNode?: boolean;
+    name?: string;
+    value?: unknown;
+    toHTML: (options?: StringOptions) => string;
+    toTex: (options?: StringOptions) => string;
+    toString: (options?: StringOptions) => string;
+}
+type CompileFunction = (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
+interface StringOptions {
+    [key: string]: unknown;
+}
+interface Dependencies {
+    Node: new (...args: unknown[]) => Node;
+    size: (value: unknown) => number[];
+}
+export declare const createIndexNode: import("../utils/factory.js").FactoryFunction<Dependencies, {
+    new (dimensions: Node[], dotNotation?: boolean): {
+        dimensions: Node[];
+        dotNotation: boolean;
+        get type(): string;
+        get isIndexNode(): boolean;
+        /**
+         * Compile a node into a JavaScript function.
+         * This basically pre-calculates as much as possible and only leaves open
+         * calculations which depend on a dynamic scope with variables.
+         * @param {Object} math     Math.js namespace with functions and constants.
+         * @param {Object} argNames An object with argument names as key and `true`
+         *                          as value. Used in the SymbolNode to optimize
+         *                          for arguments from user assigned functions
+         *                          (see FunctionAssignmentNode) or special symbols
+         *                          like `end` (see IndexNode).
+         * @return {function} Returns a function which can be called like:
+         *                        evalNode(scope: Object, args: Object, context: *)
+         */
+        _compile(math: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
+        /**
+         * Execute a callback for each of the child nodes of this node
+         * @param {function(child: Node, path: string, parent: Node)} callback
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * Create a new IndexNode whose children are the results of calling
+         * the provided callback function for each child of the original node.
+         * @param {function(child: Node, path: string, parent: Node): Node} callback
+         * @returns {IndexNode} Returns a transformed copy of the node
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {IndexNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Test whether this IndexNode contains a single property name
+         * @return {boolean}
+         */
+        isObjectProperty(): boolean;
+        /**
+         * Returns the property name if IndexNode contains a property.
+         * If not, returns null.
+         * @return {string | null}
+         */
+        getObjectProperty(): string | null;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toString(_options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toHTML(_options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        filter: (callback: (node: Node) => boolean) => Node[];
+        isSymbolNode?: boolean;
+        name?: string;
+        value?: unknown;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+        toString: (options?: StringOptions) => string;
+    };
+    name: string;
+    /**
+     * Instantiate an IndexNode from its JSON representation
+     * @param {Object} json
+     *     An object structured like
+     *     `{"mathjs": "IndexNode", dimensions: [...], dotNotation: false}`,
+     *     where mathjs is optional
+     * @returns {IndexNode}
+     */
+    fromJSON(json: {
+        dimensions: Node[];
+        dotNotation: boolean;
+    }): {
+        dimensions: Node[];
+        dotNotation: boolean;
+        get type(): string;
+        get isIndexNode(): boolean;
+        /**
+         * Compile a node into a JavaScript function.
+         * This basically pre-calculates as much as possible and only leaves open
+         * calculations which depend on a dynamic scope with variables.
+         * @param {Object} math     Math.js namespace with functions and constants.
+         * @param {Object} argNames An object with argument names as key and `true`
+         *                          as value. Used in the SymbolNode to optimize
+         *                          for arguments from user assigned functions
+         *                          (see FunctionAssignmentNode) or special symbols
+         *                          like `end` (see IndexNode).
+         * @return {function} Returns a function which can be called like:
+         *                        evalNode(scope: Object, args: Object, context: *)
+         */
+        _compile(math: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
+        /**
+         * Execute a callback for each of the child nodes of this node
+         * @param {function(child: Node, path: string, parent: Node)} callback
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * Create a new IndexNode whose children are the results of calling
+         * the provided callback function for each child of the original node.
+         * @param {function(child: Node, path: string, parent: Node): Node} callback
+         * @returns {IndexNode} Returns a transformed copy of the node
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {IndexNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Test whether this IndexNode contains a single property name
+         * @return {boolean}
+         */
+        isObjectProperty(): boolean;
+        /**
+         * Returns the property name if IndexNode contains a property.
+         * If not, returns null.
+         * @return {string | null}
+         */
+        getObjectProperty(): string | null;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toString(_options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toHTML(_options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        filter: (callback: (node: Node) => boolean) => Node[];
+        isSymbolNode?: boolean;
+        name?: string;
+        value?: unknown;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+        toString: (options?: StringOptions) => string;
+    };
+}>;
+export {};
+//# sourceMappingURL=IndexNode.d.ts.map

package/dist/node/IndexNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexNode.d.ts","sourceRoot":"","sources":["../../src/node/IndexNode.ts"],"names":[],"mappings":"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"}

package/dist/node/Node.d.ts

@@ -0,0 +1,259 @@
+type Scope = Map<string, unknown>;
+export interface CompiledExpression {
+    evaluate: (scope?: Record<string, unknown>) => unknown;
+}
+type CompileFunction = (scope: Scope, args: Record<string, unknown>, context: unknown) => unknown;
+export interface StringOptions {
+    handler?: ((node: MathNode, options?: StringOptions) => string) | Record<string, (node: MathNode, options?: StringOptions) => string>;
+    parenthesis?: 'keep' | 'auto' | 'all';
+    implicit?: 'hide' | 'show';
+    [key: string]: unknown;
+}
+interface Dependencies {
+    mathWithTransform: Record<string, unknown>;
+}
+export declare const createNode: import("../utils/factory.js").FactoryFunction<Dependencies, {
+    new (): {
+        get type(): string;
+        get isNode(): boolean;
+        /**
+         * Evaluate the node
+         * @param {Object} [scope]  Scope to read/write variables
+         * @return {*}              Returns the result
+         */
+        evaluate(scope?: Record<string, unknown>): unknown;
+        /**
+         * Compile the node into an optimized, evauatable JavaScript function
+         * @return {{evaluate: function([Object])}} object
+         *                Returns an object with a function 'evaluate',
+         *                which can be invoked as expr.evaluate([scope: Object]),
+         *                where scope is an optional object with
+         *                variables.
+         */
+        compile(): CompiledExpression;
+        /**
+         * Compile a node into a JavaScript function.
+         * This basically pre-calculates as much as possible and only leaves open
+         * calculations which depend on a dynamic scope with variables.
+         * @param {Object} math     Math.js namespace with functions and constants.
+         * @param {Object} argNames An object with argument names as key and `true`
+         *                          as value. Used in the SymbolNode to optimize
+         *                          for arguments from user assigned functions
+         *                          (see FunctionAssignmentNode) or special symbols
+         *                          like `end` (see IndexNode).
+         * @return {function} Returns a function which can be called like:
+         *                        evalNode(scope: Object, args: Object, context: *)
+         */
+        _compile(_math: Record<string, unknown>, _argNames: Record<string, boolean>): CompileFunction;
+        /**
+         * Execute a callback for each of the child nodes of this node
+         * @param {function(child: Node, path: string, parent: Node)} callback
+         */
+        forEach(_callback: (child: /*elided*/ any, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * Create a new Node whose children are the results of calling the
+         * provided callback function for each child of the original node.
+         * @param {function(child: Node, path: string, parent: Node): Node} callback
+         * @returns {OperatorNode} Returns a transformed copy of the node
+         */
+        map(_callback: (child: /*elided*/ any, path: string, parent: /*elided*/ any) => /*elided*/ any): /*elided*/ any;
+        /**
+         * Validate whether an object is a Node, for use with map
+         * @param {Node} node
+         * @returns {Node} Returns the input if it's a node, else throws an Error
+         * @protected
+         */
+        _ifNode(node: unknown): /*elided*/ any;
+        /**
+         * Recursively traverse all nodes in a node tree. Executes given callback for
+         * this node and each of its child nodes.
+         * @param {function(node: Node, path: string, parent: Node)} callback
+         *          A callback called for every node in the node tree.
+         */
+        traverse(callback: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => void): void;
+        /**
+         * Recursively transform a node tree via a transform function.
+         *
+         * For example, to replace all nodes of type SymbolNode having name 'x' with
+         * a ConstantNode with value 2:
+         *
+         *     const res = Node.transform(function (node, path, parent) {
+         *       if (node && node.isSymbolNode) && (node.name === 'x')) {
+         *         return new ConstantNode(2)
+         *       }
+         *       else {
+         *         return node
+         *       }
+         *     })
+         *
+         * @param {function(node: Node, path: string, parent: Node) : Node} callback
+         *          A mapping function accepting a node, and returning
+         *          a replacement for the node or the original node. The "signature"
+         *          of the callback must be:
+         *          callback(node: Node, index: string, parent: Node) : Node
+         * @return {Node} Returns the original node or its replacement
+         */
+        transform(callback: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => /*elided*/ any): /*elided*/ any;
+        /**
+         * Find any node in the node tree matching given filter function. For
+         * example, to find all nodes of type SymbolNode having name 'x':
+         *
+         *     const results = Node.filter(function (node) {
+         *       return (node && node.isSymbolNode) && (node.name === 'x')
+         *     })
+         *
+         * @param {function(node: Node, path: string, parent: Node) : Node} callback
+         *            A test function returning true when a node matches, and false
+         *            otherwise. Function signature:
+         *            callback(node: Node, index: string, parent: Node) : boolean
+         * @return {Node[]} nodes
+         *            An array with nodes matching given filter criteria
+         */
+        filter(callback: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => boolean): /*elided*/ any[];
+        /**
+         * Create a shallow clone of this node
+         * @return {Node}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Create a deep clone of this node
+         * @return {Node}
+         */
+        cloneDeep(): /*elided*/ any;
+        /**
+         * Deep compare this node with another node.
+         * @param {Node} other
+         * @return {boolean} Returns true when both nodes are of the same type and
+         *                   contain the same values (as do their childs)
+         */
+        equals(other: /*elided*/ any | null | undefined): boolean;
+        /**
+         * Get string representation. (wrapper function)
+         *
+         * This function can get an object of the following form:
+         * {
+         *    handler: //This can be a callback function of the form
+         *             // "function callback(node, options)"or
+         *             // a map that maps function names (used in FunctionNodes)
+         *             // to callbacks
+         *    parenthesis: "keep" //the parenthesis option (This is optional)
+         * }
+         *
+         * @param {Object} [options]
+         * @return {string}
+         */
+        toString(options?: StringOptions): string;
+        /**
+         * Internal function to generate the string output.
+         * This has to be implemented by every Node
+         *
+         * @throws {Error}
+         */
+        _toString(_options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * Both .toJSON() and the static .fromJSON(json) should be implemented by all
+         * implementations of Node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get HTML representation. (wrapper function)
+         *
+         * This function can get an object of the following form:
+         * {
+         *    handler: //This can be a callback function of the form
+         *             // "function callback(node, options)" or
+         *             // a map that maps function names (used in FunctionNodes)
+         *             // to callbacks
+         *    parenthesis: "keep" //the parenthesis option (This is optional)
+         * }
+         *
+         * @param {Object} [options]
+         * @return {string}
+         */
+        toHTML(options?: StringOptions): string;
+        /**
+         * Internal function to generate the HTML output.
+         * This has to be implemented by every Node
+         *
+         * @throws {Error}
+         */
+        _toHTML(_options?: StringOptions): string;
+        /**
+         * Get LaTeX representation. (wrapper function)
+         *
+         * This function can get an object of the following form:
+         * {
+         *    handler: //This can be a callback function of the form
+         *             // "function callback(node, options)"or
+         *             // a map that maps function names (used in FunctionNodes)
+         *             // to callbacks
+         *    parenthesis: "keep" //the parenthesis option (This is optional)
+         * }
+         *
+         * @param {Object} [options]
+         * @return {string}
+         */
+        toTex(options?: StringOptions): string;
+        /**
+         * Render this node as Markdown-embeddable math. Display (block) math by
+         * default (`$$…$$`), inline (`$…$`) when `options.inline` is true. Thin
+         * wrapper over toTex(); adds no failure mode beyond toTex's own.
+         * @param {Object} [options]
+         * @return {string}
+         */
+        toMarkdown(options?: {
+            inline?: boolean;
+        } & StringOptions): string;
+        /**
+         * Render the AST subtree rooted at this node as a Graphviz digraph: one
+         * DOT node per AST node (label = node type + a value for leaves), with
+         * parent→child edges. Never throws.
+         * @param {Object} [options]
+         * @return {string}
+         */
+        toDOT(options?: {
+            name?: string;
+        }): string;
+        /**
+         * Render this node to a MathML fragment (the MathML analog of `toTex`).
+         * Like `toTex`, this returns the body — wrap it in a `<math>` element with
+         * `mathMLDocument(node)` to render. Never throws: a failing node degrades
+         * to an escaped `<merror>` fragment.
+         * @return {string}
+         */
+        toMathML(): string;
+        /**
+         * Internal MathML generator. Overridden by the node types that render as
+         * typeset math; the base falls back to escaped text (best-effort display),
+         * rather than throwing like `_toTex`, so unhandled nodes degrade gracefully.
+         */
+        _toMathML(): string;
+        /**
+         * Internal function to generate the LaTeX output.
+         * This has to be implemented by every Node
+         *
+         * @param {Object} [options]
+         * @throws {Error}
+         */
+        _toTex(_options?: StringOptions): string;
+        /**
+         * Helper used by `to...` functions.
+         */
+        _getCustomString(options?: StringOptions): string | undefined;
+        /**
+         * Get identifier.
+         * @return {string}
+         */
+        getIdentifier(): string;
+        /**
+         * Get the content of the current Node.
+         * @return {Node} node
+         **/
+        getContent(): /*elided*/ any;
+    };
+}>;
+export type MathNode = InstanceType<ReturnType<typeof createNode>>;
+export {};
+//# sourceMappingURL=Node.d.ts.map

package/dist/node/Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../src/node/Node.ts"],"names":[],"mappings":"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"}

package/dist/node/ObjectNode.d.ts

@@ -0,0 +1,158 @@
+interface Node {
+    _compile: (math: Record<string, unknown>, argNames: Record<string, boolean>) => CompileFunction;
+    _ifNode: (node: unknown) => Node;
+    toString: (options?: StringOptions) => string;
+    toHTML: (options?: StringOptions) => string;
+    toTex: (options?: StringOptions) => string;
+}
+type CompileFunction = (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
+interface StringOptions {
+    [key: string]: unknown;
+}
+interface Dependencies {
+    Node: new (...args: unknown[]) => Node;
+}
+export declare const createObjectNode: import("../utils/factory.js").FactoryFunction<Dependencies, {
+    new (properties?: Record<string, Node>): {
+        properties: Record<string, Node>;
+        get type(): string;
+        get isObjectNode(): boolean;
+        /**
+         * Compile a node into a JavaScript function.
+         * This basically pre-calculates as much as possible and only leaves open
+         * calculations which depend on a dynamic scope with variables.
+         * @param {Object} math     Math.js namespace with functions and constants.
+         * @param {Object} argNames An object with argument names as key and `true`
+         *                          as value. Used in the SymbolNode to optimize
+         *                          for arguments from user assigned functions
+         *                          (see FunctionAssignmentNode) or special symbols
+         *                          like `end` (see IndexNode).
+         * @return {function} Returns a function which can be called like:
+         *                        evalNode(scope: Object, args: Object, context: *)
+         */
+        _compile(math: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
+        /**
+         * Execute a callback for each of the child nodes of this node
+         * @param {function(child: Node, path: string, parent: Node)} callback
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * Create a new ObjectNode whose children are the results of calling
+         * the provided callback function for each child of the original node.
+         * @param {function(child: Node, path: string, parent: Node): Node} callback
+         * @returns {ObjectNode} Returns a transformed copy of the node
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {ObjectNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toString(options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toHTML(options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        toString: (options?: StringOptions) => string;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+    };
+    name: string;
+    /**
+     * Instantiate an OperatorNode from its JSON representation
+     * @param {Object} json  An object structured like
+     *                       `{"mathjs": "ObjectNode", "properties": {...}}`,
+     *                       where mathjs is optional
+     * @returns {ObjectNode}
+     */
+    fromJSON(json: {
+        properties: Record<string, Node>;
+    }): {
+        properties: Record<string, Node>;
+        get type(): string;
+        get isObjectNode(): boolean;
+        /**
+         * Compile a node into a JavaScript function.
+         * This basically pre-calculates as much as possible and only leaves open
+         * calculations which depend on a dynamic scope with variables.
+         * @param {Object} math     Math.js namespace with functions and constants.
+         * @param {Object} argNames An object with argument names as key and `true`
+         *                          as value. Used in the SymbolNode to optimize
+         *                          for arguments from user assigned functions
+         *                          (see FunctionAssignmentNode) or special symbols
+         *                          like `end` (see IndexNode).
+         * @return {function} Returns a function which can be called like:
+         *                        evalNode(scope: Object, args: Object, context: *)
+         */
+        _compile(math: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
+        /**
+         * Execute a callback for each of the child nodes of this node
+         * @param {function(child: Node, path: string, parent: Node)} callback
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * Create a new ObjectNode whose children are the results of calling
+         * the provided callback function for each child of the original node.
+         * @param {function(child: Node, path: string, parent: Node): Node} callback
+         * @returns {ObjectNode} Returns a transformed copy of the node
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {ObjectNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toString(options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toHTML(options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        toString: (options?: StringOptions) => string;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+    };
+}>;
+export {};
+//# sourceMappingURL=ObjectNode.d.ts.map

package/dist/node/ObjectNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectNode.d.ts","sourceRoot":"","sources":["../../src/node/ObjectNode.ts"],"names":[],"mappings":"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"}