@adaas/are 0.0.2

package/src/lib/AreNode/AreNode.entity.ts

@@ -0,0 +1,249 @@
+import { A_Context, A_Entity, A_Error, A_FormatterHelper, A_IdentityHelper, A_Scope, A_TypeGuards, ASEID } from "@adaas/a-concept";
+import { AreNodeNewProps } from "./AreNode.types";
+import { AreEvent } from "@adaas/are/event";
+import { AreNodeFeatures } from "./AreNode.constants";
+import { AreScene } from "@adaas/are/scene";
+import { A_Frame } from "@adaas/a-frame";
+
+
+
+@A_Frame.Entity({
+    namespace: 'A-ARE',
+    name: 'AreNode',
+    description: 'An AreNode entity represents a node within the A-Concept Rendering Engine (ARE) framework. It encapsulates template, markup, and styles, and manages its own scope for nested fragments and entities. AreNodes are responsible for handling events, compiling, rendering, updating, and lifecycle management within the ARE context.'
+})
+export class AreNode extends A_Entity<AreNodeNewProps> {
+    /**
+     * Template string defined for the node
+     * Example: `<div>{{name}}</div>`
+     */
+    _template!: string
+    /**
+     * Markup string defined for the node
+     * Example: `<custom-component :prop="value"> <div>Inner Content</div> </custom-component>`
+     */
+    _markup!: string
+    /**
+     * Styles string defined for the node
+     */
+    _styles!: string
+    /**
+     * The scope associated with this node
+     * uses to store all nested fragments and entities like other AreNodes and Scene
+     */
+    protected _scope!: A_Scope
+
+    get id(): string {
+        return this.aseid.id;
+    }
+
+    get scope(): A_Scope {
+        if (!this._scope) {
+            this._scope = new A_Scope({
+                name: `${this.aseid.id}`,
+            });
+        }
+
+        return this._scope;
+    }
+
+    get content(): AreScene {
+        return this.scope.resolveFlat<AreScene>(AreScene)!;
+    }
+
+    get type(): string {
+        return this.aseid.entity;
+    }
+
+    get template(): string {
+        return this._template;
+    }
+
+
+    get markup(): string {
+        return this._markup;
+    }
+
+    get styles(): string {
+        return this._styles;
+    }
+
+
+    fromNew(newEntity: AreNodeNewProps): void {
+        this.aseid = this.generateASEID({
+            id: newEntity.id,
+            entity: newEntity.component,
+            scope: newEntity.scope,
+        });
+
+        this._template = newEntity.template || '';
+        this._markup = newEntity.markup || '';
+        this._styles = newEntity.styles || '';
+    }
+
+
+    fromASEID(aseid: string | ASEID): void {
+        super.fromASEID(aseid);
+
+        this._template = '';
+        this._markup = '';
+        this._styles = '';
+    }
+
+
+    setTemplate(template: string): void {
+        this._template = template;
+    }
+
+    setMarkup(markup: string): void {
+        this._markup = markup;
+    }
+
+    setStyles(styles: string): void {
+        this._styles = styles;
+    }
+
+
+
+    async emit(
+        scope: A_Scope,
+    )
+    async emit(
+        event: AreEvent,
+    )
+    async emit(
+        eventOrScope: AreEvent | A_Scope,
+    ) {
+        this.checkScopeInheritance();
+
+        /**
+         * isolated event scope to avoid polluting the node scope
+         */
+        const eventScope = A_TypeGuards.isScopeInstance(eventOrScope)
+            ? eventOrScope
+                .inherit(this.scope)
+            : new A_Scope({
+                name: `${eventOrScope.name}-scope`,
+                fragments: [eventOrScope]
+            })
+                .inherit(this.scope)
+
+        try {
+
+            await this.call(AreNodeFeatures.onEvent, eventScope)
+
+            eventScope.destroy()
+
+        } catch (error) {
+
+            eventScope.destroy();
+
+            throw error;
+        }
+
+    }
+
+    compile(): void {
+
+        this.checkScopeInheritance();
+
+        try {
+
+             this.call(AreNodeFeatures.onCompile, this.scope);
+
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    render(): void {
+        this.checkScopeInheritance();
+
+        try {
+
+            return this.call(AreNodeFeatures.onRender, this.scope);
+
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    async update(): Promise<void> {
+
+        this.checkScopeInheritance();
+
+        try {
+            await this.call(AreNodeFeatures.onUpdate, this.scope);
+
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    async reset(): Promise<void> {
+        this.scope.destroy();
+
+        this._template = '';
+        this._styles = '';
+
+        this._scope = new A_Scope({
+            name: `${this.aseid.id}`,
+        });
+    }
+
+    unmount(): void {
+        this.checkScopeInheritance();
+
+        try {
+            this.call(AreNodeFeatures.onUnmount, this.scope);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+
+    async load(): Promise<any> {
+        return await super.load(this.scope);
+    }
+
+    async destroy(): Promise<any> {
+        this.checkScopeInheritance();
+        try {
+
+            await super.destroy(this.scope);
+
+            this.scope.destroy();
+
+        } catch (error) {
+
+            this._scope.destroy();
+
+            throw error;
+        }
+    }
+
+
+    //============================================================================================
+    //                                Helpers Methods
+    //============================================================================================
+    /**
+     * Method to ensure that the current scope is inherited from the context scope
+     * 
+     * @throws A_Error if the scope is not inherited from the context scope
+     */
+    protected checkScopeInheritance(): void {
+        let attachedScope: A_Scope;
+
+        try {
+            attachedScope = A_Context.scope(this);
+        } catch (error) {
+            throw new A_Error({
+                title: `A_UI_Node Scope Inheritance Error`,
+                description: `The A_UI_Node entity with ASEID '${this.aseid.toString()}' is not bound to any context scope. Please ensure that the entity is created within a valid context.`,
+                originalError: error
+            });
+        }
+    }
+}

package/src/lib/AreNode/AreNode.types.ts

@@ -0,0 +1,15 @@
+
+
+export type AreNodeProps = {
+    component: string,
+    scope: string,
+    markup: string,
+}
+
+export type AreNodeOptionalProps = {
+    id?: string,
+    styles?: string
+    template?: string
+}
+
+export type AreNodeNewProps = AreNodeProps & AreNodeOptionalProps;

package/src/lib/AreNode/index.ts

@@ -0,0 +1,4 @@
+export { AreNode } from './AreNode.entity';
+// export { AreNodeError } from './AreNode.error';
+export * from './AreNode.types';
+export * from './AreNode.constants';

package/src/lib/AreProps/AreProps.context.ts

@@ -0,0 +1,26 @@
+import { ASEID } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
+import { A_ExecutionContext } from "@adaas/a-utils/a-execution";
+
+
+
+@A_Frame.Fragment({
+    namespace: 'A-ARE',
+    name: 'AreProps',
+    description: 'Execution context for managing properties within the A-Concept Rendering Engine (ARE) framework, allowing for type-safe storage and retrieval of key-value pairs associated with a specific ASEID.'
+})
+export class AreProps<
+    T extends Record<string, any> = Record<string, any>
+> extends A_ExecutionContext<T> {
+
+    constructor(aseid: ASEID) {
+        super(aseid.toString());
+    }
+
+
+    setMultiple(values: Partial<T>): void {
+        Object.entries(values).forEach(([key, value]) => {
+            this.set(key as keyof T, value);
+        });
+    }
+}

package/src/lib/AreProps/index.ts

@@ -0,0 +1 @@
+export { AreProps } from './AreProps.context'

package/src/lib/AreRoot/AreRoot.component.ts

@@ -0,0 +1,54 @@
+import { A_Caller, A_Dependency, A_Feature, A_Inject } from "@adaas/a-concept";
+import { Are } from "@adaas/are/component";
+import { AreStore } from "@adaas/are/store";
+import { AreNode } from "@adaas/are/node";
+import { AreEvent } from "@adaas/are/event";
+import { AreScene } from "@adaas/are/scene";
+import { A_ServiceFeatures } from "@adaas/a-utils/a-service";
+import { A_SignalVector } from "@adaas/a-utils/a-signal";
+
+
+
+export class AreRoot extends Are {
+
+    @A_Feature.Extend({
+        name: A_ServiceFeatures.onLoad
+    })
+    async attachListeners() {
+        
+    }
+
+
+
+    @Are.Template
+    async template(
+        @A_Inject(A_Caller) node: AreNode,
+        @A_Inject(AreStore) store: AreStore,
+    ) {
+
+
+
+        // node.setTemplate(`
+        //     <h2>Welcome to Adaas ARE Framework!</h2>
+        // `);
+    }
+
+
+    @Are.Signal
+    async onSignal(
+        @A_Inject(A_Caller) node: AreNode,
+        @A_Inject(AreStore) store: AreStore,
+        @A_Inject(AreScene) scene: AreScene,
+        @A_Inject(A_SignalVector) vector: A_SignalVector,
+        @A_Inject(AreEvent) event: AreEvent,
+        // @A_Dependency.All()
+        // @A_Inject(A_Signal) signals: A_Signal[],
+    ) {
+        // Handle signals here
+        // console.log('Signals received :', signals);
+        console.log('Vector  received :', vector);
+        console.log('Node  received   :', node);
+
+
+    }
+}

package/src/lib/AreRoot/index.ts

@@ -0,0 +1 @@
+export { AreRoot } from './AreRoot.component'

package/src/lib/AreRouter/AreRouter.componeent.ts

@@ -0,0 +1,24 @@
+import { A_Component, A_Dependency, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_Config } from "@adaas/a-utils/a-config";
+import { A_Logger } from "@adaas/a-utils/a-logger";
+import { A_ServiceFeatures } from "@adaas/a-utils/a-service";
+import { AreScene } from "@adaas/are/scene";
+
+export class AreRouter extends A_Component {
+
+
+
+    @A_Feature.Extend()
+    protected async [A_ServiceFeatures.onBeforeLoad](
+        @A_Dependency.Parent()
+        @A_Inject(A_Scope) scope: A_Scope,
+        @A_Inject(AreScene) root?: AreScene,
+        @A_Inject(A_Config) config?: A_Config<any>,
+        @A_Inject(A_Logger) logger?: A_Logger,
+    ): Promise<void> {
+        // 1) Initialize Scene if not present
+        logger?.debug('cyan', `AreRouter initializing  ...`);
+
+    }
+
+}

package/src/lib/AreRouter/index.ts

@@ -0,0 +1 @@
+export { AreRouter } from './AreRouter.componeent'