fromsrc 0.0.0 → 0.0.1

package/dist/frontmatter.js

@@ -0,0 +1,65 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+
+function parseFrontmatter(source, schema) {
+  try {
+    const { data, content } = matter(source);
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return {
+        data: result.data,
+        content,
+        valid: true
+      };
+    }
+    const errors = result.error.errors.map((err) => {
+      const path = err.path.join(".");
+      return path ? `${path}: ${err.message}` : err.message;
+    });
+    return {
+      valid: false,
+      errors,
+      content
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error instanceof Error ? error.message : "Failed to parse frontmatter"],
+      content: source
+    };
+  }
+}
+async function getAllMdxFiles(dir) {
+  const files = [];
+  async function scan(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await scan(dir);
+  return files;
+}
+async function validateAllFrontmatter(docsDir, schema) {
+  const files = await getAllMdxFiles(docsDir);
+  const results = [];
+  for (const file of files) {
+    const source = await readFile(file, "utf-8");
+    const result = parseFrontmatter(source, schema);
+    if (!result.valid) {
+      results.push({
+        path: file,
+        errors: result.errors
+      });
+    }
+  }
+  return results;
+}
+
+export { parseFrontmatter, validateAllFrontmatter };

package/dist/github.d.ts

@@ -0,0 +1,15 @@
+import { ContentSource } from './source.js';
+import './content.js';
+import 'zod';
+import './schema.js';
+
+interface GithubSourceConfig {
+    owner: string;
+    repo: string;
+    branch?: string;
+    path?: string;
+    token?: string;
+}
+declare function createGithubSource(config: GithubSourceConfig): ContentSource;
+
+export { type GithubSourceConfig, createGithubSource };

package/dist/github.js

@@ -0,0 +1,254 @@
+import matter from 'gray-matter';
+import { extractHeadings } from './content';
+
+const TTL = 5 * 60 * 1e3;
+const SEARCH_CONCURRENCY = 12;
+const RATE_RETRIES = 3;
+function createCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry) return null;
+      if (Date.now() - entry.timestamp > TTL) {
+        store.delete(key);
+        return null;
+      }
+      return entry.data;
+    },
+    set(key, data) {
+      store.set(key, { data, timestamp: Date.now() });
+    }
+  };
+}
+async function maplimit(items, limit, run) {
+  if (items.length === 0) return [];
+  const workers = Math.max(1, Math.min(limit, items.length));
+  const output = new Array(items.length);
+  let cursor = 0;
+  await Promise.all(
+    Array.from({ length: workers }, async () => {
+      while (cursor < items.length) {
+        const index = cursor++;
+        const item = items[index];
+        if (item === void 0) continue;
+        output[index] = await run(item, index);
+      }
+    })
+  );
+  return output;
+}
+function waitms(res, attempt) {
+  const retry = Number(res.headers.get("retry-after") ?? "");
+  if (Number.isFinite(retry) && retry > 0) {
+    return retry * 1e3;
+  }
+  const reset = Number(res.headers.get("x-ratelimit-reset") ?? "");
+  if (Number.isFinite(reset) && reset > 0) {
+    return Math.max(0, reset * 1e3 - Date.now());
+  }
+  return Math.min(4e3, 500 * 2 ** attempt);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function request(url, headers) {
+  for (let attempt = 0; attempt < RATE_RETRIES; attempt++) {
+    const res = await fetch(url, { headers });
+    const limited = res.status === 429 || res.status === 403 && res.headers.get("x-ratelimit-remaining") === "0";
+    if (!limited || attempt === RATE_RETRIES - 1) {
+      return res;
+    }
+    await sleep(waitms(res, attempt));
+  }
+  return new Response(null, { status: 429 });
+}
+function createGithubSource(config) {
+  const branch = config.branch ?? "main";
+  const docsPath = config.path ?? "docs";
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  const listCache = createCache();
+  const fileCache = createCache();
+  const searchCache = createCache();
+  const treeCache = createCache();
+  const pathCache = createCache();
+  const rawCache = createCache();
+  function rawUrl(filepath) {
+    return `https://raw.githubusercontent.com/${config.owner}/${config.repo}/${branch}/${filepath}`;
+  }
+  function treeUrl(ref, recursive) {
+    const suffix = recursive ? "?recursive=1" : "";
+    return `https://api.github.com/repos/${config.owner}/${config.repo}/git/trees/${ref}${suffix}`;
+  }
+  function joinPath(base, path) {
+    if (!base) return path;
+    return `${base}/${path}`;
+  }
+  async function tree(ref, recursive) {
+    const url = treeUrl(ref, recursive);
+    const cached = treeCache.get(url);
+    const requestHeaders = { ...headers };
+    if (cached?.etag) {
+      requestHeaders["If-None-Match"] = cached.etag;
+    }
+    const res = await request(url, requestHeaders);
+    if (res.status === 304 && cached) {
+      return { entries: cached.entries, truncated: cached.truncated };
+    }
+    if (!res.ok) {
+      console.error(`github tree request failed (${res.status}) for ${url}`);
+      return cached ? { entries: cached.entries, truncated: cached.truncated } : { entries: [], truncated: false };
+    }
+    const json = await res.json();
+    const entries = (json.tree ?? []).filter(
+      (item) => typeof item.path === "string" && (item.type === "blob" || item.type === "tree") && typeof item.sha === "string"
+    ).map((item) => ({
+      path: item.path,
+      type: item.type,
+      sha: item.sha
+    }));
+    const result = {
+      entries,
+      truncated: json.truncated === true
+    };
+    treeCache.set(url, {
+      entries: result.entries,
+      truncated: result.truncated,
+      etag: res.headers.get("etag") ?? void 0
+    });
+    return result;
+  }
+  async function allEntries() {
+    const recursive = await tree(branch, true);
+    if (!recursive.truncated) return recursive.entries;
+    const root = await tree(branch, false);
+    const files = root.entries.filter((item) => item.type === "blob");
+    const queue = root.entries.filter((item) => item.type === "tree");
+    const width = 6;
+    while (queue.length > 0) {
+      const batch = queue.splice(0, width);
+      const nodes = await Promise.all(
+        batch.map(async (current) => {
+          const next = await tree(current.sha, false);
+          return { base: current.path, entries: next.entries };
+        })
+      );
+      for (const node of nodes) {
+        for (const item of node.entries) {
+          const path = joinPath(node.base, item.path);
+          if (item.type === "blob") {
+            files.push({ ...item, path });
+          } else {
+            queue.push({ ...item, path });
+          }
+        }
+      }
+    }
+    return files;
+  }
+  const list = async () => {
+    const cached = listCache.get("list");
+    if (cached) return cached;
+    try {
+      const entries = await allEntries();
+      const prefix = docsPath ? `${docsPath}/` : "";
+      const paths = {};
+      const docs = entries.filter((item) => item.path.startsWith(prefix) && item.path.endsWith(".mdx")).map((item) => {
+        const rawSlug = item.path.slice(prefix.length).replace(/\.mdx$/, "").replace(/\/index$/, "");
+        const slug = rawSlug === "index" ? "" : rawSlug;
+        const fallbackTitle = slug === "" ? "index" : slug.split("/").pop() ?? slug;
+        paths[slug] = item.path;
+        return { slug, title: fallbackTitle };
+      });
+      pathCache.set("paths", paths);
+      listCache.set("list", docs);
+      return docs;
+    } catch (error) {
+      console.error("github source list failed", error);
+      return [];
+    }
+  };
+  const get = async (slug) => {
+    const path = slug.length === 0 ? "index" : slug.join("/");
+    const slugValue = slug.join("/");
+    const cacheKey = path;
+    const cached = fileCache.get(cacheKey);
+    if (cached) return cached;
+    const knownPaths = pathCache.get("paths") ?? {};
+    const knownPath = knownPaths[slugValue];
+    const filepath = `${docsPath}/${path}.mdx`;
+    const indexPath = `${docsPath}/${path}/index.mdx`;
+    const candidates = knownPath ? [knownPath, filepath, indexPath] : [filepath, indexPath];
+    const seen = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      if (seen.has(candidate)) continue;
+      seen.add(candidate);
+      try {
+        const url = rawUrl(candidate);
+        const cachedRaw = rawCache.get(url);
+        const requestHeaders = { ...headers };
+        if (cachedRaw?.etag) {
+          requestHeaders["If-None-Match"] = cachedRaw.etag;
+        }
+        const res = await request(url, requestHeaders);
+        if (res.status === 304 && cachedRaw) {
+          const result2 = { content: cachedRaw.content, data: cachedRaw.data };
+          fileCache.set(cacheKey, result2);
+          return result2;
+        }
+        if (!res.ok) continue;
+        const raw = await res.text();
+        const { content, data } = matter(raw);
+        const result = { content, data };
+        rawCache.set(url, {
+          content,
+          data,
+          etag: res.headers.get("etag") ?? void 0
+        });
+        fileCache.set(cacheKey, result);
+        return result;
+      } catch (error) {
+        console.error(`github source fetch failed for ${candidate}`, error);
+        continue;
+      }
+    }
+    return null;
+  };
+  return {
+    list,
+    get,
+    async search() {
+      const cached = searchCache.get("search");
+      if (cached) return cached;
+      const listed = await list();
+      const values = await maplimit(listed, SEARCH_CONCURRENCY, async (doc) => {
+        const value = await get(doc.slug ? doc.slug.split("/") : []);
+        if (!value) return null;
+        const title = typeof value.data.title === "string" && value.data.title.length > 0 ? value.data.title : doc.title;
+        const description = typeof value.data.description === "string" ? value.data.description : doc.description;
+        return {
+          slug: doc.slug,
+          title,
+          description,
+          content: value.content,
+          headings: extractHeadings(value.content)
+        };
+      });
+      const docs = [];
+      for (const item of values) {
+        if (!item) continue;
+        docs.push(item);
+      }
+      searchCache.set("search", docs);
+      return docs;
+    }
+  };
+}
+
+export { createGithubSource };

