asajs 4.2.0 → 5.0.0-indev-0

package/dist/js/{compilers → compiler}/FormatProperties.js

@@ -1,6 +1,4 @@
-import { AnimationKeyframe } from "../components/AnimationKeyframe.js";
-import { BagBinding } from "../types/enums/BagBinding.js";
-import { config } from "./Configuration.js";
+import { AnimationKeyframe } from "../components/ui/AnimationKeyframe.js";
 export function FormatProperties(properties) {
     const property_bag = {};
     for (const key in properties) {
@@ -25,9 +23,6 @@ export function FormatProperties(properties) {
             }
         }
     }
-    if (config.compiler?.fixInventoryItemRenderer && property_bag[BagBinding.ITEM_ID_AUX]) {
-        property_bag[BagBinding.ITEM_ID_AUX] = `(${property_bag[BagBinding.ITEM_ID_AUX]} / 1)`;
-    }
     if (properties.anchor) {
         properties.anchor_from = properties.anchor_to = properties.anchor;
         delete properties.anchor;

package/dist/js/compiler/builder.js

@@ -0,0 +1,27 @@
+import { storage } from "./storage.js";
+import fs from "fs/promises";
+import path from "path";
+import { Cache } from "./cache.js";
+let isFirstRun = true;
+process.on("beforeExit", async () => {
+    if (isFirstRun) {
+        isFirstRun = false;
+        await Promise.all(Cache.get("build_files").map(async (file) => {
+            await fs.rm(path.resolve(file)).catch(() => { });
+        }) || []).then(v => {
+            if (v.length) {
+                console.log(`Removed ${v.length} build files.`);
+            }
+        });
+        Cache.set("build_files", await Promise.all(storage.entries().map(async ([file, builder]) => {
+            const fullpath = path.resolve(file);
+            const dirname = path.dirname(fullpath);
+            await fs.stat(dirname).catch(async () => await fs.mkdir(dirname, { recursive: true }));
+            await fs.writeFile(fullpath, builder.build());
+            storage.delete(fullpath);
+            return file;
+        })));
+        await Cache.save();
+    }
+});
+//# sourceMappingURL=builder.js.map

package/dist/js/compiler/cache.js

@@ -0,0 +1,18 @@
+import fs from "fs/promises";
+import _fs from "fs";
+import path from "path";
+export class Cache {
+    static cache = _fs.existsSync(path.join("build", "cache.json"))
+        ? JSON.parse(_fs.readFileSync(path.join("build", "cache.json"), "utf-8"))
+        : {};
+    static set(key, value) {
+        this.cache[key] = value;
+    }
+    static get(key) {
+        return this.cache[key];
+    }
+    static async save() {
+        await fs.writeFile(path.resolve(path.join("build", "cache.json")), JSON.stringify(this.cache));
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/js/compiler/properties.js

@@ -0,0 +1,50 @@
+import { AnimationKeyframe } from "../components/ui/AnimationKeyframe.js";
+export function FormatProperties(properties) {
+    const property_bag = {};
+    for (const key in properties) {
+        const value = properties[key];
+        if (key.startsWith("#")) {
+            property_bag[key] = value;
+            delete properties[key];
+        }
+        if (key.startsWith("$")) {
+            const [varName, varType] = key.split("|");
+            if (!varType)
+                break;
+            switch (varType) {
+                case "d":
+                    properties[`${varName}|default`] = value;
+                    delete properties[key];
+                    break;
+                case "default":
+                    break;
+                default:
+                    throw new Error("Invalid variable type");
+            }
+        }
+    }
+    if (properties.anchor) {
+        properties.anchor_from = properties.anchor_to = properties.anchor;
+        delete properties.anchor;
+    }
+    if (properties.fit_to_width) {
+        properties["$fit_to_width"] = properties.fit_to_width;
+        delete properties.fit_to_width;
+    }
+    if (Object.keys(property_bag).length) {
+        if (properties.property_bag) {
+            properties.property_bag = { ...property_bag, ...properties.property_bag };
+        }
+        else {
+            properties.property_bag = property_bag;
+        }
+    }
+    return properties;
+}
+export function FormatAnimationProperties(properties) {
+    if (properties.next instanceof AnimationKeyframe) {
+        properties.next = `${properties.next}`;
+    }
+    return properties;
+}
+//# sourceMappingURL=properties.js.map

package/dist/js/compiler/storage.js

@@ -0,0 +1,2 @@
+export const storage = new Map();
+//# sourceMappingURL=storage.js.map

package/dist/js/compiler/ui/animstorage.js

@@ -0,0 +1,9 @@
+import { JsonBuilder } from "../../components/builder/JsonBuilder.js";
+export const storage = new Map();
+export class AnimStorage extends JsonBuilder {
+    constructor(namespace) {
+        super(namespace);
+    }
+    toJSON() { }
+}
+//# sourceMappingURL=animstorage.js.map

package/dist/js/{compilers → compiler/ui}/bindings/Binary.js

@@ -1,8 +1,8 @@
-import { RandomBindingString } from "../../components/Utils.js";
+import { GetRandomBindingString } from "../../../utils/Random.js";
 import { defaultFunctions } from "./Function.js";
 export function intToBin(input) {
     const { abs, negabs } = defaultFunctions;
-    const ret = RandomBindingString();
+    const ret = GetRandomBindingString();
     const bindings = [];
     // negative bit
     bindings.push({
@@ -15,7 +15,7 @@ export function intToBin(input) {
     };
 }
 export function binToInt(input) {
-    const ret = RandomBindingString();
+    const ret = GetRandomBindingString();
     const bindings = [];
     const nevBind = (input + "0");
     // Is reverse to positive

package/dist/js/{compilers → compiler/ui}/bindings/Function.js

@@ -1,6 +1,5 @@
-import { bs, RandomBindingString, RandomString, ResolveBinding, vs } from "../../components/Utils.js";
-import { bindingFuntions } from "../Configuration.js";
-import { isBinding, isNumber, isString, isVariable } from "./Checker.js";
+import { GetRandomBindingString, GetRandomString } from "../../../utils/Random.js";
+import { isBinding, isNumber, isString } from "./Checker.js";
 export const FunctionMap = new Map();
 export const defaultFunctions = {
     /**
@@ -9,7 +8,7 @@ export const defaultFunctions = {
      * @returns
      */
     abs: number => {
-        const randomBinding = RandomBindingString();
+        const randomBinding = GetRandomBindingString();
         return {
             genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
             value: randomBinding,
@@ -21,7 +20,7 @@ export const defaultFunctions = {
      * @returns
      */
     negabs: number => {
-        const randomBinding = RandomBindingString();
+        const randomBinding = GetRandomBindingString();
         return {
             genBindings: [{ source: `((-1 + (${number} < 0) * 2) * ${number})`, target: randomBinding }],
             value: randomBinding,
@@ -33,18 +32,18 @@ export const defaultFunctions = {
      * @returns
      */
     new: expression => {
-        const randomBinding = RandomBindingString();
+        const randomBinding = GetRandomBindingString();
         return {
             genBindings: [{ source: expression, target: randomBinding }],
             value: randomBinding,
         };
     },
     sqrt: input => {
-        const ret = RandomBindingString();
-        const isNegative = RandomBindingString();
-        const isLowerThanTwo = RandomBindingString();
-        const next = RandomBindingString();
-        const nextEqualOrGreaterThan = RandomBindingString();
+        const ret = GetRandomBindingString();
+        const isNegative = GetRandomBindingString();
+        const isLowerThanTwo = GetRandomBindingString();
+        const next = GetRandomBindingString();
+        const nextEqualOrGreaterThan = GetRandomBindingString();
         const isNextEqualOrGreaterThanRet = `(${nextEqualOrGreaterThan} * ${ret})`;
         const isNotNextEqualOrGreaterThanRet = `((not ${nextEqualOrGreaterThan}) * ${next})`;
         const lowerThanTwoPart = `(${isLowerThanTwo} * ${input})`;
@@ -97,8 +96,8 @@ export const defaultFunctions = {
     strlen: str => {
         if (!/\#\w+/.test(str))
             throw new Error("Invalid string");
-        const count = RandomBindingString();
-        const inputStr = RandomBindingString();
+        const count = GetRandomBindingString();
+        const inputStr = GetRandomBindingString();
         return {
             genBindings: [
                 {
@@ -128,7 +127,7 @@ export const defaultFunctions = {
         };
     },
     starts_with: (source_str, start_str) => {
-        const prefix = `'asajs:${RandomString(5)}:'`;
+        const prefix = `'asajs:${GetRandomString()}:'`;
         if (isString(source_str)) {
             if (isString(start_str)) {
                 return {
@@ -137,7 +136,7 @@ export const defaultFunctions = {
             }
             else {
                 source_str = prefix.slice(0, -1) + source_str.slice(1);
-                const start_str_bind = RandomBindingString();
+                const start_str_bind = GetRandomBindingString();
                 return {
                     genBindings: [
                         {
@@ -157,8 +156,8 @@ export const defaultFunctions = {
                 };
             }
             else {
-                const source_str_bind = RandomBindingString();
-                const start_str_bind = RandomBindingString();
+                const source_str_bind = GetRandomBindingString();
+                const start_str_bind = GetRandomBindingString();
                 return {
                     genBindings: [
                         {
@@ -176,10 +175,10 @@ export const defaultFunctions = {
         }
     },
     str_slice: (str, start, end) => {
-        const prefix = `'asajs:${RandomString(5)}:'`;
+        const prefix = `'asajs:${GetRandomString()}:'`;
         const genStrBinds = {
             source: ``,
-            target: RandomBindingString(),
+            target: GetRandomBindingString(),
         };
         if (isBinding(str))
             genStrBinds.source = `(${prefix} + ${str})`;
@@ -202,7 +201,7 @@ export const defaultFunctions = {
                 throw new Error("Invalid end");
             const sliceEnd = {
                 source: `(${end} * ${genStrBinds.target})`,
-                target: RandomBindingString(),
+                target: GetRandomBindingString(),
             };
             return {
                 genBindings: [genStrBinds, sliceEnd],
@@ -216,22 +215,6 @@ export const defaultFunctions = {
             };
         }
     },
-    bs: input_binding => {
-        if (!isBinding(input_binding))
-            throw new Error("Invalid input binding");
-        return {
-            doNotAddParentesis: true,
-            value: bs(input_binding),
-        };
-    },
-    vs: input_variable => {
-        if (!isVariable(input_variable))
-            throw new Error("Invalid input binding");
-        return {
-            doNotAddParentesis: true,
-            value: vs(input_variable),
-        };
-    },
     /**
      * Return a translatable string
      * @param key
@@ -262,7 +245,7 @@ export const defaultFunctions = {
      * @returns
      */
     bind: (value, bait) => {
-        const ret = RandomBindingString();
+        const ret = GetRandomBindingString();
         if (!bait) {
             throw new Error("Bait is required");
         }
@@ -277,7 +260,7 @@ export const defaultFunctions = {
      * @returns
      */
     int: input => {
-        const ret = RandomBindingString();
+        const ret = GetRandomBindingString();
         return {
             genBindings: [{ source: `${input}`, target: ret }],
             value: ret,
@@ -285,24 +268,4 @@ export const defaultFunctions = {
     },
 };
 Object.entries(defaultFunctions).forEach(([key, value]) => FunctionMap.set(key, value));
-if (bindingFuntions)
-    Object.entries(bindingFuntions).forEach(([key, value]) => {
-        // @ts-ignore
-        FunctionMap.set(key, (...args) => {
-            const { generate_bindings, return_value } = value(...args);
-            if (generate_bindings) {
-                const resolve = ResolveBinding(new Map(), ...generate_bindings);
-                return {
-                    genBindings: resolve.map(({ source_property_name, target_property_name }) => ({
-                        source: source_property_name,
-                        target: target_property_name,
-                    })),
-                    value: return_value,
-                };
-            }
-            return {
-                value: return_value,
-            };
-        });
-    });
 //# sourceMappingURL=Function.js.map

package/dist/js/{compilers → compiler/ui}/bindings/Parser.js

@@ -1,9 +1,9 @@
 import { TokenKind, TSTokenKind } from "./types.js";
-import { BindingType } from "../../types/enums/BindingType.js";
 import { FunctionMap } from "./Function.js";
 import { Lexer } from "./Lexer.js";
-import { RandomBindingString } from "../../components/Utils.js";
 import { isHasBinding } from "./Checker.js";
+import { GetRandomBindingString } from "../../../utils/Random.js";
+import { BindingType } from "../../../types/ui/enums/BindingType.js";
 export class Parser {
     input;
     cache;
@@ -28,7 +28,7 @@ export class Parser {
     }
     static intToBin(input) {
         const bindings = [];
-        const rtn = RandomBindingString();
+        const rtn = GetRandomBindingString();
         for (let i = 0; i < 30; i++) {
             bindings.push({
                 source: `(${input} / ${2 ** i} - (${input} / ${2 ** (i + 1)}) * 2)`,
@@ -77,7 +77,7 @@ export class Parser {
                 this.expect(TokenKind.OPERATOR, "Unexpected token!");
             let leftBind, middleBind, rightBind;
             if (isHasBinding(left)) {
-                leftBind = RandomBindingString();
+                leftBind = GetRandomBindingString();
                 this.genBindings.push({
                     source: `((0 + ${left}) > 0)`,
                     target: leftBind,
@@ -86,7 +86,7 @@ export class Parser {
             else
                 this.expect(TokenKind.WORD, "Unexpected token!");
             if (isHasBinding(middle)) {
-                middleBind = RandomBindingString();
+                middleBind = GetRandomBindingString();
                 this.genBindings.push({
                     source: middle,
                     target: middleBind,
@@ -95,7 +95,7 @@ export class Parser {
             else
                 this.expect(TokenKind.WORD, "Unexpected token!");
             if (isHasBinding(right)) {
-                rightBind = RandomBindingString();
+                rightBind = GetRandomBindingString();
                 this.genBindings.push({
                     source: right,
                     target: rightBind,
@@ -173,7 +173,7 @@ export class Parser {
                 if (this.cache.has(cacheStr)) {
                     return (left = this.cache.get(cacheStr));
                 }
-                const ret = RandomBindingString();
+                const ret = GetRandomBindingString();
                 this.genBindings.push({
                     source: `(${left} - (${left} / ${right} * ${right}))`,
                     target: ret,

package/dist/js/compiler/ui/initstorate.js

@@ -0,0 +1,21 @@
+import { JsonBuilder } from "../../components/builder/JsonBuilder.js";
+import path from "path";
+export const storage = new Map();
+export class InitStorage extends JsonBuilder {
+    file;
+    uiMap = new Map();
+    constructor(file) {
+        file = path.join("resoucepack", file);
+        super(file);
+        this.file = file;
+    }
+    add(key, ui) {
+        if (this.uiMap.has(key))
+            throw new Error("UI already exists");
+        this.uiMap.set(key, ui);
+    }
+    get() {
+        return Object.fromEntries(this.uiMap.entries());
+    }
+}
+//# sourceMappingURL=initstorate.js.map

package/dist/js/compiler/ui/modifystorage.js

@@ -0,0 +1,26 @@
+import { InitStorage, storage } from "./initstorate.js";
+export function GetModifyStorage(file) {
+    const $ = storage.get(file);
+    if ($) {
+        if ($.isUI)
+            throw new Error(`${file} is not a Modify file`);
+        else {
+            return $;
+        }
+    }
+    else {
+        const modify = new ModifyStorage(file);
+        storage.set(file, modify);
+        return modify;
+    }
+}
+class ModifyStorage extends InitStorage {
+    isUI = false;
+    constructor(file) {
+        super(file);
+    }
+    toJSON() {
+        return this.get();
+    }
+}
+//# sourceMappingURL=modifystorage.js.map

package/dist/js/compiler/ui/resolve.js

@@ -0,0 +1,85 @@
+import { BindingType } from "../../types/ui/enums/BindingType.js";
+import { GetRandomBindingString } from "../../utils/Random.js";
+import { isCompileBinding } from "./bindings/Checker.js";
+import { Lexer } from "./bindings/Lexer.js";
+import { Parser } from "./bindings/Parser.js";
+import { TokenKind, TSTokenKind } from "./bindings/types.js";
+export function ResolveBinding(cache, ...bindings) {
+    const result = [];
+    for (const binding of bindings) {
+        if (binding.source_property_name) {
+            if (isCompileBinding(binding.source_property_name)) {
+                const inputBindings = binding.source_property_name.slice(1, -1);
+                if (binding.source_control_name) {
+                    // @ts-ignore
+                    const tokensMapping = (token) => {
+                        if (token.kind === TokenKind.VARIABLE) {
+                            const mapkey = `mapping:${binding.source_control_name}:${token.value}`;
+                            if (cache.has(mapkey)) {
+                                return {
+                                    ...token,
+                                    value: cache.get(mapkey),
+                                };
+                            }
+                            else {
+                                const ret = GetRandomBindingString();
+                                cache.set(mapkey, ret);
+                                result.push({
+                                    source_property_name: token.value,
+                                    source_control_name: binding.source_control_name,
+                                    target_property_name: ret,
+                                    binding_type: BindingType.VIEW,
+                                });
+                                return {
+                                    ...token,
+                                    value: ret,
+                                };
+                            }
+                        }
+                        else if (token.kind === TokenKind.TEMPLATE_STRING) {
+                            return {
+                                ...token,
+                                // @ts-ignore
+                                value: token.value.map((tstoken) => {
+                                    if (tstoken.kind === TSTokenKind.STRING)
+                                        return tstoken;
+                                    else {
+                                        return {
+                                            ...tstoken,
+                                            tokens: tstoken.tokens.map(tokensMapping),
+                                        };
+                                    }
+                                }),
+                            };
+                        }
+                        else
+                            return token;
+                    };
+                    const { gen, out } = new Parser(inputBindings, cache, Lexer(inputBindings).map(tokensMapping)).out();
+                    delete binding.source_control_name;
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
+                else {
+                    const { gen, out } = new Parser(inputBindings, cache).out();
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
+            }
+            binding.binding_type ||= BindingType.VIEW;
+            if (!binding.target_property_name)
+                throw new Error("Binding must have a target property name");
+        }
+        else if (binding.binding_collection_name) {
+            if (Object.keys(binding).length > 1)
+                binding.binding_type ||= BindingType.COLLECTION;
+            else
+                binding.binding_type ||= BindingType.COLLECTION_DETAILS;
+        }
+        result.push(binding);
+    }
+    return result;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/js/compiler/ui/uidefs.js

@@ -0,0 +1,23 @@
+import path from "path";
+import { JsonBuilder } from "../../components/builder/JsonBuilder.js";
+export class UIDefs extends JsonBuilder {
+    static instance;
+    static getInstance() {
+        if (!UIDefs.instance)
+            UIDefs.instance = new UIDefs();
+        return UIDefs.instance;
+    }
+    set = new Set();
+    constructor() {
+        super(path.join("resoucepack", "ui", "ui_defs.json"));
+    }
+    add(filepath) {
+        this.set.add(filepath.replaceAll("\\", "/"));
+    }
+    toJSON() {
+        return {
+            _ui_defs: Array.from(this.set),
+        };
+    }
+}
+//# sourceMappingURL=uidefs.js.map

package/dist/js/compiler/ui/uistorage.js

@@ -0,0 +1,37 @@
+import { InitStorage, storage } from "./initstorate.js";
+import { UIDefs } from "./uidefs.js";
+export function GetUIStorage(namespace, file) {
+    const $ = storage.get(file);
+    if ($) {
+        if ($.isUI) {
+            const $ui = $;
+            if ($ui.namespace === namespace)
+                return $ui;
+            else
+                throw new Error("UI already exists");
+        }
+        else
+            throw new Error(`${file} is not a UI file`);
+    }
+    else {
+        const ui = new UIStorage(namespace, file);
+        storage.set(file, ui);
+        return ui;
+    }
+}
+class UIStorage extends InitStorage {
+    namespace;
+    isUI = true;
+    constructor(namespace, file) {
+        super(file);
+        this.namespace = namespace;
+        UIDefs.getInstance().add(file);
+    }
+    toJSON() {
+        return {
+            namespace: this.namespace,
+            ...this.get(),
+        };
+    }
+}
+//# sourceMappingURL=uistorage.js.map

package/dist/js/components/builder/Builder.js

@@ -0,0 +1,10 @@
+import path from "path";
+import { storage } from "../../compiler/storage.js";
+export class Builder {
+    path;
+    constructor(filepath) {
+        this.path = path.join("build", filepath);
+        storage.set(this.path, this);
+    }
+}
+//# sourceMappingURL=Builder.js.map

package/dist/js/components/builder/JsonBuilder.js

@@ -0,0 +1,12 @@
+import { Builder } from "./Builder.js";
+export class JsonBuilder extends Builder {
+    file;
+    constructor(file) {
+        super(file);
+        this.file = file;
+    }
+    build() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+//# sourceMappingURL=JsonBuilder.js.map

package/dist/js/components/builder/UIDefs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UIDefs.js.map

package/dist/js/components/{Animation.js → ui/Animation.js}

@@ -1,14 +1,11 @@
-import { AnimType } from "../types/enums/AnimType.js";
-import { Class } from "./Class.js";
-import { KeyframeController } from "./KeyframeController.js";
-import util from "node:util";
-export class Animation extends Class {
+import { AnimType } from "../../types/ui/enums/AnimType.js";
+import { AnimationKeyframe } from "./AnimationKeyframe.js";
+export class Animation {
     type;
     keyframes = [];
     loop = false;
     smartAnimationMode = "none";
     constructor(type, ...keyframes) {
-        super();
         this.type = type;
         if ([AnimType.ASEPRITE_FLIP_BOOK, AnimType.FLIP_BOOK, AnimType.WAIT].includes(type)) {
             throw new Error(`${type} is not need for Animation constructor, please use AnimetionKeyframe instead!`);
@@ -45,7 +42,7 @@ export class Animation extends Class {
         if (this.smartAnimationMode === "none") {
             for (const $ of keyframes) {
                 const { type, properties } = this.transformKeyframe($);
-                const keyframeController = new KeyframeController(type, properties);
+                const keyframeController = new AnimationKeyframe(type, properties);
                 const prevKeyframe = this.lastKey();
                 if (prevKeyframe)
                     prevKeyframe.setNext(keyframeController);
@@ -66,7 +63,7 @@ export class Animation extends Class {
                     else if (to === undefined)
                         properties.to = from;
                 }
-                const keyframeController = new KeyframeController(type, properties);
+                const keyframeController = new AnimationKeyframe(type, properties);
                 const prevKeyframe = this.lastKey();
                 if (prevKeyframe)
                     prevKeyframe.setNext(keyframeController);
@@ -89,7 +86,7 @@ export class Animation extends Class {
                         lastTo = properties.to;
                     }
                 }
-                const keyframeController = new KeyframeController(type, properties);
+                const keyframeController = new AnimationKeyframe(type, properties);
                 const prevKeyframe = this.lastKey();
                 if (prevKeyframe)
                     prevKeyframe.setNext(keyframeController);
@@ -124,11 +121,5 @@ export class Animation extends Class {
     toString() {
         return String(this.firstKey());
     }
-    [util.inspect.custom]($, opts) {
-        const out = this.keyframes.map((v, i) => {
-            return `  \x1b[33m${i}\x1b[0m: \x1b[33mKeyframe\x1b[0m<\x1b[92m${v.type}\x1b[0m> \x1b[92m"${v}\x1b[92m"\x1b[0m ${util.inspect(v.serialize(), opts)}`.replace(/\n/g, "\n  ");
-        });
-        return `\x1b[33mAnimation\x1b[0m<\x1b[92m${this.type}\x1b[0m> \x1b[92m"${this}\x1b[92m"\x1b[0m {\n${out.join("\n")}\n}\n`;
-    }
 }
 //# sourceMappingURL=Animation.js.map