@adaas/are 0.0.2 → 0.0.3

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/AreEvent/AreEvent.context.ts"],"names":["AreEvent","A_Fragment","A_Frame"],"mappings":";;;;;;;;;;;;;AAYaA,gBAAA,GAAN,uBAEGC,mBAAA,CAAW;AAAA,EAOjB,WAAA,CAAY,WAAmB,KAAA,EAAyB;AACpD,IAAA,KAAA,CAAM,EAAE,IAAA,EAAM,SAAA,EAAW,CAAA;AAGzB,IAAA,IAAA,CAAK,MAAA,GAAS,KAAA;AAAA,EAClB;AAAA,EAEA,IAAI,IAAA,GAAU;AACV,IAAA,OAAO,KAAK,MAAA,CAAO,IAAA;AAAA,EACvB;AAAA,EAEA,IAAI,KAAA,GAAgB;AAChB,IAAA,OAAO,KAAK,MAAA,CAAO,KAAA;AAAA,EACvB;AAGJ;AAzBaD,gBAAA,GAAN,eAAA,CAAA;AAAA,EALNE,eAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,UAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACYF,gBAAA,CAAA","file":"AreEvent.context.js","sourcesContent":["import { A_Fragment } from \"@adaas/a-concept\"\nimport { A_Frame } from \"@adaas/a-frame\"\nimport type { AreNode } from \"@adaas/are/node\"\nimport { AreEventProps } from \"./AreEvent.types\"\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreEvent',\n    description: 'Event context for managing events within the A-Concept Rendering Engine (ARE) framework, encapsulating event data and associated nodes to facilitate event-driven interactions.'\n})\nexport class AreEvent<\n    T extends any = any\n> extends A_Fragment {\n\n\n    protected _node?: AreNode\n\n    protected _props: AreEventProps<T>\n\n    constructor(eventName: string, props: AreEventProps<T>) {\n        super({ name: eventName })\n\n\n        this._props = props;\n    }\n\n    get data(): T {\n        return this._props.data\n    }\n\n    get event(): string {\n        return this._props.event\n    }\n\n\n}"]}
+{"version":3,"sources":["../../../../src/lib/AreEvent/AreEvent.context.ts"],"names":["AreEvent","A_ExecutionContext","A_Frame"],"mappings":";;;;;;;;;;;;;AASaA,gBAAA,GAAN,uBAEGC,6BAAA,CAAsB;AAEhC;AAJaD,gBAAA,GAAN,eAAA,CAAA;AAAA,EALNE,eAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,UAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACYF,gBAAA,CAAA","file":"AreEvent.context.js","sourcesContent":["import { A_Frame } from \"@adaas/a-frame\"\nimport { A_ExecutionContext } from \"@adaas/a-utils/a-execution\"\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreEvent',\n    description: 'Event context for managing events within the A-Concept Rendering Engine (ARE) framework, encapsulating event data and associated nodes to facilitate event-driven interactions.'\n})\nexport class AreEvent<\n    T extends Record<string, any> = Record<string, any>\n> extends A_ExecutionContext<T> {\n\n}"]}

package/dist/node/lib/AreEvent/AreEvent.context.mjs

@@ -1,18 +1,8 @@
 import { __decorateClass } from '../../chunk-EQQGB2QZ.mjs';
-import { A_Fragment } from '@adaas/a-concept';
 import { A_Frame } from '@adaas/a-frame';
+import { A_ExecutionContext } from '@adaas/a-utils/a-execution';
 
