@stacksjs/stx 0.2.94 → 0.2.96

package/dist/formatter.js

@@ -1,2 +1,265 @@
-// @bun
-import{$m as b,_m as a}from"./chunk-kkp6rs2n.js";import"./chunk-3jm3snz8.js";export{a as formatStxContent,b as formatMarkdownContent};
+const DEFAULT_OPTIONS = {
+  indentSize: 2,
+  useTabs: !1,
+  maxLineLength: 120,
+  normalizeWhitespace: !0,
+  sortAttributes: !1,
+  trimTrailingWhitespace: !0
+};
+export function formatStxContent(content, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (content.trim() === "")
+    return `
+`;
+  let formatted = content;
+  if (opts.trimTrailingWhitespace)
+    formatted = formatted.replace(/[ \t]+$/gm, "");
+  formatted = formatHtml(formatted, opts);
+  formatted = formatAttributes(formatted, opts);
+  formatted = formatStxDirectives(formatted, opts);
+  if (opts.trimTrailingWhitespace) {
+    formatted = formatted.replace(/[ \t]+$/gm, "");
+    formatted = formatted.replace(/(\S)[ \t]+(<\/[^>]+>)/g, "$1$2");
+  }
+  formatted = formatted.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  if (!formatted.endsWith(`
+`))
+    formatted += `
+`;
+  return formatted;
+}
+export function formatMarkdownContent(content, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (content.trim() === "")
+    return `
+`;
+  let formatted = content;
+  formatted = formatted.replace(/^( *)```(html|stx)\n([\s\S]*?)^( *)```/gm, (match, startIndent, lang, code, _endIndent) => {
+    const lines = code.split(`
+`), nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length === 0)
+      return match;
+    const minIndent = Math.min(...nonEmptyLines.map((line) => {
+      const match = line.match(/^( *)/);
+      return match ? match[1].length : 0;
+    })), dedented = lines.map((line) => {
+      if (line.trim().length === 0)
+        return "";
+      return line.substring(minIndent);
+    }).join(`
+`), reindented = formatStxContent(dedented, opts).trimEnd().split(`
+`).map((line) => {
+      if (line.trim().length === 0)
+        return "";
+      return startIndent + line;
+    }).join(`
+`);
+    return `${startIndent}\`\`\`${lang}
+${reindented}
+${startIndent}\`\`\``;
+  });
+  if (opts.trimTrailingWhitespace)
+    formatted = formatted.replace(/[ \t]+$/gm, "");
+  formatted = formatted.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  if (!formatted.endsWith(`
+`))
+    formatted += `
+`;
+  return formatted;
+}
+function _formatScriptTags(content, options) {
+  return content.replace(/<script\b[^>]*>([\s\S]*?)<\/script>/gi, (match, scriptContent) => {
+    const trimmed = scriptContent.trim();
+    if (trimmed && !trimmed.includes(`
+`) && trimmed.length < 80)
+      return match.replace(scriptContent, trimmed);
+    const lines = scriptContent.split(`
+`), formattedLines = lines.map((line, index) => {
+      if (index === 0 && line.trim() === "")
+        return "";
+      if (index === lines.length - 1 && line.trim() === "")
+        return "";
+      const lineTrimmed = line.trim();
+      if (lineTrimmed === "")
+        return "";
+      if (lineTrimmed.startsWith("/**") || lineTrimmed.startsWith("/*") || lineTrimmed.startsWith("*") || lineTrimmed.startsWith("*/"))
+        return `${options.useTabs ? "\t" : " ".repeat(options.indentSize)}${lineTrimmed}`;
+      return `${options.useTabs ? "\t" : " ".repeat(options.indentSize)}${lineTrimmed}`;
+    }).filter((line, index, arr) => {
+      if (index === 0 || index === arr.length - 1)
+        return line !== "";
+      return !0;
+    }), formattedScript = formattedLines.length > 0 ? `
+${formattedLines.join(`
+`)}
+` : "";
+    return match.replace(scriptContent, formattedScript);
+  });
+}
+function splitInlineTags(content) {
+  let result = content;
+  const protectedBlocks = [], placeholder = "__PROTECTED_BLOCK_";
+  result = result.replace(/(<(?:pre|code|textarea)[^>]*>)([\s\S]*?)(<\/(?:pre|code|textarea)>)/gi, (match) => {
+    const index = protectedBlocks.length;
+    protectedBlocks.push(match);
+    return `${placeholder}${index}__`;
+  });
+  result = result.replace(/(@(?:if|foreach|for|while|unless|section|component|slot|push|prepend|error|auth|guest|can)(?:\((?:[^()'"]|'[^']*'|"[^"]*"|\((?:[^()'"]|'[^']*'|"[^"]*")*\))*\))?)/g, `
+$1
+`);
+  result = result.replace(/(@end\w+)/g, `
+$1
+`);
+  result = result.replace(/(@(?:else|elseif|empty)(?:\((?:[^()'"]|'[^']*'|"[^"]*"|\((?:[^()'"]|'[^']*'|"[^"]*")*\))*\))?)/g, `
+$1
+`);
+  result = result.replace(/(@(?:csrf|method|include|extends|yield|stack|vite|asset)(?:\([^)]*\))?)/g, `
+$1
+`);
+  result = result.replace(/(?<=>)(<(?!\/)[^>]+>)/g, (match, _p1, offset, string) => {
+    const after = string.substring(offset + match.length, Math.min(string.length, offset + match.length + 20)), tagName = match.match(/<(\w+)/)?.[1];
+    if (tagName && after.match(new RegExp(`^</${tagName}>`)))
+      return match;
+    return `
+${match}`;
+  });
+  result = result.replace(/(>)(<\/)/g, (match, gt, closeTag, offset, string) => {
+    const before = string.substring(Math.max(0, offset - 50), offset), closeTagName = string.substring(offset + match.length, Math.min(string.length, offset + match.length + 20)).match(/^(\w+)>/)?.[1], openTagName = before.match(/<(\w+)[^>]*$/)?.[1];
+    if (openTagName && closeTagName && openTagName === closeTagName)
+      return match;
+    return `${gt}
+${closeTag}`;
+  });
+  result = result.replace(/(<\/[^>]+>)(?=<|$)/g, (match, _p1, offset, string) => {
+    const before = string.substring(Math.max(0, offset - 20), offset), tagName = match.match(/<\/(\w+)>/)?.[1], emptyPattern = new RegExp(`<${tagName}[^>]*>$`);
+    if (tagName && before.match(emptyPattern))
+      return match;
+    return `${match}
+`;
+  });
+  result = result.replace(new RegExp(`${placeholder}(\\d+)__`, "g"), (_match, index) => {
+    return protectedBlocks[Number.parseInt(index, 10)];
+  });
+  result = result.replace(/\n{2,}/g, `
+`);
+  result = result.split(`
+`).map((line) => line.trim()).join(`
+`);
+  result = result.replace(/^\n+/, "").replace(/\n+$/, "");
+  return result;
+}
+function formatHtml(content, options) {
+  const lines = splitInlineTags(content).split(`
+`), formattedLines = [];
+  let indentLevel = 0, inScriptTag = !1;
+  const indent = options.useTabs ? "\t" : " ".repeat(options.indentSize);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i], trimmed = line.trim();
+    if (trimmed === "") {
+      formattedLines.push("");
+      continue;
+    }
+    const hasScriptOpen = trimmed.match(/<script\b/i), hasScriptClose = trimmed.match(/<\/script>/i);
+    if (inScriptTag && !hasScriptClose) {
+      formattedLines.push(line);
+      continue;
+    }
+    const isJustClosingBracket = trimmed === ">";
+    if (hasCompleteElement(trimmed) && !trimmed.startsWith("<") && !trimmed.startsWith("@")) {
+      formattedLines.push(indent.repeat(indentLevel) + trimmed);
+      continue;
+    }
+    const isClosingDirective = trimmed.startsWith("@end"), isMiddleDirective = trimmed.startsWith("@else") || trimmed.startsWith("@elseif"), isDirectiveOpening = trimmed.startsWith("@") && isOpeningDirective(trimmed), isDocType = trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<!doctype"), isComment = trimmed.startsWith("<!--"), isClosingTag = trimmed.startsWith("</"), isOpeningTag = trimmed.startsWith("<") && !isClosingTag && !isComment && !isDocType, isSelfClosing = trimmed.includes("/>") || isSelfClosingTag(trimmed), hasCompleteTag = hasCompleteElement(trimmed);
+    if (isClosingTag || isClosingDirective)
+      indentLevel = Math.max(0, indentLevel - 1);
+    const currentIndent = isMiddleDirective ? Math.max(0, indentLevel - 1) : indentLevel;
+    if (isJustClosingBracket)
+      formattedLines.push(line);
+    else
+      formattedLines.push(indent.repeat(currentIndent) + trimmed);
+    if (isOpeningTag && !isSelfClosing && !hasCompleteTag && !isJustClosingBracket || isDirectiveOpening)
+      indentLevel++;
+    if (hasScriptOpen)
+      inScriptTag = !0;
+    if (hasScriptClose)
+      inScriptTag = !1;
+  }
+  return formattedLines.join(`
+`);
+}
+function formatStxDirectives(content, options) {
+  content = content.replace(/@(if|elseif|foreach|for|while)\s*\(\s*([^)]+)\s*\)/g, (match, directive, condition) => {
+    const normalizedCondition = condition.trim().replace(/\s+/g, " ");
+    return `@${directive}(${normalizedCondition})`;
+  });
+  content = content.replace(/@(csrf|method)\s*\(\s*([^)]*)\s*\)/g, (match, directive, param) => {
+    if (param.trim() === "")
+      return `@${directive}`;
+    return `@${directive}(${param.trim()})`;
+  });
+  if (options.normalizeWhitespace) {
+    content = content.replace(/\{\{\s*([^}]+)\s*\}\}/g, (match, expression) => {
+      return `{{ ${expression.trim()} }}`;
+    });
+    content = content.replace(/\{!!\s*([^!]+)\s*!!\}/g, (match, expression) => {
+      return `{!! ${expression.trim()} !!}`;
+    });
+  }
+  return content;
+}
+function isSelfClosingTag(line) {
+  const selfClosingTags = ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"];
+  if (line.includes("/>"))
+    return !0;
+  const tagMatch = line.match(/<(\w+)/);
+  if (tagMatch) {
+    const tagName = tagMatch[1];
+    return selfClosingTags.includes(tagName.toLowerCase());
+  }
+  return !1;
+}
+function hasCompleteElement(line) {
+  return /<(\w+)(?:\s[^>]*)?>[\s\S]*?<\/\1>/.test(line);
+}
+function isOpeningDirective(line) {
+  const blockDirectives = ["if", "unless", "foreach", "for", "while", "section", "push", "component", "slot", "markdown", "wrap", "error"];
+  for (const directive of blockDirectives)
+    if (line.startsWith(`@${directive}`))
+      return !line.includes(`@end${directive}`);
+  return !1;
+}
+function formatAttributes(content, options) {
+  if (!options.sortAttributes)
+    return content;
+  return content.replace(/<(\w+)([^>]*)>/g, (match, tagName, attributes) => {
+    if (!attributes.trim())
+      return match;
+    if (attributes.includes("<") || attributes.includes(`
+`) || attributes.includes("@"))
+      return match;
+    const attrRegex = /(\w+)(?:=("[^"]*"|'[^']*'|[^\s>]+))?/g, attrs = [];
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(attributes)) !== null)
+      attrs.push({
+        name: attrMatch[1],
+        value: attrMatch[2]
+      });
+    attrs.sort((a, b) => {
+      if (a.name === "id")
+        return -1;
+      if (b.name === "id")
+        return 1;
+      if (a.name === "class")
+        return -1;
+      if (b.name === "class")
+        return 1;
+      return a.name.localeCompare(b.name);
+    });
+    const formattedAttrs = attrs.map((attr) => attr.value ? `${attr.name}=${attr.value}` : attr.name).join(" ");
+    return `<${tagName}${formattedAttrs ? ` ${formattedAttrs}` : ""}>`;
+  });
+}