arrmatura 5.0.6 → 6.2.1

package/index.ts

@@ -0,0 +1,20 @@
+import { ICtx, IPlatform } from "arrmatura-api/types";
+import { CRootNode } from "./src/core/root";
+
+export { Registry } from "./src/core";
+export { CRootNode } from "./src/core/root";
+
+/**
+ * Launches the runtime with given top-level template on the specified platform.
+ *
+ * @param {IPlatform} platform - The platform on which to launch the template.
+ * @param {string} template - The template to launch with.
+ * @return {ICtx} The root context object.
+ */
+export const launch = (platform: IPlatform, template: string): ICtx => {
+  const root = new CRootNode(template).createContext(platform);
+
+  root.up({}, true);
+
+  return root;
+};

package/package.json

@@ -1,48 +1,19 @@
 {
   "name": "arrmatura",
-  "version": "5.0.6",
-  "description": "framework",
-  "scripts": {
-    "start": "npx webpack-dev-server --hot --contentBase docs",
-    "build": "npx webpack-cli --mode production && cp -fv docs/quiz.js public",
-    "deploy:host": "firebase use ${NODE_ENV:-default} && firebase deploy --only hosting",
-    "release": "npx webpack-cli && npm publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/alitskevich/arrmatura.git"
-  },
-  "author": "alitskevich",
-  "license": "MIT",
-  "main": "docs/index.js",
+  "version": "6.2.1",
+  "description": "Arrmatura runtime engine",
+  "author": "alitskevich@gmail.com",
+  "license": "ISC",
+  "type": "module",
+  "main": "index.ts",
   "files": [
-    "lib",
-    "core",
-    "core-web",
-    "commons",
-    "declarations.d"
+    "src/**/*"
   ],
-  "devDependencies": {
-    "@babel/cli": "^7.12.1",
-    "@babel/core": "^7.12.3",
-    "@babel/preset-env": "^7.12.1",
-    "babel-loader": "^8.2.1",
-    "babel-plugin-module-resolver": "^4.1.0",
-    "eslint": "^7.30.0",
-    "@typescript-eslint/eslint-plugin": "^2.27.0",
-    "@typescript-eslint/parser": "^2.27.0",
-    "eslint-config-airbnb": "^18.2.1",
-    "eslint-plugin-jest": "^23.18.0",
-    "eslint-plugin-react": "^7.20.3",
-    "eslint-plugin-react-hooks": "^4.0.5",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "metro-react-native-babel-preset": "^0.66.2",
-    "raw-loader": "^4.0.2",
-    "typescript": "^4.4.4",
-    "webpack": "^4.44.2",
-    "webpack-cli": "^3.3.12",
-    "webpack-dev-server": "^3.11.0"
+  "dependencies": {
+    "arrmatura-api": "1.0.2",
+    "ultimus": "2.1.4"
+  },
+  "scripts": {
+    "pnpm:publish": "pnpm publish --no-git-checks"
   }
-}
+}

package/src/core/composition.ts

@@ -0,0 +1,71 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { Hash, XmlNode } from "ultimus/types";
+import type { EContent, ICtxNode, IPlatform } from "arrmatura-api/types";
+
+export class Composite extends Ctx<CCompositeNode> {
+  get displayName(): string {
+    return `💠${this.node.tag}`;
+  }
+
+  get recontentScope(): Ctx {
+    return this;
+  }
+
+  slotContent(slotId?: string): EContent | undefined {
+    return this.node.getSlotContent(this.platform, slotId);
+  }
+
+  createComponent(initials: Hash) {
+    return this.platform.createComponent(this.node.tag, initials, this);
+  }
+}
+
+export class CCompositeNode extends CtxNode {
+  slotContent: Hash<EContent> | null = null;
+  tag: string;
+  nodes?: XmlNode["nodes"];
+  #content: Map<string, ICtxNode>;
+
+  constructor({ tag, attrs, nodes }: XmlNode) {
+    super();
+    this.tag = tag;
+    this.nodes = nodes;
+    this.compileAttributes(attrs);
+  }
+
+  getSlotContent(platform: IPlatform, slotId?: string): EContent | undefined {
+    if (!this.slotContent) {
+      const slots = this.nodes?.reduce<Hash<XmlNode[]>>((groups, e) => {
+        let gId = "default";
+        let isContainer = false;
+        if (e.tag.startsWith(`${this.tag}:`)) {
+          gId = e.tag.split(":")[1];
+          isContainer = true;
+        }
+        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;
+        },
+        {}
+      );
+    }
+
+    return this.slotContent[slotId ?? "default"] ?? undefined;
+  }
+
+  getContent(platform: IPlatform) {
+    return this.#content ?? (this.#content = platform.getCompiledNodes(this.tag));
+  }
+
+  get EntityConstructor() {
+    return Composite;
+  }
+}

package/src/core/conditionals.ts

