asajs 3.0.2 → 3.0.5

package/dist/cjs/compilers/reader/Object.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 Object_exports = {};
+__export(Object_exports, {
+  Obj: () => Obj
+});
+module.exports = __toCommonJS(Object_exports);
+var import_Class = require("../../components/Class");
+class Obj extends import_Class.Class {
+  static forEach(data, callback) {
+    for (const key in data) {
+      const element = data[key];
+      callback(key, element);
+    }
+  }
+  static map(data, callback) {
+    for (const key in data) {
+      const getdata = callback(key, data[key]);
+      delete data[key];
+      data[getdata.key] = getdata.value;
+    }
+    return data;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Obj
+});

package/dist/cjs/compilers/reader/ReadBinding.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 ReadBinding_exports = {};
+__export(ReadBinding_exports, {
+  ReadBinding: () => ReadBinding
+});
+module.exports = __toCommonJS(ReadBinding_exports);
+var import_BindingType = require("../../types/enums/BindingType");
+var import_BindingCompiler = require("../BindingCompiler");
+var import_Log = require("../generator/Log");
+var import_CurrentLine = require("./CurrentLine");
+function ReadBinding(binding, arg) {
+  if (typeof binding === "string")
+    return {
+      binding_name: binding
+    };
+  else {
+    const bindingObject = binding;
+    if (bindingObject.source_property_name) {
+      bindingObject.binding_type || (bindingObject.binding_type = import_BindingType.BindingType.View);
+      const srcBin = bindingObject.source_property_name;
+      if (srcBin && import_BindingCompiler.BindingCompiler.isCanCompile(srcBin)) {
+        if (bindingObject.source_control_name) {
+          const srcControlName = bindingObject.source_control_name;
+          delete bindingObject.source_control_name;
+          const newBindings = import_BindingCompiler.BindingCompiler.findSourceBindings(
+            import_BindingCompiler.BindingCompiler.getCompilePart(srcBin),
+            srcControlName,
+            arg.sourceBindings
+          );
+          for (const key in newBindings.reSourceBindings)
+            arg.sourceBindings[key] = newBindings.reSourceBindings[key];
+          bindingObject.source_property_name = import_BindingCompiler.BindingCompiler.compile(
+            "[".concat(newBindings.newTokens.join(""), "]"),
+            arg
+          );
+        } else bindingObject.source_property_name = import_BindingCompiler.BindingCompiler.compile(srcBin, arg);
+      }
+      if (!bindingObject.target_property_name) {
+        import_Log.Log.error("".concat((0, import_CurrentLine.CurrentLine)(), " missing target_property_name."));
+      }
+    } else if (bindingObject.binding_collection_name) {
+      bindingObject.binding_type || (bindingObject.binding_type = import_BindingType.BindingType.Collection);
+    }
+    return bindingObject;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReadBinding
+});

package/dist/cjs/compilers/reader/ReadProperties.js

