asajs 4.0.0-indev-1 → 4.0.0-indev-2

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/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,36 @@
 import { isBuildMode } from "../Configuration.js";
 import { Memory } from "../Memory.js";
-import { createBuildFolder } from "./linker.js";
+import { createBuildFolder, linkToGame } from "./linker.js";
+import { genManifest } from "./manifest.js";
 import fs from "fs/promises";
 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]) => {
+    build.set("build.json", {
+        files: Array.from(build.keys()),
+    });
+    const out = await Promise.all(build.entries().map(async ([file, value]) => {
         const outFile = `build/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/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")),
+    ]);
+    return out.length;
 }
 if (isBuildMode) {
     let first = true;
@@ -24,6 +38,7 @@ if (isBuildMode) {
         if (first) {
             await createBuildFolder();
             await buildUI();
+            await linkToGame();
         }
         first = false;
     });

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);
+        }
+    }
+}

package/dist/js/compilers/ui/linker.js

@@ -1,6 +1,24 @@
 import fs from "fs/promises";
+import { BuildCache } from "./buildcache.js";
+import { RandomString } from "../../components/Utils.js";
+import { prevData } from "./prevdata.js";
+import path from "path";
+import { getGamedataPath } from "./installer.js";
+const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function genUUID() {
+    const b = Array.from({ length: 16 }, () => Math.floor(Math.random() * 256));
+    // version 4
+    b[6] = (b[6] & 0x0f) | 0x40;
+    // variant 10xx
+    b[8] = (b[8] & 0x3f) | 0x80;
+    return (`${HEX[b[0]]}${HEX[b[1]]}${HEX[b[2]]}${HEX[b[3]]}-` +
+        `${HEX[b[4]]}${HEX[b[5]]}-` +
+        `${HEX[b[6]]}${HEX[b[7]]}-` +
+        `${HEX[b[8]]}${HEX[b[9]]}-` +
+        `${HEX[b[10]]}${HEX[b[11]]}${HEX[b[12]]}${HEX[b[13]]}${HEX[b[14]]}${HEX[b[15]]}`);
+}
 export async function clearBuild() {
-    await fs.rm("build/build", { recursive: true, force: true });
+    await Promise.all(prevData.files.map(file => fs.rm(`build/build/${file}`).catch(() => null)));
 }
 export async function createBuildFolder() {
     return fs
@@ -8,3 +26,18 @@ export async function createBuildFolder() {
         .catch(() => fs.mkdir("build"))
         .then(() => clearBuild());
 }
+export async function getBuildFolderName() {
+    return await BuildCache.getWithSetDefault("build-key", () => RandomString(16));
+}
+export async function linkToGame() {
+    const sourcePath = path.resolve("build/build");
+    const targetPath = path.resolve(getGamedataPath(), "development_resource_packs", await getBuildFolderName());
+    await fs.stat(targetPath).catch(async () => {
+        await fs.symlink(sourcePath, targetPath, "junction");
+    });
+}
+export async function getUUID() {
+    return await BuildCache.getWithSetDefault("uuid", () => {
+        return [genUUID(), genUUID()];
+    });
+}

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

@@ -1 +1,22 @@
-export {};
+import { getUUID } from "./linker.js";
+export async function genManifest() {
+    const [uuid1, uuid2] = await getUUID();
+    return JSON.stringify({
+        format_version: 2,
+        header: {
+            name: "AsaJS UI",
+            description: "A framework for creating UIs for AsaJS.",
+            uuid: uuid1,
+            version: [4, 0, 0],
+            min_engine_version: [1, 21, 132],
+        },
+        modules: [
+            {
+                description: "This resource pack generate by AsaJS.",
+                type: "resources",
+                uuid: uuid2,
+                version: [4, 0, 0],
+            },
+        ],
+    });
+}

package/dist/js/compilers/ui/prevdata.js

@@ -0,0 +1,8 @@
+import fs from "fs";
+export let prevData;
+try {
+    prevData = JSON.parse(fs.readFileSync("build/build/build.json", "utf-8"));
+}
+catch (error) {
+    prevData = { files: [] };
+}

package/dist/js/components/AnimationKeyframe.js

@@ -25,7 +25,7 @@ export class AnimationKeyframe extends Class {
         }
         this.name = name || RandomString(16);
         this.namespace = namespace || RandomNamespace();
-        this.path = path || `@/${this.namespace}`;
+        this.path = path || `@/${this.namespace}.json`;
         Memory.add(this);
     }
     setNext(keyframe) {

package/dist/js/components/UI.js

@@ -3,7 +3,7 @@ import { Memory } from "../compilers/Memory.js";
 import { ArrayName } from "../types/enums/ArrayName.js";
 import { Operation } from "../types/enums/Operation.js";
 import { Class } from "./Class.js";
-import { ExtendsOf, RandomString, ResolveBinding } from "./Utils.js";
+import { RandomString, ResolveBinding } from "./Utils.js";
 import { RandomNamespace } from "../compilers/Random.js";
 import util from "node:util";
 export class UI extends Class {
@@ -34,7 +34,7 @@ export class UI extends Class {
         this.name = name?.match(/^(\w|\/)+/)?.[0] || RandomString(16);
         this.namespace = namespace || RandomNamespace();
         if (!path)
-            this.path = `@/${this.namespace}`;
+            this.path = `asajs/${this.namespace}.json`;
         else
             this.path = path;
         this.extendable = this.name.search("/") === -1;
@@ -105,8 +105,17 @@ export class UI extends Class {
      * @param namespace
      * @returns
      */
-    clone(properties, name, namespace) {
-        return ExtendsOf(this, properties, name, namespace);
+    createExtends(properties, name, namespace) {
+        if (!this.extendable)
+            throw new Error("This element is not extendable");
+        const ui = new UI(undefined, name, namespace);
+        if (properties)
+            ui.setProperties(properties);
+        // @ts-ignore
+        ui.extend = this;
+        // @ts-ignore
+        ui.extendType = this.type || this.extendType;
+        return ui;
     }
     toString() {
         return `@${this.namespace}.${this.name}`;
@@ -199,9 +208,11 @@ export class ModifyUI extends UI {
         return this.addModifications({
             array_name: ArrayName.CONTROLS,
             operation: Operation.INSERT_FRONT,
-            value: {
-                [`${name}${child}`]: properties || {},
-            },
+            value: [
+                {
+                    [`${name}${child}`]: properties || {},
+                },
+            ],
         });
     }
     insertAfterChild(where, child, properties, name) {
@@ -233,7 +244,7 @@ export class ModifyUI extends UI {
         });
     }
     insertChild(child, properties) {
-        return this.insertBackChild(child, properties);
+        return this.insertFrontChild(child, properties);
     }
     replaceChild(where, child, properties) {
         return this.addModifications({
@@ -270,7 +281,7 @@ export class ModifyUI extends UI {
         });
     }
     insertBindings(...bindings) {
-        return this.insertBackBindings(...bindings);
+        return this.insertFrontBindings(...bindings);
     }
     /**
      * Remove a binding of this element
@@ -298,7 +309,7 @@ export class ModifyUI extends UI {
         });
     }
     insertButtonMappings(...buttonMappings) {
-        return this.insertBackButtonMappings(...buttonMappings);
+        return this.insertFrontButtonMappings(...buttonMappings);
     }
     /**
      * Remove a button mapping of this element

package/dist/js/components/Utils.js

@@ -178,9 +178,8 @@ export function SliderBox(properties, namespace, name) {
     return new UI(Type.SLIDER_BOX, name, namespace).setProperties(properties || {});
 }
 export function ExtendsOf(element, properties, namespace, name) {
-    if (!element.extendable) {
+    if (!element.extendable)
         throw new Error("Cannot extend a UI that cannot be extended");
-    }
     const ui = new UI(undefined, name, namespace);
     if (properties)
         ui.setProperties(properties);
@@ -190,6 +189,21 @@ export function ExtendsOf(element, properties, namespace, name) {
     ui.extendType = element.type || element.extendType;
     return ui;
 }
+export function VanillaExtendsOf(originNamespace, originName, 
+// @ts-ignore
+properties, namespace, name) {
+    // @ts-ignore
+    const ui = new UI(undefined, name, namespace);
+    if (properties)
+        ui.setProperties(properties);
+    // @ts-ignore
+    ui.extend = {
+        name: originName,
+        namespace: originNamespace,
+        toString: () => `@${originNamespace}.${originName}`,
+    };
+    return ui;
+}
 // Quick Keyframe
 export function KeyframeOffset(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.OFFSET, properties || {}, name, namespace);
@@ -236,7 +250,7 @@ export function AnimationColor(...keyframes) {
 export function AnimationAlpha(...keyframes) {
     return new Animation(AnimType.ALPHA, ...keyframes);
 }
-// Animation Extendof
+// Animation ExtendsOf
 export function AnimationExtendsOf(animation, properties) {
     const anim = new AnimationKeyframe(animation.type, properties || {});
     // @ts-ignore

package/dist/js/index.js

@@ -1,5 +1,6 @@
 import "./compilers/PreCompile.js";
 import "./compilers/ui/builder.js";
+import "./compilers/ui/installer.js";
 export { Animation } from "./components/Animation.js";
 export { AnimationKeyframe } from "./components/AnimationKeyframe.js";
 export { ModifyUI, UI } from "./components/UI.js";

package/dist/types/compilers/ui/buildcache.d.ts

@@ -0,0 +1,8 @@
+export declare class BuildCache {
+    private static queue;
+    private static enqueue;
+    static get<T = unknown>(key: string): Promise<T | null>;
+    static getWithDefault<T = unknown>(key: string, defaultValue: (() => T) | T): Promise<T>;
+    static getWithSetDefault<T>(key: string, defaultValue: (() => T) | T): Promise<T>;
+    static set(key: string, value: unknown): Promise<void>;
+}

package/dist/types/compilers/ui/builddata.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/compilers/ui/installer.d.ts

@@ -1 +1 @@
-export {};
+export declare function getGamedataPath(): string;

package/dist/types/compilers/ui/linker.d.ts

@@ -1,2 +1,5 @@
 export declare function clearBuild(): Promise<void>;
 export declare function createBuildFolder(): Promise<void>;
+export declare function getBuildFolderName(): Promise<string>;
+export declare function linkToGame(): Promise<void>;
+export declare function getUUID(): Promise<[string, string]>;

package/dist/types/compilers/ui/manifest.d.ts

@@ -1 +1 @@
-export {};
+export declare function genManifest(): Promise<string>;

package/dist/types/compilers/ui/prevdata.d.ts

@@ -0,0 +1,3 @@
+export declare let prevData: {
+    files: string[];
+};

package/dist/types/components/UI.d.ts

@@ -7,12 +7,17 @@ import { Animation } from "./Animation.js";
 import { AnimationKeyframe } from "./AnimationKeyframe.js";
 import { Class } from "./Class.js";
 import util from "node:util";
+interface ExtendUI {
+    name: string;
+    namespace: string;
+    toString(): string;
+}
 export declare class UI<T extends Type, K extends Renderer | null = null> extends Class {
     type?: T | undefined;
     readonly path: string;
     readonly name: string;
     readonly namespace: string;
-    readonly extend?: UI<Type, Renderer | null>;
+    readonly extend?: UI<Type, Renderer | null> | ExtendUI;
     readonly extendable: boolean;
     protected readonly controls: Map<string, [UI<Type, Renderer | null>, Properties<Type, Renderer | null>]>;
     protected readonly bindings: BindingItem[];
@@ -62,7 +67,7 @@ export declare class UI<T extends Type, K extends Renderer | null = null> extend
      * @param namespace
      * @returns
      */
-    clone(properties?: Properties<T, K>, name?: string, namespace?: string): UI<T, K>;
+    createExtends(properties?: Properties<T, K>, name?: string, namespace?: string): UI<T, K>;
     protected toString(): string;
     protected toJsonUI(): any;
     protected toJSON(): any;
@@ -127,3 +132,4 @@ export declare class ModifyUI<T extends Type = Type.PANEL, S extends string = st
     protected toJSON(): any;
     protected [util.inspect.custom]($: any, opts: any): string;
 }
+export {};

package/dist/types/components/Utils.d.ts

@@ -49,6 +49,7 @@ export declare function ScrollView(properties?: ScrollView, namespace?: string,
 export declare function Slider(properties?: Slider, namespace?: string, name?: string): UI<Type.SLIDER, null>;
 export declare function SliderBox(properties?: SliderBox, namespace?: string, name?: string): UI<Type.SLIDER_BOX, null>;
 export declare function ExtendsOf<T extends Type, K extends Renderer | null>(element: UI<T, K>, properties?: Properties<T, K>, namespace?: string, name?: string): typeof element;
+export declare function VanillaExtendsOf<T extends Namespace, K extends Exclude<Element<T>, `${string}/${string}`>>(originNamespace: T, originName: K, properties?: Properties<VanillaType<T, K>, null>, namespace?: string, name?: string): UI<VanillaType<T, K>, null>;
 export declare function KeyframeOffset(properties?: KeyframeAnimationProperties<AnimType.OFFSET>, namespace?: string, name?: string): AnimationKeyframe<AnimType.OFFSET>;
 export declare function KeyframeSize(properties?: KeyframeAnimationProperties<AnimType.SIZE>, namespace?: string, name?: string): AnimationKeyframe<AnimType.SIZE>;
 export declare function KeyframeUV(properties?: KeyframeAnimationProperties<AnimType.UV>, namespace?: string, name?: string): AnimationKeyframe<AnimType.UV>;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import "./compilers/PreCompile.js";
 import "./compilers/ui/builder.js";
+import "./compilers/ui/installer.js";
 export { Animation } from "./components/Animation.js";
 export { AnimationKeyframe } from "./components/AnimationKeyframe.js";
 export { ModifyUI, UI } from "./components/UI.js";

package/package.json

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