@adaas/are 0.0.2

package/src/lib/AreScene/AreScene.context.ts

@@ -0,0 +1,382 @@
+import { A_Context, A_Dependency, A_Fragment, A_Scope, ASEID } from "@adaas/a-concept";
+import { AreIndex } from "../AreIndex/AreIndex.context";
+import { AreNode } from "@adaas/are/node";
+import { AreSCene_Serialized } from "./AreScene.types";
+import { AreProps } from "@adaas/are/props";
+import { AreStore } from "@adaas/are/store";
+import { AreSceneInstruction } from "@adaas/are/scene-instruction";
+
+export class AreScene extends A_Fragment {
+
+    protected _state: Set<string> = new Set();
+
+    constructor(
+        /**
+         * Scene identity will be used to identify mounting point in the parent scene
+         */
+        id: string | ASEID,
+    ) {
+        super({ name: id.toString() });
+    }
+
+    get id(): string {
+        return this.name;
+    }
+
+    /**
+     * Get the root scene of the current scene
+     */
+    get root(): AreScene {
+        let currentScope: A_Scope | undefined = this.scope;
+        let rootScene: AreScene = this;
+
+        while (currentScope) {
+            const parentScene = currentScope.parent?.resolve<AreScene>(this.constructor as typeof AreScene);
+            if (parentScene) {
+                rootScene = parentScene;
+            }
+            currentScope = currentScope.parent;
+        }
+
+        return rootScene;
+    }
+
+    get scope(): A_Scope {
+        return A_Context.scope(this);
+    }
+
+    get index(): AreIndex<string> {
+        return A_Context.scope(this).resolveFlat<AreIndex<string>>(AreIndex)!;
+    }
+
+    get parent(): AreScene | undefined {
+        return A_Context.scope(this).parent?.resolveFlat<AreScene>(AreScene);
+    }
+
+    get children(): Array<AreScene> {
+        return this.scope.resolveFlatAll<AreNode>(AreNode)
+            .map(n => n.scope.resolveFlat<AreScene>(AreScene))
+            .filter(s => !!s);
+    }
+
+
+    get depth(): number {
+        let depth = 0;
+        let currentScope: A_Scope | undefined = this.scope;
+
+        while (currentScope) {
+            if (currentScope.parent && currentScope.parent.resolve<AreScene>(this.constructor as typeof AreScene)) {
+                depth++;
+            }
+            currentScope = currentScope.parent;
+        }
+
+        return depth;
+    }
+
+
+    get instructions(): Array<AreSceneInstruction> {
+        return this.scope.resolveFlatAll<AreSceneInstruction>(AreSceneInstruction) || [];
+    }
+
+
+    nodes(
+        filter?: (node: AreNode) => boolean
+    ): AreNode[] {
+
+        const nodes: AreNode[] = [];
+
+        for (const path of this.paths()) {
+
+            const node = this.index.nodeOf(path);
+
+            if (!node) {
+                continue;
+            }
+
+            if (filter && !filter(node)) {
+                continue;
+            }
+
+            nodes.push(node);
+        }
+
+        return nodes;
+    }
+
+
+    renderPlanFor(
+        node: AreNode,
+        filter?: {
+            filter?: (instruction: AreSceneInstruction) => boolean,
+            changes?: Array<new (...args: any[]) => AreSceneInstruction>,
+            order?: Array<new (...args: any[]) => AreSceneInstruction>,
+        }
+    ) {
+
+        const actions: AreSceneInstruction[] = [];
+
+        const order = filter?.order || [];
+        const filterFn = filter?.filter;
+
+        let plan = this.instructions;
+
+        plan = plan.sort((a, b) => {
+            const aIndex = order.findIndex(instructionType => a instanceof instructionType);
+            const bIndex = order.findIndex(instructionType => b instanceof instructionType);
+
+            return (aIndex === -1 ? order.length : aIndex) - (bIndex === -1 ? order.length : bIndex);
+        });
+
+        if (filterFn) {
+            plan = plan.filter(filterFn);
+        }
+
+        for (const action of plan) {
+            if (action.node === node) {
+                actions.push(action);
+            }
+        }
+        return actions;
+    }
+
+    get debugPrefix() {
+        return `${' - '.repeat(this.depth)}`
+    }
+
+    get path(): string {
+        if (!this.parent)
+            return '';
+        else {
+            const ownerNode = this.parent.scope.resolve<AreNode>(new A_Dependency(AreNode, {
+                flat: true,
+                query: {
+                    aseid: this.id
+                }
+            })) as AreNode;
+
+            const NodePath = this.parent.index.pathOf(ownerNode);
+
+            return this.parent.path ? (this.parent.path + '.' + NodePath) : NodePath!;
+        }
+    }
+
+    *paths(): Iterable<string> {
+        let paths = this.index.paths;
+
+        //  create proper tree sequence
+        paths.sort((a, b) => {
+            const aParsed = a.split('.').map(part => parseInt(part, 10));
+            const bParsed = b.split('.').map(part => parseInt(part, 10));
+
+            const len = Math.min(aParsed.length, bParsed.length);
+            for (let i = 0; i < len; i++) {
+                if (aParsed[i] !== bParsed[i]) {
+                    return aParsed[i] - bParsed[i];
+                }
+            }
+            return aParsed.length - bParsed.length;
+        });
+
+        // yield paths
+        for (const path of paths) {
+            yield path;
+        }
+    }
+
+    plan(instruction: AreSceneInstruction) {
+        try {
+            this.scope.register(instruction);
+        } catch (error) {
+        }
+    }
+
+    unPlan(
+        instruction: AreSceneInstruction
+    ) {
+        const planned = this.getPlanned(instruction);
+
+        try {
+            if (planned)
+                this.scope.deregister(planned);
+        } catch (error) {
+
+        }
+    }
+
+    isAttached(node: AreNode): boolean {
+        return !!(this.scope.resolve<AreNode>(new A_Dependency(AreNode, {
+            flat: true,
+            query: {
+                aseid: node.aseid
+            }
+        })));
+    }
+
+    attach(node: AreNode): void {
+        this.scope.register(node);
+        node.scope.inherit(this.scope)
+    }
+
+    sceneOf(node: AreNode): AreScene | undefined {
+        return node.scope.resolveFlat<AreScene>(AreScene);
+    }
+
+    propsOf(node: AreNode): AreProps {
+        return node.scope.resolveFlat<AreProps>(AreProps)!;
+    }
+
+    storeOf(node: AreNode): AreStore {
+        return node.scope.resolveFlat<AreStore>(AreStore)!;
+    }
+    isPlanned(action: AreSceneInstruction): boolean {
+        return this.getPlanned(action) !== undefined;
+    }
+
+    /**
+     * It returns planned instruction instance from the scene
+     * 
+     * [!] Only Planned instructions can be used for state checking
+     * 
+     * @param instruction 
+     * @returns 
+     */
+    getPlanned<T extends AreSceneInstruction>(
+        /**
+         * Should be instruction instance to get
+         */
+        instruction: T
+    ): T | undefined {
+
+        const planned = this.scope.resolve<AreSceneInstruction>(new A_Dependency(AreSceneInstruction, {
+            flat: true,
+            query: {
+                aseid: instruction.aseid.toString()
+            }
+        })) as T | undefined;
+
+        return planned;
+    }
+
+    /**
+     * Operation Only applicable from Plan -> State
+     * 
+     * So only instructions presented in the plan can be moved to state
+     * State is a set of instructions that are currently applied to the scene
+     * 
+     * @param instruction 
+     */
+    setState(
+        /**
+         * Should be instruction instance to apply
+         */
+        instruction: AreSceneInstruction
+    ) {
+        const planned = this.getPlanned(instruction);
+
+
+
+        if (planned) {
+            this._state.delete(planned.aseid.toString());
+            this._state.add(instruction.aseid.toString());
+        }
+    }
+
+
+    dropState<T extends AreSceneInstruction>(
+        /**
+         * Should be instruction instance to drop
+         */
+        instruction: T
+    ) {
+        const planned = this.getPlanned(instruction);
+
+        if (planned) {
+            this._state.delete(planned.aseid.toString());
+        }
+    }
+
+
+    resetPlan(
+        node: AreNode
+    ) {
+        for (const instruction of this.renderPlanFor(node)) {
+            if (instruction.node === node) {
+                this.unPlan(instruction);
+            }
+        }
+    }
+
+    resetState(
+        node: AreNode
+    ) {
+        for (const instruction of this.renderPlanFor(node)) {
+            if (instruction.node === node) {
+
+                this._state.delete(instruction.aseid.toString());
+            }
+        }
+    }
+
+
+    getState<T extends AreSceneInstruction>(
+        /**
+         * Should be instruction instance to get state for
+         */
+        instruction: T
+    ): T | undefined {
+
+
+        const planned = this.getPlanned(instruction);
+
+
+        if (!planned) {
+            return undefined;
+        }
+
+        if (this._state.has(planned.aseid.toString()))
+            return planned as T;
+        else
+            return undefined;
+    }
+
+    revert(
+        /**
+         * Should be instruction instance to revert
+         */
+        instruction: AreSceneInstruction
+    ) {
+        this._state.delete(instruction!.aseid.toString());
+    }
+
+
+    reset() {
+        this.index.clear();
+        this._state.clear();
+    }
+
+
+    toJSON(): AreSCene_Serialized {
+        return {
+            ...super.toJSON(),
+            children: Object.fromEntries(
+                Array.from(this.children).map(child => [
+                    child.id.toString(),
+                    child.toJSON()
+                ])
+            )
+        }
+    }
+}
+
+
+
+
+
+//  Just to cover the proper lifecycle
+
+/*
+1) Create Scene with template from mounting point content
+2) Do indexing of the scene 
+
+*/

