fromsrc 0.0.0 → 0.0.2

package/dist/searchscore.d.ts

@@ -0,0 +1,30 @@
+interface Termindex {
+    list: string[];
+    set: Set<string>;
+}
+interface Searchtermdata {
+    title: string;
+    slug: string;
+    description: string;
+    content: string;
+    titleindex: Termindex;
+    slugindex: Termindex;
+    descriptionindex: Termindex;
+    headingindex: Termindex;
+    contentindex: Termindex;
+}
+interface Searchweights {
+    titleExact: number;
+    titleTypo: number;
+    slugExact: number;
+    slugTypo: number;
+    descriptionExact: number;
+    descriptionTypo: number;
+    headingTypo: number;
+    contentExact: number;
+}
+declare const defaultweights: Searchweights;
+declare function termindex(words: string[]): Termindex;
+declare function scoreterms(terms: string[], data: Searchtermdata, weights?: Searchweights): number;
+
+export { type Searchtermdata, type Searchweights, type Termindex, defaultweights, scoreterms, termindex };

package/dist/searchscore.js

@@ -0,0 +1,54 @@
+import { typomatch } from './searchtypo';
+
+const defaultweights = {
+  titleExact: 9,
+  titleTypo: 5,
+  slugExact: 7,
+  slugTypo: 4,
+  descriptionExact: 4,
+  descriptionTypo: 2,
+  headingTypo: 2,
+  contentExact: 2
+};
+function termindex(words) {
+  return { list: words, set: new Set(words) };
+}
+function scoreterms(terms, data, weights = defaultweights) {
+  let score = 0;
+  for (const term of terms) {
+    if (data.title.includes(term) || data.titleindex.set.has(term)) {
+      score += weights.titleExact;
+      continue;
+    }
+    if (typomatch(term, data.titleindex.list)) {
+      score += weights.titleTypo;
+      continue;
+    }
+    if (data.slug.includes(term) || data.slugindex.set.has(term)) {
+      score += weights.slugExact;
+      continue;
+    }
+    if (typomatch(term, data.slugindex.list)) {
+      score += weights.slugTypo;
+      continue;
+    }
+    if (data.description.includes(term) || data.descriptionindex.set.has(term)) {
+      score += weights.descriptionExact;
+      continue;
+    }
+    if (typomatch(term, data.descriptionindex.list)) {
+      score += weights.descriptionTypo;
+      continue;
+    }
+    if (typomatch(term, data.headingindex.list)) {
+      score += weights.headingTypo;
+      continue;
+    }
+    if (data.contentindex.set.has(term) || data.content.includes(term)) {
+      score += weights.contentExact;
+    }
+  }
+  return score;
+}
+
+export { defaultweights, scoreterms, termindex };

package/dist/searchtypo.d.ts

@@ -0,0 +1,3 @@
+declare function typomatch(term: string, words: string[]): boolean;
+
+export { typomatch };

package/dist/searchtypo.js

@@ -0,0 +1,47 @@
+function oneedit(left, right) {
+  const a = left.length;
+  const b = right.length;
+  if (Math.abs(a - b) > 1) return false;
+  if (a === b) {
+    const diffs = [];
+    for (let i2 = 0; i2 < a; i2++) {
+      if (left[i2] !== right[i2]) {
+        diffs.push(i2);
+        if (diffs.length > 2) return false;
+      }
+    }
+    if (diffs.length === 1) return true;
+    if (diffs.length !== 2) return false;
+    const first = diffs[0];
+    const second = diffs[1];
+    if (first === void 0 || second === void 0) return false;
+    if (second !== first + 1) return false;
+    return left[first] === right[second] && left[second] === right[first];
+  }
+  const longer = a > b ? left : right;
+  const shorter = a > b ? right : left;
+  let i = 0;
+  let j = 0;
+  let diff = 0;
+  while (i < longer.length && j < shorter.length) {
+    if (longer[i] === shorter[j]) {
+      i++;
+      j++;
+      continue;
+    }
+    diff++;
+    if (diff > 1) return false;
+    i++;
+  }
+  return true;
+}
+function typomatch(term, words) {
+  if (term.length < 3) return false;
+  for (const word of words) {
+    if (Math.abs(word.length - term.length) > 1) continue;
+    if (word === term || oneedit(term, word)) return true;
+  }
+  return false;
+}
+
+export { typomatch };

package/dist/seo.d.ts

