mathjs 10.6.2 → 11.0.0

package/lib/esm/expression/node/AccessorNode.js

@@ -1,3 +1,4 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isNode, isObjectNode, isParenthesisNode, isSymbolNode } from '../../utils/is.js';
 import { getSafeProperty } from '../../utils/customs.js';
 import { factory } from '../../utils/factory.js';
@@ -13,196 +14,200 @@ export var createAccessorNode = /* #__PURE__ */factory(name, dependencies, _ref
     subset
   });
   /**
-   * @constructor AccessorNode
-   * @extends {Node}
-   * Access an object property or get a matrix subset
-   *
-   * @param {Node} object                 The object from which to retrieve
-   *                                      a property or subset.
-   * @param {IndexNode} index             IndexNode containing ranges
+   * Are parenthesis needed?
+   * @private
    */
 
-  function AccessorNode(object, index) {
-    if (!(this instanceof AccessorNode)) {
-      throw new SyntaxError('Constructor must be called with the new operator');
-    }
-
-    if (!isNode(object)) {
-      throw new TypeError('Node expected for parameter "object"');
-    }
-
-    if (!isIndexNode(index)) {
-      throw new TypeError('IndexNode expected for parameter "index"');
-    }
-
-    this.object = object || null;
-    this.index = index; // readonly property name
-
-    Object.defineProperty(this, 'name', {
-      get: function () {
-        if (this.index) {
-          return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
-        } else {
-          return this.object.name || '';
-        }
-      }.bind(this),
-      set: function set() {
-        throw new Error('Cannot assign a new name, name is read-only');
-      }
-    });
+  function needParenthesis(node) {
+    // TODO: maybe make a method on the nodes which tells whether they need parenthesis?
+    return !(isAccessorNode(node) || isArrayNode(node) || isConstantNode(node) || isFunctionNode(node) || isObjectNode(node) || isParenthesisNode(node) || isSymbolNode(node));
   }
 
-  AccessorNode.prototype = new Node();
-  AccessorNode.prototype.type = 'AccessorNode';
-  AccessorNode.prototype.isAccessorNode = true;
-  /**
-   * 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: *)
-   */
+  class AccessorNode extends Node {
+    /**
+     * @constructor AccessorNode
+     * @extends {Node}
+     * Access an object property or get a matrix subset
+     *
+     * @param {Node} object                 The object from which to retrieve
+     *                                      a property or subset.
+     * @param {IndexNode} index             IndexNode containing ranges
+     */
+    constructor(object, index) {
+      super();
+
+      if (!isNode(object)) {
+        throw new TypeError('Node expected for parameter "object"');
+      }
 
-  AccessorNode.prototype._compile = function (math, argNames) {
-    var evalObject = this.object._compile(math, argNames);
+      if (!isIndexNode(index)) {
+        throw new TypeError('IndexNode expected for parameter "index"');
+      }
 
-    var evalIndex = this.index._compile(math, argNames);
+      this.object = object;
+      this.index = index;
+    } // readonly property name
 
-    if (this.index.isObjectProperty()) {
-      var prop = this.index.getObjectProperty();
-      return function evalAccessorNode(scope, args, context) {
-        // get a property from an object evaluated using the scope.
-        return getSafeProperty(evalObject(scope, args, context), prop);
-      };
-    } else {
-      return function evalAccessorNode(scope, args, context) {
-        var object = evalObject(scope, args, context);
-        var index = evalIndex(scope, args, object); // we pass object here instead of context
 
-        return access(object, index);
-      };
+    get name() {
+      if (this.index) {
+        return this.index.isObjectProperty() ? this.index.getObjectProperty() : '';
+      } else {
+        return this.object.name || '';
+      }
     }
-  };
-  /**
-   * Execute a callback for each of the child nodes of this node
-   * @param {function(child: Node, path: string, parent: Node)} callback
-   */
 
+    get type() {
+      return name;
+    }
 
-  AccessorNode.prototype.forEach = function (callback) {
-    callback(this.object, 'object', this);
-    callback(this.index, 'index', this);
-  };
-  /**
-   * Create a new AccessorNode having it's childs be the results of calling
-   * the provided callback function for each of the childs of the original node.
-   * @param {function(child: Node, path: string, parent: Node): Node} callback
-   * @returns {AccessorNode} Returns a transformed copy of the node
-   */
+    get isAccessorNode() {
+      return true;
+    }
+    /**
+     * 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, argNames) {
+      var evalObject = this.object._compile(math, argNames);
+
+      var evalIndex = this.index._compile(math, argNames);
+
+      if (this.index.isObjectProperty()) {
+        var prop = this.index.getObjectProperty();
+        return function evalAccessorNode(scope, args, context) {
+          // get a property from an object evaluated using the scope.
+          return getSafeProperty(evalObject(scope, args, context), prop);
+        };
+      } else {
+        return function evalAccessorNode(scope, args, context) {
+          var object = evalObject(scope, args, context); // we pass just object here instead of context:
+
+          var index = evalIndex(scope, args, object);
+          return access(object, index);
+        };
+      }
+    }
+    /**
+     * Execute a callback for each of the child nodes of this node
+     * @param {function(child: Node, path: string, parent: Node)} callback
+     */
 
 
-  AccessorNode.prototype.map = function (callback) {
-    return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
-  };
-  /**
-   * Create a clone of this node, a shallow copy
-   * @return {AccessorNode}
-   */
-
+    forEach(callback) {
+      callback(this.object, 'object', this);
+      callback(this.index, 'index', this);
+    }
+    /**
+     * Create a new AccessorNode 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 {AccessorNode} Returns a transformed copy of the node
+     */
 
-  AccessorNode.prototype.clone = function () {
-    return new AccessorNode(this.object, this.index);
-  };
-  /**
-   * Get string representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    map(callback) {
+      return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this)));
+    }
+    /**
+     * Create a clone of this node, a shallow copy
+     * @return {AccessorNode}
+     */
 
-  AccessorNode.prototype._toString = function (options) {
-    var object = this.object.toString(options);
 
-    if (needParenthesis(this.object)) {
-      object = '(' + object + ')';
+    clone() {
+      return new AccessorNode(this.object, this.index);
     }
+    /**
+     * Get string representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toString(options);
-  };
-  /**
-   * Get HTML representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    _toString(options) {
+      var object = this.object.toString(options);
 
-  AccessorNode.prototype.toHTML = function (options) {
-    var object = this.object.toHTML(options);
+      if (needParenthesis(this.object)) {
+        object = '(' + object + ')';
+      }
 
-    if (needParenthesis(this.object)) {
-      object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      return object + this.index.toString(options);
     }
+    /**
+     * Get HTML representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toHTML(options);
-  };
-  /**
-   * Get LaTeX representation
-   * @param {Object} options
-   * @return {string}
-   */
 
+    toHTML(options) {
+      var object = this.object.toHTML(options);
 
-  AccessorNode.prototype._toTex = function (options) {
-    var object = this.object.toTex(options);
+      if (needParenthesis(this.object)) {
+        object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+      }
 
-    if (needParenthesis(this.object)) {
-      object = '\\left(\' + object + \'\\right)';
+      return object + this.index.toHTML(options);
     }
+    /**
+     * Get LaTeX representation
+     * @param {Object} options
+     * @return {string}
+     */
 
-    return object + this.index.toTex(options);
-  };
-  /**
-   * Get a JSON representation of the node
-   * @returns {Object}
-   */
 
+    _toTex(options) {
+      var object = this.object.toTex(options);
 
-  AccessorNode.prototype.toJSON = function () {
-    return {
-      mathjs: 'AccessorNode',
-      object: this.object,
-      index: this.index
-    };
-  };
-  /**
-   * Instantiate an AccessorNode from its JSON representation
-   * @param {Object} json  An object structured like
-   *                       `{"mathjs": "AccessorNode", object: ..., index: ...}`,
-   *                       where mathjs is optional
-   * @returns {AccessorNode}
-   */
+      if (needParenthesis(this.object)) {
+        object = '\\left(\' + object + \'\\right)';
+      }
 
+      return object + this.index.toTex(options);
+    }
+    /**
+     * Get a JSON representation of the node
+     * @returns {Object}
+     */
 
-  AccessorNode.fromJSON = function (json) {
-    return new AccessorNode(json.object, json.index);
-  };
-  /**
-   * Are parenthesis needed?
-   * @private
-   */
 
+    toJSON() {
+      return {
+        mathjs: name,
+        object: this.object,
+        index: this.index
+      };
+    }
+    /**
+     * Instantiate an AccessorNode from its JSON representation
+     * @param {Object} json
+     *     An object structured like
+     *     `{"mathjs": "AccessorNode", object: ..., index: ...}`,
+     *     where mathjs is optional
+     * @returns {AccessorNode}
+     */
+
+
+    static fromJSON(json) {
+      return new AccessorNode(json.object, json.index);
+    }
 
-  function needParenthesis(node) {
-    // TODO: maybe make a method on the nodes which tells whether they need parenthesis?
-    return !(isAccessorNode(node) || isArrayNode(node) || isConstantNode(node) || isFunctionNode(node) || isObjectNode(node) || isParenthesisNode(node) || isSymbolNode(node));
   }
 
+  _defineProperty(AccessorNode, "name", name);
+
   return AccessorNode;
 }, {
   isClass: true,