mlld/dist/chunk-DUS6QZAC.mjs

mlld: llm scripting language

import { isExecutableVariable, isStructuredValue, asData, asText } from './chunk-RKGZ44GZ.mjs';
import { isPipelineInput, isStructured, isPrimitive, isTextLike, isPath, isImported, isComputed } from './chunk-EIWSEMQ4.mjs';
import { __name } from './chunk-NJQT543K.mjs';

// interpreter/utils/variable-resolution.ts
var ResolutionContext = /* @__PURE__ */ function(ResolutionContext2) {
  ResolutionContext2["VariableAssignment"] = "variable-assignment";
  ResolutionContext2["VariableCopy"] = "variable-copy";
  ResolutionContext2["ArrayElement"] = "array-element";
  ResolutionContext2["ObjectProperty"] = "object-property";
  ResolutionContext2["FunctionArgument"] = "function-argument";
  ResolutionContext2["DataStructure"] = "data-structure";
  ResolutionContext2["FieldAccess"] = "field-access";
  ResolutionContext2["ImportResult"] = "import-result";
  ResolutionContext2["StringInterpolation"] = "string-interpolation";
  ResolutionContext2["CommandExecution"] = "command-execution";
  ResolutionContext2["FileOutput"] = "file-output";
  ResolutionContext2["Conditional"] = "conditional";
  ResolutionContext2["Display"] = "display";
  ResolutionContext2["PipelineInput"] = "pipeline-input";
  ResolutionContext2["Truthiness"] = "truthiness";
  ResolutionContext2["Equality"] = "equality";
  return ResolutionContext2;
}({});
function shouldPreserveVariable(context) {
  switch (context) {
    // Preserve Variable wrapper contexts
    case "variable-assignment":
    case "variable-copy":
    case "array-element":
    case "object-property":
    case "function-argument":
    case "data-structure":
    case "field-access":
    case "import-result":
      return true;
    // Extract raw value contexts
    case "string-interpolation":
    case "command-execution":
    case "file-output":
    case "conditional":
    case "display":
    case "pipeline-input":
    case "truthiness":
    case "equality":
      return false;
    default:
      return false;
  }
}
__name(shouldPreserveVariable, "shouldPreserveVariable");
async function resolveVariable(variable, env, context = "display") {
  if (isPipelineInput(variable) && context === "pipeline-input") {
    return variable.value;
  }
  if (shouldPreserveVariable(context)) {
    if (isStructured(variable)) {
      const complexFlag = variable.isComplex;
      if (complexFlag) {
        const { evaluateDataValue } = await import('./data-value-evaluator-6G4NQGOF.mjs');
        const evaluatedValue = await evaluateDataValue(variable.value, env);
        const evaluatedAt = Date.now();
        return {
          ...variable,
          value: evaluatedValue,
          mx: {
            ...variable.mx
          },
          internal: {
            ...variable.internal ?? {},
            wasEvaluated: true,
            evaluatedAt
          }
        };
      }
    }
    if (isExecutableVariable(variable)) {
      return variable;
    }
    return variable;
  }
  const extracted = await extractVariableValue(variable, env);
  if (!isStructuredValue(extracted)) {
    return extracted;
  }
  if (context === "equality") {
    return asData(extracted);
  }
  if (context === "command-execution") {
    return asText(extracted);
  }
  return extracted;
}
__name(resolveVariable, "resolveVariable");
async function extractVariableValue(variable, env) {
  if (isPrimitive(variable)) {
    return variable.value;
  } else if (isTextLike(variable)) {
    return variable.value;
  } else if (isStructured(variable)) {
    const complexFlag = variable.isComplex;
    if (complexFlag) {
      const { evaluateDataValue } = await import('./data-value-evaluator-6G4NQGOF.mjs');
      const evaluatedValue = await evaluateDataValue(variable.value, env);
      return evaluatedValue;
    }
    const arrayType = variable.internal?.arrayType;
    if (variable.type === "array" && arrayType && (arrayType === "renamed-content" || arrayType === "load-content-result")) {
      const { extractVariableValue: extractWithBehaviors } = await import('./variable-migration-2P4Z3L4P.mjs');
      return extractWithBehaviors(variable);
    }
    return variable.value;
  } else if ((variable.type === "object" || variable.type === "array") && variable.isComplex) {
    if (process.env.MLLD_DEBUG_FIX === "true") {
      console.error("[extractVariableValue] evaluating complex collection", {
        name: variable.name,
        type: variable.type,
        isComplex: variable.isComplex,
        valuePreview: variable.value && typeof variable.value === "object" ? {
          type: variable.value.type,
          keys: Object.keys(variable.value || {})
        } : typeof variable.value
      });
    }
    const { evaluateDataValue } = await import('./data-value-evaluator-6G4NQGOF.mjs');
    return await evaluateDataValue(variable.value, env);
  } else if (isPath(variable)) {
    return variable.value.resolvedPath;
  } else if (isPipelineInput(variable)) {
    return variable.value;
  } else if (isExecutableVariable(variable)) {
    const { evaluateExecInvocation } = await import('./exec-invocation-M54PNM33.mjs');
    const invocation = {
      type: "ExecInvocation",
      commandRef: {
        identifier: variable.name,
        args: []
      }
    };
    const result = await evaluateExecInvocation(invocation, env);
    return result.value;
  } else if (isImported(variable)) {
    return variable.value;
  } else if (isComputed(variable)) {
    return variable.value;
  }
  return variable.value;
}
__name(extractVariableValue, "extractVariableValue");
function isVariable(value) {
  return value !== null && typeof value === "object" && "type" in value && "name" in value && "value" in value && "source" in value;
}
__name(isVariable, "isVariable");
async function resolveValue(value, env, context) {
  if (isVariable(value)) {
    return resolveVariable(value, env, context);
  }
  return value;
}
__name(resolveValue, "resolveValue");

export { ResolutionContext, extractVariableValue, isVariable, resolveValue, resolveVariable, shouldPreserveVariable };
//# sourceMappingURL=chunk-DUS6QZAC.mjs.map
//# sourceMappingURL=chunk-DUS6QZAC.mjs.map