@@ -0,0 +1,26 @@
+interface SeoConfig {
+    baseUrl: string;
+    siteName: string;
+    titleTemplate?: string;
+    defaultImage?: string;
+    twitter?: string;
+    locale?: string;
+}
+interface PageSeo {
+    title: string;
+    description?: string;
+    path: string;
+    image?: string;
+    type?: "article" | "website";
+    publishedAt?: string;
+    modifiedAt?: string;
+    noindex?: boolean;
+}
+declare function createSeo(config: SeoConfig): {
+    meta: (page: PageSeo) => Record<string, string>[];
+    jsonLd: (page: PageSeo) => object;
+    canonical: (page: PageSeo) => string;
+    title: (page: PageSeo) => string;
+};
+
+export { type PageSeo, type SeoConfig, createSeo };

package/dist/seo.js

@@ -0,0 +1,69 @@
+function createSeo(config) {
+  const locale = config.locale ?? "en_US";
+  const template = config.titleTemplate ?? "%s";
+  function title(page) {
+    return template.replace("%s", page.title);
+  }
+  function canonical(page) {
+    const base = config.baseUrl.replace(/\/$/, "");
+    const path = page.path.startsWith("/") ? page.path : `/${page.path}`;
+    return `${base}${path}`;
+  }
+  function meta(page) {
+    const url = canonical(page);
+    const formatted = title(page);
+    const image = page.image ?? config.defaultImage;
+    const type = page.type ?? "article";
+    const tags = [
+      { property: "og:title", content: formatted },
+      { property: "og:url", content: url },
+      { property: "og:type", content: type },
+      { property: "og:site_name", content: config.siteName },
+      { property: "og:locale", content: locale },
+      { name: "twitter:card", content: "summary_large_image" }
+    ];
+    if (page.description) {
+      tags.unshift({ name: "description", content: page.description });
+      tags.push({ property: "og:description", content: page.description });
+    }
+    if (image) {
+      tags.push({ property: "og:image", content: image });
+    }
+    if (config.twitter) {
+      tags.push({ name: "twitter:site", content: config.twitter });
+    }
+    if (page.noindex) {
+      tags.push({ name: "robots", content: "noindex,nofollow" });
+    }
+    return tags;
+  }
+  function jsonLd(page) {
+    const data = {
+      "@context": "https://schema.org",
+      "@type": "TechArticle",
+      headline: title(page),
+      url: canonical(page),
+      publisher: {
+        "@type": "Organization",
+        name: config.siteName
+      }
+    };
+    if (page.description) {
+      data.description = page.description;
+    }
+    const image = page.image ?? config.defaultImage;
+    if (image) {
+      data.image = image;
+    }
+    if (page.publishedAt) {
+      data.datePublished = page.publishedAt;
+    }
+    if (page.modifiedAt) {
+      data.dateModified = page.modifiedAt;
+    }
+    return data;
+  }
+  return { meta, jsonLd, canonical, title };
+}
+
+export { createSeo };

package/dist/shortcodes.d.ts

@@ -0,0 +1,13 @@
+type ShortcodeDefinition = {
+    name: string;
+    transform: (attrs: Record<string, string>, content?: string) => string;
+};
+type ShortcodeConfig = {
+    definitions: ShortcodeDefinition[];
+};
+declare function parseAttrs(tag: string): Record<string, string>;
+declare function registerShortcode(name: string, transform: (attrs: Record<string, string>, content?: string) => string): ShortcodeDefinition;
+declare function processShortcodes(content: string, config: ShortcodeConfig): string;
+declare const builtinShortcodes: ShortcodeDefinition[];
+
+export { type ShortcodeConfig, type ShortcodeDefinition, builtinShortcodes, parseAttrs, processShortcodes, registerShortcode };

