fromsrc 0.0.0 → 0.0.1

package/dist/ansi.js

@@ -0,0 +1,192 @@
+const ansiColors = {
+  30: "#000000",
+  31: "#f85149",
+  32: "#3fb950",
+  33: "#d29922",
+  34: "#58a6ff",
+  35: "#bc8cff",
+  36: "#39c5cf",
+  37: "#e6edf3",
+  40: "#000000",
+  41: "#f85149",
+  42: "#3fb950",
+  43: "#d29922",
+  44: "#58a6ff",
+  45: "#bc8cff",
+  46: "#39c5cf",
+  47: "#e6edf3",
+  90: "#484f58",
+  91: "#ff7b72",
+  92: "#56d364",
+  93: "#e3b341",
+  94: "#79c0ff",
+  95: "#d2a8ff",
+  96: "#56d4dd",
+  97: "#f0f6fc",
+  100: "#484f58",
+  101: "#ff7b72",
+  102: "#56d364",
+  103: "#e3b341",
+  104: "#79c0ff",
+  105: "#d2a8ff",
+  106: "#56d4dd",
+  107: "#f0f6fc"
+};
+function parseAnsi(text) {
+  const segments = [];
+  const state = {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    fg: null,
+    bg: null
+  };
+  let current = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "\x1B" && text[i + 1] === "[") {
+      if (current) {
+        segments.push({ text: current, style: { ...state } });
+        current = "";
+      }
+      let j = i + 2;
+      while (j < text.length && text[j] !== "m") {
+        j++;
+      }
+      const codes = text.slice(i + 2, j).split(";").map(Number);
+      i = j + 1;
+      let k = 0;
+      while (k < codes.length) {
+        const code = codes[k];
+        if (code === void 0) {
+          k++;
+          continue;
+        }
+        if (code === 0) {
+          state.bold = false;
+          state.dim = false;
+          state.italic = false;
+          state.underline = false;
+          state.fg = null;
+          state.bg = null;
+        } else if (code === 1) {
+          state.bold = true;
+        } else if (code === 2) {
+          state.dim = true;
+        } else if (code === 3) {
+          state.italic = true;
+        } else if (code === 4) {
+          state.underline = true;
+        } else if (code === 22) {
+          state.bold = false;
+          state.dim = false;
+        } else if (code === 23) {
+          state.italic = false;
+        } else if (code === 24) {
+          state.underline = false;
+        } else if (code === 38 && codes[k + 1] === 5) {
+          const colorIndex = codes[k + 2];
+          if (colorIndex !== void 0) {
+            state.fg = ansi256ToHex(colorIndex);
+            k += 2;
+          }
+        } else if (code === 48 && codes[k + 1] === 5) {
+          const colorIndex = codes[k + 2];
+          if (colorIndex !== void 0) {
+            state.bg = ansi256ToHex(colorIndex);
+            k += 2;
+          }
+        } else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+          state.fg = ansiColors[code] || null;
+        } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+          state.bg = ansiColors[code] || null;
+        } else if (code === 39) {
+          state.fg = null;
+        } else if (code === 49) {
+          state.bg = null;
+        }
+        k++;
+      }
+    } else {
+      current += text[i];
+      i++;
+    }
+  }
+  if (current) {
+    segments.push({ text: current, style: { ...state } });
+  }
+  return segments;
+}
+function ansi256ToHex(n) {
+  if (n < 16) {
+    const basic = [0, 128, 0, 128, 0, 128, 0, 192, 128, 255, 0, 255, 0, 255, 0, 255];
+    const r = basic[n * 3] || 0;
+    const g = basic[n * 3 + 1] || 0;
+    const b = basic[n * 3 + 2] || 0;
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  if (n < 232) {
+    const index = n - 16;
+    const r = Math.floor(index / 36);
+    const g = Math.floor(index % 36 / 6);
+    const b = index % 6;
+    const toVal = (v) => v === 0 ? 0 : 55 + v * 40;
+    return `#${toVal(r).toString(16).padStart(2, "0")}${toVal(g).toString(16).padStart(2, "0")}${toVal(b).toString(16).padStart(2, "0")}`;
+  }
+  const gray = 8 + (n - 232) * 10;
+  return `#${gray.toString(16).padStart(2, "0")}${gray.toString(16).padStart(2, "0")}${gray.toString(16).padStart(2, "0")}`;
+}
+function transformerAnsi() {
+  return {
+    name: "ansi",
+    preprocess(code, options) {
+      if (options.lang === "ansi" || options.lang === "terminal") {
+        return code;
+      }
+    },
+    code(node) {
+      const lang = this.options.lang;
+      if (lang !== "ansi" && lang !== "terminal") return;
+      const lines = node.children;
+      if (!Array.isArray(lines)) return;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || line.type !== "element") continue;
+        const textNode = line.children[0];
+        if (!textNode || textNode.type !== "text") continue;
+        const text = textNode.value;
+        const segments = parseAnsi(text);
+        if (segments.length === 0) continue;
+        line.children = segments.map((seg) => {
+          const styles = [];
+          if (seg.style.fg) styles.push(`color: ${seg.style.fg}`);
+          if (seg.style.bg) styles.push(`background-color: ${seg.style.bg}`);
+          if (seg.style.bold) styles.push("font-weight: bold");
+          if (seg.style.dim) styles.push("opacity: 0.5");
+          if (seg.style.italic) styles.push("font-style: italic");
+          if (seg.style.underline) styles.push("text-decoration: underline");
+          if (styles.length === 0) {
+            return {
+              type: "text",
+              value: seg.text
+            };
+          }
+          return {
+            type: "element",
+            tagName: "span",
+            properties: { style: styles.join("; ") },
+            children: [
+              {
+                type: "text",
+                value: seg.text
+              }
+            ]
+          };
+        });
+      }
+    }
+  };
+}
+
+export { transformerAnsi };

