@pagesmith/core 0.1.0

package/dist/content-config-fHPaFZ7i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-config-fHPaFZ7i.d.mts","names":["Data","Point","line","column","offset","Position","start","end","Literal","Node","value","type","data","position","Parent","children","Data","UnistData","Literal","UnistLiteral","Node","UnistNode","Parent","UnistParent","AlignType","ReferenceType","Alternative","alt","Association","identifier","label","Reference","referenceType","Resource","url","title","BlockContent","BlockContentMap","Blockquote","Code","Heading","Html","List","Paragraph","Table","ThematicBreak","blockquote","code","heading","html","list","paragraph","table","thematicBreak","DefinitionContent","DefinitionContentMap","Definition","FootnoteDefinition","definition","footnoteDefinition","FrontmatterContent","FrontmatterContentMap","Yaml","yaml","ListContent","ListContentMap","ListItem","listItem","PhrasingContent","PhrasingContentMap","Break","Delete","Emphasis","FootnoteReference","Image","ImageReference","InlineCode","Link","LinkReference","Strong","Text","break","delete","emphasis","footnoteReference","image","imageReference","inlineCode","link","linkReference","strong","text","RootContent","RootContentMap","TableCell","TableRow","tableCell","tableRow","RowContent","RowContentMap","TableContent","TableContentMap","Content","Literals","Nodes","Extract","Root","Parents","TopLevelContent","value","data","children","Array","BlockquoteData","type","BreakData","CodeData","lang","meta","DefinitionData","DeleteData","EmphasisData","FootnoteDefinitionData","FootnoteReferenceData","HeadingData","depth","HtmlData","HTML","ImageData","ImageReferenceData","InlineCodeData","LinkData","LinkReferenceData","ListData","ordered","start","spread","ListItemData","checked","ParagraphData","RootData","StrongData","TableData","align","TableRowData","TableCellData","TextData","ThematicBreakData","YamlData","YAML"],"sources":["../../../node_modules/@types/unist/index.d.ts","../../../node_modules/@types/mdast/index.d.ts","../src/validation/schema-validator.ts","../src/validation/types.ts","../src/schemas/collection.ts","../src/schemas/content-config.ts"],"x_google_ignoreList":[0,1],"mappings":"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"}

package/dist/content-layer-B7fQ3im4.mjs