package/dist/shortcodes.js

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+
+function parseAttrs(tag) {
+  const attrs = {};
+  const pattern = /(\w+)="([^"]*)"/g;
+  let match;
+  while ((match = pattern.exec(tag)) !== null) {
+    const key = match[1];
+    const value = match[2];
+    if (!key || value === void 0) continue;
+    attrs[key] = value;
+  }
+  return attrs;
+}
+function registerShortcode(name, transform) {
+  return { name, transform };
+}
+function processShortcodes(content, config) {
+  let result = content;
+  for (const def of config.definitions) {
+    const block = new RegExp(
+      `\\{\\{${def.name}([^}]*)\\}\\}([\\s\\S]*?)\\{\\{/${def.name}\\}\\}`,
+      "g"
+    );
+    result = result.replace(block, (_, tag, inner) => {
+      return def.transform(parseAttrs(tag), inner);
+    });
+    const inline = new RegExp(`\\{\\{${def.name}([^}]*)\\}\\}`, "g");
+    result = result.replace(inline, (_, tag) => {
+      return def.transform(parseAttrs(tag));
+    });
+  }
+  return result;
+}
+const builtinShortcodes = [
+  registerShortcode("youtube", (attrs) => {
+    return `<YouTube id="${attrs.id}" />`;
+  }),
+  registerShortcode("note", (attrs, content) => {
+    return `<Note type="${attrs.type}">${content ?? ""}</Note>`;
+  }),
+  registerShortcode("badge", (attrs) => {
+    return `<Badge>${attrs.text}</Badge>`;
+  }),
+  registerShortcode("include", (attrs) => {
+    try {
+      const file = attrs.file;
+      if (!file || file.includes("..") || isAbsolute(file)) return "";
+      const root = resolve(process.cwd());
+      const full = resolve(root, file);
+      const rooted = `${root}/`;
+      if (full !== root && !full.startsWith(rooted)) return "";
+      return readFileSync(full, "utf-8");
+    } catch {
+      return "";
+    }
+  })
+];
+
+export { builtinShortcodes, parseAttrs, processShortcodes, registerShortcode };

package/dist/sitemap.d.ts

@@ -0,0 +1,25 @@
+import { DocMeta } from './content.js';
+import 'zod';
+import './schema.js';
+
+interface SitemapConfig {
+    baseUrl: string;
+    docsPrefix?: string;
+}
+interface SitemapEntry {
+    url: string;
+    lastmod?: string;
+    changefreq?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+    priority?: number;
+}
+declare function generateSitemap(config: SitemapConfig, entries: SitemapEntry[]): string;
+declare function generateSitemapIndex(baseUrl: string, sitemaps: string[]): string;
+declare function entriesToRss(config: {
+    title: string;
+    description: string;
+    baseUrl: string;
+    link: string;
+}, entries: SitemapEntry[]): string;
+declare function docsToEntries(config: SitemapConfig, docs: DocMeta[]): SitemapEntry[];
+
+export { type SitemapConfig, type SitemapEntry, docsToEntries, entriesToRss, generateSitemap, generateSitemapIndex };

package/dist/sitemap.js

