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

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

@@ -1,15 +1,150 @@
 import os from "os";
 import path from "path";
+import fs from "fs";
+import fsp from "fs/promises";
+import { config } from "../Configuration.js";
+import { BuildCache } from "./buildcache.js";
+import { version } from "./manifest.js";
+import { Log } from "../PreCompile.js";
+export const pathinfo = {
+    os: os.platform(),
+    isGdk: false,
+    gamepath: null,
+};
+function getGlobalResourcePackFile(gamepath) {
+    return path.join(gamepath, "minecraftpe/global_resource_packs.json");
+}
+async function readGlobalRspFile(filepath) {
+    try {
+        if (await fsp.stat(filepath)) {
+            return JSON.parse(await fsp.readFile(filepath, "utf-8"));
+        }
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function writeGlobalRspFile(filepath, data) {
+    try {
+        await fsp.writeFile(filepath, JSON.stringify(data), "utf-8");
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function enable(uuid, version, filepath) {
+    try {
+        const globalRsp = await readGlobalRspFile(filepath);
+        if (!globalRsp)
+            return null;
+        const index = globalRsp.findIndex(data => data.pack_id === uuid);
+        if (index === -1) {
+            globalRsp.push({ pack_id: uuid, version });
+            await writeGlobalRspFile(filepath, globalRsp);
+            return true;
+        }
+        else if (globalRsp[index].version.join(".") !== version.join(".")) {
+            globalRsp[index].version = version;
+            await writeGlobalRspFile(filepath, globalRsp);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function disable(uuid, filepath) {
+    try {
+        let globalRsp = await readGlobalRspFile(filepath);
+        if (!globalRsp)
+            return null;
+        let isWrite = false;
+        globalRsp = globalRsp.filter(data => {
+            if (data.pack_id === uuid)
+                isWrite = true;
+            return data.pack_id !== uuid;
+        });
+        if (isWrite) {
+            await writeGlobalRspFile(filepath, globalRsp);
+            return true;
+        }
+        else
+            return false;
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function enableRSP() {
+    if (pathinfo.isGdk && pathinfo.gamepath) {
+        const ids = [], gamepath = path.join(pathinfo.gamepath, "../../..");
+        if (config.compiler?.gdkUserId && /^\d+$/.test(config.compiler.gdkUserId))
+            ids.push(config.compiler.gdkUserId);
+        else
+            ids.push(...(await fsp.readdir(gamepath, { withFileTypes: false })).filter((id) => id !== "Shared"));
+        const [uuid] = await Promise.all([BuildCache.get("uuid")]);
+        if (!uuid)
+            return;
+        await Promise.all(ids.map(async (id) => enable(uuid[0], version, getGlobalResourcePackFile(path.join(gamepath, id, "games/com.mojang"))).then(v => {
+            if (v) {
+                Log("INFO", "Resource Pack enabled automaticly for " + id);
+            }
+        })));
+    }
+    else if (pathinfo.gamepath) {
+        const [uuid] = await Promise.all([BuildCache.get("uuid")]);
+        if (!uuid)
+            return;
+        await enable(uuid[0], version, getGlobalResourcePackFile(pathinfo.gamepath)).then(v => {
+            if (v) {
+                Log("INFO", "Resource Pack enabled automaticly");
+            }
+        });
+    }
+}
+export async function disableRSP() {
+    if (pathinfo.isGdk && pathinfo.gamepath) {
+        const gamepath = path.join(pathinfo.gamepath, "../../..");
+        const [uuid] = await Promise.all([BuildCache.get("uuid")]);
+        if (!uuid)
+            return;
+        await Promise.all((await fsp.readdir(gamepath, { withFileTypes: false })).map(async (id) => disable(uuid[0], getGlobalResourcePackFile(path.join(gamepath, id, "games/com.mojang"))).then(v => {
+            if (v) {
+                Log("INFO", "Resource Pack disabled automaticly for " + id);
+            }
+        })));
+    }
+    else if (pathinfo.gamepath) {
+        const [uuid] = await Promise.all([BuildCache.get("uuid")]);
+        if (!uuid)
+            return;
+        await disable(uuid[0], getGlobalResourcePackFile(pathinfo.gamepath)).then(v => {
+            if (v) {
+                Log("INFO", "Resource Pack disabled automaticly");
+            }
+        });
+    }
+}
 export function getGamedataPath() {
-    switch (os.platform()) {
+    switch (pathinfo.os) {
         case "win32": {
             if (/Windows (10|11)/.test(os.version())) {
-                return path.join(process.env.APPDATA, "Minecraft Bedrock\\Users\\Shared\\games\\com.mojang");
+                let gamedata = path.join(process.env.APPDATA, config.compiler?.importToPreview ? "Minecraft Bedrock Preview" : "Minecraft Bedrock", "\\Users\\Shared\\games\\com.mojang");
+                if (fs.existsSync(gamedata)) {
+                    pathinfo.isGdk = true;
+                    return (pathinfo.gamepath = gamedata);
+                }
+                gamedata = path.join(process.env.LOCALAPPDATA, "Packages", config.compiler?.importToPreview
+                    ? "Microsoft.MinecraftWindowsBeta_8wekyb3d8bbwe"
+                    : "Microsoft.MinecraftUWP_8wekyb3d8bbwe", "LocalState\\games\\com.mojang");
+                if (fs.existsSync(gamedata)) {
+                    return (pathinfo.gamepath = gamedata);
+                }
             }
         }
         default: {
-            console.error(`Your platform is not supported the install feature yet! \nYour OS version: ${os.version()}`);
-            process.exit(1);
+            console.warn(`Your platform is not supported the install feature yet! \nYour OS version: ${os.version()}`);
         }
     }
 }

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

@@ -1,9 +1,9 @@
 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";
+import { getGamedataPath, pathinfo } from "./installer.js";
+import { Log } from "../PreCompile.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));
@@ -18,23 +18,50 @@ function genUUID() {
         `${HEX[b[10]]}${HEX[b[11]]}${HEX[b[12]]}${HEX[b[13]]}${HEX[b[14]]}${HEX[b[15]]}`);
 }
 export async function clearBuild() {
-    await Promise.all(prevData.files.map(file => fs.rm(`build/build/${file}`).catch(() => null)));
+    const files = (await BuildCache.get("build-files")) || [];
+    await Promise.all(files.map(file => fs.rm(`build/${file}`).catch(() => null))).then(() => {
+        if (files.length) {
+            Log("INFO", `Build folder cleared (${files.length} files removed)!`);
+        }
+    });
 }
 export async function createBuildFolder() {
     return fs
         .stat("build")
-        .catch(() => fs.mkdir("build"))
+        .catch(() => fs.mkdir("build").then(() => Log("INFO", "Build folder created!")))
         .then(() => clearBuild());
 }
 export async function getBuildFolderName() {
     return await BuildCache.getWithSetDefault("build-key", () => RandomString(16));
 }
+export let gamePath = null;
 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");
-    });
+    const gamedataPath = getGamedataPath();
+    await BuildCache.set("last-gamedata-path", pathinfo);
+    if (gamedataPath) {
+        const sourcePath = path.resolve("build");
+        const targetPath = path.resolve(gamedataPath, "development_resource_packs", await getBuildFolderName());
+        await fs.stat(targetPath).catch(async () => {
+            await fs
+                .symlink(sourcePath, targetPath, "junction")
+                .then(() => Log("INFO", "Linked build folder to gamedata!"));
+        });
+        gamePath = gamedataPath;
+    }
+    else
+        console.warn("No gamedata path found, cannot link!");
+}
+export async function unlink() {
+    const gamedataPath = await BuildCache.get("last-gamedata-path");
+    if (!gamedataPath?.gamepath)
+        return;
+    const targetPath = path.resolve(gamedataPath.gamepath, "development_resource_packs", await getBuildFolderName());
+    try {
+        await fs.unlink(targetPath).then(() => Log("INFO", "Unlinked build folder from gamedata!"));
+    }
+    catch (error) {
+        console.error(error);
+    }
 }
 export async function getUUID() {
     return await BuildCache.getWithSetDefault("uuid", () => {

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

@@ -1,22 +1,26 @@
+import { config } from "../Configuration.js";
 import { getUUID } from "./linker.js";
+export const version = config.packinfo?.version || [4, 0, 0];
 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.",
+            name: config.packinfo?.name || "AsaJS",
+            description: config.packinfo?.description || "Create your Minecraft JSON-UI resource packs using JavaScript.",
             uuid: uuid1,
-            version: [4, 0, 0],
-            min_engine_version: [1, 21, 132],
+            version,
+            min_engine_version: [1, 21, 80],
         },
         modules: [
             {
                 description: "This resource pack generate by AsaJS.",
                 type: "resources",
                 uuid: uuid2,
-                version: [4, 0, 0],
+                version: version,
             },
         ],
+        subpacks: config.packinfo?.subpacks,
+        metadata: config.packinfo?.metadata,
     });
 }

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}.json`;
+        this.path = path || `asajs/${this.namespace}.json`;
         Memory.add(this);
     }
     setNext(keyframe) {

package/dist/js/components/UI.js

@@ -20,6 +20,7 @@ export class UI extends Class {
     anims = [];
     extendType;
     properties = {};
+    bindCache = new Map();
     constructor(type, name, namespace, path) {
         super();
         this.type = type;
@@ -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;
     }
     /**
@@ -270,14 +271,14 @@ 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) {

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
@@ -205,49 +268,49 @@ properties, namespace, name) {
     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 ExtendsOf

package/dist/js/index.js

@@ -1,3 +1,4 @@
+import "./compilers/Configuration.js";
 import "./compilers/PreCompile.js";
 import "./compilers/ui/builder.js";
 import "./compilers/ui/installer.js";
@@ -8,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/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/PreCompile.d.ts

@@ -6,4 +6,6 @@ declare global {
         lastItem(): T;
     }
 }
+type LogType = "INFO";
+export declare function Log(type: LogType, message: string): void;
 export {};

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/{Funtion.d.ts → Function.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/installer.d.ts

@@ -1 +1,11 @@
-export declare function getGamedataPath(): string;
+export interface PathInfo<Platform = NodeJS.Platform> {
+    os: Platform;
+    isGdk: Platform extends "win32" ? boolean : never;
+    gamepath: string | null;
+}
+export declare const pathinfo: PathInfo;
+export declare function enable(uuid: string, version: [number, number, number], filepath: string): Promise<boolean | null>;
+export declare function disable(uuid: string, filepath: string): Promise<boolean | null>;
+export declare function enableRSP(): Promise<void>;
+export declare function disableRSP(): Promise<void>;
+export declare function getGamedataPath(): string | undefined;

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

@@ -1,5 +1,7 @@
 export declare function clearBuild(): Promise<void>;
 export declare function createBuildFolder(): Promise<void>;
 export declare function getBuildFolderName(): Promise<string>;
+export declare let gamePath: string | null;
 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,2 @@
+export declare const version: [number, number, number];
 export declare function genManifest(): Promise<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

@@ -26,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