@@ -0,0 +1,590 @@
+import { t as processMarkdown } from "./markdown-Cj5X26FL.mjs";
+import { n as resolveLoader, t as defaultIncludePatterns } from "./loaders-DyABmDrE.mjs";
+import { dirname, extname, relative, resolve } from "path";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { existsSync } from "fs";
+import fg from "fast-glob";
+//#region src/utils/read-time.ts
+/**
+* Read time estimation.
+*
+* Computes estimated reading time from markdown source (~200 words per minute).
+*/
+/** Compute read time in minutes from raw markdown. */
+function computeReadTime(rawMarkdown) {
+	const wordCount = rawMarkdown.replace(/```[\s\S]*?```/g, " ").replace(/^( {4}|\t).+$/gm, " ").replace(/^---[\s\S]*?---/m, " ").replace(/<[^>]+>/g, " ").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[#*_~`>]/g, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean).length;
+	return Math.max(1, Math.ceil(wordCount / 200));
+}
+//#endregion
+//#region src/entry.ts
+var ContentEntry = class {
+	/** URL-friendly identifier */
+	slug;
+	/** Collection this entry belongs to */
+	collection;
+	/** Absolute path to source file */
+	filePath;
+	/** Validated data (frontmatter or parsed data) */
+	data;
+	/** Raw body content (markdown only) */
+	rawContent;
+	/** Cached render result */
+	_rendered;
+	/** Markdown config for rendering */
+	_markdownConfig;
+	constructor(slug, collection, filePath, data, rawContent, markdownConfig) {
+		this.slug = slug;
+		this.collection = collection;
+		this.filePath = filePath;
+		this.data = data;
+		this.rawContent = rawContent;
+		this._markdownConfig = markdownConfig;
+	}
+	/** Render the entry content to HTML. Cached after first call. */
+	async render(options) {
+		if (this._rendered && !options?.force) return this._rendered;
+		if (!this.rawContent) {
+			this._rendered = {
+				html: "",
+				headings: [],
+				readTime: 0
+			};
+			return this._rendered;
+		}
+		const result = await processMarkdown(this.rawContent, this._markdownConfig, {
+			content: this.rawContent,
+			frontmatter: this.data
+		});
+		const readTime = computeReadTime(this.rawContent);
+		this._rendered = {
+			html: result.html,
+			headings: result.headings,
+			readTime
+		};
+		return this._rendered;
+	}
+	/** Clear cached render result. */
+	clearRenderCache() {
+		this._rendered = void 0;
+	}
+};
+//#endregion
+//#region src/plugins/index.ts
+/** Collect all remark plugins from content plugins. */
+function collectRemarkPlugins(plugins) {
+	return plugins.filter((p) => p.remarkPlugin).map((p) => p.remarkPlugin);
+}
+/** Collect all rehype plugins from content plugins. */
+function collectRehypePlugins(plugins) {
+	return plugins.filter((p) => p.rehypePlugin).map((p) => p.rehypePlugin);
+}
+/** Run all plugin validators against an entry. */
+function runPluginValidators(plugins, entry) {
+	const issues = [];
+	for (const plugin of plugins) if (plugin.validate) issues.push(...plugin.validate(entry));
+	return issues;
+}
+//#endregion
+//#region src/utils/glob.ts
+/**
+* File discovery via glob patterns.
+*/
+/** Discover files matching glob patterns in a directory. */
+function discoverFiles(options) {
+	const { directory, include, exclude = [] } = options;
+	return fg.sync(include, {
+		cwd: directory,
+		absolute: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/dev/**",
+			...exclude
+		]
+	}).map((p) => resolve(p));
+}
+//#endregion
+//#region src/utils/slug.ts
+/**
+* Path-to-slug conversion.
+*
+* Generalized from packages/core/src/content/collector.ts.
+*/
+/**
+* Convert a content file path to a URL-friendly slug.
+*
+* Examples:
+*   content/posts/hello-world/README.md  ->  'hello-world'
+*   content/posts/hello-world/index.md   ->  'hello-world'
+*   content/posts/hello-world.md         ->  'hello-world'
+*   content/authors/john.json            ->  'john'
+*   content/posts/nested/deep/post.md    ->  'nested/deep/post'
+*/
+function toSlug(filePath, directory) {
+	const ext = extname(filePath);
+	let slug = relative(directory, filePath).replace(/\\/g, "/");
+	if (ext) slug = slug.slice(0, -ext.length);
+	if (slug === "README" || slug === "index") return "/";
+	if (slug.endsWith("/README")) slug = slug.slice(0, -7);
+	if (slug.endsWith("/index")) slug = slug.slice(0, -6);
+	return slug;
+}
+//#endregion
+//#region src/validation/schema-validator.ts
+/** Format a Zod error path into a human-readable field path. */
+function formatPath(path) {
+	return path.map((segment, i) => {
+		if (typeof segment === "number") return `[${segment}]`;
+		if (typeof segment === "symbol") return `[${String(segment)}]`;
+		if (i === 0) return segment;
+		return `.${segment}`;
+	}).join("");
+}
+/** Validate data against a Zod schema and return structured issues. */
+function validateSchema(data, schema) {
+	const result = schema.safeParse(data);
+	if (result.success) return {
+		issues: [],
+		validatedData: result.data
+	};
+	return {
+		issues: result.error.issues.map((issue) => ({
+			field: issue.path.length > 0 ? formatPath(issue.path) : void 0,
+			message: issue.message,
+			severity: "error"
+		})),
+		validatedData: data
+	};
+}
+//#endregion
+//#region src/validation/code-block-validator.ts
+/** Known meta properties accepted by Expressive Code and its plugins. */
+const KNOWN_META_PROPS = new Set([
+	"title",
+	"showLineNumbers",
+	"startLineNumber",
+	"wrap",
+	"frame",
+	"collapse",
+	"mark",
+	"ins",
+	"del"
+]);
+/** Extract the property name portion of a meta token (before `=` or `{`). */
+function extractMetaPropNames(meta) {
+	const props = [];
+	const tokenRegex = /(\w+)(?:=(?:\{[^}]*\}|"[^"]*"|'[^']*'|\S+))?/g;
+	let match;
+	while ((match = tokenRegex.exec(meta)) !== null) props.push(match[1]);
+	return props;
+}
+/** Collect all `code` nodes from MDAST. */
+function collectCodeBlocks(node) {
+	const blocks = [];
+	if (node.type === "code") blocks.push(node);
+	if (node.children) for (const child of node.children) blocks.push(...collectCodeBlocks(child));
+	return blocks;
+}
+const codeBlockValidator = {
+	name: "code-blocks",
+	validate(ctx) {
+		if (!ctx.rawContent || !ctx.mdast) return [];
+		const issues = [];
+		const tree = ctx.mdast;
+		const codeBlocks = collectCodeBlocks(tree);
+		for (const block of codeBlocks) {
+			const line = block.position?.start.line;
+			const lineInfo = line ? ` (line ${line})` : "";
+			const meta = block.meta ?? "";
+			const hasMeta = meta.trim().length > 0;
+			if (hasMeta && !block.lang) issues.push({
+				field: `code-block${lineInfo}`,
+				message: "Code block has meta properties but no language identifier",
+				severity: "warn"
+			});
+			if (!hasMeta) continue;
+			const propNames = extractMetaPropNames(meta);
+			for (const prop of propNames) if (!KNOWN_META_PROPS.has(prop)) issues.push({
+				field: `code-block${lineInfo}`,
+				message: `Unknown code block meta property: "${prop}"`,
+				severity: "warn"
+			});
+		}
+		return issues;
+	}
+};
+//#endregion
+//#region src/validation/heading-validator.ts
+/** Extract plain text from a heading node's children. */
+function getTextContent(node) {
+	if (node.type === "text") return node.value ?? "";
+	if (node.children) return node.children.map(getTextContent).join("");
+	return "";
+}
+/** Collect all heading nodes from MDAST. */
+function collectHeadings(node) {
+	const headings = [];
+	if (node.type === "heading" && node.depth) headings.push({
+		depth: node.depth,
+		text: getTextContent(node),
+		line: node.position?.start.line
+	});
+	if (node.children) for (const child of node.children) headings.push(...collectHeadings(child));
+	return headings;
+}
+const headingValidator = {
+	name: "headings",
+	validate(ctx) {
+		if (!ctx.rawContent || !ctx.mdast) return [];
+		const issues = [];
+		const tree = ctx.mdast;
+		const headings = collectHeadings(tree);
+		if (headings.length === 0) {
+			if (ctx.rawContent.trim().length > 0) issues.push({
+				message: "Document has content but no headings",
+				severity: "warn"
+			});
+			return issues;
+		}
+		const h1s = headings.filter((h) => h.depth === 1);
+		if (h1s.length > 1) for (const h of h1s.slice(1)) {
+			const lineInfo = h.line ? ` (line ${h.line})` : "";
+			issues.push({
+				field: `headings${lineInfo}`,
+				message: `Multiple h1 headings found: "${h.text}"`,
+				severity: "warn"
+			});
+		}
+		for (let i = 1; i < headings.length; i++) {
+			const prev = headings[i - 1];
+			const curr = headings[i];
+			if (curr.depth > prev.depth + 1) {
+				const lineInfo = curr.line ? ` (line ${curr.line})` : "";
+				issues.push({
+					field: `headings${lineInfo}`,
+					message: `Heading level skip: h${prev.depth} -> h${curr.depth} ("${curr.text}")`,
+					severity: "warn"
+				});
+			}
+		}
+		return issues;
+	}
+};
+//#endregion
+//#region src/validation/link-validator.ts
+/**
+* Link validator — checks links in markdown content.
+*
+* Walks the shared MDAST for link/image nodes. Internal links are checked for file existence;
+* external links are checked for well-formed URL format.
+*/
+/** Walk MDAST tree, collecting link and image nodes. */
+function collectLinks(node) {
+	const links = [];
+	if ((node.type === "link" || node.type === "image") && node.url) links.push({
+		url: node.url,
+		line: node.position?.start.line
+	});
+	if (node.children) for (const child of node.children) links.push(...collectLinks(child));
+	return links;
+}
+function isInternalLink(url) {
+	if (url.startsWith("#")) return false;
+	if (url.startsWith("http://") || url.startsWith("https://")) return false;
+	if (url.startsWith("//")) return false;
+	if (url.startsWith("mailto:")) return false;
+	if (url.startsWith("tel:")) return false;
+	return true;
+}
+function isWellFormedUrl(url) {
+	try {
+		new URL(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const linkValidator = {
+	name: "links",
+	validate(ctx) {
+		if (!ctx.rawContent || !ctx.mdast) return [];
+		const issues = [];
+		const tree = ctx.mdast;
+		const links = collectLinks(tree);
+		const fileDir = dirname(ctx.filePath);
+		for (const link of links) {
+			const lineInfo = link.line ? ` (line ${link.line})` : "";
+			if (link.url.startsWith("http://") || link.url.startsWith("https://")) {
+				if (!isWellFormedUrl(link.url)) issues.push({
+					field: `links${lineInfo}`,
+					message: `Malformed external URL: ${link.url}`,
+					severity: "warn"
+				});
+				continue;
+			}
+			if (isInternalLink(link.url)) {
+				const urlPath = link.url.split("#")[0].split("?")[0];
+				if (!urlPath) continue;
+				if (!existsSync(resolve(fileDir, urlPath))) issues.push({
+					field: `links${lineInfo}`,
+					message: `Broken internal link: ${link.url}`,
+					severity: "error"
+				});
+			}
+		}
+		return issues;
+	}
+};
+//#endregion
+//#region src/validation/runner.ts
+/**
+* Validation runner — executes a list of content validators on an entry.
+*
+* Validators that throw are caught and converted to error-severity issues
+* so one failing validator does not block the rest.
+*/
+/** The built-in validators for markdown content. */
+const builtinMarkdownValidators = [
+	linkValidator,
+	codeBlockValidator,
+	headingValidator
+];
+/** Run all validators on a single content entry. */
+async function runValidators(ctx, validators) {
+	if (ctx.rawContent && !ctx.mdast) ctx.mdast = unified().use(remarkParse).parse(ctx.rawContent);
+	const issues = [];
+	for (const validator of validators) try {
+		const result = await validator.validate(ctx);
+		issues.push(...result);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		issues.push({
+			message: `Validator "${validator.name}" threw: ${message}`,
+			severity: "error"
+		});
+	}
+	return issues;
+}
+//#endregion
+//#region src/store.ts
+/**
+* ContentStore — in-memory cache for loaded collections.
+*
+* Handles file discovery, loading, validation, and caching.
+* Not exported directly — used internally by ContentLayer.
+*/
+var ContentStore = class {
+	cache = /* @__PURE__ */ new Map();
+	loaded = /* @__PURE__ */ new Set();
+	config;
+	rootDir;
+	markdownConfig;
+	constructor(config) {
+		this.config = config;
+		this.rootDir = config.root ? resolve(config.root) : process.cwd();
+		this.markdownConfig = this.createMarkdownConfig();
+	}
+	/** Load a collection (if not already loaded) and return entries. */
+	async loadCollection(name, def) {
+		if (this.loaded.has(name)) {
+			const cached = this.cache.get(name);
+			return cached ? Array.from(cached.values()).map((c) => c.entry) : [];
+		}
+		const loader = resolveLoader(def.loader);
+		const directory = resolve(this.rootDir, def.directory);
+		const files = discoverFiles({
+			directory,
+			include: def.include ?? defaultIncludePatterns(loader),
+			exclude: def.exclude
+		});
+		const entries = /* @__PURE__ */ new Map();
+		const results = await Promise.all(files.map(async (filePath) => {
+			try {
+				return await this.loadEntry(name, filePath, directory, loader, def);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					entry: new ContentEntry(def.slugify ? def.slugify(filePath, directory) : toSlug(filePath, directory), name, filePath, {}, void 0, this.markdownConfig),
+					issues: [{
+						message: `Failed to load: ${message}`,
+						severity: "error"
+					}]
+				};
+			}
+		}));
+		for (const result of results) if (result) entries.set(result.entry.slug, result);
+		this.cache.set(name, entries);
+		this.loaded.add(name);
+		return Array.from(entries.values()).map((c) => c.entry);
+	}
+	/** Load a single entry from a file. */
+	async loadEntry(collectionName, filePath, directory, loader, def) {
+		const loaded = await loader.load(filePath);
+		const slug = def.slugify ? def.slugify(filePath, directory) : toSlug(filePath, directory);
+		let raw = {
+			data: loaded.data,
+			content: loaded.content,
+			filePath,
+			slug
+		};
+		if (def.transform) raw = await def.transform(raw);
+		if (def.computed) for (const [key, fn] of Object.entries(def.computed)) raw.data[key] = fn(raw);
+		if (def.filter && !def.filter(raw)) return null;
+		const { issues, validatedData } = validateSchema(raw.data, def.schema);
+		if (def.validate) {
+			const customError = def.validate(raw);
+			if (customError) issues.push({
+				message: customError,
+				severity: "error"
+			});
+		}
+		if (raw.content !== void 0) {
+			const validators = this.resolveValidators(def);
+			if (validators.length > 0) {
+				const contentIssues = await runValidators({
+					filePath,
+					slug,
+					collection: collectionName,
+					rawContent: raw.content,
+					data: raw.data
+				}, validators);
+				issues.push(...contentIssues);
+			}
+		}
+		if (this.config.plugins?.length) {
+			const pluginIssues = runPluginValidators(this.config.plugins, {
+				data: raw.data,
+				content: raw.content
+			});
+			for (const message of pluginIssues) issues.push({
+				message,
+				severity: "error"
+			});
+		}
+		return {
+			entry: new ContentEntry(slug, collectionName, filePath, validatedData, raw.content, this.markdownConfig),
+			issues
+		};
+	}
+	/** Get a single entry by slug. */
+	getEntry(collection, slug) {
+		return this.cache.get(collection)?.get(slug)?.entry;
+	}
+	/** Get validation issues for a collection. */
+	getIssues(collection) {
+		const result = /* @__PURE__ */ new Map();
+		const entries = this.cache.get(collection);
+		if (!entries) return result;
+		for (const [slug, cached] of entries) if (cached.issues.length > 0) result.set(slug, cached.issues);
+		return result;
+	}
+	/** Invalidate a single entry (forces full collection reload on next access). */
+	invalidate(collection, slug) {
+		this.cache.get(collection)?.delete(slug);
+		this.loaded.delete(collection);
+	}
+	/** Invalidate an entire collection. */
+	invalidateCollection(collection) {
+		this.cache.delete(collection);
+		this.loaded.delete(collection);
+	}
+	/** Invalidate all collections. */
+	invalidateAll() {
+		this.cache.clear();
+		this.loaded.clear();
+	}
+	/** Resolve the list of content validators for a collection. */
+	resolveValidators(def) {
+		const builtin = def.disableBuiltinValidators ? [] : builtinMarkdownValidators;
+		const custom = def.validators ?? [];
+		return [...builtin, ...custom];
+	}
+	createMarkdownConfig() {
+		const base = this.config.markdown ?? {};
+		const remarkPlugins = [...base.remarkPlugins ?? []];
+		const rehypePlugins = [...base.rehypePlugins ?? []];
+		const plugins = this.config.plugins ?? [];
+		if (plugins.length > 0) {
+			remarkPlugins.push(...collectRemarkPlugins(plugins));
+			rehypePlugins.push(...collectRehypePlugins(plugins));
+		}
+		return {
+			...base,
+			...remarkPlugins.length > 0 ? { remarkPlugins } : {},
+			...rehypePlugins.length > 0 ? { rehypePlugins } : {}
+		};
+	}
+};
+//#endregion
+//#region src/content-layer.ts
+var ContentLayerImpl = class {
+	store;
+	config;
+	constructor(config) {
+		this.config = config;
+		this.store = new ContentStore(config);
+	}
+	async getCollection(name) {
+		const def = this.config.collections[name];
+		if (!def) throw new Error(`Collection "${name}" not found. Available: ${Object.keys(this.config.collections).join(", ")}`);
+		return this.store.loadCollection(name, def);
+	}
+	async getEntry(collection, slug) {
+		await this.getCollection(collection);
+		return this.store.getEntry(collection, slug);
+	}
+	async convert(markdown, options) {
+		const { convert: coreConvert } = await import("./convert-DnuB6SVV.mjs").then((n) => n.n);
+		return coreConvert(markdown, { markdown: options?.markdown ?? this.config.markdown });
+	}
+	invalidate(collection, slug) {
+		this.store.invalidate(collection, slug);
+	}
+	invalidateCollection(collection) {
+		this.store.invalidateCollection(collection);
+	}
+	invalidateAll() {
+		this.store.invalidateAll();
+	}
+	async validate(collection) {
+		const names = collection ? [collection] : Object.keys(this.config.collections);
+		const results = [];
+		for (const name of names) {
+			await this.getCollection(name);
+			const issues = this.store.getIssues(name);
+			const entries = Array.from(issues.entries()).map(([slug, entryIssues]) => {
+				return {
+					slug,
+					filePath: this.store.getEntry(name, slug)?.filePath ?? "",
+					issues: entryIssues
+				};
+			});
+			let errors = 0;
+			let warnings = 0;
+			for (const entry of entries) for (const issue of entry.issues) if (issue.severity === "error") errors++;
+			else warnings++;
+			results.push({
+				collection: name,
+				entries,
+				errors,
+				warnings
+			});
+		}
+		return results;
+	}
+	getCollectionNames() {
+		return Object.keys(this.config.collections);
+	}
+	getCollectionDef(name) {
+		return this.config.collections[name];
+	}
+};
+/** Create a new content layer from a configuration. */
+function createContentLayer(config) {
+	return new ContentLayerImpl(config);
+}
+//#endregion
+export { headingValidator as a, ContentEntry as c, linkValidator as i, builtinMarkdownValidators as n, codeBlockValidator as o, runValidators as r, toSlug as s, createContentLayer as t };
+
+//# sourceMappingURL=content-layer-B7fQ3im4.mjs.map