@kaskad/core 0.0.8 → 0.0.9

package/fesm2022/kaskad-core.mjs

@@ -46,13 +46,13 @@ class TemplateLoadingTracker {
 // Export a singleton instance for tracking template loading operations
 const templateLoadingTracker = new TemplateLoadingTracker();
 
-function execute$U(_ctx, ms) {
+function execute$X(_ctx, ms) {
     return new Promise((resolve) => setTimeout(() => resolve(), ms));
 }
 
 var delay$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$U
+    execute: execute$X
 });
 
 const commands$1 = {
@@ -86,7 +86,7 @@ const and = {
     signature: '(...unknown) => boolean',
 };
 
-function execute$T(source, path) {
+function execute$W(source, path) {
     const takeDeep = (source, path) => path.reduce((current, step) => {
         return current?.[step];
     }, source);
@@ -94,99 +94,99 @@ function execute$T(source, path) {
 }
 const arrayPluck = {
     kind: 'imperative',
-    execute: execute$T,
+    execute: execute$W,
     signature: '(unknown{}[], string[]) => unknown',
 };
 
-function execute$S(value, index) {
+function execute$V(value, index) {
     return value[index];
 }
 const at = {
     kind: 'imperative',
-    execute: execute$S,
+    execute: execute$V,
     signature: '(unknown[], number) => unknown',
 };
 
-function execute$R(value) {
+function execute$U(value) {
     return Boolean(value);
 }
 const bool = {
     kind: 'imperative',
-    execute: execute$R,
+    execute: execute$U,
     signature: '(unknown) => boolean',
 };
 
-function execute$Q(value) {
+function execute$T(value) {
     return Math.ceil(value);
 }
 const ceil = {
     kind: 'imperative',
-    execute: execute$Q,
+    execute: execute$T,
     signature: '(number) => number',
 };
 
-function execute$P(strings, separator = '') {
+function execute$S(strings, separator = '') {
     return strings.join(separator);
 }
 const concat = {
     kind: 'imperative',
-    execute: execute$P,
+    execute: execute$S,
     signature: '(unknown[], string) => string',
 };
 
-const execute$O = (value) => {
+const execute$R = (value) => {
     return new Promise((resolve) => setTimeout(() => resolve(value), 500));
 };
 const delay = {
     kind: 'imperative',
-    execute: execute$O,
+    execute: execute$R,
     signature: '(unknown) => unknown',
 };
 
-function execute$N(num1, num2) {
+function execute$Q(num1, num2) {
     return num1 / num2;
 }
 const divide = {
     kind: 'imperative',
-    execute: execute$N,
+    execute: execute$Q,
     signature: '(number, number) => number',
 };
 
-function execute$M(items) {
+function execute$P(items) {
     return items.length === 0;
 }
 const empty = {
     kind: 'imperative',
-    execute: execute$M,
+    execute: execute$P,
     signature: '(unknown[]) => boolean',
 };
 
-function execute$L(object) {
+function execute$O(object) {
     return Object.keys(object).length === 0;
 }
 const emptyObject = {
     kind: 'imperative',
-    execute: execute$L,
+    execute: execute$O,
     signature: '(unknown{}) => boolean',
 };
 
-const execute$K = (a, b) => a === b;
+const execute$N = (a, b) => a === b;
 const eq = {
     kind: 'imperative',
-    execute: execute$K,
+    execute: execute$N,
     signature: '(unknown, unknown) => boolean',
 };
 
-function execute$J(items) {
+function execute$M(items) {
     return items.every((item) => !!item);
 }
 const every = {
     kind: 'imperative',
-    execute: execute$J,
+    execute: execute$M,
     signature: '(unknown[]) => boolean',
 };
 
-function execute$I(array, allowedValues) {
+function execute$L(array, allowedValues) {
     if (!allowedValues) {
         return [];
     }
@@ -197,60 +197,60 @@ function execute$I(array, allowedValues) {
 }
 const filterIn = {
     kind: 'imperative',
-    execute: execute$I,
+    execute: execute$L,
     signature: '(unknown[], unknown[]) => unknown[]',
 };
 
-function execute$H(collection, key, values) {
+function execute$K(collection, key, values) {
     return values
         .map((value) => collection.find((element) => element[key] === value))
         .filter((item) => item !== undefined);
 }
 const findAllBy = {
     kind: 'imperative',
-    execute: execute$H,
+    execute: execute$K,
     signature: '(unknown{}[], string, unknown[]) => unknown{}[]',
 };
 
-function execute$G(collection, key, value) {
+function execute$J(collection, key, value) {
     const found = collection.find((element) => element[key] === value);
     return found || null;
 }
 const findBy = {
     kind: 'imperative',
-    execute: execute$G,
+    execute: execute$J,
     signature: '(unknown{}[], string, unknown) => unknown',
 };
 
-function execute$F(array) {
+function execute$I(array) {
     return array.flat();
 }
 const flatten = {
     kind: 'imperative',
-    execute: execute$F,
+    execute: execute$I,
     signature: '(unknown[][]) => unknown[]',
 };
 
-function execute$E(value) {
+function execute$H(value) {
     return Math.floor(value);
 }
 const floor = {
     kind: 'imperative',
-    execute: execute$E,
+    execute: execute$H,
     signature: '(number) => number',
 };
 
-const execute$D = (a, b) => a > b;
+const execute$G = (a, b) => a > b;
 const gt = {
     kind: 'imperative',
-    execute: execute$D,
+    execute: execute$G,
     signature: '(number, number) => boolean',
 };
 
-const execute$C = (a, b) => a >= b;
+const execute$F = (a, b) => a >= b;
 const gte = {
     kind: 'imperative',
-    execute: execute$C,
+    execute: execute$F,
     signature: '(number, number) => boolean',
 };
 
@@ -281,7 +281,7 @@ const ifFn = {
     signature: '(unknown, unknown, unknown) => unknown',
 };
 
-function execute$B(collection, value) {
+function execute$E(collection, value) {
     if (collection instanceof Set) {
         return collection.has(value);
     }
@@ -289,7 +289,7 @@ function execute$B(collection, value) {
 }
 const inFn = {
     kind: 'imperative',
-    execute: execute$B,
+    execute: execute$E,
     signature: '(unknown[], unknown) => boolean',
 };
 
@@ -299,96 +299,96 @@ function replacer(_key, value) {
     }
     return value;
 }
-function execute$A(arg) {
+function execute$D(arg) {
     return JSON.stringify(arg, replacer);
 }
 const json = {
     kind: 'imperative',
-    execute: execute$A,
+    execute: execute$D,
     signature: '(unknown) => string',
 };
 
-function execute$z(object) {
+function execute$C(object) {
     return Object.keys(object);
 }
 const keys = {
     kind: 'imperative',
-    execute: execute$z,
+    execute: execute$C,
     signature: '(unknown{}) => string[]',
 };
 
-function execute$y(value) {
+function execute$B(value) {
     return value.length;
 }
 const length = {
     kind: 'imperative',
-    execute: execute$y,
+    execute: execute$B,
     signature: '(unknown[]) => number',
 };
 
-const execute$x = (a, b) => a < b;
+const execute$A = (a, b) => a < b;
 const lt = {
     kind: 'imperative',
-    execute: execute$x,
+    execute: execute$A,
     signature: '(number, number) => boolean',
 };
 
-const execute$w = (a, b) => a <= b;
+const execute$z = (a, b) => a <= b;
 const lte = {
     kind: 'imperative',
-    execute: execute$w,
+    execute: execute$z,
     signature: '(number, number) => boolean',
 };
 
-function execute$v(num, delta) {
+function execute$y(num, delta) {
     return num - delta;
 }
 const minus = {
     kind: 'imperative',
-    execute: execute$v,
+    execute: execute$y,
     signature: '(number, number) => number',
 };
 
-function execute$u(a, b) {
+function execute$x(a, b) {
     return a % b;
 }
 const modulo = {
     kind: 'imperative',
-    execute: execute$u,
+    execute: execute$x,
     signature: '(number, number) => number',
 };
 
-function execute$t(num1, num2) {
+function execute$w(num1, num2) {
     return num1 * num2;
 }
 const multiply = {
     kind: 'imperative',
-    execute: execute$t,
+    execute: execute$w,
     signature: '(number, number) => number',
 };
 
-function execute$s(num) {
+function execute$v(num) {
     return -num;
 }
 const negate = {
     kind: 'imperative',
-    execute: execute$s,
+    execute: execute$v,
     signature: '(number) => number',
 };
 
-const execute$r = (a, b) => a !== b;
+const execute$u = (a, b) => a !== b;
 const neq = {
     kind: 'imperative',
-    execute: execute$r,
+    execute: execute$u,
     signature: '(unknown, unknown) => boolean',
 };
 
-function execute$q(value) {
+function execute$t(value) {
     return !value;
 }
 const not = {
     kind: 'imperative',
-    execute: execute$q,
+    execute: execute$t,
     signature: '(unknown) => boolean',
 };
 
@@ -422,7 +422,7 @@ const nullCoalesce = {
     signature: '(unknown, unknown) => unknown',
 };
 
-function execute$p(value) {
+function execute$s(value) {
     const number = Number(value);
     if (Number.isNaN(number)) {
         throw new Error(`Cannot convert value ${value} to number`);
@@ -431,11 +431,11 @@ function execute$p(value) {
 }
 const number = {
     kind: 'imperative',
-    execute: execute$p,
+    execute: execute$s,
     signature: '(unknown) => number',
 };
 
-function execute$o(parts) {
+function execute$r(parts) {
     const result = {};
     for (let i = 0; i < parts.length; i += 2) {
         const key = parts[i];
@@ -448,7 +448,7 @@ function execute$o(parts) {
 }
 const objectFn = {
     kind: 'imperative',
-    execute: execute$o,
+    execute: execute$r,
     signature: '(unknown[]) => unknown{}',
 };
 
@@ -479,60 +479,60 @@ const or = {
     signature: '(...unknown) => boolean',
 };
 
-function execute$n(source, path) {
+function execute$q(source, path) {
     return path.reduce((current, step) => {
         return current?.[step];
     }, source);
 }
 const pluck = {
     kind: 'imperative',
-    execute: execute$n,
+    execute: execute$q,
     signature: '(unknown{}, string[]) => unknown',
 };
 
-function execute$m(a, b) {
+function execute$p(a, b) {
     return a + b;
 }
 const plus = {
     kind: 'imperative',
-    execute: execute$m,
+    execute: execute$p,
     signature: '(unknown, unknown) => unknown',
 };
 
-function execute$l(value, precision = 0) {
+function execute$o(value, precision = 0) {
     const multiplier = Math.pow(10, precision);
     return Math.round(value * multiplier) / multiplier;
 }
 const round = {
     kind: 'imperative',
-    execute: execute$l,
+    execute: execute$o,
     signature: '(number, number) => number',
 };
 
-function execute$k(value, start, end) {
+function execute$n(value, start, end) {
     return value.slice(start, end);
 }
 const slice = {
     kind: 'imperative',
-    execute: execute$k,
+    execute: execute$n,
     signature: '(unknown[], number, number) => unknown[]',
 };
 
-function execute$j(items) {
+function execute$m(items) {
     return items.some((item) => !!item);
 }
 const some = {
     kind: 'imperative',
-    execute: execute$j,
+    execute: execute$m,
     signature: '(unknown[]) => boolean',
 };
 
-function execute$i(value) {
+function execute$l(value) {
     return String(value);
 }
 const string = {
     kind: 'imperative',
-    execute: execute$i,
+    execute: execute$l,
     signature: '(unknown) => string',
 };
 
@@ -604,21 +604,21 @@ const switchFn = {
     signature: '(...unknown) => unknown',
 };
 
-function execute$h(value) {
+function execute$k(value) {
     return value.toLowerCase();
 }
 const toLowerCase = {
     kind: 'imperative',
-    execute: execute$h,
+    execute: execute$k,
     signature: '(string) => string',
 };
 
-function execute$g(value) {
+function execute$j(value) {
     return value.toUpperCase();
 }
 const toUpperCase = {
     kind: 'imperative',
-    execute: execute$g,
+    execute: execute$j,
     signature: '(string) => string',
 };
 
@@ -1522,14 +1522,19 @@ function activateFormulaComputation(node) {
     });
     currentFrame.disposers.push(...disposers);
     const computationDisposer = reaction(() => computed.get(), (computationState) => {
-        const { evaluating, value: rawSchema, failed } = computationState;
+        const { evaluating, value: rawSchema, failed, hasResult, error } = computationState;
         node.evaluating = evaluating;
+        node.failed = failed;
+        node.error = error ?? null;
+        if (!hasResult) {
+            return; // No value produced yet (initial async load or args failed)
+        }
         if (evaluating) {
+            node.setPendingValue(rawSchema);
             return;
         }
-        node.failed = failed;
-        // Clear result frames from this depth onward (not all results!)
-        // Example: if this is depth 2, clear frames 2, 3, 4... but keep 0, 1
+        // Fully settled — clear pending value, apply schema, rebuild structure
+        node.clearPendingValue();
         node.computationStack.popFrom(thisFrameDepth);
         store.setNodeRawSchema(node, rawSchema);
         if (node.computationStack.depth > thisFrameDepth) {
@@ -1851,7 +1856,7 @@ function createJsFunction(func) {
     return new Function(commandsStr, 'args', `return (async () => { ${func} })();`);
 }
 
-function execute$f(ctx, selector, item) {
+function execute$i(ctx, selector, item) {
     ComponentTreeApi.appendArrayItem(ctx.componentId, selector, item);
     const arrayNode = ComponentTreeApi.findNode(ctx.componentId, selector);
     if (arrayNode) {
@@ -1866,55 +1871,55 @@ function execute$f(ctx, selector, item) {
 
 var appendArrayItem = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$f
+    execute: execute$i
 });
 
-function execute$e(ctx, selector) {
+function execute$h(ctx, selector) {
     return ComponentTreeApi.findNode(ctx.componentId, selector)?.extractedValue ?? null;
 }
 
 var get = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$e
+    execute: execute$h
 });
 
-function execute$d(ctx, selector, path) {
+function execute$g(ctx, selector, path) {
     return ComponentTreeApi.collectValuesArray(ctx.componentId, selector, path);
 }
 
 var propArray$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$d
+    execute: execute$g
 });
 
-function execute$c(ctx, selector, objectKey, objectValue) {
+function execute$f(ctx, selector, objectKey, objectValue) {
     return ComponentTreeApi.collectValuesMap(ctx.componentId, selector, objectKey, objectValue);
 }
 
 var propObject$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$c
+    execute: execute$f
 });
 
-function execute$b(ctx, selector, index) {
+function execute$e(ctx, selector, index) {
     ComponentTreeApi.removeArrayItem(ctx.componentId, selector, index);
 }
 
 var removeArrayItem = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$b
+    execute: execute$e
 });
 
-function execute$a(ctx, selector, ...args) {
+function execute$d(ctx, selector, ...args) {
     return ComponentTreeApi.runCommandNode(ctx.componentId, selector, ...args);
 }
 
 var run = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$a
+    execute: execute$d
 });
 
-function execute$9(ctx, componentSelector, methodName, ...args) {
+function execute$c(ctx, componentSelector, methodName, ...args) {
     const component = ComponentTreeApi.getComponent(ctx.componentId, componentSelector);
     const instance = componentInstanceMap.get(component.id);
     if (!instance) {
@@ -1929,10 +1934,10 @@ function execute$9(ctx, componentSelector, methodName, ...args) {
 
 var runComponentMethod = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$9
+    execute: execute$c
 });
 
-function execute$8(ctx, selector, value) {
+function execute$b(ctx, selector, value) {
     ComponentTreeApi.setNodeRawSchema(ctx.componentId, selector, value);
     const node = ComponentTreeApi.findNode(ctx.componentId, selector);
     if (node) {
@@ -1942,7 +1947,7 @@ function execute$8(ctx, selector, value) {
 
 var set = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    execute: execute$8
+    execute: execute$b
 });
 
 const commands = {
@@ -1977,23 +1982,33 @@ const componentsDefinitions$2 = {
     },
 };
 
-function execute$7(ctx, selector) {
+function execute$a(ctx, selector) {
+    return ComponentTreeApi.getNode(ctx.componentId, selector).error;
+}
+const error = {
+    kind: 'imperative',
+    contextual: true,
+    execute: execute$a,
+    signature: '(string) => unknown',
+};
+
+function execute$9(ctx, selector) {
     return ComponentTreeApi.getNode(ctx.componentId, selector).evaluating;
 }
 const evaluating = {
     kind: 'imperative',
     contextual: true,
-    execute: execute$7,
+    execute: execute$9,
     signature: '(string) => boolean',
 };
 
-function execute$6(ctx, selector) {
+function execute$8(ctx, selector) {
     return ComponentTreeApi.getNode(ctx.componentId, selector).failed;
 }
 const failed = {
     kind: 'imperative',
     contextual: true,
-    execute: execute$6,
+    execute: execute$8,
     signature: '(string) => boolean',
 };
 
@@ -2042,15 +2057,13 @@ const getFn = {
             if (!targetNode) {
                 return state.success(isOptional ? null : createFailedAsyncValue(new Error(`Node not found: ${selector}`)));
             }
-            // Wrap node value in AsyncValue if needed to propagate evaluating/failed state
-            if (targetNode.evaluating || targetNode.failed) {
-                const asyncValue = {
-                    kind: 'promise',
-                    current: targetNode.extractedValue,
-                    error: targetNode.failed ? new Error('Target node failed') : null,
-                    pending: targetNode.evaluating,
-                };
-                return state.success(asyncValue);
+            // Signal evaluating through side-channel, not through the value
+            if (targetNode.evaluating) {
+                state.markEvaluating();
+            }
+            // Only wrap in AsyncValue for failed (no usable value)
+            if (targetNode.failed) {
+                return state.success(createFailedAsyncValue(new Error('Target node failed')));
             }
             return state.success(targetNode.extractedValue);
         });
@@ -2058,36 +2071,47 @@ const getFn = {
     signature: '(string) => unknown',
 };
 
-function execute$5(ctx, componentSelector) {
+function execute$7(ctx, componentSelector) {
     return ComponentTreeApi.findComponent(ctx.componentId, componentSelector)?.id ?? null;
 }
 const idFn = {
     kind: 'imperative',
     contextual: true,
-    execute: execute$5,
+    execute: execute$7,
     signature: '(string) => string',
 };
 
-function execute$4(ctx, selector, path) {
+function execute$6(ctx, selector, path) {
     return ComponentTreeApi.collectValuesArray(ctx.componentId, selector, path);
 }
 const propArray = {
     kind: 'imperative',
     contextual: true,
-    execute: execute$4,
+    execute: execute$6,
     signature: '(string, string) => unknown[]',
 };
 
-function execute$3(ctx, selector, objectKey, objectValue) {
+function execute$5(ctx, selector, objectKey, objectValue) {
     return ComponentTreeApi.collectValuesMap(ctx.componentId, selector, objectKey, objectValue);
 }
 const propObject = {
     kind: 'imperative',
     contextual: true,
-    execute: execute$3,
+    execute: execute$5,
     signature: '(string, string, string) => unknown{}',
 };
 
+function execute$4(ctx, selector) {
+    const node = ComponentTreeApi.getNode(ctx.componentId, selector);
+    return node.settled && !node.evaluating && !node.failed;
+}
+const ready = {
+    kind: 'imperative',
+    contextual: true,
+    execute: execute$4,
+    signature: '(string) => boolean',
+};
+
 /**
  * Get a nested property value from an object using dot notation
  * e.g., getNestedProperty({ user: { id: 123 } }, "user.id") => 123
@@ -2106,7 +2130,7 @@ function getNestedProperty(obj, path) {
     }
     return current;
 }
-function execute$2(dimensions, content) {
+function execute$3(dimensions, content) {
     return generateCombinations(dimensions).map(({ variables }) => ({
         componentType: 'sys.RefSpace',
         content,
@@ -2188,14 +2212,24 @@ function generateCombinations(dimensions) {
 }
 const repeat = {
     kind: 'imperative',
-    execute: execute$2,
+    execute: execute$3,
     signature: '({items: unknown[], itemsType: unknown, item: string, index: string, first: unknown, last: unknown, trackBy: unknown}[], componentSchema) => componentSchema[]',
 };
 
-function execute$1(ctx, selector) {
+function execute$2(ctx, selector) {
     return ComponentTreeApi.isCommandRunning(ctx.componentId, selector);
 }
 const running = {
+    kind: 'imperative',
+    contextual: true,
+    execute: execute$2,
+    signature: '(string) => boolean',
+};
+
+function execute$1(ctx, selector) {
+    return ComponentTreeApi.getNode(ctx.componentId, selector).settled;
+}
+const settled = {
     kind: 'imperative',
     contextual: true,
     execute: execute$1,
@@ -2207,7 +2241,10 @@ const formulaFunctions$1 = {
     propArray,
     get: getFn,
     id: idFn,
+    error,
     evaluating,
+    settled,
+    ready,
     failed,
     running,
     repeat,