@stacksjs/stx 0.2.94 → 0.2.96

package/dist/analytics.js

@@ -1,2 +1,159 @@
-// @bun
-import{mA as a,nA as b,oA as c}from"./chunk-gcf5v18y.js";import"./chunk-3jm3snz8.js";export{b as injectAnalytics,a as generateAnalyticsScript,c as analyticsDirective};
+export function generateAnalyticsScript(options) {
+  const analytics = options.analytics;
+  if (!analytics?.enabled)
+    return "";
+  switch (analytics.driver) {
+    case "fathom":
+      return generateFathomScript(analytics);
+    case "google-analytics":
+      return generateGoogleAnalyticsScript(analytics);
+    case "plausible":
+      return generatePlausibleScript(analytics);
+    case "self-hosted":
+      return generateSelfHostedScript(analytics);
+    case "custom":
+      return generateCustomScript(analytics);
+    default:
+      return "";
+  }
+}
+function generateFathomScript(config) {
+  const fathom = config.fathom;
+  if (!fathom?.siteId)
+    return "";
+  const scriptUrl = fathom.scriptUrl || "https://cdn.usefathom.com/script.js", defer = fathom.defer !== !1 ? " defer" : "", dataAttrs = [`data-site="${escapeAttr(fathom.siteId)}"`];
+  if (fathom.honorDnt)
+    dataAttrs.push('data-honor-dnt="true"');
+  if (fathom.spa)
+    dataAttrs.push('data-spa="auto"');
+  if (fathom.canonical)
+    dataAttrs.push(`data-canonical="${escapeAttr(fathom.canonical)}"`);
+  if (fathom.auto === !1)
+    dataAttrs.push('data-auto="false"');
+  return `
+<!-- Fathom Analytics -->
+<script src="${escapeAttr(scriptUrl)}" ${dataAttrs.join(" ")}${defer}></script>
+`;
+}
+function generateGoogleAnalyticsScript(config) {
+  const ga = config.googleAnalytics;
+  if (!ga?.measurementId)
+    return "";
+  const measurementId = escapeAttr(ga.measurementId), debugMode = ga.debug ? `gtag('config', '${measurementId}', { 'debug_mode': true });` : "";
+  return `
+<!-- Google Analytics -->
+<script async src="https://www.googletagmanager.com/gtag/js?id=${measurementId}"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', '${measurementId}');
+  ${debugMode}
+</script>
+`;
+}
+function generatePlausibleScript(config) {
+  const plausible = config.plausible;
+  if (!plausible?.domain)
+    return "";
+  const scriptUrl = plausible.scriptUrl || "https://plausible.io/js/script.js", _dataAttrs = [`data-domain="${escapeAttr(plausible.domain)}"`];
+  let finalScriptUrl = scriptUrl;
+  const extensions = [];
+  if (plausible.trackLocalhost)
+    extensions.push("local");
+  if (plausible.hashMode)
+    extensions.push("hash");
+  if (extensions.length > 0 && scriptUrl === "https://plausible.io/js/script.js")
+    finalScriptUrl = `https://plausible.io/js/script.${extensions.join(".")}.js`;
+  return `
+<!-- Plausible Analytics -->
+<script defer data-domain="${escapeAttr(plausible.domain)}" src="${escapeAttr(finalScriptUrl)}"></script>
+`;
+}
+function generateSelfHostedScript(config) {
+  const selfHosted = config.selfHosted;
+  if (!selfHosted?.siteId || !selfHosted?.apiEndpoint)
+    return "";
+  const siteId = escapeAttr(selfHosted.siteId), apiEndpoint = escapeAttr(selfHosted.apiEndpoint), honorDnt = selfHosted.honorDnt ? 'if(n.doNotTrack==="1")return;' : "", hashTracking = selfHosted.trackHashChanges ? "w.addEventListener('hashchange',pv);" : "", outboundTracking = selfHosted.trackOutboundLinks ? `
+  d.addEventListener('click',function(e){
+    var a=e.target.closest('a');
+    if(a&&a.hostname!==location.hostname){
+      t('outbound',{url:a.href});
+    }
+  });` : "";
+  return `
+<!-- Self-Hosted Analytics -->
+<script data-site="${siteId}" data-api="${apiEndpoint}" defer>
+(function(){
+  'use strict';
+  var d=document,w=window,n=navigator,s=d.currentScript;
+  var site=s.dataset.site,api=s.dataset.api;
+  ${honorDnt}
+  var q=[],sid=Math.random().toString(36).slice(2);
+  function t(e,p){
+    var x=new XMLHttpRequest();
+    x.open('POST',api+'/collect',true);
+    x.setRequestHeader('Content-Type','application/json');
+    x.send(JSON.stringify({
+      s:site,sid:sid,e:e,p:p||{},
+      u:location.href,r:d.referrer,t:d.title,
+      sw:screen.width,sh:screen.height
+    }));
+  }
+  function pv(){t('pageview');}
+  ${hashTracking}
+  ${outboundTracking}
+  if(d.readyState==='complete')pv();
+  else w.addEventListener('load',pv);
+  w.stxAnalytics={track:function(n,v){t('event',{name:n,value:v});}};
+})();
+</script>
+`;
+}
+function generateCustomScript(config) {
+  const custom = config.custom;
+  if (!custom)
+    return "";
+  if (custom.inlineScript)
+    return `
+<!-- Custom Analytics -->
+<script>
+${custom.inlineScript}
+</script>
+`;
+  if (!custom.scriptUrl)
+    return "";
+  const attrs = [];
+  if (custom.scriptId)
+    attrs.push(`id="${escapeAttr(custom.scriptId)}"`);
+  if (custom.attributes)
+    for (const [key, value] of Object.entries(custom.attributes))
+      attrs.push(`${escapeAttr(key)}="${escapeAttr(value)}"`);
+  return `
+<!-- Custom Analytics -->
+<script${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""} src="${escapeAttr(custom.scriptUrl)}" defer></script>
+`;
+}
+export function injectAnalytics(html, options) {
+  const analyticsScript = generateAnalyticsScript(options);
+  if (!analyticsScript)
+    return html;
+  if (!html.includes("</head>")) {
+    const anBodyIdx = html.lastIndexOf("</body>");
+    if (anBodyIdx !== -1)
+      return html.slice(0, anBodyIdx) + analyticsScript + html.slice(anBodyIdx);
+    return html + analyticsScript;
+  }
+  return html.replace("</head>", `${analyticsScript}</head>`);
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export const analyticsDirective = {
+  name: "analytics",
+  hasEndTag: !1,
+  handler: async (_content, _params, context, _filePath) => {
+    const options = context.__stx_config || {};
+    return generateAnalyticsScript(options);
+  }
+};

package/dist/analyzer.js

@@ -1,2 +1,240 @@
-// @bun
-import{Hq as a,Iq as b}from"./chunk-vdfwv0fp.js";import"./chunk-3jm3snz8.js";export{a as analyzeTemplate,b as analyzeProject};
+export async function analyzeTemplate(filePath) {
+  try {
+    const content = await Bun.file(filePath).text(), metrics = calculateMetrics(content), issues = findIssues(content, filePath), suggestions = generateSuggestions(content, metrics), performance = analyzePerformance(content, metrics);
+    return {
+      file: filePath,
+      metrics,
+      issues,
+      suggestions,
+      performance
+    };
+  } catch (error) {
+    throw Error(`Failed to analyze template ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function calculateMetrics(content) {
+  const lines = content.split(`
+`), scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i), scriptLines = (scriptMatch ? scriptMatch[1] : "").split(`
+`).length, directives = {
+    conditionals: (content.match(/@(if|unless|elseif|else|endif|endunless)\b/g) || []).length,
+    loops: (content.match(/@(foreach|for|endforeach|endfor|while|endwhile)\b/g) || []).length,
+    includes: (content.match(/@(include|component|extends|section|yield)\b/g) || []).length,
+    custom: 0,
+    total: 0
+  };
+  directives.total = directives.conditionals + directives.loops + directives.includes + directives.custom;
+  const regularExpressions = (content.match(/\{\{[\s\S]*?\}\}/g) || []).length, rawExpressions = (content.match(/\{!![\s\S]*?!!\}/g) || []).length, directiveExpressions = (content.match(/@(?:if|unless|elseif|foreach|for|while)\s*\([^)]+\)/g) || []).length, expressions = regularExpressions + rawExpressions + directiveExpressions, components = (content.match(/<[A-Z][^>]*>/g) || []).length, layouts = (content.match(/@(?:layout|extends)\(/g) || []).length;
+  let maxNestingDepth = 0, currentDepth = 0;
+  for (const line of lines)
+    if (/@(?:if|unless|foreach|for|while|section)\b/.test(line) && !/@end/.test(line) && !/@else/.test(line)) {
+      currentDepth++;
+      maxNestingDepth = Math.max(maxNestingDepth, currentDepth);
+    } else if (/@end(?:if|unless|foreach|for|while|section)\b/.test(line))
+      currentDepth--;
+  const nestingBonus = maxNestingDepth >= 4 ? 3 : 0, complexity = Math.min(10, Math.ceil(directives.total * 0.5 + expressions * 0.1 + components * 0.3 + (scriptLines > 10 ? scriptLines * 0.05 : 0) + nestingBonus));
+  return {
+    lines: lines.length,
+    characters: content.length,
+    directives,
+    expressions,
+    components,
+    layouts,
+    scriptLines,
+    complexity
+  };
+}
+function findIssues(content, _filePath) {
+  const issues = [], unmatchedIfs = findUnmatchedDirectives(content, "if", "endif");
+  if (unmatchedIfs > 0)
+    issues.push({
+      type: "error",
+      category: "syntax",
+      message: `Found ${unmatchedIfs} unmatched @if directive(s)`,
+      suggestion: "Ensure every @if has a corresponding @endif"
+    });
+  const unmatchedForeachs = findUnmatchedDirectives(content, "foreach", "endforeach");
+  if (unmatchedForeachs > 0)
+    issues.push({
+      type: "error",
+      category: "syntax",
+      message: `Found ${unmatchedForeachs} unmatched @foreach directive(s)`,
+      suggestion: "Ensure every @foreach has a corresponding @endforeach"
+    });
+  const nestedLoops = content.match(/@foreach[\s\S]*?@foreach[\s\S]*?@endforeach[\s\S]*?@endforeach/g);
+  if (nestedLoops && nestedLoops.length > 0)
+    issues.push({
+      type: "warning",
+      category: "performance",
+      message: "Nested loops detected which may impact performance",
+      suggestion: "Consider preprocessing data or using more efficient data structures"
+    });
+  const rawOutputs = (content.match(/\{!![\s\S]*?!!\}/g) || []).length;
+  if (rawOutputs > 0)
+    issues.push({
+      type: "warning",
+      category: "security",
+      message: `Found ${rawOutputs} raw output expression(s) {!! !!}`,
+      suggestion: "Ensure raw outputs are properly sanitized to prevent XSS"
+    });
+  const images = content.match(/<img[^>]*>/g);
+  if (images) {
+    const imagesWithoutAlt = images.filter((img) => !img.includes("alt="));
+    if (imagesWithoutAlt.length > 0)
+      issues.push({
+        type: "warning",
+        category: "accessibility",
+        message: `Found ${imagesWithoutAlt.length} image(s) without alt attributes`,
+        suggestion: "Add alt attributes to all images for screen reader accessibility"
+      });
+  }
+  const longLines = content.split(`
+`).filter((line) => line.length > 120);
+  if (longLines.length > 0)
+    issues.push({
+      type: "info",
+      category: "maintainability",
+      message: `Found ${longLines.length} line(s) longer than 120 characters`,
+      suggestion: "Consider breaking long lines for better readability"
+    });
+  const inlineStyles = (content.match(/style\s*=\s*["'][^"']*["']/g) || []).length;
+  if (inlineStyles > 3)
+    issues.push({
+      type: "info",
+      category: "maintainability",
+      message: `Found ${inlineStyles} inline style attributes`,
+      suggestion: "Consider moving styles to CSS classes for better maintainability"
+    });
+  return issues;
+}
+function generateSuggestions(content, metrics) {
+  const suggestions = [];
+  if (metrics.complexity > 7)
+    suggestions.push({
+      type: "refactor",
+      message: "Template complexity is high. Consider breaking into smaller components.",
+      impact: "high",
+      effort: "medium"
+    });
+  else if (metrics.complexity > 5 && metrics.directives.total > 8)
+    suggestions.push({
+      type: "optimization",
+      message: "Template has moderate complexity. Consider component extraction for reusability.",
+      impact: "medium",
+      effort: "low"
+    });
+  if (metrics.lines > 100 && metrics.components === 0)
+    suggestions.push({
+      type: "refactor",
+      message: "Large template with no components. Consider extracting reusable parts into components.",
+      impact: "medium",
+      effort: "medium"
+    });
+  if (metrics.expressions > 20)
+    suggestions.push({
+      type: "optimization",
+      message: "Many template expressions detected. Consider preprocessing some data in the script section.",
+      impact: "medium",
+      effort: "low"
+    });
+  const nestedLoops = content.match(/@foreach[\s\S]*?@foreach[\s\S]*?@endforeach[\s\S]*?@endforeach/g);
+  if (nestedLoops && nestedLoops.length > 0)
+    suggestions.push({
+      type: "optimization",
+      message: "Nested loops detected. Consider preprocessing data or optimizing data structures.",
+      impact: "high",
+      effort: "medium"
+    });
+  if (metrics.directives.total === 0 && metrics.expressions < 5)
+    suggestions.push({
+      type: "optimization",
+      message: "Template appears static. Consider enabling aggressive caching.",
+      impact: "high",
+      effort: "low"
+    });
+  if (metrics.scriptLines > 50)
+    suggestions.push({
+      type: "refactor",
+      message: "Large script section. Consider moving complex logic to external modules.",
+      impact: "medium",
+      effort: "medium"
+    });
+  return suggestions;
+}
+function analyzePerformance(content, metrics) {
+  let estimatedRenderTime = 1;
+  estimatedRenderTime += metrics.directives.conditionals * 0.1;
+  estimatedRenderTime += metrics.directives.loops * 0.5;
+  estimatedRenderTime += metrics.directives.includes * 2;
+  estimatedRenderTime += metrics.expressions * 0.05;
+  estimatedRenderTime += metrics.components * 1;
+  if (metrics.scriptLines > 10)
+    estimatedRenderTime += metrics.scriptLines * 0.1;
+  let cacheability;
+  if (metrics.expressions === 0 && metrics.directives.total === 0)
+    cacheability = "high";
+  else if (metrics.expressions < 5 && metrics.directives.total < 3)
+    cacheability = "medium";
+  else
+    cacheability = "low";
+  const recommendations = [];
+  if (estimatedRenderTime > 10)
+    recommendations.push("Consider optimizing template complexity");
+  if (cacheability === "low" && metrics.directives.total > 5)
+    recommendations.push("Reduce dynamic content for better caching");
+  if (metrics.components === 0 && metrics.lines > 40)
+    recommendations.push("Extract components to improve reusability and performance");
+  return {
+    estimatedRenderTime: Math.round(estimatedRenderTime * 100) / 100,
+    complexityScore: metrics.complexity,
+    cacheability,
+    recommendations
+  };
+}
+function findUnmatchedDirectives(content, startDirective, endDirective) {
+  const contentWithoutComments = content.replace(/<!--[\s\S]*?-->/g, ""), starts = (contentWithoutComments.match(new RegExp(`@${startDirective}\\b`, "g")) || []).length, ends = (contentWithoutComments.match(new RegExp(`@${endDirective}\\b`, "g")) || []).length;
+  return Math.abs(starts - ends);
+}
+export async function analyzeProject(patterns = ["**/*.stx"], cwd) {
+  const results = [], allFiles = [];
+  for (const pattern of patterns) {
+    const files = await Array.fromAsync(new Bun.Glob(pattern).scan({
+      cwd: cwd || process.cwd(),
+      onlyFiles: !0,
+      absolute: !0
+    }));
+    allFiles.push(...files.filter((f) => f.endsWith(".stx")));
+  }
+  for (const file of allFiles)
+    try {
+      const result = await analyzeTemplate(file);
+      results.push(result);
+    } catch (error) {
+      console.warn(`Failed to analyze ${file}:`, error);
+    }
+  const summary = generateProjectSummary(results);
+  return { results, summary };
+}
+function generateProjectSummary(results) {
+  const totalFiles = results.length, totalLines = results.reduce((sum, r) => sum + r.metrics.lines, 0), avgComplexity = totalFiles > 0 ? results.reduce((sum, r) => sum + r.metrics.complexity, 0) / totalFiles : 0, totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0), issuesByCategory = {};
+  results.forEach((r) => {
+    r.issues.forEach((issue) => {
+      issuesByCategory[issue.category] = (issuesByCategory[issue.category] || 0) + 1;
+    });
+  });
+  const avgRenderTime = totalFiles > 0 ? results.reduce((sum, r) => sum + r.performance.estimatedRenderTime, 0) / totalFiles : 0, performanceScore = Math.max(1, Math.min(10, Math.round(10 - avgRenderTime / 2 - avgComplexity / 2))), recommendations = [];
+  if (avgComplexity > 6)
+    recommendations.push("Project has high average complexity. Consider refactoring complex templates.");
+  if (totalIssues > totalFiles * 2)
+    recommendations.push("High number of issues detected. Run detailed analysis on individual files.");
+  if (issuesByCategory.security > 0)
+    recommendations.push("Security issues found. Review raw output usage and input sanitization.");
+  return {
+    totalFiles,
+    totalLines,
+    avgComplexity: Math.round(avgComplexity * 100) / 100,
+    totalIssues,
+    issuesByCategory,
+    performanceScore,
+    recommendations
+  };
+}