asajs 3.0.2 → 3.0.5

package/dist/cjs/components/Modify.js

@@ -0,0 +1,377 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Modify_exports = {};
+__export(Modify_exports, {
+  Modify: () => Modify
+});
+module.exports = __toCommonJS(Modify_exports);
+var import_JsonBuilder = require("../compilers/generator/JsonBuilder");
+var import_Log = require("../compilers/generator/Log");
+var import_CurrentLine = require("../compilers/reader/CurrentLine");
+var import_Object = require("../compilers/reader/Object");
+var import_ReadBinding = require("../compilers/reader/ReadBinding");
+var import_ReadProperties = require("../compilers/reader/ReadProperties");
+var import_Class = require("./Class");
+var import_Random = require("./Random");
+var import_UI = require("./UI");
+class Modify extends import_Class.Class {
+  constructor(properties, identifier) {
+    var _a, _b;
+    super();
+    __publicField(this, "properties", {});
+    __publicField(this, "controls");
+    __publicField(this, "bindings");
+    __publicField(this, "variables");
+    __publicField(this, "isValidPath");
+    __publicField(this, "name", "");
+    __publicField(this, "namespace", "");
+    __publicField(this, "modifyBindings");
+    __publicField(this, "removeModifyBindings");
+    __publicField(this, "modifyControls", {
+      remove: [],
+      replace: [],
+      insertBack: [],
+      insertFront: [],
+      insertAfter: [],
+      insertBefore: [],
+      moveAfter: [],
+      moveBack: [],
+      moveBefore: [],
+      moveFront: []
+    });
+    __publicField(this, "override", {
+      sourceBindings: {},
+      setProperties: (properties) => {
+        this.properties = {
+          ...this.properties,
+          ...properties
+        };
+        return this.override;
+      },
+      addChild: (element, properties, name, callback) => {
+        if (!element) {
+          this.controls || (this.controls = []);
+          return this.override;
+        }
+        if (!this.controls) this.controls = [];
+        name || (name = import_Random.Random.getName());
+        this.controls.push({
+          ["".concat(name, "@").concat(typeof element === "string" ? element.startsWith("@") ? element.slice(1) : element : element.getPath())]: properties ? (0, import_ReadProperties.ReadProperties)(properties) : {}
+        });
+        callback == null ? void 0 : callback(this, name);
+        return this.override;
+      },
+      addBindings: (bindings) => {
+        if (!bindings) {
+          this.bindings || (this.bindings = []);
+          return this.override;
+        }
+        if (Array.isArray(bindings))
+          for (const binding of bindings) this.override.addBindings(binding);
+        else (this.bindings || (this.bindings = [])).push((0, import_ReadBinding.ReadBinding)(bindings, this.override));
+        return this.override;
+      },
+      addVariables: (variables) => {
+        this.variables || (this.variables = {});
+        if (variables)
+          import_Object.Obj.forEach(variables, (key, value) => {
+            this.variables[key] = {
+              ...import_Object.Obj.map(value, (k, v) => {
+                return { key: k, value: (0, import_ReadProperties.ReadValue)(v) };
+              })
+            };
+          });
+        return this.override;
+      },
+      searchBinding: (bindingName, controlName, targetBindingName) => {
+        var _a, _b;
+        for (let index = 0; index < (((_a = this.bindings) == null ? void 0 : _a.length) || 0); index++) {
+          const binding = (_b = this.bindings) == null ? void 0 : _b[index];
+          if (controlName) {
+            if ((binding == null ? void 0 : binding.source_control_name) === controlName && binding.source_property_name === bindingName) {
+              if (targetBindingName) {
+                if (binding.target_property_name === targetBindingName) {
+                  return targetBindingName;
+                } else return void 0;
+              } else return binding.target_property_name;
+            }
+          } else {
+            if ((binding == null ? void 0 : binding.source_property_name) === bindingName) {
+              if (targetBindingName) {
+                if (binding.target_property_name === targetBindingName) {
+                  return targetBindingName;
+                } else return void 0;
+              } else return binding.target_property_name;
+            }
+          }
+        }
+        return void 0;
+      }
+    });
+    __publicField(this, "modify", {
+      bindings: {
+        remove: (bindings) => {
+          var _a, _b;
+          if (Array.isArray(bindings)) {
+            (_a = this.removeModifyBindings || (this.removeModifyBindings = [])) == null ? void 0 : _a.push(...bindings);
+          } else (_b = this.removeModifyBindings || (this.removeModifyBindings = [])) == null ? void 0 : _b.push(bindings);
+          return this.modify.bindings;
+        },
+        addBindings: (bindings) => {
+          if (Array.isArray(bindings))
+            bindings.forEach((binding) => this.modify.bindings.addBindings(binding));
+          else {
+            (this.modifyBindings || (this.modifyBindings = [])).push(
+              (0, import_ReadBinding.ReadBinding)(bindings, this.modify.bindings)
+            );
+          }
+          return this.modify.bindings;
+        }
+      },
+      controls: {
+        remove: (childName) => {
+          if (Array.isArray(childName)) this.modifyControls.remove.push(...childName);
+          else this.modifyControls.remove.push(childName);
+          return this.modify.controls;
+        },
+        moveAfter: (childName) => {
+          if (Array.isArray(childName)) this.modifyControls.moveAfter.push(...childName);
+          else this.modifyControls.moveAfter.push(childName);
+          return this.modify.controls;
+        },
+        moveBack: (childName) => {
+          if (Array.isArray(childName)) this.modifyControls.moveBack.push(...childName);
+          else this.modifyControls.moveBack.push(childName);
+          return this.modify.controls;
+        },
+        moveFront: (childName) => {
+          if (Array.isArray(childName)) this.modifyControls.moveFront.push(...childName);
+          else this.modifyControls.moveFront.push(childName);
+          return this.modify.controls;
+        },
+        moveBefore: (childName) => {
+          if (Array.isArray(childName)) this.modifyControls.moveBefore.push(...childName);
+          else this.modifyControls.moveBefore.push(childName);
+          return this.modify.controls;
+        },
+        replace: (childName, ui, properties, elementName) => {
+          this.modifyControls.replace.push([
+            childName,
+            {
+              ["".concat(elementName || import_Random.Random.getName(), "@").concat(typeof ui === "string" ? ui : ui.getPath())]: (0, import_ReadProperties.ReadProperties)(properties || {})
+            }
+          ]);
+          return this.modify.controls;
+        },
+        insertAfter: (childName, ui, properties, elementName) => {
+          this.modifyControls.insertAfter.push([
+            childName,
+            {
+              ["".concat(elementName || import_Random.Random.getName(), "@").concat(typeof ui === "string" ? ui : ui.getPath())]: (0, import_ReadProperties.ReadProperties)(properties || {})
+            }
+          ]);
+          return this.modify.controls;
+        },
+        insertBefore: (childName, ui, properties, elementName) => {
+          this.modifyControls.insertBefore.push([
+            childName,
+            {
+              ["".concat(elementName || import_Random.Random.getName(), "@").concat(typeof ui === "string" ? ui : ui.getPath())]: (0, import_ReadProperties.ReadProperties)(properties || {})
+            }
+          ]);
+          return this.modify.controls;
+        },
+        insertBack: (ui, properties, elementName) => {
+          this.modifyControls.insertBack.push({
+            ["".concat(elementName || import_Random.Random.getName(), "@").concat(typeof ui === "string" ? ui : ui.getPath())]: (0, import_ReadProperties.ReadProperties)(properties || {})
+          });
+          return this.modify.controls;
+        },
+        insertFront: (ui, properties, elementName) => {
+          this.modifyControls.insertFront.push({
+            ["".concat(elementName || import_Random.Random.getName(), "@").concat(typeof ui === "string" ? ui : ui.getPath())]: (0, import_ReadProperties.ReadProperties)(properties || {})
+          });
+          return this.modify.controls;
+        }
+      }
+    });
+    if (properties) this.override.setProperties(properties);
+    if (identifier && ((_b = (_a = identifier.name) == null ? void 0 : _a.match(/\w+/g)) == null ? void 0 : _b.length) === 1 && identifier.namespace)
+      this.isValidPath = true;
+    else this.isValidPath = false;
+    this.name = (identifier == null ? void 0 : identifier.name) || "";
+    this.namespace = (identifier == null ? void 0 : identifier.namespace) || "";
+  }
+  getPath() {
+    if (this.isValidPath) return "".concat(this.namespace, ".").concat(this.name);
+    else {
+      import_Log.Log.error("".concat((0, import_CurrentLine.CurrentLine)(), " Cannot use this element for extend or addChild!"));
+      return "";
+    }
+  }
+  getElement() {
+    return "@".concat(this.getPath());
+  }
+  extend(identifier, properties) {
+    return import_UI.UI.extend(this, properties, identifier);
+  }
+  getUI() {
+    const code = (0, import_ReadProperties.ReadProperties)(this.properties);
+    const modifications = [];
+    for (const key of ["type", "controls", "bindings", "button_mappings"])
+      if (this[key]) code[key] = this[key];
+    if (this.variables)
+      import_Object.Obj.forEach(this.variables, (k, v) => {
+        (code.variables || (code.variables = [])).push({
+          requires: k,
+          ...v
+        });
+      });
+    if (this.variables && Object.keys(this.variables).length === 0) code.variables || (code.variables = []);
+    {
+      if (this.modifyBindings) {
+        modifications.push({
+          array_name: "bindings",
+          operation: "insert_front",
+          value: this.modifyBindings
+        });
+      }
+      if (this.removeModifyBindings) {
+        modifications.push(
+          ...this.removeModifyBindings.map((v) => ({
+            array_name: "bindings",
+            operation: "remove",
+            where: v
+          }))
+        );
+      }
+    }
+    {
+      modifications.push(
+        ...this.modifyControls.remove.map((controlName) => ({
+          array_name: "controls",
+          operation: "remove",
+          control_name: controlName
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.moveAfter.map((controlName) => ({
+          array_name: "controls",
+          operation: "move_after",
+          control_name: controlName
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.moveBack.map((controlName) => ({
+          array_name: "controls",
+          operation: "move_back",
+          control_name: controlName
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.moveBefore.map((controlName) => ({
+          array_name: "controls",
+          operation: "move_before",
+          control_name: controlName
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.moveFront.map((controlName) => ({
+          array_name: "controls",
+          operation: "move_front",
+          control_name: controlName
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.replace.map(([childName, element]) => ({
+          array_name: "controls",
+          operation: "replace",
+          control_name: childName,
+          value: element
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.insertAfter.map(([childName, element]) => ({
+          array_name: "controls",
+          operation: "insert_after",
+          control_name: childName,
+          value: [element]
+        }))
+      );
+      modifications.push(
+        ...this.modifyControls.insertBefore.map(([childName, element]) => ({
+          array_name: "controls",
+          operation: "insert_before",
+          control_name: childName,
+          value: [element]
+        }))
+      );
+      if (this.modifyControls.insertBack.length)
+        modifications.push({
+          array_name: "controls",
+          operation: "insert_back",
+          value: this.modifyControls.insertBack
+        });
+      if (this.modifyControls.insertFront.length)
+        modifications.push({
+          array_name: "controls",
+          operation: "insert_front",
+          value: this.modifyControls.insertFront
+        });
+    }
+    if (modifications.length > 0) code["modifications"] = modifications;
+    for (const bindingKey in this.override.sourceBindings) {
+      const targetBinding = this.override.sourceBindings[bindingKey];
+      const [sourceBinding, sourceControl] = bindingKey.split(":");
+      code.bindings.push({
+        binding_type: "view",
+        source_control_name: sourceControl,
+        source_property_name: sourceBinding,
+        target_property_name: targetBinding
+      });
+    }
+    return Object.keys(code).length > 0 ? code : void 0;
+  }
+  addChild(element, properties, elementName) {
+    this.modify.controls.insertFront(element, properties, elementName);
+    return this;
+  }
+  static register(filePath, elementPath, properties) {
+    return this.registerWithNamespace(filePath, elementPath, "", properties);
+  }
+  static registerWithNamespace(filePath, elementPath, namespace, properties) {
+    var _a;
+    const modify = import_JsonBuilder.JsonBuilder.getModify(filePath, elementPath);
+    (_a = modify == null ? void 0 : modify.override) == null ? void 0 : _a.setProperties(properties || {});
+    return modify || import_JsonBuilder.JsonBuilder.registerModify(
+      filePath,
+      elementPath,
+      new Modify(properties, {
+        name: elementPath,
+        namespace
+      })
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Modify
+});

package/dist/cjs/components/Random.js

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Random_exports = {};
+__export(Random_exports, {
+  Random: () => Random
+});
+module.exports = __toCommonJS(Random_exports);
+var import_Class = require("./Class");
+var import_Config = require("../compilers/Config");
+const HEX = Array.from(
+  { length: 256 },
+  (_, i) => i.toString(16).toUpperCase().padStart(2, "0")
+);
+const CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
+const _Random = class _Random extends import_Class.Class {
+  static get uiConfig() {
+    var _a;
+    return (_a = this._uiConfig) != null ? _a : this._uiConfig = import_Config.Configs.getConfig().compiler.UI;
+  }
+  static get isObfuscate() {
+    return import_Config.Configs.getConfig().compiler.UI.obfuscateName;
+  }
+  static get uniqueKey() {
+    var _a;
+    return (_a = this._uniqueKey) != null ? _a : this._uniqueKey = _Random.genString(5, 16).toUpperCase();
+  }
+  static get prefix() {
+    return this.uniqueKey;
+  }
+  static genString(length, base = 32) {
+    const chars = CHARS.slice(0, base);
+    const out = new Array(length);
+    try {
+      const buffer = new Uint8Array(length);
+      crypto.getRandomValues(buffer);
+      for (let i = 0; i < length; i++) {
+        out[i] = chars[buffer[i] % base];
+      }
+    } catch (e) {
+      for (let i = 0; i < length; i++) {
+        out[i] = chars[Math.floor(Math.random() * base)];
+      }
+    }
+    return out.join("");
+  }
+  static getName(length = _Random.uiConfig.nameLength) {
+    if (_Random.isObfuscate) return _Random.genString(length);
+    const counter = ++_Random.counter.element;
+    return "".concat(_Random.prefix, "_ELEMENT_").concat(counter.toString(16).toUpperCase());
+  }
+  static getAnimationName(length = _Random.uiConfig.nameLength) {
+    if (_Random.isObfuscate) return _Random.genString(length);
+    const counter = ++_Random.counter.animation;
+    return "".concat(_Random.prefix, "_ANIMATION_").concat(counter.toString(16).toUpperCase());
+  }
+  static getNamespace() {
+    if (!_Random.namespaces) {
+      const { namespaceAmount, namespaceLength } = _Random.uiConfig;
+      _Random.namespaces = Array.from(
+        { length: namespaceAmount },
+        (_, index2) => _Random.isObfuscate ? _Random.genString(namespaceLength) : "".concat(_Random.prefix, "_NAMESPACE_").concat((index2 + 1).toString(16).toUpperCase())
+      );
+    }
+    const index = _Random.namespaceIndex++ % _Random.namespaces.length;
+    return _Random.namespaces[index];
+  }
+  static getUUID() {
+    const b = Array.from({ length: 16 }, () => Math.floor(Math.random() * 256));
+    return "".concat(HEX[b[0]]).concat(HEX[b[1]]).concat(HEX[b[2]]).concat(HEX[b[3]], "-").concat(HEX[b[4]]).concat(HEX[b[5]], "-").concat(HEX[b[6]]).concat(HEX[b[7]], "-").concat(HEX[b[8]]).concat(HEX[b[9]], "-").concat(HEX[b[10]]).concat(HEX[b[11]]).concat(HEX[b[12]]).concat(HEX[b[13]]).concat(HEX[b[14]]).concat(HEX[b[15]]);
+  }
+  static bindingName() {
+    if (_Random.isObfuscate) return "#".concat(_Random.genString(_Random.uiConfig.nameLength));
+    const counter = ++_Random.counter.binding;
+    return "#".concat(_Random.prefix, "_BINDING_").concat(counter.toString(16).toUpperCase());
+  }
+};
+__publicField(_Random, "namespaces");
+__publicField(_Random, "namespaceIndex", 0);
+__publicField(_Random, "_uiConfig");
+__publicField(_Random, "_uniqueKey");
+__publicField(_Random, "counter", { element: 0, animation: 0, binding: 0 });
+let Random = _Random;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Random
+});