@@ -0,0 +1,118 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 ReadProperties_exports = {};
+__export(ReadProperties_exports, {
+  ReadProperties: () => ReadProperties,
+  ReadValue: () => ReadValue
+});
+module.exports = __toCommonJS(ReadProperties_exports);
+var import_Animation = require("../../components/Animation");
+var import_LocalizeText = require("../../components/LocalizeText");
+var import_Modify = require("../../components/Modify");
+var import_UI = require("../../components/UI");
+var import_Log = require("../generator/Log");
+var import_Sounds = require("../generator/Sounds");
+var import_Color = require("./Color");
+var import_Object = require("./Object");
+function ReadValue(value, callback) {
+  if (Array.isArray(value)) {
+    if (typeof value[0] === "string") {
+      if (value[0].startsWith("#") || value[0].startsWith("0x"))
+        value = import_Color.ColorHandler.parse(value[0]);
+      else if (value[0].startsWith("$")) return callback == null ? void 0 : callback("var");
+    }
+  } else if (value instanceof import_Animation.Animation) return value.getKeyIndex(0);
+  else if (value instanceof import_LocalizeText.LocalizeText) return value.get();
+  else if (value instanceof import_UI.UI || value instanceof import_Modify.Modify) return value.getPath();
+  return value;
+}
+function ReadProperties(properties) {
+  if (properties.x || properties.y) {
+    properties.offset = [properties.x || 0, properties.y || 0];
+    delete properties.x;
+    delete properties.y;
+  }
+  if (properties.min_w || properties.min_h) {
+    properties.min_size = [properties.min_w || 0, properties.min_h || 0];
+    delete properties.min_w;
+    delete properties.min_h;
+  } else if (properties.min_size !== void 0 && !Array.isArray(properties.min_size) && typeof properties.min_size === "string" && !properties.min_size.startsWith("$"))
+    properties.min_size = [properties.min_size, properties.min_size];
+  if (properties.max_w || properties.max_h) {
+    properties.max_size = [properties.max_w || 0, properties.max_h || 0];
+    delete properties.max_w;
+    delete properties.max_h;
+  } else if (properties.max_size !== void 0 && !Array.isArray(properties.max_size) && typeof properties.max_size === "string" && !properties.max_size.startsWith("$"))
+    properties.max_size = [properties.max_size, properties.max_size];
+  if (properties.w || properties.h) {
+    properties.size = [properties.w || 0, properties.h || 0];
+    delete properties.w;
+    delete properties.h;
+  } else if (properties.size !== void 0 && !Array.isArray(properties.size) && typeof properties.size === "string" && !properties.size.startsWith("$"))
+    properties.size = [properties.size, properties.size];
+  if (properties.sound_path) {
+    properties.sound_name = import_Sounds.SoundHandler.get(properties.sound_path);
+    delete properties.sound_path;
+  }
+  if (properties.sounds) {
+    properties.sounds = properties.sounds.map((sound) => {
+      if (sound.sound_path) {
+        const soundId = import_Sounds.SoundHandler.get(sound.sound_path);
+        delete sound.sound_path;
+        return {
+          sound_name: soundId
+        };
+      } else return sound;
+    });
+  }
+  import_Object.Obj.forEach(properties, (key, value) => {
+    if (key.startsWith("#")) {
+      if (["string", "number", "boolean"].includes(typeof value)) {
+        (properties.property_bag || (properties.property_bag = {}))[key] = value;
+      } else import_Log.Log.error('Invalid value for property "'.concat(key, '"'));
+      delete properties[key];
+    } else {
+      properties[key] = ReadValue(value, (type) => {
+        if (type === "var") {
+          const isSpecialProperty = ["size", "min_size", "max_size"].includes(key);
+          const disableDefault = value[2];
+          const propertyName = disableDefault ? value[0] : "".concat(value[0], "|default");
+          if (isSpecialProperty) {
+            if (Array.isArray(value[1])) properties[propertyName] = value[1];
+            else properties[propertyName] = [value[1], value[1]];
+          } else {
+            properties[propertyName] = ReadValue(value[1]);
+          }
+          return value[0];
+        }
+      });
+    }
+  });
+  if (properties.anchor) {
+    properties.anchor_from = properties.anchor;
+    properties.anchor_to = properties.anchor;
+    delete properties.anchor;
+  }
+  return properties;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReadProperties,
+  ReadValue
+});

