@adaas/are 0.0.2 → 0.0.3

package/src/engines/html/AreHTML.engine.ts

@@ -1,62 +0,0 @@
-import { A_Caller, A_Component, A_Container, A_Feature, A_Inject } from "@adaas/a-concept";
-import { A_Frame } from "@adaas/a-frame";
-import { AreSyntaxContext } from "@adaas/are/syntax";
-import { AreHTMLCompiler } from "./AreHTML.compiler";
-import { A_ServiceFeatures } from "@adaas/a-utils/a-service";
-import { A_Logger } from "@adaas/a-utils/a-logger";
-
-
-
-@A_Frame.Component({
-    namespace: 'A-ARE',
-    name: 'AreHTMLEngine',
-    description: 'HTML Rendering Engine for A-Concept Rendering Engine (ARE), responsible for processing and rendering HTML templates within the ARE framework.'
-})
-export class AreHTMLEngine extends A_Component {
-
-    /**
-     * Inject AreHTMLSyntax into the container scope before loading
-     * 
-     * @param container 
-     */
-    @A_Feature.Extend({
-        name: A_ServiceFeatures.onBeforeLoad,
-        before: /.*/
-    })
-    async injectSyntax(
-        @A_Inject(A_Caller) container: A_Container,
-        @A_Inject(AreSyntaxContext) syntax?: AreSyntaxContext,
-        @A_Inject(AreHTMLCompiler) compiler?: AreHTMLCompiler,
-        @A_Inject(A_Logger) logger?: A_Logger,
-    ) {
-        if (!syntax) {
-            logger?.info('cyan', 'Injecting AreHTMLSyntax into container scope...');
-
-            const htmlSyntax = new AreSyntaxContext({
-                rootTag: 'are-root',
-                standardTags: [
-                    "html", "head", "body", "div", "span", "p", "a", "ul", "ol", "li",
-                    "table", "thead", "tbody", "tr", "td", "th", "form", "input", "button",
-                    "select", "option", "textarea", "label", "img", "h1", "h2", "h3", "h4",
-                    "h5", "h6", "script", "style", "link", "meta", "nav", "footer", "header",
-                    "section", "article", "aside", "main", "canvas", "video", "audio", "br",
-                    "hr", "strong", "em", "small", "pre", "code", "iframe", "details",
-                    "summary", "svg", "path", "circle", "rect", "polygon", "g", "defs"
-                ],
-                debugMode: true,
-                interpolationDelimiters: ['{{', '}}'],
-                bindingDelimiter: ':',
-                listenerDelimiter: '@',
-                directiveDelimiter: '$',
-            });
-
-            container.scope.register(htmlSyntax);
-        }
-
-        if (!compiler) {
-            logger?.info('cyan', 'Injecting AreHTMLCompiler into container scope...');
-            container.scope.register(AreHTMLCompiler);
-        }
-    }
-
-}

package/src/engines/html/index.ts

@@ -1,2 +0,0 @@
-export { AreHTMLCompiler } from './AreHTML.compiler';
-export { AreHTMLEngine } from './AreHTML.engine'

package/src/engines/json/AreJSON.compiler.ts

@@ -1,13 +0,0 @@
-import { A_Frame } from "@adaas/a-frame";
-import { AreCompiler } from "@adaas/are/compiler";
-
-
-@A_Frame.Component({
-    namespace: 'A-ARE',
-    name: 'AreJSONCompiler',
-    description: 'JSON-specific compiler for A-Concept Rendering Engine (ARE) components, extending the base AreCompiler to handle JSON templates and data structures for headless or API-based rendering environments.'
-})
-export class AreJSONCompiler extends AreCompiler {
-
-
-}

package/src/lib/AreApp/AreApp.container.ts

