Skip to content

The Open Standard for Generative UI

4.1 KB
Raw Blame
/**
 * Shared prop value evaluation logic.
 *
 * Both evaluator.ts (inline path) and evaluate-tree.ts (React path) need
 * identical prop evaluation — AST resolution, ReactiveAssign handling,
 * ElementNode recursion, ActionPlan preservation. The only difference is
 * how they recurse into ElementNodes. This module extracts the shared core
 * and takes recursion callbacks so each caller can supply its own strategy.
 *
 * Also fixes the nested reactive drop bug: reactiveSchema is now correctly
 * passed through plain object recursion.
 */

import { isASTNode } from "../parser/ast";
import type { ElementNode } from "../parser/types";
import { isElementNode } from "../parser/types";
import { isReactiveSchema } from "../reactive";
import type { EvaluationContext, SchemaContext } from "./evaluator";
import { evaluate, isActionPlan, isReactiveAssign, ownSteps } from "./evaluator";

export interface PropEvalCallbacks {
  /** How to recurse into an ElementNode (evaluator vs evaluate-tree differ here). */
  recurseElement: (el: ElementNode) => ElementNode;
  /** How to self-recurse for a prop value. */
  recurse: (value: unknown, reactiveSchema?: unknown) => unknown;
}

/**
 * Evaluate a single prop value with schema awareness. Handles AST nodes,
 * ReactiveAssign markers, nested ElementNodes, arrays, and ActionPlans.
 */
export function evaluatePropCore(
  value: unknown,
  context: EvaluationContext,
  schemaCtx: SchemaContext,
  reactiveSchema: unknown | undefined,
  callbacks: PropEvalCallbacks,
): unknown {
  const result = evaluatePropValue(value, context, schemaCtx, reactiveSchema, callbacks);
  // Only real calls make custom steps: a plan read from data loses them
  return isActionPlan(result) ? ownSteps(result) : result;
}

function evaluatePropValue(
  value: unknown,
  context: EvaluationContext,
  schemaCtx: SchemaContext,
  reactiveSchema: unknown | undefined,
  callbacks: PropEvalCallbacks,
): unknown {
  if (value == null) return value;
  if (typeof value !== "object") return value;

  // AST node — evaluate with schema context
  if (isASTNode(value)) {
    // StateRef on reactive prop → ReactiveAssign marker
    if (value.k === "StateRef" && reactiveSchema && isReactiveSchema(reactiveSchema)) {
      return {
        __reactive: "assign" as const,
        target: value.n,
        expr: { k: "StateRef" as const, n: "$value" },
      };
    }
    const result = evaluate(value, context, schemaCtx);
    // ElementNode result (from ternary/Comp) → recurse into its props
    if (isElementNode(result)) {
      return callbacks.recurseElement(result as ElementNode);
    }
    // Array result (from Each) → recurse into any ElementNodes
    if (Array.isArray(result)) {
      return result.map((item) =>
        isElementNode(item) ? callbacks.recurseElement(item as ElementNode) : item,
      );
    }
    // Strip ReactiveAssign from non-reactive props
    if (isReactiveAssign(result) && !(reactiveSchema && isReactiveSchema(reactiveSchema))) {
      return context.getState(result.target) ?? null;
    }
    return result;
  }

  // String on reactive schema → pass through (component's useStateField resolves it)
  if (typeof value === "string" && reactiveSchema && isReactiveSchema(reactiveSchema)) {
    return value;
  }

  // Array — recurse
  if (Array.isArray(value)) {
    return value.map((v) => callbacks.recurse(v, reactiveSchema));
  }

  // ElementNode — recurse with schema
  if (isElementNode(value)) {
    return callbacks.recurseElement(value as ElementNode);
  }

  // ActionPlan — preserve as-is (deferred click-time evaluation)
  if (isActionPlan(value)) return value;
  const obj = value as Record<string, unknown>;

  // Plain data object — recurse if contains nested objects
  // NOTE: reactiveSchema is passed through — fixes nested reactive drop bug
  let needsEval = false;
  for (const val of Object.values(obj)) {
    if (typeof val === "object" && val !== null) {
      needsEval = true;
      break;
    }
  }
  if (needsEval) {
    const result: Record<string, unknown> = {};
    for (const [k, v] of Object.entries(obj)) {
      result[k] = callbacks.recurse(v, reactiveSchema);
    }
    return result;
  }

  return value;
}