arrmatura 6.2.1 → 6.3.2

package/src/utils/FingerprintMashine.ts

@@ -0,0 +1,128 @@
+const CACHE = new Map();
+
+function upnum(r: number, n: number) {
+  const rr = ((r << 5) - r) + n;
+  return rr & rr;
+}
+
+const COLON_NUM = ":".charCodeAt(0);
+
+function stringHash(x: string) {
+  let h = 0;
+  if (CACHE.has(x)) {
+    h = CACHE.get(x) as number;
+  } else {
+    for (let i = 0; i < x.length; i++) {
+      h = upnum(h, x.charCodeAt(i));
+    }
+    CACHE.set(x, h);
+  }
+  return h;
+}
+
+export class FingerprintMashine {
+  r = 0;
+  x?: any;
+  $path?: Set<unknown>;
+
+  get path() {
+    return this.$path ?? (this.$path = new Set());
+  }
+
+  upNumber(n: number) {
+    return (this.r = upnum(this.r, n));
+  }
+
+  upString(x: string) {
+    return this.upNumber(stringHash(x))
+  }
+
+  upObject(x) {
+
+    if (x.$hash) return x.$hash;
+
+    if (x instanceof Date) return this.upNumber(x.getTime());
+
+    if (this.path.size > 10 || this.path.has(x)) {
+      return;
+    }
+
+    this.path.add(x);
+
+    if (x instanceof Map) {
+      this.upString("$$$Map$$$");
+      x.forEach((v, k) => {
+        this.upString(k);
+        this.upNumber(COLON_NUM);
+        this.upAny(v);
+      })
+    } else if (x instanceof Set) {
+      this.upString("$$$Set$$$");
+      x.forEach((v) => this.upAny(v))
+    } else if (Array.isArray(x)) {
+      this.upString("$$$Array$$$");
+      x.forEach((v) => this.upAny(v))
+    } else {
+      this.upString("$$$Object$$$");
+      for (const k in x) {
+        if (Object.prototype.hasOwnProperty.call(x, k) && k[0] !== '$') {
+          this.upString(k)
+          this.upNumber(COLON_NUM);
+          this.upAny(x[k]);
+        }
+      }
+    }
+
+    this.path.delete(x);
+
+    return this.r;
+  }
+  upAny(x: any): void {
+
+    if (x == null) {
+      this.upString(String(x));
+    } else if (typeof x === 'number') {
+      if (isNaN(x)) {
+        this.upString(`$$$NaN$$$`);
+      } else {
+        this.upNumber(x);
+      }
+    } else if (typeof x === 'object') {
+      this.upObject(x);
+    } else if (typeof x === 'string') {
+      this.upString(x);
+    } else if (typeof x === 'boolean') {
+      this.upString(`$$$Boolean$$$${x}`);
+    } else if (typeof x === 'function') {
+      // this.upString(`$$$Function$$$${x}`);
+    } else {
+      this.upString(String(x))
+    }
+  }
+
+  do(x: any) {
+
+    if (x == null) return x;
+
+    if (typeof x !== "object") return x;
+
+    if (Object.isFrozen(x)) return x;
+
+    if (x.$hash) return x.$hash;
+
+    this.r = 0;
+    this.x = x;
+    if (this.$path) {
+      this.$path?.clear();
+    }
+
+    this.upObject(x);
+
+    return this.r;
+  }
+
+}
+
+const FM = new FingerprintMashine();
+
+export const objectFingerprint = (x: any) => FM.do(x)

package/src/utils/applyStateChangedToImpl.ts

@@ -0,0 +1,18 @@
+import { capitalize } from "ultimus";
+
+import type { IComponent } from "../../types";
+
+export function applyStateChangedToImpl(changes: Map<string, unknown>, impl: IComponent) {
+  if (impl.__stateChanged) {
+    impl.__stateChanged(changes);
+  } else {
+    changes.forEach((v, k) => {
+      const setter = impl[`set${capitalize(k)}`];
+      if (typeof setter === "function") {
+        setter.call(impl, v);
+      } else {
+        impl[k] = v;
+      }
+    });
+  }
+}

