fromsrc 0.0.0 → 0.0.2

package/dist/contentcache.d.ts

@@ -0,0 +1,28 @@
+type CacheEntry<T> = {
+    value: T;
+    expires: number;
+    key: string;
+};
+type CacheConfig = {
+    maxSize?: number;
+    ttl?: number;
+    onEvict?: (key: string) => void;
+};
+type CacheStats = {
+    hits: number;
+    misses: number;
+    size: number;
+    evictions: number;
+};
+declare function createCache<T>(config?: CacheConfig): {
+    get: (key: string) => T | undefined;
+    set: (key: string, value: T, ttl?: number) => void;
+    has: (key: string) => boolean;
+    delete: (key: string) => boolean;
+    clear: () => void;
+    stats: () => CacheStats;
+    keys: () => string[];
+    prune: () => number;
+};
+
+export { type CacheConfig, type CacheEntry, type CacheStats, createCache };

package/dist/contentcache.js

@@ -0,0 +1,76 @@
+function createCache(config) {
+  const maxSize = config?.maxSize ?? 1e3;
+  const defaultTtl = config?.ttl ?? 3e5;
+  const onEvict = config?.onEvict;
+  const store = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+  function isExpired(entry) {
+    return Date.now() > entry.expires;
+  }
+  function evictOldest() {
+    const oldest = store.keys().next().value;
+    if (!oldest) return;
+    store.delete(oldest);
+    evictions++;
+    onEvict?.(oldest);
+  }
+  function get(key) {
+    const entry = store.get(key);
+    if (!entry) {
+      misses++;
+      return void 0;
+    }
+    if (isExpired(entry)) {
+      store.delete(key);
+      misses++;
+      return void 0;
+    }
+    hits++;
+    store.delete(key);
+    store.set(key, entry);
+    return entry.value;
+  }
+  function set(key, value, ttl) {
+    store.delete(key);
+    if (store.size >= maxSize) {
+      evictOldest();
+    }
+    store.set(key, { value, expires: Date.now() + (ttl ?? defaultTtl), key });
+  }
+  function has(key) {
+    const entry = store.get(key);
+    if (!entry) return false;
+    if (isExpired(entry)) {
+      store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  function del(key) {
+    return store.delete(key);
+  }
+  function clear() {
+    store.clear();
+  }
+  function stats() {
+    return { hits, misses, size: store.size, evictions };
+  }
+  function keys() {
+    return [...store.keys()];
+  }
+  function prune() {
+    let count = 0;
+    for (const [key, entry] of store) {
+      if (isExpired(entry)) {
+        store.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  return { get, set, has, delete: del, clear, stats, keys, prune };
+}
+
+export { createCache };

package/dist/contentdiff.d.ts

@@ -0,0 +1,19 @@
+type ContentChange = {
+    type: "added" | "removed" | "modified";
+    path: string;
+    title?: string;
+};
+type ContentDiff = {
+    added: ContentChange[];
+    removed: ContentChange[];
+    modified: ContentChange[];
+    summary: string;
+};
+declare function contentFromDocs(docs: {
+    slug: string;
+    content: string;
+}[]): Map<string, string>;
+declare function diffContent(before: Map<string, string>, after: Map<string, string>): ContentDiff;
+declare function formatChangelog(diff: ContentDiff): string;
+
+export { type ContentChange, type ContentDiff, contentFromDocs, diffContent, formatChangelog };

package/dist/contentdiff.js

@@ -0,0 +1,48 @@
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match?.[1];
+}
+function contentFromDocs(docs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const doc of docs) map.set(doc.slug, doc.content);
+  return map;
+}
+function diffContent(before, after) {
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [path, content] of after) {
+    if (!before.has(path)) {
+      added.push({ type: "added", path, title: extractTitle(content) });
+    } else if (before.get(path) !== content) {
+      modified.push({ type: "modified", path, title: extractTitle(content) });
+    }
+  }
+  for (const [path, content] of before) {
+    if (!after.has(path)) {
+      removed.push({ type: "removed", path, title: extractTitle(content) });
+    }
+  }
+  const summary = `${added.length} added, ${removed.length} removed, ${modified.length} modified`;
+  return { added, removed, modified, summary };
+}
+function formatChangelog(diff) {
+  const sections = [];
+  if (diff.added.length > 0) {
+    sections.push("## Added\n");
+    for (const c of diff.added) sections.push(`- ${c.title ?? c.path}`);
+  }
+  if (diff.removed.length > 0) {
+    sections.push("## Removed\n");
+    for (const c of diff.removed) sections.push(`- ${c.title ?? c.path}`);
+  }
+  if (diff.modified.length > 0) {
+    sections.push("## Modified\n");
+    for (const c of diff.modified) sections.push(`- ${c.title ?? c.path}`);
+  }
+  sections.push(`
+${diff.summary}`);
+  return sections.join("\n");
+}
+
+export { contentFromDocs, diffContent, formatChangelog };

package/dist/contributors.d.ts

@@ -0,0 +1,22 @@
+type Contributor = {
+    name: string;
+    email: string;
+    commits: number;
+    lastCommit: Date;
+};
+type ContributorConfig = {
+    dir: string;
+    file: string;
+    excludeEmails?: string[];
+};
+declare function getContributors(config: ContributorConfig): Promise<Contributor[]>;
+declare function getLastAuthor(config: ContributorConfig): Promise<Contributor | null>;
+declare function getEditHistory(config: ContributorConfig): Promise<{
+    hash: string;
+    author: string;
+    date: Date;
+    message: string;
+}[]>;
+declare function formatContributors(contributors: Contributor[]): string;
+
+export { type Contributor, type ContributorConfig, formatContributors, getContributors, getEditHistory, getLastAuthor };

package/dist/contributors.js

@@ -0,0 +1,64 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const run = promisify(execFile);
+async function getContributors(config) {
+  try {
+    const { stdout } = await run("git", ["log", "--format=%aN|%aE|%aI", "--", config.file], {
+      cwd: config.dir
+    });
+    if (!stdout.trim()) return [];
+    const exclude = new Set(config.excludeEmails ?? []);
+    const map = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim().split("\n")) {
+      const parts = line.split("|");
+      const name = parts[0];
+      const email = parts[1];
+      const dateRaw = parts[2];
+      if (!name || !email || !dateRaw) continue;
+      const date = new Date(dateRaw);
+      if (Number.isNaN(date.getTime())) continue;
+      if (exclude.has(email)) continue;
+      const existing = map.get(email);
+      if (existing) {
+        existing.commits++;
+        if (date > existing.lastCommit) existing.lastCommit = date;
+      } else {
+        map.set(email, { name, email, commits: 1, lastCommit: date });
+      }
+    }
+    return [...map.values()].sort((a, b) => b.commits - a.commits);
+  } catch {
+    return [];
+  }
+}
+async function getLastAuthor(config) {
+  const contributors = await getContributors(config);
+  if (!contributors.length) return null;
+  return [...contributors].sort((a, b) => b.lastCommit.getTime() - a.lastCommit.getTime())[0] ?? null;
+}
+async function getEditHistory(config) {
+  try {
+    const { stdout } = await run("git", ["log", "--format=%H|%aN|%aI|%s", "--", config.file], {
+      cwd: config.dir
+    });
+    if (!stdout.trim()) return [];
+    return stdout.trim().split("\n").map((line) => {
+      const parts = line.split("|");
+      const hash = parts[0];
+      const author = parts[1];
+      const dateRaw = parts[2];
+      if (!hash || !author || !dateRaw) return null;
+      const date = new Date(dateRaw);
+      if (Number.isNaN(date.getTime())) return null;
+      return { hash, author, date, message: parts.slice(3).join("|") };
+    }).filter((item) => item !== null);
+  } catch {
+    return [];
+  }
+}
+function formatContributors(contributors) {
+  return contributors.map((c) => `- ${c.name} (${c.commits} commits)`).join("\n");
+}
+
+export { formatContributors, getContributors, getEditHistory, getLastAuthor };

package/dist/diff.d.ts

@@ -0,0 +1,25 @@
+type DiffLine = {
+    type: "add" | "remove" | "same";
+    content: string;
+    oldLine?: number;
+    newLine?: number;
+};
+type DiffResult = {
+    lines: DiffLine[];
+    additions: number;
+    removals: number;
+    unchanged: number;
+};
+type DiffOptions = {
+    context?: number;
+    ignoreWhitespace?: boolean;
+};
+declare function diffLines(oldText: string, newText: string, options?: DiffOptions): DiffResult;
+declare function diffFrontmatter(oldContent: string, newContent: string): Record<string, {
+    old?: string;
+    new?: string;
+}>;
+declare function formatDiff(result: DiffResult): string;
+declare function summarizeDiff(result: DiffResult): string;
+
+export { type DiffLine, type DiffOptions, type DiffResult, diffFrontmatter, diffLines, formatDiff, summarizeDiff };

package/dist/diff.js

@@ -0,0 +1,117 @@
+function lcs(a, b, ignore) {
+  const table = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const aiRaw = a[i - 1] ?? "";
+      const bjRaw = b[j - 1] ?? "";
+      const ai = ignore ? aiRaw.trim() : aiRaw;
+      const bj = ignore ? bjRaw.trim() : bjRaw;
+      const upLeft = table[i - 1]?.[j - 1] ?? 0;
+      const up = table[i - 1]?.[j] ?? 0;
+      const left = table[i]?.[j - 1] ?? 0;
+      const row = table[i];
+      if (!row) continue;
+      row[j] = ai === bj ? upLeft + 1 : Math.max(up, left);
+    }
+  }
+  return table;
+}
+function backtrack(table, a, b, ignore) {
+  const result = [];
+  let i = a.length;
+  let j = b.length;
+  while (i > 0 || j > 0) {
+    const aiRaw = i > 0 ? a[i - 1] ?? "" : "";
+    const bjRaw = j > 0 ? b[j - 1] ?? "" : "";
+    const ai = ignore ? aiRaw.trim() : aiRaw;
+    const bj = ignore ? bjRaw.trim() : bjRaw;
+    if (i > 0 && j > 0 && ai === bj) {
+      result.push({ type: "same", content: aiRaw, oldLine: i, newLine: j });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || (table[i]?.[j - 1] ?? 0) >= (table[i - 1]?.[j] ?? 0))) {
+      result.push({ type: "add", content: bjRaw, newLine: j });
+      j--;
+    } else {
+      result.push({ type: "remove", content: aiRaw, oldLine: i });
+      i--;
+    }
+  }
+  return result.reverse();
+}
+function applyContext(lines, ctx) {
+  const changed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line && line.type !== "same") changed.add(i);
+  }
+  const visible = /* @__PURE__ */ new Set();
+  for (const idx of changed) {
+    for (let d = -ctx; d <= ctx; d++) {
+      const t = idx + d;
+      if (t >= 0 && t < lines.length) visible.add(t);
+    }
+  }
+  return lines.filter((_, i) => visible.has(i));
+}
+function diffLines(oldText, newText, options) {
+  const ctx = options?.context ?? 3;
+  const ignore = options?.ignoreWhitespace ?? false;
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  const table = lcs(a, b, ignore);
+  let lines = backtrack(table, a, b, ignore);
+  if (ctx >= 0) lines = applyContext(lines, ctx);
+  let additions = 0;
+  let removals = 0;
+  let unchanged = 0;
+  for (const line of lines) {
+    if (line.type === "add") additions++;
+    else if (line.type === "remove") removals++;
+    else unchanged++;
+  }
+  return { lines, additions, removals, unchanged };
+}
+function diffFrontmatter(oldContent, newContent) {
+  const parse = (text) => {
+    const match = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+    const body = match[1];
+    if (!body) return {};
+    const fields = {};
+    for (const line of body.split("\n")) {
+      const idx = line.indexOf(":");
+      if (idx > 0) fields[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    }
+    return fields;
+  };
+  const oldFields = parse(oldContent);
+  const newFields = parse(newContent);
+  const keys = /* @__PURE__ */ new Set([...Object.keys(oldFields), ...Object.keys(newFields)]);
+  const result = {};
+  for (const key of keys) {
+    if (oldFields[key] !== newFields[key]) {
+      result[key] = { old: oldFields[key], new: newFields[key] };
+    }
+  }
+  return result;
+}
+function formatDiff(result) {
+  const output = [];
+  const { lines } = result;
+  const oldStart = lines.find((l) => l.oldLine)?.oldLine ?? 0;
+  const newStart = lines.find((l) => l.newLine)?.newLine ?? 0;
+  const oldCount = lines.filter((l) => l.type !== "add").length;
+  const newCount = lines.filter((l) => l.type !== "remove").length;
+  output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+  for (const line of lines) {
+    const prefix = line.type === "add" ? "+" : line.type === "remove" ? "-" : " ";
+    output.push(`${prefix}${line.content}`);
+  }
+  return output.join("\n");
+}
+function summarizeDiff(result) {
+  return `+${result.additions} -${result.removals} ~${result.unchanged}`;
+}
+
+export { diffFrontmatter, diffLines, formatDiff, summarizeDiff };

package/dist/draft.d.ts

@@ -0,0 +1,33 @@
+type DraftConfig = {
+    secret: string;
+    cookieName?: string;
+    maxAge?: number;
+};
+type DraftInfo = {
+    enabled: boolean;
+    token?: string;
+    expires?: number;
+};
+type DraftFilter = {
+    includeDrafts: boolean;
+};
+declare function createDraftMode(config: DraftConfig): {
+    enable: (token: string) => {
+        cookie: string;
+        value: string;
+        maxAge: number;
+    };
+    disable: () => {
+        cookie: string;
+        value: string;
+        maxAge: number;
+    };
+    check: (cookieValue: string | undefined) => DraftInfo;
+    generateToken: () => string;
+    validateToken: (token: string) => boolean;
+};
+declare function filterDrafts<T>(items: T[], key: keyof T, filter: DraftFilter): T[];
+declare function isDraft(frontmatter: Record<string, unknown>): boolean;
+declare function scheduledDraft(frontmatter: Record<string, unknown>): boolean;
+
+export { type DraftConfig, type DraftFilter, type DraftInfo, createDraftMode, filterDrafts, isDraft, scheduledDraft };

package/dist/draft.js

@@ -0,0 +1,62 @@
+function createDraftMode(config) {
+  const cookieName = config.cookieName ?? "fromsrc-preview";
+  const maxAge = config.maxAge ?? 3600;
+  function enable(token) {
+    if (!validateToken(token)) {
+      throw new Error("invalid token");
+    }
+    return { cookie: cookieName, value: token, maxAge };
+  }
+  function disable() {
+    return { cookie: cookieName, value: "", maxAge: 0 };
+  }
+  function check(cookieValue) {
+    if (!cookieValue) {
+      return { enabled: false };
+    }
+    if (!validateToken(cookieValue)) {
+      return { enabled: false };
+    }
+    const decoded = atob(cookieValue);
+    const timestamp = Number(decoded.slice(config.secret.length + 1));
+    return { enabled: true, token: cookieValue, expires: timestamp + maxAge * 1e3 };
+  }
+  function generateToken() {
+    const timestamp = Date.now();
+    return btoa(`${config.secret}:${timestamp}`);
+  }
+  function validateToken(token) {
+    try {
+      const decoded = atob(token);
+      return decoded.startsWith(`${config.secret}:`);
+    } catch {
+      return false;
+    }
+  }
+  return { enable, disable, check, generateToken, validateToken };
+}
+function filterDrafts(items, key, filter) {
+  if (filter.includeDrafts) {
+    return items;
+  }
+  return items.filter((item) => !item[key]);
+}
+function isDraft(frontmatter) {
+  return frontmatter.draft === true;
+}
+function scheduledDraft(frontmatter) {
+  const publishDate = frontmatter.publishDate;
+  if (!publishDate) {
+    return false;
+  }
+  if (typeof publishDate !== "string" && typeof publishDate !== "number" && !(publishDate instanceof Date)) {
+    return false;
+  }
+  const date = new Date(publishDate);
+  if (Number.isNaN(date.getTime())) {
+    return false;
+  }
+  return date.getTime() > Date.now();
+}
+
+export { createDraftMode, filterDrafts, isDraft, scheduledDraft };

package/dist/env.d.ts

@@ -0,0 +1,12 @@
+type Environment = "development" | "production" | "test" | "preview";
+type FeatureFlags = Record<string, boolean>;
+declare function getEnv(): Environment;
+declare function isDev(): boolean;
+declare function isProd(): boolean;
+declare function isPreview(): boolean;
+declare function getBaseUrl(): string;
+declare function getFeatureFlags(prefix?: string): FeatureFlags;
+declare function requireEnv(name: string): string;
+declare function optionalEnv(name: string, fallback?: string): string | undefined;
+
+export { type Environment, type FeatureFlags, getBaseUrl, getEnv, getFeatureFlags, isDev, isPreview, isProd, optionalEnv, requireEnv };

package/dist/env.js

@@ -0,0 +1,50 @@
+function getEnv() {
+  const vercel = process.env.VERCEL_ENV;
+  if (vercel === "preview") return "preview";
+  if (vercel === "production") return "production";
+  const node = process.env.NODE_ENV;
+  if (node === "test") return "test";
+  if (node === "production") return "production";
+  return "development";
+}
+function isDev() {
+  return getEnv() === "development";
+}
+function isProd() {
+  return getEnv() === "production";
+}
+function isPreview() {
+  return getEnv() === "preview";
+}
+function getBaseUrl() {
+  const vercel = process.env.VERCEL_URL;
+  if (vercel) return `https://${vercel}`;
+  const pub = process.env.NEXT_PUBLIC_URL;
+  if (pub) return pub;
+  const base = process.env.BASE_URL;
+  if (base) return base;
+  const port = process.env.PORT || "3000";
+  return `http://localhost:${port}`;
+}
+function getFeatureFlags(prefix = "FEATURE_") {
+  const flags = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith(prefix) && value !== void 0) {
+      const name = key.slice(prefix.length).toLowerCase();
+      flags[name] = value === "true" || value === "1";
+    }
+  }
+  return flags;
+}
+function requireEnv(name) {
+  const value = process.env[name];
+  if (value === void 0 || value === "") {
+    throw new Error(`${name}`);
+  }
+  return value;
+}
+function optionalEnv(name, fallback) {
+  return process.env[name] ?? fallback;
+}
+
+export { getBaseUrl, getEnv, getFeatureFlags, isDev, isPreview, isProd, optionalEnv, requireEnv };

