@adaas/are 0.0.2

package/src/lib/AreCompiler/AreCompiler.error.ts

@@ -0,0 +1,9 @@
+import { A_Error } from "@adaas/a-concept";
+
+
+
+export class AreCompilerError extends A_Error {
+
+    static readonly RenderError = 'Are Compiler Render Error';
+    static readonly CompilationError = 'Are Compiler Compilation Error';
+}

package/src/lib/AreCompiler/index.ts

@@ -0,0 +1,3 @@
+export { AreCompiler } from './AreCompiler.component';
+export { AreCompilerError } from './AreCompiler.error';
+export * from './AreCompiler.types';

package/src/lib/AreComponent/Are.component.ts

@@ -0,0 +1,203 @@
+import { A_Component,  A_Feature } from "@adaas/a-concept";
+import { AreFeatures } from "./Are.constants";
+import { A_Frame } from "@adaas/a-frame";
+
+
+@A_Frame.Component({
+    namespace: 'A-ARE',
+    name: 'Are',
+    description: 'Base component class for A-Concept Rendering Engine (ARE) components. It provides lifecycle decorators and methods for defining templates, styles, and data, facilitating the creation of dynamic and interactive UI components within the ARE framework.'
+})
+export class Are extends A_Component {
+
+
+    //==================================================================================
+    //======================== LIFECYCLE DECORATORS ====================================
+    //==================================================================================
+
+    static get EventHandler() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: propertyKey,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onBeforeLoad() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onBeforeLoad,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+    static get onAfterLoad() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onAfterLoad,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+    static get onBeforeCompile() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onBeforeCompile,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onAfterCompile() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onAfterCompile,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onBeforeMount() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onBeforeMount,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onAfterMount() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onAfterMount,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onBeforeUnmount() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onBeforeUnmount,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onAfterUnmount() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onAfterUnmount,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onBeforeUpdate() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onBeforeUpdate,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get onAfterUpdate() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onAfterUpdate,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+    static get Template() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onTemplate,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+    static get Styles() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onStyles,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get Data() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onData,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    static get Signal() {
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: AreFeatures.onSignal,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+    // ==================================================================================
+    // ========================= COMPONENT METHODS ======================================
+    // ==================================================================================
+
+    /**
+     * Returns the template string for the component
+     * 
+     * Could be overridden to provide dynamic templates based on component state
+     * 
+     * @returns 
+     */
+    @Are.Template
+    async template(
+        ...args: any[]
+    ): Promise<void> {
+
+    }
+
+    /**
+     * Returns the styles string for the component
+     *  
+     * Could be overridden to provide dynamic styles based on component state
+     * 
+     * @returns 
+     */
+    @Are.Styles
+    async styles(
+        ...args: any[]
+    ): Promise<void> {
+
+    }
+
+    /**
+     * Returns the data object for the component
+     * 
+     * Uses as the initial state of the component
+     * 
+     * @returns 
+     */
+    @Are.Data
+    async data(
+        ...args: any[]
+    ): Promise<void> {
+
+    }
+
+}

package/src/lib/AreComponent/Are.constants.ts

@@ -0,0 +1,39 @@
+
+
+export enum AreFeatures {
+    /**
+     * Runs before the component is loaded into memory
+     * 
+     * Before template, styles and data are fetched
+     */
+    onBeforeLoad = '_Are_onBeforeLoad',
+    /**
+     * Runs after the component is loaded into memory
+     * 
+     * After template, styles and data are fetched
+     */
+    onAfterLoad = '_Are_onAfterLoad',
+    onBeforeMount = '_Are_onBeforeMount',
+    onAfterMount = '_Are_onAfterMount',
+    onBeforeUnmount = '_Are_onBeforeUnmount',
+    onAfterUnmount = '_Are_onAfterUnmount',
+    onBeforeUpdate = '_Are_onBeforeUpdate',
+    onAfterUpdate = '_Are_onAfterUpdate',
+    onBeforeDestroy = '_Are_onBeforeDestroy',
+    onAfterDestroy = '_Are_onAfterDestroy',
+
+
+    onBeforeCompile = '_Are_onBeforeCompile',
+    onAfterCompile = '_Are_onAfterCompile',
+
+    onBeforeRender = '_Are_onBeforeRender',
+    onAfterRender = '_Are_onAfterRender',
+
+
+
+    onTemplate = '_Are_onTemplate',
+    onStyles = '_Are_onStyles',
+    onData = '_Are_onData',
+
+    onSignal = '_Are_onSignal',
+}

package/src/lib/AreComponent/Are.context.ts

@@ -0,0 +1,43 @@
+import { A_Context, A_Fragment } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
+import { AreNode } from "@adaas/are/node";
+
+
+
+@A_Frame.Fragment({
+    namespace: 'A-ARE',
+    name: 'AreContext',
+    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.'
+})
+export class AreContext extends A_Fragment {
+
+    protected _source: string;
+    protected _roots: Array<AreNode> = [];
+
+    constructor(source: string = '') {
+        super({ name: 'AreContext' });
+        this._source = source;
+    }
+
+    get scope() {
+        return A_Context.scope(this);
+    }
+
+    get roots(): Array<AreNode> {
+        return this._roots;
+    }
+
+    get source(): string {
+        return this._source;
+    }
+
+    addRoot(node: AreNode) {
+        this._roots.push(node);
+        this.scope.register(node);
+    }
+
+    removeRoot(node: AreNode) {
+        this._roots = this._roots.filter(r => r.aseid.toString() !== node.aseid.toString());
+    }
+
+}

package/src/lib/AreComponent/index.ts

@@ -0,0 +1,4 @@
+export { Are } from './Are.component';
+export { AreContext } from './Are.context';
+export * from './Are.types';
+export * from './Are.constants';

package/src/lib/AreEvent/AreEvent.context.ts

@@ -0,0 +1,38 @@
+import { A_Fragment } from "@adaas/a-concept"
+import { A_Frame } from "@adaas/a-frame"
+import type { AreNode } from "@adaas/are/node"
+import { AreEventProps } from "./AreEvent.types"
+
+
+
+@A_Frame.Fragment({
+    namespace: 'A-ARE',
+    name: 'AreEvent',
+    description: 'Event context for managing events within the A-Concept Rendering Engine (ARE) framework, encapsulating event data and associated nodes to facilitate event-driven interactions.'
+})
+export class AreEvent<
+    T extends any = any
+> extends A_Fragment {
+
+
+    protected _node?: AreNode
+
+    protected _props: AreEventProps<T>
+
+    constructor(eventName: string, props: AreEventProps<T>) {
+        super({ name: eventName })
+
+
+        this._props = props;
+    }
+
+    get data(): T {
+        return this._props.data
+    }
+
+    get event(): string {
+        return this._props.event
+    }
+
+
+}

package/src/lib/AreEvent/AreEvent.types.ts

@@ -0,0 +1,16 @@
+
+
+/**
+ * Properties for the AreEvent context
+ * 
+ */
+export type AreEventProps<T = any> = {
+    /**
+     * The data associated with the event
+     */
+    data: T;
+    /**
+     * The name of the event
+     */
+    event: string;
+};

package/src/lib/AreEvent/index.ts

@@ -0,0 +1,2 @@
+export { AreEvent } from './AreEvent.context';
+export * from './AreEvent.types';

package/src/lib/AreIndex/AreIndex.context.ts

@@ -0,0 +1,174 @@
+import { A_Context, A_Fragment, A_Scope, ASEID } from "@adaas/a-concept";
+import { AreNode } from "@adaas/are/node";
+
+
+
+export class AreIndex<
+    _PathType = any
+> extends A_Fragment {
+
+    constructor(aseid: string | ASEID) {
+        super({
+            name: aseid instanceof ASEID ? aseid.toString() : aseid
+        });
+    }
+
+    /**
+     * Platform-agnostic element index
+     * Element can be DOM Element, PDF element, DOCX element, etc.
+     * The actual type depends on the compiler being used
+     */
+    protected _index: {
+        ASEID_to_Path: Map<string, _PathType>,
+        Path_to_ASEID: Map<_PathType, string>,
+
+        
+        Node_to_Path: Map<AreNode, _PathType>,
+        Path_to_Node: Map<_PathType, AreNode>,
+    } = {
+            ASEID_to_Path: new Map(),
+            Path_to_ASEID: new Map(),
+            Node_to_Path: new Map(),
+            Path_to_Node: new Map(),
+        }
+
+
+    /**
+     * Unique hash representing the current state of the index
+     * Can be used to identify changes in the index
+     */
+    get state(): string {
+        const entries = Array.from(this._index.ASEID_to_Path.entries())
+            .sort(([aseidA], [aseidB]) => aseidA.localeCompare(aseidB))
+            .map(([aseid, path]) => `${aseid}:${JSON.stringify(path)}`);
+        return entries.join('|');
+    }
+
+    get scope(): A_Scope {
+        return A_Context.scope(this);
+    }
+
+    get parent() {
+        return A_Context.scope(this).parent?.resolve<AreIndex>(AreIndex);
+    }
+
+    get size(): number {
+        return this._index.ASEID_to_Path.size;
+    }
+
+    get nodes(): Array<AreNode> {
+        return Array.from(this._index.Node_to_Path.keys());
+    }
+
+    get paths(): Array<_PathType> {
+        return Array.from(this._index.Path_to_Node.keys());
+    }
+
+    protected get depth(): number {
+        let depth = 0;
+        let currentScope: A_Scope | undefined = this.scope;
+
+        while (currentScope) {
+            depth++;
+            currentScope = currentScope.parent;
+        }
+
+        return depth;
+    }
+    
+
+    /**
+     * Adds a platform-agnostic element to the index
+     * @param node - AreNode to index
+     * @param path - Platform-specific element (DOM, PDF, DOCX, etc.)
+     */
+    add(node: AreNode, path: _PathType) {
+        this._index.ASEID_to_Path.set(node.aseid.toString(), path);
+        this._index.Path_to_ASEID.set(path, node.aseid.toString());
+        this._index.Node_to_Path.set(node, path);
+        this._index.Path_to_Node.set(path, node);
+    }
+
+    /**
+     * Retrieves platform-specific element by AreNode
+     * @param node - AreNode to look up
+     * @returns Platform-specific element or undefined
+     */
+    pathOf(node: AreNode): _PathType | undefined {
+        return this._index.Node_to_Path.get(node);
+    }
+
+    /**
+     * Retrieves AreNode by platform-specific element
+     * @param element - Platform-specific element to look up
+     * @returns AreNode or undefined
+     */
+    nodeOf(path: _PathType): AreNode | undefined {
+        return this._index.Path_to_Node.get(path);
+    }
+
+    /**
+     * Removes index entry by AreNode
+     * @param node - AreNode to remove from index
+     */
+    removeByNode(node: AreNode) {
+        const path = this._index.Node_to_Path.get(node);
+        if (path) {
+            this._index.ASEID_to_Path.delete(node.aseid.toString());
+            this._index.Path_to_ASEID.delete(path);
+            this._index.Node_to_Path.delete(node);
+            this._index.Path_to_Node.delete(path);
+        }
+    }
+
+
+    replaceByNode(oldNode: AreNode, newNode: AreNode) {
+        const path = this._index.Node_to_Path.get(oldNode);
+        if (path) {
+            this._index.ASEID_to_Path.delete(oldNode.aseid.toString());
+            this._index.Path_to_ASEID.set(path, newNode.aseid.toString());
+            this._index.Node_to_Path.delete(oldNode);
+            this._index.Node_to_Path.set(newNode, path);
+            this._index.Path_to_Node.set(path, newNode);
+        }
+    }
+
+
+    replacePath(oldPath: _PathType, newPath: _PathType) {
+        const aseid = this._index.Path_to_ASEID.get(oldPath);
+        const node = this._index.Path_to_Node.get(oldPath);
+        if (aseid && node) {
+            this._index.ASEID_to_Path.set(aseid, newPath);
+            this._index.Path_to_ASEID.delete(oldPath);
+            this._index.Path_to_ASEID.set(newPath, aseid);
+            this._index.Node_to_Path.set(node, newPath);
+            this._index.Path_to_Node.delete(oldPath);
+            this._index.Path_to_Node.set(newPath, node);
+        }
+    }
+    
+
+    /**
+     * Removes index entry by platform-specific element
+     * @param path - Platform-specific element to remove from index
+     */
+    removeByElement(path: _PathType) {
+        const aseid = this._index.Path_to_ASEID.get(path);
+        if (aseid) {
+            const node = this._index.Path_to_Node.get(path);
+            if (node) {
+                this._index.ASEID_to_Path.delete(aseid);
+                this._index.Path_to_ASEID.delete(path);
+                this._index.Node_to_Path.delete(node);
+                this._index.Path_to_Node.delete(path);
+            }
+        }
+    }
+
+    clear() {
+        this._index.ASEID_to_Path.clear();
+        this._index.Path_to_ASEID.clear();
+        this._index.Node_to_Path.clear();
+        this._index.Path_to_Node.clear();
+    }
+}

package/src/lib/AreIndex/index.ts

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

package/src/lib/AreNode/AreNode.constants.ts

@@ -0,0 +1,37 @@
+
+
+
+export enum AreNodeFeatures {
+    /**
+     * Event fired when the element node is about to be rendered
+     */
+    onBeforeRender = '_AreNode_onBeforeRender',
+    /**
+     * Event fired when the element node is rendered
+     */
+    onRender = '_AreNode_onRender',
+    /**
+     * Event fired when the element node is after rendered
+     */
+    onAfterRender = '_AreNode_onAfterRender',
+    /**
+     * Feature that is called to compile the element node
+     */
+    onCompile = '_AreNode_onCompile',
+    /**
+     * Feature that is called to handle events
+     */
+    onEvent = '_AreNode_onEvent',
+    /**
+     * Feature that is called to update the element node
+     */
+    onUpdate = '_AreNode_onUpdate',
+    /**
+     * Feature that is called to mount the element node
+     */
+    onMount = '_AreNode_onMount',
+    /**
+     * Feature that is called to unmount the element node
+     */
+    onUnmount = '_AreNode_onUnmount',
+}