package/src/utils/compileExpression.ts

@@ -1,9 +1,88 @@
-import { scalarParse } from "ultimus";
-import type { Expression, Fn, StringHash } from "ultimus/types";
-import type { ICtx } from "arrmatura-api/types";
-import { createStringInterpolator } from "ultimus/src/parsing/createStringInterpolator";
+import type { IArrmatron } from "arrmatura/types";
+import { scalarParse, gettus } from "ultimus";
+import type { ExpressionText, Fn, StringHash } from "ultimus/types";
+
+type PipeFn = (c: IArrmatron, argValue: unknown) => unknown;
+
+// function tokenize(expression) {
+//   return expression.split(/[\(\)\<\>=\?!:']+/g);
+// }
+// class Node {
+//   constructor(public type, public value: string | null = null, public left = null, public right = null) {
+//   }
+// }
+
+// function parse(tokens) {
+//   let current = 0;
+
+//   function walk(priority = 0) {
+//     const token = tokens[current++];
+//     const nextToken = tokens[current];
+
+//     if (priority >= 0 && token === '(') {
+//       const node = walk();
+//       current++;
+//       return node;
+//     }
+
+//     if (priority >= 0 && ['>', '<', '==', '!=', '&&', '||', '??'].includes(nextToken)) {
+//       return new Node('binary', nextToken, walk(), walk());
+//     }
+
+//     if (priority >= 0 && ['>', '<', '==', '!=', '&&', '||', '??'].includes(nextToken)) {
+//       return new Node('binary', nextToken, walk(), walk());
+//     }
+
+//     if (priority >= 0 && ['>', '<', '==', '!=', '&&', '||', '??'].includes(nextToken)) {
+//       return new Node('binary', nextToken, walk(), walk());
+//     }
+
+//     if (priority >= 0 && nextToken === '?') {
+//       const node = new Node('coalesce', walk());
+//       if (tokens[current] !== ':') {
+//         throw new TypeError('Expected colon after "?" in coalesce operation');
+//       }
+//       current++;
+//       node.right = new Node('colon', token, walk(), walk());
+//       return node;
+//     }
+//     return new Node('operand', (token));;
+//   }
+
+//   return walk();
+// }
+
+// function evaluate(node) {
+//   switch (node.type) {
+//     case 'number':
+//       return node.value;
+//     case 'operator':
+//       switch (node.value) {
+//         case '>':
+//           return evaluate(node.left) > evaluate(node.right);
+//         case '<':
+//           return evaluate(node.left) < evaluate(node.right);
+//         case '==':
+//           return evaluate(node.left) == evaluate(node.right);
+//         case '!=':
+//           return evaluate(node.left) != evaluate(node.right);
+//         default:
+//           throw new TypeError(`Unknown operator: ${node.value}`);
+//       }
+//     case 'coalesce':
+//       const condition = evaluate(node.left);
+//       return condition ? evaluate(node.middle) : evaluate(node.right);
+//     default:
+//       throw new TypeError(`Unknown node type: ${node.type}`);
+//   }
+// }
+
+// // Example usage
+// const expression = '1 < 2 ? 3 : 4';
+// const tokens = tokenize(expression);
+// const ast = parse(tokens);
+// console.log(evaluate(ast)); // Outputs: 3
 
