@pitlane/content 0.1.0

package/dist/mdx.mjs

@@ -0,0 +1,389 @@
+//#region src/mdx.ts
+/**
+* The imports in one top-level ESM block, and what is left after removing them.
+*
+* The remainder matters twice over. A block holds whatever the author wrote, so
+* an `export const` can sit beside an import and the document's body may use
+* it; dropping the whole block would take the export with the import. And what
+* is left is spliced back into the document, so it has to stay recognisable as
+* ESM: a comment surviving on its own line starts a paragraph, which swallows
+* the export that follows it.
+*
+* Statement boundaries come from `es-module-lexer`, the lexer Vite reads the
+* same imports with. Deciding them here instead means reimplementing JavaScript
+* tokenization: a quote inside a regex literal is not a string, a line starting
+* with `import` inside a template is not a statement, `{ import: "x" }` is a
+* property, and each of those was wrong before the lexer answered it.
+*
+* Anything import-shaped the lexer reports and this cannot read throws rather
+* than being skipped: a skipped import is a component that silently renders as
+* nothing, which is the failure this whole path exists to remove.
+*/
+async function readEsm(block, where) {
+	let { init, parse } = await import("es-module-lexer");
+	await init;
+	let lexable = readable(block, parse, where);
+	let comments = commentSpans(lexable);
+	let statements = [];
+	let imports = [];
+	for (let found of parse(lexable)[0]) {
+		if (found.t === 3) throw importMeta(where);
+		if (found.t !== 1 || !block.startsWith("import", found.ss)) continue;
+		let tail = endOfStatement(block, found.e + 1, comments);
+		statements.push({
+			start: found.ss,
+			end: tail.end
+		});
+		let read = readImport(block, found, tail, comments, where);
+		if (read) imports.push(read);
+	}
+	let outside = comments.filter((comment) => !statements.some((held) => covers(held, comment)));
+	return {
+		imports,
+		remainder: blank(block, [...statements, ...outside])
+	};
+}
+function covers(outer, inner) {
+	return inner.start >= outer.start && inner.end <= outer.end;
+}
+/**
+* The block in a form the lexer can read.
+*
+* An MDX document defines a component by writing JSX in its ESM block, and the
+* lexer is a JavaScript lexer: `() => <em>n</em>` is a parse error to it. So
+* each line is masked from the first JSX tag it holds, which leaves every
+* import intact -- an import statement cannot contain a `<` -- and keeps every
+* offset, because the mask is the same width as what it covers.
+*/
+function readable(block, parse, where) {
+	if (lexes(block, parse)) return block;
+	let masked = block.split("\n").map((line) => {
+		let at = line.search(/<(?=[A-Za-z_$>/])/);
+		return at === -1 ? line : line.slice(0, at) + " ".repeat(line.length - at);
+	}).join("\n");
+	if (lexes(masked, parse)) return masked;
+	throw new Error(`Could not read the imports of "${where}": its \`import\` and \`export\` block is not valid JavaScript. Add contentLayer() from @pitlane/content/vite so the build compiles this collection.`);
+}
+function lexes(source, parse) {
+	try {
+		parse(source);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* What follows the specifier: an optional attributes clause, then an optional
+* semicolon, with comments allowed in both gaps.
+*
+* The lexer reports neither reliably. Its statement end stops at the specifier,
+* leaving a `;` that becomes a paragraph reading `;` in the rendered page, and
+* it declines to report a clause written with a trailing comma, with no
+* attributes at all, or on the line below -- all of which are valid, and all of
+* which the host still demands before it will load the module.
+*/
+function endOfStatement(block, after, comments) {
+	let end = skipBlanks(block, after, comments);
+	let attributes;
+	let phrase = /^(?:with|assert)\b/.exec(block.slice(end));
+	if (phrase) {
+		let open = skipBlanks(block, end + phrase[0].length, comments);
+		if (block[open] === "{") {
+			let close = balanced(block, open);
+			attributes = {
+				start: open,
+				end: close
+			};
+			end = close;
+		}
+	}
+	let semicolon = skipBlanks(block, end, comments);
+	return {
+		end: block[semicolon] === ";" ? semicolon + 1 : end,
+		attributes
+	};
+}
+/** Past whitespace and comments, which may sit anywhere in a statement. */
+function skipBlanks(block, from, comments) {
+	let index = from;
+	for (;;) {
+		while (index < block.length && /\s/.test(block[index])) index += 1;
+		let comment = comments.find((held) => held.start === index);
+		if (!comment) return index;
+		index = comment.end;
+	}
+}
+/** The index just past the `}` closing the `{` at `open`. */
+function balanced(block, open) {
+	let depth = 0;
+	for (let index = open; index < block.length; index += 1) if (block[index] === "{") depth += 1;
+	else if (block[index] === "}") {
+		depth -= 1;
+		if (depth === 0) return index + 1;
+	}
+	return block.length;
+}
+/**
+* Replaces each span with its own newlines.
+*
+* Blanked rather than deleted so every offset after it still lines up with the
+* source the author wrote, which is what keeps a later error's line number
+* pointing at the right line.
+*/
+function blank(block, spans) {
+	let ordered = [...spans].sort((a, b) => b.start - a.start);
+	let out = block;
+	for (let { start, end } of ordered) {
+		let removed = out.slice(start, end);
+		out = out.slice(0, start) + "\n".repeat((removed.match(/\n/g) ?? []).length) + out.slice(end);
+	}
+	return out;
+}
+/** Reads one statement, or nothing when it is type-only. */
+function readImport(block, found, tail, comments, where) {
+	let statement = block.slice(found.ss, tail.end);
+	let specifier = found.n;
+	if (specifier === void 0) throw unreadable(statement, where);
+	let clause = erase(block, {
+		start: found.ss + 6,
+		end: found.s - 1
+	}, comments).trim().replace(/\bfrom$/, "").trim();
+	if (/^type\b/.test(clause) && clause.slice(4).trim().length > 0) return void 0;
+	let attributes = tail.attributes && readAttributes(erase(block, tail.attributes, comments));
+	return {
+		specifier,
+		bindings: readBindings(clause, statement, where),
+		attributes
+	};
+}
+/** A slice of the block with any comment in it replaced by blanks. */
+function erase(block, span, comments) {
+	let out = block.slice(span.start, span.end);
+	for (let comment of comments) {
+		if (!covers(span, comment)) continue;
+		let start = comment.start - span.start;
+		let width = comment.end - comment.start;
+		out = out.slice(0, start) + " ".repeat(width) + out.slice(start + width);
+	}
+	return out;
+}
+function readBindings(clause, statement, where) {
+	let bindings = /* @__PURE__ */ new Map();
+	let named = /\{([\s\S]*)\}/.exec(clause);
+	let head = (named ? clause.slice(0, named.index) : clause).replace(/,\s*$/, "").trim();
+	if (head.startsWith("* as ")) throw namespaceImport(head.slice(5).trim(), statement, where);
+	if (head.length > 0) bindings.set(identifier(head, statement, where), "default");
+	for (let part of named?.[1]?.split(",") ?? []) {
+		let entry = part.trim();
+		if (entry.length === 0) continue;
+		let words = entry.split(/\s+/);
+		if (words[0] === "type" && words.length > 1 && words[1] !== "as") continue;
+		let renamed = /^(\S+)\s+as\s+(\S+)$/.exec(entry);
+		if (renamed) bindings.set(identifier(renamed[2], statement, where), renamed[1]);
+		else bindings.set(identifier(entry, statement, where), entry);
+	}
+	return bindings;
+}
+const ATTRIBUTE_RE = /(?:([A-Za-z_$][\w$]*)|"([^"]*)"|'([^']*)')\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+/**
+* An attributes clause has to reach the `import()` this path performs. Dropping
+* it leaves `import data from "./x.json" with { type: "json" }` importing the
+* file with no attribute, which Node refuses outright.
+*/
+function readAttributes(clause) {
+	let attributes = {};
+	for (let [, name, quoted, single, value, singleValue] of clause.matchAll(ATTRIBUTE_RE)) attributes[name ?? quoted ?? single] = value ?? singleValue;
+	return attributes;
+}
+/**
+* The comments in a block of ESM source.
+*
+* Only comments: the lexer answers for imports, so a mistake here leaves a
+* comment in the remainder rather than losing a component. Regex literals are
+* tracked all the same, because `/"/` holds a quote that would otherwise open a
+* string running to the end of the next real one.
+*/
+function commentSpans(block) {
+	let comments = [];
+	let nesting = [];
+	let previous = "";
+	let index = 0;
+	while (index < block.length) {
+		let char = block[index];
+		if (nesting.at(-1) === "template") {
+			if (char === "\\") index += 2;
+			else if (char === "`") {
+				nesting.pop();
+				previous = "`";
+				index += 1;
+			} else if (char === "$" && block[index + 1] === "{") {
+				nesting.push("interpolation");
+				previous = "";
+				index += 2;
+			} else index += 1;
+			continue;
+		}
+		if (char === "/" && block[index + 1] === "/") {
+			let line = block.indexOf("\n", index);
+			let end = line === -1 ? block.length : line;
+			comments.push({
+				start: index,
+				end
+			});
+			index = end;
+		} else if (char === "/" && block[index + 1] === "*") {
+			let close = block.indexOf("*/", index + 2);
+			let end = close === -1 ? block.length : close + 2;
+			comments.push({
+				start: index,
+				end
+			});
+			index = end;
+		} else if (char === "/" && startsRegex(previous)) {
+			index = endOfRegex(block, index);
+			previous = "/";
+		} else if (char === "\"" || char === "'") {
+			index = endOfString(block, index, char);
+			previous = char;
+		} else if (char === "`") {
+			nesting.push("template");
+			index += 1;
+		} else if (char === "{") {
+			nesting.push("brace");
+			previous = char;
+			index += 1;
+		} else if (char === "}") {
+			if (nesting.length > 0) nesting.pop();
+			previous = char;
+			index += 1;
+		} else if (isWordStart(char)) {
+			let end = index;
+			while (end < block.length && isWordPart(block[end])) end += 1;
+			previous = block.slice(index, end);
+			index = end;
+		} else if (/\s/.test(char)) index += 1;
+		else {
+			previous = char;
+			index += 1;
+		}
+	}
+	return comments;
+}
+/** Where a `/` can only begin a regex, never divide. */
+const BEFORE_REGEX = /* @__PURE__ */ new Set([
+	"",
+	"=",
+	"(",
+	",",
+	":",
+	"[",
+	"!",
+	"&",
+	"|",
+	"?",
+	";",
+	"{",
+	"}",
+	"+",
+	"-",
+	"*",
+	"%",
+	"~",
+	"^",
+	"<",
+	">",
+	"return",
+	"typeof",
+	"instanceof",
+	"in",
+	"of",
+	"new",
+	"delete",
+	"void",
+	"case",
+	"do",
+	"else",
+	"yield",
+	"await",
+	"throw"
+]);
+function startsRegex(previous) {
+	return BEFORE_REGEX.has(previous);
+}
+/**
+* The end of a regex literal, or the `/` itself when it turns out to divide.
+*
+* A literal never spans a line, so an unclosed one by the end of the line is
+* division after all, whatever the token before it suggested.
+*/
+function endOfRegex(block, start) {
+	let index = start + 1;
+	let inClass = false;
+	while (index < block.length) {
+		let char = block[index];
+		if (char === "\n") return start + 1;
+		if (char === "\\") index += 2;
+		else if (char === "[") {
+			inClass = true;
+			index += 1;
+		} else if (char === "]") {
+			inClass = false;
+			index += 1;
+		} else if (char === "/" && !inClass) {
+			index += 1;
+			while (index < block.length && /[a-z]/.test(block[index])) index += 1;
+			return index;
+		} else index += 1;
+	}
+	return start + 1;
+}
+function endOfString(block, start, quote) {
+	let index = start + 1;
+	while (index < block.length) {
+		let char = block[index];
+		if (char === "\\") index += 2;
+		else if (char === quote) return index + 1;
+		else index += 1;
+	}
+	return block.length;
+}
+function isWordStart(char) {
+	return /[A-Za-z_$]/.test(char);
+}
+function isWordPart(char) {
+	return /[\w$]/.test(char);
+}
+/**
+* A bundler compiles the document to a module, where `import.meta` is
+* ordinary. Here the body is a function body, so the engine refuses it with
+* `SyntaxError: Cannot use 'import.meta' outside a module` thrown from source
+* the author never wrote, naming neither the document nor the reason.
+*/
+function importMeta(where) {
+	return /* @__PURE__ */ new Error(`"${where}" uses \`import.meta\`, which cannot be evaluated outside a bundler: the document is compiled to a function body rather than a module. Add contentLayer() from @pitlane/content/vite so the build compiles this collection.`);
+}
+/**
+* A local name becomes a parameter of the function the compiled body is
+* evaluated as, so anything that is not an identifier has to be refused here
+* rather than producing a syntax error in generated source.
+*/
+function identifier(name, statement, where) {
+	if (!/^[A-Za-z_$][\w$]*$/.test(name)) throw unreadable(statement, where);
+	return name;
+}
+/**
+* Sätteri compiles `import * as ui from "./x.tsx"` to `const {} = arguments[0]`
+* in `function-body` mode: the local name is never bound, so the document
+* throws `ReferenceError: ui is not defined` from inside compiled source the
+* author never wrote. Refused here, where the file and the statement are both
+* still in hand. A bundler compiles the same document to a module, where the
+* namespace import is ordinary and works.
+*/
+function namespaceImport(local, statement, where) {
+	return /* @__PURE__ */ new Error(`"${where}" imports \`* as ${local}\` in \`${statement}\`, which cannot be resolved outside a bundler. Import the components by name instead, or add contentLayer() from @pitlane/content/vite so the build compiles this collection.`);
+}
+function unreadable(statement, where) {
+	return /* @__PURE__ */ new Error(`Could not read the import \`${statement}\` in "${where}". Rendering an MDX entry outside a bundler resolves its imports directly, which needs an ordinary import statement.`);
+}
+//#endregion
+export { readEsm };

package/dist/parse-DoKe2tNa.mjs

@@ -0,0 +1,57 @@
+//#region src/parse.ts
+/**
+* An error already framed with the collection that produced it.
+*
+* The marker is a type rather than a substring of the message: matching on
+* wording couples every thrower to `annotate`'s idea of what a framed message
+* looks like, and rewording one of them would double-wrap or skip silently.
+*/
+var ContentError = class extends Error {
+	collection;
+	constructor(collection, message, options) {
+		super(message, options);
+		this.name = "ContentError";
+		this.collection = collection;
+	}
+};
+/**
+* Validates one entry's data against its collection's schema.
+*
+* The thrown message names everything needed to find the file and fix it: the
+* entry, the collection, the path when there is one, and one line per issue.
+* This is the earliest point the data exists, so it is the earliest point the
+* mistake can be reported.
+*/
+async function parseEntryData(schema, target, data) {
+	let result = await schema["~standard"].validate(data);
+	if (result.issues) throw new ContentError(target.collection, parseFailure(target, result.issues));
+	return result.value;
+}
+function parseFailure(target, issues) {
+	let where = target.filePath ? ` (${target.filePath})` : "";
+	let lines = issues.map((issue) => `  - ${issuePath(issue)}${issue.message}`);
+	return [`Failed to parse entry "${target.id}" in collection "${target.collection}"${where}:`, ...lines].join("\n");
+}
+function issuePath(issue) {
+	if (!issue.path || issue.path.length === 0) return "";
+	return `${issue.path.map((segment) => typeof segment === "object" ? String(segment.key) : String(segment)).join(".")}: `;
+}
+/**
+* Frames the one import failure `render()` can produce on its own.
+*
+* The renderer is loaded on demand so that reading a collection needs no
+* framework, which means an application that never renders never installs
+* one. When it does render, Node reports a resolver path and a specifier and
+* nothing about content. Anything else that fails while the renderer loads is
+* left alone, so a real error inside it is not disguised as a missing install.
+*
+* @param where The entry being rendered, for the message.
+* @param cause The failure the dynamic import threw.
+* @returns A framed error, or `undefined` when this was some other failure.
+*/
+function missingRenderer(where, cause) {
+	if (!(cause instanceof Error && cause.code === "ERR_MODULE_NOT_FOUND" && /'remix(?:\/[^']*)?'/.test(cause.message))) return void 0;
+	return new Error(`Rendering "${where}" needs the peer dependency "remix"; install it, or read the entry's data without calling render().`, { cause });
+}
+//#endregion
+export { missingRenderer as n, parseEntryData as r, ContentError as t };

package/dist/prebuild.d.mts

@@ -0,0 +1,65 @@
+import { g as PrebuiltCollections } from "./types-xSR1WTBq.mjs";
+//#region src/prebuild.d.ts
+/**
+ * The channel between `contentLayer()` and `createContent`.
+ *
+ * The plugin runs the application's content module through Vite's module
+ * runner, which evaluates it in a realm of its own. A module-scoped variable
+ * would therefore be a different variable on each side, so the handshake lives
+ * on globals whose names `symbols.ts` owns.
+ */
+interface Channel {
+  collections: Map<string, unknown[]>;
+  watched: Set<string>;
+  /** Collections whose loader configured runtime rendering options. */
+  configuredSatteri: Set<string>;
+  tasks: (() => Promise<void>)[];
+  root: string;
+}
+/** Opens prebuild mode. Called by `contentLayer()` before it runs the entry. */
+declare function openPrebuild(root: string): Channel;
+/** Closes prebuild mode, so a later `createContent` in this process is normal. */
+declare function closePrebuild(): void;
+/** Whether a build is collecting declarations and prebuilding their entries. */
+declare function isPrebuilding(): boolean;
+/**
+ * The root loaders resolve relative paths against.
+ *
+ * A prebuilt collection never asks, so the fallback only runs where a loader
+ * is about to read the filesystem anyway. `process` is reached defensively all
+ * the same: a host without it should hear about the missing filesystem from
+ * the loader, which names the collection, rather than about a missing global.
+ */
+declare function contentRoot(): string;
+/** Defers loading until the plugin finishes evaluating the declaration module. */
+declare function registerPrebuild(populate: () => Promise<void>): void;
+/** Records one collection's entries for `contentLayer()` to read back. */
+declare function recordPrebuilt(collection: string, entries: unknown[]): void;
+/**
+ * Records the paths a loader says it reads, so `contentLayer()` can watch them.
+ *
+ * This comes from the loader rather than from the entries it produced: a
+ * collection that currently matches nothing has no file paths to infer from,
+ * and it is exactly the collection whose first file needs to be noticed.
+ */
+declare function recordWatched(paths: readonly string[]): void;
+/**
+ * Records that a prebuilt collection's loader configured `options.satteri`.
+ *
+ * Those options only take effect when the collection renders at runtime, so a
+ * prebuilt collection carrying them has a plugin list that silently applies on
+ * some hosts and not others. `contentLayer()` warns rather than let that pass.
+ */
+declare function recordConfiguredSatteri(collection: string): void;
+/**
+ * The manifest `contentLayer()` emitted, or `null` when nothing prebuilt anything.
+ *
+ * A prebuild reads no manifest, because it is producing one. Without that rule
+ * a process that has already imported a prebuilt bundle — two builds in one
+ * test run, a build after a preview — would hand the next prebuild the previous
+ * manifest, the loaders would look as though they had already run, and the
+ * collection would be emitted empty.
+ */
+declare function prebuiltManifest(): PrebuiltCollections | null;
+//#endregion
+export { closePrebuild, contentRoot, isPrebuilding, openPrebuild, prebuiltManifest, recordConfiguredSatteri, recordPrebuilt, recordWatched, registerPrebuild };

package/dist/prebuild.mjs

@@ -0,0 +1,81 @@
+import { n as PREBUILD_CHANNEL, r as PREBUILT_MANIFEST } from "./symbols-DmXlrDbX.mjs";
+import "./manifest.mjs";
+//#region src/prebuild.ts
+/** Opens prebuild mode. Called by `contentLayer()` before it runs the entry. */
+function openPrebuild(root) {
+	let channel = {
+		collections: /* @__PURE__ */ new Map(),
+		watched: /* @__PURE__ */ new Set(),
+		configuredSatteri: /* @__PURE__ */ new Set(),
+		tasks: [],
+		root
+	};
+	globalThis[PREBUILD_CHANNEL] = channel;
+	return channel;
+}
+/** Closes prebuild mode, so a later `createContent` in this process is normal. */
+function closePrebuild() {
+	delete globalThis[PREBUILD_CHANNEL];
+}
+/** Whether a build is collecting declarations and prebuilding their entries. */
+function isPrebuilding() {
+	return globalThis[PREBUILD_CHANNEL] !== void 0;
+}
+/**
+* The root loaders resolve relative paths against.
+*
+* A prebuilt collection never asks, so the fallback only runs where a loader
+* is about to read the filesystem anyway. `process` is reached defensively all
+* the same: a host without it should hear about the missing filesystem from
+* the loader, which names the collection, rather than about a missing global.
+*/
+function contentRoot() {
+	let root = globalThis[PREBUILD_CHANNEL]?.root;
+	if (root !== void 0) return root;
+	return typeof process === "undefined" ? "/" : process.cwd();
+}
+/** Defers loading until the plugin finishes evaluating the declaration module. */
+function registerPrebuild(populate) {
+	globalThis[PREBUILD_CHANNEL]?.tasks.push(populate);
+}
+/** Records one collection's entries for `contentLayer()` to read back. */
+function recordPrebuilt(collection, entries) {
+	globalThis[PREBUILD_CHANNEL]?.collections.set(collection, entries);
+}
+/**
+* Records the paths a loader says it reads, so `contentLayer()` can watch them.
+*
+* This comes from the loader rather than from the entries it produced: a
+* collection that currently matches nothing has no file paths to infer from,
+* and it is exactly the collection whose first file needs to be noticed.
+*/
+function recordWatched(paths) {
+	let channel = globalThis[PREBUILD_CHANNEL];
+	if (!channel) return;
+	for (let path of paths) channel.watched.add(path);
+}
+/**
+* Records that a prebuilt collection's loader configured `options.satteri`.
+*
+* Those options only take effect when the collection renders at runtime, so a
+* prebuilt collection carrying them has a plugin list that silently applies on
+* some hosts and not others. `contentLayer()` warns rather than let that pass.
+*/
+function recordConfiguredSatteri(collection) {
+	globalThis[PREBUILD_CHANNEL]?.configuredSatteri.add(collection);
+}
+/**
+* The manifest `contentLayer()` emitted, or `null` when nothing prebuilt anything.
+*
+* A prebuild reads no manifest, because it is producing one. Without that rule
+* a process that has already imported a prebuilt bundle — two builds in one
+* test run, a build after a preview — would hand the next prebuild the previous
+* manifest, the loaders would look as though they had already run, and the
+* collection would be emitted empty.
+*/
+function prebuiltManifest() {
+	if (isPrebuilding()) return null;
+	return globalThis[PREBUILT_MANIFEST] ?? null;
+}
+//#endregion
+export { closePrebuild, contentRoot, isPrebuilding, openPrebuild, prebuiltManifest, recordConfiguredSatteri, recordPrebuilt, recordWatched, registerPrebuild };