arrmatura 6.3.2 → 6.3.3

package/src/utils/FingerprintMashine.ts

@@ -1,7 +1,7 @@
 const CACHE = new Map();
 
 function upnum(r: number, n: number) {
-  const rr = ((r << 5) - r) + n;
+  const rr = (r << 5) - r + n;
   return rr & rr;
 }
 
@@ -34,12 +34,11 @@ export class FingerprintMashine {
   }
 
   upString(x: string) {
-    return this.upNumber(stringHash(x))
+    return this.upNumber(stringHash(x));
   }
 
   upObject(x) {
-
-    if (x.$hash) return x.$hash;
+    if (x.uid) return x.uid;
 
     if (x instanceof Date) return this.upNumber(x.getTime());
 
@@ -55,18 +54,18 @@ export class FingerprintMashine {
         this.upString(k);
         this.upNumber(COLON_NUM);
         this.upAny(v);
-      })
+      });
     } else if (x instanceof Set) {
       this.upString("$$$Set$$$");
-      x.forEach((v) => this.upAny(v))
+      x.forEach((v) => this.upAny(v));
     } else if (Array.isArray(x)) {
       this.upString("$$$Array$$$");
-      x.forEach((v) => this.upAny(v))
+      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)
+        if (Object.prototype.hasOwnProperty.call(x, k) && k[0] !== "$") {
+          this.upString(k);
           this.upNumber(COLON_NUM);
           this.upAny(x[k]);
         }
