mlld/dist/when-expression-O2PEVPZS.mjs.map

mlld: a modular prompt scripting language

{"version":3,"sources":["../interpreter/eval/when-expression.ts"],"names":["evaluateWhenExpression","node","env","context","errors","conditions","length","value","hasAnyAction","some","c","action","logger","warn","i","pair","hasCodeExecution","actionNode","type","directive","MlldWhenExpressionError","location","conditionIndex","phase","conditionResult","evaluateCondition","condition","process","DEBUG_WHEN","debug","index","hasAction","actionResult","evaluate","isExpression","withClause","pipes","applyTailModifiers","actionError","message","originalError","conditionError","push","result","pipe","pipeEnv","createChild","createPipelineInputVariable","pipelineInput","text","String","data","toString","pipelineVar","syntax","hasInterpolation","isMultiLine","setVariable","pipeResult","createLazyWhenExpressionVariable","name","definition","parameterNames","createWhenExpressionVariable","source","metadata","isEvaluated","conditionCount","hasParameters","evaluateWhenExpressionVariable","variable","args","evalEnv","paramNames","createSimpleTextVariable","createPrimitiveVariable","paramName","paramValue","paramVar","JSON","stringify","evaluatedAt","Date","peekWhenExpressionType","actionTypes","Set","firstNode","add","literal","size","Array","from"],"mappings":"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","file":"when-expression-O2PEVPZS.mjs","sourcesContent":["/**\n * When Expression Evaluator\n * \n * Handles value-returning when expressions used in /var and /exe contexts.\n * Distinct from directive /when which executes side effects.\n */\n\nimport type { WhenExpressionNode, WhenConditionPair } from '@core/types/when';\nimport type { BaseMlldNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { MlldWhenExpressionError } from '@core/errors';\nimport { evaluate } from '../core/interpreter';\nimport { evaluateCondition } from './when';\nimport { logger } from '@core/utils/logger';\n\n/**\n * Evaluates a when expression node to return a value.\n * \n * Key differences from directive /when:\n * 1. Returns the value of the matching action (not empty string)\n * 2. Returns null if no conditions match\n * 3. Supports tail modifiers on the result\n * 4. Uses first-match semantics\n */\nexport async function evaluateWhenExpression(\n  node: WhenExpressionNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  const errors: Error[] = [];\n  \n  // Empty conditions array - return null\n  if (node.conditions.length === 0) {\n    return { value: null, env };\n  }\n  \n  // Check if any condition has an action\n  const hasAnyAction = node.conditions.some(c => c.action && c.action.length > 0);\n  if (!hasAnyAction) {\n    logger.warn('WhenExpression has no actions defined');\n    return { value: null, env };\n  }\n  \n  // Check all actions for code blocks upfront\n  for (let i = 0; i < node.conditions.length; i++) {\n    const pair = node.conditions[i];\n    if (pair.action && pair.action.length > 0) {\n      const hasCodeExecution = pair.action.some(actionNode => {\n        if (typeof actionNode === 'object' && actionNode !== null && 'type' in actionNode) {\n          return actionNode.type === 'code' || actionNode.type === 'command' || \n                 (actionNode.type === 'nestedDirective' && actionNode.directive === 'run');\n        }\n        return false;\n      });\n      \n      if (hasCodeExecution) {\n        throw new MlldWhenExpressionError(\n          'Code blocks are not supported in when expressions. Define your logic in a separate /exe function and call it instead.',\n          node.location,\n          { conditionIndex: i, phase: 'action', type: 'code-block-not-supported' }\n        );\n      }\n    }\n  }\n  \n  // Evaluate conditions in order (first-match semantics)\n  for (let i = 0; i < node.conditions.length; i++) {\n    const pair = node.conditions[i];\n    \n    try {\n      // Evaluate the condition\n      const conditionResult = await evaluateCondition(pair.condition, env);\n      \n      if (process.env.DEBUG_WHEN) {\n        logger.debug('WhenExpression condition result:', { \n          index: i, \n          conditionResult,\n          hasAction: !!(pair.action && pair.action.length > 0)\n        });\n      }\n      \n      if (conditionResult) {\n        // Condition matched - evaluate the action\n        if (!pair.action || pair.action.length === 0) {\n          // No action for this condition - return null\n          return { value: null, env };\n        }\n        \n        try {\n          // Evaluate the action to get its value\n          const actionResult = await evaluate(pair.action, env, {\n            ...context,\n            isExpression: true // Mark as expression context\n          });\n          \n          let value = actionResult.value;\n          \n          // Apply tail modifiers if present\n          if (node.withClause && node.withClause.pipes) {\n            value = await applyTailModifiers(value, node.withClause.pipes, env);\n          }\n          \n          return { value, env };\n        } catch (actionError) {\n          throw new MlldWhenExpressionError(\n            `Error evaluating action for condition ${i + 1}: ${actionError.message}`,\n            node.location,\n            { conditionIndex: i, phase: 'action', originalError: actionError }\n          );\n        }\n      }\n    } catch (conditionError) {\n      // Collect condition errors but continue evaluating\n      errors.push(new MlldWhenExpressionError(\n        `Error evaluating condition ${i + 1}: ${conditionError.message}`,\n        node.location,\n        { conditionIndex: i, phase: 'condition', originalError: conditionError }\n      ));\n    }\n  }\n  \n  // If we collected errors and no condition matched, report them\n  if (errors.length > 0) {\n    throw new MlldWhenExpressionError(\n      `When expression evaluation failed with ${errors.length} condition errors`,\n      node.location,\n      { errors }\n    );\n  }\n  \n  // No conditions matched - return null\n  return { value: null, env };\n}\n\n/**\n * Apply tail modifiers (pipeline operations) to a value\n */\nasync function applyTailModifiers(\n  value: unknown,\n  pipes: BaseMlldNode[],\n  env: Environment\n): Promise<unknown> {\n  let result = value;\n  \n  for (const pipe of pipes) {\n    // Create a child environment with the current value as pipeline input\n    const pipeEnv = env.createChild();\n    \n    // Set up pipeline input variable\n    const { createPipelineInputVariable } = await import('@core/types/variable');\n    const pipelineInput = {\n      text: String(result),\n      data: result,\n      toString: () => String(result)\n    };\n    \n    const pipelineVar = createPipelineInputVariable(\n      '_pipelineInput',\n      pipelineInput,\n      'text',\n      String(result),\n      { directive: 'var', syntax: 'reference', hasInterpolation: false, isMultiLine: false },\n      0\n    );\n    \n    pipeEnv.setVariable('_pipelineInput', pipelineVar);\n    \n    // Evaluate the pipe operation\n    const pipeResult = await evaluate(pipe, pipeEnv);\n    result = pipeResult.value;\n  }\n  \n  return result;\n}\n\n/**\n * Create a WhenExpressionVariable that evaluates lazily\n */\nexport async function createLazyWhenExpressionVariable(\n  name: string,\n  definition: WhenExpressionNode,\n  env: Environment,\n  parameterNames?: string[]\n): Promise<import('@core/types/variable').WhenExpressionVariable> {\n  const { createWhenExpressionVariable } = await import('@core/types/variable');\n  \n  const source: import('@core/types/variable').VariableSource = {\n    directive: 'var',\n    syntax: 'template', // when expressions are template-like\n    hasInterpolation: true, // conditions can reference variables\n    isMultiLine: true // typically multiline\n  };\n  \n  const metadata: import('@core/types/variable').VariableMetadata & \n    import('@core/types/variable').WhenExpressionVariable['metadata'] = {\n    isEvaluated: false,\n    conditionCount: definition.conditions.length,\n    hasParameters: !!parameterNames && parameterNames.length > 0,\n    parameterNames: parameterNames || []\n  };\n  \n  return createWhenExpressionVariable(name, definition, source, metadata);\n}\n\n/**\n * Evaluate a WhenExpressionVariable when accessed\n */\nexport async function evaluateWhenExpressionVariable(\n  variable: import('@core/types/variable').WhenExpressionVariable,\n  env: Environment,\n  args?: unknown[]\n): Promise<unknown> {\n  // If already evaluated and no parameters, return cached value\n  if (variable.metadata.isEvaluated && !variable.metadata.hasParameters) {\n    return variable.value;\n  }\n  \n  // Create evaluation environment\n  let evalEnv = env;\n  \n  // If this is a parameterized when expression (from /exe), bind parameters\n  if (variable.metadata.hasParameters && args) {\n    evalEnv = env.createChild();\n    const paramNames = variable.metadata.parameterNames || [];\n    \n    // Import variable creation functions\n    const { createSimpleTextVariable, createPrimitiveVariable } = await import('@core/types/variable');\n    \n    // Bind parameters\n    for (let i = 0; i < paramNames.length; i++) {\n      const paramName = paramNames[i];\n      const paramValue = args[i] ?? null;\n      \n      // Create appropriate variable type based on value\n      let paramVar;\n      if (typeof paramValue === 'string') {\n        paramVar = createSimpleTextVariable(\n          paramName,\n          paramValue,\n          { directive: 'var', syntax: 'quoted', hasInterpolation: false, isMultiLine: false }\n        );\n      } else if (typeof paramValue === 'number' || typeof paramValue === 'boolean' || paramValue === null) {\n        paramVar = createPrimitiveVariable(\n          paramName,\n          paramValue,\n          { directive: 'var', syntax: 'quoted', hasInterpolation: false, isMultiLine: false }\n        );\n      } else {\n        // For complex types, create appropriate variable\n        // This would need more sophisticated handling in production\n        paramVar = createSimpleTextVariable(\n          paramName,\n          JSON.stringify(paramValue),\n          { directive: 'var', syntax: 'quoted', hasInterpolation: false, isMultiLine: false }\n        );\n      }\n      \n      evalEnv.setVariable(paramName, paramVar);\n    }\n  }\n  \n  // Evaluate the when expression\n  const result = await evaluateWhenExpression(variable.definition, evalEnv);\n  \n  // Cache result if not parameterized\n  if (!variable.metadata.hasParameters) {\n    variable.value = result.value;\n    variable.metadata.isEvaluated = true;\n    variable.metadata.evaluatedAt = new Date();\n  }\n  \n  return result.value;\n}\n\n/**\n * Peek at the type of a when expression without full evaluation\n * Used for type inference in var assignments\n */\nexport async function peekWhenExpressionType(\n  node: WhenExpressionNode,\n  env: Environment\n): Promise<import('@core/types/variable').VariableTypeDiscriminator> {\n  // Analyze action types without evaluation\n  const actionTypes = new Set<import('@core/types/variable').VariableTypeDiscriminator>();\n  \n  for (const pair of node.conditions) {\n    if (pair.action && pair.action.length > 0) {\n      // Simple heuristic based on first node type\n      const firstNode = pair.action[0];\n      \n      if (firstNode.type === 'Text') {\n        actionTypes.add('simple-text');\n      } else if (firstNode.type === 'Literal') {\n        const literal = firstNode as any;\n        if (typeof literal.value === 'number') {\n          actionTypes.add('primitive');\n        } else if (typeof literal.value === 'boolean') {\n          actionTypes.add('primitive');\n        } else if (literal.value === null) {\n          actionTypes.add('primitive');\n        }\n      } else if (firstNode.type === 'object') {\n        actionTypes.add('object');\n      } else if (firstNode.type === 'array') {\n        actionTypes.add('array');\n      } else if (firstNode.type === 'Directive') {\n        // Directives in expressions typically return computed values\n        actionTypes.add('computed');\n      } else {\n        // Default to computed for complex expressions\n        actionTypes.add('computed');\n      }\n    }\n  }\n  \n  // If all actions have same type, use that\n  if (actionTypes.size === 1) {\n    return Array.from(actionTypes)[0];\n  }\n  \n  // Mixed types or unknown - use computed\n  return 'computed';\n}"]}