@@ -1,77 +0,0 @@
-import { A_Dependency, A_Feature, A_Inject } from "@adaas/a-concept";
-import { AreContext } from "@adaas/are/component";
-import { AreSyntax } from "@adaas/are/syntax";
-import { AreInitSignal } from "@adaas/are/signals";
-import { A_Service, A_ServiceFeatures } from "@adaas/a-utils/a-service";
-import { A_Logger } from "@adaas/a-utils/a-logger";
-import { A_SignalBus } from "@adaas/a-utils/a-signal";
-
-
-
-export class AreApp extends A_Service {
-
-
-
-    @A_Feature.Extend()
-    protected async [A_ServiceFeatures.onAfterLoad](
-        @A_Dependency.Required()
-        @A_Inject(AreContext) context: AreContext,
-
-        @A_Inject(A_Logger) logger?: A_Logger,
-    ): Promise<void> {
-
-    }
-
-
-    // @A_Feature.Extend()
-    // protected async [A_ServiceFeatures.onBeforeLoad](
-    //     @A_Inject(AreSyntax) syntax: AreSyntax,
-    //     @A_Inject(AreContext) context: AreContext,
-
-    //     @A_Inject(A_Logger) logger?: A_Logger,
-    // ): Promise<void> {
-    //     logger?.debug('cyan', `Initializing AreScene in AreBrowserCompiler...`);
-
-
-    // }
-
-
-    @A_Feature.Extend()
-    protected async [A_ServiceFeatures.onStart](
-        @A_Dependency.Required()
-        @A_Inject(AreContext) context: AreContext,
-        @A_Inject(AreSyntax) syntax: AreSyntax,
-        @A_Inject(A_SignalBus) bus: A_SignalBus,
-
-        @A_Inject(A_Logger) logger?: A_Logger,
-    ): Promise<void> {
-
-        for (const root of syntax.extractRoots(context.source)) {
-
-            context.addRoot(root)
-
-            let startTime = Date.now();
-
-            await root.load();
-
-            logger?.info('red', `Root <${root.aseid.id}> loaded in ${Date.now() - startTime} ms.`);
-
-            startTime = Date.now();
-
-            root.compile();
-
-            logger?.info('red', `Root <${root.aseid.id}> compiled in ${Date.now() - startTime} ms.`);
-
-            startTime = Date.now();
-
-            root.render();
-
-            logger?.info('red', `Root <${root.aseid.id}> rendered in ${Date.now() - startTime} ms.`);
-        }
-
-        logger?.debug('cyan', `UI Application started at <${context.roots.map(root => root.aseid.id).join(', ')}> with ${context.roots.length} root nodes.`);
-
-        await bus.next(new AreInitSignal())
-    }
-
-}

package/src/lib/AreApp/AreApp.error.ts

@@ -1,7 +0,0 @@
-import { A_Error } from "@adaas/a-concept";
-
-
-export class AreAppError extends A_Error {
-
-
-}

package/src/lib/AreApp/index.ts

@@ -1,4 +0,0 @@
-export { AreApp } from './AreApp.container';
-export { AreAppError } from './AreApp.error';
-export * from './AreApp.types';
-// export * from './AreApp.env';

package/src/lib/AreCompiler/index.ts

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

package/src/lib/AreComponent/index.ts

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

package/src/lib/AreEvent/index.ts

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

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

@@ -1,174 +0,0 @@
-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

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

package/src/lib/AreNode/index.ts

@@ -1,4 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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

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

@@ -1,54 +0,0 @@
-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

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

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

@@ -1,24 +0,0 @@
-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

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

package/src/lib/AreScene/index.ts

@@ -1,3 +0,0 @@
-export { AreScene } from './AreScene.context';
-export { AreSceneError } from './AreScene.error';
-export * from './AreScene.types';

package/src/lib/AreSceneInstruction/AreSceneInstruction.constants.ts

@@ -1,7 +0,0 @@
-
-
-export enum AreSceneInstructionFeatures {
-    Init = '_AreSceneInstructionInit',
-    Apply = '_AreSceneInstructionApply',
-    Revert = '_AreSceneInstructionRevert'
-}

package/src/lib/AreSceneInstruction/AreSceneInstruction.entity.ts

