asajs 4.0.0-indev-2 → 4.0.0-indev-4

package/README.md

@@ -1,3 +1,57 @@
-AsaJS Logo made by [Kammasy](https://www.youtube.com/channel/UCrmjDWdM8-ZSeekzLeCnftg) a.k.a **[E.G.G](https://www.youtube.com/channel/UCrmjDWdM8-ZSeekzLeCnftg)**
+<div align="center">
+<img src="./resources/logo.png" />
 
-![image](/resources/logo.png)
+<h2 align="center">
+    <a href="https://asajs.asakiyuki.com/">AsaJS</a> - The <a href="https://www.minecraft.net/en-us">Minecraft: Bedrock Edition</a> JSON-UI Framework
+</h2>
+    
+[![asajs version](https://img.shields.io/npm/v/asajs.svg?style=for-the-badge&labelColor=000000)](https://www.npmjs.com/package/asajs)
+[![asajs license](https://img.shields.io/npm/l/asajs.svg?style=for-the-badge&labelColor=000000)](https://github.com/AsakiYuki/AsaJS/blob/main/README.md)
+[![asajs downloads](https://img.shields.io/npm/dm/asajs.svg?style=for-the-badge&labelColor=000000)](https://www.npmjs.com/package/asajs)
+</div>
+
+**AsaJS** is a NodeJS library designed to empower developers to create **JSON-UI** packages for Minecraft: Bedrock Edition using **JavaScript** or **TypeScript**.
+
+Say goodbye to the tedious and repetitive nature of manual JSON editing. AsaJS streamlines your workflow by bringing the programmatic flexibility to Minecraft UI development.
+
+## 🛠 Installation
+
+To use AsaJS, ensure you have **[Node.js](https://nodejs.org/en)** installed on your system.
+
+**Latest stable version:**
+
+```bash
+npm install asajs
+```
+
+**For our nightly builds:**
+
+```
+npm install asajs@indev
+```
+
+## 📖 "Hello World!" Example
+
+Creating a custom UI with AsaJS is straightforward. Here is how you can insert a custom label onto the Minecraft Start Screen:
+
+```javascript
+import { Anchor, Label, Modify } from "asajs"
+
+const label = Label({
+	text: "Hello World from my Custom UI!",
+	shadow: true,
+	anchor: Anchor.TOP_MIDDLE,
+	offset: [0, 10],
+})
+
+// This code injects the label into the top of the start screen
+Modify("start", "start_screen_content").insertChild(label)
+```
+
+## 📚 Documentation
+
+Detailed guides and API references are available at: 👉 https://asajs.asakiyuki.com/
+
+## 🤝 Contributing
+
+Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

package/config.d.ts

@@ -0,0 +1,29 @@
+import { Variable } from "./src/types/properties/value.ts"
+
+export interface Config {
+	compiler?: {
+		enabled?: boolean
+		autoImport?: boolean
+		importToPreview?: boolean
+		autoEnable?: boolean
+		gdkUserId?: string
+	}
+	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?.autoImport ?? false;
+export let unLinked = !(config.compiler?.autoImport ?? 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

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

package/dist/js/compilers/PreCompile.js

@@ -6,4 +6,15 @@ Map.prototype.toJSON = function () {
 Array.prototype.lastItem = function () {
     return this[this.length - 1];
 };
-export {};
+const now = performance.now();
+function TypeHighlight(type) {
+    switch (type) {
+        case "INFO":
+            return `\x1b[32mINFO\x1b[0m`;
+        default:
+            return type;
+    }
+}
+export function Log(type, message) {
+    console.log(`\x1b[90m[${(performance.now() - now).toFixed(2)}ms]\x1b[0m`, `[${TypeHighlight(type)}]`, message, "\x1b[0m");
+}

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/{Funtion.js → Function.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/builder.js

@@ -1,34 +1,46 @@
-import { isBuildMode } from "../Configuration.js";
+import { config, isBuildMode, isLinkMode, unLinked } from "../Configuration.js";
 import { Memory } from "../Memory.js";
-import { createBuildFolder, linkToGame } from "./linker.js";
-import { genManifest } from "./manifest.js";
+import { createBuildFolder, gamePath, getBuildFolderName, linkToGame, unlink } from "./linker.js";
+import { genManifest, version } from "./manifest.js";
 import fs from "fs/promises";
+import { BuildCache } from "./buildcache.js";
+import { disableRSP, enableRSP } from "./installer.js";
+import { Log } from "../PreCompile.js";
+import path from "path";
 async function buildUI() {
     const build = Memory.build();
     build.set("ui/_ui_defs.json", {
         ui_defs: Array.from(build.keys()),
     });
-    build.set("build.json", {
-        files: Array.from(build.keys()),
-    });
+    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/build/${file}`;
+        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(Object.fromEntries(Object.entries(value).map(([key, value]) => {
+        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");
+        }))), "utf-8")
+            .then(() => Log("INFO", `${outFile} with ${Object.keys(value).length} elements created!`));
         build.delete(file);
         return file;
     }));
     await Promise.all([
-        fs.writeFile("build/build/manifest.json", await genManifest(), "utf-8"),
-        fs.writeFile("build/build/.gitignore", [...out, "manifest.json"].join("\n"), "utf-8"),
         fs
-            .stat("build/build/pack_icon.png")
-            .catch(() => fs.copyFile("node_modules/asajs/resources/pack_icon.png", "build/build/pack_icon.png")),
+            .writeFile("build/manifest.json", await genManifest(), "utf-8")
+            .then(() => Log("INFO", "build/manifest.json created!")),
+        fs
+            .writeFile("build/.gitignore", [...out, "manifest.json"].join("\n"), "utf-8")
+            .then(() => Log("INFO", "build/.gitignore created!")),
+        BuildCache.set("build-files", [...out, "manifest.json"]).then(() => Log("INFO", "build-files set!")),
+        BuildCache.set("version", version).then(() => Log("INFO", "version set!")),
+        fs
+            .stat("build/pack_icon.png")
+            .catch(() => fs.copyFile("node_modules/asajs/resources/pack_icon.png", "build/pack_icon.png"))
+            .then(() => Log("INFO", "build/pack_icon.png copied!")),
     ]);
     return out.length;
 }
@@ -38,8 +50,26 @@ if (isBuildMode) {
         if (first) {
             await createBuildFolder();
             await buildUI();
-            await linkToGame();
+            if (isLinkMode)
+                await linkToGame();
+            if (config.compiler?.autoEnable)
+                await enableRSP();
+            else
+                await disableRSP();
+            Log("INFO", "Build completed!");
+            console.log("========================= PACK INFO =========================");
+            console.log("Name:", `\x1b[32m${config.packinfo?.name || "MyPack"}\x1b[0m`);
+            console.log("Description:", `\x1b[32m${config.packinfo?.description || "Create your Minecraft JSON-UI resource packs using JavaScript."}\x1b[0m`);
+            console.log("Version:", config.packinfo?.version || [4, 0, 0]);
+            console.log("UUID:", await BuildCache.get("uuid"));
+            if (gamePath)
+                console.log("Install Path:", `\x1b[32m"${path.join(gamePath, await getBuildFolderName())}"\x1b[0m`);
+            console.log("=============================================================");
         }
         first = false;
     });
 }
+else if (isLinkMode)
+    linkToGame();
+else if (unLinked)
+    unlink();