@rohal12/spindle-lsp 0.4.0 → 0.5.1

package/dist/bin.js

@@ -1011,6 +1011,12 @@ var init_macro_supplements = __esm({
         name: "unwatch",
         description: "Stops watching a variable.\n\nUsage: `{unwatch $var}`",
         parameters: ["...text"]
+      },
+      unless: {
+        name: "unless",
+        container: true,
+        description: "Conditionally displays its contents when the expression is falsy. The inverse of `{if}`.\n\nUsage:\n\n```\n{unless condition}\n  ...\n{/unless}\n```",
+        parameters: ["...text"]
       }
     };
   }
@@ -2787,51 +2793,392 @@ var init_check = __esm({
   }
 });
 
-// src/plugins/format.ts
-function formatDocument(text) {
+// src/plugins/format/segment.ts
+function splitPassages(text) {
   const lines = text.split("\n");
-  const result = [];
-  let indentLevel = 0;
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const passages = [];
+  let currentHeader = "";
+  let bodyLines = [];
+  let startLine = 0;
+  function pushPassage() {
+    if (currentHeader || bodyLines.length > 0) {
+      while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1].trim() === "") {
+        bodyLines.pop();
+      }
+      passages.push({
+        header: currentHeader,
+        body: bodyLines.join("\n") + (bodyLines.length > 0 ? "\n" : ""),
+        startLine
+      });
+    }
+  }
   for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