@@ -0,0 +1,80 @@
+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 { XmlNode } from "ultimus/types";
+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;
+  }
+
+  get displayName(): string {
+    return "🔹if";
+  }
+}
+
+export class CIfNode extends CtxNode {
+  #xml: XmlNode;
+  #branches?: { then?: EContent; else?: EContent };
+  constructor(xml: XmlNode, expr: string) {
+    super();
+    this.#xml = xml;
+    this.compileCondition(expr);
+  }
+
+  get EntityConstructor() {
+    return Conditional;
+  }
+
+  getBranches(platform: IPlatform) {
+    if (this.#branches) {
+      return this.#branches;
+    }
+
+    this.#branches = {};
+
+    const { nodes } = this.#xml;
+
+    let $then: XmlNode[] | undefined = [this.#xml];
+    if (nodes?.length) {
+      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;
+        $then = ifThen
+          ? ifThen.nodes
+          : [
+              Object.assign(this.#xml, {
+                nodes: nodes.filter((e) => e !== ifElse),
+              }),
+            ];
+      } else if (ifThen) {
+        $then = ifThen.nodes;
+      }
+    }
+    this.#branches.then = $then ? platform.getCompiledNodes($then) : undefined;
+
+    return this.#branches;
+  }
+
+  compileCondition(expr: string): void {
+    if (expr[0] === "<" && expr[1] === "-") {
+      this.addConnector(expr.slice(2), "condition");
+    } 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"
+      );
+    } else {
+      const resolver = compilePlaceholder(expr);
+      this.addPropertyResolver((c) => !!resolver(c), "condition");
+    }
+  }
+}

package/src/core/elementary.ts

@@ -0,0 +1,40 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { Hash, XmlNode } from "ultimus/types";
+import { IPlatform } from "arrmatura-api/types";
+
+class Element extends Ctx<CElementNode> {
+  get displayName(): string {
+    return this.node.tag;
+  }
+
+  createComponent(initials: Hash) {
+    return this.platform.createComponent(
+      { tag: this.node.tag, native: true },
+      initials,
+      this
+    );
+  }
+}
+
+export class CElementNode extends CtxNode {
+  #nodes: XmlNode[] | undefined;
+
+  constructor({ tag, attrs, nodes, text }: XmlNode) {
+    super();
+    this.tag = tag;
+    this.compileAttributes(attrs);
+    if (text) {
+      this.compileAttribute("#text", text);
+    }
+    this.#nodes = nodes;
+  }
+
+  getContent(platform: IPlatform) {
+    return this.#nodes ? platform.getCompiledNodes(this.#nodes) : undefined;
+  }
+
+  get EntityConstructor() {
+    return Element;
+  }
+}

package/src/core/fragment.ts

