@stacksjs/stx 0.2.95 → 0.2.96

package/dist/validator.js

@@ -1,2 +1,171 @@
-// @bun
-import{$s as c,Zs as a,_s as b,at as d,bt as e}from"./chunk-kx6eb6ma.js";import"./chunk-xv34zbp4.js";export{a as validateTemplate,c as validateDirective,d as hasDirectives,b as getPositionInfo,e as extractDirectiveNames};
+const DIRECTIVE_PAIRS = [
+  { open: "@if", close: "@endif", name: "if" },
+  { open: "@unless", close: "@endunless", name: "unless" },
+  { open: "@foreach", close: "@endforeach", name: "foreach" },
+  { open: "@for", close: "@endfor", name: "for" },
+  { open: "@while", close: "@endwhile", name: "while" },
+  { open: "@forelse", close: "@endforelse", name: "forelse" },
+  { open: "@switch", close: "@endswitch", name: "switch" },
+  { open: "@isset", close: "@endisset", name: "isset" },
+  { open: "@empty", close: "@endempty", name: "empty" },
+  { open: "@auth", close: "@endauth", name: "auth" },
+  { open: "@guest", close: "@endguest", name: "guest" },
+  { open: "@can", close: "@endcan", name: "can" },
+  { open: "@cannot", close: "@endcannot", name: "cannot" },
+  { open: "@section", close: "@endsection", name: "section", altClose: "@show" },
+  { open: "@push", close: "@endpush", name: "push" },
+  { open: "@prepend", close: "@endprepend", name: "prepend" },
+  { open: "@once", close: "@endonce", name: "once" },
+  { open: "@markdown", close: "@endmarkdown", name: "markdown" },
+  { open: "@component", close: "@endcomponent", name: "component" }
+], MALFORMED_DIRECTIVE_CHECKS = [
+  { pattern: /@if\s*[^(]/, message: "@if directive missing parentheses", suggestion: "Use @if(condition)" },
+  { pattern: /@foreach\s*[^(]/, message: "@foreach directive missing parentheses", suggestion: "Use @foreach(items as item)" },
+  { pattern: /@foreach\([^)]*\)\s*[^@\n<]/, message: "@foreach may have content on same line", suggestion: "Put content on new line after @foreach()" },
+  { pattern: /@include\s*[^(]/, message: "@include directive missing parentheses", suggestion: "Use @include('partial-name')" },
+  { pattern: /@extends\s*[^(]/, message: "@extends directive missing parentheses", suggestion: "Use @extends('layout-name') or @layout('layout-name')" },
+  { pattern: /@layout\s*[^(]/, message: "@layout directive missing parentheses", suggestion: "Use @layout('layout-name')" }
+], DANGEROUS_PATTERN_CHECKS = [
+  { pattern: /\{\{\s*constructor\s*\}\}/, message: "Attempting to access constructor property" },
+  { pattern: /\{\{\s*__proto__\s*\}\}/, message: "Attempting to access __proto__ property" },
+  { pattern: /\{\{\s*eval\s*\(/, message: "Attempting to use eval in expression" }
+];
+export function validateTemplate(template) {
+  const errors = [], warnings = [];
+  validateExpressionBrackets(template, errors);
+  validateDirectivePairs(template, errors, warnings);
+  validateDirectiveSyntax(template, warnings);
+  validateSecurityPatterns(template, errors);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateExpressionBrackets(template, errors) {
+  const expressionOpens = (template.match(/\{\{/g) || []).length, expressionCloses = (template.match(/\}\}/g) || []).length;
+  if (expressionOpens !== expressionCloses)
+    errors.push({
+      type: "expression",
+      message: `Unclosed expression brackets: found ${expressionOpens} opening '{{' and ${expressionCloses} closing '}}'`,
+      suggestion: "Ensure every {{ has a matching }}"
+    });
+}
+function validateDirectivePairs(template, errors, warnings) {
+  for (const pair of DIRECTIVE_PAIRS) {
+    const openRegex = new RegExp(`${pair.open}(?:\\s|\\()`, "g"), closeRegex = new RegExp(pair.close, "g"), openCount = (template.match(openRegex) || []).length;
+    let closeCount = (template.match(closeRegex) || []).length;
+    if (pair.altClose) {
+      const altCloseRegex = new RegExp(pair.altClose, "g");
+      closeCount += (template.match(altCloseRegex) || []).length;
+    }
+    if (openCount > closeCount)
+      errors.push({
+        type: "directive",
+        message: `Unclosed @${pair.name} directive: found ${openCount} opening and ${closeCount} closing`,
+        suggestion: `Add ${openCount - closeCount} missing ${pair.close} tag(s)`
+      });
+    else if (closeCount > openCount)
+      warnings.push({
+        type: "directive",
+        message: `Extra ${pair.close} found: ${closeCount - openCount} more closing than opening`,
+        suggestion: `Check for orphaned ${pair.close} tags`
+      });
+  }
+}
+function validateDirectiveSyntax(template, warnings) {
+  for (const check of MALFORMED_DIRECTIVE_CHECKS)
+    if (check.pattern.test(template))
+      warnings.push({
+        type: "syntax",
+        message: check.message,
+        suggestion: check.suggestion
+      });
+}
+function validateSecurityPatterns(template, errors) {
+  for (const check of DANGEROUS_PATTERN_CHECKS)
+    if (check.pattern.test(template))
+      errors.push({
+        type: "expression",
+        message: `Security warning: ${check.message}`,
+        suggestion: "Remove dangerous code from template expressions"
+      });
+}
+export function getPositionInfo(template, position) {
+  const lines = template.slice(0, position).split(`
+`);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+export function validateDirective(directiveName, content, params) {
+  const errors = [];
+  switch (directiveName) {
+    case "if":
+    case "elseif":
+    case "unless":
+      if (params.length === 0)
+        errors.push({
+          type: "syntax",
+          message: `@${directiveName} requires a condition`,
+          suggestion: `Use @${directiveName}(condition)`
+        });
+      break;
+    case "foreach":
+      if (params.length === 0 || !params[0].includes(" as "))
+        errors.push({
+          type: "syntax",
+          message: '@foreach requires "items as item" syntax',
+          suggestion: "Use @foreach(items as item) or @foreach(items as key => value)"
+        });
+      break;
+    case "for":
+      if (params.length === 0)
+        errors.push({
+          type: "syntax",
+          message: "@for requires loop parameters",
+          suggestion: "Use @for(let i = 0; i < 10; i++)"
+        });
+      break;
+    case "switch":
+      if (params.length === 0)
+        errors.push({
+          type: "syntax",
+          message: "@switch requires an expression",
+          suggestion: "Use @switch(expression)"
+        });
+      break;
+    case "case":
+      if (params.length === 0)
+        errors.push({
+          type: "syntax",
+          message: "@case requires a value",
+          suggestion: "Use @case(value)"
+        });
+      break;
+    case "include":
+    case "extends":
+    case "component":
+      if (params.length === 0)
+        errors.push({
+          type: "syntax",
+          message: `@${directiveName} requires a path`,
+          suggestion: `Use @${directiveName}('path/to/template')`
+        });
+      break;
+  }
+  return errors;
+}
+export function hasDirectives(template) {
+  return /@[a-z]+/i.test(template) || /\{\{/.test(template);
+}
+export function extractDirectiveNames(template) {
+  const matches = template.matchAll(/@([a-z]+)/gi), names = new Set;
+  for (const match of matches) {
+    const name = match[1].toLowerCase();
+    if (!name.startsWith("end"))
+      names.add(name);
+  }
+  return Array.from(names);
+}