fromsrc 0.0.0 → 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,267 @@
+import { ReactNode } from 'react';
+
+interface AvatarProps {
+    src?: string;
+    name: string;
+    size?: "sm" | "md" | "lg";
+}
+interface AvatarGroupProps {
+    children: ReactNode;
+    label: string;
+}
+interface UserProps {
+    name: string;
+    avatar?: string;
+    role?: string;
+}
+interface ReleaseProps {
+    version: string;
+    date?: string;
+    datetime?: string;
+    children: ReactNode;
+}
+type ChangeType = "added" | "changed" | "fixed" | "removed" | "deprecated" | "security";
+interface ChangeProps {
+    type: ChangeType;
+    children: ReactNode;
+}
+interface ChangelogProps {
+    children: ReactNode;
+}
+interface CollapsibleProps {
+    title: string;
+    defaultOpen?: boolean;
+    children: ReactNode;
+}
+interface DetailsProps {
+    summary: string;
+    children: ReactNode;
+}
+type CompareVariant = "default" | "good" | "bad";
+interface CompareProps {
+    children: ReactNode;
+    label?: string;
+}
+interface ColumnProps {
+    title: string;
+    variant?: CompareVariant;
+    children: ReactNode;
+}
+interface CompareRowProps {
+    left: ReactNode;
+    right: ReactNode;
+    leftLabel?: string;
+    rightLabel?: string;
+}
+interface CopyableProps {
+    value: string;
+    label?: string;
+}
+interface CopyBlockProps {
+    children: string;
+}
+interface ContentProps {
+    source: string;
+}
+interface CreateProps {
+    package?: string;
+}
+interface DividerProps {
+    label?: string;
+    className?: string;
+}
+interface YouTubeProps {
+    id: string;
+    title?: string;
+}
+interface CodeSandboxProps {
+    id: string;
+    title?: string;
+}
+interface StackBlitzProps {
+    id: string;
+    file?: string;
+    title?: string;
+}
+interface TweetProps {
+    id: string;
+}
+interface GistProps {
+    id: string;
+    file?: string;
+    title?: string;
+}
+type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface FeatureProps {
+    icon?: ReactNode;
+    title: string;
+    children: ReactNode;
+}
+interface FeaturesProps {
+    children: ReactNode;
+    columns?: 2 | 3;
+}
+interface FeatureCardProps {
+    icon?: ReactNode;
+    title: string;
+    children: ReactNode;
+}
+interface IconProps {
+    className?: string;
+    size?: number;
+    fill?: string;
+}
+interface InstallProps {
+    package: string;
+}
+interface LinkCardProps {
+    href: string;
+    title: string;
+    description?: string;
+    icon?: ReactNode;
+}
+interface LinkCardsProps {
+    children: ReactNode;
+}
+interface CheckItemProps {
+    checked?: boolean;
+    children: ReactNode;
+}
+interface BulletItemProps {
+    children: ReactNode;
+}
+interface NumberListProps {
+    start?: number;
+    children: ReactNode;
+}
+interface NumberItemProps {
+    number: number;
+    children: ReactNode;
+}
+interface MathProps {
+    children: ReactNode;
+    display?: boolean;
+}
+interface BlockMathProps {
+    children: ReactNode;
+}
+interface InlineMathProps {
+    children: ReactNode;
+}
+interface NoteProps {
+    children: ReactNode;
+    className?: string;
+    label?: string;
+}
+interface PropertyProps {
+    name: string;
+    type: string;
+    required?: boolean;
+    default?: ReactNode;
+    deprecated?: boolean;
+    children?: ReactNode;
+}
+interface PropertiesProps {
+    children: ReactNode;
+}
+interface QuoteProps {
+    children: ReactNode;
+    author?: string;
+    role?: string;
+    avatar?: string;
+}
+interface TestimonialsProps {
+    children: ReactNode;
+}
+interface TestimonialProps {
+    children: ReactNode;
+    author: string;
+    role?: string;
+    avatar?: string;
+}
+interface ScreenshotProps {
+    src: string;
+    alt: string;
+    caption?: string;
+    browser?: boolean;
+    className?: string;
+}
+interface FrameProps {
+    children: ReactNode;
+    title?: string;
+    className?: string;
+}
+type StatusType = "success" | "warning" | "error" | "info" | "neutral";
+interface StatusProps {
+    type?: StatusType;
+    children: string;
+}
+interface StatusDotProps {
+    type?: StatusType;
+    label?: string;
+    pulse?: boolean;
+}
+interface TerminalProps {
+    title?: string;
+    children: ReactNode;
+}
+interface LineProps {
+    prompt?: string;
+    children: ReactNode;
+}
+interface OutputProps {
+    children: ReactNode;
+}
+interface TypedProps {
+    text: string;
+    speed?: number;
+}
+interface BackToTopProps {
+    threshold?: number;
+    className?: string;
+}
+interface NavLinkProps {
+    href: string;
+    children: ReactNode;
+    icon?: ReactNode;
+    onClick?: () => void;
+    external?: boolean;
+}
+interface CodeBlockProps {
+    children: ReactNode;
+    lang?: string;
+    title?: string;
+}
+interface MobileNavProps {
+    title: string;
+    logo?: ReactNode;
+    navigation: SidebarSection[];
+    docs: DocMeta[];
+    basePath?: string;
+    github?: string;
+}
+interface SidebarSection {
+    title: string;
+    items: (SidebarItem | SidebarFolder | DocMeta)[];
+}
+interface SidebarItem {
+    type: "item";
+    title: string;
+    href: string;
+    icon?: ReactNode;
+}
+interface SidebarFolder {
+    type: "folder";
+    title: string;
+    href?: string;
+    icon?: ReactNode;
+    defaultOpen?: boolean;
+    items: (SidebarItem | SidebarFolder)[];
+}
+interface DocMeta {
+    slug: string;
+    title: string;
+    description?: string;
+}
+
+export type { AvatarGroupProps, AvatarProps, BackToTopProps, BlockMathProps, BulletItemProps, ChangeProps, ChangeType, ChangelogProps, CheckItemProps, CodeBlockProps, CodeSandboxProps, CollapsibleProps, ColumnProps, CompareProps, CompareRowProps, CompareVariant, ContentProps, CopyBlockProps, CopyableProps, CreateProps, DetailsProps, DividerProps, DocMeta, FeatureCardProps, FeatureProps, FeaturesProps, FrameProps, GistProps, IconProps, InlineMathProps, InstallProps, LineProps, LinkCardProps, LinkCardsProps, MathProps, Method, MobileNavProps, NavLinkProps, NoteProps, NumberItemProps, NumberListProps, OutputProps, PropertiesProps, PropertyProps, QuoteProps, ReleaseProps, ScreenshotProps, SidebarFolder, SidebarItem, SidebarSection, StackBlitzProps, StatusDotProps, StatusProps, StatusType, TerminalProps, TestimonialProps, TestimonialsProps, TweetProps, TypedProps, UserProps, YouTubeProps };

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/validate.d.ts

