@frontmcp/uipack 0.12.2 → 1.0.0-beta.10

package/esm/validation/index.mjs

@@ -1,542 +0,0 @@
-// libs/uipack/src/utils/index.ts
-import {
-  safeStringify,
-  escapeHtml,
-  escapeHtmlAttr,
-  escapeJsString,
-  escapeScriptClose,
-  safeJsonForScript
-} from "@frontmcp/utils";
-
-// libs/uipack/src/validation/error-box.ts
-var errorIcon = `<svg class="w-5 h-5 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true">
-  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/>
-</svg>`;
-function validationErrorBox(options) {
-  const { componentName, invalidParam } = options;
-  return `<div
-  class="validation-error flex items-start gap-3 p-4 bg-red-50 border border-red-200 text-red-800 rounded-lg"
-  role="alert"
-  data-testid="validation-error"
-  data-component="${escapeHtml(componentName)}"
-  data-param="${escapeHtml(invalidParam)}"
->
-  ${errorIcon}
-  <div class="min-w-0">
-    <p class="font-semibold text-sm">${escapeHtml(componentName)}: Invalid Configuration</p>
-    <p class="text-sm opacity-90 mt-0.5">The "${escapeHtml(invalidParam)}" parameter is invalid.</p>
-  </div>
-</div>`;
-}
-
-// libs/uipack/src/validation/wrapper.ts
-function getFirstInvalidPath(error) {
-  const firstError = error.issues[0];
-  if (!firstError || firstError.path.length === 0) {
-    return "options";
-  }
-  return firstError.path.map(String).join(".");
-}
-function validateOptions(options, config) {
-  const result = config.schema.safeParse(options);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  const invalidParam = getFirstInvalidPath(result.error);
-  return {
-    success: false,
-    error: validationErrorBox({
-      componentName: config.componentName,
-      invalidParam
-    })
-  };
-}
-
-// libs/uipack/src/validation/schema-paths.ts
-import { z } from "zod";
-function extractSchemaPaths(schema, prefix = "output", options = {}) {
-  const { maxDepth = 10, includeArrayItems = true } = options;
-  const paths = [];
-  const visited = /* @__PURE__ */ new Set();
-  function recurse(currentSchema, currentPath, depth, isOptional, isNullable, isArrayItem) {
-    if (depth > maxDepth) return;
-    const pathKey = `${currentPath}:${depth}`;
-    if (visited.has(pathKey)) return;
-    visited.add(pathKey);
-    const description = currentSchema.description;
-    const innerType = unwrapType(currentSchema);
-    paths.push({
-      path: currentPath,
-      zodType: currentSchema,
-      optional: isOptional,
-      nullable: isNullable,
-      isArrayItem,
-      description
-    });
-    if (innerType instanceof z.ZodObject) {
-      const shape = innerType.shape;
-      for (const [key, value] of Object.entries(shape)) {
-        const childSchema = value;
-        const childOptional = isOptional || isOptionalType(childSchema);
-        const childNullable = isNullable || isNullableType(childSchema);
-        recurse(childSchema, `${currentPath}.${key}`, depth + 1, childOptional, childNullable, false);
-      }
-    } else if (innerType instanceof z.ZodArray && includeArrayItems) {
-      const itemSchema = innerType.element;
-      recurse(itemSchema, `${currentPath}.[]`, depth + 1, isOptional, isNullable, true);
-    } else if (innerType instanceof z.ZodUnion || innerType instanceof z.ZodDiscriminatedUnion) {
-      const options2 = "options" in innerType ? innerType.options : [];
-      for (const option of options2) {
-        recurse(option, currentPath, depth, isOptional, isNullable, isArrayItem);
-      }
-    } else if (innerType instanceof z.ZodIntersection) {
-      recurse(innerType._def.left, currentPath, depth, isOptional, isNullable, isArrayItem);
-      recurse(innerType._def.right, currentPath, depth, isOptional, isNullable, isArrayItem);
-    } else if (innerType instanceof z.ZodRecord) {
-      const valueSchema = innerType._def.valueType;
-      recurse(valueSchema, `${currentPath}.[]`, depth + 1, isOptional, isNullable, true);
-    } else if (innerType instanceof z.ZodTuple) {
-      const items = innerType._def.items;
-      items.forEach((item, index) => {
-        recurse(item, `${currentPath}.${index}`, depth + 1, isOptional, isNullable, true);
-      });
-    }
-  }
-  recurse(schema, prefix, 0, false, false, false);
-  const seen = /* @__PURE__ */ new Set();
-  return paths.filter((p) => {
-    if (seen.has(p.path)) return false;
-    seen.add(p.path);
-    return true;
-  });
-}
-function unwrapType(schema) {
-  if (schema instanceof z.ZodOptional) {
-    return unwrapType(schema.unwrap());
-  }
-  if (schema instanceof z.ZodNullable) {
-    return unwrapType(schema.unwrap());
-  }
-  if (schema instanceof z.ZodDefault) {
-    return unwrapType(schema._def.innerType);
-  }
-  if (schema instanceof z.ZodCatch && "innerType" in schema._def) {
-    return unwrapType(schema._def.innerType);
-  }
-  return schema;
-}
-function isOptionalType(schema) {
-  if (schema instanceof z.ZodOptional) return true;
-  if (schema instanceof z.ZodDefault) return true;
-  if (schema instanceof z.ZodNullable) return isOptionalType(schema.unwrap());
-  return false;
-}
-function isNullableType(schema) {
-  if (schema instanceof z.ZodNullable) return true;
-  if (schema instanceof z.ZodOptional) return isNullableType(schema.unwrap());
-  return false;
-}
-function getSchemaPathStrings(schema, prefix = "output") {
-  const paths = extractSchemaPaths(schema, prefix);
-  return new Set(paths.map((p) => p.path));
-}
-function isValidSchemaPath(schema, path) {
-  const prefix = path.split(".")[0];
-  const paths = getSchemaPathStrings(schema, prefix);
-  if (paths.has(path)) return true;
-  const normalizedPath = normalizePath(path);
-  if (paths.has(normalizedPath)) return true;
-  const pathParts = path.split(".");
-  for (let i = pathParts.length - 1; i >= 0; i--) {
-    const part = pathParts[i];
-    if (/^\d+$/.test(part)) {
-      const parentPath = pathParts.slice(0, i).join(".");
-      const wildcardPath = `${parentPath}.[]`;
-      if (paths.has(wildcardPath)) {
-        const restPath = pathParts.slice(i + 1).join(".");
-        if (restPath) {
-          const fullWildcardPath = `${wildcardPath}.${restPath}`;
-          const normalizedFullPath = normalizePath(fullWildcardPath);
-          if (paths.has(normalizedFullPath)) return true;
-        } else {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function normalizePath(path) {
-  return path.replace(/\.\d+\./g, ".[].").replace(/\.\d+$/g, ".[]").replace(/\[\d+\]/g, ".[]");
-}
-function getTypeAtPath(schema, path) {
-  const prefix = path.split(".")[0];
-  const paths = extractSchemaPaths(schema, prefix);
-  let schemaPath = paths.find((p) => p.path === path);
-  if (!schemaPath) {
-    const normalizedPath = normalizePath(path);
-    schemaPath = paths.find((p) => p.path === normalizedPath);
-  }
-  return schemaPath?.zodType;
-}
-function getPathInfo(schema, path) {
-  const prefix = path.split(".")[0];
-  const paths = extractSchemaPaths(schema, prefix);
-  let schemaPath = paths.find((p) => p.path === path);
-  if (!schemaPath) {
-    const normalizedPath = normalizePath(path);
-    schemaPath = paths.find((p) => p.path === normalizedPath);
-  }
-  return schemaPath;
-}
-function getRootFieldNames(schema) {
-  const unwrapped = unwrapType(schema);
-  if (unwrapped instanceof z.ZodObject) {
-    return Object.keys(unwrapped.shape);
-  }
-  return [];
-}
-function getTypeDescription(schema, path) {
-  const zodType = getTypeAtPath(schema, path);
-  if (!zodType) return "unknown";
-  return describeZodType(zodType);
-}
-function describeZodType(schema) {
-  const inner = unwrapType(schema);
-  if (inner instanceof z.ZodString) return "string";
-  if (inner instanceof z.ZodNumber) return "number";
-  if (inner instanceof z.ZodBoolean) return "boolean";
-  if (inner instanceof z.ZodDate) return "Date";
-  if (inner instanceof z.ZodBigInt) return "bigint";
-  if (inner instanceof z.ZodSymbol) return "symbol";
-  if (inner instanceof z.ZodUndefined) return "undefined";
-  if (inner instanceof z.ZodNull) return "null";
-  if (inner instanceof z.ZodVoid) return "void";
-  if (inner instanceof z.ZodAny) return "any";
-  if (inner instanceof z.ZodUnknown) return "unknown";
-  if (inner instanceof z.ZodNever) return "never";
-  if (inner instanceof z.ZodLiteral) return `literal(${JSON.stringify(inner.value)})`;
-  if (inner instanceof z.ZodEnum) return `enum(${inner.options.join(" | ")})`;
-  if (inner instanceof z.ZodArray) return `${describeZodType(inner.element)}[]`;
-  if (inner instanceof z.ZodObject) return "object";
-  if (inner instanceof z.ZodUnion) return "union";
-  if (inner instanceof z.ZodDiscriminatedUnion) return "discriminatedUnion";
-  if (inner instanceof z.ZodIntersection) return "intersection";
-  if (inner instanceof z.ZodTuple) return "tuple";
-  if (inner instanceof z.ZodRecord) return `Record<string, ${describeZodType(inner._def.valueType)}>`;
-  if (inner instanceof z.ZodMap) return "Map";
-  if (inner instanceof z.ZodSet) return "Set";
-  if (inner instanceof z.ZodFunction) return "function";
-  if (inner instanceof z.ZodPromise) return "Promise";
-  if (schema instanceof z.ZodOptional) {
-    return `${describeZodType(schema.unwrap())}?`;
-  }
-  if (schema instanceof z.ZodNullable) {
-    return `${describeZodType(schema.unwrap())} | null`;
-  }
-  return "unknown";
-}
-
-// libs/uipack/src/handlebars/expression-extractor.ts
-var EXPRESSION_REGEX = /\{\{\{?(?!!)(#|\/)?([^}]+?)\}?\}\}/g;
-var PATH_REGEX = /\b(output|input|structuredContent)(\.[a-zA-Z_$][a-zA-Z0-9_$]*|\.\[[^\]]+\])+/g;
-var KEYWORDS = /* @__PURE__ */ new Set(["this", "else", "@index", "@key", "@first", "@last", "@root"]);
-function extractExpressions(template) {
-  const expressions = [];
-  const positionMap = buildPositionMap(template);
-  let match;
-  EXPRESSION_REGEX.lastIndex = 0;
-  while ((match = EXPRESSION_REGEX.exec(template)) !== null) {
-    const fullExpression = match[0];
-    const prefix = match[1];
-    const content = match[2].trim();
-    const position = positionMap.get(match.index) ?? { line: 1, column: 1 };
-    let type = "variable";
-    let helperName;
-    if (prefix === "/") {
-      type = "block-close";
-      helperName = content;
-    } else if (prefix === "#") {
-      type = "block";
-      const parts = content.split(/\s+/);
-      helperName = parts[0];
-    } else {
-      const parts = content.split(/\s+/);
-      if (parts.length > 1 && !content.startsWith("(")) {
-        const firstToken = parts[0];
-        if (!firstToken.includes(".") && !KEYWORDS.has(firstToken)) {
-          type = "helper";
-          helperName = firstToken;
-        }
-      }
-    }
-    const paths = extractPathsFromContent(content);
-    for (const path of paths) {
-      expressions.push({
-        path,
-        fullExpression,
-        line: position.line,
-        column: position.column,
-        type,
-        helperName
-      });
-    }
-    if (paths.length === 0 && type === "variable") {
-      const cleanContent = content.trim();
-      if (!KEYWORDS.has(cleanContent) && !cleanContent.includes(" ") && !cleanContent.startsWith("(")) {
-      }
-    }
-  }
-  return expressions;
-}
-function extractPathsFromContent(content) {
-  const paths = [];
-  let match;
-  const regex = new RegExp(PATH_REGEX.source, "g");
-  while ((match = regex.exec(content)) !== null) {
-    paths.push(match[0]);
-  }
-  return paths;
-}
-function buildPositionMap(template) {
-  const map = /* @__PURE__ */ new Map();
-  let line = 1;
-  let column = 1;
-  for (let i = 0; i < template.length; i++) {
-    map.set(i, { line, column });
-    if (template[i] === "\n") {
-      line++;
-      column = 1;
-    } else {
-      column++;
-    }
-  }
-  return map;
-}
-function extractAll(template) {
-  const expressions = extractExpressions(template);
-  const paths = [...new Set(expressions.map((e) => e.path))];
-  return {
-    expressions,
-    paths,
-    outputPaths: paths.filter((p) => p.startsWith("output.")),
-    inputPaths: paths.filter((p) => p.startsWith("input.")),
-    structuredContentPaths: paths.filter((p) => p.startsWith("structuredContent."))
-  };
-}
-function normalizePath2(path) {
-  return path.replace(/\.\d+\./g, ".[].").replace(/\.\d+$/g, ".[]").replace(/\[\d+\]/g, ".[]");
-}
-
-// libs/uipack/src/validation/template-validator.ts
-function validateTemplate(template, outputSchema, options = {}) {
-  const { inputSchema, warnOnOptional = true, suggestSimilar = true, maxSuggestionDistance = 3 } = options;
-  const errors = [];
-  const warnings = [];
-  const extraction = extractAll(template);
-  const expressions = extractExpressions(template);
-  const outputPaths = getSchemaPathStrings(outputSchema, "output");
-  const inputPaths = inputSchema ? getSchemaPathStrings(inputSchema, "input") : /* @__PURE__ */ new Set();
-  const outputPathInfos = extractSchemaPaths(outputSchema, "output");
-  const inputPathInfos = inputSchema ? extractSchemaPaths(inputSchema, "input") : [];
-  const pathInfoMap = /* @__PURE__ */ new Map();
-  for (const info of [...outputPathInfos, ...inputPathInfos]) {
-    pathInfoMap.set(info.path, info);
-  }
-  for (const expr of expressions) {
-    const { path, fullExpression, line, column } = expr;
-    let validPaths;
-    let allPaths;
-    if (path.startsWith("output.")) {
-      validPaths = outputPaths;
-      allPaths = Array.from(outputPaths);
-    } else if (path.startsWith("input.")) {
-      if (!inputSchema) {
-        continue;
-      }
-      validPaths = inputPaths;
-      allPaths = Array.from(inputPaths);
-    } else if (path.startsWith("structuredContent.")) {
-      continue;
-    } else {
-      continue;
-    }
-    const normalizedPath = normalizePath2(path);
-    const isValid = validPaths.has(path) || validPaths.has(normalizedPath);
-    if (!isValid) {
-      const isArrayAccess = checkArrayAccess(path, validPaths);
-      if (!isArrayAccess) {
-        const suggestions = suggestSimilar ? findSimilarPaths(path, allPaths, maxSuggestionDistance) : [];
-        errors.push({
-          type: "missing_field",
-          path,
-          expression: fullExpression,
-          line,
-          column,
-          message: `Field '${getFieldName(path)}' does not exist in ${getSchemaName(path)} schema`,
-          suggestions
-        });
-      }
-    } else {
-      const pathInfo = pathInfoMap.get(path) ?? pathInfoMap.get(normalizedPath);
-      if (pathInfo && warnOnOptional) {
-        if (pathInfo.optional && expr.type === "variable") {
-          const hasGuard = hasConditionalGuard(template, path);
-          if (!hasGuard) {
-            warnings.push({
-              type: "optional_field",
-              path,
-              expression: fullExpression,
-              line,
-              message: `Accessing optional field '${getFieldName(path)}' without {{#if}} guard`
-            });
-          }
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    templatePaths: extraction.paths,
-    schemaPaths: [...outputPaths, ...inputPaths]
-  };
-}
-function checkArrayAccess(path, validPaths) {
-  const parts = path.split(".");
-  for (let i = 0; i < parts.length; i++) {
-    if (/^\d+$/.test(parts[i])) {
-      const wildcardParts = [...parts];
-      wildcardParts[i] = "[]";
-      const wildcardPath = wildcardParts.join(".");
-      if (validPaths.has(wildcardPath)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function getFieldName(path) {
-  const parts = path.split(".");
-  return parts[parts.length - 1];
-}
-function getSchemaName(path) {
-  if (path.startsWith("output.")) return "output";
-  if (path.startsWith("input.")) return "input";
-  if (path.startsWith("structuredContent.")) return "structuredContent";
-  return "unknown";
-}
-function hasConditionalGuard(template, path) {
-  const guardPattern = new RegExp(`\\{\\{#if\\s+${escapeRegex(path)}`, "i");
-  return guardPattern.test(template);
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findSimilarPaths(path, validPaths, maxDistance) {
-  const fieldName = getFieldName(path);
-  const prefix = path.substring(0, path.lastIndexOf(".") + 1);
-  const suggestions = [];
-  for (const validPath of validPaths) {
-    if (!validPath.startsWith(prefix)) continue;
-    const validFieldName = getFieldName(validPath);
-    const distance = levenshteinDistance(fieldName, validFieldName);
-    if (distance <= maxDistance && distance > 0) {
-      suggestions.push({ path: validPath, distance });
-    }
-  }
-  return suggestions.sort((a, b) => a.distance - b.distance).slice(0, 3).map((s) => s.path);
-}
-function levenshteinDistance(a, b) {
-  const matrix = [];
-  for (let i = 0; i <= a.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= b.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,
-        // deletion
-        matrix[i][j - 1] + 1,
-        // insertion
-        matrix[i - 1][j - 1] + cost
-        // substitution
-      );
-    }
-  }
-  return matrix[a.length][b.length];
-}
-function formatValidationWarnings(result, toolName) {
-  if (result.valid && result.warnings.length === 0) {
-    return "";
-  }
-  const lines = [];
-  if (result.errors.length > 0) {
-    lines.push(`[FrontMCP] Template validation warnings for tool "${toolName}":`);
-    lines.push("");
-    for (const error of result.errors) {
-      lines.push(`  Line ${error.line}: ${error.expression}`);
-      lines.push(`    ${error.message}`);
-      if (error.suggestions.length > 0) {
-        lines.push(`    Did you mean: ${error.suggestions.join(", ")}?`);
-      }
-      lines.push("");
-    }
-    const outputFields = result.schemaPaths.filter((p) => p.startsWith("output.") && p.split(".").length === 2).map((p) => p.replace("output.", ""));
-    if (outputFields.length > 0) {
-      lines.push(`  Available output fields: ${outputFields.join(", ")}`);
-    }
-  }
-  if (result.warnings.length > 0) {
-    if (lines.length > 0) lines.push("");
-    lines.push(`  Warnings:`);
-    for (const warning of result.warnings) {
-      lines.push(`    Line ${warning.line}: ${warning.message}`);
-    }
-  }
-  return lines.join("\n");
-}
-function logValidationWarnings(result, toolName) {
-  const formatted = formatValidationWarnings(result, toolName);
-  if (formatted) {
-    console.warn(formatted);
-  }
-}
-function assertTemplateValid(template, outputSchema, toolName) {
-  const result = validateTemplate(template, outputSchema);
-  if (!result.valid) {
-    const formatted = formatValidationWarnings(result, toolName);
-    throw new Error(`Template validation failed for tool "${toolName}":
-${formatted}`);
-  }
-}
-function isTemplateValid(template, outputSchema) {
-  const result = validateTemplate(template, outputSchema);
-  return result.valid;
-}
-function getMissingFields(template, outputSchema) {
-  const result = validateTemplate(template, outputSchema);
-  return result.errors.map((e) => e.path);
-}
-export {
-  assertTemplateValid,
-  extractSchemaPaths,
-  formatValidationWarnings,
-  getMissingFields,
-  getPathInfo,
-  getRootFieldNames,
-  getSchemaPathStrings,
-  getTypeAtPath,
-  getTypeDescription,
-  isTemplateValid,
-  isValidSchemaPath,
-  logValidationWarnings,
-  validateOptions,
-  validateTemplate,
-  validationErrorBox
-};

package/handlebars/expression-extractor.d.ts

@@ -1,147 +0,0 @@
-/**
- * Handlebars Expression Extractor
- *
- * Extracts variable paths from Handlebars templates for validation
- * against schemas.
- *
- * @packageDocumentation
- */
-/**
- * Type of Handlebars expression.
- */
-export type ExpressionType = 'variable' | 'helper' | 'block' | 'block-close';
-/**
- * Extracted expression with metadata.
- */
-export interface ExtractedExpression {
-    /** The variable path (e.g., "output.temperature") */
-    path: string;
-    /** The full expression (e.g., "{{output.temperature}}") */
-    fullExpression: string;
-    /** Line number in template (1-indexed) */
-    line: number;
-    /** Column position (1-indexed) */
-    column: number;
-    /** Type of expression */
-    type: ExpressionType;
-    /** For helpers, the helper name */
-    helperName?: string;
-}
-/**
- * Result of expression extraction.
- */
-export interface ExtractionResult {
-    /** All extracted expressions */
-    expressions: ExtractedExpression[];
-    /** Unique variable paths */
-    paths: string[];
-    /** Paths starting with "output." */
-    outputPaths: string[];
-    /** Paths starting with "input." */
-    inputPaths: string[];
-    /** Paths starting with "structuredContent." */
-    structuredContentPaths: string[];
-}
-/**
- * Extract all Handlebars expressions from a template.
- *
- * @param template - Handlebars template string
- * @returns Array of extracted expressions with metadata
- *
- * @example
- * ```typescript
- * const expressions = extractExpressions('<div>{{output.name}}</div>');
- * // [{ path: 'output.name', fullExpression: '{{output.name}}', ... }]
- * ```
- */
-export declare function extractExpressions(template: string): ExtractedExpression[];
-/**
- * Extract all variable paths from a template.
- *
- * @param template - Handlebars template string
- * @returns Array of unique variable paths
- *
- * @example
- * ```typescript
- * const paths = extractVariablePaths('<div>{{output.a}} {{input.b}}</div>');
- * // ['output.a', 'input.b']
- * ```
- */
-export declare function extractVariablePaths(template: string): string[];
-/**
- * Extract only output.* paths from a template.
- *
- * @param template - Handlebars template string
- * @returns Array of unique output paths
- *
- * @example
- * ```typescript
- * const paths = extractOutputPaths('<div>{{output.temp}} {{input.city}}</div>');
- * // ['output.temp']
- * ```
- */
-export declare function extractOutputPaths(template: string): string[];
-/**
- * Extract only input.* paths from a template.
- *
- * @param template - Handlebars template string
- * @returns Array of unique input paths
- */
-export declare function extractInputPaths(template: string): string[];
-/**
- * Extract only structuredContent.* paths from a template.
- *
- * @param template - Handlebars template string
- * @returns Array of unique structuredContent paths
- */
-export declare function extractStructuredContentPaths(template: string): string[];
-/**
- * Comprehensive extraction returning all path categories.
- *
- * @param template - Handlebars template string
- * @returns Extraction result with categorized paths
- *
- * @example
- * ```typescript
- * const result = extractAll('<div>{{output.a}} {{input.b}}</div>');
- * // {
- * //   expressions: [...],
- * //   paths: ['output.a', 'input.b'],
- * //   outputPaths: ['output.a'],
- * //   inputPaths: ['input.b'],
- * //   structuredContentPaths: []
- * // }
- * ```
- */
-export declare function extractAll(template: string): ExtractionResult;
-/**
- * Check if a template contains any Handlebars expressions with variable paths.
- *
- * @param template - Handlebars template string
- * @returns true if template contains variable paths
- */
-export declare function hasVariablePaths(template: string): boolean;
-/**
- * Get expression details at a specific line and column.
- *
- * @param template - Handlebars template string
- * @param line - Line number (1-indexed)
- * @param column - Column number (1-indexed)
- * @returns Expression at position or undefined
- */
-export declare function getExpressionAt(template: string, line: number, column: number): ExtractedExpression | undefined;
-/**
- * Normalize a path for comparison.
- * Converts array index access to wildcard format.
- *
- * @param path - Variable path
- * @returns Normalized path
- *
- * @example
- * ```typescript
- * normalizePath('output.items.0.name'); // 'output.items.[].name'
- * normalizePath('output.data[0].value'); // 'output.data.[].value'
- * ```
- */
-export declare function normalizePath(path: string): string;
-//# sourceMappingURL=expression-extractor.d.ts.map

package/handlebars/expression-extractor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expression-extractor.d.ts","sourceRoot":"","sources":["../../src/handlebars/expression-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,yBAAyB;IACzB,IAAI,EAAE,cAAc,CAAC;IACrB,mCAAmC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,4BAA4B;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oCAAoC;IACpC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mCAAmC;IACnC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,+CAA+C;IAC/C,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC;AAwCD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAkE1E;AAgDD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAExE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAW7D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAS/G;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQlD"}