@kaskad/eval-tree 0.0.1

package/fesm2022/kaskad-eval-tree.mjs

@@ -0,0 +1,787 @@
+import { computed, untracked, observable, runInAction, isComputed, toJS, comparer } from 'mobx';
+import { parseValueType, isUnfoldedNodeSchema, unfoldNodeSchema } from '@kaskad/schema';
+import { isObservable } from 'rxjs';
+import { log } from '@kaskad/config';
+
+const debugName = (context, thing) => {
+    return [context.componentId, thing].join('|');
+};
+
+function evaluateArray(evalNode, context) {
+    const itemResults = evalNode.items.map((item) => evaluateNode(item, context));
+    const itemComputeds = itemResults.map((result) => result.computed);
+    const disposers = itemResults.flatMap((result) => result.disposers);
+    return {
+        computed: computed(() => {
+            const evaluating = itemComputeds.some((ro) => ro.get().evaluating);
+            const failed = itemComputeds.some((ro) => ro.get().failed);
+            return itemComputeds.reduce((acc, ro) => {
+                acc.value.push(ro.get().value);
+                return acc;
+            }, { value: [], evaluating, settled: !evaluating, failed });
+        }, {
+            name: debugName(context, 'array-literal'),
+        }),
+        disposers,
+    };
+}
+
+/**
+ * Parses a function signature string into structured parameter and return types.
+ *
+ * Format: (param1Type, param2Type, ...) => returnType
+ * Variadic: (...type) => returnType
+ *
+ * Examples:
+ * - '() => void'
+ * - '(string, number) => boolean'
+ * - '(unknown[], number) => unknown'
+ * - '(...unknown) => boolean'
+ * - '({name: string}, number[]) => void'
+ */
+function parseSignature(signature) {
+    const trimmed = signature.trim();
+    // Split by => to get params and return parts
+    const arrowIndex = trimmed.indexOf('=>');
+    if (arrowIndex === -1) {
+        throw new Error(`Invalid signature: missing '=>'. Expected format: '(params) => returnType'`);
+    }
+    const paramsStr = trimmed.slice(0, arrowIndex).trim();
+    const returnStr = trimmed.slice(arrowIndex + 2).trim();
+    if (!returnStr) {
+        throw new Error(`Invalid signature: missing return type after '=>'`);
+    }
+    // Parse return type
+    const returns = parseValueType(returnStr);
+    // Parse params
+    if (!paramsStr.startsWith('(') || !paramsStr.endsWith(')')) {
+        throw new Error(`Invalid signature: params must be wrapped in parentheses. Got: ${paramsStr}`);
+    }
+    const paramsContent = paramsStr.slice(1, -1).trim();
+    // Empty params
+    if (!paramsContent) {
+        return {
+            params: [],
+            variadic: false,
+            returns,
+        };
+    }
+    // Check for variadic
+    if (paramsContent.startsWith('...')) {
+        const variadicType = paramsContent.slice(3).trim();
+        if (!variadicType) {
+            throw new Error(`Invalid signature: variadic parameter must have a type. Got: '...${variadicType}'`);
+        }
+        return {
+            params: [parseValueType(variadicType)],
+            variadic: true,
+            returns,
+        };
+    }
+    // Split by comma, respecting nesting
+    const paramTypes = splitByComma(paramsContent);
+    return {
+        params: paramTypes.map((typeStr) => parseValueType(typeStr.trim())),
+        variadic: false,
+        returns,
+    };
+}
+/**
+ * Splits a string by commas while respecting nested braces and brackets.
+ * Used to split parameter lists that may contain complex types like {a: string, b: number}.
+ */
+function splitByComma(str) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === '{' || char === '[' || char === '(') {
+            depth++;
+            current += char;
+        }
+        else if (char === '}' || char === ']' || char === ')') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+
+/**
+ * Recursively extracts primitive values from nested NodeSchema structures.
+ *
+ * Traverses the value tree and unwraps NodeSchema objects to their primitive values.
+ * Preserves collection types (Array, Set, Map) and component inline values.
+ *
+ * @param value - Value that may contain nested NodeSchema objects
+ * @returns Primitive value with all NodeSchema wrappers removed
+ */
+function extractPrimitiveValue(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (isUnfoldedNodeSchema(value)) {
+        return extractPrimitiveValue(value.value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(extractPrimitiveValue);
+    }
+    if (value instanceof Set) {
+        const extracted = new Set();
+        value.forEach((item) => extracted.add(extractPrimitiveValue(item)));
+        return extracted;
+    }
+    if (value instanceof Map) {
+        const extracted = new Map();
+        value.forEach((val, key) => extracted.set(key, extractPrimitiveValue(val)));
+        return extracted;
+    }
+    // ComponentNodeInlineValue has Maps that must be preserved
+    if (typeof value === 'object' && 'componentType' in value && value.componentType) {
+        return value;
+    }
+    if (typeof value === 'object') {
+        const extracted = {};
+        for (const [key, val] of Object.entries(value)) {
+            extracted[key] = extractPrimitiveValue(val);
+        }
+        return extracted;
+    }
+    return value;
+}
+/**
+ * Normalizes raw values by detecting formulas and extracting primitives.
+ *
+ * Performs schema unfolding to handle formula detection (e.g., "={{...}}" or "=..."),
+ * then extracts primitive values from the resulting NodeSchema structure.
+ *
+ * @param rawValue - Raw value that may be a formula string or contain nested schemas
+ * @param valueType - Expected type of the value after normalization
+ * @returns ComputationSchema if value is a formula, otherwise primitive value
+ */
+function normalizeValue(rawValue, valueType) {
+    // Handle runtime Set values directly - they don't need unfolding.
+    // This occurs when Set-typed variables are passed to functions expecting arrays.
+    // The function implementations (e.g., filterIn) handle both arrays and Sets.
+    if (rawValue instanceof Set) {
+        return rawValue;
+    }
+    const schema = unfoldNodeSchema(rawValue, valueType);
+    if (schema.computation) {
+        return schema.computation;
+    }
+    return extractPrimitiveValue(schema.value);
+}
+
+/**
+ * Sentinel value for arguments that have not yet been evaluated.
+ * Distinguishes unevaluated arguments from arguments that evaluated to null.
+ */
+const NOT_EVALUATED = Symbol('NOT_EVALUATED');
+/**
+ * Evaluates function arguments and aggregates evaluation states.
+ * Returns values array with NOT_EVALUATED symbol for unevaluated arguments.
+ */
+function evaluateArguments(ctx) {
+    const { computedArgs, argsTypes } = ctx;
+    const values = [];
+    let allEvaluated = true;
+    let anyEvaluating = false;
+    let anyFailed = false;
+    for (let i = 0; i < computedArgs.length; i++) {
+        const { value: rawValue, settled, evaluating, failed } = computedArgs[i].get();
+        if (evaluating) {
+            anyEvaluating = true;
+        }
+        if (failed) {
+            anyFailed = true;
+        }
+        if (!settled) {
+            allEvaluated = false;
+            values.push(NOT_EVALUATED);
+        }
+        else {
+            if (!argsTypes[i]) {
+                throw new Error(`Argument type definition missing for argument ${i}. ` +
+                    `Expected ${argsTypes.length} arguments but got ${computedArgs.length}.`);
+            }
+            values.push(normalizeValue(rawValue, argsTypes[i].valueType));
+        }
+    }
+    return { values, allEvaluated, anyEvaluating, anyFailed };
+}
+
+/**
+ * Wraps async values (Promises, RxJS Observables) in MobX-tracked structures.
+ *
+ * Returns PromiseValue for Promises, ObservableValue for Observables, or the value unchanged.
+ */
+function toObservable(result) {
+    if (result instanceof Promise) {
+        return untracked(() => {
+            const asyncValue = observable.object({
+                kind: 'promise',
+                current: null,
+                error: null,
+                pending: true,
+            });
+            result.then((value) => {
+                runInAction(() => {
+                    asyncValue.current = value;
+                    asyncValue.pending = false;
+                    asyncValue.error = null;
+                });
+            }, (err) => {
+                runInAction(() => {
+                    asyncValue.error = err;
+                    asyncValue.pending = false;
+                    asyncValue.current = null;
+                });
+            });
+            return asyncValue;
+        });
+    }
+    if (isObservable(result)) {
+        return untracked(() => {
+            const asyncValue = observable.object({
+                kind: 'observable',
+                current: null,
+                error: null,
+                pending: true,
+                subscription: undefined,
+            });
+            try {
+                const subscription = result.subscribe({
+                    next: (value) => {
+                        runInAction(() => {
+                            asyncValue.current = value;
+                            asyncValue.pending = false;
+                            asyncValue.error = null;
+                        });
+                    },
+                    error: (err) => {
+                        runInAction(() => {
+                            asyncValue.error = err;
+                            asyncValue.pending = false;
+                        });
+                    },
+                    complete: () => {
+                        runInAction(() => {
+                            asyncValue.pending = false;
+                        });
+                    },
+                });
+                runInAction(() => {
+                    asyncValue.subscription = subscription;
+                });
+            }
+            catch (error) {
+                runInAction(() => {
+                    asyncValue.error = error;
+                    asyncValue.pending = false;
+                    asyncValue.current = null;
+                });
+            }
+            return asyncValue;
+        });
+    }
+    return result;
+}
+
+/**
+ * Wraps an imperative function to work in the reactive pipeline.
+ * Unwraps computed arguments to plain values and propagates argument states.
+ */
+function wrapImperativeAsReactive(imperativeDef) {
+    const { params } = parseSignature(imperativeDef.signature);
+    const argsTypes = params.map((p) => ({ valueType: p }));
+    if (imperativeDef.contextual) {
+        // Contextual imperative -> contextual reactive
+        return {
+            kind: 'reactive',
+            contextual: true,
+            execute: (ctx, computedArgs) => {
+                return computed(() => {
+                    const { values, allEvaluated, anyEvaluating, anyFailed } = evaluateArguments({
+                        computedArgs,
+                        argsTypes,
+                    });
+                    if (!allEvaluated || anyFailed) {
+                        return {
+                            returnValue: null,
+                            argsEvaluated: false,
+                            argsEvaluating: anyEvaluating,
+                            argsFailed: anyFailed,
+                        };
+                    }
+                    try {
+                        const result = imperativeDef.execute(ctx, ...values);
+                        return {
+                            returnValue: toObservable(result),
+                            argsEvaluated: true,
+                            argsEvaluating: false,
+                            argsFailed: false,
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            returnValue: toObservable(Promise.reject(error)),
+                            argsEvaluated: true,
+                            argsEvaluating: false,
+                            argsFailed: false,
+                        };
+                    }
+                });
+            },
+            signature: imperativeDef.signature,
+        };
+    }
+    else {
+        // Pure imperative -> pure reactive
+        return {
+            kind: 'reactive',
+            execute: (computedArgs) => {
+                return computed(() => {
+                    const { values, allEvaluated, anyEvaluating, anyFailed } = evaluateArguments({
+                        computedArgs,
+                        argsTypes,
+                    });
+                    if (!allEvaluated || anyFailed) {
+                        return {
+                            returnValue: null,
+                            argsEvaluated: false,
+                            argsEvaluating: anyEvaluating,
+                            argsFailed: anyFailed,
+                        };
+                    }
+                    try {
+                        const result = imperativeDef.execute(...values);
+                        return {
+                            returnValue: toObservable(result),
+                            argsEvaluated: true,
+                            argsEvaluating: false,
+                            argsFailed: false,
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            returnValue: toObservable(Promise.reject(error)),
+                            argsEvaluated: true,
+                            argsEvaluating: false,
+                            argsFailed: false,
+                        };
+                    }
+                });
+            },
+            signature: imperativeDef.signature,
+        };
+    }
+}
+
+/**
+ * Ensures a function definition is reactive.
+ *
+ * This utility function provides a consistent way to convert any function definition
+ * into a reactive version that works with MobX computed values. Reactive functions
+ * are required for the evaluation pipeline to support lazy evaluation and proper
+ * dependency tracking.
+ *
+ * @param definition - Either an imperative or reactive function definition
+ * @returns A reactive function definition. If the input was already reactive,
+ *          returns it unchanged. If imperative, wraps it using wrapImperativeAsReactive.
+ *
+ * @example
+ * ```typescript
+ * // Register a function, ensuring it's reactive
+ * const reactiveFn = ensureReactive(myImperativeFunction);
+ * defStore.setFunction('myFn', reactiveFn);
+ * ```
+ */
+function ensureReactive(definition) {
+    if (definition.kind === 'reactive') {
+        return definition;
+    }
+    else {
+        return wrapImperativeAsReactive(definition);
+    }
+}
+
+/**
+ * Validates that a function definition's signature string matches its execute function.
+ *
+ * Performs basic parameter count validation to catch common mistakes.
+ * Runs at function registration time (once per function), not on every invocation.
+ *
+ * @param name - Function identifier for error messages
+ * @param definition - Function definition to validate
+ * @throws {Error} When signature is malformed or parameter count exceeds declaration
+ */
+function validateFunctionSignature(name, definition) {
+    try {
+        const { params, variadic } = parseSignature(definition.signature);
+        if (definition.kind === 'imperative') {
+            const ctxOffset = definition.contextual ? 1 : 0; // +1 for ctx parameter if contextual
+            const expectedLength = params.length + ctxOffset;
+            const actualLength = definition.execute.length;
+            // Validate only when execute has MORE parameters than declared in signature.
+            // We allow fewer because function.length excludes default parameters.
+            // Example: execute(ctx, a, b = 5) has length 2, even with signature '(a, b) => result'
+            if (actualLength > 0 && actualLength > expectedLength && !variadic) {
+                throw new Error(`Function "${name}": execute function has more parameters (${actualLength - ctxOffset}) than signature declares (${params.length}). ` +
+                    `Signature: ${definition.signature}`);
+            }
+        }
+        else {
+            // Reactive functions: contextual receives (ctx, args), pure receives just (args)
+            const actualLength = definition.execute.length;
+            const expectedLength = definition.contextual ? 2 : 1;
+            if (actualLength !== expectedLength) {
+                log.warn(`Function "${name}": reactive execute should take exactly ${expectedLength} parameter(s) ${definition.contextual ? '(ctx, args)' : '(args)'}. Got ${actualLength}. ` +
+                    `This is unusual but may be intentional.`);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Function "${name}": Invalid signature - ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Validates all functions in a registry.
+ *
+ * Useful for bulk validation in test setup or during application initialization.
+ * Throws on the first invalid function encountered.
+ *
+ * @param functions - Map of function names to their definitions
+ * @throws {Error} When any function has an invalid signature
+ */
+function validateFunctionRegistry(functions) {
+    for (const [name, definition] of Object.entries(functions)) {
+        validateFunctionSignature(name, definition);
+    }
+}
+
+/**
+ * Registry for formula functions.
+ * Singleton pattern for global access throughout the application.
+ */
+class FunctionRegistry {
+    static instance;
+    // All functions are stored as reactive (imperative ones are wrapped automatically)
+    reactiveFunctions = {};
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor() { }
+    static getInstance() {
+        if (!FunctionRegistry.instance) {
+            FunctionRegistry.instance = new FunctionRegistry();
+        }
+        return FunctionRegistry.instance;
+    }
+    static reset() {
+        FunctionRegistry.instance = new FunctionRegistry();
+        return FunctionRegistry.instance;
+    }
+    /**
+     * Register multiple formula functions at once.
+     * Automatically wraps imperative functions as reactive.
+     */
+    setFunctions(definitions) {
+        for (const [functionType, definition] of Object.entries(definitions)) {
+            this.setFunction(functionType, definition);
+        }
+    }
+    /**
+     * Register a formula function.
+     *
+     * Accepts both reactive and imperative definitions. Imperative definitions are
+     * automatically wrapped as reactive. The registry stores all functions as ReactiveFunctionDefinition.
+     *
+     * In development mode, validates that the signature matches the execute function.
+     *
+     * @param functionType - Unique identifier for the function
+     * @param definition - Function definition (imperative or reactive)
+     */
+    setFunction(functionType, definition) {
+        // Validate signature in development
+        validateFunctionSignature(functionType, definition);
+        this.reactiveFunctions[functionType] = ensureReactive(definition);
+    }
+    /**
+     * Get a registered formula function.
+     * @throws Error if function is not found
+     */
+    getFunction(functionType) {
+        const definition = this.reactiveFunctions[functionType];
+        if (!definition) {
+            throw new Error(`Function "${functionType}" not found.`);
+        }
+        return definition;
+    }
+    /**
+     * Get all registered function names.
+     */
+    getFunctionNames() {
+        return Object.keys(this.reactiveFunctions);
+    }
+    /**
+     * Check if a function is registered.
+     */
+    hasFunction(functionType) {
+        return !!this.reactiveFunctions[functionType];
+    }
+}
+
+/** Type guard for AsyncValue. */
+function isAsyncValue(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'kind' in obj &&
+        (obj.kind === 'promise' || obj.kind === 'observable') &&
+        'current' in obj &&
+        'error' in obj &&
+        'pending' in obj);
+}
+/** Type guard for PromiseValue. */
+function isPromiseValue(obj) {
+    return isAsyncValue(obj) && obj.kind === 'promise';
+}
+/** Type guard for ObservableValue. */
+function isObservableValue(obj) {
+    return isAsyncValue(obj) && obj.kind === 'observable';
+}
+
+/**
+ * Manages RxJS subscription lifecycle across function re-evaluations.
+ */
+const createSubscriptionTracker = () => {
+    let currentSubscription = null;
+    const updateSubscription = (result) => {
+        const newSubscription = isObservableValue(result.returnValue) ? result.returnValue.subscription : null;
+        if (currentSubscription !== null && currentSubscription !== newSubscription) {
+            if (typeof currentSubscription.unsubscribe === 'function') {
+                currentSubscription.unsubscribe();
+            }
+        }
+        currentSubscription = newSubscription;
+    };
+    const cleanupDisposer = (() => {
+        if (currentSubscription && typeof currentSubscription.unsubscribe === 'function') {
+            currentSubscription.unsubscribe();
+        }
+        currentSubscription = null;
+    });
+    return [updateSubscription, cleanupDisposer];
+};
+/**
+ * Executes a function and returns its reactive state with cleanup handlers.
+ */
+const executeFunction = (evalNode, context) => {
+    const fnRegistry = FunctionRegistry.getInstance();
+    const argResults = evalNode.args.map((arg) => evaluateNode(arg, context));
+    const computedArgs = argResults.map((result) => result.computed);
+    const argDisposers = argResults.flatMap((result) => result.disposers);
+    const fnDefinition = fnRegistry.getFunction(evalNode.name);
+    try {
+        const resultComputed = fnDefinition.contextual
+            ? fnDefinition.execute(context, computedArgs)
+            : fnDefinition.execute(computedArgs);
+        const [updateSubscription, cleanupDisposer] = createSubscriptionTracker();
+        const executionResultComputed = computed(() => {
+            const result = resultComputed.get();
+            updateSubscription(result);
+            return result;
+        }, {
+            name: debugName(context, evalNode.name),
+        });
+        return [executionResultComputed, cleanupDisposer, argDisposers];
+    }
+    catch (error) {
+        const src = context.sourceUrl ? `[${context.sourceUrl}] ` : '';
+        if (error instanceof Error) {
+            const message = [
+                `${src}Function "${evalNode.name}" failed`,
+                error.message,
+                `\nContext:\n  Component: ${context.componentId}`,
+            ].join('\n');
+            throw new Error(message, { cause: error });
+        }
+        else {
+            throw new Error(`${src}Function "${evalNode.name}" failed: ${String(error)}`, { cause: error });
+        }
+    }
+};
+
+function isComputedValue(value) {
+    return isComputed(value);
+}
+
+/**
+ * Extracts evaluation state from return values, unwrapping AsyncValue wrappers.
+ */
+function getReturnValueState(source) {
+    let rawValue;
+    let evaluating = false;
+    let failed = false;
+    if (isAsyncValue(source)) {
+        rawValue = toJS(source.current);
+        evaluating = source.pending;
+        failed = !!source.error;
+    }
+    else {
+        try {
+            rawValue = isComputedValue(source) ? source.get() : source;
+        }
+        catch {
+            rawValue = null;
+            failed = true;
+        }
+    }
+    return {
+        value: rawValue,
+        evaluating,
+        failed,
+    };
+}
+
+/**
+ * Evaluates a function call with reactive state tracking.
+ * Supports synchronous values, Promises, and RxJS Observables.
+ */
+function evaluateFunction(evalNode, context) {
+    const [executionResult, functionDisposer, argDisposers] = executeFunction(evalNode, context);
+    return {
+        computed: computed(() => {
+            const { returnValue, argsEvaluated, argsEvaluating, argsFailed } = executionResult.get();
+            const returnValueState = getReturnValueState(returnValue);
+            return {
+                value: returnValueState.value,
+                settled: argsEvaluated && !returnValueState.evaluating,
+                evaluating: argsEvaluating || returnValueState.evaluating,
+                failed: argsFailed || returnValueState.failed,
+            };
+        }, {
+            equals: comparer.structural,
+            name: debugName(context, evalNode.name),
+        }),
+        disposers: [functionDisposer, ...argDisposers],
+    };
+}
+
+function evaluateObject(evalNode, context) {
+    const propertyResults = evalNode.properties.map((property) => {
+        const keyResult = evaluateNode(property.key, context);
+        const valueResult = evaluateNode(property.value, context);
+        return { keyResult, valueResult };
+    });
+    const entriesComputeds = propertyResults.map(({ keyResult, valueResult }) => [keyResult.computed, valueResult.computed]);
+    const disposers = propertyResults.flatMap(({ keyResult, valueResult }) => [
+        ...keyResult.disposers,
+        ...valueResult.disposers,
+    ]);
+    return {
+        computed: computed(() => {
+            const evaluating = entriesComputeds.some(([keyComputed, valueComputed]) => keyComputed.get().evaluating || valueComputed.get().evaluating);
+            const failed = entriesComputeds.some(([keyComputed, valueComputed]) => keyComputed.get().failed || valueComputed.get().failed);
+            const entries = entriesComputeds.map(([keyComputed, valueComputed]) => [
+                keyComputed.get().value,
+                valueComputed.get().value,
+            ]);
+            const value = Object.fromEntries(entries);
+            return { value, evaluating, settled: !evaluating, failed };
+        }, {
+            equals: comparer.structural,
+            name: debugName(context, 'object-literal'),
+        }),
+        disposers,
+    };
+}
+
+function evaluateValue(node) {
+    return {
+        computed: computed(() => ({
+            value: node.value,
+            evaluating: false,
+            settled: true,
+            failed: false,
+        })),
+        disposers: [],
+    };
+}
+
+const delegates = {
+    function: (evalNode, context) => evaluateFunction(evalNode, context),
+    value: (evalNode) => evaluateValue(evalNode),
+    array: (evalNode, context) => evaluateArray(evalNode, context),
+    object: (evalNode, context) => evaluateObject(evalNode, context),
+};
+function evaluateNode(evalNode, context) {
+    const delegate = delegates[evalNode.type];
+    if (!delegate) {
+        throw new Error(`Cannot found computer. Node: ${JSON.stringify(evalNode)}`);
+    }
+    return delegate(evalNode, context);
+}
+
+/**
+ * Helper for building FunctionExecutionState in reactive functions.
+ * Tracks argument evaluation states and provides early-return helpers.
+ */
+class FunctionExecutionStateBuilder {
+    argsEvaluating = false;
+    argsFailed = false;
+    /** Track state from an argument. */
+    trackArg(argState) {
+        if (argState.evaluating)
+            this.argsEvaluating = true;
+        if (argState.failed)
+            this.argsFailed = true;
+    }
+    /** Check if argument is ready. Returns state to return early if not ready, null otherwise. */
+    checkReady(argState) {
+        this.trackArg(argState);
+        if (!argState.settled) {
+            return this.notReady();
+        }
+        return null;
+    }
+    /** Return state when arguments are not ready. */
+    notReady() {
+        return {
+            returnValue: null,
+            argsEvaluated: false,
+            argsEvaluating: this.argsEvaluating,
+            argsFailed: this.argsFailed,
+        };
+    }
+    /** Return successful state with a value. */
+    success(value) {
+        return {
+            returnValue: value,
+            argsEvaluated: true,
+            argsEvaluating: this.argsEvaluating,
+            argsFailed: this.argsFailed,
+        };
+    }
+}
+
+// Main evaluation function
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { FunctionExecutionStateBuilder, FunctionRegistry, evaluateNode, wrapImperativeAsReactive };
+//# sourceMappingURL=kaskad-eval-tree.mjs.map