@@ -0,0 +1,13 @@
+interface LinkIssue {
+    file: string;
+    line: number;
+    link: string;
+    type: "broken" | "external";
+}
+interface ValidateOptions {
+    docsDir: string;
+    checkExternal?: boolean;
+}
+declare function validateLinks(options: ValidateOptions): Promise<LinkIssue[]>;
+
+export { type LinkIssue, type ValidateOptions, validateLinks };

package/dist/validate.js

@@ -0,0 +1,78 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+async function validateLinks(options) {
+  const { docsDir, checkExternal = false } = options;
+  const issues = [];
+  const validSlugs = /* @__PURE__ */ new Set();
+  async function collectSlugs(dir, prefix = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await collectSlugs(join(dir, entry.name), `${prefix}${entry.name}/`);
+      } else if (entry.name.endsWith(".mdx")) {
+        const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+        validSlugs.add(slug === "index" ? "" : slug);
+        validSlugs.add(`/docs/${slug === "index" ? "" : slug}`);
+      }
+    }
+  }
+  async function scanFile(filepath, relativePath) {
+    const content = await readFile(filepath, "utf-8");
+    const lines = content.split("\n");
+    const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    const hrefRegex = /href=["']([^"']+)["']/g;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === void 0) continue;
+      let match;
+      while ((match = linkRegex.exec(line)) !== null) {
+        const link = match[2];
+        if (!link) continue;
+        checkLink(link, relativePath, i + 1, issues, validSlugs, checkExternal);
+      }
+      while ((match = hrefRegex.exec(line)) !== null) {
+        const link = match[1];
+        if (!link) continue;
+        checkLink(link, relativePath, i + 1, issues, validSlugs, checkExternal);
+      }
+    }
+  }
+  async function scanDir(dir, prefix = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await scanDir(join(dir, entry.name), `${prefix}${entry.name}/`);
+      } else if (entry.name.endsWith(".mdx")) {
+        await scanFile(join(dir, entry.name), `${prefix}${entry.name}`);
+      }
+    }
+  }
+  await collectSlugs(docsDir);
+  await scanDir(docsDir);
+  return issues;
+}
+function checkLink(link, file, line, issues, validSlugs, checkExternal) {
+  if (link.startsWith("#")) return;
+  if (link.startsWith("mailto:")) return;
+  if (link.startsWith("tel:")) return;
+  if (link.startsWith("http://") || link.startsWith("https://")) {
+    if (checkExternal) {
+      issues.push({ file, line, link, type: "external" });
+    }
+    return;
+  }
+  const normalized = link.split("#")[0]?.split("?")[0] ?? "";
+  if (!normalized) {
+    issues.push({ file, line, link, type: "broken" });
+    return;
+  }
+  if (!validSlugs.has(normalized) && !normalized.startsWith("/docs/")) {
+    const withPrefix = `/docs${normalized.startsWith("/") ? "" : "/"}${normalized}`;
+    if (!validSlugs.has(withPrefix)) {
+      issues.push({ file, line, link, type: "broken" });
+    }
+  }
+}
+
+export { validateLinks };

