fromsrc 0.0.2 → 0.0.21

package/dist/stats.js

@@ -7,7 +7,7 @@ function analyzePage(content, path) {
   const links = (content.match(/\[([^\]]*)\]\(([^)]*)\)/g) || []).length;
   const images = (content.match(/!\[([^\]]*)\]\(([^)]*)\)/g) || []).length;
   const codeBlocks = Math.floor((content.match(/^```/gm) || []).length / 2);
-  return { path, words, headings, links, codeBlocks, images };
+  return { codeBlocks, headings, images, links, path, words };
 }
 function extractLanguages(content) {
   const langs = {};
@@ -21,8 +21,11 @@ async function collectFiles(dir) {
   const files = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
     const full = join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...await collectFiles(full));
-    else if ([".md", ".mdx"].includes(extname(entry.name))) files.push(full);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(full));
+    } else if ([".md", ".mdx"].includes(extname(entry.name))) {
+      files.push(full);
+    }
   }
   return files;
 }
@@ -32,25 +35,28 @@ async function analyzeDocs(dir) {
   const languages = {};
   let latest = "";
   for (const file of files) {
-    const content = await readFile(file, "utf-8");
+    const content = await readFile(file, "utf8");
     const modified = (await stat(file)).mtime.toISOString();
-    if (modified > latest) latest = modified;
+    if (modified > latest) {
+      latest = modified;
+    }
     pages.push(analyzePage(content, relative(dir, file)));
-    for (const [lang, count] of Object.entries(extractLanguages(content)))
+    for (const [lang, count] of Object.entries(extractLanguages(content))) {
       languages[lang] = (languages[lang] || 0) + count;
+    }
   }
   const totalWords = pages.reduce((s, p) => s + p.words, 0);
   const sum = (fn) => pages.reduce((s, p) => s + fn(p), 0);
   return {
-    totalPages: pages.length,
-    totalWords,
     avgWords: pages.length ? Math.round(totalWords / pages.length) : 0,
-    totalHeadings: sum((p) => p.headings),
-    totalLinks: sum((p) => p.links),
+    languages,
+    lastUpdated: latest || (/* @__PURE__ */ new Date()).toISOString(),
     totalCodeBlocks: sum((p) => p.codeBlocks),
+    totalHeadings: sum((p) => p.headings),
     totalImages: sum((p) => p.images),
-    languages,
-    lastUpdated: latest || (/* @__PURE__ */ new Date()).toISOString()
+    totalLinks: sum((p) => p.links),
+    totalPages: pages.length,
+    totalWords
   };
 }
 function formatStats(stats) {

package/dist/testing.d.ts

@@ -1,23 +1,23 @@
-type TestCase = {
+interface TestCase {
     name: string;
     fn: () => Promise<void> | void;
-};
-type TestResult = {
+}
+interface TestResult {
     name: string;
     passed: boolean;
     error?: string;
     duration: number;
-};
-type TestSuite = {
+}
+interface TestSuite {
     name: string;
     results: TestResult[];
     passed: number;
     failed: number;
     duration: number;
-};
+}
 declare function createTestSuite(name: string): {
-    test: (caseName: string, fn: () => Promise<void> | void) => void;
     run: () => Promise<TestSuite>;
+    test: (caseName: string, fn: () => Promise<void> | void) => void;
 };
 declare function assertFrontmatter(content: string, fields: string[]): void;
 declare function assertHeadings(content: string, options?: {

package/dist/testing.js

@@ -1,17 +1,19 @@
 function headingid(value) {
-  return value.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+  return value.toLowerCase().replaceAll(/[^\w\s-]/g, "").trim().replaceAll(/\s+/g, "-");
 }
 function collectheadingids(content) {
   return [...content.matchAll(/^#{1,6}\s+(.+)$/gm)].map((match) => {
     const value = match[1];
-    if (!value) return "";
+    if (!value) {
+      return "";
+    }
     return headingid(value);
   }).filter(Boolean);
 }
 function createTestSuite(name) {
   const cases = [];
   function test(caseName, fn) {
-    cases.push({ name: caseName, fn });
+    cases.push({ fn, name: caseName });
   }
   async function run() {
     const results = [];
@@ -20,63 +22,87 @@ function createTestSuite(name) {
       const t = performance.now();
       try {
         await c.fn();
-        results.push({ name: c.name, passed: true, duration: performance.now() - t });
-      } catch (e) {
         results.push({
+          duration: performance.now() - t,
           name: c.name,
-          passed: false,
-          error: e instanceof Error ? e.message : String(e),
-          duration: performance.now() - t
+          passed: true
+        });
+      } catch (error) {
+        results.push({
+          duration: performance.now() - t,
+          error: error instanceof Error ? error.message : String(error),
+          name: c.name,
+          passed: false
         });
       }
     }
     return {
+      duration: performance.now() - start,
+      failed: results.filter((r) => !r.passed).length,
       name,
-      results,
       passed: results.filter((r) => r.passed).length,
-      failed: results.filter((r) => !r.passed).length,
-      duration: performance.now() - start
+      results
     };
   }
-  return { test, run };
+  return { run, test };
 }
 function assertFrontmatter(content, fields) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) throw new Error("missing frontmatter");
+  if (!match) {
+    throw new Error("missing frontmatter");
+  }
   const body = match[1];
-  if (!body) throw new Error("invalid frontmatter");
+  if (!body) {
+    throw new Error("invalid frontmatter");
+  }
   const lines = body.split("\n");
   const values = /* @__PURE__ */ new Map();
   for (const line of lines) {
     const index = line.indexOf(":");
-    if (index < 1) continue;
+    if (index < 1) {
+      continue;
+    }
     const key = line.slice(0, index).trim();
-    if (!key) continue;
-    if (values.has(key)) throw new Error(`duplicate field: ${key}`);
+    if (!key) {
+      continue;
+    }
+    if (values.has(key)) {
+      throw new Error(`duplicate field: ${key}`);
+    }
     const value = line.slice(index + 1).trim();
     values.set(key, value);
   }
   for (const field of fields) {
-    if (!values.has(field)) throw new Error(`missing field: ${field}`);
+    if (!values.has(field)) {
+      throw new Error(`missing field: ${field}`);
+    }
     const value = values.get(field) ?? "";
-    if (!value) throw new Error(`empty field: ${field}`);
+    if (!value) {
+      throw new Error(`empty field: ${field}`);
+    }
   }
 }
 function assertHeadings(content, options) {
   const ids = collectheadingids(content);
   const seen = /* @__PURE__ */ new Set();
   for (const id of ids) {
-    if (seen.has(id)) throw new Error(`duplicate heading id: ${id}`);
+    if (seen.has(id)) {
+      throw new Error(`duplicate heading id: ${id}`);
+    }
     seen.add(id);
   }
   const headings = [...content.matchAll(/^(#{1,6})\s+/gm)].map((m) => m[1]?.length ?? 0).filter((level) => level > 0);
   if (options?.minCount && headings.length < options.minCount) {
-    throw new Error(`expected at least ${options.minCount} headings, found ${headings.length}`);
+    throw new Error(
+      `expected at least ${options.minCount} headings, found ${headings.length}`
+    );
   }
   if (options?.maxDepth) {
     for (const level of headings) {
       if (level > options.maxDepth) {
-        throw new Error(`heading h${level} exceeds max depth ${options.maxDepth}`);
+        throw new Error(
+          `heading h${level} exceeds max depth ${options.maxDepth}`
+        );
       }
     }
   }
@@ -84,19 +110,32 @@ function assertHeadings(content, options) {
     for (let i = 1; i < headings.length; i++) {
       const current = headings[i];
       const previous = headings[i - 1];
-      if (!current || !previous) continue;
+      if (!current || !previous) {
+        continue;
+      }
       if (current > previous + 1) {
-        throw new Error(`heading h${headings[i]} skips level after h${headings[i - 1]}`);
+        throw new Error(
+          `heading h${headings[i]} skips level after h${headings[i - 1]}`
+        );
       }
     }
   }
 }
 function assertLinks(content) {
-  const placeholders = /* @__PURE__ */ new Set(["#", "todo", "http://", "https://", "about:blank", "javascript:void(0)"]);
+  const placeholders = /* @__PURE__ */ new Set([
+    "#",
+    "todo",
+    "http://",
+    "https://",
+    "about:blank",
+    "javascript:void(0)"
+  ]);
   const headingids = new Set(collectheadingids(content));
   const links = [...content.matchAll(/\[([^\]]*)\]\(([^)]*)\)/g)];
   for (const [, text = "", url = ""] of links) {
-    if (!text.trim()) throw new Error("empty link text");
+    if (!text.trim()) {
+      throw new Error("empty link text");
+    }
     const value = url.trim();
     const lowered = value.toLowerCase();
     if (!value || placeholders.has(lowered)) {
@@ -113,10 +152,14 @@ function assertLinks(content) {
 function assertLength(content, options) {
   const words = content.replace(/^---\n[\s\S]*?\n---\n?/, "").split(/\s+/).filter(Boolean).length;
   if (options.minWords && words < options.minWords) {
-    throw new Error(`expected at least ${options.minWords} words, found ${words}`);
+    throw new Error(
+      `expected at least ${options.minWords} words, found ${words}`
+    );
   }
   if (options.maxWords && words > options.maxWords) {
-    throw new Error(`expected at most ${options.maxWords} words, found ${words}`);
+    throw new Error(
+      `expected at most ${options.maxWords} words, found ${words}`
+    );
   }
 }
 function formatTestSuite(suite) {
@@ -126,7 +169,9 @@ function formatTestSuite(suite) {
   for (const r of suite.results) {
     const status = r.passed ? "pass" : "FAIL";
     lines.push(`  ${status} ${r.name} (${Math.round(r.duration)}ms)`);
-    if (r.error) lines.push(`       ${r.error}`);
+    if (r.error) {
+      lines.push(`       ${r.error}`);
+    }
   }
   return lines.join("\n");
 }

package/dist/themeutil.d.ts

@@ -1,4 +1,4 @@
-type ThemeColors = {
+interface ThemeColors {
     bg: string;
     surface: string;
     fg: string;
@@ -10,18 +10,18 @@ type ThemeColors = {
     warning: string;
     error: string;
     info: string;
-};
-type ThemeConfig = {
+}
+interface ThemeConfig {
     light: ThemeColors;
     dark: ThemeColors;
     radius?: string;
     font?: string;
     mono?: string;
-};
-type ThemePreset = {
+}
+interface ThemePreset {
     name: string;
     config: ThemeConfig;
-};
+}
 declare function generateCss(config: ThemeConfig): string;
 declare const presets: Record<string, ThemePreset>;
 declare function mergeTheme(base: ThemeConfig, overrides: Partial<ThemeConfig>): ThemeConfig;

package/dist/themeutil.js

@@ -12,56 +12,174 @@ const colorKeys = [
   "info"
 ];
 function colors(bg, surface, fg, muted, dim, accent, line, success, warning, error, info) {
-  return { bg, surface, fg, muted, dim, accent, line, success, warning, error, info };
+  return {
+    accent,
+    bg,
+    dim,
+    error,
+    fg,
+    info,
+    line,
+    muted,
+    success,
+    surface,
+    warning
+  };
 }
 function generateCss(config) {
   const lines = [":root {"];
-  for (const key of colorKeys) lines.push(`	--${key}: ${config.light[key]};`);
-  if (config.radius) lines.push(`	--radius: ${config.radius};`);
-  if (config.font) lines.push(`	--font: ${config.font};`);
-  if (config.mono) lines.push(`	--mono: ${config.mono};`);
+  for (const key of colorKeys) {
+    lines.push(`	--${key}: ${config.light[key]};`);
+  }
+  if (config.radius) {
+    lines.push(`	--radius: ${config.radius};`);
+  }
+  if (config.font) {
+    lines.push(`	--font: ${config.font};`);
+  }
+  if (config.mono) {
+    lines.push(`	--mono: ${config.mono};`);
+  }
   lines.push("}", "", ".dark {");
-  for (const key of colorKeys) lines.push(`	--${key}: ${config.dark[key]};`);
+  for (const key of colorKeys) {
+    lines.push(`	--${key}: ${config.dark[key]};`);
+  }
   lines.push("}");
   return lines.join("\n");
 }
 const presets = {
   default: {
-    name: "default",
     config: {
-      light: colors("#ffffff", "#f8f9fa", "#1a1a1a", "#6b7280", "#9ca3af", "#2563eb", "#e5e7eb", "#16a34a", "#ca8a04", "#dc2626", "#2563eb"),
-      dark: colors("#0a0a0a", "#141414", "#f5f5f5", "#a1a1aa", "#71717a", "#3b82f6", "#27272a", "#22c55e", "#eab308", "#ef4444", "#3b82f6")
-    }
+      light: colors(
+        "#ffffff",
+        "#f8f9fa",
+        "#1a1a1a",
+        "#6b7280",
+        "#9ca3af",
+        "#2563eb",
+        "#e5e7eb",
+        "#16a34a",
+        "#ca8a04",
+        "#dc2626",
+        "#2563eb"
+      ),
+      dark: colors(
+        "#0a0a0a",
+        "#141414",
+        "#f5f5f5",
+        "#a1a1aa",
+        "#71717a",
+        "#3b82f6",
+        "#27272a",
+        "#22c55e",
+        "#eab308",
+        "#ef4444",
+        "#3b82f6"
+      )
+    },
+    name: "default"
   },
-  ocean: {
-    name: "ocean",
+  forest: {
     config: {
-      light: colors("#f0f7ff", "#e0efff", "#0c1929", "#4a6a8a", "#7a9aba", "#0066cc", "#c4daf0", "#0d7a3e", "#b8860b", "#c41e3a", "#0066cc"),
-      dark: colors("#0a1628", "#112240", "#e6f0ff", "#8baac8", "#5a7a98", "#4d9fff", "#1e3a5f", "#2ecc71", "#f1c40f", "#e74c3c", "#4d9fff")
-    }
+      light: colors(
+        "#f5faf5",
+        "#e8f5e8",
+        "#1a2e1a",
+        "#4a6b4a",
+        "#7a9b7a",
+        "#2d8a4e",
+        "#c8e0c8",
+        "#1a7a35",
+        "#a68b00",
+        "#c0392b",
+        "#2d8a4e"
+      ),
+      dark: colors(
+        "#0a160a",
+        "#142014",
+        "#e8f5e8",
+        "#8ab88a",
+        "#5a8a5a",
+        "#4caf50",
+        "#1e3a1e",
+        "#27ae60",
+        "#f39c12",
+        "#e74c3c",
+        "#4caf50"
+      )
+    },
+    name: "forest"
   },
-  forest: {
-    name: "forest",
+  ocean: {
     config: {
-      light: colors("#f5faf5", "#e8f5e8", "#1a2e1a", "#4a6b4a", "#7a9b7a", "#2d8a4e", "#c8e0c8", "#1a7a35", "#a68b00", "#c0392b", "#2d8a4e"),
-      dark: colors("#0a160a", "#142014", "#e8f5e8", "#8ab88a", "#5a8a5a", "#4caf50", "#1e3a1e", "#27ae60", "#f39c12", "#e74c3c", "#4caf50")
-    }
+      light: colors(
+        "#f0f7ff",
+        "#e0efff",
+        "#0c1929",
+        "#4a6a8a",
+        "#7a9aba",
+        "#0066cc",
+        "#c4daf0",
+        "#0d7a3e",
+        "#b8860b",
+        "#c41e3a",
+        "#0066cc"
+      ),
+      dark: colors(
+        "#0a1628",
+        "#112240",
+        "#e6f0ff",
+        "#8baac8",
+        "#5a7a98",
+        "#4d9fff",
+        "#1e3a5f",
+        "#2ecc71",
+        "#f1c40f",
+        "#e74c3c",
+        "#4d9fff"
+      )
+    },
+    name: "ocean"
   },
   rose: {
-    name: "rose",
     config: {
-      light: colors("#fff5f7", "#ffe4ea", "#2a1015", "#8a4a5a", "#ba7a8a", "#e11d48", "#f0c8d0", "#16a34a", "#ca8a04", "#dc2626", "#e11d48"),
-      dark: colors("#160a0e", "#201418", "#fce4ec", "#c88a9a", "#8a5a6a", "#fb7185", "#3a1e28", "#22c55e", "#eab308", "#ef4444", "#fb7185")
-    }
+      light: colors(
+        "#fff5f7",
+        "#ffe4ea",
+        "#2a1015",
+        "#8a4a5a",
+        "#ba7a8a",
+        "#e11d48",
+        "#f0c8d0",
+        "#16a34a",
+        "#ca8a04",
+        "#dc2626",
+        "#e11d48"
+      ),
+      dark: colors(
+        "#160a0e",
+        "#201418",
+        "#fce4ec",
+        "#c88a9a",
+        "#8a5a6a",
+        "#fb7185",
+        "#3a1e28",
+        "#22c55e",
+        "#eab308",
+        "#ef4444",
+        "#fb7185"
+      )
+    },
+    name: "rose"
   }
 };
 function mergeTheme(base, overrides) {
   return {
-    light: { ...base.light, ...overrides.light },
     dark: { ...base.dark, ...overrides.dark },
-    radius: overrides.radius ?? base.radius,
     font: overrides.font ?? base.font,
-    mono: overrides.mono ?? base.mono
+    light: { ...base.light, ...overrides.light },
+    mono: overrides.mono ?? base.mono,
+    radius: overrides.radius ?? base.radius
   };
 }
 function luminance(hex) {

package/dist/typegen.js

@@ -3,18 +3,30 @@ import { join } from 'node:path';
 import matter from 'gray-matter';
 
 function inferType(value) {
-  if (value === null || value === void 0) return "unknown";
-  if (typeof value === "string") return "string";
-  if (typeof value === "number") return "number";
-  if (typeof value === "boolean") return "boolean";
+  if (value === null || value === void 0) {
+    return "unknown";
+  }
+  if (typeof value === "string") {
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
   if (Array.isArray(value)) {
-    if (value.length === 0) return "unknown[]";
+    if (value.length === 0) {
+      return "unknown[]";
+    }
     const types = [...new Set(value.map(inferType))];
     return types.length === 1 ? `${types[0]}[]` : `(${types.join(" | ")})[]`;
   }
   if (typeof value === "object") {
     const entries = Object.entries(value);
-    if (entries.length === 0) return "Record<string, unknown>";
+    if (entries.length === 0) {
+      return "Record<string, unknown>";
+    }
     const fields = entries.map(([k, v]) => `${k}: ${inferType(v)}`).join("; ");
     return `{ ${fields} }`;
   }
@@ -26,8 +38,11 @@ async function scanFiles(dir) {
     const entries = await readdir(current, { withFileTypes: true });
     for (const entry of entries) {
       const full = join(current, entry.name);
-      if (entry.isDirectory()) await walk(full);
-      else if (entry.name.endsWith(".mdx")) paths.push(full);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.name.endsWith(".mdx")) {
+        paths.push(full);
+      }
     }
   }
   await walk(dir);
@@ -40,9 +55,11 @@ async function generateTypes(config) {
   const fieldCounts = /* @__PURE__ */ new Map();
   let total = 0;
   for (const file of files) {
-    const source = await readFile(file, "utf-8");
+    const source = await readFile(file, "utf8");
     const { data } = matter(source);
-    if (!data || typeof data !== "object") continue;
+    if (!data || typeof data !== "object") {
+      continue;
+    }
     total++;
     for (const [key, value] of Object.entries(data)) {
       const type = inferType(value);
@@ -56,7 +73,9 @@ async function generateTypes(config) {
     }
   }
   const lines = [`export interface ${name} {`];
-  const sorted = [...fieldTypes.entries()].sort(([a], [b]) => a.localeCompare(b));
+  const sorted = [...fieldTypes.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
   for (const [key, types] of sorted) {
     const optional = (fieldCounts.get(key) ?? 0) < total;
     const union = [...types].join(" | ");
@@ -68,7 +87,7 @@ async function generateTypes(config) {
 }
 async function writeTypes(config) {
   const content = await generateTypes(config);
-  await writeFile(config.output, content, "utf-8");
+  await writeFile(config.output, content, "utf8");
 }
 
 export { generateTypes, inferType, writeTypes };

package/dist/validate.js

@@ -18,22 +18,28 @@ async function validateLinks(options) {
     }
   }
   async function scanFile(filepath, relativePath) {
-    const content = await readFile(filepath, "utf-8");
+    const content = await readFile(filepath, "utf8");
     const lines = content.split("\n");
     const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
     const hrefRegex = /href=["']([^"']+)["']/g;
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      if (line === void 0) continue;
+      if (line === void 0) {
+        continue;
+      }
       let match;
       while ((match = linkRegex.exec(line)) !== null) {
         const link = match[2];
-        if (!link) continue;
+        if (!link) {
+          continue;
+        }
         checkLink(link, relativePath, i + 1, issues, validSlugs, checkExternal);
       }
       while ((match = hrefRegex.exec(line)) !== null) {
         const link = match[1];
-        if (!link) continue;
+        if (!link) {
+          continue;
+        }
         checkLink(link, relativePath, i + 1, issues, validSlugs, checkExternal);
       }
     }
@@ -53,9 +59,15 @@ async function validateLinks(options) {
   return issues;
 }
 function checkLink(link, file, line, issues, validSlugs, checkExternal) {
-  if (link.startsWith("#")) return;
-  if (link.startsWith("mailto:")) return;
-  if (link.startsWith("tel:")) return;
+  if (link.startsWith("#")) {
+    return;
+  }
+  if (link.startsWith("mailto:")) {
+    return;
+  }
+  if (link.startsWith("tel:")) {
+    return;
+  }
   if (link.startsWith("http://") || link.startsWith("https://")) {
     if (checkExternal) {
       issues.push({ file, line, link, type: "external" });