arrmatura 5.2.0 → 6.3.1

package/src/registry/elementary.ts

@@ -0,0 +1,36 @@
+import { ManifestNode } from "../core/ManifestNode";
+import { Entitron } from "../core/Entitron";
+import type { Hash, XmlNode } from "ultimus/types";
+import { IPlatform } from "arrmatura/types";
+
+class NativeElementEntitron extends Entitron<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({ tag, attrs, nodes, text }: XmlNode) {
+    super();
+    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,21 @@
+import { ManifestNode } from "../core/ManifestNode";
+import { Entitron } from "../core/Entitron";
+import type { XmlNode } from "ultimus/types";
+import type { IPlatform } from "arrmatura/types";
+
+export class CFragmentNode extends ManifestNode {
+  #nodes: XmlNode[] | undefined;
+
+  constructor({ nodes }: XmlNode) {
+    super();
+    this.#nodes = nodes;
+  }
+
+  getSubNodes(platform: IPlatform) {
+    return this.#nodes ? platform.getCompiledNodes(this.#nodes) : undefined;
+  }
+
+  get EntitronConstructor() {
+    return Entitron;
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,69 @@
+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";
+
+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
+  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 Registry.CForNode(cloneNode(x, "each"), String(attrs["each"]).trim().split(" "));
+  }
+  if (attrs?.["if"]) {
+    return new Registry.CIfNode(cloneNode(x, "if"), String(attrs["if"]));
+  }
+  if (tag === "div" || tag[0]?.match(/[A-Z0-9]/) == null) {
+    return new Registry.CElementNode(x);
+  }
+  if (tag === "Dynamic") {
+    return new Registry.CDynamicTagNode(cloneNode(x, "as"), String(attrs?.as ?? "Error.Dynamic"));
+  }
+  if (tag === "Slot") {
+    return new Registry.CSlotNode(x);
+  }
+  if (tag === "Selector") {
+    return new Registry.CSelectorNode(x);
+  }
+  if (tag === "Fragment" || tag === "Then" || tag === "Else") {
+    return new Registry.CFragmentNode(x);
+  }
+  return new Registry.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/registry/iterations.ts

@@ -0,0 +1,122 @@
+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 { compilePlaceholder } from "../utils/compileExpression";
+
+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 Object.values(data);
+  return [{ id: String(data), name: String(data) }];
+}
+
+class Iterative extends Entitron<CForNode> {
+  pkHash: Hash<Datum> = {};
+
+  get displayName(): string {
+    return "🔹each";
+  }
+
+  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) => {
+        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 ManifestNode {
+  #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 EntitronConstructor() {
+    return Iterative;
+  }
+}
+
+class IterativeItem extends Entitron<CItemNode> {
+  get recontentScope(): Entitron {
+    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.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 ManifestNode {
+  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.getSubNodes(platform)), {
+      uid,
+    });
+  }
+
+  get EntitronConstructor() {
+    return IterativeItem;
+  }
+}

package/src/registry/root.ts

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

package/src/registry/routing.ts

@@ -0,0 +1,31 @@
+import { ManifestNode } from "../core/ManifestNode";
+import { Entitron } from "../core/Entitron";
+import type { XmlNode } from "ultimus/types";
+
+class DynamicTag extends Entitron<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();
+    this.compileAttribute("tag", expr);
+    this.xml = xml;
+  }
+
+  get EntitronConstructor() {
+    return DynamicTag;
+  }
+}

package/src/registry/selection.ts

@@ -0,0 +1,57 @@
+import { ManifestNode } from "../core/ManifestNode";
+import { Entitron } from "../core/Entitron";
+import type { Hash, XmlNode } from "ultimus/types";
+import type { EContent, IPlatform } from "arrmatura/types";
+
+export class Selector extends Entitron<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 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 ManifestNode {
+  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 EntitronConstructor() {
+    return Selector;
+  }
+}

package/src/registry/slot.ts

@@ -0,0 +1,36 @@
+import { ManifestNode } from "../core/ManifestNode";
+import { Entitron } from "../core/Entitron";
+import type { XmlNode } from "ultimus/types";
+import type { IEntitron } from "arrmatura/types";
+import { Composite } from "./composition";
+
+class Slot extends Entitron {
+  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(): IEntitron {
+    return this.compositeScope.scope;
+  }
+}
+
+export class CSlotNode extends ManifestNode {
+  key?: string;
+
+  constructor(x: XmlNode) {
+    super();
+    this.key = x.attrs?.key as string;
+  }
+
+  get EntitronConstructor() {
+    return Slot;
+  }
+}