-let AreEvent = class extends A_Fragment {
-  constructor(eventName, props) {
-    super({ name: eventName });
-    this._props = props;
-  }
-  get data() {
-    return this._props.data;
-  }
-  get event() {
-    return this._props.event;
-  }
+let AreEvent = class extends A_ExecutionContext {
 };
 AreEvent = __decorateClass([
   A_Frame.Fragment({

package/dist/node/lib/AreEvent/AreEvent.context.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/AreEvent/AreEvent.context.ts"],"names":[],"mappings":";;;;AAYO,IAAM,QAAA,GAAN,cAEG,UAAA,CAAW;AAAA,EAOjB,WAAA,CAAY,WAAmB,KAAA,EAAyB;AACpD,IAAA,KAAA,CAAM,EAAE,IAAA,EAAM,SAAA,EAAW,CAAA;AAGzB,IAAA,IAAA,CAAK,MAAA,GAAS,KAAA;AAAA,EAClB;AAAA,EAEA,IAAI,IAAA,GAAU;AACV,IAAA,OAAO,KAAK,MAAA,CAAO,IAAA;AAAA,EACvB;AAAA,EAEA,IAAI,KAAA,GAAgB;AAChB,IAAA,OAAO,KAAK,MAAA,CAAO,KAAA;AAAA,EACvB;AAGJ;AAzBa,QAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,UAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,QAAA,CAAA","file":"AreEvent.context.mjs","sourcesContent":["import { A_Fragment } from \"@adaas/a-concept\"\nimport { A_Frame } from \"@adaas/a-frame\"\nimport type { AreNode } from \"@adaas/are/node\"\nimport { AreEventProps } from \"./AreEvent.types\"\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreEvent',\n    description: 'Event context for managing events within the A-Concept Rendering Engine (ARE) framework, encapsulating event data and associated nodes to facilitate event-driven interactions.'\n})\nexport class AreEvent<\n    T extends any = any\n> extends A_Fragment {\n\n\n    protected _node?: AreNode\n\n    protected _props: AreEventProps<T>\n\n    constructor(eventName: string, props: AreEventProps<T>) {\n        super({ name: eventName })\n\n\n        this._props = props;\n    }\n\n    get data(): T {\n        return this._props.data\n    }\n\n    get event(): string {\n        return this._props.event\n    }\n\n\n}"]}
+{"version":3,"sources":["../../../../src/lib/AreEvent/AreEvent.context.ts"],"names":[],"mappings":";;;;AASO,IAAM,QAAA,GAAN,cAEG,kBAAA,CAAsB;AAEhC;AAJa,QAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,QAAA,CAAS;AAAA,IACd,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,UAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,QAAA,CAAA","file":"AreEvent.context.mjs","sourcesContent":["import { A_Frame } from \"@adaas/a-frame\"\nimport { A_ExecutionContext } from \"@adaas/a-utils/a-execution\"\n\n\n@A_Frame.Fragment({\n    namespace: 'A-ARE',\n    name: 'AreEvent',\n    description: 'Event context for managing events within the A-Concept Rendering Engine (ARE) framework, encapsulating event data and associated nodes to facilitate event-driven interactions.'\n})\nexport class AreEvent<\n    T extends Record<string, any> = Record<string, any>\n> extends A_ExecutionContext<T> {\n\n}"]}

package/dist/node/lib/AreInstruction/AreInstruction.constants.d.mts

@@ -0,0 +1,21 @@
+declare const AreInstructionFeatures: {
+    /**
+     * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.
+     */
+    readonly Apply: "_AreInstruction_Apply";
+    /**
+     * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.
+     */
+    readonly Update: "_AreInstruction_Update";
+    /**
+     * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.
+     */
+    readonly Revert: "_AreInstruction_Revert";
+};
+declare const AreInstructionDefaultNames: {
+    readonly Default: "_Are_DefaultInstruction";
+    readonly Declaration: "_Are_DeclarationInstruction";
+    readonly Mutation: "_Are_MutationInstruction";
+};
+
+export { AreInstructionDefaultNames, AreInstructionFeatures };

package/dist/node/lib/AreInstruction/AreInstruction.constants.d.ts

@@ -0,0 +1,21 @@
+declare const AreInstructionFeatures: {
+    /**
+     * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.
+     */
+    readonly Apply: "_AreInstruction_Apply";
+    /**
+     * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.
+     */
+    readonly Update: "_AreInstruction_Update";
+    /**
+     * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.
+     */
+    readonly Revert: "_AreInstruction_Revert";
+};
+declare const AreInstructionDefaultNames: {
+    readonly Default: "_Are_DefaultInstruction";
+    readonly Declaration: "_Are_DeclarationInstruction";
+    readonly Mutation: "_Are_MutationInstruction";
+};
+
+export { AreInstructionDefaultNames, AreInstructionFeatures };

package/dist/node/lib/AreInstruction/AreInstruction.constants.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const AreInstructionFeatures = {
+  /**
+   * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.
+   */
+  Apply: "_AreInstruction_Apply",
+  /**
+   * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.
+   */
+  Update: "_AreInstruction_Update",
+  /**
+   * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.
+   */
+  Revert: "_AreInstruction_Revert"
+};
+const AreInstructionDefaultNames = {
+  Default: "_Are_DefaultInstruction",
+  Declaration: "_Are_DeclarationInstruction",
+  Mutation: "_Are_MutationInstruction"
+};
+
+exports.AreInstructionDefaultNames = AreInstructionDefaultNames;
+exports.AreInstructionFeatures = AreInstructionFeatures;
+//# sourceMappingURL=AreInstruction.constants.js.map
+//# sourceMappingURL=AreInstruction.constants.js.map

package/dist/node/lib/AreInstruction/AreInstruction.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.constants.ts"],"names":[],"mappings":";;AAEO,MAAM,sBAAA,GAAyB;AAAA;AAAA;AAAA;AAAA,EAIlC,KAAA,EAAO,uBAAA;AAAA;AAAA;AAAA;AAAA,EAIP,MAAA,EAAQ,wBAAA;AAAA;AAAA;AAAA;AAAA,EAIR,MAAA,EAAQ;AACZ;AAGO,MAAM,0BAAA,GAA6B;AAAA,EACtC,OAAA,EAAS,yBAAA;AAAA,EACT,WAAA,EAAa,6BAAA;AAAA,EACb,QAAA,EAAU;AACd","file":"AreInstruction.constants.js","sourcesContent":["\n\nexport const AreInstructionFeatures = {\n    /**\n     * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.\n     */\n    Apply: '_AreInstruction_Apply',\n    /**\n     * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.\n     */\n    Update: '_AreInstruction_Update',\n    /**\n     * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.\n     */\n    Revert: '_AreInstruction_Revert'\n} as const\n\n\nexport const AreInstructionDefaultNames = {\n    Default: '_Are_DefaultInstruction',\n    Declaration: '_Are_DeclarationInstruction',\n    Mutation: '_Are_MutationInstruction',\n} as const"]}

package/dist/node/lib/AreInstruction/AreInstruction.constants.mjs

@@ -0,0 +1,25 @@
+import '../../chunk-EQQGB2QZ.mjs';
+
+const AreInstructionFeatures = {
+  /**
+   * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.
+   */
+  Apply: "_AreInstruction_Apply",
+  /**
+   * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.
+   */
+  Update: "_AreInstruction_Update",
+  /**
+   * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.
+   */
+  Revert: "_AreInstruction_Revert"
+};
+const AreInstructionDefaultNames = {
+  Default: "_Are_DefaultInstruction",
+  Declaration: "_Are_DeclarationInstruction",
+  Mutation: "_Are_MutationInstruction"
+};
+
+export { AreInstructionDefaultNames, AreInstructionFeatures };
+//# sourceMappingURL=AreInstruction.constants.mjs.map
+//# sourceMappingURL=AreInstruction.constants.mjs.map

package/dist/node/lib/AreInstruction/AreInstruction.constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.constants.ts"],"names":[],"mappings":";;AAEO,MAAM,sBAAA,GAAyB;AAAA;AAAA;AAAA;AAAA,EAIlC,KAAA,EAAO,uBAAA;AAAA;AAAA;AAAA;AAAA,EAIP,MAAA,EAAQ,wBAAA;AAAA;AAAA;AAAA;AAAA,EAIR,MAAA,EAAQ;AACZ;AAGO,MAAM,0BAAA,GAA6B;AAAA,EACtC,OAAA,EAAS,yBAAA;AAAA,EACT,WAAA,EAAa,6BAAA;AAAA,EACb,QAAA,EAAU;AACd","file":"AreInstruction.constants.mjs","sourcesContent":["\n\nexport const AreInstructionFeatures = {\n    /**\n     * The 'Apply' feature indicates that the instruction has been applied to the scene or component, meaning that its effects have been executed and are now reflected in the state of the scene or component. This status is typically used to track the lifecycle of an instruction, allowing for proper management and potential reversal of changes if needed.\n     */\n    Apply: '_AreInstruction_Apply',\n    /**\n     * The 'Update' feature indicates that the instruction has been updated, meaning that its properties or effects have been modified after it was initially applied. This status is important for managing dynamic changes in the scene or component, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely.\n     */\n    Update: '_AreInstruction_Update',\n    /**\n     * The 'Revert' feature indicates that the instruction has been reverted, meaning that any changes or effects that were applied by the instruction have been undone, and the scene or component has been returned to its previous state before the instruction was applied. This status is crucial for managing the state of the scene or component, especially in cases where an instruction needs to be rolled back due to errors or changes in requirements.\n     */\n    Revert: '_AreInstruction_Revert'\n} as const\n\n\nexport const AreInstructionDefaultNames = {\n    Default: '_Are_DefaultInstruction',\n    Declaration: '_Are_DeclarationInstruction',\n    Mutation: '_Are_MutationInstruction',\n} as const"]}

package/dist/node/lib/AreInstruction/AreInstruction.entity.d.mts

@@ -0,0 +1,14 @@
+import '@adaas/a-concept';
+export { c as AreInstruction } from '../../Are.context-D7w32H1G.mjs';
+import '../AreStore/AreStore.types.mjs';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../AreScene/AreScene.constants.mjs';
+import '../AreAttribute/AreAttribute.types.mjs';
+import '../AreAttribute/AreAttribute.constants.mjs';
+import '../AreComponent/Are.component.mjs';
+import '../AreComponent/Are.types.mjs';
+import '../AreComponent/Are.constants.mjs';
+import '../AreNode/AreNode.constants.mjs';
+import '../AreStore/AreStore.constants.mjs';

package/dist/node/lib/AreInstruction/AreInstruction.entity.d.ts

@@ -0,0 +1,14 @@
+import '@adaas/a-concept';
+export { c as AreInstruction } from '../../Are.context-9Ija_fdC.js';
+import '../AreStore/AreStore.types.js';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../AreScene/AreScene.constants.js';
+import '../AreAttribute/AreAttribute.types.js';
+import '../AreAttribute/AreAttribute.constants.js';
+import '../AreComponent/Are.component.js';
+import '../AreComponent/Are.types.js';
+import '../AreComponent/Are.constants.js';
+import '../AreNode/AreNode.constants.js';
+import '../AreStore/AreStore.constants.js';

package/dist/node/lib/AreInstruction/AreInstruction.entity.js

@@ -0,0 +1,152 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var aFrame = require('@adaas/a-frame');
+var AreInstruction_constants = require('./AreInstruction.constants');
+
+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.AreInstruction = class AreInstruction extends aConcept.A_Entity {
+  /**
+   * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
+   */
+  get name() {
+    return this._name;
+  }
+  /**
+   * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed. 
+   * 
+   * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.
+   */
+  get payload() {
+    return this._payload || {};
+  }
+  /**
+   * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. 
+   * 
+   * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
+   */
+  get group() {
+    return this._group;
+  }
+  /**
+   * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
+   * 
+   * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.
+   */
+  get parent() {
+    return this._parent;
+  }
+  get id() {
+    return this.aseid.id;
+  }
+  get owner() {
+    return aConcept.A_Context.scope(this).issuer();
+  }
+  fromNew(newEntity) {
+    this.aseid = this.generateASEID({
+      // shard: newEntity.node.id,
+      entity: aConcept.A_FormatterHelper.toKebabCase(newEntity.name)
+      // id: id,
+    });
+    this._name = newEntity.name;
+    this._payload = newEntity.payload;
+    this._group = newEntity.group?.aseid.toString();
+    this._parent = newEntity.parent?.aseid.toString();
+  }
+  fromUndefined() {
+    throw new aConcept.A_Error({
+      title: "Cannot create an instruction without properties",
+      description: "AreInstruction cannot be created without properties. Please provide the necessary properties to create an instruction."
+    });
+  }
+  // ===============================================================================
+  // ----------------------------Instruction Operations ------------------------------
+  // ===============================================================================
+  /**
+   * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions. 
+   * 
+   * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.
+   * 
+   * @param instruction 
+   * @returns 
+   */
+  groupWith(instruction) {
+    this._group = instruction.id;
+    return this;
+  }
+  /**
+   * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.
+   * 
+   * @returns 
+   */
+  unGroup() {
+    this._group = void 0;
+    return this;
+  }
+  /**
+   * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies. 
+   * 
+   * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.
+   * 
+   * @param parent 
+   * @returns 
+   */
+  attachTo(parent) {
+    this._parent = parent.id;
+    return this;
+  }
+  /**
+   * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.
+   * 
+   * @returns 
+   */
+  detach() {
+    this._parent = void 0;
+    return this;
+  }
+  // ===============================================================================
+  // ----------------------------Instruction Features ------------------------------
+  // ===============================================================================
+  /**
+   * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. 
+   * 
+   * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.
+   * 
+   * @param scope 
+   */
+  apply(scope) {
+    this.call(AreInstruction_constants.AreInstructionFeatures.Apply, scope);
+  }
+  /**
+   * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.
+   * 
+   * @param scope 
+   */
+  update(scope) {
+    this.call(AreInstruction_constants.AreInstructionFeatures.Update, scope);
+  }
+  /**
+   * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.
+   * 
+   * @param scope 
+   */
+  revert(scope) {
+    this.call(AreInstruction_constants.AreInstructionFeatures.Revert, scope);
+  }
+};
+exports.AreInstruction = __decorateClass([
+  aFrame.A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreInstruction",
+    description: "AreInstruction is the base entity for all rendering instructions in the ARE framework. It represents a serializable, reversible operation (such as creating or mutating a DOM element) that can be applied to and tracked within the AreScene, enabling deterministic rendering and undo/redo capabilities."
+  })
+], exports.AreInstruction);
+//# sourceMappingURL=AreInstruction.entity.js.map
+//# sourceMappingURL=AreInstruction.entity.js.map

package/dist/node/lib/AreInstruction/AreInstruction.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.entity.ts"],"names":["AreInstruction","A_Entity","A_Context","A_FormatterHelper","A_Error","AreInstructionFeatures","A_Frame"],"mappings":"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","file":"AreInstruction.entity.js","sourcesContent":["\nimport { A_Context, A_Entity, A_Error, A_FormatterHelper, A_Scope } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport type { AreNode } from \"@adaas/are/node/AreNode.entity\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"./AreInstruction.types\";\nimport { AreInstructionFeatures } from \"./AreInstruction.constants\";\nimport { AreStoreWatchingEntity } from \"@adaas/are/store/AreStore.types\";\n\n\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreInstruction',\n    description: 'AreInstruction is the base entity for all rendering instructions in the ARE framework. It represents a serializable, reversible operation (such as creating or mutating a DOM element) that can be applied to and tracked within the AreScene, enabling deterministic rendering and undo/redo capabilities.'\n})\nexport class AreInstruction<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends A_Entity<AreInstructionNewProps<T>, S> implements AreStoreWatchingEntity {\n    /**\n     * The name of the instruction, for example \"CreateElement\", \"AddAttribute\", \"RemoveNode\", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example \"CreateElement\" for instructions that create new elements, \"UpdateAttribute\" for instructions that update attributes, etc.\n     */\n    protected _name!: string\n    /**\n     * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed.\n     */\n    protected _payload?: T\n    /**\n     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.\n     */\n    protected _group: string | undefined\n    /**\n     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.\n     */\n    protected _parent: string | undefined\n\n    /**\n     * A set of properties that influence the behavior of the instruction, for example, for AddTextInstruction, we can interpolation dependent on some key in the store, so we can have a property called \"interpolationKey\" that will be used to track the dependencies of the instruction, and when the value of this key changes in the scope, we can update the instruction accordingly.\n     */\n    protected _props!: Set<string>\n\n\n    /**\n     * The name of the instruction, for example \"CreateElement\", \"AddAttribute\", \"RemoveNode\", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example \"CreateElement\" for instructions that create new elements, \"UpdateAttribute\" for instructions that update attributes, etc.\n     */\n    get name(): string {\n        return this._name;\n    }\n    /**\n     * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed. \n     * \n     * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.\n     */\n    get payload(): T {\n        return this._payload || {} as T;\n    }\n\n    /**\n     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.\n     */\n    get group(): string | undefined {\n        return this._group;\n    }\n    /**\n     * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.\n     * \n     * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.\n     */\n    get parent(): string | undefined {\n        return this._parent;\n    }\n\n    get id(): string {\n        return this.aseid.id;\n    }\n\n    get owner(): AreNode {\n        return A_Context.scope(this).issuer<AreNode>()!;\n    }\n\n\n    fromNew(newEntity: AreInstructionNewProps<T>): void {\n\n        // TODO: Verify if deduplication ID is needed\n        // const identity = newEntity.id || {\n        //     name: newEntity.name,\n        // };\n\n        // const id = AreCacheHelper.createHash(identity);\n\n        this.aseid = this.generateASEID({\n            // shard: newEntity.node.id,\n            entity: A_FormatterHelper.toKebabCase(newEntity.name),\n            // id: id,\n        });\n\n        this._name = newEntity.name;\n        this._payload = newEntity.payload\n        this._group = newEntity.group?.aseid.toString();\n        this._parent = newEntity.parent?.aseid.toString();\n    }\n\n\n    fromUndefined(): void {\n        throw new A_Error({\n            title: \"Cannot create an instruction without properties\",\n            description: \"AreInstruction cannot be created without properties. Please provide the necessary properties to create an instruction.\",\n        })\n    }\n\n\n    // ===============================================================================\n    // ----------------------------Instruction Operations ------------------------------\n    // ===============================================================================\n\n    /**\n     * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.\n     * \n     * @param instruction \n     * @returns \n     */\n    groupWith(instruction: AreInstruction): this {\n        this._group = instruction.id;\n        return this;\n    }\n    /**\n     * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.\n     * \n     * @returns \n     */\n    unGroup(): this {\n        this._group = undefined;\n        return this;\n    }\n    /**\n     * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies. \n     * \n     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.\n     * \n     * @param parent \n     * @returns \n     */\n    attachTo(parent: AreInstruction): this {\n        this._parent = parent.id;\n        return this;\n    }\n    /**\n     * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.\n     * \n     * @returns \n     */\n    detach(): this {\n        this._parent = undefined;\n        return this;\n    }\n\n\n    // ===============================================================================\n    // ----------------------------Instruction Features ------------------------------\n    // ===============================================================================\n    /**\n     * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. \n     * \n     * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.\n     * \n     * @param scope \n     */\n    apply(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Apply, scope);\n    }   \n    /**\n     * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.\n     * \n     * @param scope \n     */\n    update(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Update, scope);\n    }\n    /**\n     * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.\n     * \n     * @param scope \n     */\n    revert(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Revert, scope);\n    }\n\n}\n\n\n\n\n\n\n\n\n"]}

