asajs 4.0.0-indev-1 → 4.0.0-indev-3

package/config.d.ts

@@ -0,0 +1,26 @@
+import { Variable } from "./src/types/properties/value.ts"
+
+export interface Config {
+	compiler?: {
+		enabled?: boolean
+		linked?: boolean
+	}
+	packinfo?: {
+		name?: string
+		description?: string
+		version?: [number, number, number]
+
+		metadata?: {
+			authors?: string[]
+			license?: string
+			url?: string
+		}
+
+		subpacks?: {
+			folder_name?: string
+			name?: string
+			memory_performance_tier?: number
+		}[]
+	}
+	global_variables?: Record<Variable, string>
+}

package/dist/js/compilers/Configuration.js

@@ -1 +1,20 @@
-export const isBuildMode = process.argv.includes("--build");
+import fs from "fs";
+import path from "path";
+if (!fs.existsSync("asajs.config.cjs")) {
+    fs.copyFileSync("node_modules/asajs/resources/asajs.config.cjs", "asajs.config.cjs");
+}
+if (!fs.existsSync(".gitignore")) {
+    fs.writeFileSync(".gitignore", `node_modules`, "utf-8");
+}
+export const config = require(path.resolve(process.cwd(), "asajs.config.cjs")).config;
+export let isBuildMode = config.compiler?.enabled ?? false;
+export let isLinkMode = config.compiler?.linked ?? false;
+export let unLinked = !(config.compiler?.linked ?? true);
+for (const arg of process.argv) {
+    if (arg === "--build")
+        isBuildMode = true;
+    if (arg === "--link")
+        isLinkMode = true;
+    else if (arg === "--unlink")
+        unLinked = true;
+}

package/dist/js/compilers/Memory.js

