arrmatura 6.2.1 → 6.3.2

package/src/{core → registry}/composition.ts

@@ -1,34 +1,35 @@
-import { CtxNode } from "../ctx/CtxNode";
-import { Ctx } from "../ctx/Ctx";
+import type { EContent, IManifestNode, IPlatform } from "arrmatura/types";
 import type { Hash, XmlNode } from "ultimus/types";
-import type { EContent, ICtxNode, IPlatform } from "arrmatura-api/types";
 
-export class Composite extends Ctx<CCompositeNode> {
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+
+export class Composite extends Arrmatron<CCompositeNode> {
   get displayName(): string {
-    return `💠${this.node.tag}`;
+    return `💠${this.manifest.tag}`;
   }
 
-  get recontentScope(): Ctx {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
   slotContent(slotId?: string): EContent | undefined {
-    return this.node.getSlotContent(this.platform, slotId);
+    return this.manifest.getSlotContent(this.platform, slotId);
   }
 
   createComponent(initials: Hash) {
-    return this.platform.createComponent(this.node.tag, initials, this);
+    return this.platform.createComponent(this.manifest.tag, initials, this);
   }
 }
 
-export class CCompositeNode extends CtxNode {
+export class CCompositeNode extends ManifestNode {
   slotContent: Hash<EContent> | null = null;
   tag: string;
   nodes?: XmlNode["nodes"];
-  #content: Map<string, ICtxNode>;
+  #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);
@@ -43,29 +44,24 @@ export class CCompositeNode extends CtxNode {
           gId = e.tag.split(":")[1];
           isContainer = true;
         }
-        groups[gId] = (groups[gId] || []).concat(
-          isContainer ? e.nodes ?? [] : e
-        );
+        groups[gId] = (groups[gId] || []).concat(isContainer ? e.nodes ?? [] : e);
         return groups;
       }, {});
 
-      this.slotContent = Object.entries(slots ?? {}).reduce<Hash<EContent>>(
-        (groups, [gId, nodes]) => {
-          groups[gId] = platform.getCompiledNodes(nodes);
-          return groups;
-        },
-        {}
-      );
+      this.slotContent = Object.entries(slots ?? {}).reduce<Hash<EContent>>((groups, [gId, nodes]) => {
+        groups[gId] = platform.getCompiledNodes(nodes);
+        return groups;
+      }, {});
     }
 
-    return this.slotContent[slotId ?? "default"] ?? undefined;
+    return this.slotContent[slotId || "default"] ?? undefined;
   }
 
-  getContent(platform: IPlatform) {
+  getSubNodes(platform: IPlatform) {
     return this.#content ?? (this.#content = platform.getCompiledNodes(this.tag));
   }
 
-  get EntityConstructor() {
+  get EntitronConstructor() {
     return Composite;
   }
 }

package/src/{core → registry}/conditionals.ts

@@ -1,14 +1,16 @@
-import { CtxNode } from "../ctx/CtxNode";
-import { Composite } from "./composition";
-import { Ctx } from "../ctx/Ctx";
-import type { EContent, ICtx, IPlatform } from "arrmatura-api/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 Ctx<CIfNode> {
-  get content() {
-    const branches = this.node.getBranches(this.platform);
-    return this.component.condition ? branches.then : branches.else;
+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;
   }
 
   get displayName(): string {
@@ -16,16 +18,16 @@ class Conditional extends Ctx<CIfNode> {
   }
 }
 
-export class CIfNode extends CtxNode {
+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);
   }
 