-    line = line.replace(/\s+$/, "");
-    if (PASSAGE_HEADER_REGEX.test(line)) {
-      line = normalizePassageHeader(line);
-      indentLevel = 0;
-      result.push(line);
+    if (PASSAGE_HEADER_REGEX.test(lines[i])) {
+      pushPassage();
+      currentHeader = lines[i];
+      bodyLines = [];
+      startLine = i;
+    } else {
+      bodyLines.push(lines[i]);
+    }
+  }
+  pushPassage();
+  return passages;
+}
+function classifyPassage(header) {
+  const tagMatch = header.match(/\[([^\]]*)\]/g);
+  if (!tagMatch) return "normal";
+  const tags = tagMatch.map((t) => t.slice(1, -1).trim().toLowerCase());
+  if (tags.includes("script")) return "script";
+  if (tags.includes("stylesheet")) return "stylesheet";
+  return "normal";
+}
+function segmentRegions(body) {
+  const lines = body.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  if (lines.length === 0) return [];
+  const regions = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^<script(\s|>)/i.test(trimmed)) {
+      const scriptLines = [line];
+      i++;
+      while (i < lines.length && !/<\/script>/i.test(lines[i])) {
+        scriptLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) {
+        scriptLines.push(lines[i]);
+        i++;
+      }
+      regions.push({ type: "script", lines: scriptLines });
+      continue;
+    }
+    if (/^<([a-zA-Z][\w-]*)/.test(trimmed)) {
+      const tagMatch = trimmed.match(/^<([a-zA-Z][\w-]*)/);
+      const tagName = tagMatch[1].toLowerCase();
+      if (VOID_ELEMENTS.has(tagName) && !lines[i + 1]?.trim().startsWith("<")) {
+        pushSpindleLine(regions, line);
+        i++;
+        continue;
+      }
+      const selfClosing = new RegExp(`</${tagName}\\s*>`, "i");
+      if (selfClosing.test(trimmed)) {
+        pushSpindleLine(regions, line);
+        i++;
+        continue;
+      }
+      const htmlLines = [line];
+      let depth = 1;
+      i++;
+      while (i < lines.length && depth > 0) {
+        htmlLines.push(lines[i]);
+        const opens = (lines[i].match(new RegExp(`<${tagName}[\\s>]`, "gi")) ?? []).length;
+        const closes = (lines[i].match(new RegExp(`</${tagName}\\s*>`, "gi")) ?? []).length;
+        depth += opens - closes;
+        i++;
+      }
+      regions.push({ type: "html", lines: htmlLines });
+      continue;
+    }
+    pushSpindleLine(regions, line);
+    i++;
+  }
+  return regions;
+}
+function pushSpindleLine(regions, line) {
+  const last = regions[regions.length - 1];
+  if (last?.type === "spindle") {
+    last.lines.push(line);
+  } else {
+    regions.push({ type: "spindle", lines: [line] });
+  }
+}
+var PASSAGE_HEADER_REGEX, VOID_ELEMENTS;
+var init_segment = __esm({
+  "src/plugins/format/segment.ts"() {
+    "use strict";
+    PASSAGE_HEADER_REGEX = /^::\s+/;
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+  }
+});
+
+// src/plugins/format/prettier-bridge.ts
+async function loadPrettier() {
+  if (prettierLoaded) return prettier;
+  prettierLoaded = true;
+  try {
+    prettier = await import("prettier");
+  } catch {
+    prettier = null;
+  }
+  return prettier;
+}
+async function getBaseConfig() {
+  const p = await loadPrettier();
+  if (!p) return {};
+  try {
+    const resolved = await p.resolveConfig(process.cwd());
+    return { tabWidth: 2, ...resolved ?? {} };
+  } catch {
+    return { tabWidth: 2 };
+  }
+}
+async function formatJS(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, { ...config, parser: "babel" });
+  } catch {
+    return code;
+  }
+}
+async function formatCSS(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, { ...config, parser: "css" });
+  } catch {
+    return code;
+  }
+}
+async function formatHTML(code) {
+  const p = await loadPrettier();
+  if (!p) return code;
+  try {
+    const config = await getBaseConfig();
+    return await p.format(code, {
+      ...config,
+      parser: "html",
+      htmlWhitespaceSensitivity: "ignore"
+    });
+  } catch {
+    return code;
+  }
+}
+var prettier, prettierLoaded;
+var init_prettier_bridge = __esm({
+  "src/plugins/format/prettier-bridge.ts"() {
+    "use strict";
+    prettier = null;
+    prettierLoaded = false;
+  }
+});
+
+// src/plugins/format/placeholders.ts
+function isInsideAttribute(text, pos) {
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0; i < pos; i++) {
+    const ch = text[i];
+    if (!inQuote && (ch === '"' || ch === "'") && i > 0 && text[i - 1] === "=") {
+      inQuote = true;
+      quoteChar = ch;
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false;
+    }
+  }
+  return inQuote;
+}
+function replaceSpindleTokens(html) {
+  const tokens = [];
+  const lines = html.split("\n");
+  const resultLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    SPINDLE_TOKEN_REGEX.lastIndex = 0;
+    if (!SPINDLE_TOKEN_REGEX.test(trimmed)) {
+      resultLines.push(line);
+      continue;
+    }
+    SPINDLE_TOKEN_REGEX.lastIndex = 0;
+    const withoutSpindle = trimmed.replace(SPINDLE_TOKEN_REGEX, "");
+    const hasHtml = HTML_TAG_REGEX.test(withoutSpindle);
+    if (!hasHtml) {
+      const idx = tokens.length;
+      tokens.push(trimmed);
+      const indent = line.match(/^(\s*)/)?.[1] ?? "";
+      resultLines.push(`${indent}<!--SP:${idx}-->`);
+    } else {
+      SPINDLE_TOKEN_REGEX.lastIndex = 0;
+      const replaced = line.replace(SPINDLE_TOKEN_REGEX, (match, ...args2) => {
+        const matchOffset = args2[args2.length - 2];
+        const idx = tokens.length;
+        tokens.push(match);
+        if (isInsideAttribute(line, matchOffset)) {
+          return `__SP${idx}__`;
+        }
+        return `<!--SP:${idx}-->`;
+      });
+      resultLines.push(replaced);
+    }
+  }
+  return { text: resultLines.join("\n"), tokens };
+}
+function restoreSpindleTokens(text, tokens) {
+  let result = text;
+  for (let i = 0; i < tokens.length; i++) {
+    result = result.replace(`<!--SP:${i}-->`, tokens[i]);
+    result = result.replace(`__SP${i}__`, tokens[i]);
+  }
+  return result;
+}
+var SPINDLE_TOKEN_REGEX, HTML_TAG_REGEX;
+var init_placeholders = __esm({
+  "src/plugins/format/placeholders.ts"() {
+    "use strict";
+    SPINDLE_TOKEN_REGEX = /(?:\{\/[A-Za-z][\w-]*\s*\}|\{(?:[#.][a-zA-Z][\w-]*\s*)*[A-Za-z][\w-]*(?:\s+(?:[^{}]|\{[^{}]*\})*)?\}|\{[$_@][a-zA-Z][\w.]*\}|\[\[(?:[^\]]*)\]\])/g;
+    HTML_TAG_REGEX = /<\/?[a-zA-Z][\w-]*[\s>/]/;
+  }
+});
+
+// src/plugins/format.ts
+function getSupplementContainers() {
+  const containers = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(macro_supplements_default)) {
+    if (entry.container) {
+      containers.add(key.toLowerCase());
+    }
+  }
+  return containers;
+}
+function detectContainersFromText(text) {
+  const found = /* @__PURE__ */ new Set();
+  const re = /\{\/([A-Za-z][\w-]*)\s*\}/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    found.add(m[1].toLowerCase());
+  }
+  return found;
+}
+function buildDefaultIsBlock(text) {
+  const containers = getSupplementContainers();
+  for (const name of detectContainersFromText(text)) {
+    containers.add(name);
+  }
+  return (name) => containers.has(name.toLowerCase());
+}
+async function formatDocument(text, options) {
+  const isBlock = options?.isBlock ?? buildDefaultIsBlock(text);
+  const isDedenting = options?.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING.has(name.toLowerCase()));
+  const passages = splitPassages(text);
+  const resultLines = [];
+  for (let pi = 0; pi < passages.length; pi++) {
+    const passage = passages[pi];
+    if (pi > 0 && passage.header) {
+      const prev = passages[pi - 1];
+      const prevBodyLineCount = prev.body ? prev.body.split("\n").length - 1 : 0;
+      const prevEndLine = prev.startLine + (prev.header ? 1 : 0) + prevBodyLineCount;
+      if (passage.startLine > prevEndLine) {
+        resultLines.push("");
+      }
+    }
+    if (passage.header) {
+      const header = PASSAGE_HEADER_REGEX2.test(passage.header) ? normalizePassageHeader(passage.header) : passage.header;
+      resultLines.push(header);
+    }
+    const kind = classifyPassage(passage.header);
+    if (kind === "script") {
+      const formatted = await formatJS(passage.body.trim());
+      resultLines.push(formatted.trim());
+      continue;
+    }
+    if (kind === "stylesheet") {
+      const formatted = await formatCSS(passage.body.trim());
+      resultLines.push(formatted.trim());
       continue;
     }
+    const regions = segmentRegions(passage.body);
+    for (const region of regions) {
+      if (region.type === "script") {
+        const firstLine = region.lines[0];
+        const lastLine = region.lines[region.lines.length - 1];
+        const innerLines = region.lines.slice(1, region.lines.length - 1);
+        const innerCode = innerLines.join("\n");
+        const formatted = await formatJS(innerCode.trim());
+        resultLines.push(firstLine);
+        if (formatted.trim()) {
+          for (const fLine of formatted.trim().split("\n")) {
+            resultLines.push("  " + fLine);
+          }
+        }
+        resultLines.push(lastLine);
+        continue;
+      }
+      if (region.type === "html") {
+        const htmlText = region.lines.join("\n");
+        const { text: placeholdered, tokens } = replaceSpindleTokens(htmlText);
+        const formatted = await formatHTML(placeholdered);
+        const restored = restoreSpindleTokens(formatted.trim(), tokens);
+        for (const fLine of restored.split("\n")) {
+          resultLines.push(fLine);
+        }
+        continue;
+      }
+      const indented = indentMacros(region.lines, isBlock, isDedenting);
+      resultLines.push(...indented);
+    }
+  }
+  let output = resultLines.map((l) => l.replace(/\s+$/, "")).join("\n");
+  output = output.replace(/\n*$/, "\n");
+  return output;
+}
+function indentMacros(lines, isBlock, isDedenting) {
+  const result = [];
+  let indentLevel = 0;
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
     const trimmed = line.trim();
     if (trimmed === "") {
       result.push("");
       continue;
     }
-    if (BLOCK_CLOSE_REGEX.test(trimmed)) {
+    const dedentMatch = trimmed.match(MACRO_OPEN_REGEX);
+    if (dedentMatch && isDedenting(dedentMatch[1])) {
+      indentLevel = Math.max(0, indentLevel - 1);
+      result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
+      indentLevel++;
+      continue;
+    }
+    const closeMatch = trimmed.match(MACRO_CLOSE_REGEX);
+    if (closeMatch) {
       indentLevel = Math.max(0, indentLevel - 1);
     }
-    const indented = indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed;
-    result.push(indented);
-    if (BLOCK_OPEN_REGEX.test(trimmed)) {
+    result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
+    const openMatch = trimmed.match(MACRO_OPEN_REGEX);
+    if (openMatch && isBlock(openMatch[1])) {
       indentLevel++;
     }
   }
-  let output = result.join("\n");
-  output = output.replace(/\n*$/, "\n");
-  return output;
-}
-function formatRange(text, range) {
-  const lines = text.split("\n");
-  const startLine = Math.max(0, range.start.line);
-  const endLine = Math.min(lines.length - 1, range.end.line);
-  const rangeLines = lines.slice(startLine, endLine + 1);
-  const rangeText = rangeLines.join("\n");
-  const formatted = formatDocument(rangeText);
-  const formattedLines = formatted.replace(/\n$/, "").split("\n");
-  const before = lines.slice(0, startLine);
-  const after = lines.slice(endLine + 1);
-  const result = [...before, ...formattedLines, ...after].join("\n");
   return result;
 }
+async function formatRange(text, _range, options) {
+  return formatDocument(text, options);
+}
 function normalizePassageHeader(line) {
   const headerMatch = line.match(/^::\s+(.*)/);
   if (!headerMatch) return line;
@@ -2851,13 +3198,18 @@ function normalizePassageHeader(line) {
   }
   return `:: ${name}${suffix}`;
 }
-var BLOCK_OPEN_REGEX, BLOCK_CLOSE_REGEX, PASSAGE_HEADER_REGEX, formatPlugin;
+var PASSAGE_HEADER_REGEX2, MACRO_OPEN_REGEX, MACRO_CLOSE_REGEX, DEFAULT_DEDENTING, formatPlugin;
 var init_format = __esm({
   "src/plugins/format.ts"() {
     "use strict";
-    BLOCK_OPEN_REGEX = /^\s*\{(if|for|switch|unless|widget)\b/i;
-    BLOCK_CLOSE_REGEX = /^\s*\{\/(if|for|switch|unless|widget)\b/i;
-    PASSAGE_HEADER_REGEX = /^(::)\s+/;
+    init_macro_supplements();
+    init_segment();
+    init_prettier_bridge();
+    init_placeholders();
+    PASSAGE_HEADER_REGEX2 = /^(::)\s+/;
+    MACRO_OPEN_REGEX = /^\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\b/;
+    MACRO_CLOSE_REGEX = /^\{\/([A-Za-z][\w-]*)\b/;
+    DEFAULT_DEDENTING = /* @__PURE__ */ new Set(["else", "elseif", "next", "case", "default"]);
     formatPlugin = {
       id: "format",
       capabilities: {
@@ -2865,10 +3217,14 @@ var init_format = __esm({
         documentRangeFormattingProvider: true
       },
       initialize(ctx) {
-        ctx.connection.onDocumentFormatting((params) => {
+        const formatOpts = {
+          isBlock: (name) => ctx.workspace.macros.isBlock(name),
+          isDedentingSubMacro: (name) => DEFAULT_DEDENTING.has(name.toLowerCase())
+        };
+        ctx.connection.onDocumentFormatting(async (params) => {
           const text = ctx.workspace.documents.getText(params.textDocument.uri);
           if (text === void 0) return [];
-          const formatted = formatDocument(text);
+          const formatted = await formatDocument(text, formatOpts);
           if (formatted === text) return [];
           const lines = text.split("\n");
           return [{
@@ -2879,14 +3235,14 @@ var init_format = __esm({
             newText: formatted
           }];
         });
-        ctx.connection.onDocumentRangeFormatting((params) => {
+        ctx.connection.onDocumentRangeFormatting(async (params) => {
           const text = ctx.workspace.documents.getText(params.textDocument.uri);
           if (text === void 0) return [];
           const range = {
             start: { line: params.range.start.line, character: params.range.start.character },
             end: { line: params.range.end.line, character: params.range.end.character }
           };
-          const formatted = formatRange(text, range);
+          const formatted = await formatRange(text, range, formatOpts);
           if (formatted === text) return [];
           const lines = text.split("\n");
           return [{
@@ -2947,7 +3303,7 @@ async function runFormat(args2) {
   for (const filePath of uniqueFiles) {
     try {
       const text = readFileSync5(filePath, "utf-8");
-      const formatted = formatDocument(text);
+      const formatted = await formatDocument(text);
       if (formatted !== text) {
         if (options.check) {
           const relative = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
@@ -3107,7 +3463,7 @@ async function startMcpServer() {
       for (const filePath of files) {
         try {
           const text = readFileSync6(filePath, "utf-8");
-          const result = formatDocument(text);
+          const result = await formatDocument(text);
           if (result !== text) {
             writeFileSync2(filePath, result, "utf-8");
             formatted++;
@@ -3139,7 +3495,7 @@ async function startMcpServer() {
       for (const filePath of files) {
         try {
           const text = readFileSync6(filePath, "utf-8");
-          const result = formatDocument(text);
+          const result = await formatDocument(text);
           const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
           if (result !== text) {
             needsFormatting.push(relativePath);