-type PipeFn = (c: ICtx, argValue: unknown) => unknown;
 
 const OP_SHORTCUTS: StringHash = {
   "&&": "|and:",
@@ -20,27 +99,34 @@ const OP_SHORTCUTS: StringHash = {
 
 const withNoPipes = (_: unknown, v: unknown) => v;
 
-function compileConstant(a: string) {
+const isConstKey = (key: string) => "'+-0123456789".includes(key[0]) || key === 'true' || key === 'false';
+
+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: ICtx) => c.getFromScope(key);
+  return (c: IArrmatron) => c.getFromScope(key);
 };
 
-const compileArgument = (a: string) => {
-  if (a[0] !== "@") return compileConstant(a);
+const compileArgument = (a: string, strings?: string[]) => {
+  if (a[0] === "!") {
+    const getter = compilePropGet(a.slice(1));
+    return (c: IArrmatron) => !getter(c);
+  };
 
-  if (a.endsWith("#not")) {
-    const getter = compilePropGet(a.slice(1, a.length - 4));
-    return (c: ICtx) => !getter(c);
+  if (a[0] === "#" && a[1] === "#") {
+    const vv = strings?.[Number(a.slice(2))];
+    return () => vv;
   }
 
-  return compilePropGet(a.slice(1));
+  if (isConstKey(a)) return compileConstant(a);
+
+  return compilePropGet(a);
 };
 
-const splitExpression = (v: Expression) =>
+const splitExpression = (v: ExpressionText) =>
   v
     .replace(/(&&|!=|==|>|<|\[|\]|\|\||\?\??)/g, (_, s) => `${OP_SHORTCUTS[s]}`)
     .split("|")
@@ -50,22 +136,37 @@ function withPipes(pipes: string[]) {
   if (!pipes.length) return withNoPipes;
 
   const compiledPipes = pipes.map((key) => {
-    const [pipeId, ...args] = key.split(":").map((s) => s.trim());
+    const strings: string[] = [];
+
+    const expr = key.replaceAll(/'[^']*'/g, (s) => {
+      strings.push(s.slice(1, -1))
+      return `##${strings.length - 1}`
+    });
+
+    const [pipeId, ...args] = expr.split(":").map((s) => s.trim());
     return {
       pipeId,
-      args: args.map((a) => compileArgument(a)),
+      args: args.map((a) => compileArgument(a, strings)),
     };
   });
 
-  return (c: ICtx, initialValue: unknown) =>
+  return (c: IArrmatron, 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);
+        if (value instanceof Promise) {
+          return value.then((val) => {
+            const args0 = [val, ...args.map((fn) => fn(c))];
+            const result = fn.apply(c, args0);
+            return result;
+          });
+        } else {
+          const args0 = [value, ...args.map((fn) => fn(c))];
+          return fn.apply(c, args0);
+        }
       } catch (ex) {
         c.logError(`ERROR: Function ${pipeId || "<empty>"}`, ex);
         return value;
@@ -73,54 +174,42 @@ function withPipes(pipes: string[]) {
     }, initialValue);
 }
 