@@ -1,156 +0,0 @@
-
-import { A_Context, A_Entity, A_FormatterHelper, A_Scope } from "@adaas/a-concept";
-import { AreSceneInstructionNewProps } from "./AreSceneInstruction.types";
-import type { AreNode } from "@adaas/are/node";
-import { AreSceneInstructionFeatures } from "./AreSceneInstruction.constants";
-import { AreScene } from "@adaas/are/scene";
-
-
-
-export class AreSceneInstruction<T extends Record<string, any> = Record<string, any>> extends A_Entity<AreSceneInstructionNewProps<T>> {
-
-    action!: string
-    node!: AreNode
-
-    params?: T
-
-
-    hashSource!: string
-
-
-    get scene(): AreScene {
-        return A_Context.scope(this).resolve(AreScene)!
-    }
-
-    /**
-     * Generates even hash uses for deduplication
-     * 
-     * @param str 
-     */
-    protected createHash(str?: string): string
-    protected createHash(str?: undefined): string
-    protected createHash(str?: Record<string, any>): string
-    protected createHash(str?: Array<any>): string
-    protected createHash(str?: number): string
-    protected createHash(str?: boolean): string
-    protected createHash(str?: null): string
-    protected createHash(map?: Map<any, any>): string
-    protected createHash(set?: Set<any>): string
-    protected createHash(str?: any): string {
-        let hashSource: string;
-
-        if (str instanceof Map) {
-            hashSource = JSON.stringify(Array.from(str.entries()));
-        } else if (str instanceof Set) {
-            hashSource = JSON.stringify(Array.from(str.values()));
-        } else {
-            switch (typeof str) {
-                case 'string':
-                    hashSource = str;
-                    break;
-                case 'undefined':
-                    hashSource = 'undefined';
-                    break;
-
-                case 'object':
-                    if ('toJSON' in str)
-                        hashSource = JSON.stringify(str.toJSON());
-
-                    else
-                        hashSource = JSON.stringify(str);
-                    break;
-                case 'number':
-                    hashSource = str.toString();
-                    break;
-                case 'boolean':
-                    hashSource = str ? 'true' : 'false';
-                    break;
-                case 'function':
-                    hashSource = str.toString();
-                    break;
-                default:
-                    hashSource = String(str);
-            }
-        }
-
-        let hash = 0, i, chr;
-        for (i = 0; i < hashSource.length; i++) {
-            chr = hashSource.charCodeAt(i);
-            hash = ((hash << 5) - hash) + chr;
-            hash |= 0; // Convert to 32bit integer
-        }
-
-        const hashString = hash.toString();
-
-        return hashString;
-    }
-
-    fromNew(newEntity: AreSceneInstructionNewProps<T>): void {
-        const identity = newEntity.id || {
-            name: newEntity.action,
-            node: newEntity.node.aseid.toString(),
-        };
-
-        const id = this.createHash(identity);
-
-
-        this.aseid = this.generateASEID({
-            entity: A_FormatterHelper.toKebabCase(newEntity.action),
-            id: id,
-        });
-
-        this.action = newEntity.action;
-        this.node = newEntity.node;
-        this.params = newEntity.params;
-
-    }
-
-
-    update(params: Partial<T>): void {
-        this.params = {
-            ...this.params,
-            ...params,
-        } as T;
-    }
-
-
-    init(
-        scope?: A_Scope
-    ): void {
-        try {
-            this.call(AreSceneInstructionFeatures.Init, scope);
-        } catch (error) {
-
-        }
-    }
-
-    apply(
-        scope?: A_Scope
-    ): void {
-        try {
-           return this.call(AreSceneInstructionFeatures.Apply, scope);
-        } catch (error) {
-
-        }
-    }
-
-    revert(
-        scope?: A_Scope
-    ): void {
-        try {
-            this.call(AreSceneInstructionFeatures.Revert, scope);
-        } catch (error) {
-
-        }
-    }
-
-
-}
-
-
-
-
-
-
-
-

package/src/lib/AreSceneInstruction/AreSceneInstruction.types.ts

@@ -1,8 +0,0 @@
-import type { AreNode } from "@adaas/are/node";
-
-export type AreSceneInstructionNewProps<T extends any = Record<string, any>> = {
-    id?: Array<any>;
-    action: string;
-    node: AreNode,
-    params?: T;
-};

package/src/lib/AreSceneInstruction/index.ts

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