package/dist/export.d.ts

@@ -0,0 +1,9 @@
+import { DocMeta, Doc } from './content.js';
+import 'zod';
+import './schema.js';
+
+declare function exportMarkdown(docs: Doc[]): string;
+declare function exportJson(docs: Doc[]): string;
+declare function exportCsv(docs: DocMeta[]): string;
+
+export { exportCsv, exportJson, exportMarkdown };

package/dist/export.js

@@ -0,0 +1,32 @@
+function escape(value) {
+  if (value.includes('"') || value.includes(",") || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function exportMarkdown(docs) {
+  return docs.map((doc) => `# ${doc.title}
+
+${doc.content.trim()}`).join("\n\n---\n\n");
+}
+function exportJson(docs) {
+  return JSON.stringify(
+    docs.map((doc) => ({
+      slug: doc.slug,
+      title: doc.title,
+      description: doc.description,
+      content: doc.content
+    })),
+    null,
+    2
+  );
+}
+function exportCsv(docs) {
+  const header = "slug,title,description";
+  const rows = docs.map(
+    (doc) => `${escape(doc.slug)},${escape(doc.title)},${escape(doc.description ?? "")}`
+  );
+  return [header, ...rows].join("\n");
+}
+
+export { exportCsv, exportJson, exportMarkdown };

package/dist/frontmatter.d.ts

@@ -0,0 +1,19 @@
+import { ZodSchema } from 'zod';
+
+interface FrontmatterResult<T> {
+    data: T;
+    content: string;
+    valid: true;
+}
+interface FrontmatterError {
+    valid: false;
+    errors: string[];
+    content: string;
+}
+declare function parseFrontmatter<T>(source: string, schema: ZodSchema<T>): FrontmatterResult<T> | FrontmatterError;
+declare function validateAllFrontmatter<T>(docsDir: string, schema: ZodSchema<T>): Promise<{
+    path: string;
+    errors: string[];
+}[]>;
+
+export { type FrontmatterError, type FrontmatterResult, parseFrontmatter, validateAllFrontmatter };