@bliztek/mdx-utils 1.0.0 → 2.0.0

package/dist/node.js

@@ -5,13 +5,333 @@ import {
 } from "./chunk-2WOYQBZW.js";
 
 // src/node.ts
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/collection.ts
 import { readdir, readFile } from "fs/promises";
 import path from "path";
+
+// src/frontmatter.ts
+function defaultParseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const lines = match[1].split(/\r?\n/);
+  const result = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^\s*(#|$)/.test(line)) {
+      i++;
+      continue;
+    }
+    const kv = line.match(/^(\s*)([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+    if (!kv) {
+      i++;
+      continue;
+    }
+    const key = kv[2];
+    const rawValue = kv[3].trim();
+    if (rawValue === "") {
+      const items = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const next = lines[j];
+        if (/^\s*$/.test(next)) {
+          j++;
+          continue;
+        }
+        const blockItem = next.match(/^\s+-\s+(.*)$/);
+        if (!blockItem) break;
+        items.push(parseScalar(blockItem[1].trim()));
+        j++;
+      }
+      if (items.length > 0) {
+        result[key] = items;
+        i = j;
+        continue;
+      }
+      result[key] = "";
+      i++;
+      continue;
+    }
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+      const inner = rawValue.slice(1, -1).trim();
+      result[key] = inner === "" ? [] : splitInlineArray(inner).map(parseScalar);
+      i++;
+      continue;
+    }
+    result[key] = parseScalar(rawValue);
+    i++;
+  }
+  return result;
+}
+function parseScalar(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function splitInlineArray(inner) {
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (quote) {
+      buf += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === ",") {
+      out.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim() !== "") out.push(buf.trim());
+  return out;
+}
+
+// src/errors.ts
+var MAX_INLINE_ISSUES = 10;
+function formatMessage(issues) {
+  if (issues.length === 0) {
+    return "MdxValidationError: no issues (this is a bug \u2014 do not throw with an empty list)";
+  }
+  const head = `MdxValidationError: ${issues.length} issue${issues.length === 1 ? "" : "s"} found in frontmatter`;
+  const shown = issues.slice(0, MAX_INLINE_ISSUES);
+  const lines = shown.map(
+    (issue) => `  - ${issue.filePath} @ ${issue.path}: ${issue.message}`
+  );
+  if (issues.length > shown.length) {
+    lines.push(`  ... and ${issues.length - shown.length} more`);
+  }
+  return [head, ...lines].join("\n");
+}
+var MdxValidationError = class extends Error {
+  constructor(issues) {
+    super(formatMessage(issues));
+    this.name = "MdxValidationError";
+    this.issues = issues;
+  }
+};
+
+// src/collection.ts
+async function walkCollection(rootAbs, namespaceDepth) {
+  const dirents = await readdir(rootAbs, {
+    withFileTypes: true,
+    recursive: true
+  });
+  const files = [];
+  for (const dirent of dirents) {
+    if (dirent.isDirectory()) continue;
+    if (!dirent.name.endsWith(".mdx")) continue;
+    const parentPath = dirent.parentPath ?? rootAbs;
+    const relativeDir = path.relative(rootAbs, parentPath);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path.sep);
+    if (segments.length !== namespaceDepth) {
+      const filePath = path.join(parentPath, dirent.name);
+      throw new Error(
+        `[mdx-utils] File ${filePath} is at depth ${segments.length} but the collection declares namespaceDepth=${namespaceDepth}. Move the file or adjust namespaceDepth.`
+      );
+    }
+    files.push({
+      namespace: segments.join("/"),
+      slug: dirent.name.slice(0, -".mdx".length),
+      filePath: path.join(parentPath, dirent.name)
+    });
+  }
+  return files;
+}
+function stripFrontmatterBlock(raw) {
+  const match = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  return match ? raw.slice(match[0].length) : raw;
+}
+function sortEntries(entries) {
+  const withDate = [];
+  const withoutDate = [];
+  for (const entry of entries) {
+    const meta = entry.metadata;
+    const publishedAt = meta?.publishedAt;
+    if (typeof publishedAt === "string") {
+      const ts = new Date(publishedAt).getTime();
+      if (!Number.isNaN(ts)) {
+        withDate.push({ entry, ts });
+        continue;
+      }
+    }
+    withoutDate.push(entry);
+  }
+  withDate.sort((a, b) => b.ts - a.ts);
+  return [...withDate.map((x) => x.entry), ...withoutDate];
+}
+function extractIssues(filePath, error) {
+  if (error && typeof error === "object" && "issues" in error && Array.isArray(error.issues)) {
+    const raw = error.issues;
+    const mapped = [];
+    for (const entry of raw) {
+      const pathValue = entry.path;
+      const dotted = Array.isArray(pathValue) ? pathValue.join(".") : typeof pathValue === "string" ? pathValue : "(root)";
+      const message2 = typeof entry.message === "string" ? entry.message : String(entry);
+      mapped.push({ filePath, path: dotted || "(root)", message: message2 });
+    }
+    if (mapped.length > 0) return mapped;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return [{ filePath, path: "(root)", message }];
+}
+function createMdxCollection(options) {
+  const {
+    root,
+    namespaceDepth = 0,
+    frontmatterSchema,
+    parseFrontmatter = defaultParseFrontmatter,
+    wordsPerMinute
+  } = options;
+  const rootAbs = path.resolve(root);
+  let entriesPromise = null;
+  async function loadEntries() {
+    const files = await walkCollection(rootAbs, namespaceDepth);
+    const loaded = await Promise.all(
+      files.map(async (file) => {
+        const raw = await readFile(file.filePath, "utf-8");
+        const metadata = parseFrontmatter(raw);
+        const body = stripFrontmatterBlock(raw);
+        const { minutes } = calculateReadTime(body, { wordsPerMinute });
+        return {
+          namespace: file.namespace,
+          slug: file.slug,
+          metadata,
+          readTime: minutes,
+          tableOfContents: void 0,
+          filePath: file.filePath
+        };
+      })
+    );
+    return sortEntries(loaded);
+  }
+  function getAll() {
+    if (!entriesPromise) {
+      entriesPromise = loadEntries().catch((err) => {
+        entriesPromise = null;
+        throw err;
+      });
+    }
+    return entriesPromise;
+  }
+  async function getAllByNamespace(namespace) {
+    const all = await getAll();
+    return all.filter((entry) => entry.namespace === namespace);
+  }
+  async function get(args) {
+    const targetNamespace = args.namespace ?? "";
+    const all = await getAll();
+    return all.find(
+      (entry) => entry.namespace === targetNamespace && entry.slug === args.slug
+    ) ?? null;
+  }
+  async function resolveRelated(namespace, slugs) {
+    const all = await getAll();
+    const inNamespace = new Map(
+      all.filter((entry) => entry.namespace === namespace).map((entry) => [entry.slug, entry])
+    );
+    const resolved = [];
+    for (const slug of slugs) {
+      const entry = inNamespace.get(slug);
+      if (entry) {
+        resolved.push(entry);
+      } else {
+        console.warn(
+          `[mdx-utils] resolveRelated: no entry for "${slug}" in namespace "${namespace}"`
+        );
+      }
+    }
+    return resolved;
+  }
+  async function validate() {
+    if (!frontmatterSchema) return;
+    const all = await getAll();
+    const issues = [];
+    for (const entry of all) {
+      try {
+        frontmatterSchema.parse(entry.metadata);
+      } catch (err) {
+        issues.push(...extractIssues(entry.filePath, err));
+      }
+    }
+    if (issues.length > 0) {
+      throw new MdxValidationError(issues);
+    }
+  }
+  function invalidate() {
+    entriesPromise = null;
+  }
+  return {
+    getAll,
+    getAllByNamespace,
+    get,
+    resolveRelated,
+    validate,
+    invalidate
+  };
+}
+
+// src/redirects.ts
+function applyTokens(template, namespace, slug) {
+  return template.replace(/\{namespace\}/g, namespace).replace(/\{slug\}/g, slug);
+}
+async function collectRedirects(options) {
+  const {
+    root,
+    namespaceDepth = 0,
+    basePath,
+    permanent = true,
+    aliasField = "aliases"
+  } = options;
+  const collection = createMdxCollection({ root, namespaceDepth });
+  const entries = await collection.getAll();
+  const redirects = [];
+  const sourceOwners = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const meta = entry.metadata;
+    const rawAliases = meta[aliasField];
+    if (!Array.isArray(rawAliases)) continue;
+    const destination = applyTokens(basePath, entry.namespace, entry.slug);
+    for (const alias of rawAliases) {
+      if (typeof alias !== "string" || alias === "") continue;
+      const source = applyTokens(basePath, entry.namespace, alias);
+      if (source === destination) continue;
+      const existing = sourceOwners.get(source);
+      if (existing && existing !== entry.filePath) {
+        console.warn(
+          `[mdx-utils] collectRedirects: duplicate alias "${alias}" defined in both ${existing} and ${entry.filePath}. Next.js will pick the first match.`
+        );
+      } else {
+        sourceOwners.set(source, entry.filePath);
+      }
+      redirects.push({ source, destination, permanent });
+    }
+  }
+  return redirects;
+}
+
+// src/node.ts
 var DEFAULT_EXTENSIONS = [".mdx"];
 async function getContentSlugs(dirPath, options) {
   const extensions = options?.extensions ?? DEFAULT_EXTENSIONS;
   const recursive = options?.recursive ?? false;
-  const dirents = await readdir(dirPath, {
+  const dirents = await readdir2(dirPath, {
     withFileTypes: true,
     recursive
   });
@@ -20,15 +340,19 @@ async function getContentSlugs(dirPath, options) {
   ).map((dirent) => {
     const slug = dirent.name.substring(0, dirent.name.lastIndexOf("."));
     if (!recursive || !dirent.parentPath) return slug;
-    const relativePath = path.relative(dirPath, dirent.parentPath);
-    return relativePath ? path.join(relativePath, slug) : slug;
+    const relativePath = path2.relative(dirPath, dirent.parentPath);
+    return relativePath ? path2.join(relativePath, slug) : slug;
   });
 }
 async function readMdxFile(filePath) {
-  return readFile(filePath, "utf-8");
+  return readFile2(filePath, "utf-8");
 }
 export {
+  MdxValidationError,
   calculateReadTime,
+  collectRedirects,
+  createMdxCollection,
+  defaultParseFrontmatter,
   getContentSlugs,
   readMdxFile,
   sortByDateDescending,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bliztek/mdx-utils",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Zero-dependency MDX content utilities for read time calculation and file discovery",
   "type": "module",
   "sideEffects": false,
@@ -27,7 +27,8 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "prepublishOnly": "npm run build"
+    "test": "node --import tsx --test src/**/*.test.ts",
+    "prepublishOnly": "pnpm run build"
   },
   "keywords": [
     "mdx",
@@ -45,11 +46,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bliztek/mdx-utils.git"
+    "url": "git+https://gitlab.com/bliztek/mdx-utils.git"
   },
   "devDependencies": {
-    "@types/node": "^24.10.3",
+    "@types/node": "^25.6.0",
     "tsup": "^8.4.0",
-    "typescript": "^5.9.3"
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
   }
 }