fromsrc 0.0.2 → 0.0.22

package/dist/validator.d.ts

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

package/dist/validator.js

@@ -1,9 +1,9 @@
 function createRule(name, check) {
-  return { name, check };
+  return { check, name };
 }
 function validate(content, path, rules) {
   const issues = rules.flatMap((r) => r.check(content, path));
-  return { path, issues, valid: !issues.some((i) => i.severity === "error") };
+  return { issues, path, valid: !issues.some((i) => i.severity === "error") };
 }
 function validateAll(files, rules) {
   return files.map((f) => validate(f.content, f.path, rules));
@@ -13,39 +13,88 @@ function scan(content, rule, severity, test, message) {
   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 });
+    if (line !== void 0 && test(line)) {
+      issues.push({ line: i + 1, message, rule, 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" }];
+  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 [];
   }),
   maxLength: createRule("maxLength", (content) => {
     const count = content.split("\n").length;
-    if (count > 500)
-      return [{ rule: "maxLength", message: `${count} lines exceeds 500`, severity: "warning" }];
+    if (count > 500) {
+      return [
+        {
+          rule: "maxLength",
+          message: `${count} lines exceeds 500`,
+          severity: "warning"
+        }
+      ];
+    }
     return [];
   }),
+  noEmptyLinks: createRule(
+    "noEmptyLinks",
+    (content) => scan(
+      content,
+      "noEmptyLinks",
+      "error",
+      (l) => /\[.+?\]\(\s*\)/.test(l),
+      "empty href"
+    )
+  ),
   noTabs: createRule(
     "noTabs",
-    (content) => scan(content, "noTabs", "warning", (l) => l.replace(/^\t+/, "").includes("	"), "tab in content")
+    (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")
+    (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" }];
+  titleRequired: createRule("titleRequired", (content) => {
+    const first = content.split("\n").find((l) => l.startsWith("#"));
+    if (!first) {
+      return [
+        {
+          rule: "titleRequired",
+          message: "missing heading",
+          severity: "error"
+        }
+      ];
+    }
     return [];
   })
 };

package/dist/versioning.d.ts

@@ -1,18 +1,18 @@
-type DocVersion = {
+interface DocVersion {
     label: string;
     path: string;
     isLatest?: boolean;
     isDefault?: boolean;
-};
-type VersionConfig = {
+}
+interface VersionConfig {
     versions: DocVersion[];
     versionedPaths?: string[];
-};
-type VersionedPage = {
+}
+interface VersionedPage {
     version: DocVersion;
     path: string;
     alternateVersions: DocVersion[];
-};
+}
 declare function parseVersion(label: string): {
     major: number;
     minor: number;
@@ -24,8 +24,8 @@ declare function resolveVersion(path: string, config: VersionConfig): VersionedP
 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;
+    resolve: (path: string) => VersionedPage | null;
     switchVersion: (path: string, target: DocVersion) => string;
 };
 

package/dist/versioning.js

@@ -13,9 +13,15 @@ function parseVersion(label) {
 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;
+  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) {
@@ -24,33 +30,43 @@ function sortVersions(versions) {
 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 match = config.versions.find(
+    (v) => v.path === `/${first}` || v.label === first
+  );
+  if (!match) {
+    return null;
+  }
   const rest = segments.slice(1).join("/");
   return {
-    version: match,
+    alternateVersions: config.versions.filter((v) => v.label !== match.label),
     path: rest ? `/${rest}` : "/",
-    alternateVersions: config.versions.filter((v) => v.label !== match.label)
+    version: match
   };
 }
 function getLatestVersion(config) {
   const latest = config.versions.find((v) => v.isLatest);
-  if (latest) return latest;
+  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 (!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);
+  return config.versions.some(
+    (v) => v.path === `/${first}` || v.label === first
+  );
 }
 function createVersionSwitcher(config) {
   return {
-    resolve: (path) => resolveVersion(path, config),
     latest: () => getLatestVersion(config),
+    resolve: (path) => resolveVersion(path, config),
     switchVersion: (path, target) => {
       const resolved = resolveVersion(path, config);
       const base = resolved ? resolved.path : path;

package/dist/watcher.js

@@ -4,7 +4,7 @@ import { clearContentCache } from './content';
 import { clearMetaCache } from './meta';
 
 function toSlug(dir, filepath) {
-  return relative(dir, filepath).replace(extname(filepath), "").replace(/\\/g, "/").replace(/\/index$/, "");
+  return relative(dir, filepath).replace(extname(filepath), "").replaceAll("\\", "/").replace(/\/index$/, "");
 }
 function collectFiles(dir, exts) {
   const files = /* @__PURE__ */ new Set();
@@ -12,8 +12,11 @@ function collectFiles(dir, exts) {
     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);
+        if (entry.isDirectory()) {
+          scan(full);
+        } else if (exts.includes(extname(entry.name))) {
+          files.add(full);
+        }
       }
     } catch {
     }
@@ -29,12 +32,18 @@ function createWatcher(config) {
   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;
+    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;
+      if (!known.has(filepath)) {
+        return;
+      }
       known.delete(filepath);
       type = "remove";
     } else if (known.has(filepath)) {
@@ -43,18 +52,31 @@ function createWatcher(config) {
       known.add(filepath);
       type = "add";
     }
-    const event = { type, path: filepath, slug: toSlug(config.dir, filepath) };
-    for (const handler of handlers) handler(event);
+    const event = {
+      path: filepath,
+      slug: toSlug(config.dir, filepath),
+      type
+    };
+    for (const handler of handlers) {
+      handler(event);
+    }
   }
   function handle(_, filename) {
-    if (!filename) return;
+    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));
+    if (prev) {
+      clearTimeout(prev);
+    }
+    timers.set(
+      filepath,
+      setTimeout(() => {
+        timers.delete(filepath);
+        emit(filepath);
+      }, 100)
+    );
   }
   return {
     on(handler) {
@@ -69,7 +91,9 @@ function createWatcher(config) {
     stop() {
       watcher?.close();
       watcher = null;
-      for (const t of timers.values()) clearTimeout(t);
+      for (const t of timers.values()) {
+        clearTimeout(t);
+      }
       timers.clear();
     }
   };

package/dist/webhook.d.ts

@@ -1,19 +1,19 @@
-type WebhookEvent = {
+interface WebhookEvent {
     type: "created" | "updated" | "deleted";
     path: string;
     timestamp: number;
     metadata?: Record<string, unknown>;
-};
-type WebhookConfig = {
+}
+interface WebhookConfig {
     url: string;
     secret?: string;
     events?: WebhookEvent["type"][];
-};
-type WebhookResult = {
+}
+interface 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[];

package/dist/webhook.js

@@ -8,11 +8,21 @@ function istype(value) {
   return value === "created" || value === "updated" || value === "deleted";
 }
 function isevent(value) {
-  if (!isrecord(value)) return false;
-  if (!istype(value.type)) return false;
-  if (typeof value.path !== "string") return false;
-  if (typeof value.timestamp !== "number" || !Number.isFinite(value.timestamp)) return false;
-  if (value.metadata !== void 0 && !isrecord(value.metadata)) return false;
+  if (!isrecord(value)) {
+    return false;
+  }
+  if (!istype(value.type)) {
+    return false;
+  }
+  if (typeof value.path !== "string") {
+    return false;
+  }
+  if (typeof value.timestamp !== "number" || !Number.isFinite(value.timestamp)) {
+    return false;
+  }
+  if (value.metadata !== void 0 && !isrecord(value.metadata)) {
+    return false;
+  }
   return true;
 }
 function parsets(payload) {
@@ -29,15 +39,19 @@ function parsets(payload) {
 }
 function verifySignature(payload, signature, secret) {
   const ts = parsets(payload);
-  if (ts === null) return false;
+  if (ts === null) {
+    return false;
+  }
   return sign(secret, ts) === signature;
 }
 function createEventFromChange(type, path, meta) {
-  return { type, path, timestamp: Date.now(), ...meta && { metadata: meta } };
+  return { path, timestamp: Date.now(), type, ...meta && { metadata: meta } };
 }
 function filterEvents(config, events) {
   const allowed = config.events;
-  if (!allowed) return events;
+  if (!allowed) {
+    return events;
+  }
   return events.filter((e) => allowed.includes(e.type));
 }
 async function dispatch(config, body, type) {
@@ -51,16 +65,24 @@ async function dispatch(config, body, type) {
   }
   const start = performance.now();
   try {
-    const res = await fetch(config.url, { method: "POST", headers, body });
-    return { success: res.ok, status: res.status, duration: performance.now() - start };
+    const res = await fetch(config.url, { body, headers, method: "POST" });
+    return {
+      duration: performance.now() - start,
+      status: res.status,
+      success: res.ok
+    };
   } catch {
-    return { success: false, status: 0, duration: performance.now() - start };
+    return { duration: performance.now() - start, status: 0, success: false };
   }
 }
 function createWebhook(config) {
   return {
     send: (event) => dispatch(config, JSON.stringify(event), event.type),
-    sendBatch: (events) => dispatch(config, JSON.stringify(events), events.map((e) => e.type).join(","))
+    sendBatch: (events) => dispatch(
+      config,
+      JSON.stringify(events),
+      events.map((e) => e.type).join(",")
+    )
   };
 }
 

package/dist/workspace.js

@@ -7,8 +7,10 @@ function isrecord(value) {
 function parsename(raw) {
   try {
     const parsed = JSON.parse(raw);
-    if (!isrecord(parsed)) return null;
-    const name = parsed.name;
+    if (!isrecord(parsed)) {
+      return null;
+    }
+    const { name } = parsed;
     return typeof name === "string" && name.length > 0 ? name : null;
   } catch {
     return null;
@@ -21,7 +23,9 @@ async function matchGlob(root, pattern) {
     const next = [];
     for (const dir of dirs) {
       if (part === "*") {
-        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        const entries = await readdir(dir, { withFileTypes: true }).catch(
+          () => []
+        );
         for (const e of entries) {
           if (e.isDirectory() && !e.name.startsWith(".")) {
             next.push(join(dir, e.name));
@@ -30,7 +34,9 @@ async function matchGlob(root, pattern) {
       } else {
         const full = join(dir, part);
         const s = await stat(full).catch(() => null);
-        if (s?.isDirectory()) next.push(full);
+        if (s?.isDirectory()) {
+          next.push(full);
+        }
       }
     }
     dirs = next;
@@ -45,35 +51,43 @@ async function discoverPackages(config) {
     const dirs = await matchGlob(root, pattern);
     for (const dir of dirs) {
       const pkgPath = join(dir, "package.json");
-      const raw = await readFile(pkgPath, "utf-8").catch(() => null);
-      if (!raw) continue;
+      const raw = await readFile(pkgPath, "utf8").catch(() => null);
+      if (!raw) {
+        continue;
+      }
       const name = parsename(raw) ?? basename(dir);
       const docs = join(dir, docsDir);
       const exists = await stat(docs).catch(() => null);
-      if (!exists?.isDirectory()) continue;
-      results.push({ name, path: dir, docsDir: docs, slug: basename(dir) });
+      if (!exists?.isDirectory()) {
+        continue;
+      }
+      results.push({ docsDir: docs, name, path: dir, slug: basename(dir) });
     }
   }
   return results;
 }
 function buildWorkspaceNav(packages) {
   return packages.map((pkg) => ({
+    children: [],
     label: pkg.name,
-    slug: pkg.slug,
-    children: []
+    slug: pkg.slug
   }));
 }
 function resolveWorkspacePath(packages, slug) {
   const [pkgSlug, ...rest] = slug.split("/");
   const pkg = packages.find((p) => p.slug === pkgSlug);
-  if (!pkg) return null;
+  if (!pkg) {
+    return null;
+  }
   const file = rest.length > 0 ? rest.join("/") : "index";
   return join(pkg.docsDir, `${file}.mdx`);
 }
 function mergeNavigation(sections) {
   const merged = [];
   for (const section of sections) {
-    for (const item of section) merged.push(item);
+    for (const item of section) {
+      merged.push(item);
+    }
   }
   return merged;
 }