asajs 4.0.0 → 4.0.2

package/dist/js/compilers/bindings/Binary.js

@@ -0,0 +1,36 @@
+import { RandomBindingString } from "../../components/Utils.js";
+import { defaultFunctions } from "./Function.js";
+export function intToBin(input) {
+    const { abs, negabs } = defaultFunctions;
+    const ret = RandomBindingString(16);
+    const bindings = [];
+    // negative bit
+    bindings.push({
+        source: `(${input} < 0)`,
+        target: `${ret}0`,
+    });
+    return {
+        ret,
+        bindings,
+    };
+}
+export function binToInt(input) {
+    const ret = RandomBindingString(16);
+    const bindings = [];
+    const nevBind = (input + "0");
+    // Is reverse to positive
+    bindings.push({
+        source: `(-1 + ((${nevBind} = 0) * 2))`,
+        target: `${ret}0`,
+    });
+    bindings.push({
+        source: `(${Array.from({ length: 31 }, ($, i) => {
+            return `${input}${i + 1}`;
+        }).join(" + ")})`,
+        target: ret,
+    });
+    return {
+        ret,
+        bindings,
+    };
+}

package/dist/js/compilers/bindings/Function.js

@@ -1,71 +1,121 @@
 import { RandomBindingString } from "../../components/Utils.js";
-import { Parser } from "./Parser.js";
 export const FunctionMap = new Map();
 function callFn(name, ...args) {
     return FunctionMap.get(name)(...args);
 }
-// Default Functions
-FunctionMap.set("abs", number => {
-    const randomBinding = RandomBindingString(16);
-    return {
-        genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
-        value: randomBinding,
-    };
-});
-FunctionMap.set("new", expression => {
-    const randomBinding = RandomBindingString(16);
-    return {
-        genBindings: [{ source: expression, target: randomBinding }],
-        value: randomBinding,
-    };
-});
-FunctionMap.set("sqrt", number => {
-    const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
-    const { genBindings: absValue, value: absRtn } = callFn("abs", number);
-    return {
-        genBindings: [
-            {
-                source: `${number} * 100 / 2`,
-                target: $1,
-            },
-            ...absValue,
-            {
-                source: `${absRtn} > 1`,
-                target: $2,
-            },
-            {
-                source: `(${number} < 0) * -1 + (${number} > -1) * (${$2} * ((${rtn} + ${number} / ${rtn}) / 2) + (not ${$2}) * ${rtn})`,
-                target: rtn,
-            },
-        ],
-        value: rtn,
-    };
-});
-FunctionMap.set("translatable", key => {
-    return {
-        value: `'%' + ${key}`,
-    };
-});
-FunctionMap.set("bin", input => {
-    const { ret, bindings } = Parser.intToBin(input);
-    bindings.push({
-        source: `'§z' + ${Array.from({ length: 30 }, (_, i) => `${ret}${30 - i - 1}`).join(" + ")}`,
-        target: ret,
-    });
-    return { genBindings: bindings, value: ret };
-});
-FunctionMap.set("bind", (value, bait) => {
-    const ret = RandomBindingString(16);
-    if (!bait) {
-        throw new Error("Bait is required");
-    }
-    return {
-        genBindings: [{ source: `((${bait} - ${bait}) + ${value})`, target: ret }],
-        value: ret,
-    };
-});
-FunctionMap.set("int", input => {
-    return {
-        value: input,
-    };
-});
+export const defaultFunctions = {
+    /**
+     * Returns the absolute value of a number (the value without regard to whether it is positive or negative). For example, the absolute value of -5 is the same as the absolute value of 5.
+     * @param number
+     * @returns
+     */
+    abs: number => {
+        const randomBinding = RandomBindingString(16);
+        return {
+            genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
+            value: randomBinding,
+        };
+    },
+    /**
+     * Returns the negative absolute value of a number (the value without regard to whether it is positive or negative). For example, the absolute value of 5 is the same as the negative absolute value of -5.
+     * @param number
+     * @returns
+     */
+    negabs: number => {
+        const randomBinding = RandomBindingString(16);
+        return {
+            genBindings: [{ source: `((-1 + (${number} < 0) * 2) * ${number})`, target: randomBinding }],
+            value: randomBinding,
+        };
+    },
+    /**
+     * Generate a new binding for expression
+     * @param expression
+     * @returns
+     */
+    new: expression => {
+        const randomBinding = RandomBindingString(16);
+        return {
+            genBindings: [{ source: expression, target: randomBinding }],
+            value: randomBinding,
+        };
+    },
+    /**
+     * Returns the square root of a number.
+     * @param number
+     * @returns
+     */
+    sqrt: number => {
+        const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
+        const { genBindings: absValue, value: absRtn } = callFn("abs", number);
+        return {
+            genBindings: [
+                {
+                    source: `${number} * 100 / 2`,
+                    target: $1,
+                },
+                ...absValue,
+                {
+                    source: `${absRtn} > 1`,
+                    target: $2,
+                },
+                {
+                    source: `(${number} < 0) * -1 + (${number} > -1) * (${$2} * ((${rtn} + ${number} / ${rtn}) / 2) + (not ${$2}) * ${rtn})`,
+                    target: rtn,
+                },
+            ],
+            value: rtn,
+        };
+    },
+    /**
+     * Return a translatable string
+     * @param key
+     * @returns
+     */
+    translatable: key => {
+        return {
+            value: `'%' + ${key}`,
+        };
+    },
+    /**
+     * Return a binary of int32 number in string
+     * @param value
+     * @param bait
+     * @returns
+     */
+    // bin: value => {
+    // 	const {} = intToBin(value)
+    // 	return {
+    // 		value,
+    // 	}
+    // },
+    /**
+     *  Generate value bindings
+     * @param value
+     * @param bait
+     * @returns
+     */
+    bind: (value, bait) => {
+        const ret = RandomBindingString(16);
+        if (!bait) {
+            throw new Error("Bait is required");
+        }
+        return {
+            genBindings: [{ source: `((${bait} - ${bait}) + ${value})`, target: ret }],
+            value: ret,
+        };
+    },
+    /**
+     * Return a int of float number, because string in JSON-UI cannot read it.
+     * @param input
+     * @returns
+     */
+    int: input => {
+        const ret = RandomBindingString(16);
+        return {
+            genBindings: [{ source: `${input}`, target: ret }],
+            value: ret,
+        };
+    },
+};
+Object.entries(defaultFunctions).forEach(([key, value]) => FunctionMap.set(key, value));