package/dist/node/lib/AreInstruction/AreInstruction.entity.mjs

@@ -0,0 +1,145 @@
+import { __decorateClass } from '../../chunk-EQQGB2QZ.mjs';
+import { A_Entity, A_Context, A_FormatterHelper, A_Error } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame';
+import { AreInstructionFeatures } from './AreInstruction.constants';
+
+let AreInstruction = class extends A_Entity {
+  /**
+   * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
+   */
+  get name() {
+    return this._name;
+  }
+  /**
+   * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed. 
+   * 
+   * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.
+   */
+  get payload() {
+    return this._payload || {};
+  }
+  /**
+   * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. 
+   * 
+   * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
+   */
+  get group() {
+    return this._group;
+  }
+  /**
+   * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
+   * 
+   * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.
+   */
+  get parent() {
+    return this._parent;
+  }
+  get id() {
+    return this.aseid.id;
+  }
+  get owner() {
+    return A_Context.scope(this).issuer();
+  }
+  fromNew(newEntity) {
+    this.aseid = this.generateASEID({
+      // shard: newEntity.node.id,
+      entity: A_FormatterHelper.toKebabCase(newEntity.name)
+      // id: id,
+    });
+    this._name = newEntity.name;
+    this._payload = newEntity.payload;
+    this._group = newEntity.group?.aseid.toString();
+    this._parent = newEntity.parent?.aseid.toString();
+  }
+  fromUndefined() {
+    throw new A_Error({
+      title: "Cannot create an instruction without properties",
+      description: "AreInstruction cannot be created without properties. Please provide the necessary properties to create an instruction."
+    });
+  }
+  // ===============================================================================
+  // ----------------------------Instruction Operations ------------------------------
+  // ===============================================================================
+  /**
+   * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions. 
+   * 
+   * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.
+   * 
+   * @param instruction 
+   * @returns 
+   */
+  groupWith(instruction) {
+    this._group = instruction.id;
+    return this;
+  }
+  /**
+   * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.
+   * 
+   * @returns 
+   */
+  unGroup() {
+    this._group = void 0;
+    return this;
+  }
+  /**
+   * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies. 
+   * 
+   * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.
+   * 
+   * @param parent 
+   * @returns 
+   */
+  attachTo(parent) {
+    this._parent = parent.id;
+    return this;
+  }
+  /**
+   * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.
+   * 
+   * @returns 
+   */
+  detach() {
+    this._parent = void 0;
+    return this;
+  }
+  // ===============================================================================
+  // ----------------------------Instruction Features ------------------------------
+  // ===============================================================================
+  /**
+   * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. 
+   * 
+   * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.
+   * 
+   * @param scope 
+   */
+  apply(scope) {
+    this.call(AreInstructionFeatures.Apply, scope);
+  }
+  /**
+   * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.
+   * 
+   * @param scope 
+   */
+  update(scope) {
+    this.call(AreInstructionFeatures.Update, scope);
+  }
+  /**
+   * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.
+   * 
+   * @param scope 
+   */
+  revert(scope) {
+    this.call(AreInstructionFeatures.Revert, scope);
+  }
+};
+AreInstruction = __decorateClass([
+  A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreInstruction",
+    description: "AreInstruction is the base entity for all rendering instructions in the ARE framework. It represents a serializable, reversible operation (such as creating or mutating a DOM element) that can be applied to and tracked within the AreScene, enabling deterministic rendering and undo/redo capabilities."
+  })
+], AreInstruction);
+
+export { AreInstruction };
+//# sourceMappingURL=AreInstruction.entity.mjs.map
+//# sourceMappingURL=AreInstruction.entity.mjs.map