package/dist/gitsource.d.ts

@@ -0,0 +1,23 @@
+interface GitSourceConfig {
+    dir: string;
+    branch?: string;
+    tag?: string;
+    glob?: string;
+}
+interface GitFile {
+    path: string;
+    content: string;
+    lastModified: Date;
+    hash: string;
+}
+declare function gitExec(args: string[], cwd: string): Promise<string>;
+declare function listFiles(config: GitSourceConfig): Promise<string[]>;
+declare function readFile(config: GitSourceConfig, path: string): Promise<GitFile>;
+declare function getLastModified(dir: string, path: string): Promise<Date>;
+declare function getFileHash(dir: string, path: string): Promise<string>;
+declare function createGitSource(config: GitSourceConfig): {
+    list(): Promise<string[]>;
+    get(path: string): Promise<GitFile>;
+};
+
+export { type GitFile, type GitSourceConfig, createGitSource, getFileHash, getLastModified, gitExec, listFiles, readFile };

package/dist/gitsource.js

@@ -0,0 +1,50 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const exec = promisify(execFile);
+function ref(config) {
+  return config.tag ?? config.branch ?? "HEAD";
+}
+async function gitExec(args, cwd) {
+  const { stdout } = await exec("git", args, { cwd });
+  return stdout.trim();
+}
+async function listFiles(config) {
+  const output = await gitExec(["ls-tree", "-r", "--name-only", ref(config)], config.dir);
+  if (!output) return [];
+  const files = output.split("\n");
+  if (!config.glob) return files;
+  const pattern = globToRegex(config.glob);
+  return files.filter((f) => pattern.test(f));
+}
+async function readFile(config, path) {
+  const r = ref(config);
+  const content = await gitExec(["show", `${r}:${path}`], config.dir);
+  const lastModified = await getLastModified(config.dir, path);
+  const hash = await getFileHash(config.dir, path);
+  return { path, content, lastModified, hash };
+}
+async function getLastModified(dir, path) {
+  const output = await gitExec(["log", "-1", "--format=%aI", path], dir);
+  return new Date(output);
+}
+async function getFileHash(dir, path) {
+  const output = await gitExec(["hash-object", path], dir);
+  return output;
+}
+function createGitSource(config) {
+  return {
+    async list() {
+      return listFiles(config);
+    },
+    async get(path) {
+      return readFile(config, path);
+    }
+  };
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${escaped}$`);
+}
+
+export { createGitSource, getFileHash, getLastModified, gitExec, listFiles, readFile };

package/dist/hash.d.ts

@@ -0,0 +1,21 @@
+type ContentHash = {
+    path: string;
+    hash: string;
+    size: number;
+};
+type HashManifest = {
+    generated: string;
+    hashes: ContentHash[];
+};
+type Changes = {
+    added: string[];
+    modified: string[];
+    removed: string[];
+};
+declare function hashContent(content: string): string;
+declare function hashFile(filepath: string): Promise<ContentHash>;
+declare function generateHashManifest(dir: string): Promise<HashManifest>;
+declare function detectChanges(previous: HashManifest, current: HashManifest): Changes;
+declare function hashFrontmatter(content: string): string | null;
+
+export { type Changes, type ContentHash, type HashManifest, detectChanges, generateHashManifest, hashContent, hashFile, hashFrontmatter };

package/dist/hash.js

@@ -0,0 +1,65 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { relative, join } from 'node:path';
+
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function hashContent(content) {
+  return fnv1a(content);
+}
+async function hashFile(filepath) {
+  const [content, info] = await Promise.all([readFile(filepath, "utf-8"), stat(filepath)]);
+  return { path: filepath, hash: fnv1a(content), size: info.size };
+}
+async function collectFiles(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await collectFiles(full));
+    } else if (/\.mdx?$/.test(entry.name)) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+async function generateHashManifest(dir) {
+  const files = await collectFiles(dir);
+  const hashes = await Promise.all(
+    files.map(async (f) => {
+      const h = await hashFile(f);
+      return { ...h, path: relative(dir, f) };
+    })
+  );
+  return { generated: (/* @__PURE__ */ new Date()).toISOString(), hashes };
+}
+function detectChanges(previous, current) {
+  const prev = new Map(previous.hashes.map((h) => [h.path, h.hash]));
+  const curr = new Map(current.hashes.map((h) => [h.path, h.hash]));
+  const added = [];
+  const modified = [];
+  const removed = [];
+  for (const [path, hash] of curr) {
+    if (!prev.has(path)) added.push(path);
+    else if (prev.get(path) !== hash) modified.push(path);
+  }
+  for (const path of prev.keys()) {
+    if (!curr.has(path)) removed.push(path);
+  }
+  return { added, modified, removed };
+}
+function hashFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const body = match[1];
+  if (!body) return null;
+  return fnv1a(body);
+}
+
+export { detectChanges, generateHashManifest, hashContent, hashFile, hashFrontmatter };

package/dist/highlight.d.ts

@@ -0,0 +1,18 @@
+type HighlightResult = {
+    text: string;
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+};
+type SnippetOptions = {
+    maxLength?: number;
+    surroundingWords?: number;
+};
+declare function highlightMatches(text: string, query: string): HighlightResult;
+declare function generateSnippet(text: string, query: string, options?: SnippetOptions): string;
+declare function highlightHtml(text: string, query: string): string;
+declare function tokenize(query: string): string[];
+declare function fuzzyHighlight(text: string, terms: string[]): HighlightResult;
+
+export { type HighlightResult, type SnippetOptions, fuzzyHighlight, generateSnippet, highlightHtml, highlightMatches, tokenize };

package/dist/highlight.js

@@ -0,0 +1,90 @@
+function escape(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function findAll(text, query) {
+  const ranges = [];
+  const lower = text.toLowerCase();
+  const q = query.toLowerCase();
+  let pos = 0;
+  while (pos < lower.length) {
+    const idx = lower.indexOf(q, pos);
+    if (idx === -1) break;
+    ranges.push({ start: idx, end: idx + q.length });
+    pos = idx + 1;
+  }
+  return ranges;
+}
+function highlightMatches(text, query) {
+  return { text, ranges: query ? findAll(text, query) : [] };
+}
+function generateSnippet(text, query, options) {
+  const maxLength = options?.maxLength ?? 200;
+  const surrounding = options?.surroundingWords ?? 10;
+  const idx = text.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1) return text.slice(0, maxLength) + (text.length > maxLength ? "..." : "");
+  const words = text.split(/(\s+)/);
+  let charCount = 0;
+  let matchWord = 0;
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i] ?? "";
+    if (charCount + word.length > idx) {
+      matchWord = i;
+      break;
+    }
+    charCount += word.length;
+  }
+  const startWord = Math.max(0, matchWord - surrounding * 2);
+  const endWord = Math.min(words.length, matchWord + surrounding * 2 + 1);
+  let snippet = words.slice(startWord, endWord).join("");
+  if (snippet.length > maxLength) snippet = snippet.slice(0, maxLength);
+  const prefix = startWord > 0 ? "..." : "";
+  const suffix = endWord < words.length || snippet.length >= maxLength ? "..." : "";
+  return prefix + snippet.trim() + suffix;
+}
+function highlightHtml(text, query) {
+  if (!query) return escape(text);
+  const terms = tokenize(query).map((term) => term.toLowerCase()).filter(Boolean);
+  if (terms.length === 0) return escape(text);
+  const result = [];
+  const lower = text.toLowerCase();
+  let last = 0;
+  let pos = 0;
+  while (pos < lower.length) {
+    let nearest = -1;
+    let match = "";
+    for (const term of terms) {
+      const idx = lower.indexOf(term, pos);
+      if (idx === -1) continue;
+      if (nearest === -1 || idx < nearest) {
+        nearest = idx;
+        match = term;
+      }
+    }
+    if (nearest === -1 || !match) break;
+    result.push(escape(text.slice(last, nearest)));
+    result.push(`<mark>${escape(text.slice(nearest, nearest + match.length))}</mark>`);
+    last = nearest + match.length;
+    pos = nearest + 1;
+  }
+  result.push(escape(text.slice(last)));
+  return result.join("");
+}
+function tokenize(query) {
+  const terms = [];
+  const regex = /"([^"]+)"|(\S+)/g;
+  let match;
+  while ((match = regex.exec(query)) !== null) {
+    const term = match[1] ?? match[2];
+    if (!term) continue;
+    terms.push(term);
+  }
+  return terms;
+}
+function fuzzyHighlight(text, terms) {
+  const ranges = [];
+  for (const term of terms) ranges.push(...findAll(text, term));
+  ranges.sort((a, b) => a.start - b.start);
+  return { text, ranges };
+}
+
+export { fuzzyHighlight, generateSnippet, highlightHtml, highlightMatches, tokenize };

package/dist/hooks/anchor.d.ts

@@ -0,0 +1,7 @@
+interface AnchorOptions {
+    offset?: number;
+    smooth?: boolean;
+}
+declare function useAnchorScroll(options?: AnchorOptions): void;
+
+export { type AnchorOptions, useAnchorScroll };

package/dist/hooks/anchor.js

@@ -0,0 +1,44 @@
+"use client";
+import { useEffect } from 'react';
+
+function useAnchorScroll(options = {}) {
+  const { offset = 80, smooth = true } = options;
+  useEffect(() => {
+    function handleClick(e) {
+      if (!(e.target instanceof Element)) return;
+      const target = e.target;
+      const anchor = target.closest("a");
+      if (!anchor) return;
+      const href = anchor.getAttribute("href");
+      if (!href?.startsWith("#")) return;
+      const id = href.slice(1);
+      const element = document.getElementById(id);
+      if (!element) return;
+      e.preventDefault();
+      const top = element.offsetTop - offset;
+      window.scrollTo({
+        top: Math.max(0, top),
+        behavior: smooth ? "smooth" : "auto"
+      });
+      window.history.pushState(null, "", href);
+    }
+    document.addEventListener("click", handleClick);
+    return () => document.removeEventListener("click", handleClick);
+  }, [offset, smooth]);
+  useEffect(() => {
+    const hash = window.location.hash;
+    if (!hash) return;
+    const id = hash.slice(1);
+    const element = document.getElementById(id);
+    if (!element) return;
+    setTimeout(() => {
+      const top = element.offsetTop - offset;
+      window.scrollTo({
+        top: Math.max(0, top),
+        behavior: "auto"
+      });
+    }, 100);
+  }, [offset]);
+}
+
+export { useAnchorScroll };

package/dist/hooks/arrownav.d.ts

@@ -0,0 +1,11 @@
+type ArrowDirection = "vertical" | "horizontal" | "both";
+interface ArrowNavOptions {
+    count: number;
+    current: number;
+    direction?: ArrowDirection;
+    wrap?: boolean;
+    isDisabled?: (index: number) => boolean;
+}
+declare function getNextIndex(key: string, options: ArrowNavOptions): number;
+
+export { type ArrowDirection, type ArrowNavOptions, getNextIndex };