298 lines
10 KiB
TypeScript
298 lines
10 KiB
TypeScript
import { existsSync, readFileSync, readdirSync } from "node:fs";
|
|
import { extname, join, relative, resolve } from "node:path";
|
|
|
|
export interface ContentSchema<T> {
|
|
parse(input: unknown): T;
|
|
}
|
|
export interface ContentEntry<T = Record<string, unknown>> {
|
|
id: string;
|
|
slug: string;
|
|
collection: string;
|
|
data: T;
|
|
body: string;
|
|
html: string;
|
|
excerpt: string;
|
|
headings: ContentHeading[];
|
|
draft: boolean;
|
|
version?: string;
|
|
source: string;
|
|
}
|
|
export interface ContentHeading {
|
|
depth: number;
|
|
text: string;
|
|
slug: string;
|
|
}
|
|
export interface ContentLoaderResult {
|
|
id: string;
|
|
source: string;
|
|
content: string;
|
|
}
|
|
export interface ContentLoader {
|
|
load(): ContentLoaderResult[] | Promise<ContentLoaderResult[]>;
|
|
}
|
|
export interface ContentCollectionOptions<T> {
|
|
name: string;
|
|
schema: ContentSchema<T>;
|
|
loader: ContentLoader;
|
|
includeDrafts?: boolean;
|
|
previewToken?: string;
|
|
references?: Record<string, ContentCollection<unknown>>;
|
|
}
|
|
export interface ContentCollection<T> {
|
|
name: string;
|
|
load(options?: {
|
|
drafts?: boolean;
|
|
previewToken?: string;
|
|
version?: string;
|
|
}): Promise<ContentEntry<T>[]>;
|
|
get(
|
|
id: string,
|
|
options?: { drafts?: boolean; previewToken?: string; version?: string },
|
|
): Promise<ContentEntry<T> | null>;
|
|
}
|
|
|
|
function scalar(value: string): unknown {
|
|
const text = value.trim();
|
|
if (/^(true|false)$/i.test(text)) return text.toLowerCase() === "true";
|
|
if (/^-?\d+(?:\.\d+)?$/.test(text)) return Number(text);
|
|
if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'")))
|
|
return text.slice(1, -1);
|
|
if (text.startsWith("[") && text.endsWith("]"))
|
|
return text
|
|
.slice(1, -1)
|
|
.split(",")
|
|
.map((item) => scalar(item));
|
|
return text;
|
|
}
|
|
export function parseFrontmatter(source: string): { data: Record<string, unknown>; body: string } {
|
|
if (!source.startsWith("---\n") && !source.startsWith("---\r\n"))
|
|
return { data: {}, body: source };
|
|
const normalized = source.replace(/\r\n/g, "\n");
|
|
const end = normalized.indexOf("\n---\n", 4);
|
|
if (end < 0) throw new Error("WRN-CONTENT-FRONTMATTER: closing delimiter is missing.");
|
|
const data: Record<string, unknown> = {};
|
|
for (const line of normalized.slice(4, end).split("\n")) {
|
|
if (!line.trim() || line.trimStart().startsWith("#")) continue;
|
|
const match = /^([A-Za-z_$][\w$.-]*):\s*(.*)$/.exec(line);
|
|
if (!match) throw new Error(`WRN-CONTENT-FRONTMATTER: invalid line '${line}'.`);
|
|
data[match[1]!] = scalar(match[2]!);
|
|
}
|
|
return { data, body: normalized.slice(end + 5) };
|
|
}
|
|
const escape = (value: string) =>
|
|
value.replace(
|
|
/[&<>"']/g,
|
|
(character) =>
|
|
({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[character]!,
|
|
);
|
|
const slugify = (value: string) =>
|
|
value
|
|
.toLowerCase()
|
|
.trim()
|
|
.replace(/[^a-z0-9]+/g, "-")
|
|
.replace(/^-|-$/g, "");
|
|
export function renderMarkdown(source: string): {
|
|
html: string;
|
|
headings: ContentHeading[];
|
|
excerpt: string;
|
|
} {
|
|
const headings: ContentHeading[] = [];
|
|
const lines = source.replace(/\r\n/g, "\n").split("\n");
|
|
const output: string[] = [];
|
|
let code: string[] | null = null;
|
|
let language = "";
|
|
for (const line of lines) {
|
|
const fence = /^```([\w-]*)/.exec(line);
|
|
if (fence) {
|
|
if (code) {
|
|
output.push(
|
|
`<pre><code class="language-${escape(language)}">${escape(code.join("\n"))}</code></pre>`,
|
|
);
|
|
code = null;
|
|
} else {
|
|
code = [];
|
|
language = fence[1] ?? "";
|
|
}
|
|
continue;
|
|
}
|
|
if (code) {
|
|
code.push(line);
|
|
continue;
|
|
}
|
|
const heading = /^(#{1,6})\s+(.+)$/.exec(line);
|
|
if (heading) {
|
|
const text = heading[2]!.trim();
|
|
const item = { depth: heading[1]!.length, text, slug: slugify(text) };
|
|
headings.push(item);
|
|
output.push(`<h${item.depth} id="${escape(item.slug)}">${escape(text)}</h${item.depth}>`);
|
|
} else if (line.trim())
|
|
output.push(
|
|
`<p>${escape(line.trim()).replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+|\/[^\s)]*)\)/g, '<a href="$2">$1</a>')}</p>`,
|
|
);
|
|
}
|
|
if (code) throw new Error("WRN-CONTENT-MARKDOWN: code fence is not closed.");
|
|
const excerpt =
|
|
lines
|
|
.find((line) => line.trim() && !line.startsWith("#") && !line.startsWith("---"))
|
|
?.trim()
|
|
.slice(0, 240) ?? "";
|
|
return { html: output.join("\n"), headings, excerpt };
|
|
}
|
|
|
|
export function localContentLoader(directory: string): ContentLoader {
|
|
const root = resolve(directory);
|
|
return {
|
|
load() {
|
|
if (!existsSync(root)) return [];
|
|
const values: ContentLoaderResult[] = [];
|
|
const walk = (current: string) => {
|
|
for (const entry of readdirSync(current, { withFileTypes: true })) {
|
|
if (entry.name.startsWith(".")) continue;
|
|
const path = join(current, entry.name);
|
|
if (entry.isDirectory()) walk(path);
|
|
else if ([".md", ".mdx"].includes(extname(entry.name)))
|
|
values.push({
|
|
id: relative(root, path)
|
|
.replace(/\\/g, "/")
|
|
.replace(/\.mdx?$/, ""),
|
|
source: path,
|
|
content: readFileSync(path, "utf8"),
|
|
});
|
|
}
|
|
};
|
|
walk(root);
|
|
return values.sort((left, right) => left.id.localeCompare(right.id));
|
|
},
|
|
};
|
|
}
|
|
export function remoteContentLoader(
|
|
url: string,
|
|
options: {
|
|
fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
|
|
headers?: HeadersInit;
|
|
} = {},
|
|
): ContentLoader {
|
|
return {
|
|
async load() {
|
|
const response = await (options.fetch ?? globalThis.fetch)(url, { headers: options.headers });
|
|
if (!response.ok) throw new Error(`WRN-CONTENT-REMOTE: ${response.status}`);
|
|
const value = (await response.json()) as Array<{
|
|
id: string;
|
|
content: string;
|
|
source?: string;
|
|
}>;
|
|
if (!Array.isArray(value)) throw new TypeError("WRN-CONTENT-REMOTE: expected an array.");
|
|
return value.map((entry) => ({
|
|
id: entry.id,
|
|
content: entry.content,
|
|
source: entry.source ?? url,
|
|
}));
|
|
},
|
|
};
|
|
}
|
|
export function defineCollection<T>(options: ContentCollectionOptions<T>): ContentCollection<T> {
|
|
const parse = (raw: ContentLoaderResult): ContentEntry<T> => {
|
|
const parsed = parseFrontmatter(raw.content);
|
|
const rendered = renderMarkdown(parsed.body);
|
|
const data = options.schema.parse(parsed.data);
|
|
const record = data as Record<string, unknown>;
|
|
return {
|
|
id: raw.id,
|
|
slug: String(record.slug ?? raw.id),
|
|
collection: options.name,
|
|
data,
|
|
body: parsed.body,
|
|
...rendered,
|
|
draft: record.draft === true,
|
|
version: typeof record.version === "string" ? record.version : undefined,
|
|
source: raw.source,
|
|
};
|
|
};
|
|
const load = async (
|
|
filter: { drafts?: boolean; previewToken?: string; version?: string } = {},
|
|
) => {
|
|
const preview = Boolean(options.previewToken && filter.previewToken === options.previewToken);
|
|
const drafts = options.includeDrafts || filter.drafts || preview;
|
|
return (await options.loader.load())
|
|
.map(parse)
|
|
.filter(
|
|
(entry) =>
|
|
(drafts || !entry.draft) && (!filter.version || entry.version === filter.version),
|
|
);
|
|
};
|
|
return {
|
|
name: options.name,
|
|
load,
|
|
async get(id, filter) {
|
|
return (await load(filter)).find((entry) => entry.id === id || entry.slug === id) ?? null;
|
|
},
|
|
};
|
|
}
|
|
export function resolveContentReference(
|
|
collections: Record<string, ContentCollection<unknown>>,
|
|
reference: string,
|
|
) {
|
|
const [collection, id] = reference.split(":", 2);
|
|
if (!collection || !id || !collections[collection])
|
|
throw new Error(`WRN-CONTENT-REFERENCE: '${reference}' is invalid.`);
|
|
return collections[collection].get(id);
|
|
}
|
|
export function paginateContent<T>(entries: T[], page = 1, pageSize = 10) {
|
|
if (!Number.isInteger(page) || page < 1 || !Number.isInteger(pageSize) || pageSize < 1)
|
|
throw new RangeError("content pagination values must be positive integers");
|
|
const totalPages = Math.max(1, Math.ceil(entries.length / pageSize));
|
|
return {
|
|
items: entries.slice((page - 1) * pageSize, page * pageSize),
|
|
page,
|
|
pageSize,
|
|
total: entries.length,
|
|
totalPages,
|
|
hasNext: page < totalPages,
|
|
hasPrevious: page > 1,
|
|
};
|
|
}
|
|
export function createSearchIndex(entries: ContentEntry[]) {
|
|
return entries.map((entry) => ({
|
|
id: entry.id,
|
|
slug: entry.slug,
|
|
title: String((entry.data as Record<string, unknown>).title ?? entry.id),
|
|
text: `${entry.excerpt} ${entry.headings.map((heading) => heading.text).join(" ")}`.toLowerCase(),
|
|
}));
|
|
}
|
|
export function searchContent(index: ReturnType<typeof createSearchIndex>, query: string) {
|
|
const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
|
|
return index.filter((entry) =>
|
|
terms.every((term) => `${entry.title} ${entry.text}`.toLowerCase().includes(term)),
|
|
);
|
|
}
|
|
export function contentSitemap(entries: ContentEntry[], baseUrl: string) {
|
|
return `<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${entries.map((entry) => `<url><loc>${escape(new URL(entry.slug, baseUrl).href)}</loc></url>`).join("")}</urlset>`;
|
|
}
|
|
export function contentRss(
|
|
entries: ContentEntry[],
|
|
options: { title: string; baseUrl: string; description?: string },
|
|
) {
|
|
return `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>${escape(options.title)}</title><link>${escape(options.baseUrl)}</link><description>${escape(options.description ?? options.title)}</description>${entries.map((entry) => `<item><title>${escape(String((entry.data as Record<string, unknown>).title ?? entry.id))}</title><link>${escape(new URL(entry.slug, options.baseUrl).href)}</link><guid>${escape(entry.id)}</guid><description>${escape(entry.excerpt)}</description></item>`).join("")}</channel></rss>`;
|
|
}
|
|
export interface CmsAdapter {
|
|
list(collection: string): Promise<Array<{ id: string; content: string; source?: string }>>;
|
|
}
|
|
export function cmsContentLoader(adapter: CmsAdapter, collection: string): ContentLoader {
|
|
return {
|
|
async load() {
|
|
return (await adapter.list(collection)).map((entry) => ({
|
|
...entry,
|
|
source: entry.source ?? `cms:${collection}:${entry.id}`,
|
|
}));
|
|
},
|
|
};
|
|
}
|
|
export {
|
|
renderMdxComponents,
|
|
createIncrementalHighlighter,
|
|
contentfulAdapter,
|
|
sanityAdapter,
|
|
strapiAdapter,
|
|
} from "./advanced.ts";
|
|
export type { MdxComponent, SyntaxLanguageBundle, VendorAdapterOptions } from "./advanced.ts";
|