fromsrc 0.0.2 → 0.0.21

package/dist/hooks/windowsize.js

@@ -2,10 +2,10 @@
 import { useState, useEffect } from 'react';
 
 function useWindowSize() {
-  const [size, setSize] = useState({ width: 0, height: 0 });
+  const [size, setSize] = useState({ height: 0, width: 0 });
   useEffect(() => {
     function update() {
-      setSize({ width: window.innerWidth, height: window.innerHeight });
+      setSize({ height: window.innerHeight, width: window.innerWidth });
     }
     update();
     window.addEventListener("resize", update, { passive: true });

package/dist/i18n.d.ts

@@ -22,9 +22,9 @@ declare function delocalizePath(path: string, config: I18nConfig): LocalizedPath
 declare function resolveContent(path: string, locale: string, config: I18nConfig): string[];
 declare function generateAlternates(path: string, config: I18nConfig): I18nResult;
 declare function createI18n(config: I18nConfig): {
-    resolve: (path: string, locale: string) => string[];
-    localize: (path: string, locale: string) => string;
     delocalize: (path: string) => LocalizedPath;
+    localize: (path: string, locale: string) => string;
+    resolve: (path: string, locale: string) => string[];
 };
 
 export { type I18nConfig, type I18nResult, type LocalizedPath, createI18n, delocalizePath, detectLocale, generateAlternates, localizePath, resolveContent };

package/dist/i18n.js

@@ -1,23 +1,36 @@
 function detectLocale(acceptLanguage, locales, fallback) {
-  if (!acceptLanguage) return fallback;
+  if (!acceptLanguage) {
+    return fallback;
+  }
   const set = new Set(locales);
   const entries = acceptLanguage.split(",").map((part) => {
     const [lang, ...params] = part.trim().split(";");
     const qp = params.find((p) => p.trim().startsWith("q="));
     const q = qp ? Number.parseFloat(qp.trim().slice(2)) : 1;
-    return { lang: (lang ?? "").trim().toLowerCase(), q: Number.isNaN(q) ? 0 : q };
+    return {
+      lang: (lang ?? "").trim().toLowerCase(),
+      q: Number.isNaN(q) ? 0 : q
+    };
   }).sort((a, b) => b.q - a.q);
   for (const { lang } of entries) {
-    if (set.has(lang)) return lang;
+    if (set.has(lang)) {
+      return lang;
+    }
     const base = lang.split("-")[0];
-    if (!base) continue;
-    if (set.has(base)) return base;
+    if (!base) {
+      continue;
+    }
+    if (set.has(base)) {
+      return base;
+    }
   }
   return fallback;
 }
 function localizePath(path, locale, config) {
   const clean = path.startsWith("/") ? path : `/${path}`;
-  if (locale === config.defaultLocale && !config.pathPrefix) return clean;
+  if (locale === config.defaultLocale && !config.pathPrefix) {
+    return clean;
+  }
   return `/${locale}${clean === "/" ? "" : clean}`;
 }
 function delocalizePath(path, config) {
@@ -28,14 +41,14 @@ function delocalizePath(path, config) {
     const rest = segments.slice(1).join("/");
     return {
       locale: first,
-      path: `/${rest}` || "/",
-      originalPath: clean
+      originalPath: clean,
+      path: `/${rest}` || "/"
     };
   }
   return {
     locale: config.defaultLocale,
-    path: clean,
-    originalPath: clean
+    originalPath: clean,
+    path: clean
   };
 }
 function resolveContent(path, locale, config) {
@@ -57,16 +70,16 @@ function generateAlternates(path, config) {
     path: localizePath(stripped, l, config)
   }));
   return {
+    alternates,
     locale,
-    path: localizePath(stripped, locale, config),
-    alternates
+    path: localizePath(stripped, locale, config)
   };
 }
 function createI18n(config) {
   return {
-    resolve: (path, locale) => resolveContent(path, locale, config),
+    delocalize: (path) => delocalizePath(path, config),
     localize: (path, locale) => localizePath(path, locale, config),
-    delocalize: (path) => delocalizePath(path, config)
+    resolve: (path, locale) => resolveContent(path, locale, config)
   };
 }
 

package/dist/index.d.ts

@@ -105,6 +105,7 @@ export { remarkToc } from './remarktoc.js';
 export { remarkFootnote } from './remarkfootnote.js';
 export { remarkBadge } from './remarkbadge.js';
 export { remarkColumns } from './remarkcolumns.js';
+export { SidebarScript } from './components/sidebarscript.js';
 export { OpenApiEndpoint, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiSchema, OpenApiSpec, OpenApiTag, generateEndpointSlug } from './openapiutil.js';
 export { z } from 'zod';
 import 'react';

package/dist/index.js

@@ -105,3 +105,4 @@ export { remarkToc } from './remarktoc';
 export { remarkFootnote } from './remarkfootnote';
 export { remarkBadge } from './remarkbadge';
 export { remarkColumns } from './remarkcolumns';
+export { SidebarScript } from './components/sidebarscript';

package/dist/lastmodified.js

@@ -2,11 +2,17 @@ import { execFileSync } from 'node:child_process';
 
 function lastModified(filepath) {
   try {
-    const result = execFileSync("git", ["log", "-1", "--format=%cI", filepath], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (!result) return null;
+    const result = execFileSync(
+      "git",
+      ["log", "-1", "--format=%cI", filepath],
+      {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    ).trim();
+    if (!result) {
+      return null;
+    }
     const value = new Date(result);
     return Number.isNaN(value.getTime()) ? null : value;
   } catch {

package/dist/linkcheck.d.ts

@@ -1,19 +1,19 @@
-type LinkCheckResult = {
+interface LinkCheckResult {
     source: string;
     href: string;
     type: "internal" | "anchor" | "external";
     status: "ok" | "broken" | "unknown";
-};
-type LinkCheckConfig = {
+}
+interface LinkCheckConfig {
     dir: string;
     extensions?: string[];
     baseUrl?: string;
-};
-type LinkCheckReport = {
+}
+interface LinkCheckReport {
     total: number;
     broken: number;
     results: LinkCheckResult[];
-};
+}
 declare function isInternalLink(href: string): boolean;
 declare function resolveLink(source: string, href: string): string;
 declare function extractLinks(content: string, source: string): {

package/dist/linkcheck.js

@@ -8,7 +8,9 @@ function isInternalLink(href) {
   return href.startsWith("/") || href.startsWith("./") || href.startsWith("../") || href.startsWith("#");
 }
 function resolveLink(source, href) {
-  if (href.startsWith("/")) return href;
+  if (href.startsWith("/")) {
+    return href;
+  }
   return resolve(dirname(source), href);
 }
 function extractLinks(content, source) {
@@ -18,9 +20,13 @@ function extractLinks(content, source) {
   const reference = /\[([^\]]*)\]\[([^\]]+)\]/g;
   for (const m of content.matchAll(inline)) {
     const raw = m[2];
-    if (!raw) continue;
+    if (!raw) {
+      continue;
+    }
     const href = raw.split(/\s/)[0];
-    if (!href) continue;
+    if (!href) {
+      continue;
+    }
     if (!seen.has(href)) {
       seen.add(href);
       results.push({ href, type: linktype(href) });
@@ -28,12 +34,18 @@ function extractLinks(content, source) {
   }
   for (const m of content.matchAll(reference)) {
     const ref = m[2];
-    if (!ref) continue;
-    const pattern = new RegExp(`\\[${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]:\\s*(.+)`);
+    if (!ref) {
+      continue;
+    }
+    const pattern = new RegExp(
+      `\\[${ref.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]:\\s*(.+)`
+    );
     const def = content.match(pattern);
     if (def) {
       const raw = def[1];
-      if (!raw) continue;
+      if (!raw) {
+        continue;
+      }
       const href = raw.trim();
       if (!seen.has(href)) {
         seen.add(href);
@@ -44,7 +56,9 @@ function extractLinks(content, source) {
   return results;
 }
 function linktype(href) {
-  if (href.startsWith("#")) return "anchor";
+  if (href.startsWith("#")) {
+    return "anchor";
+  }
   if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:")) {
     return "external";
   }
@@ -76,31 +90,58 @@ async function checkInternalLinks(config) {
   const files = await gather(config.dir, exts);
   const results = [];
   for (const filepath of files) {
-    const content = await readFile(filepath, "utf-8");
+    const content = await readFile(filepath, "utf8");
     const links = extractLinks(content);
     for (const link of links) {
       if (link.type === "external") {
-        results.push({ source: filepath, href: link.href, type: "external", status: "unknown" });
+        results.push({
+          href: link.href,
+          source: filepath,
+          status: "unknown",
+          type: "external"
+        });
         continue;
       }
       if (link.type === "anchor") {
         const slug = link.href.slice(1);
-        const heading = new RegExp(`^#{1,6}\\s+.*${slug.replace(/-/g, "[\\s-]")}`, "im");
+        const heading = new RegExp(
+          `^#{1,6}\\s+.*${slug.replaceAll("-", "[\\s-]")}`,
+          "im"
+        );
         const status = heading.test(content) ? "ok" : "broken";
-        results.push({ source: filepath, href: link.href, type: "anchor", status });
+        results.push({
+          href: link.href,
+          source: filepath,
+          status,
+          type: "anchor"
+        });
         continue;
       }
       const clean = link.href.split("#")[0]?.split("?")[0] ?? "";
       if (!clean) {
-        results.push({ source: filepath, href: link.href, type: "internal", status: "broken" });
+        results.push({
+          href: link.href,
+          source: filepath,
+          status: "broken",
+          type: "internal"
+        });
         continue;
       }
       const resolved = resolveLink(filepath, clean);
       const found = await exists(resolved) || await exists(`${resolved}.md`) || await exists(`${resolved}.mdx`) || await exists(join(resolved, "index.md")) || await exists(join(resolved, "index.mdx"));
-      results.push({ source: filepath, href: link.href, type: "internal", status: found ? "ok" : "broken" });
+      results.push({
+        href: link.href,
+        source: filepath,
+        status: found ? "ok" : "broken",
+        type: "internal"
+      });
     }
   }
-  return { total: results.length, broken: results.filter((r) => r.status === "broken").length, results };
+  return {
+    broken: results.filter((r) => r.status === "broken").length,
+    results,
+    total: results.length
+  };
 }
 function formatReport(report) {
   const lines = [`${report.total} links, ${report.broken} broken`];

package/dist/llms.js

@@ -1,5 +1,7 @@
 function clean(path) {
-  if (!path.startsWith("/")) return `/${path}`;
+  if (!path.startsWith("/")) {
+    return `/${path}`;
+  }
   return path;
 }
 function formatEntry(baseUrl, docsPath, doc) {
@@ -10,7 +12,14 @@ function formatEntry(baseUrl, docsPath, doc) {
 }
 function generateLlmsIndex(config, docs) {
   const docsPath = clean(config.docsPath ?? "/docs");
-  const lines = [`# ${config.title}`, "", config.description, "", "## pages", ""];
+  const lines = [
+    `# ${config.title}`,
+    "",
+    config.description,
+    "",
+    "## pages",
+    ""
+  ];
   for (const doc of docs) {
     lines.push(formatEntry(config.baseUrl, docsPath, doc));
   }
@@ -18,7 +27,14 @@ function generateLlmsIndex(config, docs) {
 }
 function generateLlmsFull(config, docs) {
   const docsPath = clean(config.docsPath ?? "/docs");
-  const lines = [`# ${config.title}`, "", config.description, "", "## pages", ""];
+  const lines = [
+    `# ${config.title}`,
+    "",
+    config.description,
+    "",
+    "## pages",
+    ""
+  ];
   for (const doc of docs) {
     lines.push(formatEntry(config.baseUrl, docsPath, doc));
   }
@@ -33,7 +49,7 @@ function generateLlmsFull(config, docs) {
   return lines.join("\n");
 }
 function escapeMarkdown(text) {
-  return text.replace(/[[\]()\\]/g, "\\$&");
+  return text.replaceAll(/[[\]()\\]/g, "\\$&");
 }
 
 export { generateLlmsFull, generateLlmsIndex };

package/dist/manifest.js

@@ -1,27 +1,27 @@
 import { extractHeadings } from './content';
 
 function countWords(content) {
-  return content.replace(/```[\s\S]*?```/g, "").replace(/<[^>]+>/g, " ").replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, "").replace(/\s+/g, " ").trim().split(" ").filter((w) => w.length > 0).length;
+  return content.replaceAll(/```[\s\S]*?```/g, "").replaceAll(/<[^>]+>/g, " ").replaceAll(/import\s+.*?from\s+['"][^'"]+['"];?/g, "").replaceAll(/\s+/g, " ").trim().split(" ").filter((w) => w.length > 0).length;
 }
 function toManifestPage(doc) {
   const headings = extractHeadings(doc.content).map((h) => ({
     depth: h.level,
-    text: h.text,
-    id: h.id
+    id: h.id,
+    text: h.text
   }));
   return {
-    slug: doc.slug,
-    title: doc.title,
     description: doc.description,
     headings,
+    slug: doc.slug,
+    title: doc.title,
     wordCount: countWords(doc.content)
   };
 }
 function generateManifest(docs) {
   return {
-    version: 1,
     generated: (/* @__PURE__ */ new Date()).toISOString(),
-    pages: docs.map(toManifestPage)
+    pages: docs.map(toManifestPage),
+    version: 1
   };
 }
 function generateManifestJson(docs) {

package/dist/mcp.js

@@ -3,18 +3,17 @@ import { trimquery } from './searchpolicy';
 
 function generateMcpManifest(config) {
   return {
-    server: { name: config.name, version: config.version },
     capabilities: {
-      tools: {
+      resources: {
         listChanged: false
       },
-      resources: {
+      tools: {
         listChanged: false
       }
     },
+    server: { name: config.name, version: config.version },
     tools: [
       {
-        name: "search_docs",
         description: "Search documentation",
         inputSchema: {
           type: "object",
@@ -22,10 +21,10 @@ function generateMcpManifest(config) {
             query: { type: "string", description: "Search query" }
           },
           required: ["query"]
-        }
+        },
+        name: "search_docs"
       },
       {
-        name: "get_page",
         description: "Get a specific documentation page",
         inputSchema: {
           type: "object",
@@ -33,39 +32,46 @@ function generateMcpManifest(config) {
             slug: { type: "string", description: "Page slug" }
           },
           required: ["slug"]
-        }
+        },
+        name: "get_page"
       },
       {
-        name: "list_pages",
         description: "List all available documentation pages",
-        inputSchema: { type: "object" }
+        inputSchema: { type: "object" },
+        name: "list_pages"
       }
     ]
   };
 }
 function createMcpHandler(config, source) {
   return {
-    async search(query) {
-      if (!source.search) return [];
-      const docs = await source.search();
-      const results = await Promise.resolve(localSearch.search(trimquery(query), docs, 10));
-      return results.map((item) => ({
-        slug: item.doc.slug,
-        title: item.doc.title,
-        snippet: item.snippet ?? item.doc.description ?? item.doc.content.slice(0, 120)
-      }));
-    },
     async getPage(slug) {
       const result = await source.get(slug.split("/"));
-      if (!result) return null;
+      if (!result) {
+        return null;
+      }
       return result.content;
     },
     async listPages() {
       const docs = await source.list();
       return docs.map((d) => ({
+        description: d.description,
         slug: d.slug,
-        title: d.title,
-        description: d.description
+        title: d.title
+      }));
+    },
+    async search(query) {
+      if (!source.search) {
+        return [];
+      }
+      const docs = await source.search();
+      const results = await Promise.resolve(
+        localSearch.search(trimquery(query), docs, 10)
+      );
+      return results.map((item) => ({
+        slug: item.doc.slug,
+        snippet: item.snippet ?? item.doc.description ?? item.doc.content.slice(0, 120),
+        title: item.doc.title
       }));
     }
   };

package/dist/mdtoc.d.ts

@@ -1,13 +1,13 @@
-type TocItem = {
+interface TocItem {
     level: number;
     text: string;
     slug: string;
-};
-type TocOptions = {
+}
+interface TocOptions {
     minLevel?: number;
     maxLevel?: number;
     ordered?: boolean;
-};
+}
 declare function extractToc(content: string): TocItem[];
 declare function generateTocMarkdown(items: TocItem[], options?: TocOptions): string;
 declare function removeToc(content: string): string;

package/dist/mdtoc.js

@@ -1,5 +1,5 @@
 function slugify(text) {
-  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return text.toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z0-9_-]/g, "").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
 }
 function extractToc(content) {
   const items = [];
@@ -10,15 +10,21 @@ function extractToc(content) {
       inCodeBlock = !inCodeBlock;
       continue;
     }
-    if (inCodeBlock) continue;
+    if (inCodeBlock) {
+      continue;
+    }
     const match = line.match(/^(#{1,6})\s+(.+)$/);
-    if (!match) continue;
+    if (!match) {
+      continue;
+    }
     const hashes = match[1];
     const heading = match[2];
-    if (!hashes || !heading) continue;
+    if (!hashes || !heading) {
+      continue;
+    }
     const level = hashes.length;
     const text = heading.trim();
-    items.push({ level, text, slug: slugify(text) });
+    items.push({ level, slug: slugify(text), text });
   }
   return items;
 }

package/dist/mdxscope.d.ts

@@ -2,11 +2,11 @@ import { ComponentType } from 'react';
 
 type MdxComponent = ComponentType<unknown>;
 type MdxScope = Record<string, MdxComponent>;
-type MdxScopeConfig = {
+interface MdxScopeConfig {
     defaults?: MdxScope;
     overrides?: MdxScope;
     aliases?: Record<string, string>;
-};
+}
 declare function createScope(config?: MdxScopeConfig): MdxScope;
 declare function mergeScopes(...scopes: MdxScope[]): MdxScope;
 declare function withDefaults(scope: MdxScope, defaults: MdxScope): MdxScope;

package/dist/mdxscope.js

@@ -1,5 +1,7 @@
 function createScope(config) {
-  if (!config) return {};
+  if (!config) {
+    return {};
+  }
   const base = { ...config.defaults };
   if (config.overrides) {
     for (const [key, value] of Object.entries(config.overrides)) {

package/dist/meta.js

@@ -7,22 +7,34 @@ function isrecord(value) {
   return typeof value === "object" && value !== null;
 }
 function isMetaFile(data) {
-  if (!isrecord(data)) return false;
+  if (!isrecord(data)) {
+    return false;
+  }
   const obj = data;
-  if (obj.title !== void 0 && typeof obj.title !== "string") return false;
-  if (obj.icon !== void 0 && typeof obj.icon !== "string") return false;
-  if (obj.pages !== void 0 && !Array.isArray(obj.pages)) return false;
-  if (Array.isArray(obj.pages) && !obj.pages.every((p) => typeof p === "string")) return false;
+  if (obj.title !== void 0 && typeof obj.title !== "string") {
+    return false;
+  }
+  if (obj.icon !== void 0 && typeof obj.icon !== "string") {
+    return false;
+  }
+  if (obj.pages !== void 0 && !Array.isArray(obj.pages)) {
+    return false;
+  }
+  if (Array.isArray(obj.pages) && !obj.pages.every((p) => typeof p === "string")) {
+    return false;
+  }
   return true;
 }
 async function loadMeta(dir) {
   if (isProduction()) {
     const cached = metaCache.get(dir);
-    if (cached !== void 0) return cached;
+    if (cached !== void 0) {
+      return cached;
+    }
   }
   const filepath = join(dir, "_meta.json");
   try {
-    const content = await readFile(filepath, "utf-8");
+    const content = await readFile(filepath, "utf8");
     const data = JSON.parse(content);
     if (!isMetaFile(data)) {
       if (isProduction()) {