fromsrc 0.0.0 → 0.0.1

package/dist/migrate.js

@@ -0,0 +1,108 @@
+import { readFile, mkdir, writeFile, readdir } from 'node:fs/promises';
+import { relative, join, dirname, extname } from 'node:path';
+
+function convertAdmonitions(content) {
+  const lines = content.split("\n");
+  const stack = [];
+  const result = [];
+  for (const line of lines) {
+    if (/^:::note\s*$/.test(line)) {
+      stack.push("Note");
+      result.push("<Note>");
+    } else if (/^:::tip\s*$/.test(line)) {
+      stack.push("Callout");
+      result.push('<Callout type="tip">');
+    } else if (/^:::warning\s*$/.test(line)) {
+      stack.push("Callout");
+      result.push('<Callout type="warning">');
+    } else if (/^:::danger\s*$/.test(line)) {
+      stack.push("Callout");
+      result.push('<Callout type="danger">');
+    } else if (/^:::\s*$/.test(line) && stack.length > 0) {
+      const tag = stack.pop();
+      if (!tag) continue;
+      result.push(`</${tag}>`);
+    } else {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+const migrateDocusaurus = (content, _filepath) => {
+  let out = content;
+  out = out.replace(/^import\s+.*from\s+['"]@docusaurus\/.*['"];?\s*$/gm, "");
+  out = out.replace(
+    /<TabItem\s+value="([^"]*)"(?:\s+label="([^"]*)")?>/g,
+    '<Tab value="$1" label="$2">'
+  );
+  out = out.replace(/<\/TabItem>/g, "</Tab>");
+  out = out.replace(/<CodeBlock(?:\s+language="([^"]*)")?\s*>/g, "```$1");
+  out = out.replace(/<\/CodeBlock>/g, "```");
+  out = convertAdmonitions(out);
+  out = out.replace(/^sidebar_position:\s*.*$/gm, "");
+  out = out.replace(/^sidebar_label:\s*.*$/gm, "");
+  out = out.replace(/\n{3,}/g, "\n\n");
+  return `${out.trim()}
+`;
+};
+const migrateNextra = (content, _filepath) => {
+  let out = content;
+  out = out.replace(/<Callout\s+type="([^"]*)"(?:\s+emoji="[^"]*")?>/g, '<Callout type="$1">');
+  out = out.replace(/<Tabs\s+items=\{(\[.*?\])\}>/g, "<Tabs items={$1}>");
+  out = out.replace(/<Tabs\.Tab>/g, "<Tab>");
+  out = out.replace(/<\/Tabs\.Tab>/g, "</Tab>");
+  return `${out.trim()}
+`;
+};
+const migrateMintlify = (content, _filepath) => {
+  let out = content;
+  out = out.replace(/<CardGroup(?:\s+cols=\{(\d+)\})?>/g, "<Cards>");
+  out = out.replace(/<\/CardGroup>/g, "</Cards>");
+  out = out.replace(/^api:\s*.*$/gm, "");
+  out = out.replace(/^openapi:\s*.*$/gm, "");
+  out = out.replace(/^auth:\s*.*$/gm, "");
+  out = out.replace(/\n{3,}/g, "\n\n");
+  return `${out.trim()}
+`;
+};
+const transforms = {
+  docusaurus: migrateDocusaurus,
+  nextra: migrateNextra,
+  mintlify: migrateMintlify
+};
+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 ([".md", ".mdx"].includes(extname(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+async function migrate(config) {
+  const { source, inputDir, outputDir } = config;
+  const transform = transforms[source];
+  const warnings = [];
+  const files = await collectFiles(inputDir);
+  let count = 0;
+  for (const filepath of files) {
+    const rel = relative(inputDir, filepath);
+    const dest = join(outputDir, rel);
+    try {
+      const content = await readFile(filepath, "utf-8");
+      const result = transform(content, filepath);
+      await mkdir(dirname(dest), { recursive: true });
+      await writeFile(dest, result, "utf-8");
+      count++;
+    } catch (err) {
+      warnings.push(`${rel}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { files: count, warnings };
+}
+
+export { migrate, migrateDocusaurus, migrateMintlify, migrateNextra };

package/dist/navgen.d.ts

@@ -0,0 +1,31 @@
+type NavItem = {
+    title: string;
+    path: string;
+    children?: NavItem[];
+    order?: number;
+    icon?: string;
+};
+type NavConfig = {
+    dir: string;
+    extensions?: string[];
+    orderFile?: string;
+    titleFromFile?: boolean;
+};
+type NavTree = {
+    items: NavItem[];
+    flat: NavItem[];
+};
+type SidebarItem = {
+    title: string;
+    href: string;
+    icon?: string;
+    items?: SidebarItem[];
+};
+declare function generateNav(config: NavConfig): Promise<NavTree>;
+declare function sortNav(items: NavItem[]): NavItem[];
+declare function flattenNav(items: NavItem[]): NavItem[];
+declare function findNavItem(items: NavItem[], path: string): NavItem | undefined;
+declare function navToSidebar(items: NavItem[]): SidebarItem[];
+declare function breadcrumbFromPath(items: NavItem[], path: string): NavItem[];
+
+export { type NavConfig, type NavItem, type NavTree, type SidebarItem, breadcrumbFromPath, findNavItem, flattenNav, generateNav, navToSidebar, sortNav };

package/dist/navgen.js

@@ -0,0 +1,147 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, basename, extname } from 'node:path';
+
+function titleize(s) {
+  return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function ismetaentry(value) {
+  if (!isrecord(value)) return false;
+  const title = value.title;
+  const order = value.order;
+  const icon = value.icon;
+  if (title !== void 0 && typeof title !== "string") return false;
+  if (order !== void 0 && typeof order !== "number") return false;
+  if (icon !== void 0 && typeof icon !== "string") return false;
+  return true;
+}
+function parsejson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function parsemetats(raw) {
+  const match = raw.match(/export\s+default\s+({[\s\S]*})/);
+  if (!match) return null;
+  const body = match[1];
+  return body ? parsejson(body) : null;
+}
+async function readMeta(dir) {
+  for (const name of ["_meta.json", "_meta.ts"]) {
+    try {
+      const raw = await readFile(join(dir, name), "utf-8");
+      const parsed = name.endsWith(".json") ? parsejson(raw) : parsemetats(raw);
+      if (!isrecord(parsed)) return {};
+      const result = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string" || ismetaentry(value)) {
+          result[key] = value;
+        }
+      }
+      return result;
+    } catch {
+    }
+  }
+  return {};
+}
+async function extractTitle(file) {
+  try {
+    const m = (await readFile(file, "utf-8")).match(/^#\s+(.+)$/m);
+    const title = m?.[1];
+    return title ? title.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function resolveMeta(meta, key, fallback) {
+  const e = meta[key];
+  const title = typeof e === "string" ? e : e?.title ?? fallback;
+  const order = typeof e === "string" ? void 0 : e?.order;
+  const icon = typeof e === "string" ? void 0 : e?.icon;
+  return { title, order, icon };
+}
+async function scanDir(dir, root, exts, h1) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const meta = await readMeta(dir);
+  const items = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    const full = join(dir, entry.name);
+    const rel = relative(root, full).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const children = await scanDir(full, root, exts, h1);
+      const idx = children.find((c) => basename(c.path).startsWith("index"));
+      const r2 = resolveMeta(meta, entry.name, idx?.title ?? titleize(entry.name));
+      items.push({
+        ...r2,
+        path: "/" + rel,
+        children: children.filter((c) => !basename(c.path).startsWith("index"))
+      });
+      continue;
+    }
+    const ext = extname(entry.name);
+    if (!exts.includes(ext)) continue;
+    const slug = rel.replace(new RegExp(`${ext}$`), "");
+    const r = resolveMeta(meta, basename(entry.name, ext), titleize(basename(entry.name, ext)));
+    if (h1) {
+      const t = await extractTitle(full);
+      if (t) r.title = t;
+    }
+    items.push({ ...r, path: "/" + slug });
+  }
+  return sortNav(items);
+}
+async function generateNav(config) {
+  const exts = config.extensions ?? [".mdx", ".md"];
+  const items = await scanDir(config.dir, config.dir, exts, config.titleFromFile ?? false);
+  return { items, flat: flattenNav(items) };
+}
+function sortNav(items) {
+  return [...items].sort((a, b) => (a.order ?? 999) - (b.order ?? 999) || a.title.localeCompare(b.title)).map((i) => i.children ? { ...i, children: sortNav(i.children) } : i);
+}
+function flattenNav(items) {
+  const r = [];
+  for (const i of items) {
+    r.push(i);
+    if (i.children) r.push(...flattenNav(i.children));
+  }
+  return r;
+}
+function findNavItem(items, path) {
+  for (const i of items) {
+    if (i.path === path) return i;
+    if (i.children) {
+      const f = findNavItem(i.children, path);
+      if (f) return f;
+    }
+  }
+  return void 0;
+}
+function navToSidebar(items) {
+  return items.map((i) => ({
+    title: i.title,
+    href: i.path,
+    icon: i.icon,
+    ...i.children?.length ? { items: navToSidebar(i.children) } : {}
+  }));
+}
+function breadcrumbFromPath(items, path) {
+  function walk(cur, trail) {
+    for (const i of cur) {
+      const next = [...trail, i];
+      if (i.path === path) return next;
+      if (i.children) {
+        const f = walk(i.children, next);
+        if (f) return f;
+      }
+    }
+    return null;
+  }
+  return walk(items, []) ?? [];
+}
+
+export { breadcrumbFromPath, findNavItem, flattenNav, generateNav, navToSidebar, sortNav };

package/dist/navtree.d.ts

@@ -0,0 +1,28 @@
+import { DocMeta } from './content.js';
+import 'zod';
+import './schema.js';
+
+interface NavNode {
+    title: string;
+    slug: string;
+    href?: string;
+    children: NavNode[];
+    order?: number;
+    icon?: string;
+    badge?: string;
+}
+interface NavTreeConfig {
+    docs: DocMeta[];
+    basePath?: string;
+    collapsible?: boolean;
+}
+declare function buildNavTree(config: NavTreeConfig): NavNode[];
+declare function flattenNavTree(nodes: NavNode[]): NavNode[];
+declare function findNavNode(nodes: NavNode[], slug: string): NavNode | null;
+declare function getNavBreadcrumbs(nodes: NavNode[], slug: string): NavNode[];
+declare function getPrevNext(nodes: NavNode[], slug: string): {
+    prev: NavNode | null;
+    next: NavNode | null;
+};
+
+export { type NavNode, type NavTreeConfig, buildNavTree, findNavNode, flattenNavTree, getNavBreadcrumbs, getPrevNext };

package/dist/navtree.js

@@ -0,0 +1,93 @@
+function titleize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1).replace(/-/g, " ");
+}
+function buildNavTree(config) {
+  const { docs, basePath = "/docs" } = config;
+  const root = [];
+  const map = /* @__PURE__ */ new Map();
+  const sorted = [...docs].sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+  for (const doc of sorted) {
+    const segments = doc.slug.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      const node = {
+        title: doc.title,
+        slug: doc.slug,
+        href: basePath,
+        children: [],
+        order: doc.order
+      };
+      map.set("", node);
+      root.push(node);
+      continue;
+    }
+    let parentChildren = root;
+    let path = "";
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (!segment) continue;
+      path = path ? `${path}/${segment}` : segment;
+      const isLast = i === segments.length - 1;
+      let existing = map.get(path);
+      if (!existing) {
+        existing = {
+          title: isLast ? doc.title : titleize(segment),
+          slug: path,
+          href: isLast ? `${basePath}/${path}` : void 0,
+          children: [],
+          order: isLast ? doc.order : void 0
+        };
+        map.set(path, existing);
+        parentChildren.push(existing);
+      } else if (isLast) {
+        existing.title = doc.title;
+        existing.href = `${basePath}/${path}`;
+        existing.order = doc.order;
+      }
+      parentChildren = existing.children;
+    }
+  }
+  function sortNodes(nodes) {
+    nodes.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+    for (const node of nodes) if (node.children.length > 0) sortNodes(node.children);
+  }
+  sortNodes(root);
+  return root;
+}
+function flattenNavTree(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    result.push(node);
+    if (node.children.length > 0) result.push(...flattenNavTree(node.children));
+  }
+  return result;
+}
+function findNavNode(nodes, slug) {
+  for (const node of nodes) {
+    if (node.slug === slug) return node;
+    const found = findNavNode(node.children, slug);
+    if (found) return found;
+  }
+  return null;
+}
+function getNavBreadcrumbs(nodes, slug) {
+  function walk(current, path) {
+    for (const node of current) {
+      const next = [...path, node];
+      if (node.slug === slug) return next;
+      const found = walk(node.children, next);
+      if (found) return found;
+    }
+    return null;
+  }
+  return walk(nodes, []) ?? [];
+}
+function getPrevNext(nodes, slug) {
+  const flat = flattenNavTree(nodes).filter((n) => n.href);
+  const i = flat.findIndex((n) => n.slug === slug);
+  if (i === -1) return { prev: null, next: null };
+  const prev = i > 0 ? flat[i - 1] ?? null : null;
+  const next = i < flat.length - 1 ? flat[i + 1] ?? null : null;
+  return { prev, next };
+}
+
+export { buildNavTree, findNavNode, flattenNavTree, getNavBreadcrumbs, getPrevNext };

package/dist/next.d.ts

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

package/dist/next.js

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

package/dist/oembed.d.ts

@@ -0,0 +1,20 @@
+type OembedData = {
+    type: "video" | "rich" | "photo" | "link";
+    title?: string;
+    html?: string;
+    width?: number;
+    height?: number;
+    thumbnail?: string;
+    provider?: string;
+};
+type OembedProvider = {
+    name: string;
+    pattern: RegExp;
+    endpoint: string;
+};
+declare const providers: OembedProvider[];
+declare function resolve(url: string): Promise<OembedData | null>;
+declare function resolveMany(urls: string[]): Promise<Map<string, OembedData | null>>;
+declare function extractUrls(content: string): string[];
+
+export { type OembedData, type OembedProvider, extractUrls, providers, resolve, resolveMany };

package/dist/oembed.js

@@ -0,0 +1,62 @@
+const providers = [
+  {
+    name: "YouTube",
+    pattern: /(?:youtube\.com\/watch|youtu\.be\/)/,
+    endpoint: "https://www.youtube.com/oembed"
+  },
+  {
+    name: "Vimeo",
+    pattern: /vimeo\.com\//,
+    endpoint: "https://vimeo.com/api/oembed.json"
+  },
+  {
+    name: "Twitter",
+    pattern: /(?:twitter\.com|x\.com)\//,
+    endpoint: "https://publish.twitter.com/oembed"
+  },
+  {
+    name: "CodePen",
+    pattern: /codepen\.io\//,
+    endpoint: "https://codepen.io/api/oembed"
+  },
+  {
+    name: "CodeSandbox",
+    pattern: /codesandbox\.io\//,
+    endpoint: "https://codesandbox.io/oembed"
+  }
+];
+function find(url) {
+  return providers.find((p) => p.pattern.test(url));
+}
+async function resolve(url) {
+  const provider = find(url);
+  if (!provider) return null;
+  try {
+    const endpoint = `${provider.endpoint}?url=${encodeURIComponent(url)}&format=json`;
+    const response = await fetch(endpoint);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return {
+      type: data.type ?? "link",
+      title: data.title,
+      html: data.html,
+      width: data.width,
+      height: data.height,
+      thumbnail: data.thumbnail_url,
+      provider: provider.name
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveMany(urls) {
+  const entries = await Promise.all(urls.map(async (url) => [url, await resolve(url)]));
+  return new Map(entries);
+}
+const urlPattern = /https?:\/\/[^\s)>\]]+/g;
+function extractUrls(content) {
+  const matches = content.match(urlPattern) ?? [];
+  return matches.filter((url) => find(url));
+}
+
+export { extractUrls, providers, resolve, resolveMany };

package/dist/ogimage.d.ts

@@ -0,0 +1,45 @@
+type OgImageConfig = {
+    title: string;
+    description?: string;
+    siteName?: string;
+    logo?: string;
+    theme?: "light" | "dark";
+    accentColor?: string;
+    width?: number;
+    height?: number;
+};
+type OgImageMeta = {
+    url: string;
+    width: number;
+    height: number;
+    alt: string;
+    type: string;
+};
+declare function ogImageUrl(base: string, params: Record<string, string | undefined>): string;
+declare function generateOgMeta(base: string, config: OgImageConfig): OgImageMeta;
+declare function defaultTemplate(config: OgImageConfig): {
+    title: string;
+    description: string;
+    siteName: string;
+    logo: string;
+    width: number;
+    height: number;
+    colors: {
+        background: string;
+        foreground: string;
+        muted: string;
+        accent: string;
+    };
+};
+type MetaTag = {
+    property: string;
+    content: string;
+} | {
+    name: string;
+    content: string;
+};
+declare function socialMeta(config: OgImageConfig & {
+    url: string;
+}): MetaTag[];
+
+export { type OgImageConfig, type OgImageMeta, defaultTemplate, generateOgMeta, ogImageUrl, socialMeta };

package/dist/ogimage.js

@@ -0,0 +1,62 @@
+function ogImageUrl(base, params) {
+  const url = new URL(base);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+function generateOgMeta(base, config) {
+  const width = config.width ?? 1200;
+  const height = config.height ?? 630;
+  const url = ogImageUrl(base, {
+    title: config.title,
+    description: config.description,
+    siteName: config.siteName,
+    logo: config.logo,
+    theme: config.theme,
+    accentColor: config.accentColor,
+    width: String(width),
+    height: String(height)
+  });
+  return {
+    url,
+    width,
+    height,
+    alt: config.description ?? config.title,
+    type: "image/png"
+  };
+}
+function defaultTemplate(config) {
+  const dark = config.theme === "dark";
+  return {
+    title: config.title,
+    description: config.description ?? "",
+    siteName: config.siteName ?? "",
+    logo: config.logo ?? "",
+    width: config.width ?? 1200,
+    height: config.height ?? 630,
+    colors: {
+      background: dark ? "#0a0a0a" : "#ffffff",
+      foreground: dark ? "#fafafa" : "#0a0a0a",
+      muted: dark ? "#a1a1aa" : "#71717a",
+      accent: config.accentColor ?? (dark ? "#3b82f6" : "#2563eb")
+    }
+  };
+}
+function socialMeta(config) {
+  const width = config.width ?? 1200;
+  const height = config.height ?? 630;
+  const alt = config.description ?? config.title;
+  return [
+    { property: "og:image", content: config.url },
+    { property: "og:image:width", content: String(width) },
+    { property: "og:image:height", content: String(height) },
+    { property: "og:image:alt", content: alt },
+    { name: "twitter:card", content: "summary_large_image" },
+    { name: "twitter:image", content: config.url }
+  ];
+}
+
+export { defaultTemplate, generateOgMeta, ogImageUrl, socialMeta };

package/dist/openapi.d.ts

@@ -0,0 +1,6 @@
+import { OpenApiSpec } from './openapiutil.js';
+export { OpenApiEndpoint, OpenApiMethod, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiSchema, OpenApiTag, generateEndpointSlug } from './openapiutil.js';
+
+declare function parseOpenApi(spec: string | object): OpenApiSpec;
+
+export { OpenApiSpec, parseOpenApi };