package/dist/validator.d.ts

@@ -0,0 +1,35 @@
+type ValidationIssue = {
+    rule: string;
+    message: string;
+    line?: number;
+    severity: "error" | "warning" | "info";
+};
+type ValidationRule = {
+    name: string;
+    check: (content: string, path: string) => ValidationIssue[];
+};
+type ValidationResult = {
+    path: string;
+    issues: ValidationIssue[];
+    valid: boolean;
+};
+type ValidatorConfig = {
+    rules: ValidationRule[];
+    failOn?: "error" | "warning";
+};
+declare function createRule(name: string, check: (content: string, path: string) => ValidationIssue[]): ValidationRule;
+declare function validate(content: string, path: string, rules: ValidationRule[]): ValidationResult;
+declare function validateAll(files: {
+    path: string;
+    content: string;
+}[], rules: ValidationRule[]): ValidationResult[];
+declare const builtinRules: {
+    readonly titleRequired: ValidationRule;
+    readonly maxLength: ValidationRule;
+    readonly noTabs: ValidationRule;
+    readonly noTrailingSpaces: ValidationRule;
+    readonly noEmptyLinks: ValidationRule;
+    readonly frontmatterRequired: ValidationRule;
+};
+
+export { type ValidationIssue, type ValidationResult, type ValidationRule, type ValidatorConfig, builtinRules, createRule, validate, validateAll };

package/dist/validator.js

@@ -0,0 +1,53 @@
+function createRule(name, check) {
+  return { name, check };
+}
+function validate(content, path, rules) {
+  const issues = rules.flatMap((r) => r.check(content, path));
+  return { path, issues, valid: !issues.some((i) => i.severity === "error") };
+}
+function validateAll(files, rules) {
+  return files.map((f) => validate(f.content, f.path, rules));
+}
+function scan(content, rule, severity, test, message) {
+  const issues = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && test(line)) issues.push({ rule, message, line: i + 1, severity });
+  }
+  return issues;
+}
+const builtinRules = {
+  titleRequired: createRule("titleRequired", (content) => {
+    const first = content.split("\n").find((l) => l.startsWith("#"));
+    if (!first) return [{ rule: "titleRequired", message: "missing heading", severity: "error" }];
+    return [];
+  }),
+  maxLength: createRule("maxLength", (content) => {
+    const count = content.split("\n").length;
+    if (count > 500)
+      return [{ rule: "maxLength", message: `${count} lines exceeds 500`, severity: "warning" }];
+    return [];
+  }),
+  noTabs: createRule(
+    "noTabs",
+    (content) => scan(content, "noTabs", "warning", (l) => l.replace(/^\t+/, "").includes("	"), "tab in content")
+  ),
+  noTrailingSpaces: createRule(
+    "noTrailingSpaces",
+    (content) => scan(content, "noTrailingSpaces", "warning", (l) => /\s+$/.test(l), "trailing space")
+  ),
+  noEmptyLinks: createRule(
+    "noEmptyLinks",
+    (content) => scan(content, "noEmptyLinks", "error", (l) => /\[.+?\]\(\s*\)/.test(l), "empty href")
+  ),
+  frontmatterRequired: createRule("frontmatterRequired", (content) => {
+    if (!content.startsWith("---"))
+      return [{ rule: "frontmatterRequired", message: "missing frontmatter", severity: "error" }];
+    if (content.indexOf("---", 3) === -1)
+      return [{ rule: "frontmatterRequired", message: "unclosed frontmatter", severity: "error" }];
+    return [];
+  })
+};
+
+export { builtinRules, createRule, validate, validateAll };

