mlld/dist/ast-evaluator-TR7L7WV6.mjs

mlld: llm scripting language

import { __name } from './chunk-NJQT543K.mjs';

// interpreter/core/ast-evaluator.ts
async function interpolateAndRecord(nodes, env) {
  const { interpolate } = await import('./interpreter-MW7QI3FC.mjs');
  const descriptors = [];
  const text = await interpolate(nodes, env, void 0, {
    collectSecurityDescriptor: /* @__PURE__ */ __name((descriptor) => {
      if (descriptor) {
        descriptors.push(descriptor);
      }
    }, "collectSecurityDescriptor")
  });
  if (descriptors.length > 0) {
    const merged = descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);
    env.recordSecurityDescriptor(merged);
  }
  return text;
}
__name(interpolateAndRecord, "interpolateAndRecord");
var _ASTEvaluator = class _ASTEvaluator {
  /**
  * Normalize an array value to have consistent type information
  */
  static normalizeArray(value) {
    if (value && typeof value === "object" && value.type === "array") {
      return value;
    }
    if (Array.isArray(value)) {
      return {
        type: "array",
        items: value.map((item) => this.normalizeValue(item)),
        location: {
          synthetic: true
        }
      };
    }
    throw new Error(`Expected array, got ${typeof value}`);
  }
  /**
  * Normalize an object value to have consistent type information
  */
  static normalizeObject(value) {
    if (value && typeof value === "object" && value.type === "object") {
      return value;
    }
    if (typeof value === "object" && value !== null && value.constructor === Object) {
      const properties = {};
      for (const [key, val] of Object.entries(value)) {
        if (key === "wrapperType" || key === "nodeId" || key === "location") {
          continue;
        }
        properties[key] = this.normalizeValue(val);
      }
      return {
        type: "object",
        properties,
        location: {
          synthetic: true
        }
      };
    }
    throw new Error(`Expected object, got ${typeof value}`);
  }
  /**
  * Normalize any value - Phase 2: Extended for objects
  */
  static normalizeValue(value) {
    if (value === null || value === void 0) {
      return value;
    }
    if (value && typeof value === "object" && "wrapperType" in value && "content" in value && Array.isArray(value.content)) {
      if (value.content.length > 0 && value.content[0].type === "Text") {
        return value.content[0].content;
      }
      if (value.content.length === 0) {
        return "";
      }
      return value;
    }
    if (value && typeof value === "object" && value.type === "Text" && "content" in value) {
      return value.content;
    }
    if (Array.isArray(value)) {
      return this.normalizeArray(value);
    }
    if (typeof value === "object" && value !== null && value.constructor === Object && !value.type) {
      return this.normalizeObject(value);
    }
    return value;
  }
  /**
  * Evaluate a value to runtime representation
  * Phase 2: Extended for objects and arrays
  */
  static async evaluateToRuntime(value, env) {
    if (value === null || value === void 0) {
      return value;
    }
    const normalized = this.normalizeValue(value);
    if (normalized && normalized.type === "array") {
      const evaluatedItems = [];
      for (const item of normalized.items) {
        evaluatedItems.push(await this.evaluateToRuntime(item, env));
      }
      return evaluatedItems;
    }
    if (normalized && normalized.type === "object") {
      const evaluatedObject = {};
      if (normalized.entries) {
        for (const entry of normalized.entries) {
          if (entry.type === "pair") {
            evaluatedObject[entry.key] = await this.evaluateToRuntime(entry.value, env);
          } else if (entry.type === "spread") {
            const varName = await interpolateAndRecord(entry.value, env);
            const spreadVar = env.getVariable(varName);
            if (spreadVar) {
              const spreadValue = spreadVar.value !== void 0 ? spreadVar.value : spreadVar;
              if (typeof spreadValue === "object" && spreadValue !== null && !Array.isArray(spreadValue)) {
                Object.assign(evaluatedObject, spreadValue);
              }
            }
          }
        }
      } else if (normalized.properties) {
        for (const [key, val] of Object.entries(normalized.properties)) {
          evaluatedObject[key] = await this.evaluateToRuntime(val, env);
        }
      }
      return evaluatedObject;
    }
    if (normalized && typeof normalized === "object" && "wrapperType" in normalized && "content" in normalized) {
      return await interpolateAndRecord(normalized.content, env);
    }
    return normalized;
  }
};
__name(_ASTEvaluator, "ASTEvaluator");
var ASTEvaluator = _ASTEvaluator;

export { ASTEvaluator };
//# sourceMappingURL=ast-evaluator-TR7L7WV6.mjs.map
//# sourceMappingURL=ast-evaluator-TR7L7WV6.mjs.map