package/src/utils/compileExpression.ts

@@ -0,0 +1,108 @@
+import { scalarParse } from "ultimus";
+import type { ExpressionText, Fn, StringHash } from "ultimus/types";
+import type { IEntitron } from "arrmatura/types";
+
+type PipeFn = (c: IEntitron, argValue: unknown) => unknown;
+
+const OP_SHORTCUTS: StringHash = {
+  "&&": "|and:",
+  "==": "|equals:",
+  "!=": "|notEquals:",
+  "||": "|or:",
+  "<": "|less:",
+  "[": "|dot:",
+  "]": "",
+  ">": "|greater:",
+  "??": "|coalesce:",
+  "?": "|then:",
+};
+
+const withNoPipes = (_: unknown, v: unknown) => v;
+
+export function compileConstant(a: string) {
+  const vv = scalarParse(a[0] === "'" ? a.slice(1, a.length - 1) : a);
+  return () => vv;
+}
+
+const compilePropGet = (key: string) => {
+  return (c: IEntitron) => c.getFromScope(key);
+};
+
+const compileArgument = (a: string) => {
+  if (a[0] !== "@") return compileConstant(a);
+
+  if (a.endsWith("#not")) {
+    const getter = compilePropGet(a.slice(1, a.length - 4));
+    return (c: IEntitron) => !getter(c);
+  }
+
+  return compilePropGet(a.slice(1));
+};
+
+const splitExpression = (v: ExpressionText) =>
+  v
+    .replace(/(&&|!=|==|>|<|\[|\]|\|\||\?\??)/g, (_, s) => `${OP_SHORTCUTS[s]}`)
+    .split("|")
+    .map((s) => s.trim());
+
+function withPipes(pipes: string[]) {
+  if (!pipes.length) return withNoPipes;
+
+  const compiledPipes = pipes.map((key) => {
+    const [pipeId, ...args] = key.split(":").map((s) => s.trim());
+    return {
+      pipeId,
+      args: args.map((a) => compileArgument(a)),
+    };
+  });
+
+  return (c: IEntitron, initialValue: unknown) =>
+    compiledPipes.reduce((value, { pipeId, args }) => {
+      try {
+        const fn = c.platform.getFunction(pipeId);
+        if (typeof fn !== "function") {
+          throw new Error(`${fn != null ? "must be a function" : "not found"}`);
+        }
+        const args0 = [value, ...args.map((fn) => fn(c))];
+        return fn.apply(c, args0);
+      } catch (ex) {
+        c.logError(`ERROR: Function ${pipeId || "<empty>"}`, ex);
+        return value;
+      }
+    }, initialValue);
+}
+
+function withHardValue(hardValue: ExpressionText, pipec: PipeFn): PipeFn {
+  if (!hardValue || hardValue === '*') return pipec;
+  const iniFn = hardValue[0] === "@" ? compilePlaceholder(hardValue) : compileConstant(hardValue);
+  return (c: IEntitron) => pipec(c, iniFn(c));
+}
+
+export function compilePipeExpression(v: ExpressionText) {
+  const [_key, ...pipes] = splitExpression(v);
+  const [key, hardValue] = _key.split("=").map((s) => s.trim());
+  return { key, pipec: withHardValue(hardValue, withPipes(pipes)) };
+}
+
+export function compilePlaceholder(expr: string): Fn {
+  const [key, ...pipesExpressions] = splitExpression(expr);
+  const pipec = withPipes(pipesExpressions);
+
+  let fn: any = null;
+
+  if (key[0] === "'") {
+    fn = compileConstant(key);
+  } else {
+    if (key[0] !== "@") {
+      console.warn(`Invalid placeholder: missed @-prefix: "${expr}"`);
+    }
+    fn = compileArgument(key[0] === "@" ? key : `@${key}`);
+  }
+
+  return (c) => pipec(c as IEntitron, fn(c));
+}
+
+export function compileJsExpression(x: string) {
+  return new Function("c", x.replaceAll(/[^'a-z]([a-z][a-z0-9-\.]+)/gi, 'c.prop("$1")'));
+}
+

package/src/utils/stringify.ts

@@ -0,0 +1,33 @@
+import { Hash } from "ultimus";
+const attributesToString = (v?: Hash): string => {
+  if (typeof v === "object") {
+    if (Array.isArray(v)) {
+      return !v.length ? "[]" : `[${attributesToString(v[0]) ?? ""} x${String(v.length)}]`;
+    }
+    return `{${Object.keys(v).toString()}}`;
+  }
+  return v ?? "";
+};
+
+const stringifyState = (attrs?: object | Hash) => {
+  if (!attrs) {
+    return "";
+  }
+
+  const r: string[] = [];
+  Object.entries(attrs).forEach(([k, v]) => {
+    if (v && k[0] !== "$") {
+      r.push(` ${k}="${attributesToString(v)}"`);
+    }
+  });
+
+  return r.length ? r.join("") : "";
+};
+
+export const stringify = (T: any, tab = ""): string => {
+  const { uid, displayName: tag = uid, component: impl, children } = T;
+
+  const ssubs: string = children?.size ? [...children.values()].map((c) => stringify(c, `  ${tab}`)).join("\n") : "";
+
+  return `${tab}<${tag}${stringifyState(impl)}${!ssubs ? "/>" : `>\n${ssubs}\n${tab}</${tag}>`}`;
+};

package/types.ts

@@ -0,0 +1,73 @@
+import { Uid, Delta, Data, LogEntry, Hash, XmlNode } from "ultimus/types";
+
+export type IComponent = {
+  $element?: unknown; // native implementation
+  done?: (c: IEntitron) => void;
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  init?: (c: IEntitron) => Delta | null | undefined | unknown | void;
+  stateChanged?: (changes: Map<string, unknown>) => void;
+  [key: string]: unknown;
+}
+
+export type IEntitron = {
+  isDone: any;
+  readonly uid: Uid;
+  parent?: IEntitron;
+  children?: Map<Uid, IEntitron>;
+  scope?: IEntitron;
+  component: IComponent;
+  root: IEntitron;
+  platform: IPlatform;
+
+  up: (d: Delta | null | void | unknown, force?: boolean) => void;
+  touch: () => void;
+  emit: (key: string, arg1: Delta) => void;
+  res: (key: string | string[]) => Data;
+  log: (val: unknown, ...arg1: unknown[]) => void;
+  logError: (error: unknown, ...arg1: unknown[]) => void;
+  defer: (fn: () => void) => void;
+  get: (propId: string) => unknown;
+
+  done: () => void;
+
+  addReference: (refId: string, r: IEntitron) => void;
+  getByRef: (refId: string) => IEntitron | undefined;
+  getFromScope: (key: string) => unknown;
+  settleAsChild: () => void;
+}
+
+export type IManifestNode = {
+  connectors?: Map<string, (c: IEntitron, x: unknown) => unknown>;
+  refId?: string;
+  readonly uid: Uid;
+  getSubNodes(platform: IPlatform): Map<Uid, IManifestNode> | undefined;
+  resolveProps: (c: IEntitron) => Delta | Promise<unknown> | undefined;
+  resolveInitialProps: (c: IEntitron) => Hash;
+
+  createEntitron: (platform: IPlatform, parent?: IEntitron, scope?: IEntitron) => IEntitron;
+}
+
+export type IPlatform = {
+  log(arg0: LogEntry): void;
+  getCompiledNodes(tag: string): Map<Uid, IManifestNode>;
+  getCompiledNodes(tag: XmlNode): IManifestNode;
+  getCompiledNodes(tag: XmlNode[]): Map<Uid, IManifestNode>;
+  getResource(key: string | string[]): Data;
+  getFunction(id: string): (...args: unknown[]) => unknown;
+  redraw(source: IEntitron, root: IEntitron): void;
+  createComponent(def: IComponentDescriptor | string, initials: Hash, ctx: IEntitron): IComponent | Hash;
+}
+
+export type ComponentConstructor = new (initials: Hash, c: IEntitron) => IComponent;
+
+export type IComponentDescriptor = {
+  tag?: string;
+  template?: string;
+  Ctor?: ComponentConstructor;
+  unknown?: boolean;
+  native?: boolean;
+}
+
+export type EclecticTypeInfo = string | IComponentDescriptor | ComponentConstructor;
+
+export type EContent = Map<Uid, IManifestNode>;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Alex Litskevich
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.