package/dist/versioning.d.ts

@@ -0,0 +1,32 @@
+type DocVersion = {
+    label: string;
+    path: string;
+    isLatest?: boolean;
+    isDefault?: boolean;
+};
+type VersionConfig = {
+    versions: DocVersion[];
+    versionedPaths?: string[];
+};
+type VersionedPage = {
+    version: DocVersion;
+    path: string;
+    alternateVersions: DocVersion[];
+};
+declare function parseVersion(label: string): {
+    major: number;
+    minor: number;
+    patch: number;
+};
+declare function compareVersions(a: string, b: string): number;
+declare function sortVersions(versions: DocVersion[]): DocVersion[];
+declare function resolveVersion(path: string, config: VersionConfig): VersionedPage | null;
+declare function getLatestVersion(config: VersionConfig): DocVersion;
+declare function isVersionedPath(path: string, config: VersionConfig): boolean;
+declare function createVersionSwitcher(config: VersionConfig): {
+    resolve: (path: string) => VersionedPage | null;
+    latest: () => DocVersion;
+    switchVersion: (path: string, target: DocVersion) => string;
+};
+
+export { type DocVersion, type VersionConfig, type VersionedPage, compareVersions, createVersionSwitcher, getLatestVersion, isVersionedPath, parseVersion, resolveVersion, sortVersions };

package/dist/versioning.js

@@ -0,0 +1,62 @@
+function parseVersion(label) {
+  const clean = label.replace(/^v/, "");
+  const parts = clean.split(".");
+  const majorRaw = parts[0];
+  const minorRaw = parts[1];
+  const patchRaw = parts[2];
+  return {
+    major: Number.parseInt(majorRaw ?? "0", 10) || 0,
+    minor: Number.parseInt(minorRaw ?? "0", 10) || 0,
+    patch: Number.parseInt(patchRaw ?? "0", 10) || 0
+  };
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (va.major !== vb.major) return va.major > vb.major ? 1 : -1;
+  if (va.minor !== vb.minor) return va.minor > vb.minor ? 1 : -1;
+  if (va.patch !== vb.patch) return va.patch > vb.patch ? 1 : -1;
+  return 0;
+}
+function sortVersions(versions) {
+  return [...versions].sort((a, b) => compareVersions(b.label, a.label));
+}
+function resolveVersion(path, config) {
+  const segments = path.split("/").filter(Boolean);
+  const first = segments[0];
+  const match = config.versions.find((v) => v.path === `/${first}` || v.label === first);
+  if (!match) return null;
+  const rest = segments.slice(1).join("/");
+  return {
+    version: match,
+    path: rest ? `/${rest}` : "/",
+    alternateVersions: config.versions.filter((v) => v.label !== match.label)
+  };
+}
+function getLatestVersion(config) {
+  const latest = config.versions.find((v) => v.isLatest);
+  if (latest) return latest;
+  return sortVersions(config.versions)[0] ?? { label: "latest", path: "/" };
+}
+function isVersionedPath(path, config) {
+  const segments = path.split("/").filter(Boolean);
+  const first = segments[0];
+  if (!first) return false;
+  if (config.versionedPaths?.length) {
+    return config.versionedPaths.some((p) => path.startsWith(p));
+  }
+  return config.versions.some((v) => v.path === `/${first}` || v.label === first);
+}
+function createVersionSwitcher(config) {
+  return {
+    resolve: (path) => resolveVersion(path, config),
+    latest: () => getLatestVersion(config),
+    switchVersion: (path, target) => {
+      const resolved = resolveVersion(path, config);
+      const base = resolved ? resolved.path : path;
+      return `${target.path}${base === "/" ? "" : base}`;
+    }
+  };
+}
+
+export { compareVersions, createVersionSwitcher, getLatestVersion, isVersionedPath, parseVersion, resolveVersion, sortVersions };

package/dist/vite.d.ts

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

package/dist/vite.js

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