package/dist/api.d.ts

@@ -0,0 +1,30 @@
+type ApiResponse<T> = {
+    data: T;
+    status: number;
+};
+type ApiError = {
+    error: string;
+    status: number;
+};
+type CorsConfig = {
+    origins?: string[];
+    methods?: string[];
+    headers?: string[];
+};
+type RateLimitConfig = {
+    windowMs: number;
+    maxRequests: number;
+};
+type RateLimitResult = {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+};
+declare function json<T>(data: T, status?: number, headers?: HeadersInit): Response;
+declare function error(message: string, status?: number): Response;
+declare function cors(config?: CorsConfig): Record<string, string>;
+declare function withCors(response: Response, config?: CorsConfig): Response;
+declare function cache(response: Response, maxAge: number, stale?: number): Response;
+declare function rateLimiter(config: RateLimitConfig): (key: string) => RateLimitResult;
+
+export { type ApiError, type ApiResponse, type CorsConfig, cache, cors, error, json, rateLimiter, withCors };

package/dist/api.js

@@ -0,0 +1,75 @@
+const DEFAULT_METHODS = "GET, POST, PUT, DELETE, OPTIONS, PATCH";
+const DEFAULT_HEADERS = "Content-Type, Authorization, X-Requested-With";
+let corsWarned = false;
+function json(data, status = 200, headers) {
+  const next = new Headers(headers);
+  if (!next.has("Content-Type")) {
+    next.set("Content-Type", "application/json");
+  }
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: next
+  });
+}
+function error(message, status = 500) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function cors(config) {
+  if (!corsWarned && process.env.NODE_ENV === "production" && (!config?.origins || config.origins.length === 0)) {
+    corsWarned = true;
+    console.warn("fromsrc cors is using wildcard origins in production");
+  }
+  const origin = config?.origins && config.origins.length > 0 ? config.origins.join(", ") : "*";
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": config?.methods?.join(", ") ?? DEFAULT_METHODS,
+    "Access-Control-Allow-Headers": config?.headers?.join(", ") ?? DEFAULT_HEADERS
+  };
+}
+function withCors(response, config) {
+  const headers = new Headers(response.headers);
+  for (const [key, value] of Object.entries(cors(config))) {
+    headers.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function cache(response, maxAge, stale) {
+  const headers = new Headers(response.headers);
+  const staleAge = stale ?? maxAge;
+  headers.set("Cache-Control", `public, max-age=${maxAge}, stale-while-revalidate=${staleAge}`);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function rateLimiter(config) {
+  const windows = /* @__PURE__ */ new Map();
+  return (key) => {
+    const now = Date.now();
+    for (const [item, value] of [...windows.entries()]) {
+      if (now >= value.resetAt) {
+        windows.delete(item);
+      }
+    }
+    const entry = windows.get(key);
+    if (!entry || now >= entry.resetAt) {
+      const resetAt = now + config.windowMs;
+      windows.set(key, { count: 1, resetAt });
+      return { allowed: true, remaining: config.maxRequests - 1, resetAt };
+    }
+    entry.count++;
+    const allowed = entry.count <= config.maxRequests;
+    const remaining = Math.max(0, config.maxRequests - entry.count);
+    return { allowed, remaining, resetAt: entry.resetAt };
+  };
+}
+
+export { cache, cors, error, json, rateLimiter, withCors };

package/dist/astro.d.ts

@@ -0,0 +1,3 @@
+export { astroAdapter } from './adapterastro.js';
+export { AdapterContext, AdapterProvider, FrameworkAdapter, createadapter, useAdapter } from './adapter.js';
+import 'react';

package/dist/astro.js

@@ -0,0 +1,3 @@
+"use client";
+export { astroAdapter } from './adapterastro';
+export { AdapterContext, AdapterProvider, createadapter, useAdapter } from './adapter';

package/dist/audit.d.ts

@@ -0,0 +1,19 @@
+type AuditConfig = {
+    docsDir: string;
+    maxAge?: number;
+    requiredFields?: string[];
+};
+type AuditIssue = {
+    file: string;
+    type: "stale" | "missing-field" | "empty" | "short" | "no-headings" | "orphan";
+    message: string;
+};
+type AuditResult = {
+    total: number;
+    issues: AuditIssue[];
+    score: number;
+};
+declare function audit(config: AuditConfig): Promise<AuditResult>;
+declare function formatAudit(result: AuditResult): string;
+
+export { type AuditConfig, type AuditIssue, type AuditResult, audit, formatAudit };

package/dist/audit.js

@@ -0,0 +1,78 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { relative, join } from 'node:path';
+
+function parsefrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { fields: {}, body: raw };
+  const full = match[0];
+  const section = match[1];
+  if (!full || section === void 0) return { fields: {}, body: raw };
+  const body = raw.slice(full.length).trim();
+  const fields = {};
+  for (const line of section.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      fields[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    }
+  }
+  return { fields, body };
+}
+async function gather(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 gather(full));
+    } else if (/\.(md|mdx)$/.test(entry.name)) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+async function audit(config) {
+  const maxAge = config.maxAge ?? 90;
+  const required = config.requiredFields ?? ["title", "description"];
+  const files = await gather(config.docsDir);
+  const issues = [];
+  const now = Date.now();
+  const threshold = maxAge * 864e5;
+  for (const filepath of files) {
+    const rel = relative(config.docsDir, filepath);
+    const [raw, info] = await Promise.all([readFile(filepath, "utf-8"), stat(filepath)]);
+    if (now - info.mtimeMs > threshold) {
+      issues.push({ file: rel, type: "stale", message: `modified over ${maxAge} days ago` });
+    }
+    const { fields, body } = parsefrontmatter(raw);
+    for (const field of required) {
+      if (!fields[field]) {
+        issues.push({ file: rel, type: "missing-field", message: `missing ${field}` });
+      }
+    }
+    if (body.length < 10) {
+      issues.push({ file: rel, type: "empty", message: "content is empty" });
+    }
+    const words = body.split(/\s+/).filter(Boolean).length;
+    if (words < 100) {
+      issues.push({ file: rel, type: "short", message: `only ${words} words` });
+    }
+    if (!/^##\s/m.test(body)) {
+      issues.push({ file: rel, type: "no-headings", message: "no headings found" });
+    }
+  }
+  const total = files.length;
+  const score = total === 0 ? 100 : Math.max(0, Math.min(100, 100 - issues.length / total * 100));
+  return { total, issues, score: Math.round(score) };
+}
+function formatAudit(result) {
+  const lines = [
+    `audit: ${result.total} files, score ${result.score}/100`,
+    `issues: ${result.issues.length}`
+  ];
+  for (const issue of result.issues) {
+    lines.push(`  ${issue.type} ${issue.file}: ${issue.message}`);
+  }
+  return lines.join("\n");
+}
+
+export { audit, formatAudit };

package/dist/autotype.d.ts

@@ -0,0 +1,17 @@
+interface TypeProperty {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+    default?: string;
+}
+interface TypeDefinition {
+    name: string;
+    description?: string;
+    properties: TypeProperty[];
+    extends?: string[];
+}
+declare function parseTypes(source: string): TypeDefinition[];
+declare function parseTypeFile(filePath: string): Promise<TypeDefinition[]>;
+
+export { type TypeDefinition, type TypeProperty, parseTypeFile, parseTypes };

package/dist/autotype.js

@@ -0,0 +1,73 @@
+import { readFile } from 'node:fs/promises';
+
+const BLOCK_PATTERN = /(?:\/\*\*\s*([\s\S]*?)\s*\*\/\s*)?(?:export\s+)?(?:interface|type)\s+(\w+)(?:<[^>]*>)?(?:\s*=\s*\{|\s*(?:extends\s+([\w\s,<>]+))?\s*\{)([\s\S]*?)\n\}/g;
+const PROP_PATTERN = /(?:\/\*\*\s*([\s\S]*?)\s*\*\/\s*)?(?:readonly\s+)?(\w+)(\??)\s*:\s*([^;\n]+)/g;
+function clean(raw) {
+  return raw.replace(/^\s*\*\s?/gm, "").replace(/@default\s+.*/g, "").trim();
+}
+function extractDefault(raw) {
+  const match = raw.match(/@default\s+(.+)/);
+  return match?.[1]?.trim();
+}
+function normalizeType(raw) {
+  return raw.replace(/\s+/g, " ").trim();
+}
+function parseExtends(raw) {
+  return raw.split(",").map((s) => s.replace(/<.*>/, "").trim());
+}
+function parseProperties(body) {
+  const properties = [];
+  const pattern = new RegExp(PROP_PATTERN.source, PROP_PATTERN.flags);
+  let match = null;
+  while ((match = pattern.exec(body)) !== null) {
+    const jsdoc = match[1];
+    const name = match[2];
+    const optional = match[3];
+    const rawType = match[4];
+    if (!name || optional === void 0 || !rawType) continue;
+    const property = {
+      name,
+      type: normalizeType(rawType),
+      required: optional !== "?"
+    };
+    if (jsdoc) {
+      const description = clean(jsdoc);
+      if (description) property.description = description;
+      const def = extractDefault(jsdoc);
+      if (def) property.default = def;
+    }
+    properties.push(property);
+  }
+  return properties;
+}
+function parseTypes(source) {
+  const definitions = [];
+  const pattern = new RegExp(BLOCK_PATTERN.source, BLOCK_PATTERN.flags);
+  let match = null;
+  while ((match = pattern.exec(source)) !== null) {
+    const jsdoc = match[1];
+    const name = match[2];
+    const extendsClause = match[3];
+    const body = match[4];
+    if (!name || !body) continue;
+    const definition = {
+      name,
+      properties: parseProperties(body)
+    };
+    if (jsdoc) {
+      const description = clean(jsdoc);
+      if (description) definition.description = description;
+    }
+    if (extendsClause) {
+      definition.extends = parseExtends(extendsClause);
+    }
+    definitions.push(definition);
+  }
+  return definitions;
+}
+async function parseTypeFile(filePath) {
+  const source = await readFile(filePath, "utf-8");
+  return parseTypes(source);
+}
+
+export { parseTypeFile, parseTypes };

package/dist/batch.d.ts

@@ -0,0 +1,22 @@
+type BatchConfig = {
+    concurrency?: number;
+    onProgress?: (done: number, total: number) => void;
+};
+type BatchResult<T> = {
+    results: T[];
+    errors: BatchError[];
+    duration: number;
+};
+type BatchError = {
+    index: number;
+    error: string;
+};
+declare function batch<TItem, TResult>(items: TItem[], fn: (item: TItem, index: number) => Promise<TResult>, config?: BatchConfig): Promise<BatchResult<TResult>>;
+declare function batchFiles<T>(dir: string, fn: (path: string, content: string) => Promise<T>, config?: BatchConfig): Promise<BatchResult<T>>;
+declare function mapFiles(dir: string, transform: (content: string, path: string) => string, config?: BatchConfig): Promise<{
+    modified: number;
+    total: number;
+}>;
+declare function forEachDoc(dir: string, fn: (path: string, content: string) => Promise<void> | void): Promise<void>;
+
+export { type BatchConfig, type BatchError, type BatchResult, batch, batchFiles, forEachDoc, mapFiles };

package/dist/batch.js

@@ -0,0 +1,68 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+
+async function collect(dir) {
+  const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((e) => e.isFile() && [".md", ".mdx"].includes(extname(e.name))).map((e) => join(e.parentPath ?? e.path, e.name));
+}
+async function batch(items, fn, config) {
+  const limit = config?.concurrency ?? 4;
+  const start = performance.now();
+  const results = new Array(items.length);
+  const errors = [];
+  let cursor = 0;
+  let done = 0;
+  async function next() {
+    while (cursor < items.length) {
+      const i = cursor++;
+      const item = items[i];
+      if (item === void 0) continue;
+      try {
+        results[i] = await fn(item, i);
+      } catch (e) {
+        errors.push({ index: i, error: e instanceof Error ? e.message : String(e) });
+      }
+      done++;
+      config?.onProgress?.(done, items.length);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => next()));
+  return { results, errors, duration: performance.now() - start };
+}
+async function batchFiles(dir, fn, config) {
+  const paths = await collect(dir);
+  return batch(
+    paths,
+    async (p) => {
+      const content = await readFile(p, "utf-8");
+      return fn(p, content);
+    },
+    config
+  );
+}
+async function mapFiles(dir, transform, config) {
+  const paths = await collect(dir);
+  let modified = 0;
+  await batch(
+    paths,
+    async (p) => {
+      const original = await readFile(p, "utf-8");
+      const result = transform(original, p);
+      if (result !== original) {
+        await writeFile(p, result, "utf-8");
+        modified++;
+      }
+    },
+    config
+  );
+  return { modified, total: paths.length };
+}
+async function forEachDoc(dir, fn) {
+  const paths = await collect(dir);
+  for (const p of paths) {
+    const content = await readFile(p, "utf-8");
+    await fn(p, content);
+  }
+}
+
+export { batch, batchFiles, forEachDoc, mapFiles };

package/dist/browser.d.ts

@@ -0,0 +1,5 @@
+declare function usepath(): string;
+declare function push(url: string): void;
+declare function back(): void;
+
+export { back, push, usepath };

package/dist/browser.js

@@ -0,0 +1,53 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function current() {
+  if (typeof window === "undefined") {
+    return "/";
+  }
+  return window.location.pathname;
+}
+function usepath() {
+  const [value, setValue] = useState(current);
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const update = () => setValue(window.location.pathname);
+    update();
+    window.addEventListener("popstate", update);
+    window.addEventListener("hashchange", update);
+    window.addEventListener("astro:page-load", update);
+    return () => {
+      window.removeEventListener("popstate", update);
+      window.removeEventListener("hashchange", update);
+      window.removeEventListener("astro:page-load", update);
+    };
+  }, []);
+  return value;
+}
+function push(url) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  let target;
+  try {
+    target = new URL(url, window.location.href);
+  } catch {
+    return;
+  }
+  if (target.origin !== window.location.origin) {
+    window.location.assign(target.toString());
+    return;
+  }
+  window.history.pushState({}, "", target.toString());
+  window.dispatchEvent(new PopStateEvent("popstate"));
+}
+function back() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.history.back();
+}
+
+export { back, push, usepath };

package/dist/changelog.d.ts

@@ -0,0 +1,27 @@
+interface ChangelogItem {
+    type: "added" | "changed" | "fixed" | "removed" | "deprecated" | "security";
+    description: string;
+}
+interface ChangelogEntry {
+    version: string;
+    date: string;
+    title?: string;
+    description: string;
+    type: "major" | "minor" | "patch" | "prerelease";
+    breaking?: boolean;
+    items: ChangelogItem[];
+}
+interface ChangelogConfig {
+    file?: string;
+}
+declare function parseChangelog(content: string): ChangelogEntry[];
+declare function generateChangelogRss(config: {
+    title: string;
+    baseUrl: string;
+    description: string;
+}, entries: ChangelogEntry[]): string;
+declare function latestVersion(entries: ChangelogEntry[]): ChangelogEntry | undefined;
+declare function filterByType(entries: ChangelogEntry[], type: ChangelogEntry["type"]): ChangelogEntry[];
+declare function hasBreaking(entries: ChangelogEntry[]): ChangelogEntry[];
+
+export { type ChangelogConfig, type ChangelogEntry, type ChangelogItem, filterByType, generateChangelogRss, hasBreaking, latestVersion, parseChangelog };