@adaas/are 0.0.2 → 0.0.4

package/dist/node/lib/AreScene/AreScene.context.js

@@ -1,249 +1,347 @@
 'use strict';
 
 var aConcept = require('@adaas/a-concept');
-var AreIndex_context = require('../AreIndex/AreIndex.context');
-var node = require('@adaas/are/node');
-var props = require('@adaas/are/props');
-var store = require('@adaas/are/store');
-var sceneInstruction = require('@adaas/are/scene-instruction');
+var aFrame = require('@adaas/a-frame');
+var AreDeclaration_instruction = require('@adaas/are/instruction/types/AreDeclaration.instruction');
+var AreInstruction_entity = require('@adaas/are/instruction/AreInstruction.entity');
+var AreScene_error = require('./AreScene.error');
+var AreMutation_instruction = require('@adaas/are/instruction/types/AreMutation.instruction');
+var AreScene_constants = require('./AreScene.constants');
 
-class AreScene extends aConcept.A_Fragment {
+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 = (decorator(result)) || result;
+  return result;
+};
+exports.AreScene = class AreScene extends aConcept.A_Fragment {
   constructor(id) {
     super({ name: id.toString() });
-    this._state = /* @__PURE__ */ new Set();
+    // -----------------------------------------------------------------------------------
+    // -----------------------------------Scene Index-------------------------------------
+    // -----------------------------------------------------------------------------------
+    this._groupToInstructionsMap = /* @__PURE__ */ new Map();
+    /**
+     * Plan is a queue of changes that should be applied to render the node
+     * 
+     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
+     */
+    this._plan = [];
+    /**
+     * State is a list of instructions that are currently applied to the node, 
+     * so it represents the current state of the node in the scene.
+     * 
+     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
+     * 
+     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
+     */
+    this._state = [];
+    /**
+     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
+     */
+    this._status = AreScene_constants.AreSceneStatuses.Active;
   }
+  /**
+   * Scene ID that corresponds to the root node's ID (part of ASEID) 
+   */
   get id() {
     return this.name;
   }
   /**
-   * Get the root scene of the current scene
+   * The scope where scene is registered. This scope is owned by AreNode 
    */
-  get root() {
-    let currentScope = this.scope;
-    let rootScene = this;
-    while (currentScope) {
-      const parentScene = currentScope.parent?.resolve(this.constructor);
-      if (parentScene) {
-        rootScene = parentScene;
-      }
-      currentScope = currentScope.parent;
-    }
-    return rootScene;
-  }
   get scope() {
     return aConcept.A_Context.scope(this);
   }
-  get index() {
-    return aConcept.A_Context.scope(this).resolveFlat(AreIndex_context.AreIndex);
+  /**
+   * The owner node of the scene, which is the node that registered the scene in its scope. 
+   * This is typically the node that is responsible for rendering the scene and managing its lifecycle.
+   */
+  get owner() {
+    return this.scope.issuer();
   }
-  get parent() {
-    return aConcept.A_Context.scope(this).parent?.resolveFlat(AreScene);
+  /**
+   * It's a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle.
+   */
+  get host() {
+    return this._host;
   }
-  get children() {
-    return this.scope.resolveFlatAll(node.AreNode).map((n) => n.scope.resolveFlat(AreScene)).filter((s) => !!s);
+  /**
+   * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
+   */
+  get status() {
+    return this._status;
   }
-  get depth() {
-    let depth = 0;
-    let currentScope = this.scope;
-    while (currentScope) {
-      if (currentScope.parent && currentScope.parent.resolve(this.constructor)) {
-        depth++;
-      }
-      currentScope = currentScope.parent;
-    }
-    return depth;
+  get isActive() {
+    return this.status === AreScene_constants.AreSceneStatuses.Active;
   }
-  get instructions() {
-    return this.scope.resolveFlatAll(sceneInstruction.AreSceneInstruction) || [];
-  }
-  nodes(filter) {
-    const nodes = [];
-    for (const path of this.paths()) {
-      const node = this.index.nodeOf(path);
-      if (!node) {
-        continue;
-      }
-      if (filter && !filter(node)) {
-        continue;
+  get isInactive() {
+    return this.status === AreScene_constants.AreSceneStatuses.Inactive;
+  }
+  /**
+   * Returns All declaration instructions are registered in the scene scope. Since declaration instructions are the main instructions that represent the structure of the node, we have a separate getter for them to easily access and manage them in the scene.
+   */
+  get declarations() {
+    return this.scope.resolve(new aConcept.A_Dependency(AreDeclaration_instruction.AreDeclaration, {
+      flat: true,
+      pagination: {
+        count: -1
       }
-      nodes.push(node);
-    }
-    return nodes;
-  }
-  renderPlanFor(node, filter) {
-    const actions = [];
-    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);
+    })) || [];
+  }
+  /**
+   * Returns All mutation instructions are registered in the scene scope. Mutation instructions are the instructions that represent the changes to be applied to the node, so we have a separate getter for them to easily access and manage them in the scene, especially when we want to apply or revert changes based on the mutations.
+   */
+  get mutations() {
+    return this.scope.resolve(new aConcept.A_Dependency(AreMutation_instruction.AreMutation, {
+      flat: true,
+      pagination: {
+        count: -1
       }
-    }
-    return actions;
+    })) || [];
+  }
+  /**
+   * Returns All instructions are registered in the scene scope. 
+   */
+  get instructions() {
+    return this.scope.resolveFlatAll(AreInstruction_entity.AreInstruction) || [];
+  }
+  /**
+   * Plan is a queue of changes that should be applied to render the node
+   * 
+   * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
+   */
+  get planned() {
+    return this._plan;
   }
-  get debugPrefix() {
-    return `${" - ".repeat(this.depth)}`;
+  /**
+   * State is a list of instructions that are currently applied to the node, 
+   * so it represents the current state of the node in the scene.
+   * 
+   * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
+   * 
+   * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
+   */
+  get applied() {
+    return this._state.reverse();
+  }
+  /**
+   * Should return instructions to be reverted and to be applied. 
+   * A difference between plan vs state is that plan is what should be applied to the scene, 
+   * while state is what currently applied to the scene. 
+   * 
+   */
+  get changes() {
+    const toApply = this.planned.filter((i) => !this.isApplied(i));
+    const toRevert = this.applied.filter((i) => !this.isInPlan(i));
+    return {
+      toApply,
+      toRevert
+    };
   }
-  get path() {
-    if (!this.parent)
-      return "";
-    else {
-      const ownerNode = this.parent.scope.resolve(new aConcept.A_Dependency(node.AreNode, {
+  //===============================================================================================
+  //============================= Scene Primary Methods ===========================================
+  //===============================================================================================
+  activate() {
+    this._status = AreScene_constants.AreSceneStatuses.Active;
+  }
+  deactivate() {
+    this._status = AreScene_constants.AreSceneStatuses.Inactive;
+  }
+  /**
+   * Each scene has a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle. This method allows to set the host instruction for the scene, but it will throw an error if we try to set another host instruction while there is already a host instruction set, so we can ensure that there is only one host instruction for the scene at any given time.
+   * 
+   * @param instruction 
+   */
+  setHost(instruction) {
+    if (this.host) {
+      const dependentInstructions = this.scope.resolve(new aConcept.A_Dependency(AreMutation_instruction.AreMutation, {
         flat: true,
+        pagination: {
+          count: -1
+        },
         query: {
-          aseid: this.id
+          parent: this.host.aseid.toString()
         }
-      }));
-      const NodePath = this.parent.index.pathOf(ownerNode);
-      return this.parent.path ? this.parent.path + "." + NodePath : NodePath;
+      })) || [];
+      dependentInstructions.forEach((element) => {
+        element.attachTo(instruction);
+        element.groupWith(instruction);
+      });
     }
+    this._host = instruction;
   }
-  *paths() {
-    let paths = this.index.paths;
-    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;
-    });
-    for (const path of paths) {
-      yield path;
-    }
+  /**
+   * Unsets the current host instruction from the scene. 
+   * 
+   * This method should be used when we want to remove the primary declaration instruction that represents the node in the scene, for example, when we want to unmount the node or when we want to replace it with another node. Unsetting the host instruction will allow us to set a new host instruction for the scene if needed.
+   */
+  removeHost() {
+    if (this.host)
+      throw new AreScene_error.AreSceneError({
+        title: AreScene_error.AreSceneError.HostInstructionHasConnectedInstructions,
+        description: `Cannot remove host instruction (${this.host.aseid}) from scene ${this.id} because it has planned instructions in the scene. Please unPlan all instructions related to the host instruction before removing it.`
+      });
+    this._host = void 0;
   }
+  // ------------------------------------------------------------------------------------------------------------
+  // Scene Render Plan Methods
+  // ------------------------------------------------------------------------------------------------------------
+  /**
+   * Method that should register the instruction in the plan, so it will be rendered in the next render cycle.
+   * 
+   * @param instruction 
+   */
   plan(instruction) {
     try {
       this.scope.register(instruction);
     } catch (error) {
     }
-  }
-  unPlan(instruction) {
-    const planned = this.getPlanned(instruction);
-    try {
-      if (planned)
-        this.scope.deregister(planned);
-    } catch (error) {
+    this._plan.push(instruction);
+    if (!this._groupToInstructionsMap.has(instruction.group || "default")) {
+      this._groupToInstructionsMap.set(instruction.group || "default", /* @__PURE__ */ new Set());
     }
+    this._groupToInstructionsMap.get(instruction.group || "default").add(instruction);
   }
-  isAttached(node$1) {
-    return !!this.scope.resolve(new aConcept.A_Dependency(node.AreNode, {
-      flat: true,
-      query: {
-        aseid: node$1.aseid
+  planBefore(instruction, beforeInstruction) {
+    const beforeIndex = this._plan.findIndex((i) => i.aseid.toString() === beforeInstruction.aseid.toString());
+    const instructionIndex = this._plan.findIndex((i) => i.aseid.toString() === instruction.aseid.toString());
+    if (beforeIndex === -1) {
+      throw new AreScene_error.AreSceneError({
+        title: AreScene_error.AreSceneError.SceneError,
+        description: `Instruction ${beforeInstruction.aseid} is not in the plan of scene ${this.id}. Cannot plan instruction ${instruction.aseid} before it.`
+      });
+    }
+    if (instructionIndex === -1) {
+      try {
+        this.scope.register(instruction);
+      } catch (error) {
       }
-    }));
-  }
-  attach(node) {
-    this.scope.register(node);
-    node.scope.inherit(this.scope);
-  }
-  sceneOf(node) {
-    return node.scope.resolveFlat(AreScene);
+      this._plan.splice(beforeIndex, 0, instruction);
+    } else {
+      this._plan.splice(instructionIndex, 1);
+      this._plan.splice(beforeIndex, 0, instruction);
+    }
   }
-  propsOf(node) {
-    return node.scope.resolveFlat(props.AreProps);
+  planAfter(instruction, afterInstruction) {
+    const afterIndex = this._plan.findIndex((i) => i.aseid.toString() === afterInstruction.aseid.toString());
+    const instructionIndex = this._plan.findIndex((i) => i.aseid.toString() === instruction.aseid.toString());
+    if (afterIndex === -1) {
+      throw new AreScene_error.AreSceneError({
+        title: AreScene_error.AreSceneError.SceneError,
+        description: `Instruction ${afterInstruction.aseid} is not in the plan of scene ${this.id}. Cannot plan instruction ${instruction.aseid} after it.`
+      });
+    }
+    if (instructionIndex === -1) {
+      this.scope.register(instruction);
+      this._plan.splice(afterIndex + 1, 0, instruction);
+    } else {
+      this._plan.splice(instructionIndex, 1);
+      this._plan.splice(afterIndex + 1, 0, instruction);
+    }
   }
-  storeOf(node) {
-    return node.scope.resolveFlat(store.AreStore);
+  moveBefore(instruction, beforeInstruction) {
+    if (!this.isInPlan(instruction)) {
+      throw new AreScene_error.AreSceneError({
+        title: AreScene_error.AreSceneError.SceneError,
+        description: `Instruction ${instruction.aseid} is not in the plan of scene ${this.id}. Cannot move instruction before ${beforeInstruction.aseid}. Please plan the instruction before moving it.`
+      });
+    }
+    this.planBefore(instruction, beforeInstruction);
   }
-  isPlanned(action) {
-    return this.getPlanned(action) !== void 0;
+  moveAfter(instruction, afterInstruction) {
+    if (!this.isInPlan(instruction)) {
+      throw new AreScene_error.AreSceneError({
+        title: AreScene_error.AreSceneError.SceneError,
+        description: `Instruction ${instruction.aseid} is not in the plan of scene ${this.id}. Cannot move instruction after ${afterInstruction.aseid}. Please plan the instruction before moving it.`
+      });
+    }
+    this.planAfter(instruction, afterInstruction);
   }
   /**
-   * It returns planned instruction instance from the scene
+   * Allows to remove instruction from the plan, so it will not be rendered anymore, but it will still be registered in the scene scope, so it can be planned again if needed.
    * 
-   * [!] Only Planned instructions can be used for state checking
+   * @param instruction 
+   */
+  unPlan(instruction) {
+    this._plan = this._plan.filter((i) => i.aseid.toString() !== instruction.aseid.toString());
+  }
+  /**
+   * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
    * 
    * @param instruction 
    * @returns 
    */
   getPlanned(instruction) {
-    const planned = this.scope.resolve(new aConcept.A_Dependency(sceneInstruction.AreSceneInstruction, {
-      flat: true,
-      query: {
-        aseid: instruction.aseid.toString()
-      }
-    }));
-    return planned;
+    const found = this._plan.find((i) => i.aseid.toString() === instruction.aseid.toString());
+    return found;
   }
   /**
-   * 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
+   * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
    * 
    * @param instruction 
+   * @returns 
    */
-  setState(instruction) {
-    const planned = this.getPlanned(instruction);
-    if (planned) {
-      this._state.delete(planned.aseid.toString());
-      this._state.add(instruction.aseid.toString());
-    }
+  isInPlan(instruction) {
+    return !!this.getPlanned(instruction);
   }
-  dropState(instruction) {
-    const planned = this.getPlanned(instruction);
-    if (planned) {
-      this._state.delete(planned.aseid.toString());
-    }
-  }
-  resetPlan(node) {
-    for (const instruction of this.renderPlanFor(node)) {
-      if (instruction.node === node) {
-        this.unPlan(instruction);
-      }
+  // -------------------------------------------------------------------------------------------------------------
+  // Scene Apply Methods
+  // -------------------------------------------------------------------------------------------------------------
+  /**
+   * Method moves the instruction to state to keep it applied and to be able to revert it later if needed. The instruction should be already registered in the scene scope and planned to be applied, otherwise it will not be applied.
+   * 
+   * @param instruction 
+   */
+  apply(instruction) {
+    if (!this.isApplied(instruction)) {
+      this._state.push(instruction);
     }
   }
-  resetState(node) {
-    for (const instruction of this.renderPlanFor(node)) {
-      if (instruction.node === node) {
-        this._state.delete(instruction.aseid.toString());
-      }
-    }
+  /**
+   * Method moves the instruction from state to unapply it and to be able to apply it later if needed. The instruction should be already registered in the scene scope and applied, otherwise it will not be unapplied.
+   * 
+   * @param instruction 
+   */
+  unApply(instruction) {
+    this._state = this._state.filter((i) => i.aseid.toString() !== instruction.aseid.toString());
   }
-  getState(instruction) {
-    const planned = this.getPlanned(instruction);
-    if (!planned) {
-      return void 0;
-    }
-    if (this._state.has(planned.aseid.toString()))
-      return planned;
-    else
-      return void 0;
+  /**
+   * Checks if the instruction is already in the state, so it is currently applied to the scene.
+   * 
+   * @param instruction 
+   * @returns 
+   */
+  getApplied(instruction) {
+    const found = this._state.find((i) => i.aseid.toString() === instruction.aseid.toString());
+    return found;
   }
-  revert(instruction) {
-    this._state.delete(instruction.aseid.toString());
+  /**
+   * Checks if the instruction is already in the state, so it is currently applied to the scene.
+   * 
+   * @param instruction 
+   * @returns 
+   */
+  isApplied(instruction) {
+    return !!this.getApplied(instruction);
   }
+  /**
+   * Method that should reset the scene to the initial state, so it will clear the plan and state, but it will not deregister the instructions from the scene scope, so they will still be registered in the scene and can be planned and applied again if needed.
+   * 
+   */
   reset() {
-    this.index.clear();
-    this._state.clear();
+    this._plan = [];
+    this._state = [];
   }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      children: Object.fromEntries(
-        Array.from(this.children).map((child) => [
-          child.id.toString(),
-          child.toJSON()
-        ])
-      )
-    };
-  }
-}
-
-exports.AreScene = AreScene;
+};
+exports.AreScene = __decorateClass([
+  aFrame.A_Frame.Component({
+    namespace: "A-ARE",
+    name: "AreScene",
+    description: "Persistent runtime structure that owns the rendering state for a component's lifetime. Maintains two sets \u2014 applied (what is currently in the DOM) and planned (what should be). Acts as the single source of truth for all rendering decisions. The Compiler produces it once, the Interpreter reads it on every update."
+  })
+], exports.AreScene);
 //# sourceMappingURL=AreScene.context.js.map
 //# sourceMappingURL=AreScene.context.js.map

package/dist/node/lib/AreScene/AreScene.context.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/AreScene/AreScene.context.ts"],"names":["A_Fragment","A_Context","AreIndex","AreNode","AreSceneInstruction","A_Dependency","node","AreProps","AreStore"],"mappings":"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","file":"AreScene.context.js","sourcesContent":["import { A_Context, A_Dependency, A_Fragment, A_Scope, ASEID } from \"@adaas/a-concept\";\nimport { AreIndex } from \"../AreIndex/AreIndex.context\";\nimport { AreNode } from \"@adaas/are/node\";\nimport { AreSCene_Serialized } from \"./AreScene.types\";\nimport { AreProps } from \"@adaas/are/props\";\nimport { AreStore } from \"@adaas/are/store\";\nimport { AreSceneInstruction } from \"@adaas/are/scene-instruction\";\n\nexport class AreScene extends A_Fragment {\n\n    protected _state: Set<string> = new Set();\n\n    constructor(\n        /**\n         * Scene identity will be used to identify mounting point in the parent scene\n         */\n        id: string | ASEID,\n    ) {\n        super({ name: id.toString() });\n    }\n\n    get id(): string {\n        return this.name;\n    }\n\n    /**\n     * Get the root scene of the current scene\n     */\n    get root(): AreScene {\n        let currentScope: A_Scope | undefined = this.scope;\n        let rootScene: AreScene = this;\n\n        while (currentScope) {\n            const parentScene = currentScope.parent?.resolve<AreScene>(this.constructor as typeof AreScene);\n            if (parentScene) {\n                rootScene = parentScene;\n            }\n            currentScope = currentScope.parent;\n        }\n\n        return rootScene;\n    }\n\n    get scope(): A_Scope {\n        return A_Context.scope(this);\n    }\n\n    get index(): AreIndex<string> {\n        return A_Context.scope(this).resolveFlat<AreIndex<string>>(AreIndex)!;\n    }\n\n    get parent(): AreScene | undefined {\n        return A_Context.scope(this).parent?.resolveFlat<AreScene>(AreScene);\n    }\n\n    get children(): Array<AreScene> {\n        return this.scope.resolveFlatAll<AreNode>(AreNode)\n            .map(n => n.scope.resolveFlat<AreScene>(AreScene))\n            .filter(s => !!s);\n    }\n\n\n    get depth(): number {\n        let depth = 0;\n        let currentScope: A_Scope | undefined = this.scope;\n\n        while (currentScope) {\n            if (currentScope.parent && currentScope.parent.resolve<AreScene>(this.constructor as typeof AreScene)) {\n                depth++;\n            }\n            currentScope = currentScope.parent;\n        }\n\n        return depth;\n    }\n\n\n    get instructions(): Array<AreSceneInstruction> {\n        return this.scope.resolveFlatAll<AreSceneInstruction>(AreSceneInstruction) || [];\n    }\n\n\n    nodes(\n        filter?: (node: AreNode) => boolean\n    ): AreNode[] {\n\n        const nodes: AreNode[] = [];\n\n        for (const path of this.paths()) {\n\n            const node = this.index.nodeOf(path);\n\n            if (!node) {\n                continue;\n            }\n\n            if (filter && !filter(node)) {\n                continue;\n            }\n\n            nodes.push(node);\n        }\n\n        return nodes;\n    }\n\n\n    renderPlanFor(\n        node: AreNode,\n        filter?: {\n            filter?: (instruction: AreSceneInstruction) => boolean,\n            changes?: Array<new (...args: any[]) => AreSceneInstruction>,\n            order?: Array<new (...args: any[]) => AreSceneInstruction>,\n        }\n    ) {\n\n        const actions: AreSceneInstruction[] = [];\n\n        const order = filter?.order || [];\n        const filterFn = filter?.filter;\n\n        let plan = this.instructions;\n\n        plan = plan.sort((a, b) => {\n            const aIndex = order.findIndex(instructionType => a instanceof instructionType);\n            const bIndex = order.findIndex(instructionType => b instanceof instructionType);\n\n            return (aIndex === -1 ? order.length : aIndex) - (bIndex === -1 ? order.length : bIndex);\n        });\n\n        if (filterFn) {\n            plan = plan.filter(filterFn);\n        }\n\n        for (const action of plan) {\n            if (action.node === node) {\n                actions.push(action);\n            }\n        }\n        return actions;\n    }\n\n    get debugPrefix() {\n        return `${' - '.repeat(this.depth)}`\n    }\n\n    get path(): string {\n        if (!this.parent)\n            return '';\n        else {\n            const ownerNode = this.parent.scope.resolve<AreNode>(new A_Dependency(AreNode, {\n                flat: true,\n                query: {\n                    aseid: this.id\n                }\n            })) as AreNode;\n\n            const NodePath = this.parent.index.pathOf(ownerNode);\n\n            return this.parent.path ? (this.parent.path + '.' + NodePath) : NodePath!;\n        }\n    }\n\n    *paths(): Iterable<string> {\n        let paths = this.index.paths;\n\n        //  create proper tree sequence\n        paths.sort((a, b) => {\n            const aParsed = a.split('.').map(part => parseInt(part, 10));\n            const bParsed = b.split('.').map(part => parseInt(part, 10));\n\n            const len = Math.min(aParsed.length, bParsed.length);\n            for (let i = 0; i < len; i++) {\n                if (aParsed[i] !== bParsed[i]) {\n                    return aParsed[i] - bParsed[i];\n                }\n            }\n            return aParsed.length - bParsed.length;\n        });\n\n        // yield paths\n        for (const path of paths) {\n            yield path;\n        }\n    }\n\n    plan(instruction: AreSceneInstruction) {\n        try {\n            this.scope.register(instruction);\n        } catch (error) {\n        }\n    }\n\n    unPlan(\n        instruction: AreSceneInstruction\n    ) {\n        const planned = this.getPlanned(instruction);\n\n        try {\n            if (planned)\n                this.scope.deregister(planned);\n        } catch (error) {\n\n        }\n    }\n\n    isAttached(node: AreNode): boolean {\n        return !!(this.scope.resolve<AreNode>(new A_Dependency(AreNode, {\n            flat: true,\n            query: {\n                aseid: node.aseid\n            }\n        })));\n    }\n\n    attach(node: AreNode): void {\n        this.scope.register(node);\n        node.scope.inherit(this.scope)\n    }\n\n    sceneOf(node: AreNode): AreScene | undefined {\n        return node.scope.resolveFlat<AreScene>(AreScene);\n    }\n\n    propsOf(node: AreNode): AreProps {\n        return node.scope.resolveFlat<AreProps>(AreProps)!;\n    }\n\n    storeOf(node: AreNode): AreStore {\n        return node.scope.resolveFlat<AreStore>(AreStore)!;\n    }\n    isPlanned(action: AreSceneInstruction): boolean {\n        return this.getPlanned(action) !== undefined;\n    }\n\n    /**\n     * It returns planned instruction instance from the scene\n     * \n     * [!] Only Planned instructions can be used for state checking\n     * \n     * @param instruction \n     * @returns \n     */\n    getPlanned<T extends AreSceneInstruction>(\n        /**\n         * Should be instruction instance to get\n         */\n        instruction: T\n    ): T | undefined {\n\n        const planned = this.scope.resolve<AreSceneInstruction>(new A_Dependency(AreSceneInstruction, {\n            flat: true,\n            query: {\n                aseid: instruction.aseid.toString()\n            }\n        })) as T | undefined;\n\n        return planned;\n    }\n\n    /**\n     * Operation Only applicable from Plan -> State\n     * \n     * So only instructions presented in the plan can be moved to state\n     * State is a set of instructions that are currently applied to the scene\n     * \n     * @param instruction \n     */\n    setState(\n        /**\n         * Should be instruction instance to apply\n         */\n        instruction: AreSceneInstruction\n    ) {\n        const planned = this.getPlanned(instruction);\n\n\n\n        if (planned) {\n            this._state.delete(planned.aseid.toString());\n            this._state.add(instruction.aseid.toString());\n        }\n    }\n\n\n    dropState<T extends AreSceneInstruction>(\n        /**\n         * Should be instruction instance to drop\n         */\n        instruction: T\n    ) {\n        const planned = this.getPlanned(instruction);\n\n        if (planned) {\n            this._state.delete(planned.aseid.toString());\n        }\n    }\n\n\n    resetPlan(\n        node: AreNode\n    ) {\n        for (const instruction of this.renderPlanFor(node)) {\n            if (instruction.node === node) {\n                this.unPlan(instruction);\n            }\n        }\n    }\n\n    resetState(\n        node: AreNode\n    ) {\n        for (const instruction of this.renderPlanFor(node)) {\n            if (instruction.node === node) {\n\n                this._state.delete(instruction.aseid.toString());\n            }\n        }\n    }\n\n\n    getState<T extends AreSceneInstruction>(\n        /**\n         * Should be instruction instance to get state for\n         */\n        instruction: T\n    ): T | undefined {\n\n\n        const planned = this.getPlanned(instruction);\n\n\n        if (!planned) {\n            return undefined;\n        }\n\n        if (this._state.has(planned.aseid.toString()))\n            return planned as T;\n        else\n            return undefined;\n    }\n\n    revert(\n        /**\n         * Should be instruction instance to revert\n         */\n        instruction: AreSceneInstruction\n    ) {\n        this._state.delete(instruction!.aseid.toString());\n    }\n\n\n    reset() {\n        this.index.clear();\n        this._state.clear();\n    }\n\n\n    toJSON(): AreSCene_Serialized {\n        return {\n            ...super.toJSON(),\n            children: Object.fromEntries(\n                Array.from(this.children).map(child => [\n                    child.id.toString(),\n                    child.toJSON()\n                ])\n            )\n        }\n    }\n}\n\n\n\n\n\n//  Just to cover the proper lifecycle\n\n/*\n1) Create Scene with template from mounting point content\n2) Do indexing of the scene \n\n*/"]}
+{"version":3,"sources":["../../../../src/lib/AreScene/AreScene.context.ts"],"names":["AreScene","A_Fragment","AreSceneStatuses","A_Context","A_Dependency","AreDeclaration","AreMutation","AreInstruction","AreSceneError","A_Frame"],"mappings":"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","file":"AreScene.context.js","sourcesContent":["import { A_Context, A_Dependency, A_Fragment, A_Scope, ASEID } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport type { AreNode } from \"@adaas/are/node/AreNode.entity\";\nimport { AreDeclaration } from \"@adaas/are/instruction/types/AreDeclaration.instruction\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { AreSceneChanges, AreSceneStatusNames } from \"./AreScene.types\";\nimport { AreSceneError } from \"./AreScene.error\";\nimport { AreMutation } from \"@adaas/are/instruction/types/AreMutation.instruction\";\nimport { AreSceneStatuses } from \"./AreScene.constants\";\n\n\n\n@A_Frame.Component({\n    namespace: 'A-ARE',\n    name: 'AreScene',\n    description: \"Persistent runtime structure that owns the rendering state for a component's lifetime. Maintains two sets — applied (what is currently in the DOM) and planned (what should be). Acts as the single source of truth for all rendering decisions. The Compiler produces it once, the Interpreter reads it on every update.\"\n})\nexport class AreScene extends A_Fragment {\n    // -----------------------------------------------------------------------------------\n    // -----------------------------------Scene Index-------------------------------------\n    // -----------------------------------------------------------------------------------\n    protected _groupToInstructionsMap: Map<string, Set<AreInstruction>> = new Map();\n\n    /**\n     * Plan is a queue of changes that should be applied to render the node\n     * \n     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.\n     */\n    protected _plan: Array<AreInstruction> = [];\n    /**\n     * State is a list of instructions that are currently applied to the node, \n     * so it represents the current state of the node in the scene.\n     * \n     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.\n     * \n     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.\n     */\n    protected _state: Array<AreInstruction> = [];\n\n\n    protected _host: AreDeclaration | undefined;\n    /**\n     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.\n     */\n    protected _status: AreSceneStatusNames = AreSceneStatuses.Active;\n\n\n    constructor(\n        /**\n         * Scene identity will be used to identify mounting point in the parent scene\n         */\n        id: string | ASEID,\n    ) {\n        super({ name: id.toString() });\n    }\n\n    /**\n     * Scene ID that corresponds to the root node's ID (part of ASEID) \n     */\n    get id(): string {\n        return this.name;\n    }\n    /**\n     * The scope where scene is registered. This scope is owned by AreNode \n     */\n    get scope(): A_Scope {\n        return A_Context.scope(this);\n    }\n    /**\n     * The owner node of the scene, which is the node that registered the scene in its scope. \n     * This is typically the node that is responsible for rendering the scene and managing its lifecycle.\n     */\n    get owner(): AreNode {\n        return this.scope.issuer() as AreNode;\n    }\n    /**\n     * It's a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle.\n     */\n    get host(): AreDeclaration | undefined {\n        return this._host;\n    }\n    /**\n     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.\n     */\n    get status(): AreSceneStatusNames {\n        return this._status;\n    }\n\n    get isActive(): boolean {\n        return this.status === AreSceneStatuses.Active;\n    }\n\n    get isInactive(): boolean {\n        return this.status === AreSceneStatuses.Inactive;\n    }\n\n    /**\n     * Returns All declaration instructions are registered in the scene scope. Since declaration instructions are the main instructions that represent the structure of the node, we have a separate getter for them to easily access and manage them in the scene.\n     */\n    get declarations(): AreDeclaration[] {\n        return this.scope.resolve<AreDeclaration>(new A_Dependency(AreDeclaration, {\n            flat: true,\n            pagination: {\n                count: -1,\n            }\n        })) as AreDeclaration[] || [];\n    }\n    /**\n     * Returns All mutation instructions are registered in the scene scope. Mutation instructions are the instructions that represent the changes to be applied to the node, so we have a separate getter for them to easily access and manage them in the scene, especially when we want to apply or revert changes based on the mutations.\n     */\n    get mutations(): AreMutation[] {\n        return this.scope.resolve<AreMutation>(new A_Dependency(AreMutation, {\n            flat: true,\n            pagination: {\n                count: -1,\n            }\n        })) as AreMutation[] || [];\n    }\n    /**\n     * Returns All instructions are registered in the scene scope. \n     */\n    get instructions(): AreInstruction[] {\n        return this.scope.resolveFlatAll<AreInstruction>(AreInstruction) || [];\n    }\n    /**\n     * Plan is a queue of changes that should be applied to render the node\n     * \n     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.\n     */\n    get planned(): AreInstruction[] {\n        return this._plan;\n    }\n    /**\n     * State is a list of instructions that are currently applied to the node, \n     * so it represents the current state of the node in the scene.\n     * \n     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.\n     * \n     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.\n     */\n    get applied(): AreInstruction[] {\n        return this._state.reverse(); // we reverse the state to have the correct order of instructions, so the first instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.\n    }\n\n    /**\n     * Should return instructions to be reverted and to be applied. \n     * A difference between plan vs state is that plan is what should be applied to the scene, \n     * while state is what currently applied to the scene. \n     * \n     */\n    get changes(): AreSceneChanges {\n        const toApply = this.planned.filter(i => !this.isApplied(i));\n        const toRevert = this.applied.filter(i => !this.isInPlan(i));\n\n        return {\n            toApply,\n            toRevert,\n        }\n    }\n\n\n    //===============================================================================================\n    //============================= Scene Primary Methods ===========================================\n    //===============================================================================================\n    activate(): void {\n        this._status = AreSceneStatuses.Active;\n    }\n\n    deactivate(): void {\n\n        this._status = AreSceneStatuses.Inactive;\n    }\n    /**\n     * Each scene has a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle. This method allows to set the host instruction for the scene, but it will throw an error if we try to set another host instruction while there is already a host instruction set, so we can ensure that there is only one host instruction for the scene at any given time.\n     * \n     * @param instruction \n     */\n    setHost(instruction: AreDeclaration): void {\n        if (this.host) {\n            const dependentInstructions = this.scope.resolve<AreMutation>(new A_Dependency(AreMutation, {\n                flat: true,\n                pagination: {\n                    count: -1,\n                },\n                query: {\n                    parent: this.host.aseid.toString(),\n\n                }\n            })) as Array<AreMutation> || [];\n\n            dependentInstructions.forEach(element => {\n                element.attachTo(instruction)\n                element.groupWith(instruction);\n            });\n        }\n\n        this._host = instruction;\n    }\n    /**\n     * Unsets the current host instruction from the scene. \n     * \n     * This method should be used when we want to remove the primary declaration instruction that represents the node in the scene, for example, when we want to unmount the node or when we want to replace it with another node. Unsetting the host instruction will allow us to set a new host instruction for the scene if needed.\n     */\n    removeHost(): void {\n        if (this.host)\n            throw new AreSceneError({\n                title: AreSceneError.HostInstructionHasConnectedInstructions,\n                description: `Cannot remove host instruction (${this.host.aseid}) from scene ${this.id} because it has planned instructions in the scene. Please unPlan all instructions related to the host instruction before removing it.`,\n            });\n\n        this._host = undefined;\n\n    }\n\n    // ------------------------------------------------------------------------------------------------------------\n    // Scene Render Plan Methods\n    // ------------------------------------------------------------------------------------------------------------\n    /**\n     * Method that should register the instruction in the plan, so it will be rendered in the next render cycle.\n     * \n     * @param instruction \n     */\n    plan(instruction: AreInstruction) {\n        // const registered = this.getPlanned(instruction);\n\n        // if (!registered) {\n        try {\n            this.scope.register(instruction);\n\n        } catch (error) {\n\n        }\n        this._plan.push(instruction);\n\n        // We also add the instruction to the group map, so we can easily manage instructions by group, for example, when we want to unPlan all instructions related to a specific host instruction, we can easily find them in the group map and unPlan them.\n        if (!this._groupToInstructionsMap.has(instruction.group || 'default')) {\n            this._groupToInstructionsMap.set(instruction.group || 'default', new Set());\n        }\n        this._groupToInstructionsMap.get(instruction.group || 'default')!.add(instruction);\n        // }\n    }\n\n    planBefore(instruction: AreInstruction, beforeInstruction: AreInstruction) {\n        const beforeIndex = this._plan.findIndex(i => i.aseid.toString() === beforeInstruction.aseid.toString());\n        const instructionIndex = this._plan.findIndex(i => i.aseid.toString() === instruction.aseid.toString());\n\n        if (beforeIndex === -1) {\n            throw new AreSceneError({\n                title: AreSceneError.SceneError,\n                description: `Instruction ${beforeInstruction.aseid} is not in the plan of scene ${this.id}. Cannot plan instruction ${instruction.aseid} before it.`,\n            });\n        }\n\n        if (instructionIndex === -1) {\n\n            try {\n                this.scope.register(instruction);\n\n            } catch (error) {\n\n            }\n            this._plan.splice(beforeIndex, 0, instruction);\n        } else {\n            // Instruction is already in the plan, we just need to move it before the beforeInstruction\n            this._plan.splice(instructionIndex, 1); // remove from current position\n            this._plan.splice(beforeIndex, 0, instruction); // insert before the beforeInstruction\n        }\n    }\n\n    planAfter(instruction: AreInstruction, afterInstruction: AreInstruction) {\n        const afterIndex = this._plan.findIndex(i => i.aseid.toString() === afterInstruction.aseid.toString());\n        const instructionIndex = this._plan.findIndex(i => i.aseid.toString() === instruction.aseid.toString());\n\n        if (afterIndex === -1) {\n            throw new AreSceneError({\n                title: AreSceneError.SceneError,\n                description: `Instruction ${afterInstruction.aseid} is not in the plan of scene ${this.id}. Cannot plan instruction ${instruction.aseid} after it.`,\n            });\n        }\n\n        if (instructionIndex === -1) {\n            this.scope.register(instruction);\n            this._plan.splice(afterIndex + 1, 0, instruction);\n        } else {\n            // Instruction is already in the plan, we just need to move it after the afterInstruction\n            this._plan.splice(instructionIndex, 1); // remove from current position\n            this._plan.splice(afterIndex + 1, 0, instruction); // insert after the afterInstruction\n        }\n    }\n\n\n    moveBefore(instruction: AreInstruction, beforeInstruction: AreInstruction) {\n        if (!this.isInPlan(instruction)) {\n            throw new AreSceneError({\n                title: AreSceneError.SceneError,\n                description: `Instruction ${instruction.aseid} is not in the plan of scene ${this.id}. Cannot move instruction before ${beforeInstruction.aseid}. Please plan the instruction before moving it.`,\n            });\n        }\n\n        this.planBefore(instruction, beforeInstruction);\n    }\n\n    moveAfter(instruction: AreInstruction, afterInstruction: AreInstruction) {\n        if (!this.isInPlan(instruction)) {\n            throw new AreSceneError({\n                title: AreSceneError.SceneError,\n                description: `Instruction ${instruction.aseid} is not in the plan of scene ${this.id}. Cannot move instruction after ${afterInstruction.aseid}. Please plan the instruction before moving it.`,\n            });\n        }\n\n        this.planAfter(instruction, afterInstruction);\n    }\n\n\n    /**\n     * Allows to remove instruction from the plan, so it will not be rendered anymore, but it will still be registered in the scene scope, so it can be planned again if needed.\n     * \n     * @param instruction \n     */\n    unPlan(\n        instruction: AreInstruction\n    ) {\n        // const registered = this.getPlanned(instruction);\n\n        // if (registered) {\n        // this.scope.deregister(instruction);\n        this._plan = this._plan.filter(i => i.aseid.toString() !== instruction.aseid.toString());\n        // }\n\n    }\n    /**\n     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.\n     * \n     * @param instruction \n     * @returns \n     */\n    getPlanned(instruction: AreInstruction): AreInstruction | undefined {\n        const found = this._plan.find(i => i.aseid.toString() === instruction.aseid.toString());\n\n        return found;\n    }\n    /**\n     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.\n     * \n     * @param instruction \n     * @returns \n     */\n    isInPlan(instruction: AreInstruction): boolean {\n        return !!this.getPlanned(instruction);\n    }\n\n    // -------------------------------------------------------------------------------------------------------------\n    // Scene Apply Methods\n    // -------------------------------------------------------------------------------------------------------------\n    /**\n     * Method moves the instruction to state to keep it applied and to be able to revert it later if needed. The instruction should be already registered in the scene scope and planned to be applied, otherwise it will not be applied.\n     * \n     * @param instruction \n     */\n    apply(instruction: AreInstruction) {\n        if (!this.isApplied(instruction)) {\n            this._state.push(instruction);\n        }\n    }\n    /**\n     * Method moves the instruction from state to unapply it and to be able to apply it later if needed. The instruction should be already registered in the scene scope and applied, otherwise it will not be unapplied.\n     * \n     * @param instruction \n     */\n    unApply(\n        instruction: AreInstruction\n    ) {\n        this._state = this._state.filter(i => i.aseid.toString() !== instruction.aseid.toString());\n    }\n    /**\n     * Checks if the instruction is already in the state, so it is currently applied to the scene.\n     * \n     * @param instruction \n     * @returns \n     */\n    getApplied(instruction: AreInstruction): AreInstruction | undefined {\n        const found = this._state.find(i => i.aseid.toString() === instruction.aseid.toString());\n\n        return found;\n    }\n    /**\n     * Checks if the instruction is already in the state, so it is currently applied to the scene.\n     * \n     * @param instruction \n     * @returns \n     */\n    isApplied(instruction: AreInstruction): boolean {\n        return !!this.getApplied(instruction);\n    }\n    /**\n     * Method that should reset the scene to the initial state, so it will clear the plan and state, but it will not deregister the instructions from the scene scope, so they will still be registered in the scene and can be planned and applied again if needed.\n     * \n     */\n    reset() {\n        this._plan = [];\n        this._state = [];\n    }\n}"]}