arrmatura 6.3.1 → 6.3.2

package/src/registry/slot.ts

@@ -1,10 +1,11 @@
-import { ManifestNode } from "../core/ManifestNode";
-import { Entitron } from "../core/Entitron";
 import type { XmlNode } from "ultimus/types";
-import type { IEntitron } from "arrmatura/types";
+
+import { Arrmatron } from "../core/Arrmatron";
+import { ManifestNode } from "../core/ManifestNode";
+
 import { Composite } from "./composition";
 
-class Slot extends Entitron {
+class Slot extends Arrmatron {
   get displayName(): string {
     return "🔸";
   }
@@ -17,7 +18,7 @@ class Slot extends Entitron {
     return this.compositeScope.slotContent((this.manifest as CSlotNode).key);
   }
 
-  get recontentScope(): IEntitron {
+  get recontentScope(): Arrmatron {
     return this.compositeScope.scope;
   }
 }
@@ -26,8 +27,8 @@ export class CSlotNode extends ManifestNode {
   key?: string;
 
   constructor(x: XmlNode) {
-    super();
-    this.key = x.attrs?.key as string;
+    super(x.id);
+    this.key = x.attrs?.Key as string;
   }
 
   get EntitronConstructor() {

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,8 +1,88 @@
-import { scalarParse } from "ultimus";
+import type { IArrmatron } from "arrmatura/types";
+import { scalarParse, gettus } from "ultimus";
 import type { ExpressionText, Fn, StringHash } from "ultimus/types";
-import type { IEntitron } from "arrmatura/types";
 
-type PipeFn = (c: IEntitron, argValue: unknown) => unknown;
+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
+
 
 const OP_SHORTCUTS: StringHash = {
   "&&": "|and:",
@@ -19,24 +99,31 @@ const OP_SHORTCUTS: StringHash = {
 
 const withNoPipes = (_: unknown, v: unknown) => v;
 
+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: IEntitron) => 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: IEntitron) => !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: ExpressionText) =>
@@ -49,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: IEntitron, 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;
@@ -74,35 +176,40 @@ function withPipes(pipes: string[]) {
 
 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));
+
+  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: 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: missed @-prefix: "${expr}"`);
-    }
-    fn = compileArgument(key[0] === "@" ? key : `@${key}`);
-  }
+  const fn = compileArgument(key);
 
-  return (c) => pipec(c as IEntitron, fn(c));
+  return (c) => pipec(c as IArrmatron, fn(c));
 }
 
 export function compileJsExpression(x: string) {
-  return new Function("c", x.replaceAll(/[^'a-z]([a-z][a-z0-9-\.]+)/gi, 'c.prop("$1")'));
+  return new Function("c", x.replaceAll(/[^'a-z]([a-z][a-z0-9-.]+)/gi, 'c.prop("$1")'));
 }
 

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/types.ts

@@ -1,64 +1,75 @@
 import { Uid, Delta, Data, LogEntry, Hash, XmlNode } from "ultimus/types";
 
+import { Arrmatron } from "./src/core/Arrmatron";
+
 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;
+  // 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 IEntitron = {
+export type IArrmatron = {
   isDone: any;
   readonly uid: Uid;
-  parent?: IEntitron;
-  children?: Map<Uid, IEntitron>;
-  scope?: IEntitron;
-  component: IComponent;
-  root: IEntitron;
+  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;
-  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 life-cycle hook
   done: () => void;
+  defer: (fn: () => void) => void;
 
-  addReference: (refId: string, r: IEntitron) => void;
-  getByRef: (refId: string) => IEntitron | undefined;
-  getFromScope: (key: string) => unknown;
-  settleAsChild: () => 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: IEntitron, x: unknown) => unknown>;
+  connectors?: Map<string, (c: IArrmatron, 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;
+  resolveProps: (c: IArrmatron) => Delta | Promise<unknown> | undefined;
+  resolveInitialProps: (c: IArrmatron) => Hash;
 
-  createEntitron: (platform: IPlatform, parent?: IEntitron, scope?: IEntitron) => IEntitron;
+  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: IEntitron, root: IEntitron): void;
-  createComponent(def: IComponentDescriptor | string, initials: Hash, ctx: IEntitron): IComponent | Hash;
+  redraw(source: IArrmatron, root: IArrmatron): void;
+  createComponent(def: IComponentDescriptor | string, initials: Hash, ctx: IArrmatron): IComponent | Hash;
 }
 
-export type ComponentConstructor = new (initials: Hash, c: IEntitron) => IComponent;
+export type ComponentConstructor = new (initials: Hash, c: IArrmatron) => IComponent;
 
 export type IComponentDescriptor = {
   tag?: string;
@@ -68,6 +79,4 @@ export type IComponentDescriptor = {
   native?: boolean;
 }
 
-export type EclecticTypeInfo = string | IComponentDescriptor | ComponentConstructor;
-
 export type EContent = Map<Uid, IManifestNode>;