package/src/lib/AreScene/AreScene.error.ts

@@ -0,0 +1,22 @@
+import { A_Error } from "@adaas/a-concept";
+
+
+export class AreSceneError extends A_Error {
+
+    static readonly SceneError = 'AreSceneError.SceneError';
+
+    static readonly RootNotFound = 'AreSceneError.RootNotFound';
+
+    static readonly UpdateFailed = 'AreSceneError.UpdateFailed';
+   
+    static readonly MountFailed = 'AreSceneError.MountFailed';
+
+    static readonly UnmountFailed = 'AreSceneError.UnmountFailed';
+
+    static readonly MountPointNotFound = 'AreSceneError.MountPointNotFound';
+
+    static readonly InvalidTemplate = 'AreSceneError.InvalidTemplate';
+
+    static readonly RenderFailed = 'AreSceneError.RenderFailed';
+
+}

package/src/lib/AreScene/AreScene.types.ts

@@ -0,0 +1,7 @@
+import { A_TYPES__Fragment_Serialized } from "@adaas/a-concept";
+
+
+
+export type AreSCene_Serialized = {
+    children: { [id: string]: AreSCene_Serialized }
+} & A_TYPES__Fragment_Serialized;

package/src/lib/AreScene/index.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+import type  { AreNode } from "@adaas/are/node";
+import { AreSceneInstruction } from "../AreSceneInstruction.entity";
+
+
+
+export class AddAttributeInstruction extends AreSceneInstruction<{
+    name: string;
+    value: string;
+}> {
+
+    get name(): string {
+        return this.params!.name;
+    }
+
+    get value(): string {
+        return this.params!.value;
+    }
+
+    constructor(
+        node: AreNode,
+        name: string,
+        value: string
+    ) {
+        super({
+            id: [name, node],
+            action: 'add-attribute',
+            node,
+            params: {
+                name,
+                value,
+            }
+        });
+    }
+}

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