package/dist/watcher.d.ts

@@ -0,0 +1,19 @@
+interface WatcherConfig {
+    dir: string;
+    extensions?: string[];
+    ignore?: string[];
+}
+interface WatchEvent {
+    type: "add" | "change" | "remove";
+    path: string;
+    slug: string;
+}
+type WatchHandler = (event: WatchEvent) => void;
+declare function createWatcher(config: WatcherConfig): {
+    on(handler: WatchHandler): void;
+    start(): void;
+    stop(): void;
+};
+declare function clearAllCaches(): void;
+
+export { type WatchEvent, type WatchHandler, type WatcherConfig, clearAllCaches, createWatcher };

package/dist/watcher.js

@@ -0,0 +1,82 @@
+import { watch, existsSync, readdirSync } from 'node:fs';
+import { join, extname, relative } from 'node:path';
+import { clearContentCache } from './content';
+import { clearMetaCache } from './meta';
+
+function toSlug(dir, filepath) {
+  return relative(dir, filepath).replace(extname(filepath), "").replace(/\\/g, "/").replace(/\/index$/, "");
+}
+function collectFiles(dir, exts) {
+  const files = /* @__PURE__ */ new Set();
+  function scan(d) {
+    try {
+      for (const entry of readdirSync(d, { withFileTypes: true })) {
+        const full = join(d, entry.name);
+        if (entry.isDirectory()) scan(full);
+        else if (exts.includes(extname(entry.name))) files.add(full);
+      }
+    } catch {
+    }
+  }
+  scan(dir);
+  return files;
+}
+function createWatcher(config) {
+  const exts = config.extensions ?? [".mdx", ".md"];
+  const ignore = config.ignore ?? ["node_modules", ".git"];
+  const handlers = [];
+  const known = collectFiles(config.dir, exts);
+  const timers = /* @__PURE__ */ new Map();
+  let watcher = null;
+  function emit(filepath) {
+    if (!exts.includes(extname(filepath))) return;
+    if (ignore.some((p) => filepath.includes(p))) return;
+    const exists = existsSync(filepath);
+    let type;
+    if (!exists) {
+      if (!known.has(filepath)) return;
+      known.delete(filepath);
+      type = "remove";
+    } else if (known.has(filepath)) {
+      type = "change";
+    } else {
+      known.add(filepath);
+      type = "add";
+    }
+    const event = { type, path: filepath, slug: toSlug(config.dir, filepath) };
+    for (const handler of handlers) handler(event);
+  }
+  function handle(_, filename) {
+    if (!filename) return;
+    const filepath = join(config.dir, filename);
+    const prev = timers.get(filepath);
+    if (prev) clearTimeout(prev);
+    timers.set(filepath, setTimeout(() => {
+      timers.delete(filepath);
+      emit(filepath);
+    }, 100));
+  }
+  return {
+    on(handler) {
+      handlers.push(handler);
+    },
+    start() {
+      try {
+        watcher = watch(config.dir, { recursive: true }, handle);
+      } catch {
+      }
+    },
+    stop() {
+      watcher?.close();
+      watcher = null;
+      for (const t of timers.values()) clearTimeout(t);
+      timers.clear();
+    }
+  };
+}
+function clearAllCaches() {
+  clearContentCache();
+  clearMetaCache();
+}
+
+export { clearAllCaches, createWatcher };

package/dist/webhook.d.ts

@@ -0,0 +1,25 @@
+type WebhookEvent = {
+    type: "created" | "updated" | "deleted";
+    path: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+};
+type WebhookConfig = {
+    url: string;
+    secret?: string;
+    events?: WebhookEvent["type"][];
+};
+type WebhookResult = {
+    success: boolean;
+    status: number;
+    duration: number;
+};
+declare function verifySignature(payload: string, signature: string, secret: string): boolean;
+declare function createEventFromChange(type: WebhookEvent["type"], path: string, meta?: Record<string, unknown>): WebhookEvent;
+declare function filterEvents(config: WebhookConfig, events: WebhookEvent[]): WebhookEvent[];
+declare function createWebhook(config: WebhookConfig): {
+    send: (event: WebhookEvent) => Promise<WebhookResult>;
+    sendBatch: (events: WebhookEvent[]) => Promise<WebhookResult>;
+};
+
+export { type WebhookConfig, type WebhookEvent, type WebhookResult, createEventFromChange, createWebhook, filterEvents, verifySignature };