@adaas/are 0.0.2 → 0.0.4

package/dist/node/lib/AreComponent/Are.context.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/AreComponent/Are.context.ts"],"names":[],"mappings":";;;;AAWO,IAAM,UAAA,GAAN,cAAyB,UAAA,CAAW;AAAA,EAKvC,WAAA,CAAY,SAAiB,EAAA,EAAI;AAC7B,IAAA,KAAA,CAAM,EAAE,IAAA,EAAM,YAAA,EAAc,CAAA;AAHhC,IAAA,IAAA,CAAU,SAAyB,EAAC;AAIhC,IAAA,IAAA,CAAK,OAAA,GAAU,MAAA;AAAA,EACnB;AAAA,EAEA,IAAI,KAAA,GAAQ;AACR,IAAA,OAAO,SAAA,CAAU,MAAM,IAAI,CAAA;AAAA,EAC/B;AAAA,EAEA,IAAI,KAAA,GAAwB;AACxB,IAAA,OAAO,IAAA,CAAK,MAAA;AAAA,EAChB;AAAA,EAEA,IAAI,MAAA,GAAiB;AACjB,IAAA,OAAO,IAAA,CAAK,OAAA;AAAA,EAChB;AAAA,EAEA,QAAQ,IAAA,EAAe;AACnB,IAAA,IAAA,CAAK,MAAA,CAAO,KAAK,IAAI,CAAA;AACrB,IAAA,IAAA,CAAK,KAAA,CAAM,SAAS,IAAI,CAAA;AAAA,EAC5B;AAAA,EAEA,WAAW,IAAA,EAAe;AACtB,IAAA,IAAA,CAAK,MAAA,GAAS,IAAA,CAAK,MAAA,CAAO,MAAA,CAAO,CAAA,CAAA,KAAK,CAAA,CAAE,KAAA,CAAM,QAAA,EAAS,KAAM,IAAA,CAAK,KAAA,CAAM,QAAA,EAAU,CAAA;AAAA,EACtF;AAEJ;AA/Ba,UAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,YAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,UAAA,CAAA","file":"Are.context.mjs","sourcesContent":["import { A_Context, A_Fragment } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { AreNode } from \"@adaas/are/node\";\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreContext',\n    description: 'Context fragment for the A-Concept Rendering Engine (ARE) framework, serving as a foundational component for managing shared state and configurations within the ARE environment. This Context uses to encapsulate global settings, resources, and utilities that can be accessed by various ARE components and entities during the rendering and interaction processes.'\n})\nexport class AreContext extends A_Fragment {\n\n    protected _source: string;\n    protected _roots: Array<AreNode> = [];\n\n    constructor(source: string = '') {\n        super({ name: 'AreContext' });\n        this._source = source;\n    }\n\n    get scope() {\n        return A_Context.scope(this);\n    }\n\n    get roots(): Array<AreNode> {\n        return this._roots;\n    }\n\n    get source(): string {\n        return this._source;\n    }\n\n    addRoot(node: AreNode) {\n        this._roots.push(node);\n        this.scope.register(node);\n    }\n\n    removeRoot(node: AreNode) {\n        this._roots = this._roots.filter(r => r.aseid.toString() !== node.aseid.toString());\n    }\n\n}\n"]}
+{"version":3,"sources":["../../../../src/lib/AreComponent/Are.context.ts"],"names":[],"mappings":"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","file":"Are.context.mjs","sourcesContent":["import { A_Context, A_Fragment } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { A_SignalVector } from \"@adaas/a-utils/a-signal\";\nimport { AreNode } from \"@adaas/are/node/AreNode.entity\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { A_ExecutionContext } from \"@adaas/a-utils/a-execution\";\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreContext',\n    description: 'Context fragment for the A-Concept Rendering Engine (ARE) framework, serving as a foundational component for managing shared state and configurations within the ARE environment. This Context uses to encapsulate global settings, resources, and utilities that can be accessed by various ARE components and entities during the rendering and interaction processes.'\n})\nexport class AreContext extends A_ExecutionContext {\n\n    /**\n     * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.\n     */\n    protected _source: string;\n    /**\n     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.\n     */\n    protected _roots: Array<AreNode> = [];\n    /**\n     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.\n     */\n    protected _signalsMap: Map<string, A_SignalVector> = new Map();\n\n    protected _performance = new Map<string, number>();\n    protected _performanceStart = new Map<string, number>();\n    protected _performanceDepth = new Map<string, number>();\n\n    /**\n     * The global object can be used to store any global data or configurations that need to be accessed across different components and entities within the ARE framework. This can include things like theme settings, user preferences, or any other shared data that is relevant to the entire scene or application. By centralizing this information in the context, it allows for easier management and access to global state without needing to pass it through multiple layers of components or entities.\n     */\n    get globals() {\n        return this.get('globals') || {};\n    }\n\n\n    constructor(\n        /**\n         * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.\n         */\n        source: string = ''\n    ) {\n        super('AreContext');\n        this._source = source;\n    }\n    /**\n     * The scope of the context, which can be used to access other entities and features within the same scope. This is particularly useful for components that need to interact with other parts of the scene or component, as it allows them to access shared data and functionality without needing to pass it explicitly through parameters.\n     */\n    get scope() {\n        return A_Context.scope(this);\n    }\n    /**\n     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.\n     */\n    get roots(): Array<AreNode> {\n        return this._roots;\n    }\n    /**\n     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.\n     */\n    get source(): string {\n        return this._source;\n    }\n\n    get performance(): Array<string> {\n        const perfObj: Array<string> = [];\n        this._performance.forEach((value, key) => {\n            perfObj.push(`${key}: ${value} ms`);\n        });\n        return perfObj;\n    }\n\n\n    get stats() {\n        return [\n            `- Total Roots: ${this._roots.length}`,\n            `- Total Nodes in Scene: ${this._roots.reduce((acc, root) => acc + this.countNodes(root), 0,)}`,\n            `- Total Instructions: ${this._roots.reduce((acc, root) => acc + this.countInstructions(root), 0,)}`,\n        ]\n    }\n\n    protected countInstructions(node: AreNode): number {\n        let count = 0; // Count instructions for the current node\n        // Assuming each node has a method or property that returns its instructions\n        if (node.scene) {\n            count += node.scene.instructions.length;\n        }\n        for (const child of node.children) {\n            count += this.countInstructions(child); // Recursively count instructions in child nodes\n        }\n        return count;\n    }\n\n    protected countNodes(node: AreNode): number {\n        let count = 1; // Count the current node\n        for (const child of node.children) {\n            count += this.countNodes(child); // Recursively count child nodes\n        }\n        return count;\n    }\n\n    /**\n     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.\n     * \n     * @param node \n     */\n    addRoot(node: AreNode) {\n        this._roots.push(node);\n        this.scope.register(node);\n    }\n    /**\n     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.\n     * \n     * @param node \n     */\n    removeRoot(node: AreNode) {\n        this._roots = this._roots.filter(r => r.aseid.toString() !== node.aseid.toString());\n    }\n\n\n\n\n    startPerformance(label: string = 'default') {\n        const depth = this._performanceDepth.get(label) || 0;\n        this._performanceDepth.set(label, depth + 1);\n\n        if (depth === 0) {\n            this._performanceStart.set(label, Date.now());\n        }\n    }\n\n    endPerformance(label: string) {\n        const depth = this._performanceDepth.get(label) || 0;\n\n        if (depth <= 1) {\n            const startTime = this._performanceStart.get(label) || this._performanceStart.get('default');\n\n            if (startTime) {\n                const duration = Date.now() - startTime;\n                const accumulated = this._performance.get(label) || 0;\n                this._performance.set(label, accumulated + duration);\n                this._performanceStart.delete(label);\n            }\n\n            this._performanceDepth.delete(label);\n        } else {\n            this._performanceDepth.set(label, depth - 1);\n        }\n    }\n}\n"]}