package/dist/node/lib/AreInstruction/AreInstruction.entity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.entity.ts"],"names":[],"mappings":"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","file":"AreInstruction.entity.mjs","sourcesContent":["\nimport { A_Context, A_Entity, A_Error, A_FormatterHelper, A_Scope } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport type { AreNode } from \"@adaas/are/node/AreNode.entity\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"./AreInstruction.types\";\nimport { AreInstructionFeatures } from \"./AreInstruction.constants\";\nimport { AreStoreWatchingEntity } from \"@adaas/are/store/AreStore.types\";\n\n\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreInstruction',\n    description: 'AreInstruction is the base entity for all rendering instructions in the ARE framework. It represents a serializable, reversible operation (such as creating or mutating a DOM element) that can be applied to and tracked within the AreScene, enabling deterministic rendering and undo/redo capabilities.'\n})\nexport class AreInstruction<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends A_Entity<AreInstructionNewProps<T>, S> implements AreStoreWatchingEntity {\n    /**\n     * The name of the instruction, for example \"CreateElement\", \"AddAttribute\", \"RemoveNode\", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example \"CreateElement\" for instructions that create new elements, \"UpdateAttribute\" for instructions that update attributes, etc.\n     */\n    protected _name!: string\n    /**\n     * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed.\n     */\n    protected _payload?: T\n    /**\n     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.\n     */\n    protected _group: string | undefined\n    /**\n     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.\n     */\n    protected _parent: string | undefined\n\n    /**\n     * A set of properties that influence the behavior of the instruction, for example, for AddTextInstruction, we can interpolation dependent on some key in the store, so we can have a property called \"interpolationKey\" that will be used to track the dependencies of the instruction, and when the value of this key changes in the scope, we can update the instruction accordingly.\n     */\n    protected _props!: Set<string>\n\n\n    /**\n     * The name of the instruction, for example \"CreateElement\", \"AddAttribute\", \"RemoveNode\", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example \"CreateElement\" for instructions that create new elements, \"UpdateAttribute\" for instructions that update attributes, etc.\n     */\n    get name(): string {\n        return this._name;\n    }\n    /**\n     * The payload of the instruction, which can contain any additional information that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene. The payload is optional and can be an empty object if no additional information is needed. \n     * \n     * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.\n     */\n    get payload(): T {\n        return this._payload || {} as T;\n    }\n\n    /**\n     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.\n     */\n    get group(): string | undefined {\n        return this._group;\n    }\n    /**\n     * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.\n     * \n     * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.\n     */\n    get parent(): string | undefined {\n        return this._parent;\n    }\n\n    get id(): string {\n        return this.aseid.id;\n    }\n\n    get owner(): AreNode {\n        return A_Context.scope(this).issuer<AreNode>()!;\n    }\n\n\n    fromNew(newEntity: AreInstructionNewProps<T>): void {\n\n        // TODO: Verify if deduplication ID is needed\n        // const identity = newEntity.id || {\n        //     name: newEntity.name,\n        // };\n\n        // const id = AreCacheHelper.createHash(identity);\n\n        this.aseid = this.generateASEID({\n            // shard: newEntity.node.id,\n            entity: A_FormatterHelper.toKebabCase(newEntity.name),\n            // id: id,\n        });\n\n        this._name = newEntity.name;\n        this._payload = newEntity.payload\n        this._group = newEntity.group?.aseid.toString();\n        this._parent = newEntity.parent?.aseid.toString();\n    }\n\n\n    fromUndefined(): void {\n        throw new A_Error({\n            title: \"Cannot create an instruction without properties\",\n            description: \"AreInstruction cannot be created without properties. Please provide the necessary properties to create an instruction.\",\n        })\n    }\n\n\n    // ===============================================================================\n    // ----------------------------Instruction Operations ------------------------------\n    // ===============================================================================\n\n    /**\n     * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions. \n     * \n     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.\n     * \n     * @param instruction \n     * @returns \n     */\n    groupWith(instruction: AreInstruction): this {\n        this._group = instruction.id;\n        return this;\n    }\n    /**\n     * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.\n     * \n     * @returns \n     */\n    unGroup(): this {\n        this._group = undefined;\n        return this;\n    }\n    /**\n     * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies. \n     * \n     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.\n     * \n     * @param parent \n     * @returns \n     */\n    attachTo(parent: AreInstruction): this {\n        this._parent = parent.id;\n        return this;\n    }\n    /**\n     * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.\n     * \n     * @returns \n     */\n    detach(): this {\n        this._parent = undefined;\n        return this;\n    }\n\n\n    // ===============================================================================\n    // ----------------------------Instruction Features ------------------------------\n    // ===============================================================================\n    /**\n     * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. \n     * \n     * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.\n     * \n     * @param scope \n     */\n    apply(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Apply, scope);\n    }   \n    /**\n     * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.\n     * \n     * @param scope \n     */\n    update(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Update, scope);\n    }\n    /**\n     * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.\n     * \n     * @param scope \n     */\n    revert(\n        scope?: A_Scope\n    ): void {\n        this.call(AreInstructionFeatures.Revert, scope);\n    }\n\n}\n\n\n\n\n\n\n\n\n"]}

