arrmatura 6.3.1 → 6.3.2

package/src/core/ManifestNode.ts

@@ -1,38 +1,46 @@
+import type { IPlatform, IArrmatron, IManifestNode } from "arrmatura/types";
 import { nextId } from "ultimus";
-import { compilePipeExpression } from "../utils/compileExpression";
 import type { Delta, ExpressionText, Hash, Uid } from "ultimus/types";
-import type { IPlatform, IEntitron, IManifestNode } from "arrmatura/types";
+
+import { compilePipeExpression } from "../utils/compileExpression";
+
+import { Arrmatron } from "./Arrmatron";
 import { resolveExpression } from "./resolveExpression";
 
-type PropertyResolver = (c: IEntitron, acc: Delta) => Delta;
 
-type PropertyGetter = (c: IEntitron) => unknown;
+type PropertyResolver = (c: IArrmatron, acc: Delta) => Delta;
+
+type PropertyGetter = (c: IArrmatron) => unknown;
 
 /**
- * ManifestNode is a abstract factory for Entitron.
+ * ManifestNode is a abstract factory for Arrmatron.
  * 
- * Each specific kind of Entitron has its own descending implementation of ManifestNode.
+ * Each specific kind of Arrmatron has its own descending implementation of ManifestNode.
  */
 export abstract class ManifestNode implements IManifestNode {
   protected $content?: Map<Uid, IManifestNode> | undefined;
-  uid: Uid = nextId("N");
+  uid: Uid;
   refId?: string;
   private readonly propertyResolvers: PropertyResolver[] = [];
-  private initialState: Hash<(c: IEntitron) => any> = {};
-  connectors?: Map<string, (c: IEntitron, x: unknown) => unknown>;
+  private initialState: Hash<(c: IArrmatron) => any> = {};
+  connectors?: Map<string, (c: IArrmatron, x: unknown) => unknown>;
   tag: any;
 
-  abstract get EntitronConstructor(): new (platform: IPlatform, node: typeof this, parent?: IEntitron, scope?: IEntitron) => IEntitron;
+  constructor(xid: Uid) {
+    this.uid = `${nextId("N")}:${xid}`;
+  }
+
+  abstract get EntitronConstructor(): new (platform: IPlatform, node: typeof this, parent?: Arrmatron, scope?: Arrmatron) => Arrmatron;
 
   /**
    * Create a context object.
    *
    * @param {IPlatform} platform - The platform object.
-   * @param {IEntitron} parent - The parent context object (optional).
-   * @param {IEntitron} scope - The scope context object (optional).
-   * @return {IEntitron} The created context object.
+   * @param {IArrmatron} parent - The parent context object (optional).
+   * @param {IArrmatron} scope - The scope context object (optional).
+   * @return {IArrmatron} The created context object.
    */
-  createEntitron(platform: IPlatform, parent?: IEntitron, scope?: IEntitron): IEntitron {
+  createArrmatron(platform: IPlatform, parent?: Arrmatron, scope?: Arrmatron): Arrmatron {
     return new this.EntitronConstructor(platform, this, parent, scope);
   }
 
@@ -41,7 +49,7 @@ export abstract class ManifestNode implements IManifestNode {
   }
 
   addPropertyResolver(getter: PropertyGetter, propKey: string) {
-    this.propertyResolvers.push((c: IEntitron, delta: Delta) => {
+    this.propertyResolvers.push((c: IArrmatron, delta: Delta) => {
       delta[propKey] = getter(c);
       return delta;
     });
@@ -49,7 +57,7 @@ export abstract class ManifestNode implements IManifestNode {
   }
 
   private addDataPropertyResolver(getter: PropertyGetter, propKey: string) {
-    this.propertyResolvers.push((c: IEntitron, delta: Delta) => {
+    this.propertyResolvers.push((c: IArrmatron, delta: Delta) => {
       const val = getter(c);
       delta.data = Object.assign((delta.data as object) || {}, {
         [propKey]: val,
@@ -60,7 +68,7 @@ export abstract class ManifestNode implements IManifestNode {
   }
 
   private addPropertiesResolver(getter: PropertyGetter) {
-    this.propertyResolvers.push((c: IEntitron, delta: Delta) => {
+    this.propertyResolvers.push((c: IArrmatron, delta: Delta) => {
       const value = getter(c);
       if (value && typeof value === "object") {
         Object.entries(value).forEach(([key, val]) => {
@@ -79,10 +87,11 @@ export abstract class ManifestNode implements IManifestNode {
 
   private addEmitter(expr: ExpressionText, k: string) {
     const { key, pipec } = compilePipeExpression(expr);
-    this.initialState[k] = (c) => (data: unknown) => c.scope?.emit(key, pipec(c, data) as Delta);
+    const rkey = key + (expr.endsWith(")") ? "()" : '');
+    this.initialState[k] = (c) => (data: unknown) => c.scope?.emit(rkey, pipec(c, data) as Delta);
   }
 
-  resolveInitialProps(c: IEntitron) {
+  resolveInitialProps(c: IArrmatron) {
     return this.propertyResolvers.reduce(
       (delta, resolver) => resolver(c, delta),
       Object.entries(this.initialState).reduce((acc, [key, fn]) => {
@@ -92,17 +101,17 @@ export abstract class ManifestNode implements IManifestNode {
     );
   }
 
-  resolveProps(c: IEntitron) {
+  resolveProps(c: IArrmatron) {
     return this.propertyResolvers.reduce((delta, resolver) => resolver(c, delta), {});
   }
 
   compileAttribute(k: string, v: unknown) {
     if (k.startsWith("data-")) {
       this.addDataPropertyResolver(resolveExpression(v), k.slice(5));
-    } else if (k === "ref") {
+    } else if (k === "Ref") {
       this.refId = String(v);
-    } else if (k === "props" || k.startsWith('{...')) {
-      const sv = k.startsWith('{...') ? k.slice(4, -1) : String(v);
+    } else if (k === '(...)') {
+      const sv = String(v);
       if (sv[0] === "<" && sv[1] === "-") {
         this.addConnector(sv.slice(2), "");
       } else {
@@ -116,11 +125,13 @@ export abstract class ManifestNode implements IManifestNode {
           this.addConnector(v.slice(2), k);
         } else if (v[0] === "-" && v[1] === ">") {
           this.addEmitter(v.slice(2), k);
+        } else if (v[0] === "d" && v.startsWith("data->")) {
+          this.addEmitter(v.slice(6), k);
         } else {
-          if (!v.includes("{") && v[0] !== "@") {
+          if (!v.includes("{")) {
             this.initialState[k] = () => v;
           } else {
-            if (v[0] === "@" && v[1] === "@" && v.match(/^@@[a-z0-9\-_.]+$/i) != null) {
+            if (v[0] === "R" && v[1] === "." && v.match(/^@@[a-z0-9\-_.]+$/i) != null) {
               this.initialState[k] = (c) => c.platform.getResource(v.slice(2));
             } else {
               this.addPropertyResolver(resolveExpression(v), k);

package/src/core/resolveExpression.ts

@@ -1,17 +1,22 @@
 import { createStringInterpolator } from "ultimus/src/parsing/createStringInterpolator";
+
 import { compileConstant, compileJsExpression, compilePlaceholder } from "../utils/compileExpression";
+// \{\{([\w\.]+)\}\}
 
 const CACHE = new Map();
 
 function compileExpression(v: unknown) {
   if (typeof v !== "string") return () => v;
 
-  if (v[0] === "@") return compilePlaceholder(v);
-
   if (v.startsWith("js:")) return compileJsExpression(v.slice(3));
 
-  if (v.includes("{")) return createStringInterpolator(v.replace(/\s+/g, " "), compilePlaceholder);
-
+  if (v.includes("{")) {
+    const vCutOne = v.slice(1, -1);
+    if (v[0] === "{" && v[v.length - 1] === "}" && !vCutOne.includes("{")) {
+      return compilePlaceholder(vCutOne)
+    }
+    return createStringInterpolator(v.replace(/\s+/g, " "), compilePlaceholder);
+  }
   return compileConstant(v);
 }
 

package/src/registry/composition.ts

@@ -1,14 +1,15 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { Hash, XmlNode } from "ultimus/types";
 import type { EContent, IManifestNode, IPlatform } from "arrmatura/types";
+import type { Hash, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 
-export class Composite extends Entitron<CCompositeNode> {
+export class Composite extends Arrmatron<CCompositeNode> {
   get displayName(): string {
     return `💠${this.manifest.tag}`;
   }
 
-  get recontentScope(): Entitron {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
@@ -27,8 +28,8 @@ export class CCompositeNode extends ManifestNode {
   nodes?: XmlNode["nodes"];
   #content?: Map<string, IManifestNode>;
 
-  constructor({ tag, attrs, nodes }: XmlNode) {
-    super();
+  constructor({ id, tag, attrs, nodes }: XmlNode) {
+    super(id);
     this.tag = tag;
     this.nodes = nodes;
     this.compileAttributes(attrs);
@@ -53,7 +54,7 @@ export class CCompositeNode extends ManifestNode {
       }, {});
     }
 
-    return this.slotContent[slotId ?? "default"] ?? undefined;
+    return this.slotContent[slotId || "default"] ?? undefined;
   }
 
   getSubNodes(platform: IPlatform) {

package/src/registry/conditionals.ts

@@ -1,14 +1,16 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Composite } from "./composition";
-import { Entitron } from "../core/Entitron";
-import type { EContent, IEntitron, IPlatform } from "arrmatura/types";
+import type { EContent, IArrmatron, IPlatform } from "arrmatura/types";
 import type { XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 import { compilePlaceholder } from "../utils/compileExpression";
 
-class Conditional extends Entitron<CIfNode> {
+import { Composite } from "./composition";
+
+class Conditional extends Arrmatron<CIfNode> {
   get contentManifests() {
     const branches = this.manifest.getBranches(this.platform);
-    return this.component.condition ? branches.then : branches.else;
+    return this.$component.condition ? branches.then : branches.else;
   }
 
   get displayName(): string {
@@ -20,7 +22,7 @@ export class CIfNode extends ManifestNode {
   #xml: XmlNode;
   #branches?: { then?: EContent; else?: EContent };
   constructor(xml: XmlNode, expr: string) {
-    super();
+    super(xml.id);
     this.#xml = xml;
     this.compileCondition(expr);
   }
@@ -66,7 +68,7 @@ export class CIfNode extends ManifestNode {
     } else if (expr.slice(0, 5) === "slot(") {
       const slotId = expr.slice(5, -1);
       // DO NOT place inside iterations.
-      this.addPropertyResolver((c: IEntitron) => !!(c.scope as Composite).slotContent?.(slotId)?.size, "condition");
+      this.addPropertyResolver((c: IArrmatron) => !!(c.scope as Composite).slotContent?.(slotId)?.size, "condition");
     } else {
       const resolver = compilePlaceholder(expr);
       this.addPropertyResolver((c) => !!resolver(c), "condition");

package/src/registry/connector.ts

@@ -0,0 +1,47 @@
+import { Fn, XmlNode } from "ultimus";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+import { objectFingerprint } from "../utils/FingerprintMashine";
+
+class Connector extends Arrmatron<ConnectorNode> {
+  prevkey: any;
+
+  counter = 0;
+
+  /**
+   * Triggers an with changes after a specified timeout.
+   *
+   * @return {void} No return value.
+   */
+  touch() {
+    super.touch();
+    //   if (this.isDone) return;
+    const { trigger, data, change } = this.$component;
+    const key = 'trigger' in this.$component ? trigger : data;
+    const fprint = objectFingerprint(key);
+    const changed = !('prevkey' in this) || this.prevkey != fprint;
+
+    if (!changed) return;
+
+    this.prevkey = fprint;
+
+    (change as Fn)?.(data);
+  }
+
+  get displayName(): string {
+    return "🔹Connector";
+  }
+}
+
+export class ConnectorNode extends ManifestNode {
+  constructor({ attrs, id }: XmlNode) {
+    super(id);
+    this.compileAttributes(attrs);
+  }
+
+  get EntitronConstructor() {
+    return Connector;
+  }
+
+}

package/src/registry/elementary.ts

@@ -1,9 +1,10 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { Hash, XmlNode } from "ultimus/types";
 import { IPlatform } from "arrmatura/types";
+import type { Hash, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 
-class NativeElementEntitron extends Entitron<CElementNode> {
+class NativeElementEntitron extends Arrmatron<CElementNode> {
   get displayName(): string {
     return this.manifest.tag;
   }
@@ -16,8 +17,8 @@ class NativeElementEntitron extends Entitron<CElementNode> {
 export class CElementNode extends ManifestNode {
   #nodes: XmlNode[] | undefined;
 
-  constructor({ tag, attrs, nodes, text }: XmlNode) {
-    super();
+  constructor({ id, tag, attrs, nodes, text }: XmlNode) {
+    super(id);
     this.tag = tag;
     this.compileAttributes(attrs);
     if (text) {

package/src/registry/fragment.ts

@@ -1,13 +1,14 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { XmlNode } from "ultimus/types";
 import type { IPlatform } from "arrmatura/types";
+import type { XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 
 export class CFragmentNode extends ManifestNode {
   #nodes: XmlNode[] | undefined;
 
-  constructor({ nodes }: XmlNode) {
-    super();
+  constructor({ id, nodes }: XmlNode) {
+    super(id);
     this.#nodes = nodes;
   }
 
@@ -16,6 +17,6 @@ export class CFragmentNode extends ManifestNode {
   }
 
   get EntitronConstructor() {
-    return Entitron;
+    return Arrmatron;
   }
 }

package/src/registry/index.ts

@@ -1,25 +1,18 @@
-import { CForNode } from "./iterations";
+import { Uid, XmlNode } from "ultimus";
+
+import { IManifestNode } from "../../types";
+
 import { CCompositeNode } from "./composition";
 import { CIfNode } from "./conditionals";
+import { ConnectorNode } from "./connector";
 import { CElementNode } from "./elementary";
-import { CDynamicTagNode } from "./routing";
-import { CSlotNode } from "./slot";
 import { CFragmentNode } from "./fragment";
+import { CForNode } from "./iterations";
+import { CDynamicTagNode } from "./routing";
 import { CSelectorNode } from "./selection";
+import { CSlotNode } from "./slot";
 
-import { Uid, XmlNode } from "ultimus";
-import { IManifestNode } from "../../types";
 
-export const Registry = {
-  CForNode,
-  CIfNode,
-  CDynamicTagNode,
-  CSlotNode,
-  CFragmentNode,
-  CCompositeNode,
-  CSelectorNode,
-  CElementNode,
-};
 
 const cloneNode = (x: XmlNode, eliminateAttr: string): XmlNode => {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -35,28 +28,31 @@ const cloneNode = (x: XmlNode, eliminateAttr: string): XmlNode => {
 
 const __compileManifestNode = (x: XmlNode): IManifestNode => {
   const { tag = 'div', attrs } = x;
-  if (attrs?.["each"]) {
-    return new Registry.CForNode(cloneNode(x, "each"), String(attrs["each"]).trim().split(" "));
+  if (attrs?.["Each"]) {
+    return new CForNode(cloneNode(x, "Each"), String(attrs["Each"]).trim().split(" "));
   }
-  if (attrs?.["if"]) {
-    return new Registry.CIfNode(cloneNode(x, "if"), String(attrs["if"]));
+  if (attrs?.["If"]) {
+    return new CIfNode(cloneNode(x, "If"), String(attrs["If"]));
   }
   if (tag === "div" || tag[0]?.match(/[A-Z0-9]/) == null) {
-    return new Registry.CElementNode(x);
+    return new CElementNode(x);
   }
   if (tag === "Dynamic") {
-    return new Registry.CDynamicTagNode(cloneNode(x, "as"), String(attrs?.as ?? "Error.Dynamic"));
+    return new CDynamicTagNode(cloneNode(x, "As"), String(attrs?.As ?? "Error.Dynamic"));
   }
   if (tag === "Slot") {
-    return new Registry.CSlotNode(x);
+    return new CSlotNode(x);
   }
   if (tag === "Selector") {
-    return new Registry.CSelectorNode(x);
+    return new CSelectorNode(x);
+  }
+  if (tag === "Connector") {
+    return new ConnectorNode(x);
   }
   if (tag === "Fragment" || tag === "Then" || tag === "Else") {
-    return new Registry.CFragmentNode(x);
+    return new CFragmentNode(x);
   }
-  return new Registry.CCompositeNode(x);
+  return new CCompositeNode(x);
 };
 
 const CTXNODES = new Map();

package/src/registry/iterations.ts

@@ -1,9 +1,12 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { Datum, Delta, Hash, Uid, XmlNode } from "ultimus/types";
 import type { EContent, IManifestNode, IPlatform } from "arrmatura/types";
+import { mapEntries } from "ultimus";
+import type { Datum, Delta, Hash, Uid, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 import { compilePlaceholder } from "../utils/compileExpression";
 
+
 const narrowData = (data: any) => {
   if (!data) {
     return [];
@@ -11,11 +14,11 @@ const narrowData = (data: any) => {
   if (Array.isArray(data)) return data;
   if (typeof data[Symbol.iterator] === 'function') return [...data];
   if (typeof data === "string") return data.split(',').map(id => ({ id, name: id }));
-  if (typeof data === "object") return Object.values(data);
+  if (typeof data === "object") return mapEntries(data, (key, value) => ({ ...value, id: key }));
   return [{ id: String(data), name: String(data) }];
 }
 
-class Iterative extends Entitron<CForNode> {
+class Iterative extends Arrmatron<CForNode> {
   pkHash: Hash<Datum> = {};
 
   get displayName(): string {
@@ -23,30 +26,36 @@ class Iterative extends Entitron<CForNode> {
   }
 
   get contentManifests() {
-    const each: any = narrowData(this.component.each);
+    const each: any = narrowData(this.$component.each);
     const itemNode = this.manifest.getItemCtxNode(this.platform);
     const nodes: Map<Uid, IManifestNode> = new Map();
     this.pkHash = {};
     if (each?.length) {
       if (!each.forEach) {
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+         
         throw new Error(`[each] Items has no forEach() ${each.toString()}`);
       }
-      each.forEach((datum: Datum, index: number) => {
+      each.forEach((_datum: Datum, index: number) => {
+        const datum = typeof _datum === "string" ? { id: _datum } : _datum;
         let id = datum.id;
+
         if (id == null) {
           this.logError("ERROR: empty item id: ", datum);
           id = String(index);
         }
+
         const pk = String(id);
         if (this.pkHash[pk]) {
           this.logError(`ERROR: duplicate item id : ${pk} (skipped)`, datum);
           return;
         }
+
         this.pkHash[pk] = datum;
+
         const inode = itemNode
           .cloneWithDatum(datum, this.platform)
           .addPropertyResolver(() => this.pkHash[pk], itemNode.itemName);
+
         nodes.set(inode.uid, inode);
       });
     }
@@ -59,9 +68,12 @@ export class CForNode extends ManifestNode {
   #itemName: string;
   #xmlNode: XmlNode;
   constructor(xmlNode: XmlNode, [itemName, prep, expr = prep]: string[]) {
-    super();
+    super(xmlNode.id);
+
     this.#xmlNode = xmlNode;
-    this.#itemName = itemName;
+
+    this.#itemName = itemName.startsWith("@") ? itemName.slice(1) : itemName;
+
     if (expr[0] === "<" && expr[1] === "-") {
       this.addConnector(expr.slice(2), "each");
     } else {
@@ -71,7 +83,7 @@ export class CForNode extends ManifestNode {
 
   getItemCtxNode(platform: IPlatform) {
     return (
-      this.#itemNode ?? (this.#itemNode = new CItemNode(this.#itemName, platform.getCompiledNodes([this.#xmlNode])))
+      this.#itemNode ?? (this.#itemNode = new CItemNode(this.#xmlNode.id, this.#itemName, platform.getCompiledNodes([this.#xmlNode])))
     );
   }
 
@@ -80,8 +92,8 @@ export class CForNode extends ManifestNode {
   }
 }
 
-class IterativeItem extends Entitron<CItemNode> {
-  get recontentScope(): Entitron {
+class IterativeItem extends Arrmatron<CItemNode> {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
@@ -103,17 +115,17 @@ class IterativeItem extends Entitron<CItemNode> {
 
 class CItemNode extends ManifestNode {
   itemName: string;
-  constructor(itemName: string, content?: EContent) {
-    super();
+  constructor(id: string, itemName: string, content?: EContent) {
+    super(id);
     this.itemName = itemName;
     this.$content = content;
   }
 
   cloneWithDatum(datum: Datum, platform: IPlatform) {
     const uid = `${String(this.uid)}#${datum.id}`;
-    return Object.assign(new CItemNode(this.itemName, this.getSubNodes(platform)), {
-      uid,
-    });
+    const c = new CItemNode(uid, this.itemName, this.getSubNodes(platform));
+    c.uid = uid;
+    return c;
   }
 
   get EntitronConstructor() {

package/src/registry/root.ts

@@ -1,16 +1,18 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { Hash, XmlNode } from "ultimus/types";
 import type { EContent, IPlatform } from "arrmatura/types";
 import { xmlParse } from "ultimus";
+import type { Hash, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+
 import { CCompositeNode } from "./composition";
 
-class RootCtx extends Entitron<CCompositeNode> {
+class RootCtx extends Arrmatron<CCompositeNode> {
   get displayName(): string {
     return `ROOT`;
   }
 
-  get recontentScope(): Entitron {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
@@ -28,7 +30,7 @@ export class CRootNode extends ManifestNode {
   nodes?: XmlNode["nodes"];
 
   constructor(private template: string) {
-    super();
+    super('R0');
     this.slotContent = {};
   }
 

package/src/registry/routing.ts

@@ -1,14 +1,15 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
 import type { XmlNode } from "ultimus/types";
 
-class DynamicTag extends Entitron<CDynamicTagNode> {
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+
+class DynamicTag extends Arrmatron<CDynamicTagNode> {
   get displayName(): string {
     return "dynamics";
   }
 
   get contentManifests() {
-    const tag = this.component.tag;
+    const tag = this.$component.tag;
     const uid = `${this.uid}:${String(tag ?? "")}`;
     return new Map([
       [uid, Object.assign(this.platform.getCompiledNodes({ ...this.manifest.xml, tag } as XmlNode), { uid })],
@@ -20,7 +21,7 @@ export class CDynamicTagNode extends ManifestNode {
   xml: XmlNode & { tag: string };
 
   constructor(xml: XmlNode, expr: string) {
-    super();
+    super(xml.id);
     this.compileAttribute("tag", expr);
     this.xml = xml;
   }

package/src/registry/selection.ts

@@ -1,9 +1,10 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
-import type { Hash, XmlNode } from "ultimus/types";
 import type { EContent, IPlatform } from "arrmatura/types";
+import type { Hash, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 
-export class Selector extends Entitron<CSelectorNode> {
+export class Selector extends Arrmatron<CSelectorNode> {
   get displayName(): string {
     return `💠Selector`;
   }
@@ -15,9 +16,10 @@ export class Selector extends Entitron<CSelectorNode> {
    */
   get contentManifests() {
     const cases = this.manifest.getCases(this.platform);
-    const matchedCase = cases?.[this.component.on as string];
+    const onKey = this.$component.On as string;
+    const matchedCase = cases?.[onKey];
     if (!matchedCase) {
-      this.log("unmatched case", this.component.on, cases);
+      this.log("unmatched case", onKey, cases);
     }
     return matchedCase ?? cases?.["default"] ?? Object.values(cases)[0];
   }
@@ -28,8 +30,8 @@ export class CSelectorNode extends ManifestNode {
   key = "";
   nodes?: XmlNode["nodes"];
 
-  constructor({ tag, attrs, nodes }: XmlNode) {
-    super();
+  constructor({ id, tag, attrs, nodes }: XmlNode) {
+    super(id);
     this.tag = tag;
     this.nodes = nodes;
     this.compileAttributes(attrs);
@@ -45,7 +47,7 @@ export class CSelectorNode extends ManifestNode {
     return (
       this.cases ??
       (this.cases = (this.nodes ?? []).reduce<Hash<EContent>>((groups, node) => {
-        groups[node.attrs?.when as string] = platform.getCompiledNodes(node.nodes ?? []);
+        groups[node.attrs?.When as string] = platform.getCompiledNodes(node.nodes ?? []);
         return groups;
       }, {}))
     );