package/dist/node/lib/AreComponent/Are.meta.d.mts

@@ -0,0 +1,14 @@
+import { A_ComponentMeta, A_TYPES__ComponentMeta } from '@adaas/a-concept';
+import { A_SignalVector } from '@adaas/a-utils/a-signal';
+
+/**
+ * The AreMeta class serves as a metadata container for components within the A-Concept Rendering Engine (ARE) framework. It extends the base A_ComponentMeta class and includes additional properties and features specific to ARE components. The AreMeta class can be used to define and manage metadata for ARE components, such as their template, styles, data, and signal handling logic, allowing for a structured and organized way to manage component behavior and interactions within the ARE environment.
+ */
+declare class AreMeta<T extends Record<string, any> = Record<string, any>> extends A_ComponentMeta<T & A_TYPES__ComponentMeta> {
+    /**
+     * Optional property to store a signal vector associated with the component. This can be used to manage and handle signals emitted by the component or other parts of the application, allowing for dynamic interactions and responsive behavior based on changes in the application state or user input.
+     */
+    vector?: A_SignalVector;
+}
+
+export { AreMeta };

package/dist/node/lib/AreComponent/Are.meta.d.ts

@@ -0,0 +1,14 @@
+import { A_ComponentMeta, A_TYPES__ComponentMeta } from '@adaas/a-concept';
+import { A_SignalVector } from '@adaas/a-utils/a-signal';
+
+/**
+ * The AreMeta class serves as a metadata container for components within the A-Concept Rendering Engine (ARE) framework. It extends the base A_ComponentMeta class and includes additional properties and features specific to ARE components. The AreMeta class can be used to define and manage metadata for ARE components, such as their template, styles, data, and signal handling logic, allowing for a structured and organized way to manage component behavior and interactions within the ARE environment.
+ */
+declare class AreMeta<T extends Record<string, any> = Record<string, any>> extends A_ComponentMeta<T & A_TYPES__ComponentMeta> {
+    /**
+     * Optional property to store a signal vector associated with the component. This can be used to manage and handle signals emitted by the component or other parts of the application, allowing for dynamic interactions and responsive behavior based on changes in the application state or user input.
+     */
+    vector?: A_SignalVector;
+}
+
+export { AreMeta };