@@ -0,0 +1,69 @@
+function escape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function urlEntry(entry) {
+  let xml = `	<url>
+		<loc>${escape(entry.url)}</loc>`;
+  if (entry.lastmod) xml += `
+		<lastmod>${escape(entry.lastmod)}</lastmod>`;
+  if (entry.changefreq) xml += `
+		<changefreq>${entry.changefreq}</changefreq>`;
+  if (entry.priority !== void 0) xml += `
+		<priority>${entry.priority}</priority>`;
+  xml += "\n	</url>";
+  return xml;
+}
+function generateSitemap(config, entries) {
+  const urls = entries.map(urlEntry).join("\n");
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">`,
+    urls,
+    `</urlset>`
+  ].join("\n");
+}
+function generateSitemapIndex(baseUrl, sitemaps) {
+  const entries = sitemaps.map((url) => `	<sitemap>
+		<loc>${escape(`${baseUrl}${url}`)}</loc>
+	</sitemap>`).join("\n");
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">`,
+    entries,
+    `</sitemapindex>`
+  ].join("\n");
+}
+function entriesToRss(config, entries) {
+  const items = entries.map(
+    (e) => `		<item>
+			<link>${escape(e.url)}</link>${e.lastmod ? `
+			<pubDate>${escape(e.lastmod)}</pubDate>` : ""}
+		</item>`
+  ).join("\n");
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<rss version="2.0">`,
+    `	<channel>`,
+    `		<title>${escape(config.title)}</title>`,
+    `		<description>${escape(config.description)}</description>`,
+    `		<link>${escape(config.link)}</link>`,
+    items,
+    `	</channel>`,
+    `</rss>`
+  ].join("\n");
+}
+function depth(slug) {
+  if (slug === "") return 0;
+  return slug.split("/").length;
+}
+function docsToEntries(config, docs) {
+  const prefix = config.docsPrefix ?? "/docs";
+  return docs.map((doc) => {
+    const d = depth(doc.slug);
+    const priority = d === 0 ? 1 : d === 1 ? 0.8 : d === 2 ? 0.6 : 0.4;
+    const url = `${config.baseUrl}${prefix}${doc.slug ? `/${doc.slug}` : ""}`;
+    return { url, priority };
+  });
+}
+
+export { docsToEntries, entriesToRss, generateSitemap, generateSitemapIndex };

package/dist/snippets.d.ts

@@ -0,0 +1,18 @@
+interface SnippetConfig {
+    dirs: string[];
+    extensions?: string[];
+}
+interface Snippet {
+    id: string;
+    file: string;
+    code: string;
+    lang: string;
+    startLine: number;
+    endLine: number;
+}
+declare function extractSnippets(config: SnippetConfig): Promise<Snippet[]>;
+declare function getSnippet(snippets: Snippet[], id: string): Snippet | null;
+declare function generateSnippetMap(snippets: Snippet[]): Record<string, string>;
+declare function extractFileSnippet(filepath: string, startLine: number, endLine: number): Promise<string>;
+
+export { type Snippet, type SnippetConfig, extractFileSnippet, extractSnippets, generateSnippetMap, getSnippet };

package/dist/snippets.js

@@ -0,0 +1,89 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, extname, relative } from 'node:path';
+
+const defaults = [".ts", ".tsx", ".js", ".jsx"];
+const languages = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".css": "css",
+  ".html": "html",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".sh": "bash"
+};
+const regionRe = /(?:\/\/|\/\*|#|\{\/\*)\s*#region\s+(\S+)(?:\s*\*\/|\s*\*\/\})?/;
+const endRe = /(?:\/\/|\/\*|#|\{\/\*)\s*#endregion\s+(\S+)(?:\s*\*\/|\s*\*\/\})?/;
+async function collect(dir, exts) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const nested = await Promise.all(
+    entries.map((e) => {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) return collect(full, exts);
+      return exts.includes(extname(e.name)) ? [full] : [];
+    })
+  );
+  return nested.flat();
+}
+function parse(content, filepath) {
+  const lines = content.split("\n");
+  const lang = languages[extname(filepath)] ?? "text";
+  const open = /* @__PURE__ */ new Map();
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const start = line.match(regionRe);
+    const startId = start?.[1];
+    if (startId) {
+      open.set(startId, i);
+      continue;
+    }
+    const end = line.match(endRe);
+    const endId = end?.[1];
+    if (endId && open.has(endId)) {
+      const s = open.get(endId);
+      if (s === void 0) continue;
+      open.delete(endId);
+      results.push({
+        id: `${relative(process.cwd(), filepath)}:${endId}`,
+        file: filepath,
+        code: lines.slice(s + 1, i).join("\n"),
+        lang,
+        startLine: s + 2,
+        endLine: i
+      });
+    }
+  }
+  return results;
+}
+async function extractSnippets(config) {
+  const exts = config.extensions ?? defaults;
+  const snippets = [];
+  for (const dir of config.dirs) {
+    const files = await collect(dir, exts);
+    for (const file of files) {
+      snippets.push(...parse(await readFile(file, "utf-8"), file));
+    }
+  }
+  return snippets;
+}
+function getSnippet(snippets, id) {
+  return snippets.find((s) => s.id === id || s.id.endsWith(`:${id}`)) ?? null;
+}
+function generateSnippetMap(snippets) {
+  const map = {};
+  for (const s of snippets) map[s.id] = s.code;
+  return map;
+}
+async function extractFileSnippet(filepath, startLine, endLine) {
+  const lines = (await readFile(filepath, "utf-8")).split("\n");
+  return lines.slice(startLine - 1, endLine).join("\n");
+}
+
+export { extractFileSnippet, extractSnippets, generateSnippetMap, getSnippet };

package/dist/source.d.ts

@@ -0,0 +1,23 @@
+import { DocMeta, SearchDoc } from './content.js';
+import 'zod';
+import './schema.js';
+
+interface ContentSource {
+    list(): Promise<DocMeta[]>;
+    get(slug: string[]): Promise<{
+        content: string;
+        data: Record<string, unknown>;
+    } | null>;
+    search?(): Promise<SearchDoc[]>;
+}
+interface RemoteSourceConfig {
+    baseUrl: string;
+    index?: string;
+    docsEndpoint?: string;
+    rawEndpoint?: string;
+    searchIndexEndpoint?: string;
+    ttl?: number;
+}
+declare function createRemoteSource(config: RemoteSourceConfig): ContentSource;
+
+export { type ContentSource, type RemoteSourceConfig, createRemoteSource };