@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/expression/node/ObjectNode.js

@@ -0,0 +1,216 @@
+import { isNode } from '../../utils/is.js';
+import { escape, stringify } from '../../utils/string.js';
+import { isSafeProperty } from '../../utils/customs.js';
+import { hasOwnProperty } from '../../utils/object.js';
+import { factory } from '../../utils/factory.js';
+var name = 'ObjectNode';
+var dependencies = ['Node'];
+export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    Node
+  } = _ref;
+
+  /**
+   * @constructor ObjectNode
+   * @extends {Node}
+   * Holds an object with keys/values
+   * @param {Object.<string, Node>} [properties]   object with key/value pairs
+   */
+  function ObjectNode(properties) {
+    if (!(this instanceof ObjectNode)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    this.properties = properties || {}; // validate input
+
+    if (properties) {
+      if (!(typeof properties === 'object') || !Object.keys(properties).every(function (key) {
+        return isNode(properties[key]);
+      })) {
+        throw new TypeError('Object containing Nodes expected');
+      }
+    }
+  }
+
+  ObjectNode.prototype = new Node();
+  ObjectNode.prototype.type = 'ObjectNode';
+  ObjectNode.prototype.isObjectNode = 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: *)
+   */
+
+  ObjectNode.prototype._compile = function (math, argNames) {
+    var evalEntries = {};
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        // we stringify/parse the key here to resolve unicode characters,
+        // so you cannot create a key like {"co\\u006Estructor": null}
+        var stringifiedKey = stringify(key);
+        var parsedKey = JSON.parse(stringifiedKey);
+
+        if (!isSafeProperty(this.properties, parsedKey)) {
+          throw new Error('No access to property "' + parsedKey + '"');
+        }
+
+        evalEntries[parsedKey] = this.properties[key]._compile(math, argNames);
+      }
+    }
+
+    return function evalObjectNode(scope, args, context) {
+      var obj = {};
+
+      for (var _key in evalEntries) {
+        if (hasOwnProperty(evalEntries, _key)) {
+          obj[_key] = evalEntries[_key](scope, args, context);
+        }
+      }
+
+      return obj;
+    };
+  };
+  /**
+   * Execute a callback for each of the child nodes of this node
+   * @param {function(child: Node, path: string, parent: Node)} callback
+   */
+
+
+  ObjectNode.prototype.forEach = function (callback) {
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        callback(this.properties[key], 'properties[' + stringify(key) + ']', this);
+      }
+    }
+  };
+  /**
+   * Create a new ObjectNode 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 {ObjectNode} Returns a transformed copy of the node
+   */
+
+
+  ObjectNode.prototype.map = function (callback) {
+    var properties = {};
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        properties[key] = this._ifNode(callback(this.properties[key], 'properties[' + stringify(key) + ']', this));
+      }
+    }
+
+    return new ObjectNode(properties);
+  };
+  /**
+   * Create a clone of this node, a shallow copy
+   * @return {ObjectNode}
+   */
+
+
+  ObjectNode.prototype.clone = function () {
+    var properties = {};
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        properties[key] = this.properties[key];
+      }
+    }
+
+    return new ObjectNode(properties);
+  };
+  /**
+   * Get string representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ObjectNode.prototype._toString = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        entries.push(stringify(key) + ': ' + this.properties[key].toString(options));
+      }
+    }
+
+    return '{' + entries.join(', ') + '}';
+  };
+  /**
+   * Get a JSON representation of the node
+   * @returns {Object}
+   */
+
+
+  ObjectNode.prototype.toJSON = function () {
+    return {
+      mathjs: 'ObjectNode',
+      properties: this.properties
+    };
+  };
+  /**
+   * Instantiate an OperatorNode from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "ObjectNode", "properties": {...}}`,
+   *                       where mathjs is optional
+   * @returns {ObjectNode}
+   */
+
+
+  ObjectNode.fromJSON = function (json) {
+    return new ObjectNode(json.properties);
+  };
+  /**
+   * Get HTML representation
+   * @param {Object} options
+   * @return {string} str
+   * @override
+   */
+
+
+  ObjectNode.prototype.toHTML = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        entries.push('<span class="math-symbol math-property">' + escape(key) + '</span>' + '<span class="math-operator math-assignment-operator math-property-assignment-operator math-binary-operator">:</span>' + this.properties[key].toHTML(options));
+      }
+    }
+
+    return '<span class="math-parenthesis math-curly-parenthesis">{</span>' + entries.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-curly-parenthesis">}</span>';
+  };
+  /**
+   * Get LaTeX representation
+   * @param {Object} options
+   * @return {string} str
+   */
+
+
+  ObjectNode.prototype._toTex = function (options) {
+    var entries = [];
+
+    for (var key in this.properties) {
+      if (hasOwnProperty(this.properties, key)) {
+        entries.push('\\mathbf{' + key + ':} & ' + this.properties[key].toTex(options) + '\\\\');
+      }
+    }
+
+    return "\\left\\{\\begin{array}{ll}".concat(entries.join('\n'), "\\end{array}\\right\\}");
+  };
+
+  return ObjectNode;
+}, {
+  isClass: true,
+  isNode: true
+});