package/dist/node/lib/AreComponent/Are.meta.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+
+class AreMeta extends aConcept.A_ComponentMeta {
+}
+
+exports.AreMeta = AreMeta;
+//# sourceMappingURL=Are.meta.js.map
+//# sourceMappingURL=Are.meta.js.map

package/dist/node/lib/AreComponent/Are.meta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreComponent/Are.meta.ts"],"names":["A_ComponentMeta"],"mappings":";;;;AAQO,MAAM,gBAAqEA,wBAAA,CAA4C;AAO9H","file":"Are.meta.js","sourcesContent":["import { A_ComponentMeta, A_TYPES__ComponentMeta } from \"@adaas/a-concept\";\nimport type { A_SignalVector } from \"@adaas/a-utils/a-signal\";\n\n\n\n/**\n * The AreMeta class serves as a metadata container for components within the A-Concept Rendering Engine (ARE) framework. It extends the base A_ComponentMeta class and includes additional properties and features specific to ARE components. The AreMeta class can be used to define and manage metadata for ARE components, such as their template, styles, data, and signal handling logic, allowing for a structured and organized way to manage component behavior and interactions within the ARE environment.\n */\nexport class AreMeta<T extends Record<string, any> = Record<string, any>> extends A_ComponentMeta<T & A_TYPES__ComponentMeta> {\n\n    /**\n     * Optional property to store a signal vector associated with the component. This can be used to manage and handle signals emitted by the component or other parts of the application, allowing for dynamic interactions and responsive behavior based on changes in the application state or user input.\n     */\n    vector?: A_SignalVector\n\n}"]}

package/dist/node/lib/AreComponent/Are.meta.mjs

@@ -0,0 +1,9 @@
+import '../../chunk-EQQGB2QZ.mjs';
+import { A_ComponentMeta } from '@adaas/a-concept';
+
+class AreMeta extends A_ComponentMeta {
+}
+
+export { AreMeta };
+//# sourceMappingURL=Are.meta.mjs.map
+//# sourceMappingURL=Are.meta.mjs.map

package/dist/node/lib/AreComponent/Are.meta.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreComponent/Are.meta.ts"],"names":[],"mappings":";;;AAQO,MAAM,gBAAqE,eAAA,CAA4C;AAO9H","file":"Are.meta.mjs","sourcesContent":["import { A_ComponentMeta, A_TYPES__ComponentMeta } from \"@adaas/a-concept\";\nimport type { A_SignalVector } from \"@adaas/a-utils/a-signal\";\n\n\n\n/**\n * The AreMeta class serves as a metadata container for components within the A-Concept Rendering Engine (ARE) framework. It extends the base A_ComponentMeta class and includes additional properties and features specific to ARE components. The AreMeta class can be used to define and manage metadata for ARE components, such as their template, styles, data, and signal handling logic, allowing for a structured and organized way to manage component behavior and interactions within the ARE environment.\n */\nexport class AreMeta<T extends Record<string, any> = Record<string, any>> extends A_ComponentMeta<T & A_TYPES__ComponentMeta> {\n\n    /**\n     * Optional property to store a signal vector associated with the component. This can be used to manage and handle signals emitted by the component or other parts of the application, allowing for dynamic interactions and responsive behavior based on changes in the application state or user input.\n     */\n    vector?: A_SignalVector\n\n}"]}

package/dist/node/lib/AreComponent/Are.types.d.mts

@@ -1,2 +1,31 @@
+import { A_SignalVector } from '@adaas/a-utils/a-signal';
+import { AreFeatures } from './Are.constants.mjs';
 