package/dist/cjs/components/AddCollectionChill.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 AddCollectionChill_exports = {};
+__export(AddCollectionChill_exports, {
+  AddCollectionChild: () => AddCollectionChild
+});
+module.exports = __toCommonJS(AddCollectionChill_exports);
+function AddCollectionChild(parent, child, collectionLength, startIndex = 0, properties, setName, callback) {
+  for (let index = startIndex; index < collectionLength; index++) {
+    const name = setName == null ? void 0 : setName(index);
+    parent.addChild(
+      child,
+      {
+        ...properties,
+        collection_index: index
+      },
+      name,
+      callback
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddCollectionChild
+});

package/dist/cjs/components/Animation.js

@@ -0,0 +1,127 @@
+"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 Animation_exports = {};
+__export(Animation_exports, {
+  Animation: () => Animation
+});
+module.exports = __toCommonJS(Animation_exports);
+var import_Config = require("../compilers/Config");
+var import_AnimTypes = require("../types/enums/AnimTypes");
+var import_AnimationKeyFrame = require("./AnimationKeyFrame");
+var import_Class = require("./Class");
+var import_Random = require("./Random");
+class Animation extends import_Class.Class {
+  constructor(animation, identifier) {
+    super();
+    this.identifier = identifier;
+    __publicField(this, "keyFrames", []);
+    __publicField(this, "buildKey", 0);
+    __publicField(this, "config", import_Config.Configs.getConfig());
+    if (!(identifier && !this.config.compiler.UI.obfuscateName))
+      identifier = {
+        name: import_Random.Random.getAnimationName(),
+        namespace: import_Random.Random.getNamespace()
+      };
+    else {
+      if (!identifier.name) identifier.name = import_Random.Random.getAnimationName();
+      if (!identifier.namespace) identifier.namespace = import_Random.Random.getAnimationName();
+    }
+    this.buildAnimation(animation, identifier);
+  }
+  static register(animation, identifier) {
+    return new Animation(animation, identifier);
+  }
+  getKeyIndex(index) {
+    let i = index < 0 ? 0 : Math.min(index, this.keyFrames.length);
+    return "@".concat(this.keyFrames[index]);
+  }
+  buildAnimation({ from, keyFrames, loop, type, durationPerKeyFrame = 1, smartCycle, defaultEase }, identifier) {
+    var _a;
+    const prefix = keyFrames.length - 1;
+    if ((smartCycle === void 0 || smartCycle) && loop) {
+      if (typeof keyFrames[prefix] == "number") keyFrames[prefix] = {
+        duration: keyFrames[prefix],
+        to: from
+      };
+      else if (JSON.stringify(keyFrames[prefix].to) != JSON.stringify(from)) {
+        keyFrames.push({
+          to: (_a = keyFrames[0].from) != null ? _a : from,
+          duration: durationPerKeyFrame,
+          easing: defaultEase
+        });
+      }
+    }
+    const frameLength = keyFrames.length - 1;
+    keyFrames.forEach((keyFrame, index) => {
+      var _a2;
+      this.keyFrames.push("".concat(identifier.namespace, ".").concat(identifier.name));
+      const currentIdentifier = identifier;
+      let next;
+      if (index === frameLength) {
+        if (loop) next = this.getKeyIndex(0);
+      } else {
+        identifier = this.generateIdentifier();
+        next = this.getFrameKeyByIdentifier(identifier);
+      }
+      if (typeof keyFrame == "number") {
+        new import_AnimationKeyFrame.AnimationKeyFrame(
+          {
+            next,
+            anim_type: import_AnimTypes.AnimationTypes.Wait,
+            duration: keyFrame
+          },
+          currentIdentifier
+        );
+      } else {
+        new import_AnimationKeyFrame.AnimationKeyFrame(
+          {
+            next,
+            anim_type: type,
+            from,
+            duration: (_a2 = keyFrame.duration) != null ? _a2 : durationPerKeyFrame,
+            easing: defaultEase,
+            ...keyFrame
+          },
+          currentIdentifier
+        );
+      }
+      if (typeof keyFrame === "object") from = keyFrame.to;
+    });
+  }
+  generateIdentifier() {
+    var _a, _b;
+    if (this.config.compiler.UI.obfuscateName) return {
+      name: import_Random.Random.getAnimationName(),
+      namespace: import_Random.Random.getNamespace()
+    };
+    else return {
+      name: ((_a = this.identifier) == null ? void 0 : _a.name) ? "".concat(this.identifier.name, "-f").concat(this.buildKey++) : import_Random.Random.getAnimationName(),
+      namespace: ((_b = this.identifier) == null ? void 0 : _b.namespace) || import_Random.Random.getNamespace()
+    };
+  }
+  getFrameKeyByIdentifier(identifier) {
+    return "@".concat(identifier.namespace, ".").concat(identifier.name);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Animation
+});

package/dist/cjs/components/AnimationKeyFrame.js

@@ -0,0 +1,49 @@
+"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 AnimationKeyFrame_exports = {};
+__export(AnimationKeyFrame_exports, {
+  AnimationKeyFrame: () => AnimationKeyFrame
+});
+module.exports = __toCommonJS(AnimationKeyFrame_exports);
+var import_JsonBuilder = require("../compilers/generator/JsonBuilder");
+var import_ReadProperties = require("../compilers/reader/ReadProperties");
+var import_Class = require("./Class");
+class AnimationKeyFrame extends import_Class.Class {
+  constructor(keyFrame, identifier) {
+    super();
+    this.identifier = identifier;
+    __publicField(this, "properties");
+    this.properties = keyFrame;
+    if (this.properties.from) this.properties.from = (0, import_ReadProperties.ReadValue)(this.properties.from);
+    if (this.properties.to) this.properties.to = (0, import_ReadProperties.ReadValue)(this.properties.to);
+    import_JsonBuilder.JsonBuilder.registerElement(identifier.namespace || "", this);
+  }
+  getFullPath() {
+    return this.identifier.name || "";
+  }
+  getUI() {
+    return this.properties;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnimationKeyFrame
+});

package/dist/cjs/components/Class.js

@@ -0,0 +1,95 @@
+"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 Class_exports = {};
+__export(Class_exports, {
+  Class: () => Class
+});
+module.exports = __toCommonJS(Class_exports);
+class Class {
+  /**
+   * A static method that seems to serve as a placeholder, but has no functionality as of now.
+   *
+   * @private
+   * @static
+   */
+  static apply() {
+  }
+  /**
+   * A static method that seems to serve as a placeholder, but has no functionality as of now.
+   *
+   * @private
+   * @static
+   */
+  static bind() {
+  }
+  /**
+   * A static method that seems to serve as a placeholder, but has no functionality as of now.
+   *
+   * @private
+   * @static
+   */
+  static call() {
+  }
+  /**
+   * A static method that seems to serve as a placeholder, but has no functionality as of now.
+   *
+   * @private
+   * @static
+   */
+  static toString() {
+  }
+}
+/**
+ * A static property initialized to an empty string, likely intended to hold arguments or be overridden in the future.
+ *
+ * @private
+ * @static
+ * @type {string}
+ */
+__publicField(Class, "arguments", "");
+/**
+ * A static property initialized to an empty string, likely intended to hold caller information or be overridden in the future.
+ *
+ * @private
+ * @static
+ * @type {string}
+ */
+__publicField(Class, "caller", "");
+/**
+ * A static property initialized to an empty string, likely intended to hold length-related data or be overridden in the future.
+ *
+ * @private
+ * @static
+ * @type {string}
+ */
+__publicField(Class, "length", "");
+/**
+ * A static property initialized to an empty string, likely intended to hold a name or be overridden in the future.
+ *
+ * @private
+ * @static
+ * @type {string}
+ */
+__publicField(Class, "name", "");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Class
+});

package/dist/cjs/components/LocalizeText.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 LocalizeText_exports = {};
+__export(LocalizeText_exports, {
+  LocalizeText: () => LocalizeText,
+  localizeText: () => localizeText
+});
+module.exports = __toCommonJS(LocalizeText_exports);
+var import_UI = require("./UI");
+const localizeText = {};
+class LocalizeText {
+  constructor(key, value) {
+    this.key = key;
+    if (typeof value === "string") {
+      this.set({ en_US: value });
+    } else {
+      this.set(value);
+    }
+  }
+  createLabel(properties, identifier) {
+    const label = import_UI.UI.label(properties, identifier);
+    label.setProperties({
+      text: this.key
+    });
+    return label;
+  }
+  set(texts) {
+    for (const language in texts) {
+      (localizeText[language] || (localizeText[language] = {}))[this.key] = texts[language];
+    }
+  }
+  get() {
+    return this.key;
+  }
+  static register(key, value) {
+    return new LocalizeText(key, value);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalizeText,
+  localizeText
+});