@@ -78,37 +77,37 @@ export class FingerprintMashine {
     return this.r;
   }
   upAny(x: any): void {
-
     if (x == null) {
       this.upString(String(x));
-    } else if (typeof x === 'number') {
+    } else if (typeof x === "number") {
       if (isNaN(x)) {
         this.upString(`$$$NaN$$$`);
       } else {
         this.upNumber(x);
       }
-    } else if (typeof x === 'object') {
+    } else if (typeof x === "object") {
       this.upObject(x);
-    } else if (typeof x === 'string') {
+    } else if (typeof x === "string") {
       this.upString(x);
-    } else if (typeof x === 'boolean') {
+    } else if (typeof x === "boolean") {
       this.upString(`$$$Boolean$$$${x}`);
-    } else if (typeof x === 'function') {
+    } else if (typeof x === "function") {
       // this.upString(`$$$Function$$$${x}`);
     } else {
-      this.upString(String(x))
+      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;
+    if (x.uid) return x.uid;
+
+    if (x.$ctx) return x.$ctx.uid;
 
     this.r = 0;
     this.x = x;
@@ -120,9 +119,8 @@ export class FingerprintMashine {
 
     return this.r;
   }
-
 }
 
 const FM = new FingerprintMashine();
 
-export const objectFingerprint = (x: any) => FM.do(x)
+export const objectFingerprint = (x: any) => FM.do(x);

package/src/utils/compileExpression.ts

@@ -4,86 +4,6 @@ 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
-
-
 const OP_SHORTCUTS: StringHash = {
   "&&": "|and:",
   "==": "|equals:",
@@ -99,7 +19,8 @@ const OP_SHORTCUTS: StringHash = {
 
 const withNoPipes = (_: unknown, v: unknown) => v;
 
-const isConstKey = (key: string) => "'+-0123456789".includes(key[0]) || key === 'true' || key === 'false';
+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);
@@ -114,7 +35,7 @@ const compileArgument = (a: string, strings?: string[]) => {
   if (a[0] === "!") {
     const getter = compilePropGet(a.slice(1));
     return (c: IArrmatron) => !getter(c);
-  };
+  }
 
   if (a[0] === "#" && a[1] === "#") {
     const vv = strings?.[Number(a.slice(2))];
@@ -128,6 +49,7 @@ const compileArgument = (a: string, strings?: string[]) => {
 
 const splitExpression = (v: ExpressionText) =>
   v
+    .trim()
     .replace(/(&&|!=|==|>|<|\[|\]|\|\||\?\??)/g, (_, s) => `${OP_SHORTCUTS[s]}`)
     .split("|")
     .map((s) => s.trim());
@@ -139,8 +61,8 @@ function withPipes(pipes: string[]) {
     const strings: string[] = [];
 
     const expr = key.replaceAll(/'[^']*'/g, (s) => {
-      strings.push(s.slice(1, -1))
-      return `##${strings.length - 1}`
+      strings.push(s.slice(1, -1));
+      return `##${strings.length - 1}`;
     });
 
     const [pipeId, ...args] = expr.split(":").map((s) => s.trim());
@@ -175,10 +97,10 @@ function withPipes(pipes: string[]) {
 }
 
 function withHardValue(hardValue: ExpressionText, pipec: PipeFn): PipeFn {
-  if (!hardValue || hardValue === '*') return pipec;
+  if (!hardValue || hardValue === "it") return pipec;
 
-  if (hardValue.startsWith('*.')) {
-    const propKey = hardValue.slice(2)
+  if (hardValue.startsWith("it.")) {
+    const propKey = hardValue.slice(3);
     return (c: IArrmatron, ini: any) => pipec(c, gettus(ini, propKey));
   }
 
@@ -188,8 +110,8 @@ function withHardValue(hardValue: ExpressionText, pipec: PipeFn): PipeFn {
 }
 
 export function compilePipeExpression(v: ExpressionText) {
-  if (v.endsWith(')')) {
-    const parts = v.slice(0, -1).split('(')
+  if (v.endsWith(")")) {
+    const parts = v.slice(0, -1).split("(");
     return compilePipeExpression(`${parts[0]}=${parts[1]}`);
   }
 
@@ -212,4 +134,3 @@ export function compilePlaceholder(expr: string): Fn {
 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/narrowData.ts

@@ -0,0 +1,15 @@
+import { mapEntries } from "ultimus";
+
+export const narrowData = (data: any) => {
+  if (!data) {
+    return [];
+  }
+  if (typeof data === "string") return data.split(",").map((id) => ({ id, name: id }));
+  if (Array.isArray(data)) return data;
+  if (typeof data[Symbol.iterator] === "function") return [...data];
+  if (typeof data === "object")
+    return mapEntries(data, (key, value) =>
+      typeof value === "object" ? { ...value, id: key } : { id: key, name: String(value) }
+    );
+  return [{ id: String(data), name: String(data) }];
+};

package/types.ts

@@ -3,47 +3,51 @@ 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.
+  __init?: (c: IArrmatron) => Delta | null | undefined | unknown | void;
+  // optional method called when the state changes.
   __stateChanged?: (changes: Map<string, unknown>) => void;
+  // optional method to get a state property by name.
+  __getStateProperty?: (propName: string) => any;
   // 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;
+export type IComponentContext = {
   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 IArrmatron = IComponentContext & {
+  readonly uid: Uid;
+  parent?: IArrmatron;
+  children?: Map<Uid, Arrmatron>;
+  scope?: IArrmatron;
+  $component: IComponent;
+  root: IArrmatron;
+
+  getFromScope: (key: string) => unknown;
+  // get registered arrmatron instance by reference. look up recurrsively from current to root scopes.
+  getByRef: (refId: string) => IArrmatron | undefined;
+};
+
+export type IArrmatronRoot = IArrmatron & {
+  // done life-cycle hook
+  done: () => void;
+};
 
 export type IManifestNode = {
   connectors?: Map<string, (c: IArrmatron, x: unknown) => unknown>;
@@ -54,7 +58,7 @@ export type IManifestNode = {
   resolveInitialProps: (c: IArrmatron) => Hash;
 
   createArrmatron: (platform: IPlatform, parent?: Arrmatron, scope?: Arrmatron) => Arrmatron;
-}
+};
 
 export type IPlatform = {
   log(arg0: LogEntry): void;
@@ -66,10 +70,14 @@ export type IPlatform = {
   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;
-}
+  createComponent(
+    def: IComponentDescriptor | string,
+    initials: Hash,
+    ctx: IComponentContext
+  ): IComponent | Hash;
+};
 
-export type ComponentConstructor = new (initials: Hash, c: IArrmatron) => IComponent;
+export type ComponentConstructor = new (initials: Hash, ctx: IComponentContext) => IComponent;
 
 export type IComponentDescriptor = {
   tag?: string;
@@ -77,6 +85,6 @@ export type IComponentDescriptor = {
   Ctor?: ComponentConstructor;
   unknown?: boolean;
   native?: boolean;
-}
+};
 
-export type EContent = Map<Uid, IManifestNode>;
+export type EContent = Map<Uid, IManifestNode>;

package/docs/glossary.md

@@ -1,19 +0,0 @@
-# Glossary
-
-|                        _Term_ | _Description_                                                                                                                                                                                                  |
-| ----------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-|                     `Program` | A formal prescription given to a runtime to process (to apply trasformation rules in some order) incoming data.                                                                                                |
-|                        `Type` | A specification that defines the possible values that can be reffered by a variable.                                                                                                                           |
-|                    `Variable` | A program entity, which may reffer some data value.                                                                                                                                                            |
-| `Object-oriented programming` | A programming style that evolves around composing components, which interact with each others by handling streams of events.                                                                                   |
-|                   `Component` | An individual runtime entity that has a lifecycle, state, and behavior. Components can interact with others and are treated as black boxes.                                                                    |
-|                       `Class` | A design-time specification for the state and behavior of a component. It provides guidance for the runtime to create and manage instances of the component.                                                   |
-|                       `State` | A private data structure that is managed by a component.                                                                                                                                                       |
-|                    `Property` | A public getter/setter pair that allows access to a state value by a specified key.                                                                                                                            |
-|                    `Behavior` | A specification that defines how a component should change its state in response to external impacts.                                                                                                          |
-|                   `Interface` | A design-time specification of the methods and signatures that can be used to interact with a component.                                                                                                       |
-|                 `Composition` | The                                                                                                                                                                                                            | parent-child and context-content relationships between components. It defines the scope and lifecycle of the components that they can interact with. |
-|                    `Template` | A text written in a formal language that allows for the description of component composition and property binding in a declarative way, focused on the desired outcome rather than the implementation details. |
-|            `Property binding` | A formal sentence that expresses a dependency between the value of a target component's property and other properties. It ensures that the target property is updated whenever the dependency changes.         |
-|        `Property propagation` | A one-way binding that passes property values from a container component to its contents.                                                                                                                      |
-|                        `Hook` | A component-bound method that is called by the runtime at specific points in the component's lifecycle.                                                                                                        |