-  get EntityConstructor() {
+  get EntitronConstructor() {
     return Conditional;
   }
 
@@ -43,16 +45,14 @@ export class CIfNode extends CtxNode {
       const ifElse = nodes.find((e) => e.tag === "Else");
       const ifThen = nodes.find((e) => e.tag === "Then");
       if (ifElse) {
-        this.#branches.else = ifElse.nodes
-          ? platform.getCompiledNodes(ifElse.nodes)
-          : undefined;
+        this.#branches.else = ifElse.nodes ? platform.getCompiledNodes(ifElse.nodes) : undefined;
         $then = ifThen
           ? ifThen.nodes
           : [
-              Object.assign(this.#xml, {
-                nodes: nodes.filter((e) => e !== ifElse),
-              }),
-            ];
+            Object.assign(this.#xml, {
+              nodes: nodes.filter((e) => e !== ifElse),
+            }),
+          ];
       } else if (ifThen) {
         $then = ifThen.nodes;
       }
@@ -68,10 +68,7 @@ export class CIfNode extends CtxNode {
     } else if (expr.slice(0, 5) === "slot(") {
       const slotId = expr.slice(5, -1);
       // DO NOT place inside iterations.
-      this.addPropertyResolver(
-        (c: ICtx) => !!(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

@@ -0,0 +1,37 @@
+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 Arrmatron<CElementNode> {
+  get displayName(): string {
+    return this.manifest.tag;
+  }
+
+  createComponent(initials: Hash) {
+    return this.platform.createComponent({ tag: this.manifest.tag, native: true }, initials, this);
+  }
+}
+
+export class CElementNode extends ManifestNode {
+  #nodes: XmlNode[] | undefined;
+
+  constructor({ id, tag, attrs, nodes, text }: XmlNode) {
+    super(id);
+    this.tag = tag;
+    this.compileAttributes(attrs);
+    if (text) {
+      this.compileAttribute("#text", text);
+    }
+    this.#nodes = nodes;
+  }
+
+  getSubNodes(platform: IPlatform) {
+    return this.#nodes ? platform.getCompiledNodes(this.#nodes) : undefined;
+  }
+
+  get EntitronConstructor() {
+    return NativeElementEntitron;
+  }
+}

package/src/registry/fragment.ts

@@ -0,0 +1,22 @@
+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({ id, nodes }: XmlNode) {
+    super(id);
+    this.#nodes = nodes;
+  }
+
+  getSubNodes(platform: IPlatform) {
+    return this.#nodes ? platform.getCompiledNodes(this.#nodes) : undefined;
+  }
+
+  get EntitronConstructor() {
+    return Arrmatron;
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,65 @@
+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 { CFragmentNode } from "./fragment";
+import { CForNode } from "./iterations";
+import { CDynamicTagNode } from "./routing";
+import { CSelectorNode } from "./selection";
+import { CSlotNode } from "./slot";
+
+
+
+const cloneNode = (x: XmlNode, eliminateAttr: string): XmlNode => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { [eliminateAttr]: _, ...attrs } = x.attrs ?? {};
+  return {
+    text: x.text,
+    tag: x.tag,
+    id: x.id,
+    attrs,
+    nodes: x.nodes?.map((n) => n),
+  };
+};
+
+const __compileManifestNode = (x: XmlNode): IManifestNode => {
+  const { tag = 'div', attrs } = x;
+  if (attrs?.["Each"]) {
+    return new CForNode(cloneNode(x, "Each"), String(attrs["Each"]).trim().split(" "));
+  }
+  if (attrs?.["If"]) {
+    return new CIfNode(cloneNode(x, "If"), String(attrs["If"]));
+  }
+  if (tag === "div" || tag[0]?.match(/[A-Z0-9]/) == null) {
+    return new CElementNode(x);
+  }
+  if (tag === "Dynamic") {
+    return new CDynamicTagNode(cloneNode(x, "As"), String(attrs?.As ?? "Error.Dynamic"));
+  }
+  if (tag === "Slot") {
+    return new CSlotNode(x);
+  }
+  if (tag === "Selector") {
+    return new CSelectorNode(x);
+  }
+  if (tag === "Connector") {
+    return new ConnectorNode(x);
+  }
+  if (tag === "Fragment" || tag === "Then" || tag === "Else") {
+    return new CFragmentNode(x);
+  }
+  return new CCompositeNode(x);
+};
+
+const CTXNODES = new Map();
+
+export const compileManifestNode = (x: XmlNode): IManifestNode => {
+  return CTXNODES.has(x) ? CTXNODES.get(x) : CTXNODES.set(x, __compileManifestNode(x)).get(x);
+};
+
+export const compileManifestNodes = (x: XmlNode[]): Map<Uid, IManifestNode> =>
+  new Map<Uid, IManifestNode>(x?.map(compileManifestNode).map((c) => [c.uid, c]) ?? []);

package/src/{core → registry}/iterations.ts

@@ -1,41 +1,61 @@
-import { CtxNode } from "../ctx/CtxNode";
-import { Ctx } from "../ctx/Ctx";
+import type { EContent, IManifestNode, IPlatform } from "arrmatura/types";
+import { mapEntries } from "ultimus";
 import type { Datum, Delta, Hash, Uid, XmlNode } from "ultimus/types";
-import type { EContent, ICtxNode, IPlatform } from "arrmatura-api/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
 import { compilePlaceholder } from "../utils/compileExpression";
 
-class Iterative extends Ctx<CForNode> {
+
+const narrowData = (data: any) => {
+  if (!data) {
+    return [];
+  }
+  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 mapEntries(data, (key, value) => ({ ...value, id: key }));
+  return [{ id: String(data), name: String(data) }];
+}
+
+class Iterative extends Arrmatron<CForNode> {
   pkHash: Hash<Datum> = {};
 
   get displayName(): string {
     return "🔹each";
   }
 
-  get content() {
-    const each: any = this.component.each;
-    const itemNode = this.node.getItemCtxNode(this.platform);
-    const nodes: Map<Uid, ICtxNode> = new Map();
+  get contentManifests() {
+    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);
       });
     }
@@ -43,14 +63,17 @@ class Iterative extends Ctx<CForNode> {
   }
 }
 
-export class CForNode extends CtxNode {
+export class CForNode extends ManifestNode {
   #itemNode?: CItemNode;
   #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 {
@@ -60,21 +83,17 @@ export class CForNode extends CtxNode {
 
   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])))
     );
   }
 
