forgepress 0.0.1 → 0.0.2

package/dist/_chunks/output2.mjs

@@ -1,333 +0,0 @@
-import { isRecord, quote } from "./value.mjs";
-import { entryKey, validateReferences } from "./references.mjs";
-import { OUTPUT_INDEX } from "./types.mjs";
-import { createOutput, defaultPaths, isEntryFile, isEntryId, toCollectionName, toEntryFile, toEntryId } from "./output.mjs";
-import { ContentError, META_KEYS, compilePattern, parseModule, validateSchema } from "./validate.mjs";
-import { existsSync, readdirSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, rm, rmdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
-import process from "node:process";
-import { randomUUID } from "node:crypto";
-import { execFileSync } from "node:child_process";
-const STATUSES = ["published", "unpublished"];
-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 (!STATUSES.includes(entry.status)) report(["status"], "\"status\" has to be \"published\" or \"unpublished\"");
-	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 (field.translate && locales.length > 0) checkTranslations(report, key, field, value, locales);
-		else checkValue(report, [key], quote(key), field, value);
-	}
-	return issues;
-}
-function parse(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 byPosition(left, right) {
-	return left.line - right.line || left.column - right.column;
-}
-function parseContent(schemaFile, entryFiles) {
-	const schemaModule = parse(schemaFile);
-	if (!("value" in schemaModule)) return {
-		issues: [...schemaModule],
-		schema: void 0,
-		content: {}
-	};
-	const schemaIssues = validateSchema(schemaModule.value);
-	if (schemaIssues.length > 0) return {
-		issues: schemaIssues.map((issue) => located(schemaFile.path, schemaModule, issue)),
-		schema: void 0,
-		content: {}
-	};
-	const schema = schemaModule.value;
-	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 = parse(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
-	};
-}
-function readEntryIds(path) {
-	if (!existsSync(path)) return [];
-	return readdirSync(path).filter(isEntryFile).map(toEntryId).sort();
-}
-function readCollections(root, paths = defaultPaths) {
-	const base = join(root, paths.content);
-	if (!existsSync(base)) return [];
-	return readdirSync(base, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => ({
-		collection: toCollectionName(item.name),
-		directory: item.name,
-		path: join(base, item.name),
-		ids: readEntryIds(join(base, item.name))
-	})).sort((left, right) => left.collection.localeCompare(right.collection));
-}
-async function loadContent(root, paths = defaultPaths) {
-	const read = (path) => readFile(join(root, path), "utf8");
-	const entries = await Promise.all(readCollections(root, paths).flatMap((directory) => directory.ids.map(async (id) => {
-		const path = `${paths.content}/${directory.directory}/${toEntryFile(id)}`;
-		return {
-			collection: directory.collection,
-			id,
-			path,
-			text: await read(path)
-		};
-	})));
-	return parseContent({
-		path: paths.schema,
-		text: await read(paths.schema)
-	}, entries);
-}
-async function checkContent(root, paths = defaultPaths) {
-	return (await loadContent(root, paths)).issues;
-}
-const COMMIT = /^[\da-f]{40}(?:[\da-f]{24})?$/i;
-const COMMIT_VARIABLES = [
-	"GITHUB_SHA",
-	"CI_COMMIT_SHA",
-	"COMMIT_REF",
-	"VERCEL_GIT_COMMIT_SHA",
-	"CF_PAGES_COMMIT_SHA",
-	"RENDER_GIT_COMMIT",
-	"AWS_COMMIT_ID",
-	"SOURCE_VERSION"
-];
-function gitHead(root) {
-	try {
-		return execFileSync("git", ["rev-parse", "HEAD"], {
-			cwd: root,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
-	} catch {
-		return;
-	}
-}
-function readCommit(root, env = process.env) {
-	return [gitHead(root), ...COMMIT_VARIABLES.map((name) => env[name]?.trim())].find((value) => value !== void 0 && COMMIT.test(value))?.toLowerCase() ?? null;
-}
-const HASHED_FILE = /^[^/]+(?:\/[^/]+)*\/[\w-]+\.[\da-f]{8}\.json$/;
-const queues = /* @__PURE__ */ new Map();
-function isOutputFile(path) {
-	return path === "index.json" || HASHED_FILE.test(path);
-}
-async function place(path, text) {
-	const temporary = `${path}.${randomUUID()}.tmp`;
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(temporary, text);
-	await rename(temporary, path);
-}
-async function listFiles(dir) {
-	return (await readdir(dir, {
-		withFileTypes: true,
-		recursive: true
-	})).filter((item) => item.isFile()).map((item) => relative(dir, join(item.parentPath, item.name)).split(sep).join("/"));
-}
-function ancestors(folder) {
-	return folder === "." || folder === "" ? [] : [folder, ...ancestors(dirname(folder))];
-}
-async function removeEmpty(path) {
-	try {
-		await rmdir(path);
-	} catch (error) {
-		const code = error.code;
-		if (code !== "ENOTEMPTY" && code !== "EEXIST" && code !== "ENOENT") throw error;
-	}
-}
-async function prune(dir, folders) {
-	const candidates = [...new Set(folders.flatMap(ancestors))];
-	for (const folder of candidates.sort((left, right) => right.split("/").length - left.split("/").length)) await removeEmpty(join(dir, folder));
-}
-function outputDir(root, config) {
-	const dir = join(root, config.output.dir);
-	const inside = relative(root, dir);
-	if (inside === "" || inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside)) throw new Error(`[forgepress] the output folder has to be inside the project, not ${JSON.stringify(config.output.dir)}`);
-	return dir;
-}
-async function write(dir, files) {
-	const index = files.at(-1);
-	if (index?.path !== "index.json") throw new Error(`[forgepress] the content output has to end with ${OUTPUT_INDEX}`);
-	const hashed = files.slice(0, -1).filter((file) => !existsSync(join(dir, file.path)));
-	await Promise.all(hashed.map((file) => place(join(dir, file.path), file.text)));
-	await place(join(dir, index.path), index.text);
-	const kept = new Set(files.map((file) => file.path));
-	const stale = (await listFiles(dir)).filter((path) => isOutputFile(path) && !kept.has(path));
-	await Promise.all(stale.map((path) => rm(join(dir, path), { force: true })));
-	await prune(dir, stale.map((path) => dirname(path)));
-}
-function writeOutput(dir, files) {
-	const next = (queues.get(dir) ?? Promise.resolve()).catch(() => void 0).then(() => write(dir, files));
-	queues.set(dir, next);
-	return next;
-}
-async function buildOutput(root, config, options = {}) {
-	const dir = outputDir(root, config);
-	const { issues, schema, content } = await loadContent(root, config.paths);
-	if (!schema || issues.length > 0 && !options.dev) throw new ContentError(issues);
-	const commit = options.dev ? null : readCommit(root);
-	const files = await createOutput(schema, content, {
-		commit,
-		...options.dev ? { dev: true } : {}
-	});
-	await writeOutput(dir, files);
-	return {
-		dir: config.output.dir,
-		files: files.length,
-		commit,
-		issues
-	};
-}
-export { buildOutput, checkContent, outputDir, readEntryIds };

package/dist/_chunks/parse.mjs

@@ -1,22 +0,0 @@
-import { isRecord } from "./value.mjs";
-import { ContentError, parseModule, validateSchema } from "./validate.mjs";
-function parseSchema(text, file) {
-	const { value, locate } = parseModule(text, file);
-	const issues = validateSchema(value);
-	if (issues.length > 0) throw new ContentError(issues.map((issue) => ({
-		file,
-		...locate(issue.path),
-		message: issue.message
-	})));
-	return value;
-}
-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;
-}
-export { parseEntry, parseSchema };

package/dist/_chunks/types.mjs

@@ -1,2 +0,0 @@
-const OUTPUT_INDEX = "index.json";
-export { OUTPUT_INDEX };