forgepress 0.0.0 → 0.0.2

package/dist/_chunks/content.mjs

@@ -0,0 +1,733 @@
+import { ENTRY_STATUSES, META_KEYS, compilePattern, fieldTypeNames, fieldTypes, isRecord, isTranslated, quote } from "./value.mjs";
+import { entryKey, validateReferences } from "./references.mjs";
+import { isCollectionName, isEntryFile, isEntryId, sortByCreation, toEntryFile, toEntryId, toEntryRef } from "./media.mjs";
+const LOCALE_CODE = /^[a-z][\w-]*$/i;
+const RESERVED_FIELDS = META_KEYS;
+const SCHEMA_KEYS = /* @__PURE__ */ new Set(["collections", "locales"]);
+const COLLECTION_KEYS = /* @__PURE__ */ new Set([
+	"label",
+	"description",
+	"fields"
+]);
+const BASE_OPTIONS = {
+	label: "text",
+	description: "text",
+	optional: "boolean",
+	translate: "boolean"
+};
+const INDEXABLE = fieldTypeNames.filter((type) => "index" in fieldTypes[type].options);
+const KINDS = {
+	text: "a string",
+	number: "a number",
+	boolean: "true or false",
+	collection: "a collection name",
+	collections: "a list of collection names"
+};
+function isFieldType(type) {
+	return typeof type === "string" && fieldTypeNames.includes(type);
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function fits(kind, value) {
+	if (kind === "number") return finite(value);
+	if (kind === "boolean") return typeof value === "boolean";
+	if (kind === "collections") return Array.isArray(value) && value.every((item) => typeof item === "string");
+	return typeof value === "string";
+}
+function optionKinds(type) {
+	const options = Object.entries(fieldTypes[type].options).map(([option, spec]) => [option, spec.type]);
+	return {
+		...BASE_OPTIONS,
+		...Object.fromEntries(options)
+	};
+}
+function checkLocales(report, locales) {
+	if (locales === void 0) return [];
+	if (!Array.isArray(locales)) {
+		report(["locales"], "\"locales\" has to be a list of locale codes");
+		return [];
+	}
+	locales.forEach((locale, index) => {
+		if (typeof locale !== "string" || !LOCALE_CODE.test(locale)) report(["locales", index], `${quote(locale)} is not a locale code`);
+		else if (locales.indexOf(locale) < index) report(["locales", index], `Locale ${quote(locale)} is listed twice`);
+	});
+	return locales;
+}
+function checkReferences(context, path, label, targets, listed) {
+	targets.forEach((target, index) => {
+		const at = listed ? [...path, index] : path;
+		if (!context.collections.has(target)) context.report(at, `Field ${quote(label)} references unknown collection ${quote(target)}`);
+		else if (targets.indexOf(target) < index) context.report(at, `Field ${quote(label)} lists collection ${quote(target)} twice`);
+	});
+}
+function checkOption(context, path, label, option, kind, value) {
+	if (!fits(kind, value)) context.report(path, `${quote(option)} of field ${quote(label)} has to be ${KINDS[kind]}`);
+	else if (kind === "collection" || kind === "collections") checkReferences(context, path, label, kind === "collection" ? [value] : value, kind === "collections");
+}
+function checkConstraints(report, path, label, field) {
+	if (field.type === "text" && typeof field.validation === "string") {
+		const pattern = compilePattern(field.validation);
+		if (pattern instanceof SyntaxError) report([...path, "validation"], `"validation" of field ${quote(label)} is not a valid regular expression: ${pattern.message.replace(/^Invalid regular expression: /, "")}`);
+	}
+	if (field.type !== "number") return;
+	if (finite(field.step) && field.step <= 0) report([...path, "step"], `"step" of field ${quote(label)} has to be greater than 0`);
+	if (finite(field.min) && finite(field.max) && field.min > field.max) report([...path, "min"], `"min" of field ${quote(label)} can't be greater than "max"`);
+}
+function checkField(context, path, collection, key, field) {
+	const { report } = context;
+	const label = `${collection}.${key}`;
+	if (RESERVED_FIELDS.includes(key)) report(path, `Field ${quote(label)} uses ${quote(key)}, which is reserved for entry metadata`);
+	if (!isRecord(field)) return report(path, `Field ${quote(label)} has to be an object`);
+	if (field.type === void 0) return report(path, `Field ${quote(label)} needs a type`);
+	if (!isFieldType(field.type)) return report([...path, "type"], `Field ${quote(label)} has unknown type ${quote(field.type)}; use one of ${fieldTypeNames.join(", ")}`);
+	const kinds = optionKinds(field.type);
+	for (const [option, value] of Object.entries(field)) {
+		const kind = kinds[option];
+		if (option === "type") continue;
+		if (kind) checkOption(context, [...path, option], label, option, kind, value);
+		else if (option === "index") report([...path, option], `Field ${quote(label)} can't be indexed; only ${INDEXABLE.slice(0, -1).join(", ")} and ${INDEXABLE.at(-1)} fields can`);
+		else report([...path, option], `Field ${quote(label)} has no option ${quote(option)}`);
+	}
+	for (const [option, spec] of Object.entries(fieldTypes[field.type].options)) if ("required" in spec && field[option] === void 0) report(path, `Field ${quote(label)} needs ${quote(option)}`);
+	checkConstraints(report, path, label, field);
+	if (field.translate === true && context.locales.length === 0) report([...path, "translate"], `Field ${quote(label)} is translated, but the schema has no locales`);
+}
+function checkCollection(context, name, collection) {
+	const { report } = context;
+	const path = ["collections", name];
+	if (!isCollectionName(name)) report(path, `Collection ${quote(name)} has to start with a lowercase letter and contain only letters and digits`);
+	if (!isRecord(collection)) return report(path, `Collection ${quote(name)} has to be an object`);
+	for (const [key, value] of Object.entries(collection)) if (!COLLECTION_KEYS.has(key)) report([...path, key], `Collection ${quote(name)} has no option ${quote(key)}`);
+	else if (key !== "fields" && typeof value !== "string") report([...path, key], `${quote(key)} of collection ${quote(name)} has to be a string`);
+	if (!isRecord(collection.fields)) return report(collection.fields === void 0 ? path : [...path, "fields"], `Collection ${quote(name)} needs "fields" as an object`);
+	for (const [key, field] of Object.entries(collection.fields)) checkField(context, [
+		...path,
+		"fields",
+		key
+	], name, key, field);
+}
+function validateSchema(schema) {
+	const issues = [];
+	const report = (path, message) => issues.push({
+		path,
+		message
+	});
+	if (!isRecord(schema)) {
+		report([], "The schema has to be an object");
+		return issues;
+	}
+	for (const key of Object.keys(schema)) if (!SCHEMA_KEYS.has(key)) report([key], `The schema has no option ${quote(key)}`);
+	const locales = checkLocales(report, schema.locales);
+	if (!isRecord(schema.collections)) {
+		report(schema.collections === void 0 ? [] : ["collections"], "The schema needs \"collections\" as an object");
+		return issues;
+	}
+	const context = {
+		report,
+		collections: new Set(Object.keys(schema.collections)),
+		locales
+	};
+	for (const [name, collection] of Object.entries(schema.collections)) checkCollection(context, name, collection);
+	return issues;
+}
+function formatIssue(issue) {
+	return `${issue.file}:${issue.line}:${issue.column} ${issue.message}`;
+}
+var ContentError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.map((issue) => `[forgepress] ${formatIssue(issue)}`).join("\n"));
+		this.name = "ContentError";
+		this.issues = issues;
+	}
+};
+const ID_START = /[$_\p{ID_Start}]/u;
+const ID_CONTINUE = /[$\u200C\u200D\p{ID_Continue}]/u;
+const SPACE = /\s/;
+const DECIMAL = /\d/;
+const HEX = /[\da-f]/i;
+const OCTAL = /[0-7]/;
+const BINARY = /[01]/;
+const HEX_DIGITS = /^[\da-f]+$/i;
+const RADIX = /[box]/i;
+const BREAKS = /* @__PURE__ */ new Set([
+	"\n",
+	"\r",
+	"\u2028",
+	"\u2029"
+]);
+const TYPE_IMPORT = "Only type imports are allowed, e.g. `import type { ForgePressEntry } from 'forgepress'`";
+const ESCAPES = /* @__PURE__ */ new Map([
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["b", "\b"],
+	["f", "\f"],
+	["v", "\v"]
+]);
+function locationAt(text, offset) {
+	let line = 1;
+	let start = 0;
+	for (let position = 0; position < offset; position += 1) {
+		const char = text[position];
+		if (BREAKS.has(char) && !(char === "\r" && text[position + 1] === "\n")) {
+			line += 1;
+			start = position + 1;
+		}
+	}
+	return {
+		line,
+		column: offset - start + 1
+	};
+}
+function pathKey(path) {
+	return JSON.stringify(path);
+}
+function parseModule(text, file) {
+	const offsets = /* @__PURE__ */ new Map();
+	let index = text.startsWith("") ? 1 : 0;
+	function fail(message, at = index) {
+		throw new ContentError([{
+			file,
+			...locationAt(text, at),
+			message
+		}]);
+	}
+	function char(offset = 0) {
+		return text[index + offset] ?? "";
+	}
+	function skip() {
+		while (index < text.length) if (SPACE.test(char())) index += 1;
+		else if (text.startsWith("//", index)) while (index < text.length && !BREAKS.has(char())) index += 1;
+		else if (text.startsWith("/*", index)) {
+			const end = text.indexOf("*/", index + 2);
+			if (end === -1) fail("Unterminated comment");
+			index = end + 2;
+		} else return;
+	}
+	function width(pattern) {
+		const point = text.codePointAt(index);
+		if (point === void 0 || !pattern.test(String.fromCodePoint(point))) return 0;
+		return point > 65535 ? 2 : 1;
+	}
+	function identifier() {
+		const start = index;
+		for (let step = width(ID_START); step > 0; step = width(ID_CONTINUE)) index += step;
+		return index > start ? text.slice(start, index) : void 0;
+	}
+	function word(expected) {
+		skip();
+		const start = index;
+		if (identifier() === expected) return true;
+		index = start;
+		return false;
+	}
+	function expectWord(expected, message) {
+		if (!word(expected)) fail(message);
+	}
+	function name(message) {
+		skip();
+		return identifier() ?? fail(message);
+	}
+	function list(close, item) {
+		index += 1;
+		for (skip(); char() !== close; skip()) {
+			item();
+			skip();
+			if (char() === ",") index += 1;
+			else if (char() !== close) fail(index < text.length ? `Expected \`,\` or \`${close}\`` : "Unexpected end of file");
+		}
+		index += 1;
+	}
+	function hex(count, start) {
+		const digits = text.slice(index, index + count);
+		if (digits.length < count || !HEX_DIGITS.test(digits)) fail("Invalid escape sequence", start);
+		index += count;
+		return Number.parseInt(digits, 16);
+	}
+	function unicode(start) {
+		if (char() !== "{") return String.fromCharCode(hex(4, start));
+		const end = text.indexOf("}", index);
+		const digits = end === -1 ? "" : text.slice(index + 1, end);
+		if (!HEX_DIGITS.test(digits) || Number.parseInt(digits, 16) > 1114111) fail("Invalid escape sequence", start);
+		index = end + 1;
+		return String.fromCodePoint(Number.parseInt(digits, 16));
+	}
+	function escape(unterminated, opening) {
+		const start = index - 1;
+		const current = char();
+		if (current === "") fail(unterminated, opening);
+		index += 1;
+		const simple = ESCAPES.get(current);
+		if (simple !== void 0) return simple;
+		if (current === "\r" && char() === "\n") index += 1;
+		if (BREAKS.has(current)) return "";
+		if (current === "x") return String.fromCharCode(hex(2, start));
+		if (current === "u") return unicode(start);
+		if (DECIMAL.test(current) && (current !== "0" || DECIMAL.test(char()))) fail(`\`\\${current}\` is not a valid escape sequence`, start);
+		if (current === "0") return "\0";
+		const point = text.codePointAt(start + 1);
+		index = start + 1 + (point > 65535 ? 2 : 1);
+		return String.fromCodePoint(point);
+	}
+	function string(quote) {
+		const start = index;
+		let result = "";
+		let run = index + 1;
+		index = run;
+		while (char() !== quote) {
+			const current = char();
+			if (current === "" || current === "\n" || current === "\r") fail("Unterminated string", start);
+			if (current === "\\") {
+				result += text.slice(run, index);
+				index += 1;
+				result += escape("Unterminated string", start);
+				run = index;
+			} else index += 1;
+		}
+		result += text.slice(run, index);
+		index += 1;
+		return result;
+	}
+	function template() {
+		const start = index;
+		let result = "";
+		let run = index + 1;
+		index = run;
+		while (char() !== "`") {
+			const current = char();
+			if (current === "") fail("Unterminated template literal", start);
+			if (current === "$" && char(1) === "{") fail("Template literals cannot contain substitutions");
+			if (current === "\\" || current === "\r") {
+				result += text.slice(run, index);
+				index += 1;
+				if (current === "\\") result += escape("Unterminated template literal", start);
+				else {
+					result += "\n";
+					if (char() === "\n") index += 1;
+				}
+				run = index;
+			} else index += 1;
+		}
+		result += text.slice(run, index);
+		index += 1;
+		return result;
+	}
+	function digits(pattern, start) {
+		const from = index;
+		while (pattern.test(char()) || char() === "_") {
+			if (char() === "_" && (index === from || !pattern.test(char(1)))) fail("Invalid numeric separator", start);
+			index += 1;
+		}
+		if (index === from) fail("Invalid number", start);
+		return text.slice(from, index).replaceAll("_", "");
+	}
+	function numberStart() {
+		return DECIMAL.test(char()) || char() === "." && DECIMAL.test(char(1));
+	}
+	function number() {
+		const start = index;
+		let source = "";
+		if (char() === "0" && RADIX.test(char(1))) {
+			const radix = char(1).toLowerCase();
+			index += 2;
+			source = `0${radix}${digits(radix === "x" ? HEX : radix === "o" ? OCTAL : BINARY, start)}`;
+		} else {
+			if (char() === "0" && (DECIMAL.test(char(1)) || char(1) === "_")) fail("Numbers cannot start with a leading zero", start);
+			if (char() !== ".") source = digits(DECIMAL, start);
+			if (char() === ".") {
+				index += 1;
+				source += `.${DECIMAL.test(char()) ? digits(DECIMAL, start) : ""}`;
+			}
+			if (char() === "e" || char() === "E") {
+				index += 1;
+				const sign = char() === "+" || char() === "-" ? char() : "";
+				index += sign.length;
+				source += `e${sign}${digits(DECIMAL, start)}`;
+			}
+		}
+		if (char() === "n") fail("BigInt values are not allowed", start);
+		if (DECIMAL.test(char()) || width(ID_START) > 0) fail("Invalid number", start);
+		const value = Number(source);
+		if (!Number.isFinite(value)) fail("Number is out of range", start);
+		return value;
+	}
+	function propertyKey() {
+		const start = index;
+		const current = char();
+		if (current === "[") fail("Computed keys are not allowed");
+		if (text.startsWith("...", index)) fail("Spread syntax is not allowed");
+		const key = current === "'" || current === "\"" ? string(current) : numberStart() ? String(number()) : identifier();
+		if (key === void 0) fail(index < text.length ? "Expected a property name" : "Unexpected end of file");
+		if (key === "__proto__") fail("`__proto__` cannot be used as a key", start);
+		return key;
+	}
+	function object(path) {
+		const result = {};
+		list("}", () => {
+			const start = index;
+			const key = propertyKey();
+			skip();
+			if (char() === "," || char() === "}") fail(`Shorthand properties are not allowed; write \`${key}: value\``, start);
+			if (char() === "(") fail("Methods are not allowed");
+			if (char() !== ":") fail(index < text.length ? `Expected \`:\` after \`${key}\`` : "Unexpected end of file");
+			index += 1;
+			if (Object.hasOwn(result, key)) fail(`Duplicate key \`${key}\``, start);
+			const child = [...path, key];
+			offsets.set(pathKey(child), start);
+			result[key] = literal(child);
+		});
+		return result;
+	}
+	function array(path) {
+		const result = [];
+		list("]", () => {
+			if (char() === ",") fail("Empty array slots are not allowed");
+			const child = [...path, result.length];
+			offsets.set(pathKey(child), index);
+			result.push(literal(child));
+		});
+		return result;
+	}
+	function literal(path) {
+		skip();
+		const start = index;
+		const current = char();
+		if (current === "{") return object(path);
+		if (current === "[") return array(path);
+		if (current === "'" || current === "\"") return string(current);
+		if (current === "`") return template();
+		if (current === "-" || current === "+") {
+			index += 1;
+			skip();
+			if (!numberStart()) fail(`Expected a number after \`${current}\``);
+			return current === "-" ? -number() : number();
+		}
+		if (numberStart()) return number();
+		if (text.startsWith("...", index)) fail("Spread syntax is not allowed");
+		const found = identifier();
+		if (found === "true" || found === "false") return found === "true";
+		if (found === "null" || found === "undefined") fail(`\`${found}\` is not supported; leave the value out instead`, start);
+		if (found === "NaN" || found === "Infinity") fail(`\`${found}\` cannot be stored`, start);
+		if (found !== void 0) fail(`\`${found}\` is not a literal value; variables, calls and expressions are not allowed`, start);
+		return fail(index < text.length ? "Expected a literal value" : "Unexpected end of file");
+	}
+	function typeReference() {
+		word("typeof");
+		name("Expected a type");
+		skip();
+		while (char() === ".") {
+			index += 1;
+			name("Expected a type");
+			skip();
+		}
+		if (char() === "<") list(">", () => {
+			const quote = char();
+			if (quote === "'" || quote === "\"") string(quote);
+			else typeReference();
+		});
+	}
+	function importDeclaration(start) {
+		if (!word("type")) fail(TYPE_IMPORT, start);
+		skip();
+		if (char() === "{") list("}", () => {
+			name("Expected an import name");
+			if (word("as")) name("Expected an import name");
+		});
+		else if (char() === "*") {
+			index += 1;
+			expectWord("as", "Expected `as`");
+			name("Expected an import name");
+		} else if (name("Expected an import clause") === "from") {
+			skip();
+			if (char() === "'" || char() === "\"") fail(TYPE_IMPORT, start);
+		}
+		expectWord("from", "Expected `from`");
+		skip();
+		if (char() !== "'" && char() !== "\"") fail("Expected a module name");
+		string(char());
+	}
+	function exportDefault() {
+		expectWord("default", "Only `export default` is allowed");
+		skip();
+		offsets.set(pathKey([]), index);
+		const value = literal([]);
+		if (word("as")) expectWord("const", "Only `as const` is allowed; use `satisfies` to type the value");
+		if (word("satisfies")) typeReference();
+		return value;
+	}
+	function statements() {
+		let exported = false;
+		let value;
+		for (skip(); index < text.length; skip()) {
+			const start = index;
+			if (char() === ";") {
+				index += 1;
+				continue;
+			}
+			if (exported) fail("Nothing may follow `export default`");
+			const keyword = identifier();
+			if (keyword === "import") importDeclaration(start);
+			else if (keyword === "export") {
+				value = exportDefault();
+				exported = true;
+			} else fail("Only `import type` and `export default` are allowed", start);
+		}
+		if (!exported) fail("Missing `export default`");
+		return value;
+	}
+	return {
+		value: statements(),
+		locate(path) {
+			for (let depth = path.length; depth >= 0; depth -= 1) {
+				const offset = offsets.get(pathKey(path.slice(0, depth)));
+				if (offset !== void 0) return locationAt(text, offset);
+			}
+			return locationAt(text, 0);
+		}
+	};
+}
+function parseFile(file) {
+	try {
+		return parseModule(file.text, file.path);
+	} catch (error) {
+		if (error instanceof ContentError) return error.issues;
+		throw error;
+	}
+}
+function located(file, parsed, issue) {
+	return {
+		file,
+		...parsed.locate(issue.path),
+		message: issue.message
+	};
+}
+function parseSchemaFile(file) {
+	const parsed = parseFile(file);
+	if (!("value" in parsed)) return { issues: [...parsed] };
+	const issues = validateSchema(parsed.value);
+	return issues.length > 0 ? { issues: issues.map((issue) => located(file.path, parsed, issue)) } : { schema: parsed.value };
+}
+function parseSchema(text, file) {
+	const parsed = parseSchemaFile({
+		path: file,
+		text
+	});
+	if ("issues" in parsed) throw new ContentError(parsed.issues);
+	return parsed.schema;
+}
+function parseEntry(text, file) {
+	const { value, locate } = parseModule(text, file);
+	if (!isRecord(value)) throw new ContentError([{
+		file,
+		...locate([]),
+		message: "An entry has to be an object"
+	}]);
+	return value;
+}
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2}))?$/;
+const MEDIA_OPTIONS = {
+	url: ["a string", (value) => typeof value === "string"],
+	alt: ["a string", (value) => typeof value === "string"],
+	width: ["a number", (value) => typeof value === "number"],
+	height: ["a number", (value) => typeof value === "number"]
+};
+const BLOCK_KEYS = /* @__PURE__ */ new Set(["collection", "id"]);
+function isDate(value) {
+	const match = typeof value === "string" ? ISO_DATE.exec(value) : null;
+	if (!match || Number.isNaN(Date.parse(match[0]))) return false;
+	const month = Number(match[2]) - 1;
+	const day = Number(match[3]);
+	const date = new Date(Date.UTC(Number(match[1]), month, day));
+	return date.getUTCMonth() === month && date.getUTCDate() === day;
+}
+function checkMeta(report, entry) {
+	if (entry.id === void 0) report([], "The entry needs an \"id\"");
+	else if (typeof entry.id !== "string" || !isEntryId(entry.id)) report(["id"], "\"id\" has to be a string of letters, digits, \"_\" and \"-\"");
+	if (entry.status === void 0) report([], "The entry needs a \"status\"");
+	else if (!ENTRY_STATUSES.includes(entry.status)) report(["status"], `"status" has to be ${ENTRY_STATUSES.map(quote).join(" or ")}`);
+	for (const key of ["createdAt", "updatedAt"]) if (entry[key] === void 0) report([], `The entry needs ${quote(key)}`);
+	else if (!isDate(entry[key])) report([key], `${quote(key)} has to be an ISO 8601 date such as "2024-01-31T09:30:00Z"`);
+}
+function checkList(report, path, value, message, item) {
+	if (!Array.isArray(value)) return report(path, message);
+	value.forEach((entry, index) => item([...path, index], entry));
+}
+function checkId(report, path, label, collection, value) {
+	if (typeof value !== "string") report(path, `Field ${label} has to hold ids of ${quote(collection)} entries`);
+}
+function checkMedia(report, path, label, value) {
+	if (!isRecord(value)) return report(path, `Field ${label} has to be a media object such as { url: "/uploads/photo.jpg" }`);
+	if (value.url === void 0) report(path, `Field ${label} needs a "url"`);
+	for (const [option, item] of Object.entries(value)) {
+		const spec = MEDIA_OPTIONS[option];
+		if (spec === void 0) report([...path, option], `Field ${label} has no media option ${quote(option)}`);
+		else if (!spec[1](item)) report([...path, option], `${quote(option)} of field ${label} has to be ${spec[0]}`);
+	}
+}
+function checkBlock(report, path, label, field, value) {
+	if (!isRecord(value)) return report(path, `Field ${label} has to hold blocks such as { collection: "…", id: "…" }`);
+	if (typeof value.collection !== "string") report(value.collection === void 0 ? path : [...path, "collection"], `A block in field ${label} needs a "collection"`);
+	else if (!field.collections.includes(value.collection)) report([...path, "collection"], `Field ${label} can't hold ${quote(value.collection)} blocks; allowed are ${field.collections.join(", ") || "none"}`);
+	if (typeof value.id !== "string") report(value.id === void 0 ? path : [...path, "id"], `A block in field ${label} needs an "id"`);
+	for (const key of Object.keys(value)) if (!BLOCK_KEYS.has(key)) report([...path, key], `A block in field ${label} has no option ${quote(key)}`);
+}
+function checkPattern(report, path, label, field, value) {
+	const pattern = field.validation === void 0 ? void 0 : compilePattern(field.validation);
+	if (pattern instanceof RegExp && !pattern.test(value)) report(path, `Field ${label} has to match the pattern ${field.validation}`);
+}
+function checkRange(report, path, label, field, value) {
+	const { min, max, step } = field;
+	if (min !== void 0 && value < min) report(path, `Field ${label} has to be at least ${min}`);
+	if (max !== void 0 && value > max) report(path, `Field ${label} has to be at most ${max}`);
+	if (step === void 0 || step <= 0) return;
+	const base = min ?? 0;
+	const steps = (value - base) / step;
+	if (Math.abs(steps - Math.round(steps)) <= 1e-9 * Math.max(1, Math.abs(steps))) return;
+	const nearest = [Math.floor(steps), Math.ceil(steps)].map((count) => Number((base + count * step).toPrecision(12))).filter((candidate) => (min === void 0 || candidate >= min) && (max === void 0 || candidate <= max));
+	report(path, `Field ${label} has to be in steps of ${step}${base === 0 ? "" : ` from ${base}`}${nearest.length > 0 ? `, such as ${nearest.join(" or ")}` : ""}`);
+}
+function checkValue(report, path, label, field, value) {
+	switch (field.type) {
+		case "text":
+			if (typeof value !== "string") report(path, `Field ${label} has to be a string`);
+			else checkPattern(report, path, label, field, value);
+			return;
+		case "richtext":
+			if (typeof value !== "string") report(path, `Field ${label} has to be a string`);
+			return;
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) report(path, `Field ${label} has to be a number`);
+			else checkRange(report, path, label, field, value);
+			return;
+		case "image":
+		case "video":
+			if (field.multiple) checkList(report, path, value, `Field ${label} has to be a list of media objects`, (at, item) => checkMedia(report, at, label, item));
+			else checkMedia(report, path, label, value);
+			return;
+		case "relation":
+			if (field.multiple) checkList(report, path, value, `Field ${label} has to be a list of ${quote(field.collection)} entry ids`, (at, item) => checkId(report, at, label, field.collection, item));
+			else checkId(report, path, label, field.collection, value);
+			return;
+		case "dynamic": checkList(report, path, value, `Field ${label} has to be a list of blocks`, (at, item) => checkBlock(report, at, label, field, item));
+	}
+}
+function checkTranslations(report, key, field, value, locales) {
+	if (!isRecord(value)) return report([key], `Field ${quote(key)} is translated and has to hold one value per locale, such as { ${locales[0]}: … }`);
+	for (const [locale, item] of Object.entries(value)) if (locales.includes(locale)) checkValue(report, [key, locale], `${quote(key)} (${locale})`, field, item);
+	else report([key, locale], `Field ${quote(key)} has no locale ${quote(locale)}; the schema has ${locales.join(", ")}`);
+	const missing = field.optional ? [] : locales.filter((locale) => value[locale] === void 0);
+	if (missing.length > 0) report([key], `Field ${quote(key)} is missing its ${missing.join(", ")} ${missing.length === 1 ? "translation" : "translations"}`);
+}
+function validateEntry(schema, collection, entry) {
+	const issues = [];
+	const report = (path, message) => issues.push({
+		path,
+		message
+	});
+	const definition = schema.collections[collection];
+	const locales = schema.locales ?? [];
+	if (!isRecord(entry)) {
+		report([], "An entry has to be an object");
+		return issues;
+	}
+	if (!definition) {
+		report([], `Collection ${quote(collection)} is not in the schema`);
+		return issues;
+	}
+	checkMeta(report, entry);
+	for (const [key, value] of Object.entries(entry)) if (value !== void 0 && !META_KEYS.includes(key) && !Object.hasOwn(definition.fields, key)) report([key], `${quote(key)} is not a field of collection ${quote(collection)}`);
+	for (const [key, field] of Object.entries(definition.fields)) {
+		const value = entry[key];
+		if (value === void 0) {
+			if (!field.optional) report([], `Field ${quote(key)} is required`);
+		} else if (isTranslated(field, locales)) checkTranslations(report, key, field, value, locales);
+		else checkValue(report, [key], quote(key), field, value);
+	}
+	return issues;
+}
+function byPosition(left, right) {
+	return left.line - right.line || left.column - right.column;
+}
+function parseContent(schemaFile, entryFiles) {
+	const parsedSchema = schemaFile ? parseSchemaFile(schemaFile) : { schema: { collections: {} } };
+	if ("issues" in parsedSchema) return {
+		issues: parsedSchema.issues,
+		schema: void 0,
+		content: {}
+	};
+	const { schema } = parsedSchema;
+	const issues = new Map(entryFiles.map((file) => [file.path, []]));
+	const sources = /* @__PURE__ */ new Map();
+	const content = {};
+	for (const file of entryFiles) {
+		const { collection, id, path } = file;
+		const found = issues.get(path);
+		const parsed = parseFile(file);
+		if (!("value" in parsed)) {
+			found.push(...parsed);
+			continue;
+		}
+		found.push(...validateEntry(schema, collection, parsed.value).map((issue) => located(path, parsed, issue)));
+		if (!isRecord(parsed.value)) continue;
+		if (typeof parsed.value.id === "string" && parsed.value.id !== id) found.push(located(path, parsed, {
+			path: ["id"],
+			message: `"id" is ${quote(parsed.value.id)}, but the file is named ${toEntryFile(id)}`
+		}));
+		content[collection] ??= {};
+		content[collection][id] = parsed.value;
+		sources.set(entryKey(collection, id), {
+			path,
+			parsed
+		});
+	}
+	for (const issue of validateReferences(schema, content)) {
+		const source = sources.get(entryKey(issue.collection, issue.id));
+		issues.get(source.path).push(located(source.path, source.parsed, issue));
+	}
+	return {
+		issues: [...issues.values()].flatMap((found) => found.sort(byPosition)),
+		schema,
+		content
+	};
+}
+async function entryFile(files, content, path) {
+	const entry = toEntryRef(content, path);
+	const text = entry && await files.read(path);
+	return entry && text !== void 0 ? [{
+		...entry,
+		path,
+		text
+	}] : [];
+}
+async function readContent(files, paths) {
+	const [schema, listed] = await Promise.all([files.read(paths.schema), files.list(paths.content)]);
+	const entries = await Promise.all(listed.sort().map((path) => entryFile(files, paths.content, path)));
+	return parseContent(schema === void 0 ? void 0 : {
+		path: paths.schema,
+		text: schema
+	}, entries.flat());
+}
+function createFileSource(files, paths) {
+	async function entry(collection, id) {
+		if (!isEntryId(id)) return void 0;
+		const path = paths.entry(collection, id);
+		const text = await files.read(path);
+		return text === void 0 ? void 0 : parseEntry(text, path);
+	}
+	return {
+		schema: async () => {
+			const text = await files.read(paths.schema);
+			return text === void 0 ? { collections: {} } : parseSchema(text, paths.schema);
+		},
+		list: async (collection) => {
+			const directory = paths.collection(collection);
+			const ids = (await files.list(directory)).map((path) => path.slice(directory.length + 1)).filter(isEntryFile).map(toEntryId);
+			const rows = await Promise.all(ids.map((id) => entry(collection, id)));
+			return sortByCreation(rows.filter((row) => row !== void 0));
+		},
+		entry
+	};
+}
+export { ContentError, createFileSource, formatIssue, readContent, validateSchema };