-  get EntityConstructor() {
+  get EntitronConstructor() {
     return Iterative;
   }
 }
 
-class IterativeItem extends Ctx<CItemNode> {
-  get recontentScope(): Ctx {
+class IterativeItem extends Arrmatron<CItemNode> {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
@@ -87,35 +106,29 @@ class IterativeItem extends Ctx<CItemNode> {
   }
 
   get(propId: string) {
-    const iName: string = this.node.itemName;
-    const value =
-      propId.startsWith(`${iName}.`) || propId === iName
-        ? super.get(propId)
-        : this.scope.get(propId);
+    const iName: string = this.manifest.itemName;
+    const value = propId.startsWith(`${iName}.`) || propId === iName ? super.get(propId) : this.scope.get(propId);
     // this.log(propId, value);
     return value;
   }
 }
 
-class CItemNode extends CtxNode {
+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.getContent(platform)),
-      {
-        uid,
-      }
-    );
+    const c = new CItemNode(uid, this.itemName, this.getSubNodes(platform));
+    c.uid = uid;
+    return c;
   }
 
-  get EntityConstructor() {
+  get EntitronConstructor() {
     return IterativeItem;
   }
 }

package/src/{core → registry}/root.ts

@@ -1,16 +1,18 @@
-import { CtxNode } from "../ctx/CtxNode";
-import { Ctx } from "../ctx/Ctx";
-import type { Hash, XmlNode } from "ultimus/types";
-import type { EContent, IPlatform } from "arrmatura-api/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 Ctx<CCompositeNode> {
+class RootCtx extends Arrmatron<CCompositeNode> {
   get displayName(): string {
     return `ROOT`;
   }
 
-  get recontentScope(): Ctx {
+  get recontentScope(): Arrmatron {
     return this;
   }
 
@@ -23,16 +25,16 @@ class RootCtx extends Ctx<CCompositeNode> {
   }
 }
 
-export class CRootNode extends CtxNode {
+export class CRootNode extends ManifestNode {
   slotContent: Hash<EContent>;
   nodes?: XmlNode["nodes"];
 
   constructor(private template: string) {
-    super();
+    super('R0');
     this.slotContent = {};
   }
 
-  getContent(platform: IPlatform) {
+  getSubNodes(platform: IPlatform) {
     return platform.getCompiledNodes(xmlParse(this.template));
   }
 
@@ -40,7 +42,7 @@ export class CRootNode extends CtxNode {
     return undefined;
   }
 
-  get EntityConstructor() {
+  get EntitronConstructor() {
     return RootCtx;
   }
 }

package/src/registry/routing.ts

@@ -0,0 +1,32 @@
+import type { XmlNode } from "ultimus/types";
+
+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 uid = `${this.uid}:${String(tag ?? "")}`;
+    return new Map([
+      [uid, Object.assign(this.platform.getCompiledNodes({ ...this.manifest.xml, tag } as XmlNode), { uid })],
+    ]);
+  }
+}
+
+export class CDynamicTagNode extends ManifestNode {
+  xml: XmlNode & { tag: string };
+
+  constructor(xml: XmlNode, expr: string) {
+    super(xml.id);
+    this.compileAttribute("tag", expr);
+    this.xml = xml;
+  }
+
+  get EntitronConstructor() {
+    return DynamicTag;
+  }
+}

package/src/registry/selection.ts

@@ -0,0 +1,59 @@
+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 Arrmatron<CSelectorNode> {
+  get displayName(): string {
+    return `💠Selector`;
+  }
+
+  /**
+   * Gets the content of the function.
+   *
+   * @return {any} The content of the function.
+   */
+  get contentManifests() {
+    const cases = this.manifest.getCases(this.platform);
+    const onKey = this.$component.On as string;
+    const matchedCase = cases?.[onKey];
+    if (!matchedCase) {
+      this.log("unmatched case", onKey, cases);
+    }
+    return matchedCase ?? cases?.["default"] ?? Object.values(cases)[0];
+  }
+}
+
+export class CSelectorNode extends ManifestNode {
+  cases: Hash<EContent> | null = null;
+  key = "";
+  nodes?: XmlNode["nodes"];
+
+  constructor({ id, tag, attrs, nodes }: XmlNode) {
+    super(id);
+    this.tag = tag;
+    this.nodes = nodes;
+    this.compileAttributes(attrs);
+  }
+
+  /**
+   * Retrieves the cases nodes for a component.
+   *
+   * @param {IPlatform} platform - The platform to get cases for.
+   * @return {Hash<EContent>} - The cases for the platform.
+   */
+  getCases(platform: IPlatform): Hash<EContent> {
+    return (
+      this.cases ??
+      (this.cases = (this.nodes ?? []).reduce<Hash<EContent>>((groups, node) => {
+        groups[node.attrs?.When as string] = platform.getCompiledNodes(node.nodes ?? []);
+        return groups;
+      }, {}))
+    );
+  }
+
+  get EntitronConstructor() {
+    return Selector;
+  }
+}

package/src/registry/slot.ts

@@ -0,0 +1,37 @@
+import type { XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+
+import { Composite } from "./composition";
+
+class Slot extends Arrmatron {
+  get displayName(): string {
+    return "🔸";
+  }
+
+  get compositeScope(): Composite {
+    return this.scope as Composite;
+  }
+
+  get contentManifests() {
+    return this.compositeScope.slotContent((this.manifest as CSlotNode).key);
+  }
+
+  get recontentScope(): Arrmatron {
+    return this.compositeScope.scope;
+  }
+}
+
+export class CSlotNode extends ManifestNode {
+  key?: string;
+
+  constructor(x: XmlNode) {
+    super(x.id);
+    this.key = x.attrs?.Key as string;
+  }
+
+  get EntitronConstructor() {
+    return Slot;
+  }
+}