@@ -0,0 +1,36 @@
+import { AreSceneInstruction } from "../AreSceneInstruction.entity";
+import type { AreNode } from "@adaas/are/node";
+import { AreDirective } from "@adaas/are/syntax";
+
+
+
+
+export class AddDirectiveInstruction extends AreSceneInstruction<{
+    directive: AreDirective;
+    value: any;
+}> {
+
+    get directive(): AreDirective {
+        return this.params!.directive;
+    }
+
+    get value(): any {
+        return this.params!.value;
+    }
+
+    constructor(
+        node: AreNode,
+        directive: AreDirective,
+        value: any
+    ) {
+        super({
+            id: [directive, node],
+            action: 'directive',
+            node,
+            params: {
+                directive,
+                value,
+            }
+        });
+    }
+}

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

@@ -0,0 +1,26 @@
+import type  { AreNode } from "@adaas/are/node";
+import { AreSceneInstruction } from "../AreSceneInstruction.entity";
+
+export class AddStyleInstruction extends AreSceneInstruction<{
+    styles: string;
+}> {
+
+    get styles(): string {
+        return this.params!.styles;
+    }
+
+
+    constructor(
+        node: AreNode,
+        styles: string,
+    ) {
+        super({
+            id: [styles, node],
+            action: 'add-style',
+            node,
+            params: {
+                styles,
+            }
+        });
+    }
+}