package/dist/js/compilers/bindings/Lexer.js

@@ -64,8 +64,12 @@ export function Lexer(input, start = 0, end) {
                     tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
                 else {
                     if (input[index] === input[index + 1]) {
-                        if (input[index] !== "!")
-                            tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
+                        if (input[index] !== "!") {
+                            if (input[++index] === input[index + 1])
+                                tokens.push(makeToken(input, TokenKind.OPERATOR, index++ - 1, 3));
+                            else
+                                tokens.push(makeToken(input, TokenKind.OPERATOR, index - 1, 2));
+                        }
                         else
                             tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                     }
@@ -125,6 +129,7 @@ export function Lexer(input, start = 0, end) {
                                             value: `'${input.slice(start, index - 1)}'`,
                                         },
                                     });
+                                index--;
                                 break;
                             }
                         }
@@ -185,14 +190,14 @@ export function Lexer(input, start = 0, end) {
                                 console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
                                 throw new Error();
                             }
-                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            tokens.push(makeToken(input, TokenKind.INT, start, index - start + 1));
                             break;
                         }
                         else if (numType === "b") {
                             index += 2;
                             while (Checker.isBinaryChar(input[index + 1]))
                                 index++;
-                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            tokens.push(makeToken(input, TokenKind.INT, start, index - start + 1));
                             if (start + 2 === index) {
                                 console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
                                 throw new Error();
@@ -203,7 +208,7 @@ export function Lexer(input, start = 0, end) {
                             index += 2;
                             while (Checker.isOctalChar(input[index + 1]))
                                 index++;
-                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            tokens.push(makeToken(input, TokenKind.INT, start, index - start + 1));
                             if (start + 2 === index) {
                                 console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
                                 throw new Error();
@@ -224,7 +229,7 @@ export function Lexer(input, start = 0, end) {
                         while (Checker.isNumberChar(input[index + 1]))
                             index++;
                     }
-                    tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                    tokens.push(makeToken(input, TokenKind.INT, start, index - start + 1));
                 }
                 else if (Checker.isWordChar(token)) {
                     while (Checker.isWordChar(input[index + 1]))

package/dist/js/compilers/bindings/Parser.js

@@ -140,80 +140,12 @@ export class Parser {
         return left;
     }
     parseBitwiseLogicExpression() {
-        let left = this.parseBitwiseShiftExpression(), current;
-        while ((current = this.at()) &&
-            this.at()?.kind === TokenKind.OPERATOR &&
-            ["&", "|", "^"].includes(current.value)) {
-            const operator = this.eat();
-            const right = this.parsePrimaryExpression();
-            const cacheStr = `expr:${left}${operator.value}${right}`;
-            if (this.cache.has(cacheStr)) {
-                return (left = this.cache.get(cacheStr));
-            }
-            const ret = RandomBindingString(16);
-            this.cache.set(cacheStr, ret);
-            const leftBin = this.intToBin(left);
-            const rightBin = this.intToBin(right);
-            if (operator.value === "&") {
-                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
-                    return {
-                        source: `(${leftBin}${i} * ${rightBin}${i})`,
-                        target: `${ret}${i}`,
-                    };
-                }));
-            }
-            else if (operator.value === "|") {
-                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
-                    return {
-                        source: `(${leftBin}${i} + ${rightBin}${i} - (${leftBin}${i} * ${rightBin}${i}))`,
-                        target: `${ret}${i}`,
-                    };
-                }));
-            }
-            else {
-                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
-                    return {
-                        source: `(${leftBin}${i} + ${rightBin}${i} - 2 * (${leftBin}${i} * ${rightBin}${i}))`,
-                        target: `${ret}${i}`,
-                    };
-                }));
-            }
-            this.genBindings.push({
-                source: `(${Array.from({ length: 30 }, (_, i) => `(${ret}${i} * ${2 ** i})`).join(" + ")})`,
-                target: ret,
-            });
-            left = ret;
-        }
-        return left;
+        // TODO
+        return this.parseBitwiseShiftExpression();
     }
     parseBitwiseShiftExpression() {
-        let left = this.parsePrimaryExpression(), current;
-        while ((current = this.at()) &&
-            this.at()?.kind === TokenKind.OPERATOR &&
-            [">>", "<<"].includes(current.value)) {
-            const operator = this.eat();
-            const right = this.parsePrimaryExpression();
-            const cacheStr = `expr:${left}${operator.value}${right}`;
-            if (this.cache.has(cacheStr)) {
-                return (left = this.cache.get(cacheStr));
-            }
-            const ret = RandomBindingString(16);
-            this.cache.set(cacheStr, ret);
-            const leftBind = this.intToBin(left);
-            const op = operator.value === "<<" ? "-" : "+";
-            this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
-                return {
-                    source: `((0 * ${left}) + ('${leftBind}' + (${i} ${op} ${right})))`,
-                    target: `${ret}${i}`,
-                };
-            }));
-            this.genBindings.push({
-                source: `(${Array.from({ length: 30 }, (_, i) => `(${ret}${i} * ${2 ** i})`).join(" + ")})`,
-                target: ret,
-            });
-            left = ret;
-        }
-        return left;
+        // TODO
+        return this.parsePrimaryExpression();
     }
     parsePrimaryExpression() {
         const left = this.at();
@@ -227,7 +159,7 @@ export class Parser {
                 this.eat();
                 return `(${value})`;
             }
-            case TokenKind.NUMBER: {
+            case TokenKind.INT: {
                 const numberToken = this.eat();
                 switch (numberToken.value[1]) {
                     case "x":
@@ -292,7 +224,7 @@ export class Parser {
                 }
             }
             default:
-                this.expect(TokenKind.NUMBER, "Unexpected token!");
+                this.expect(TokenKind.INT, "Unexpected token!");
         }
         return left.value;
     }
@@ -302,14 +234,14 @@ export class Parser {
             this.eat();
             const args = [];
             if (this.at().kind === TokenKind.COMMA) {
-                this.expect(TokenKind.NUMBER, "Unexpected token!");
+                this.expect(TokenKind.INT, "Unexpected token!");
             }
             if (this.at().kind !== TokenKind.CLOSE_PARENTHESIS) {
                 args.push(this.parseExpression());
                 while (this.at().kind === TokenKind.COMMA) {
                     this.eat();
                     if (this.at().kind === TokenKind.CLOSE_PARENTHESIS) {
-                        this.expect(TokenKind.NUMBER, "Unexpected token!");
+                        this.expect(TokenKind.INT, "Unexpected token!");
                     }
                     args.push(this.parseExpression());
                 }

package/dist/js/compilers/bindings/types.js

@@ -1,15 +1,16 @@
 export var TokenKind;
 (function (TokenKind) {
     TokenKind[TokenKind["VARIABLE"] = 0] = "VARIABLE";
-    TokenKind[TokenKind["NUMBER"] = 1] = "NUMBER";
-    TokenKind[TokenKind["STRING"] = 2] = "STRING";
-    TokenKind[TokenKind["TEMPLATE_STRING"] = 3] = "TEMPLATE_STRING";
-    TokenKind[TokenKind["WORD"] = 4] = "WORD";
-    TokenKind[TokenKind["OPEN_PARENTHESIS"] = 5] = "OPEN_PARENTHESIS";
-    TokenKind[TokenKind["CLOSE_PARENTHESIS"] = 6] = "CLOSE_PARENTHESIS";
-    TokenKind[TokenKind["OPERATOR"] = 7] = "OPERATOR";
-    TokenKind[TokenKind["COMMA"] = 8] = "COMMA";
-    TokenKind[TokenKind["EOF"] = 9] = "EOF";
+    TokenKind[TokenKind["STRING"] = 1] = "STRING";
+    TokenKind[TokenKind["TEMPLATE_STRING"] = 2] = "TEMPLATE_STRING";
+    TokenKind[TokenKind["WORD"] = 3] = "WORD";
+    TokenKind[TokenKind["INT"] = 4] = "INT";
+    TokenKind[TokenKind["FLOAT"] = 5] = "FLOAT";
+    TokenKind[TokenKind["OPEN_PARENTHESIS"] = 6] = "OPEN_PARENTHESIS";
+    TokenKind[TokenKind["CLOSE_PARENTHESIS"] = 7] = "CLOSE_PARENTHESIS";
+    TokenKind[TokenKind["OPERATOR"] = 8] = "OPERATOR";
+    TokenKind[TokenKind["COMMA"] = 9] = "COMMA";
+    TokenKind[TokenKind["EOF"] = 10] = "EOF";
 })(TokenKind || (TokenKind = {}));
 export var TSTokenKind;
 (function (TSTokenKind) {

package/dist/js/compilers/ui/builder.js

@@ -48,6 +48,7 @@ if (isBuildMode) {
     let first = true;
     process.on("beforeExit", async () => {
         if (first) {
+            first = false;
             await createBuildFolder();
             await buildUI();
             if (isLinkMode)
@@ -66,7 +67,6 @@ if (isBuildMode) {
                 console.log("Install Path:", `\x1b[32m"${path.join(gamePath, await getBuildFolderName())}"\x1b[0m`);
             console.log("=============================================================");
         }
-        first = false;
     });
 }
 else if (isLinkMode)

package/dist/js/compilers/ui/manifest.js

@@ -1,6 +1,6 @@
 import { config } from "../Configuration.js";
 import { getUUID } from "./linker.js";
-export const version = config.packinfo?.version || [4, 0, 0];
+export const version = config.packinfo?.version || [4, 0, 1];
 export async function genManifest() {
     const [uuid1, uuid2] = await getUUID();
     return JSON.stringify({

package/dist/js/components/UI.js

@@ -137,7 +137,7 @@ export class UI extends Class {
             obj.anims = this.anims.map(a => String(a));
         if (this.controls.size) {
             obj.controls = [];
-            this.controls.forEach((e, key) => obj.controls.push({ [key + e[0]]: e[1] }));
+            this.controls.forEach((e, key) => obj.controls.push({ [key + e[0]]: FormatProperties(e[1]) }));
         }
         return obj;
     }

package/dist/js/index.js

@@ -10,4 +10,4 @@ export * from "./types/enums/index.js";
 export * as Properties from "./types/properties/index.js";
 export { ItemAuxID } from "./types/enums/Items.js";
 export { ArrayName, Operation } from "./types/properties/index.js";
-export { Lexer } from "./compilers/bindings/Lexer.js";
+export * from "./compilers/bindings/Binary.js";

package/dist/types/compilers/bindings/Binary.d.ts

@@ -0,0 +1,10 @@
+import { Binding } from "../../types/properties/value.js";
+import { GenBinding } from "./types.js";
+export declare function intToBin(input: string): {
+    ret: `#${string}`;
+    bindings: GenBinding[];
+};
+export declare function binToInt(input: Binding): {
+    ret: `#${string}`;
+    bindings: GenBinding[];
+};

package/dist/types/compilers/bindings/Function.d.ts

@@ -4,4 +4,90 @@ type Callback = (...args: Expression[]) => {
     value: Expression;
 };
 export declare const FunctionMap: Map<string, Callback>;
+export declare const defaultFunctions: {
+    /**
+     * Returns the absolute value of a number (the value without regard to whether it is positive or negative). For example, the absolute value of -5 is the same as the absolute value of 5.
+     * @param number
+     * @returns
+     */
+    abs: (number: string) => {
+        genBindings: {
+            source: string;
+            target: `#${string}`;
+        }[];
+        value: `#${string}`;
+    };
+    /**
+     * Returns the negative absolute value of a number (the value without regard to whether it is positive or negative). For example, the absolute value of 5 is the same as the negative absolute value of -5.
+     * @param number
+     * @returns
+     */
+    negabs: (number: string) => {
+        genBindings: {
+            source: string;
+            target: `#${string}`;
+        }[];
+        value: `#${string}`;
+    };
+    /**
+     * Generate a new binding for expression
+     * @param expression
+     * @returns
+     */
+    new: (expression: string) => {
+        genBindings: {
+            source: string;
+            target: `#${string}`;
+        }[];
+        value: `#${string}`;
+    };
+    /**
+     * Returns the square root of a number.
+     * @param number
+     * @returns
+     */
+    sqrt: (number: string) => {
+        genBindings: GenBinding[];
+        value: `#${string}`;
+    };
+    /**
+     * Return a translatable string
+     * @param key
+     * @returns
+     */
+    translatable: (key: string) => {
+        value: string;
+    };
+    /**
+     * Return a binary of int32 number in string
+     * @param value
+     * @param bait
+     * @returns
+     */
+    /**
+     *  Generate value bindings
+     * @param value
+     * @param bait
+     * @returns
+     */
+    bind: (value: string, bait: string) => {
+        genBindings: {
+            source: string;
+            target: `#${string}`;
+        }[];
+        value: `#${string}`;
+    };
+    /**
+     * Return a int of float number, because string in JSON-UI cannot read it.
+     * @param input
+     * @returns
+     */
+    int: (input: string) => {
+        genBindings: {
+            source: string;
+            target: `#${string}`;
+        }[];
+        value: `#${string}`;
+    };
+};
 export {};

package/dist/types/compilers/bindings/types.d.ts

@@ -1,14 +1,15 @@
 export declare enum TokenKind {
     VARIABLE = 0,
-    NUMBER = 1,
-    STRING = 2,
-    TEMPLATE_STRING = 3,
-    WORD = 4,
-    OPEN_PARENTHESIS = 5,
-    CLOSE_PARENTHESIS = 6,
-    OPERATOR = 7,
-    COMMA = 8,
-    EOF = 9
+    STRING = 1,
+    TEMPLATE_STRING = 2,
+    WORD = 3,
+    INT = 4,
+    FLOAT = 5,
+    OPEN_PARENTHESIS = 6,
+    CLOSE_PARENTHESIS = 7,
+    OPERATOR = 8,
+    COMMA = 9,
+    EOF = 10
 }
 export declare enum TSTokenKind {
     STRING = 0,

package/dist/types/index.d.ts

@@ -10,4 +10,4 @@ export * from "./types/enums/index.js";
 export * as Properties from "./types/properties/index.js";
 export { ItemAuxID } from "./types/enums/Items.js";
 export { ArrayName, Operation } from "./types/properties/index.js";
-export { Lexer } from "./compilers/bindings/Lexer.js";
+export * from "./compilers/bindings/Binary.js";

package/dist/types/types/properties/element/Cycler.d.ts

@@ -1,5 +1,6 @@
 import { Value } from "../value.js";
 export interface Image {
+    fill?: Value<boolean>;
     texture_path?: Value<string>;
     texture?: Value<string>;
 }

package/dist/types/types/properties/element/Layout.d.ts

@@ -1,7 +1,7 @@
 import { Anchor } from "../../enums/Anchor.js";
 import { Value, AnimValue, Array2 } from "../value.js";
 export interface Layout {
-    offset?: AnimValue<Array2<number>>;
+    offset?: AnimValue<Array2<number | string>>;
     size?: AnimValue<Array2<number | string>>;
     max_size?: AnimValue<Array2<number | string>>;
     min_size?: AnimValue<Array2<number | string>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "asajs",
-	"version": "4.0.0",
+	"version": "4.0.2",
 	"description": "Create your Minecraft JSON-UI resource packs using JavaScript",
 	"keywords": [
 		"Minecraft",

package/resources/asajs.config.cjs

@@ -4,9 +4,9 @@
  */
 export const config = {
 	packinfo: {
-		name: "AsaJS - Installer Test",
+		name: "AsaJS",
 		description: "Create your Minecraft JSON-UI resource packs using JavaScript.",
-		version: [4, 0, 0],
+		version: [4, 0, 1],
 	},
 	compiler: {
 		enabled: true,