starlight-cannoli-plugins 2.1.8 → 2.1.9

package/dist/{chunk-3ATSZG6H.js → chunk-IY4A67ZP.js}

@@ -1718,10 +1718,6 @@ var require_components2 = __commonJS({
   }
 });
 
-// src/plugins/utils/sidebar-builder-utils.ts
-import * as fs from "fs";
-import * as path2 from "path";
-
 // node_modules/remark-smartypants/dist/plugin.js
 import { visit } from "unist-util-visit";
 
@@ -5102,24 +5098,8 @@ function parseFrontmatter(code, options) {
 // node_modules/@astrojs/markdown-remark/dist/index.js
 var isPerformanceBenchmark = Boolean(process.env.ASTRO_PERFORMANCE_BENCHMARK);
 
-// src/plugins/utils/sidebar-builder-utils.ts
-function isDir(filePath) {
-  try {
-    return fs.statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function findIndexMd(dirPath) {
-  const indexMd = path2.join(dirPath, "index.md");
-  const indexMdx = path2.join(dirPath, "index.mdx");
-  try {
-    if (fs.statSync(indexMd).isFile()) return indexMd;
-    if (fs.statSync(indexMdx).isFile()) return indexMdx;
-  } catch {
-  }
-  return null;
-}
+// src/plugins/utils/workspace-utils.ts
+import * as fs from "fs";
 function parseFrontmatter2(filePath) {
   let content;
   try {
@@ -5131,164 +5111,16 @@ function parseFrontmatter2(filePath) {
     const { frontmatter } = parseFrontmatter(content);
     return frontmatter;
   } catch (err) {
-    console.warn(`[parseFrontmatter] Failed to parse frontmatter in ${filePath}:`, err);
-    return {};
-  }
-}
-function getSlug(dirPath, rootDir) {
-  const normalized = path2.normalize(dirPath).replace(/\\/g, "/");
-  const rootParent = path2.normalize(path2.dirname(rootDir)).replace(/\\/g, "/");
-  const slug = normalized.startsWith(rootParent) ? normalized.slice(rootParent.length + 1) : normalized;
-  return slug + "/index";
-}
-function hasIndexMdInSubtree(dirPath) {
-  const indexFile = findIndexMd(dirPath);
-  if (indexFile) {
-    const fm = parseFrontmatter2(indexFile);
-    if (fm.draft || fm.sidebar?.hidden) return false;
-    return true;
-  }
-  try {
-    const entries = fs.readdirSync(dirPath);
-    for (const entry of entries) {
-      if (entry === "assets") continue;
-      const fullPath = path2.join(dirPath, entry);
-      if (isDir(fullPath) && hasIndexMdInSubtree(fullPath)) {
-        return true;
-      }
-    }
-  } catch {
-    return false;
-  }
-  return false;
-}
-function isGroupItem(item) {
-  return "items" in item;
-}
-function pathSegmentToLabel(pathSegment) {
-  let label = pathSegment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  const match = label.match(/^([a-z]+) [0-9]{2,}/i);
-  if (match) {
-    const firstGroup = match[1];
-    const uppercasedFirstGroup = firstGroup.toUpperCase();
-    label = uppercasedFirstGroup + label.substring(firstGroup.length);
-  }
-  return label;
-}
-function buildSidebarItems(dirPath, rootDir, currentDepth, maxDepth, dirnameDeterminesLabels, parentDirName = "") {
-  const items = [];
-  const indexFile = findIndexMd(dirPath);
-  if (indexFile) {
-    const fm = parseFrontmatter2(indexFile);
-    if (!fm.draft && !fm.sidebar?.hidden) {
-      let label;
-      if (currentDepth >= maxDepth && parentDirName) {
-        label = parentDirName;
-      } else if (dirnameDeterminesLabels) {
-        label = "Overview";
-      } else {
-        label = fm.title || "Overview";
-      }
-      items.push({
-        label,
-        slug: getSlug(dirPath, rootDir)
-      });
-    }
-  }
-  if (currentDepth >= maxDepth) {
-    const flattenedItems = flattenIndexFilesAtDepth(
-      dirPath,
-      rootDir,
-      dirnameDeterminesLabels
+    console.warn(
+      `[parseFrontmatter] Failed to parse frontmatter in ${filePath}:`,
+      err
     );
-    items.push(...flattenedItems);
-    return items;
-  }
-  try {
-    const entries = fs.readdirSync(dirPath).sort();
-    for (const entry of entries) {
-      if (entry === "assets") continue;
-      const fullPath = path2.join(dirPath, entry);
-      if (!isDir(fullPath)) continue;
-      if (!hasIndexMdInSubtree(fullPath)) continue;
-      const subItems = buildSidebarItems(
-        fullPath,
-        rootDir,
-        currentDepth + 1,
-        maxDepth,
-        dirnameDeterminesLabels,
-        entry
-      );
-      const hasIndex = findIndexMd(fullPath) !== null;
-      if (!hasIndex) {
-        const allGroups = subItems.length > 0 && subItems.every(isGroupItem);
-        if (allGroups || subItems.length === 1 && isGroupItem(subItems[0])) {
-          items.push(...subItems);
-        } else {
-          items.push({
-            label: pathSegmentToLabel(entry),
-            items: subItems
-          });
-        }
-      } else {
-        items.push({
-          label: pathSegmentToLabel(entry),
-          items: subItems
-        });
-      }
-    }
-  } catch {
-  }
-  return items;
-}
-function flattenIndexFilesAtDepth(dirPath, rootDir, dirnameDeterminesLabels) {
-  const items = [];
-  try {
-    const entries = fs.readdirSync(dirPath);
-    for (const entry of entries) {
-      if (entry === "assets") continue;
-      const fullPath = path2.join(dirPath, entry);
-      if (!isDir(fullPath)) continue;
-      const indexFile = findIndexMd(fullPath);
-      if (indexFile) {
-        const fm = parseFrontmatter2(indexFile);
-        if (!fm.draft && !fm.sidebar?.hidden) {
-          items.push({
-            label: pathSegmentToLabel(entry),
-            slug: getSlug(fullPath, rootDir)
-          });
-        }
-      }
-      items.push(
-        ...flattenIndexFilesAtDepth(fullPath, rootDir, dirnameDeterminesLabels)
-      );
-    }
-  } catch {
+    return {};
   }
-  return items;
-}
-function getIndexMdSidebarItems(directory, options = {}) {
-  const maxDepth = options.maxDepthNesting ?? 100;
-  const dirnameDeterminesLabels = options.dirnameDeterminesLabels ?? true;
-  const rootDirName = pathSegmentToLabel(path2.basename(directory));
-  const items = buildSidebarItems(
-    directory,
-    directory,
-    0,
-    maxDepth,
-    dirnameDeterminesLabels
-  );
-  return [
-    {
-      label: rootDirName,
-      items
-    }
-  ];
 }
 
 export {
-  parseFrontmatter2 as parseFrontmatter,
-  getIndexMdSidebarItems
+  parseFrontmatter2 as parseFrontmatter
 };
 /*! Bundled license information:
 

package/dist/chunk-N2I2GJW3.js

@@ -0,0 +1,238 @@
+import {
+  parseFrontmatter
+} from "./chunk-IY4A67ZP.js";
+
+// src/plugins/starlight-index-only-sidebar/index.ts
+import { join as join2 } from "path";
+
+// src/plugins/starlight-index-only-sidebar/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+function isDir(filePath) {
+  try {
+    return fs.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function findIndexMd(dirPath) {
+  const indexMd = path.join(dirPath, "index.md");
+  const indexMdx = path.join(dirPath, "index.mdx");
+  try {
+    if (fs.statSync(indexMd).isFile()) return indexMd;
+    if (fs.statSync(indexMdx).isFile()) return indexMdx;
+  } catch {
+  }
+  return null;
+}
+function getSlug(dirPath, rootDir) {
+  const normalized = path.normalize(dirPath).replace(/\\/g, "/");
+  const rootParent = path.normalize(path.dirname(rootDir)).replace(/\\/g, "/");
+  const slug = normalized.startsWith(rootParent) ? normalized.slice(rootParent.length + 1) : normalized;
+  return slug + "/index";
+}
+function hasIndexMdInSubtree(dirPath) {
+  const indexFile = findIndexMd(dirPath);
+  if (indexFile) {
+    const fm = parseFrontmatter(indexFile);
+    if (fm.draft || fm.sidebar?.hidden) return false;
+    return true;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      if (entry === "assets") continue;
+      const fullPath = path.join(dirPath, entry);
+      if (isDir(fullPath) && hasIndexMdInSubtree(fullPath)) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function isGroupItem(item) {
+  return "items" in item;
+}
+function pathSegmentToLabel(pathSegment) {
+  let label = pathSegment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const match = label.match(/^([a-z]+) [0-9]{2,}/i);
+  if (match) {
+    const firstGroup = match[1];
+    const uppercasedFirstGroup = firstGroup.toUpperCase();
+    label = uppercasedFirstGroup + label.substring(firstGroup.length);
+  }
+  return label;
+}
+function buildSidebarItems(dirPath, rootDir, currentDepth, maxDepth, dirnameDeterminesLabels, parentDirName = "") {
+  const items = [];
+  const indexFile = findIndexMd(dirPath);
+  if (indexFile) {
+    const fm = parseFrontmatter(indexFile);
+    if (!fm.draft && !fm.sidebar?.hidden) {
+      let label;
+      if (currentDepth >= maxDepth && parentDirName) {
+        label = parentDirName;
+      } else if (dirnameDeterminesLabels) {
+        label = "Overview";
+      } else {
+        label = fm.title || "Overview";
+      }
+      items.push({
+        label,
+        slug: getSlug(dirPath, rootDir)
+      });
+    }
+  }
+  if (currentDepth >= maxDepth) {
+    const flattenedItems = flattenIndexFilesAtDepth(
+      dirPath,
+      rootDir,
+      dirnameDeterminesLabels
+    );
+    items.push(...flattenedItems);
+    return items;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath).sort();
+    for (const entry of entries) {
+      if (entry === "assets") continue;
+      const fullPath = path.join(dirPath, entry);
+      if (!isDir(fullPath)) continue;
+      if (!hasIndexMdInSubtree(fullPath)) continue;
+      const subItems = buildSidebarItems(
+        fullPath,
+        rootDir,
+        currentDepth + 1,
+        maxDepth,
+        dirnameDeterminesLabels,
+        entry
+      );
+      const hasIndex = findIndexMd(fullPath) !== null;
+      if (!hasIndex) {
+        const allGroups = subItems.length > 0 && subItems.every(isGroupItem);
+        if (allGroups || subItems.length === 1 && isGroupItem(subItems[0])) {
+          items.push(...subItems);
+        } else {
+          items.push({
+            label: pathSegmentToLabel(entry),
+            items: subItems
+          });
+        }
+      } else {
+        items.push({
+          label: pathSegmentToLabel(entry),
+          items: subItems
+        });
+      }
+    }
+  } catch {
+  }
+  return items;
+}
+function flattenIndexFilesAtDepth(dirPath, rootDir, dirnameDeterminesLabels) {
+  const items = [];
+  try {
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      if (entry === "assets") continue;
+      const fullPath = path.join(dirPath, entry);
+      if (!isDir(fullPath)) continue;
+      const indexFile = findIndexMd(fullPath);
+      if (indexFile) {
+        const fm = parseFrontmatter(indexFile);
+        if (!fm.draft && !fm.sidebar?.hidden) {
+          items.push({
+            label: pathSegmentToLabel(entry),
+            slug: getSlug(fullPath, rootDir)
+          });
+        }
+      }
+      items.push(
+        ...flattenIndexFilesAtDepth(fullPath, rootDir, dirnameDeterminesLabels)
+      );
+    }
+  } catch {
+  }
+  return items;
+}
+function getIndexMdSidebarItems(directory, options = {}) {
+  const maxDepth = options.maxDepthNesting ?? 100;
+  const dirnameDeterminesLabels = options.dirnameDeterminesLabels ?? true;
+  const rootDirName = pathSegmentToLabel(path.basename(directory));
+  const items = buildSidebarItems(
+    directory,
+    directory,
+    0,
+    maxDepth,
+    dirnameDeterminesLabels
+  );
+  return [
+    {
+      label: rootDirName,
+      items
+    }
+  ];
+}
+
+// src/plugins/starlight-index-only-sidebar/index.ts
+var SITE_DOCS_ROOT = "./src/content/docs";
+function normalizeSlug(slug) {
+  return slug.endsWith("/index") ? slug.slice(0, -6) : slug;
+}
+function normalizeItems(items) {
+  return items.map((item) => {
+    if ("items" in item) {
+      return {
+        label: item.label,
+        items: normalizeItems(item.items)
+      };
+    }
+    if ("slug" in item) {
+      return {
+        label: item.label,
+        slug: normalizeSlug(item.slug)
+      };
+    }
+    return item;
+  });
+}
+function starlightIndexOnlySidebar(pluginOptions) {
+  return {
+    name: "index-only-sidebar",
+    hooks: {
+      "config:setup": (hookOptions) => {
+        const { updateConfig } = hookOptions;
+        const { directories, maxDepthNesting, dirnameDeterminesLabels } = pluginOptions;
+        const functionOptions = {
+          maxDepthNesting,
+          dirnameDeterminesLabels
+        };
+        const sidebarItems = directories.map((directory) => {
+          const dirPath = join2(SITE_DOCS_ROOT, directory);
+          const rawItems = getIndexMdSidebarItems(dirPath, functionOptions);
+          const rootGroup = rawItems[0];
+          if (!rootGroup || !("items" in rootGroup)) {
+            return void 0;
+          }
+          const items = rootGroup.items || [];
+          const normalizedItems = normalizeItems(items);
+          return {
+            label: rootGroup.label,
+            items: normalizedItems
+          };
+        }).filter(
+          (group) => group !== void 0 && group.items.length > 0
+        );
+        updateConfig({
+          sidebar: sidebarItems
+        });
+      }
+    }
+  };
+}
+
+export {
+  starlightIndexOnlySidebar
+};

package/dist/{chunk-KJ6KZOCD.js → chunk-WZNJ5VFU.js}

@@ -1,6 +1,6 @@
 import {
   parseFrontmatter
-} from "./chunk-3ATSZG6H.js";
+} from "./chunk-IY4A67ZP.js";
 
 // src/plugins/astro-sync-docs-to-public/index.ts
 import { fileURLToPath } from "url";

package/dist/{chunk-TTQY54Q6.js → chunk-XVMRLEQM.js}

@@ -1,6 +1,10 @@
+// src/plugins/astro-latex-compile/index.ts
+import { rm } from "fs/promises";
+import { join as join2, resolve } from "path";
+import { visit, SKIP } from "unist-util-visit";
+
 // src/plugins/astro-latex-compile/utils.ts
 import { createHash } from "crypto";
-import { spawn } from "child_process";
 import {
   existsSync,
   mkdirSync,
@@ -161,8 +165,29 @@ ${formattedSource}
 `;
 }
 
+// src/plugins/utils/process-utils.ts
+import { spawn } from "child_process";
+function execProcess(command, args) {
+  return new Promise((resolve2, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn(command, args);
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      resolve2({ status: code ?? 1, stdout, stderr });
+    });
+  });
+}
+
 // src/plugins/astro-latex-compile/utils.ts
-var LATEX_BLOCK_REGEX = /```(?:tex|latex)\s+compile[^\r\n]*\r?\n([\s\S]*?)\r?\n```/g;
 function hashLatexCode(code) {
   const normalized = code.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("%")).filter(Boolean).join("\n").trim();
   return createHash("md5").update(normalized).digest("hex").slice(0, 16);
@@ -188,25 +213,6 @@ function buildLatexSource(latexCode) {
     "\\end{document}"
   ].join("\n");
 }
-function execProcess(command, args) {
-  return new Promise((resolve, reject) => {
-    let stdout = "";
-    let stderr = "";
-    const proc = spawn(command, args);
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("error", (err) => {
-      reject(err);
-    });
-    proc.on("close", (code) => {
-      resolve({ status: code ?? 1, stdout, stderr });
-    });
-  });
-}
 async function compileLatexToSvg(latexCode, svgOutputDir) {
   const hash = hashLatexCode(latexCode);
   const svgPath = join(svgOutputDir, `${hash}.svg`);
@@ -275,8 +281,91 @@ Error: ${errorOutput}`
   return { hash, svgPath, wasCompiled: true };
 }
 
+// src/plugins/astro-latex-compile/index.ts
+function extractClassesFromMeta(meta) {
+  const classMatch = meta.match(/class="([^"]+)"/);
+  if (classMatch?.[1]) {
+    return classMatch[1].split(/\s+/).filter(Boolean);
+  }
+  return [];
+}
+function remarkLatexCompile(options) {
+  const svgOutputDir = resolve(options.svgOutputDir);
+  return async function transformer(tree, file) {
+    const nodes = [];
+    visit(tree, "code", (node, index, parent) => {
+      if ((node.lang === "tex" || node.lang === "latex") && node.meta?.includes("compile") && parent && index !== void 0) {
+        nodes.push({ node, index, parent });
+      }
+      return SKIP;
+    });
+    if (nodes.length === 0) return;
+    const filePath = file.path || "unknown";
+    const results = await Promise.all(
+      nodes.map(async ({ node, index, parent }) => {
+        const lineNumber = node.position?.start.line ?? "?";
+        try {
+          const result = await compileLatexToSvg(node.value, svgOutputDir);
+          if (result.wasCompiled) {
+            console.log(
+              `[remark-latex-compile] ${filePath}:${lineNumber}: compiled ${result.hash}.svg`
+            );
+          }
+          options._referencedHashes?.add(result.hash);
+          return { index, parent, result, error: null, hash: result.hash };
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          const match = errorMsg.match(/\n\n([\s\S]+)/);
+          const details = match ? match[1] : errorMsg;
+          console.error(
+            `[remark-latex-compile] ${filePath}:${lineNumber}
+${details}`
+          );
+          return { index, parent, result: null, error: err, hash: null };
+        }
+      })
+    );
+    if (options._fileHashMap) {
+      const newHashes = new Set(
+        results.map((r) => r.hash).filter(Boolean)
+      );
+      const oldHashes = options._fileHashMap.get(filePath) ?? /* @__PURE__ */ new Set();
+      const staleHashes = [...oldHashes].filter((h) => !newHashes.has(h));
+      for (const staleHash of staleHashes) {
+        console.warn(
+          `[remark-latex-compile] Removing orphaned svg: ${staleHash}.svg`
+        );
+      }
+      await Promise.all(
+        staleHashes.map(
+          (h) => rm(join2(svgOutputDir, `${h}.svg`), { force: true })
+        )
+      );
+      options._fileHashMap.set(filePath, newHashes);
+    }
+    for (let i = results.length - 1; i >= 0; i--) {
+      const { index, parent, result } = results[i];
+      const { node } = nodes[i];
+      if (!result) continue;
+      const customClasses = extractClassesFromMeta(node.meta ?? "");
+      const imageNode = {
+        type: "image",
+        url: `/static/tex-svgs/${result.hash}.svg`,
+        alt: "LaTeX diagram",
+        data: {
+          hProperties: { className: ["tex-compiled", ...customClasses] }
+        }
+      };
+      const paragraph = {
+        type: "paragraph",
+        children: [imageNode]
+      };
+      parent.children.splice(index, 1, paragraph);
+    }
+  };
+}
+
 export {
-  LATEX_BLOCK_REGEX,
-  hashLatexCode,
-  compileLatexToSvg
+  compileLatexToSvg,
+  remarkLatexCompile
 };

package/dist/cpp-VZKLUKT7.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-ICUS267J.js";
 import "./chunk-MT4FGOLU.js";
 import "./chunk-YJV35WLF.js";
-import "./chunk-IWM27JZF.js";
 import "./chunk-XOMTOLBK.js";
+import "./chunk-IWM27JZF.js";
 import "./chunk-QGM4M3NI.js";
 export {
   cpp_default as default

package/dist/{erb-5EKNOWNJ.js → erb-WAGUANI2.js}

@@ -1,17 +1,17 @@
 import {
   ruby_default
-} from "./chunk-26NQJBXH.js";
+} from "./chunk-7DJE5LRN.js";
 import "./chunk-ZSX4GOHC.js";
-import "./chunk-NE25QJUZ.js";
 import "./chunk-OII47WE4.js";
 import "./chunk-76C5RMV7.js";
 import "./chunk-S3SFQXYS.js";
+import "./chunk-NE25QJUZ.js";
 import "./chunk-ICUS267J.js";
 import "./chunk-MT4FGOLU.js";
 import "./chunk-YJV35WLF.js";
 import "./chunk-5TDK5Y5S.js";
-import "./chunk-IWM27JZF.js";
 import "./chunk-XOMTOLBK.js";
+import "./chunk-IWM27JZF.js";
 import "./chunk-VB3O6QM4.js";
 import "./chunk-QFOAKHDY.js";
 import "./chunk-AZIN3OHL.js";

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { SyncDocsToPublicOptions, syncDocsToPublic } from './plugins/astro-sync-
 export { default as rehypeValidateLinks } from './plugins/rehype-validate-links.js';
 export { astroNormalizePaths } from './plugins/astro-normalize-paths.js';
 import { RemarkLatexCompileOptions } from './plugins/astro-latex-compile.js';
-export { rehypeLatexCompile, default as remarkLatexCompile } from './plugins/astro-latex-compile.js';
+export { default as remarkLatexCompile } from './plugins/astro-latex-compile.js';
 import { AstroIntegration } from 'astro';
 import '@astrojs/starlight/types';
 import 'hast';

package/dist/index.js

@@ -1,21 +1,19 @@
 import {
   starlightIndexOnlySidebar
-} from "./chunk-HDL4DZNT.js";
+} from "./chunk-N2I2GJW3.js";
 import {
   rehypeValidateLinks
 } from "./chunk-FQLJMU2J.js";
 import {
-  rehypeLatexCompile,
   remarkLatexCompile
-} from "./chunk-IX5UFISR.js";
+} from "./chunk-XVMRLEQM.js";
 import {
   astroNormalizePaths
 } from "./chunk-AZPHBHBE.js";
 import {
   syncDocsToPublic
-} from "./chunk-KJ6KZOCD.js";
-import "./chunk-3ATSZG6H.js";
-import "./chunk-TTQY54Q6.js";
+} from "./chunk-WZNJ5VFU.js";
+import "./chunk-IY4A67ZP.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/plugins/astro-latex-compile/astro-integration.ts
@@ -82,7 +80,6 @@ function astroLatexCompile(options) {
 export {
   astroLatexCompile,
   astroNormalizePaths,
-  rehypeLatexCompile,
   rehypeValidateLinks,
   remarkLatexCompile,
   starlightIndexOnlySidebar,