@@ -22,9 +22,7 @@ export class Memory extends Class {
         const data = new Map();
         Memory.files.entries().forEach(([path, { elements, namespace }]) => {
             const record = {};
-            elements.forEach(element => {
-                record[element.name] = element;
-            });
+            elements.forEach(element => (record[element.name] = element));
             data.set(path, {
                 namespace,
                 ...record,

package/dist/js/compilers/bindings/Checker.js

@@ -7,6 +7,15 @@ export function isWordChar(char) {
 export function isNumberChar(char) {
     return /\d/.test(char);
 }
+export function isHexChar(char) {
+    return /[0-9a-fA-F]/.test(char);
+}
+export function isBinaryChar(char) {
+    return /[01]/.test(char);
+}
+export function isOctalChar(char) {
+    return /[0-7]/.test(char);
+}
 export function isCompileBinding(input) {
     return input.startsWith("[") && input.endsWith("]");
 }

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

@@ -0,0 +1,71 @@
+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,
+    };
+});

package/dist/js/compilers/bindings/Funtion.js

@@ -1,24 +1,25 @@
 import { RandomBindingString } from "../../components/Utils.js";
-export const FuntionMap = new Map();
+import { Parser } from "./Parser.js";
+export const FunctionMap = new Map();
 function callFn(name, ...args) {
-    return FuntionMap.get(name)(...args);
+    return FunctionMap.get(name)(...args);
 }
 // Default Functions
-FuntionMap.set("abs", number => {
+FunctionMap.set("abs", number => {
     const randomBinding = RandomBindingString(16);
     return {
         genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
         value: randomBinding,
     };
 });
-FuntionMap.set("new", expression => {
+FunctionMap.set("new", expression => {
     const randomBinding = RandomBindingString(16);
     return {
         genBindings: [{ source: expression, target: randomBinding }],
         value: randomBinding,
     };
 });
-FuntionMap.set("sqrt", number => {
+FunctionMap.set("sqrt", number => {
     const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
     const { genBindings: absValue, value: absRtn } = callFn("abs", number);
     return {
@@ -40,8 +41,31 @@ FuntionMap.set("sqrt", number => {
         value: rtn,
     };
 });
-FuntionMap.set("translatable", key => {
+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,
+    };
+});

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

@@ -39,6 +39,7 @@ export function Lexer(input, start = 0, end) {
             case "*":
             case "/":
             case "%":
+            case "^":
                 tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                 break;
             case "(":
@@ -53,18 +54,24 @@ export function Lexer(input, start = 0, end) {
             case "=":
                 if (input[index + 1] === input[index])
                     tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
-                else {
-                    console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 7) + "^"}\nInvalid character.\x1b[0m`);
-                    throw new Error();
-                }
+                else
+                    tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                 break;
             case "!":
             case ">":
             case "<":
                 if (input[index + 1] === "=")
                     tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
-                else
-                    tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                else {
+                    if (input[index] === input[index + 1]) {
+                        if (input[index] !== "!")
+                            tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
+                        else
+                            tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                    }
+                    else
+                        tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                }
                 break;
             // string
             case "'": {
@@ -168,6 +175,42 @@ export function Lexer(input, start = 0, end) {
             default: {
                 let start = index;
                 if (Checker.isNumberChar(token)) {
+                    if (token === "0") {
+                        const numType = input[index + 1];
+                        if (numType === "x") {
+                            index += 2;
+                            while (Checker.isHexChar(input[index + 1]))
+                                index++;
+                            if (start + 2 === index) {
+                                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));
+                            break;
+                        }
+                        else if (numType === "b") {
+                            index += 2;
+                            while (Checker.isBinaryChar(input[index + 1]))
+                                index++;
+                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            if (start + 2 === index) {
+                                console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
+                                throw new Error();
+                            }
+                            break;
+                        }
+                        else if (numType === "o") {
+                            index += 2;
+                            while (Checker.isOctalChar(input[index + 1]))
+                                index++;
+                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            if (start + 2 === index) {
+                                console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
+                                throw new Error();
+                            }
+                            break;
+                        }
+                    }
                     while (Checker.isNumberChar(input[index + 1]))
                         index++;
                     if (input[index + 1] === "e") {

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

@@ -1,21 +1,55 @@
 import { TokenKind, TSTokenKind } from "./types.js";
 import { BindingType } from "../../types/enums/BindingType.js";
-import { FuntionMap } from "./Funtion.js";
+import { FunctionMap } from "./Function.js";
 import { Lexer } from "./Lexer.js";
+import { RandomBindingString } from "../../components/Utils.js";
 export class Parser {
     input;
+    cache;
     position = 0;
-    tokens;
     genBindings = [];
     output;
-    constructor(input) {
+    tokens;
+    constructor(input, cache = new Map(), tokens) {
         this.input = input;
-        this.tokens = Lexer(this.input);
+        this.cache = cache;
+        if (tokens) {
+            this.tokens = tokens;
+            tokens = undefined;
+        }
+        else
+            this.tokens = Lexer(input);
         this.output = this.parseExpression();
         if (this.at()) {
             this.expect(TokenKind.EOF, "Unexpected token!");
         }
     }
+    static intToBin(input) {
+        const bindings = [];
+        const rtn = RandomBindingString(16);
+        for (let i = 0; i < 30; i++) {
+            bindings.push({
+                source: `(${input} / ${2 ** i} - (${input} / ${2 ** (i + 1)}) * 2)`,
+                target: `${rtn}${i}`,
+            });
+        }
+        return {
+            ret: rtn,
+            bindings,
+        };
+    }
+    intToBin(input) {
+        const inStr = `expr:${input}`;
+        if (this.cache.has(inStr)) {
+            return this.cache.get(inStr);
+        }
+        else {
+            const { ret, bindings } = Parser.intToBin(input);
+            this.cache.set(inStr, ret);
+            this.genBindings.push(...bindings);
+            return ret;
+        }
+    }
     at() {
         return this.tokens[this.position];
     }
@@ -81,19 +115,106 @@ export class Parser {
         return left;
     }
     parseMultiplicativeExpression() {
-        let left = this.parsePrimaryExpression(), current;
+        let left = this.parseBitwiseLogicExpression(), current;
         while ((current = this.at()) &&
             this.at()?.kind === TokenKind.OPERATOR &&
             ["*", "/", "%"].includes(current.value)) {
             const operator = this.eat();
             const right = this.parsePrimaryExpression();
-            if (current.value === "%")
-                left = `(${left} - (${left} / ${right} * ${right}))`;
+            if (current.value === "%") {
+                const cacheStr = `expr:${left}${operator.value}${right}`;
+                if (this.cache.has(cacheStr)) {
+                    return (left = this.cache.get(cacheStr));
+                }
+                const ret = RandomBindingString(16);
+                this.genBindings.push({
+                    source: `(${left} - (${left} / ${right} * ${right}))`,
+                    target: ret,
+                });
+                this.cache.set(cacheStr, ret);
+                left = ret;
+            }
             else
                 left = `(${left} ${operator.value} ${right})`;
         }
         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;
+    }
+    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;
+    }
     parsePrimaryExpression() {
         const left = this.at();
         switch (left?.kind) {
@@ -107,8 +228,18 @@ export class Parser {
                 return `(${value})`;
             }
             case TokenKind.NUMBER: {
-                const [num, exp] = this.eat().value.split("e");
-                return "" + (exp ? +num * 10 ** +exp : num);
+                const numberToken = this.eat();
+                switch (numberToken.value[1]) {
+                    case "x":
+                        return "" + parseInt(numberToken.value.slice(2), 16);
+                    case "o":
+                        return "" + parseInt(numberToken.value.slice(2), 8);
+                    case "b":
+                        return "" + parseInt(numberToken.value.slice(2), 2);
+                    default:
+                        const [num, exp] = numberToken.value.split("e");
+                        return "" + (exp ? +num * 10 ** +exp : num);
+                }
             }
             case TokenKind.VARIABLE:
             case TokenKind.STRING:
@@ -184,7 +315,15 @@ export class Parser {
                 }
             }
             this.eat();
-            return this.funtionCall(callerToken.value, ...args);
+            const inputStr = `func:${callerToken.value}(${args.join(", ")})`;
+            if (this.cache.has(inputStr)) {
+                return this.cache.get(inputStr);
+            }
+            else {
+                const ret = this.functionCall(callerToken.value, ...args);
+                this.cache.set(inputStr, ret);
+                return ret;
+            }
         }
         else if (left?.kind === TokenKind.OPERATOR) {
             this.warn(`Implicit string literal '${callerToken.value}'. Use quoted string ('${callerToken.value}') for clarity!`, callerToken);
@@ -198,8 +337,8 @@ export class Parser {
             return callerToken.value;
         }
     }
-    funtionCall(name, ...params) {
-        const func = FuntionMap.get(name.toLowerCase());
+    functionCall(name, ...params) {
+        const func = FunctionMap.get(name.toLowerCase());
         if (!func) {
             return this.expect(TokenKind.WORD, "Function not found!");
         }
@@ -226,6 +365,7 @@ export class Parser {
     out() {
         return {
             out: `(${this.output})`,
+            cache: this.cache,
             gen: this.genBindings.map(({ source, target }) => ({
                 binding_type: BindingType.VIEW,
                 source_property_name: `(${source})`,

package/dist/js/compilers/ui/buildcache.js

@@ -0,0 +1,53 @@
+import fs from "fs/promises";
+export class BuildCache {
+    static queue = Promise.resolve();
+    static async enqueue(task) {
+        let result;
+        this.queue = this.queue.then(async () => {
+            result = await task();
+        });
+        return this.queue.then(() => result);
+    }
+    static async get(key) {
+        return this.enqueue(async () => {
+            try {
+                return await fs.readFile("build/cache.json", "utf-8").then(data => JSON.parse(data)[key] ?? null);
+            }
+            catch (error) {
+                return null;
+            }
+        });
+    }
+    static async getWithDefault(key, defaultValue) {
+        const outVal = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+        return this.get(key).then(value => value ?? outVal);
+    }
+    static async getWithSetDefault(key, defaultValue) {
+        const outVal = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+        return this.enqueue(async () => {
+            let data = {};
+            try {
+                data = JSON.parse(await fs.readFile("build/cache.json", "utf-8"));
+            }
+            catch { }
+            if (key in data)
+                return data[key];
+            data[key] = outVal;
+            await fs.writeFile("build/cache.json", JSON.stringify(data), "utf-8");
+            return outVal;
+        });
+    }
+    static async set(key, value) {
+        return this.enqueue(async () => {
+            try {
+                return fs.writeFile("build/cache.json", JSON.stringify({
+                    ...(await fs.readFile("build/cache.json", "utf-8").then(data => JSON.parse(data))),
+                    [key]: value,
+                }), "utf-8");
+            }
+            catch (error) {
+                return fs.writeFile("build/cache.json", JSON.stringify({ [key]: value }), "utf-8");
+            }
+        });
+    }
+}

package/dist/js/compilers/ui/builddata.js

@@ -0,0 +1,4 @@
+try {
+}
+catch (error) { }
+export {};

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

@@ -1,22 +1,37 @@
-import { isBuildMode } from "../Configuration.js";
+import { config, isBuildMode, isLinkMode, unLinked } from "../Configuration.js";
 import { Memory } from "../Memory.js";
-import { createBuildFolder } from "./linker.js";
+import { createBuildFolder, linkToGame, unlink } from "./linker.js";
+import { genManifest } from "./manifest.js";
 import fs from "fs/promises";
+import { BuildCache } from "./buildcache.js";
 async function buildUI() {
     const build = Memory.build();
-    let i = 0;
-    build.set("ui/ui_defs.json", {
+    build.set("ui/_ui_defs.json", {
         ui_defs: Array.from(build.keys()),
     });
-    await Promise.all(build.entries().map(async ([file, value]) => {
-        const outFile = `build/build/${file}`;
+    if (config.global_variables)
+        build.set("ui/_global_variables.json", config.global_variables);
+    const out = await Promise.all(build.entries().map(async ([file, value]) => {
+        const outFile = `build/${file}`;
         await fs
             .stat(outFile.split(/\\|\//g).slice(0, -1).join("/"))
             .catch(async () => await fs.mkdir(outFile.split(/\\|\//g).slice(0, -1).join("/"), { recursive: true }));
-        await fs.writeFile(outFile, JSON.stringify(value), "utf-8");
-        i++;
+        await fs.writeFile(outFile, JSON.stringify(Object.fromEntries(Object.entries(value).map(([key, value]) => {
+            const extend = value.extend;
+            return [extend ? key + String(extend) : key, value];
+        }))), "utf-8");
+        build.delete(file);
+        return file;
     }));
-    return i - 1;
+    await Promise.all([
+        fs.writeFile("build/manifest.json", await genManifest(), "utf-8"),
+        fs.writeFile("build/.gitignore", [...out, "manifest.json"].join("\n"), "utf-8"),
+        BuildCache.set("build-files", [...out, "manifest.json"]),
+        fs
+            .stat("build/pack_icon.png")
+            .catch(() => fs.copyFile("node_modules/asajs/resources/pack_icon.png", "build/pack_icon.png")),
+    ]);
+    return out.length;
 }
 if (isBuildMode) {
     let first = true;
@@ -24,7 +39,13 @@ if (isBuildMode) {
         if (first) {
             await createBuildFolder();
             await buildUI();
+            if (isLinkMode)
+                await linkToGame();
         }
         first = false;
     });
 }
+else if (isLinkMode)
+    linkToGame();
+else if (unLinked)
+    unlink();

package/dist/js/compilers/ui/installer.js

@@ -1 +1,15 @@
-export {};
+import os from "os";
+import path from "path";
+export function getGamedataPath() {
+    switch (os.platform()) {
+        case "win32": {
+            if (/Windows (10|11)/.test(os.version())) {
+                return path.join(process.env.APPDATA, "Minecraft Bedrock\\Users\\Shared\\games\\com.mojang");
+            }
+        }
+        default: {
+            console.error(`Your platform is not supported the install feature yet! \nYour OS version: ${os.version()}`);
+            process.exit(1);
+        }
+    }
+}