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

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 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 });
+    const files = (await BuildCache.get("build-files")) || [];
+    await Promise.all(files.map(file => fs.rm(`build/${file}`).catch(() => null)));
 }
 export async function createBuildFolder() {
     return fs
@@ -8,3 +26,27 @@ 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");
+    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 unlink() {
+    const targetPath = path.resolve(getGamedataPath(), "development_resource_packs", await getBuildFolderName());
+    try {
+        await fs.unlink(targetPath);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+export async function getUUID() {
+    return await BuildCache.getWithSetDefault("uuid", () => {
+        return [genUUID(), genUUID()];
+    });
+}

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

@@ -1 +1,25 @@
-export {};
+import { config } from "../Configuration.js";
+import { getUUID } from "./linker.js";
+export async function genManifest() {
+    const [uuid1, uuid2] = await getUUID();
+    return JSON.stringify({
+        format_version: 2,
+        header: {
+            name: config.packinfo?.name || "AsaJS",
+            description: config.packinfo?.description || "Create your Minecraft JSON-UI resource packs using JavaScript.",
+            uuid: uuid1,
+            version: config.packinfo?.version || [4, 0, 0],
+            min_engine_version: [1, 21, 80],
+        },
+        modules: [
+            {
+                description: "This resource pack generate by AsaJS.",
+                type: "resources",
+                uuid: uuid2,
+                version: [4, 0, 0],
+            },
+        ],
+        subpacks: config.packinfo?.subpacks,
+        metadata: config.packinfo?.metadata,
+    });
+}

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.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 || `asajs/${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 {
@@ -20,6 +20,7 @@ export class UI extends Class {
     anims = [];
     extendType;
     properties = {};
+    bindCache = new Map();
     constructor(type, name, namespace, path) {
         super();
         this.type = type;
@@ -34,7 +35,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;
@@ -55,7 +56,7 @@ export class UI extends Class {
      * @returns
      */
     addBindings(...bindings) {
-        this.bindings.push(...ResolveBinding(...bindings));
+        this.bindings.push(...ResolveBinding(this.bindCache, ...bindings));
         return this;
     }
     /**
@@ -105,8 +106,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 +209,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 +245,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({
@@ -259,18 +271,18 @@ export class ModifyUI extends UI {
         return this.addModifications({
             array_name: ArrayName.BINDINGS,
             operation: Operation.INSERT_BACK,
-            value: ResolveBinding(...bindings),
+            value: ResolveBinding(this.bindCache, ...bindings),
         });
     }
     insertFrontBindings(...bindings) {
         return this.addModifications({
             array_name: ArrayName.BINDINGS,
             operation: Operation.INSERT_FRONT,
-            value: ResolveBinding(...bindings),
+            value: ResolveBinding(this.bindCache, ...bindings),
         });
     }
     insertBindings(...bindings) {
-        return this.insertBackBindings(...bindings);
+        return this.insertFrontBindings(...bindings);
     }
     /**
      * Remove a binding of this element
@@ -298,7 +310,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

@@ -9,6 +9,8 @@ import { AnimType } from "../types/enums/AnimType.js";
 import { AnimationKeyframe } from "./AnimationKeyframe.js";
 import { Animation } from "./Animation.js";
 import { MemoryModify } from "../compilers/Memory.js";
+import { Lexer } from "../compilers/bindings/Lexer.js";
+import { TokenKind, TSTokenKind } from "../compilers/bindings/types.js";
 export function Color(hex) {
     if (typeof hex === "number") {
         return [((hex >> 16) & 0xff) / 0xff, ((hex >> 8) & 0xff) / 0xff, (hex & 0xff) / 0xff];
@@ -36,15 +38,69 @@ export function Color(hex) {
         }
     }
 }
-export function ResolveBinding(...bindings) {
+export function ResolveBinding(cache, ...bindings) {
     const result = [];
     for (const binding of bindings) {
         if (binding.source_property_name) {
             if (isCompileBinding(binding.source_property_name)) {
-                const { gen, out } = new Parser(binding.source_property_name.slice(1, -1)).out();
-                if (gen)
-                    result.push(...gen);
-                binding.source_property_name = out;
+                const inputBindings = binding.source_property_name.slice(1, -1);
+                if (binding.source_control_name) {
+                    // @ts-ignore
+                    const tokensMapping = (token) => {
+                        if (token.kind === TokenKind.VARIABLE) {
+                            const mapkey = `mapping:${binding.source_control_name}:${token.value}`;
+                            if (cache.has(mapkey)) {
+                                return {
+                                    ...token,
+                                    value: cache.get(mapkey),
+                                };
+                            }
+                            else {
+                                const ret = RandomBindingString(16);
+                                cache.set(mapkey, ret);
+                                result.push({
+                                    source_property_name: token.value,
+                                    source_control_name: binding.source_control_name,
+                                    target_property_name: ret,
+                                    binding_type: BindingType.VIEW,
+                                });
+                                return {
+                                    ...token,
+                                    value: ret,
+                                };
+                            }
+                        }
+                        else if (token.kind === TokenKind.TEMPLATE_STRING) {
+                            return {
+                                ...token,
+                                // @ts-ignore
+                                value: token.value.map((tstoken) => {
+                                    if (tstoken.kind === TSTokenKind.STRING)
+                                        return tstoken;
+                                    else {
+                                        return {
+                                            ...tstoken,
+                                            tokens: tstoken.tokens.map(tokensMapping),
+                                        };
+                                    }
+                                }),
+                            };
+                        }
+                        else
+                            return token;
+                    };
+                    const { gen, out } = new Parser(inputBindings, cache, Lexer(inputBindings).map(tokensMapping)).out();
+                    delete binding.source_control_name;
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
+                else {
+                    const { gen, out } = new Parser(inputBindings, cache).out();
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
             }
             binding.binding_type = BindingType.VIEW;
             if (!binding.target_property_name)
@@ -107,6 +163,13 @@ export function Modify(namespace, name) {
     // @ts-ignore
     if (memoryUI)
         return memoryUI;
+    if (!paths[namespace]) {
+        throw new Error(`Namespace '${namespace}' does not exist`);
+        // @ts-ignore
+    }
+    else if (!paths[namespace][name]) {
+        throw new Error(`Element '${name}' does not exist in namespace '${namespace}'`);
+    }
     // @ts-ignore
     const modifyUI = new ModifyUI(namespace, name, 
     // @ts-ignore
@@ -178,9 +241,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,53 +252,68 @@ 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) {
+export function OffsetKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.OFFSET, properties || {}, name, namespace);
 }
-export function KeyframeSize(properties, namespace, name) {
+export function SizeKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.SIZE, properties || {}, name, namespace);
 }
-export function KeyframeUV(properties, namespace, name) {
+export function UVKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.UV, properties || {}, name, namespace);
 }
-export function KeyframeClip(properties, namespace, name) {
+export function ClipKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.CLIP, properties || {}, name, namespace);
 }
-export function KeyframeColor(properties, namespace, name) {
+export function ColorKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.COLOR, properties || {}, name, namespace);
 }
-export function KeyframeAlpha(properties, namespace, name) {
+export function AlphaKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.ALPHA, properties || {}, name, namespace);
 }
-export function KeyframeWait(properties, namespace, name) {
+export function WaitKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.WAIT, properties || {}, name, namespace);
 }
-export function KeyframeFlipBook(properties, namespace, name) {
+export function FlipBookKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.FLIP_BOOK, properties || {}, name, namespace);
 }
-export function KeyframeAsepriteFlipBook(properties, namespace, name) {
+export function AsepriteFlipBookKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.ASEPRITE_FLIP_BOOK, properties || {}, name, namespace);
 }
-export function AnimationOffset(...keyframes) {
+export function OffsetAnimation(...keyframes) {
     return new Animation(AnimType.OFFSET, ...keyframes);
 }
-export function AnimationSize(...keyframes) {
+export function SizeAnimation(...keyframes) {
     return new Animation(AnimType.SIZE, ...keyframes);
 }
-export function AnimationUV(...keyframes) {
+export function UVAnimation(...keyframes) {
     return new Animation(AnimType.UV, ...keyframes);
 }
-export function AnimationClip(...keyframes) {
+export function ClipAnimation(...keyframes) {
     return new Animation(AnimType.CLIP, ...keyframes);
 }
-export function AnimationColor(...keyframes) {
+export function ColorAnimation(...keyframes) {
     return new Animation(AnimType.COLOR, ...keyframes);
 }
-export function AnimationAlpha(...keyframes) {
+export function AlphaAnimation(...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/config..js

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

package/dist/js/config.js

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

package/dist/js/index.js

@@ -1,5 +1,7 @@
+import "./compilers/Configuration.js";
 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";
@@ -7,3 +9,5 @@ export * from "./components/Utils.js";
 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";

package/dist/js/types/config.js

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

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

@@ -1 +1,5 @@
-export declare const isBuildMode: boolean;
+import { Config } from "../../config.js";
+export declare const config: Config;
+export declare let isBuildMode: boolean;
+export declare let isLinkMode: boolean;
+export declare let unLinked: boolean;

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

@@ -1,4 +1,7 @@
 export declare function isBlankChar(char: string): boolean;
 export declare function isWordChar(char: string): boolean | "";
 export declare function isNumberChar(char: string): boolean;
+export declare function isHexChar(char: string): boolean;
+export declare function isBinaryChar(char: string): boolean;
+export declare function isOctalChar(char: string): boolean;
 export declare function isCompileBinding(input: string): boolean;

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

@@ -0,0 +1,7 @@
+import { Expression, GenBinding } from "./types.js";
+type Callback = (...args: Expression[]) => {
+    genBindings?: GenBinding[];
+    value: Expression;
+};
+export declare const FunctionMap: Map<string, Callback>;
+export {};

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

@@ -3,5 +3,5 @@ type Callback = (...args: Expression[]) => {
     genBindings?: GenBinding[];
     value: Expression;
 };
-export declare const FuntionMap: Map<string, Callback>;
+export declare const FunctionMap: Map<string, Callback>;
 export {};

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

@@ -2,11 +2,17 @@ import { Expression, GenBinding, Token } from "./types.js";
 import { BindingItem } from "../../types/properties/value.js";
 export declare class Parser {
     private input;
+    private cache;
     position: number;
-    tokens: Token[];
     genBindings: GenBinding[];
     output: Expression;
-    constructor(input: string);
+    tokens: Token[];
+    constructor(input: string, cache?: Map<string, unknown>, tokens?: Token[]);
+    static intToBin(input: string): {
+        ret: `#${string}`;
+        bindings: GenBinding[];
+    };
+    intToBin(input: string): string;
     at(): Token;
     eat(): Token;
     last(): Token;
@@ -16,14 +22,17 @@ export declare class Parser {
     private parseComparisonExpression;
     private parseAdditiveExpression;
     private parseMultiplicativeExpression;
+    private parseBitwiseLogicExpression;
+    private parseBitwiseShiftExpression;
     private parsePrimaryExpression;
     private parseCallableOrLiteral;
-    private funtionCall;
+    private functionCall;
     private expect;
     private warn;
     private getPointer;
     out(): {
         gen?: BindingItem[];
         out: Expression;
+        cache: Map<string, unknown>;
     };
 }

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,6 @@
 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 unlink(): 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/AnimationKeyframe.d.ts

@@ -15,8 +15,8 @@ export declare class AnimationKeyframe<T extends AnimType> extends Class {
     clearNext(): this;
     protected toJsonUI(): KeyframeAnimationProperties<AnimType>;
     protected toJSON(): (Partial<import("../types/properties/element/Animation.js").DurationAnimation> & import("../types/properties/element/Animation.js").KeyframeAnimationPropertiesItem) | (Partial<import("../types/properties/element/Animation.js").AsepriteFlipBookAnimation> & import("../types/properties/element/Animation.js").KeyframeAnimationPropertiesItem) | {
-        from?: import("../types/properties/value.js").Array2<string | number> | undefined;
-        to?: import("../types/properties/value.js").Array2<string | number> | undefined;
+        from?: import("../types/properties/value.js").Value<number> | undefined;
+        to?: import("../types/properties/value.js").Value<number> | undefined;
         duration?: import("../types/properties/value.js").Value<number> | undefined;
         easing?: import("../types/properties/value.js").Value<string | import("../index.js").Easing> | undefined;
         next?: import("../types/properties/value.js").Value<string | AnimationKeyframe<AnimType> | Animation<AnimType>>;
@@ -33,8 +33,8 @@ export declare class AnimationKeyframe<T extends AnimType> extends Class {
         wait_until_rendered_to_play?: import("../types/properties/value.js").Value<boolean>;
         anim_type: T;
     } | {
-        from?: import("../types/properties/value.js").Value<number> | undefined;
-        to?: import("../types/properties/value.js").Value<number> | undefined;
+        from?: import("../types/properties/value.js").Array2<string | number> | undefined;
+        to?: import("../types/properties/value.js").Array2<string | number> | undefined;
         duration?: import("../types/properties/value.js").Value<number> | undefined;
         easing?: import("../types/properties/value.js").Value<string | import("../index.js").Easing> | undefined;
         next?: import("../types/properties/value.js").Value<string | AnimationKeyframe<AnimType> | Animation<AnimType>>;

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[];
@@ -21,6 +26,7 @@ export declare class UI<T extends Type, K extends Renderer | null = null> extend
     protected readonly anims: (Animation<AnimType> | AnimationKeyframe<AnimType>)[];
     protected readonly extendType?: Type;
     protected properties: Properties<T, K>;
+    protected bindCache: Map<string, unknown>;
     constructor(type?: T | undefined, name?: string, namespace?: string, path?: string);
     /**
      * Set properties for this element
@@ -62,7 +68,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 +133,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 {};