-export {  }
+type AreContextInit = {
+    /**
+     * The base template to be used for rendering and compilation.
+     */
+    source?: string;
+    /**
+     * Conditions Mapping between roots and signals associated with components rendered inside the roots. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     */
+    map: {
+        [rootName: string]: A_SignalVector;
+    };
+};
+type ArePropDefinition = {
+    /**
+     * The type of the property, which can be used for validation and parsing purposes. This can include basic types like 'string', 'number', 'boolean', as well as more complex types like 'object' or 'array'.
+     */
+    type: string;
+    /**
+     * The default value of the property, which will be used if the property is not provided during the component's usage. This can help ensure that the component has a consistent behavior even when certain props are omitted.
+     */
+    default: any;
+};
+/**
+ * The names of the features that can be implemented by the AreComponent entity. These features correspond to specific methods that can be defined on the AreComponent class to provide custom behavior for handling signals, defining the component's template, styles, data, and other aspects of its functionality within the ARE framework. Each feature name is associated with a specific method that should be implemented to handle the corresponding aspect of the component's behavior and lifecycle within the ARE framework.
+ */
+type AreFeatureNames = typeof AreFeatures[keyof typeof AreFeatures];
+
+export type { AreContextInit, AreFeatureNames, ArePropDefinition };

package/dist/node/lib/AreComponent/Are.types.d.ts

@@ -1,2 +1,31 @@
+import { A_SignalVector } from '@adaas/a-utils/a-signal';
+import { AreFeatures } from './Are.constants.js';
 
-export {  }
+type AreContextInit = {
+    /**
+     * The base template to be used for rendering and compilation.
+     */
+    source?: string;
+    /**
+     * Conditions Mapping between roots and signals associated with components rendered inside the roots. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     */
+    map: {
+        [rootName: string]: A_SignalVector;
+    };
+};
+type ArePropDefinition = {
+    /**
+     * The type of the property, which can be used for validation and parsing purposes. This can include basic types like 'string', 'number', 'boolean', as well as more complex types like 'object' or 'array'.
+     */
+    type: string;
+    /**
+     * The default value of the property, which will be used if the property is not provided during the component's usage. This can help ensure that the component has a consistent behavior even when certain props are omitted.
+     */
+    default: any;
+};
+/**
+ * The names of the features that can be implemented by the AreComponent entity. These features correspond to specific methods that can be defined on the AreComponent class to provide custom behavior for handling signals, defining the component's template, styles, data, and other aspects of its functionality within the ARE framework. Each feature name is associated with a specific method that should be implemented to handle the corresponding aspect of the component's behavior and lifecycle within the ARE framework.
+ */
+type AreFeatureNames = typeof AreFeatures[keyof typeof AreFeatures];
+
+export type { AreContextInit, AreFeatureNames, ArePropDefinition };

package/dist/node/lib/AreEngine/AreEngine.component.d.mts