-function withHardValue(hardValue: Expression, pipec: PipeFn): PipeFn {
-  if (hardValue === undefined) return pipec;
-  const iniFn =
-    hardValue[0] === "@"
-      ? compilePlaceholder(hardValue)
-      : compileConstant(hardValue);
-  return (c: ICtx) => pipec(c, iniFn(c));
+function withHardValue(hardValue: ExpressionText, pipec: PipeFn): PipeFn {
+  if (!hardValue || hardValue === '*') return pipec;
+
+  if (hardValue.startsWith('*.')) {
+    const propKey = hardValue.slice(2)
+    return (c: IArrmatron, ini: any) => pipec(c, gettus(ini, propKey));
+  }
+
+  const iniFn = isConstKey(hardValue) ? compileConstant(hardValue) : compilePlaceholder(hardValue);
+
+  return (c: IArrmatron) => pipec(c, iniFn(c));
 }
 
-export function compilePipeExpression(v: Expression) {
+export function compilePipeExpression(v: ExpressionText) {
+  if (v.endsWith(')')) {
+    const parts = v.slice(0, -1).split('(')
+    return compilePipeExpression(`${parts[0]}=${parts[1]}`);
+  }
+
   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;
+  const pipec = withPipes(pipesExpressions);
 
-  if (key[0] === "'") {
-    fn = compileConstant(key);
-  } else {
-    if (key[0] !== "@") {
-      console.warn(`Invalid placeholder "${expr}"`);
-    }
-    fn = compileArgument(key[0] === "@" ? key : `@${key}`);
-  }
+  const fn = compileArgument(key);
 
-  return (c) => pipec(c as ICtx, fn(c));
+  return (c) => pipec(c as IArrmatron, fn(c));
 }
 
-const JS = {}
 export function compileJsExpression(x: string) {
-  return JS[x] ?? (JS[x] = new Function('c', x.replaceAll(/[^'a-z]([a-z][a-z0-9-\.]+)/ig, 'c.prop("$1")')))
+  return new Function("c", x.replaceAll(/[^'a-z]([a-z][a-z0-9-.]+)/gi, 'c.prop("$1")'));
 }
 
-export 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);
-
-  return compileConstant(v);
-}

package/src/utils/objectFingerprint.spec.ts

@@ -0,0 +1,70 @@
+import { objectFingerprint } from './FingerprintMashine';
+
+describe('objectFingerprint', () => {
+  it('should return 0 for null or undefined input', () => {
+    expect(objectFingerprint(null)).toBe(null);
+    expect(objectFingerprint(undefined)).toBe(undefined);
+    expect(objectFingerprint(0)).toBe(0);
+    expect(objectFingerprint("")).toBe("");
+  });
+
+  it('should return the same hash value for the same input string, regardless of the case of its characters', () => {
+    const str1 = 'Hello World';
+    const str2 = 'Hello World';
+    const str3 = 'Hello world';
+    expect(objectFingerprint(str1)).toBe(objectFingerprint(str2));
+    expect(objectFingerprint(str1)).not.toBe(objectFingerprint(str3));
+  });
+
+  it('should return a unique hash value for different input objects', () => {
+    const obj1 = { foo: 'bar' };
+    const obj2 = { bar: 'baz' };
+    expect(objectFingerprint(obj1)).not.toBe(objectFingerprint(obj2));
+  });
+
+  it('should return the same hash value for the same input object, regardless of the order of its properties', () => {
+    const obj0 = { foo: 'bar', baz: 'qux' };
+    const obj1 = { foo: 'bar', baz: 'qux' };
+    const obj2 = { baz: 'qux', foo: 'bar' };
+    expect(objectFingerprint(obj1)).toBe(objectFingerprint(obj0));
+    expect(objectFingerprint(obj1)).not.toBe(objectFingerprint(obj2));
+  });
+
+  it('should return the same hash value for the same input array, regardless of the order of its elements', () => {
+    const arr0 = [1, 2, 3];
+    const arr1 = [1, 2, 3];
+    const arr2 = [3, 2, 1];
+    expect(objectFingerprint(arr1)).toBe(objectFingerprint(arr0));
+    expect(objectFingerprint(arr1)).not.toBe(objectFingerprint(arr2));
+  });
+
+  it('should return the same hash value for the same input map, regardless of the order of its entries', () => {
+    const map0 = new Map([[1, 'one'], [2, 'two']]);
+    const map1 = new Map([[1, 'one'], [2, 'two']]);
+    const map2 = new Map([[2, 'two'], [1, 'one']]);
+    expect(objectFingerprint(map1)).toBe(objectFingerprint(map0));
+    expect(objectFingerprint(map1)).not.toBe(objectFingerprint(map2));
+  });
+
+  it('should return the same hash value for the same input set, regardless of the order of its elements', () => {
+    const set0 = new Set([1, 2, 3]);
+    const set1 = new Set([1, 2, 3]);
+    const set2 = new Set([3, 2, 1]);
+    expect(objectFingerprint(set1)).toBe(objectFingerprint(set0));
+    expect(objectFingerprint(set1)).not.toBe(objectFingerprint(set2));
+  });
+
+
+  it('should return the same hash value for the same input number, regardless of its precision', () => {
+    const num1 = 3.14159;
+    const num2 = 3.14159;
+    const num3 = 3.14158;
+    expect(objectFingerprint(num1)).toBe(objectFingerprint(num2));
+    expect(objectFingerprint(num1)).not.toBe(objectFingerprint(num3));
+  });
+
+  it('should return the same hash value for the same input boolean, regardless of its value', () => {
+    expect(objectFingerprint(true)).toBe(objectFingerprint(true));
+    expect(objectFingerprint(false)).toBe(objectFingerprint(false))
+  });
+})

package/src/utils/stringify.ts

@@ -2,9 +2,7 @@ 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 !v.length ? "[]" : `[${attributesToString(v[0]) ?? ""} x${String(v.length)}]`;
     }
     return `{${Object.keys(v).toString()}}`;
   }
@@ -29,11 +27,7 @@ const stringifyState = (attrs?: object | Hash) => {
 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")
-    : "";
+  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}>`
-  }`;
+  return `${tab}<${tag}${stringifyState(impl)}${!ssubs ? "/>" : `>\n${ssubs}\n${tab}</${tag}>`}`;
 };

package/types.ts

@@ -0,0 +1,82 @@
+import { Uid, Delta, Data, LogEntry, Hash, XmlNode } from "ultimus/types";
+
+import { Arrmatron } from "./src/core/Arrmatron";
+
+export type IComponent = {
+  // optional Lifecycle method called when the component is done.
+  done?: (c: IArrmatron) => void;
+  // optional Lifecycle method called during initialization.
+   
+  init?: (c: IArrmatron) => Delta | null | undefined | unknown | void;
+  // optional Lifecycle method called when the state changes.
+  __stateChanged?: (changes: Map<string, unknown>) => void;
+  // state key/values
+  [key: string]: unknown;
+}
+
+export type IArrmatron = {
+  isDone: any;
+  readonly uid: Uid;
+  parent?: IArrmatron;
+  children?: Map<Uid, IArrmatron>;
+  scope?: IArrmatron;
+  $component: IComponent;
+  root: IArrmatron;
+  platform: IPlatform;
+
+  // state access
+  get: (propId: string) => unknown;
+  getFromScope: (key: string) => unknown;
+  up: (d: Delta | null | void | unknown, force?: boolean) => void;
+
+  touch: () => void;
+  emit: (key: string, arg1: Delta) => void;
+
+  // done life-cycle hook
+  done: () => void;
+  defer: (fn: () => void) => void;
+
+  // get registered arrmatron instance by reference. look up recurrsively from current to root scopes.
+  readonly refId?: string;
+  getByRef: (refId: string) => IArrmatron | undefined;
+
+  log: (val: unknown, ...arg1: unknown[]) => void;
+  logError: (error: unknown, ...arg1: unknown[]) => void;
+  toast(t: LogEntry): void;
+}
+
+export type IManifestNode = {
+  connectors?: Map<string, (c: IArrmatron, x: unknown) => unknown>;
+  refId?: string;
+  readonly uid: Uid;
+  getSubNodes(platform: IPlatform): Map<Uid, IManifestNode> | undefined;
+  resolveProps: (c: IArrmatron) => Delta | Promise<unknown> | undefined;
+  resolveInitialProps: (c: IArrmatron) => Hash;
+
+  createArrmatron: (platform: IPlatform, parent?: Arrmatron, scope?: Arrmatron) => Arrmatron;
+}
+
+export type IPlatform = {
+  log(arg0: LogEntry): void;
+  toast(t: LogEntry, ctx: IArrmatron): void;
+  getCompiledNodes(tag: string): Map<Uid, IManifestNode>;
+  getCompiledNodes(tag: XmlNode): IManifestNode;
+  getCompiledNodes(tag: XmlNode[]): Map<Uid, IManifestNode>;
+  updateResources(delta: any): void;
+  getResource(key: string | string[]): Data;
+  getFunction(id: string): (...args: unknown[]) => unknown;
+  redraw(source: IArrmatron, root: IArrmatron): void;
+  createComponent(def: IComponentDescriptor | string, initials: Hash, ctx: IArrmatron): IComponent | Hash;
+}
+
+export type ComponentConstructor = new (initials: Hash, c: IArrmatron) => IComponent;
+
+export type IComponentDescriptor = {
+  tag?: string;
+  template?: string;
+  Ctor?: ComponentConstructor;
+  unknown?: boolean;
+  native?: boolean;
+}
+
+export type EContent = Map<Uid, IManifestNode>;

package/src/core/elementary.ts

@@ -1,40 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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,
-};