@@ -0,0 +1,21 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { XmlNode } from "ultimus/types";
+import type { IPlatform } from "arrmatura-api/types";
+
+export class CFragmentNode extends CtxNode {
+  #nodes: XmlNode[] | undefined;
+
+  constructor({ nodes }: XmlNode) {
+    super();
+    this.#nodes = nodes;
+  }
+
+  getContent(platform: IPlatform) {
+    return this.#nodes ? platform.getCompiledNodes(this.#nodes) : undefined;
+  }
+
+  get EntityConstructor() {
+    return Ctx;
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,19 @@
+import { CForNode } from "./iterations";
+import { CCompositeNode } from "./composition";
+import { CIfNode } from "./conditionals";
+import { CElementNode } from "./elementary";
+import { CDynamicTagNode } from "./routing";
+import { CSlotNode } from "./slot";
+import { CFragmentNode } from "./fragment";
+import { CSelectorNode } from "./selection";
+
+export const Registry = {
+  CForNode,
+  CIfNode,
+  CDynamicTagNode,
+  CSlotNode,
+  CFragmentNode,
+  CCompositeNode,
+  CSelectorNode,
+  CElementNode,
+};

package/src/core/iterations.ts

@@ -0,0 +1,121 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { Datum, Delta, Hash, Uid, XmlNode } from "ultimus/types";
+import type { EContent, ICtxNode, IPlatform } from "arrmatura-api/types";
+import { compilePlaceholder } from "../utils/compileExpression";
+
+class Iterative extends Ctx<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();
+    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) => {
+        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);
+      });
+    }
+    return nodes;
+  }
+}
+
+export class CForNode extends CtxNode {
+  #itemNode?: CItemNode;
+  #itemName: string;
+  #xmlNode: XmlNode;
+  constructor(xmlNode: XmlNode, [itemName, prep, expr = prep]: string[]) {
+    super();
+    this.#xmlNode = xmlNode;
+    this.#itemName = itemName;
+    if (expr[0] === "<" && expr[1] === "-") {
+      this.addConnector(expr.slice(2), "each");
+    } else {
+      this.addPropertyResolver(compilePlaceholder(expr), "each");
+    }
+  }
+
+  getItemCtxNode(platform: IPlatform) {
+    return (
+      this.#itemNode ??
+      (this.#itemNode = new CItemNode(
+        this.#itemName,
+        platform.getCompiledNodes([this.#xmlNode])
+      ))
+    );
+  }
+
+  get EntityConstructor() {
+    return Iterative;
+  }
+}
+
+class IterativeItem extends Ctx<CItemNode> {
+  get recontentScope(): Ctx {
+    return this;
+  }
+
+  get displayName(): string {
+    return "🔹ui:for:item";
+  }
+
+  emit(key: string, data: Delta) {
+    return this.scope.emit(key, data);
+  }
+
+  get(propId: string) {
+    const iName: string = this.node.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 {
+  itemName: string;
+  constructor(itemName: string, content?: EContent) {
+    super();
+    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,
+      }
+    );
+  }
+
+  get EntityConstructor() {
+    return IterativeItem;
+  }
+}

package/src/core/root.ts

@@ -0,0 +1,46 @@
+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 { xmlParse } from "ultimus";
+import { CCompositeNode } from "./composition";
+
+class RootCtx extends Ctx<CCompositeNode> {
+  get displayName(): string {
+    return `ROOT`;
+  }
+
+  get recontentScope(): Ctx {
+    return this;
+  }
+
+  slotContent(_slotId?: string): EContent | undefined {
+    return undefined;
+  }
+
+  createComponent(initials: Hash) {
+    return this.platform.createComponent({}, initials, this);
+  }
+}
+
+export class CRootNode extends CtxNode {
+  slotContent: Hash<EContent>;
+  nodes?: XmlNode["nodes"];
+
+  constructor(private template: string) {
+    super();
+    this.slotContent = {};
+  }
+
+  getContent(platform: IPlatform) {
+    return platform.getCompiledNodes(xmlParse(this.template));
+  }
+
+  getSlotContent(_platform: IPlatform, _slotId?: string) {
+    return undefined;
+  }
+
+  get EntityConstructor() {
+    return RootCtx;
+  }
+}

package/src/core/routing.ts

@@ -0,0 +1,37 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { XmlNode } from "ultimus/types";
+
+class DynamicTag extends Ctx<CDynamicTagNode> {
+  get displayName(): string {
+    return "dynamics";
+  }
+
+  get content() {
+    const tag = this.component.tag;
+    const uid = `${this.uid}:${String(tag ?? "")}`;
+    return new Map([
+      [
+        uid,
+        Object.assign(
+          this.platform.getCompiledNodes({ ...this.node.xml, tag } as XmlNode),
+          { uid }
+        ),
+      ],
+    ]);
+  }
+}
+
+export class CDynamicTagNode extends CtxNode {
+  xml: XmlNode & { tag: string };
+
+  constructor(xml: XmlNode, expr: string) {
+    super();
+    this.compileAttribute("tag", expr);
+    this.xml = xml;
+  }
+
+  get EntityConstructor() {
+    return DynamicTag;
+  }
+}

package/src/core/selection.ts

@@ -0,0 +1,57 @@
+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";
+
+export class Selector extends Ctx<CSelectorNode> {
+  get displayName(): string {
+    return `💠Selector`;
+  }
+
+  /**
+   * Gets the content of the function.
+   *
+   * @return {any} The content of the function.
+   */
+  get content() {
+    const cases = this.node.getCases(this.platform);
+    const matchedCase = cases?.[this.component.on as string];
+    if (!matchedCase) {
+      this.log('unmatched case', this.component.on, cases);
+    }
+    return matchedCase ?? cases?.['default'] ?? Object.values(cases)[0];
+  }
+}
+
+export class CSelectorNode extends CtxNode {
+  cases: Hash<EContent> | null = null;
+  key = '';
+  nodes?: XmlNode["nodes"];
+
+  constructor({ tag, attrs, nodes }: XmlNode) {
+    super();
+    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 EntityConstructor() {
+    return Selector;
+  }
+}

package/src/core/slot.ts

@@ -0,0 +1,36 @@
+import { CtxNode } from "../ctx/CtxNode";
+import { Ctx } from "../ctx/Ctx";
+import type { XmlNode } from "ultimus/types";
+import type { ICtx } from "arrmatura-api/types";
+import { Composite } from "./composition";
+
+class Slot extends Ctx {
+  get displayName(): string {
+    return "🔸";
+  }
+
+  get compositeScope(): Composite {
+    return this.scope as Composite;
+  }
+
+  get content() {
+    return this.compositeScope.slotContent((this.node as CSlotNode).key);
+  }
+
+  get recontentScope(): ICtx {
+    return this.compositeScope.scope;
+  }
+}
+
+export class CSlotNode extends CtxNode {
+  key?: string;
+
+  constructor(x: XmlNode) {
+    super();
+    this.key = x.attrs?.key as string;
+  }
+
+  get EntityConstructor() {
+    return Slot;
+  }
+}