package/dist/node/lib/AreInstruction/AreInstruction.error.d.mts

@@ -0,0 +1,6 @@
+import { A_Error } from '@adaas/a-concept';
+
+declare class AreInstructionError extends A_Error {
+}
+
+export { AreInstructionError };

package/dist/node/lib/AreInstruction/AreInstruction.error.d.ts

@@ -0,0 +1,6 @@
+import { A_Error } from '@adaas/a-concept';
+
+declare class AreInstructionError extends A_Error {
+}
+
+export { AreInstructionError };

package/dist/node/lib/AreInstruction/AreInstruction.error.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+
+class AreInstructionError extends aConcept.A_Error {
+}
+
+exports.AreInstructionError = AreInstructionError;
+//# sourceMappingURL=AreInstruction.error.js.map
+//# sourceMappingURL=AreInstruction.error.js.map

package/dist/node/lib/AreInstruction/AreInstruction.error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.error.ts"],"names":["A_Error"],"mappings":";;;;AAIO,MAAM,4BAA4BA,gBAAA,CAAO;AAEhD","file":"AreInstruction.error.js","sourcesContent":["import { A_Error } from \"@adaas/a-concept\"\n\n\n\nexport class AreInstructionError extends A_Error{\n    \n}"]}

package/dist/node/lib/AreInstruction/AreInstruction.error.mjs

@@ -0,0 +1,9 @@
+import '../../chunk-EQQGB2QZ.mjs';
+import { A_Error } from '@adaas/a-concept';
+
+class AreInstructionError extends A_Error {
+}
+
+export { AreInstructionError };
+//# sourceMappingURL=AreInstruction.error.mjs.map
+//# sourceMappingURL=AreInstruction.error.mjs.map

package/dist/node/lib/AreInstruction/AreInstruction.error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/AreInstruction/AreInstruction.error.ts"],"names":[],"mappings":";;;AAIO,MAAM,4BAA4B,OAAA,CAAO;AAEhD","file":"AreInstruction.error.mjs","sourcesContent":["import { A_Error } from \"@adaas/a-concept\"\n\n\n\nexport class AreInstructionError extends A_Error{\n    \n}"]}