@@ -0,0 +1,77 @@
+import { A_Component, A_Scope, A_TYPES__A_DependencyInjectable, A_TYPES__Ctor } from '@adaas/a-concept';
+import { AreSyntax } from '../AreSyntax/AreSyntax.context.mjs';
+import { A_Logger } from '@adaas/a-utils/a-logger';
+import { AreCompiler } from '../AreCompiler/AreCompiler.component.mjs';
+import { AreTransformer } from '../AreTransformer/AreTransformer.component.mjs';
+import { AreLoader } from '../AreLoader/AreLoader.component.mjs';
+import { AreInterpreter } from '../AreInterpreter/AreInterpreter.component.mjs';
+import { AreLifecycle } from '../AreLifecycle/AreLifecycle.component.mjs';
+import { a as AreContext } from '../../Are.context-D7w32H1G.mjs';
+import { AreEngineDependencies } from './AreEngine.types.mjs';
+import { A_SignalBus } from '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.mjs';
+import '../AreStore/AreStore.constants.mjs';
+import '../AreScene/AreScene.constants.mjs';
+import '../AreAttribute/AreAttribute.types.mjs';
+import '../AreAttribute/AreAttribute.constants.mjs';
+import '../AreComponent/Are.component.mjs';
+import '../AreComponent/Are.types.mjs';
+import '../AreComponent/Are.constants.mjs';
+import '../AreNode/AreNode.constants.mjs';
+import '../AreTokenizer/AreTokenizer.component.mjs';
+import '../AreSignals/AreSignals.component.mjs';
+import '../AreSignals/AreSignals.context.mjs';
+import '../AreSignals/AreSignals.types.mjs';
+import '../AreSignals/AreSignals.meta.mjs';
+
+declare class AreEngine extends A_Component {
+    /**
+     * Feature decorator for the load method, which is responsible for the initial loading phase of the engine. This method is where the engine reads the source template, tokenizes it, and prepares the initial context for building the scene. The decorator allows for extending or overriding the default loading behavior by attaching additional functionality before or after the load process.
+     */
+    static get Load(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the build method, which is responsible for constructing the scene based on the loaded context. This method typically involves initializing root nodes, applying transformations, and compiling the scene into a format that can be executed by the interpreter. The decorator allows for customizing the build process by adding additional steps or modifying the existing behavior.
+     */
+    static get Build(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the execute method, which is responsible for the final execution phase of the engine. This method typically involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes. The decorator allows for customizing the execution process by adding additional steps or modifying the existing behavior.
+     */
+    static get Execute(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Method to start the engine, which involves loading necessary resources, building the scene, and executing the rendering process. It accepts an optional scope parameter that can be used to provide a custom scope for the engine's operations, allowing for greater flexibility in how dependencies are managed and accessed during the rendering lifecycle.
+     *
+     * @param scope
+     * @returns
+     */
+    load(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for building the scene, which includes initializing root nodes, loading necessary data, applying transformations, and compiling the scene into a format that can be executed by the interpreter.
+     *
+     * @param context
+     * @param logger
+     */
+    build(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for executing the rendering process, which involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes.
+     *
+     * @param context
+     * @param logger
+     */
+    execute(scope?: A_Scope): Promise<void>;
+    protected defaultBuild(context: AreContext, logger?: A_Logger): Promise<void>;
+    protected defaultExecute(context: AreContext, bus?: A_SignalBus, logger?: A_Logger): Promise<void>;
+    init(scope: A_Scope): Promise<void>;
+    verify(scope: A_Scope, syntax?: AreSyntax, syntaxContext?: AreSyntax, transformer?: AreTransformer, loader?: AreLoader, compiler?: AreCompiler, interpreter?: AreInterpreter, lifecycle?: AreLifecycle, logger?: A_Logger): Promise<void>;
+    /**
+     * Method to pack all necessary dependencies for the engine. This method is called during the initialization phase of the engine and ensures that all required components are registered in the container scope, allowing for proper dependency injection and management throughout the engine's lifecycle.
+     *
+     * @param scope
+     * @param dependencies
+     */
+    protected package(scope: A_Scope, dependencies?: Partial<AreEngineDependencies>): void;
+    protected packDependency<T extends A_TYPES__A_DependencyInjectable>(scope: A_Scope, dependency: T | A_TYPES__Ctor<T>, existed?: A_TYPES__Ctor<T>): T | A_TYPES__Ctor<T>;
+}
+
+export { AreEngine };

package/dist/node/lib/AreEngine/AreEngine.component.d.ts

@@ -0,0 +1,77 @@
+import { A_Component, A_Scope, A_TYPES__A_DependencyInjectable, A_TYPES__Ctor } from '@adaas/a-concept';
+import { AreSyntax } from '../AreSyntax/AreSyntax.context.js';
+import { A_Logger } from '@adaas/a-utils/a-logger';
+import { AreCompiler } from '../AreCompiler/AreCompiler.component.js';
+import { AreTransformer } from '../AreTransformer/AreTransformer.component.js';
+import { AreLoader } from '../AreLoader/AreLoader.component.js';
+import { AreInterpreter } from '../AreInterpreter/AreInterpreter.component.js';
+import { AreLifecycle } from '../AreLifecycle/AreLifecycle.component.js';
+import { a as AreContext } from '../../Are.context-9Ija_fdC.js';
+import { AreEngineDependencies } from './AreEngine.types.js';
+import { A_SignalBus } from '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.js';
+import '../AreStore/AreStore.constants.js';
+import '../AreScene/AreScene.constants.js';
+import '../AreAttribute/AreAttribute.types.js';
+import '../AreAttribute/AreAttribute.constants.js';
+import '../AreComponent/Are.component.js';
+import '../AreComponent/Are.types.js';
+import '../AreComponent/Are.constants.js';
+import '../AreNode/AreNode.constants.js';
+import '../AreTokenizer/AreTokenizer.component.js';
+import '../AreSignals/AreSignals.component.js';
+import '../AreSignals/AreSignals.context.js';
+import '../AreSignals/AreSignals.types.js';
+import '../AreSignals/AreSignals.meta.js';
+
+declare class AreEngine extends A_Component {
+    /**
+     * Feature decorator for the load method, which is responsible for the initial loading phase of the engine. This method is where the engine reads the source template, tokenizes it, and prepares the initial context for building the scene. The decorator allows for extending or overriding the default loading behavior by attaching additional functionality before or after the load process.
+     */
+    static get Load(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the build method, which is responsible for constructing the scene based on the loaded context. This method typically involves initializing root nodes, applying transformations, and compiling the scene into a format that can be executed by the interpreter. The decorator allows for customizing the build process by adding additional steps or modifying the existing behavior.
+     */
+    static get Build(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the execute method, which is responsible for the final execution phase of the engine. This method typically involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes. The decorator allows for customizing the execution process by adding additional steps or modifying the existing behavior.
+     */
+    static get Execute(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Method to start the engine, which involves loading necessary resources, building the scene, and executing the rendering process. It accepts an optional scope parameter that can be used to provide a custom scope for the engine's operations, allowing for greater flexibility in how dependencies are managed and accessed during the rendering lifecycle.
+     *
+     * @param scope
+     * @returns
+     */
+    load(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for building the scene, which includes initializing root nodes, loading necessary data, applying transformations, and compiling the scene into a format that can be executed by the interpreter.
+     *
+     * @param context
+     * @param logger
+     */
+    build(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for executing the rendering process, which involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes.
+     *
+     * @param context
+     * @param logger
+     */
+    execute(scope?: A_Scope): Promise<void>;
+    protected defaultBuild(context: AreContext, logger?: A_Logger): Promise<void>;
+    protected defaultExecute(context: AreContext, bus?: A_SignalBus, logger?: A_Logger): Promise<void>;
+    init(scope: A_Scope): Promise<void>;
+    verify(scope: A_Scope, syntax?: AreSyntax, syntaxContext?: AreSyntax, transformer?: AreTransformer, loader?: AreLoader, compiler?: AreCompiler, interpreter?: AreInterpreter, lifecycle?: AreLifecycle, logger?: A_Logger): Promise<void>;
+    /**
+     * Method to pack all necessary dependencies for the engine. This method is called during the initialization phase of the engine and ensures that all required components are registered in the container scope, allowing for proper dependency injection and management throughout the engine's lifecycle.
+     *
+     * @param scope
+     * @param dependencies
+     */
+    protected package(scope: A_Scope, dependencies?: Partial<AreEngineDependencies>): void;
+    protected packDependency<T extends A_TYPES__A_DependencyInjectable>(scope: A_Scope, dependency: T | A_TYPES__Ctor<T>, existed?: A_TYPES__Ctor<T>): T | A_TYPES__Ctor<T>;
+}
+
+export { AreEngine };

package/dist/node/lib/AreEngine/AreEngine.component.js

@@ -0,0 +1,259 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var AreSyntax_context = require('@adaas/are/syntax/AreSyntax.context');
+var aLogger = require('@adaas/a-utils/a-logger');
+var AreCompiler_component = require('@adaas/are/compiler/AreCompiler.component');
+var AreTransformer_component = require('@adaas/are/transformer/AreTransformer.component');
+var AreLoader_component = require('@adaas/are/loader/AreLoader.component');
+var AreInterpreter_component = require('@adaas/are/interpreter/AreInterpreter.component');
+var AreEngine_error = require('./AreEngine.error');
+var AreLifecycle_component = require('@adaas/are/lifecycle/AreLifecycle.component');
+var AreEngine_constants = require('./AreEngine.constants');
+var Are_context = require('@adaas/are/component/Are.context');
+var aFrame = require('@adaas/a-frame');
+var AreTokenizer_component = require('@adaas/are/tokenizer/AreTokenizer.component');
+var AreSignals_component = require('@adaas/are/signals/AreSignals.component');
+var AreInit_signal = require('@adaas/are/signals/entities/AreInit.signal');
+var aSignal = require('@adaas/a-utils/a-signal');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+exports.AreEngine = class AreEngine extends aConcept.A_Component {
+  /**
+   * Feature decorator for the load method, which is responsible for the initial loading phase of the engine. This method is where the engine reads the source template, tokenizes it, and prepares the initial context for building the scene. The decorator allows for extending or overriding the default loading behavior by attaching additional functionality before or after the load process.
+   */
+  static get Load() {
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name: AreEngine_constants.AreEngineFeatures.Load,
+        scope: [target.constructor],
+        override: ["defaultLoad"]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * Feature decorator for the build method, which is responsible for constructing the scene based on the loaded context. This method typically involves initializing root nodes, applying transformations, and compiling the scene into a format that can be executed by the interpreter. The decorator allows for customizing the build process by adding additional steps or modifying the existing behavior.
+   */
+  static get Build() {
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name: AreEngine_constants.AreEngineFeatures.Build,
+        scope: [target.constructor],
+        override: ["defaultBuild"]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * Feature decorator for the execute method, which is responsible for the final execution phase of the engine. This method typically involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes. The decorator allows for customizing the execution process by adding additional steps or modifying the existing behavior.
+   */
+  static get Execute() {
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name: AreEngine_constants.AreEngineFeatures.Execute,
+        scope: [target.constructor],
+        override: ["defaultExecute"]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  async load(scope) {
+    const context = scope?.resolve(Are_context.AreContext) || aConcept.A_Context.scope(this).resolve(Are_context.AreContext);
+    context?.startPerformance();
+    await this.call(AreEngine_constants.AreEngineFeatures.Load, scope || aConcept.A_Context.scope(this));
+  }
+  async build(scope) {
+    const context = scope?.resolve(Are_context.AreContext) || aConcept.A_Context.scope(this).resolve(Are_context.AreContext);
+    context?.startPerformance("Build Total");
+    await this.call(AreEngine_constants.AreEngineFeatures.Build, scope || aConcept.A_Context.scope(this));
+    context?.endPerformance("Build Total");
+  }
+  async execute(scope) {
+    const context = scope?.resolve(Are_context.AreContext) || aConcept.A_Context.scope(this).resolve(Are_context.AreContext);
+    context?.startPerformance("Execute Total");
+    await this.call(AreEngine_constants.AreEngineFeatures.Execute, scope || aConcept.A_Context.scope(this));
+    context?.endPerformance("Execute Total");
+    context?.endPerformance("Total");
+  }
+  async defaultBuild(context, logger) {
+    logger?.debug("cyan", "Starting to build the scene...");
+    for (const root of context.roots) {
+      context.startPerformance(`Init root <${root.aseid.id}>`);
+      root.init();
+      context.endPerformance(`Init root <${root.aseid.id}>`);
+      context.startPerformance(`Load root <${root.aseid.id}>`);
+      await root.load();
+      context.endPerformance(`Load root <${root.aseid.id}>`);
+      context.startPerformance(`Transform root <${root.aseid.id}>`);
+      root.transform();
+      context.endPerformance(`Transform root <${root.aseid.id}>`);
+      context.startPerformance(`Compile root <${root.aseid.id}>`);
+      root.compile();
+      context.endPerformance(`Compile root <${root.aseid.id}>`);
+      context.endPerformance(`Root <${root.aseid.id}> Total`);
+    }
+  }
+  async defaultExecute(context, bus, logger) {
+    logger?.debug("cyan", "Starting to execute the scene and mount root nodes...");
+    for (const root of context.roots) {
+      context.startPerformance(`Mount root <${root.aseid.id}>`);
+      root.mount();
+      context.endPerformance(`Mount root <${root.aseid.id}>`);
+    }
+    logger?.debug("cyan", "Emitting AreInit signal to start the reactive update cycle...");
+    await bus?.next(new AreInit_signal.AreInit());
+  }
+  async init(scope) {
+    this.package(scope);
+  }
+  async verify(scope, syntax, syntaxContext, transformer, loader, compiler, interpreter, lifecycle, logger) {
+    if (!syntax)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreSyntax or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!syntaxContext)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreSyntax or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!loader)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreLoader or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!transformer)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreTransformer or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!compiler)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreCompiler or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!interpreter)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreInterpreter or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+    if (!lifecycle)
+      throw new AreEngine_error.AreEngineError({
+        title: AreEngine_error.AreEngineError.MissedRequiredDependency,
+        description: `AreLifecycle or its inherited variation is a required dependency for ${this.constructor.name}. Please ensure that it is registered in the container scope before starting the engine.`
+      });
+  }
+  package(scope, dependencies) {
+    const { context, syntax, loader, tokenizer, compiler, transformer, interpreter, lifecycle, signals } = dependencies || {};
+    const existedContext = scope.resolveConstructor(Are_context.AreContext);
+    const existedSyntax = scope.resolveConstructor(AreSyntax_context.AreSyntax);
+    const existedLoader = scope.resolveConstructor(AreLoader_component.AreLoader);
+    const existedTokenizer = scope.resolveConstructor(AreTokenizer_component.AreTokenizer);
+    const existedCompiler = scope.resolveConstructor(AreCompiler_component.AreCompiler);
+    const existedInterpreter = scope.resolveConstructor(AreInterpreter_component.AreInterpreter);
+    const existedLifecycle = scope.resolveConstructor(AreLifecycle_component.AreLifecycle);
+    const existedTransformer = scope.resolveConstructor(AreTransformer_component.AreTransformer);
+    const existedSignals = scope.resolveConstructor(AreSignals_component.AreSignals);
+    this.packDependency(scope, context || Are_context.AreContext, existedContext);
+    this.packDependency(scope, syntax || AreSyntax_context.AreSyntax, existedSyntax);
+    this.packDependency(scope, tokenizer || AreTokenizer_component.AreTokenizer, existedTokenizer);
+    this.packDependency(scope, loader || AreLoader_component.AreLoader, existedLoader);
+    this.packDependency(scope, compiler || AreCompiler_component.AreCompiler, existedCompiler);
+    this.packDependency(scope, transformer || AreTransformer_component.AreTransformer, existedTransformer);
+    this.packDependency(scope, interpreter || AreInterpreter_component.AreInterpreter, existedInterpreter);
+    this.packDependency(scope, lifecycle || AreLifecycle_component.AreLifecycle, existedLifecycle);
+    this.packDependency(scope, signals || AreSignals_component.AreSignals, existedSignals);
+  }
+  packDependency(scope, dependency, existed) {
+    const logger = scope.resolve(aLogger.A_Logger);
+    const thisName = aConcept.A_CommonHelper.getComponentName(this);
+    const scopeIssuerName = aConcept.A_CommonHelper.getComponentName(scope.issuer());
+    const dependencyName = aConcept.A_CommonHelper.getComponentName(dependency);
+    if (existed) {
+      logger?.debug("cyan", `Dependency ${dependencyName} already exists in ${scopeIssuerName} scope. Skipping injection.`);
+      return existed;
+    } else {
+      logger?.debug("cyan", `Injecting ${dependencyName} into ${scopeIssuerName} scope for ${thisName}...`);
+      scope.register(dependency);
+      return dependency;
+    }
+  }
+};
+__decorateClass([
+  aFrame.A_Frame.Method({
+    description: "Method does engine loading, first read of the source and tokenization."
+  })
+], exports.AreEngine.prototype, "load", 1);
+__decorateClass([
+  aFrame.A_Frame.Method({
+    description: "Method responsible for building the scene, which includes initializing root nodes, loading necessary data, applying transformations, and compiling the scene into a format that can be executed by the interpreter."
+  })
+], exports.AreEngine.prototype, "build", 1);
+__decorateClass([
+  aFrame.A_Frame.Method({
+    description: "Method responsible for executing the rendering process, which involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes."
+  })
+], exports.AreEngine.prototype, "execute", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreEngine_constants.AreEngineFeatures.Build,
+    before: /.*/
+  }),
+  __decorateParam(0, aConcept.A_Dependency.Required()),
+  __decorateParam(0, aConcept.A_Inject(Are_context.AreContext)),
+  __decorateParam(1, aConcept.A_Inject(aLogger.A_Logger))
+], exports.AreEngine.prototype, "defaultBuild", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreEngine_constants.AreEngineFeatures.Execute,
+    before: /.*/
+  }),
+  __decorateParam(0, aConcept.A_Dependency.Required()),
+  __decorateParam(0, aConcept.A_Inject(Are_context.AreContext)),
+  __decorateParam(1, aConcept.A_Inject(aSignal.A_SignalBus)),
+  __decorateParam(2, aConcept.A_Inject(aLogger.A_Logger))
+], exports.AreEngine.prototype, "defaultExecute", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreEngine_constants.AreEngineFeatures.Load,
+    before: /.*/
+  }),
+  __decorateParam(0, aConcept.A_Inject(aConcept.A_Scope))
+], exports.AreEngine.prototype, "init", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreEngine_constants.AreEngineFeatures.Load,
+    before: /.*/
+  }),
+  __decorateParam(0, aConcept.A_Inject(aConcept.A_Scope)),
+  __decorateParam(1, aConcept.A_Inject(AreSyntax_context.AreSyntax)),
+  __decorateParam(2, aConcept.A_Inject(AreSyntax_context.AreSyntax)),
+  __decorateParam(3, aConcept.A_Inject(AreTransformer_component.AreTransformer)),
+  __decorateParam(4, aConcept.A_Inject(AreLoader_component.AreLoader)),
+  __decorateParam(5, aConcept.A_Inject(AreCompiler_component.AreCompiler)),
+  __decorateParam(6, aConcept.A_Inject(AreInterpreter_component.AreInterpreter)),
+  __decorateParam(7, aConcept.A_Inject(AreLifecycle_component.AreLifecycle)),
+  __decorateParam(8, aConcept.A_Inject(aLogger.A_Logger))
+], exports.AreEngine.prototype, "verify", 1);
+__decorateClass([
+  aFrame.A_Frame.Method({
+    description: "Method to pack all necessary dependencies for the engine. This method is called during the initialization phase of the engine and ensures that all required components are registered in the container scope, allowing for proper dependency injection and management throughout the engine's lifecycle."
+  })
+], exports.AreEngine.prototype, "package", 1);
+exports.AreEngine = __decorateClass([
+  aFrame.A_Frame.Component({
+    namespace: "A-ARE",
+    name: "AreEngine",
+    description: "Core rendering engine for A-Concept Rendering Engine (ARE), responsible for orchestrating the loading, building, and execution of the rendering process. It manages the lifecycle of root nodes, coordinates the interactions between syntax, transformer, loader, compiler, and interpreter components, and ensures the proper initialization and mounting of the UI application."
+  })
+], exports.AreEngine);
+//# sourceMappingURL=AreEngine.component.js.map
+//# sourceMappingURL=AreEngine.component.js.map