wuppycms 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,83 @@
+import { C as collectionSchema, _ as isPrivateAddress, d as resolveRedirect, f as createWebhookSender, g as fetchPublic, h as assertPublicUrl, l as redirectsSchema, m as UnsafeUrlError, n as loadConfig, p as webhooksSchema, t as defineConfig, v as redact } from "./config-CM8_-x_W.mjs";
+import { n as serializeDocument, t as parseDocument } from "./frontmatter-DGaz9--t.mjs";
+import { a as FilesystemContent, n as ContentService, s as assertSafeSlug, t as ContentExistsError } from "./service-CgcvCG7l.mjs";
+import { a as AuditLog, c as resolveSessionPolicy, d as creditsOf, f as buildDashboard, i as sanitizeHtml, l as CSRF_HEADER, n as CommentService, o as resolveOAuthProviders, r as JsonStore, s as resolvePasskeyOptions, t as createServer, u as createApp } from "./server-D92ryW2y.mjs";
+import "./generate-iX4B_2U2.mjs";
+import "./theme-pages-CRsBm1EX.mjs";
+import "./site-dF-xVPqe.mjs";
+import { isPublished } from "./publishing.mjs";
+import { i as settingsSchema, n as dataNames, r as dataSchemas, t as dataDefaults } from "./schemas-dHRJ1HeG.mjs";
+import "./render-DzH7Wil3.mjs";
+import { a as translationStatus, i as splitLocale, n as localeSwitcher, r as resolveLocale, t as hreflangAlternates } from "./i18n-CgLAHd9Q.mjs";
+import { a as detectImage, n as MediaService, o as serveUpload, t as MAX_UPLOAD_BYTES } from "./media-DGfJXgBA.mjs";
+import { buildRobots, buildSeo, buildSitemap, renderHead } from "./seo.mjs";
+import { t as readData } from "./read-Bh4-a3Ap.mjs";
+
+//#region src/data/helpers.ts
+/** Template helpers: read the site data files under `.wuppy/data`. All take `root` for tests; templates omit it. */
+/** The menu `name` in `locale`, else the menu without a locale. */
+async function getMenu(name, locale, root) {
+	const named = (await readData("menus", [], root)).filter((m) => m.name === name);
+	return named.find((m) => locale && m.locale === locale) ?? named.find((m) => !m.locale) ?? null;
+}
+const trimSlash = (p) => p.length > 1 ? p.replace(/\/+$/, "") : p;
+/** `/blog/*` matches the blog and everything below it; any other pattern must equal the path (trailing slash ignored). */
+function pathMatches(pattern, path) {
+	if (pattern.endsWith("/*")) {
+		const base = trimSlash(pattern.slice(0, -2)) || "";
+		return trimSlash(path) === (base || "/") || trimSlash(path).startsWith(`${base}/`);
+	}
+	return trimSlash(pattern) === trimSlash(path);
+}
+/** Widgets of an area visible for the given locale, collection and page path, with HTML widgets already sanitized. */
+async function getWidgetArea(name, where = {}, root) {
+	return ((await readData("widgets", [], root)).find((a) => a.name === name)?.widgets ?? []).filter((w) => !w.locales?.length || where.locale !== void 0 && w.locales.includes(where.locale)).filter((w) => !w.collections?.length || where.collection !== void 0 && w.collections.includes(where.collection)).filter((w) => !w.paths?.length || where.path !== void 0 && w.paths.some((p) => pathMatches(p, where.path))).map((w) => w.type === "html" ? {
+		...w,
+		body: sanitizeHtml(w.body)
+	} : w);
+}
+const localized = (b, locale) => {
+	const t = locale ? b.translations[locale] : void 0;
+	return t ? {
+		...b,
+		name: t.name || b.name,
+		bio: t.bio ?? b.bio
+	} : b;
+};
+/** A byline, with the name and bio of `locale` when translated. The email is never returned. */
+async function getByline(slug, root, locale) {
+	const found = (await readData("bylines", [], root)).find((b) => b.slug === slug);
+	return found ? localized({
+		...found,
+		email: ""
+	}, locale) : null;
+}
+/** Credits of a `byline` field value, resolved to profiles; unknown slugs are skipped. */
+async function getCredits(value, root, locale) {
+	const all = await readData("bylines", [], root);
+	return creditsOf(value).flatMap(({ byline, role }) => {
+		const found = all.find((b) => b.slug === byline);
+		return found ? [{
+			byline: localized({
+				...found,
+				email: ""
+			}, locale),
+			role
+		}] : [];
+	});
+}
+/** The published section `slug`; the variant for `locale` wins over the language-neutral one. */
+async function getSection(slug, root, locale) {
+	const all = (await readData("sections", [], root)).filter((s) => s.slug === slug && !s.draft);
+	return locale && all.find((s) => s.locale === locale) || all.find((s) => !s.locale) || null;
+}
+/** Published sections in the order of `slugs`; unknown and draft ones are skipped. */
+async function getSections(slugs, root, locale) {
+	return (await Promise.all(slugs.map((slug) => getSection(slug, root, locale)))).flatMap((s) => s ?? []);
+}
+async function getTaxonomy(name, root) {
+	return (await readData("taxonomies", [], root)).find((t) => t.name === name) ?? null;
+}
+
+//#endregion
+export { AuditLog, CSRF_HEADER, CommentService, ContentExistsError, ContentService, FilesystemContent, JsonStore, MAX_UPLOAD_BYTES, MediaService, UnsafeUrlError, assertPublicUrl, assertSafeSlug, buildDashboard, buildRobots, buildSeo, buildSitemap, collectionSchema, createApp, createServer, createWebhookSender, dataDefaults, dataNames, dataSchemas, defineConfig, detectImage, fetchPublic, getByline, getCredits, getMenu, getSection, getSections, getTaxonomy, getWidgetArea, hreflangAlternates, isPrivateAddress, isPublished, loadConfig, localeSwitcher, parseDocument, pathMatches, readData, redact, redirectsSchema, renderHead, resolveLocale, resolveOAuthProviders, resolvePasskeyOptions, resolveRedirect, resolveSessionPolicy, sanitizeHtml, serializeDocument, serveUpload, settingsSchema, splitLocale, translationStatus, webhooksSchema };

package/dist/live-runtime.d.mts

@@ -0,0 +1,120 @@
+import { MarkdownHeading, MarkdownSettings, markdownRenderer, mdxContent } from "./mdx.mjs";
+
+//#region src/astro/live-runtime.d.ts
+/**
+ * Runtime half of live content. The site's pages keep calling `getCollection()` / `getEntry()` from `astro:content`;
+ * for Wuppy collections these read the files on disk, so a save in the admin shows on the next request, no rebuild.
+ * Astro's own helpers (frontmatter parser, Markdown renderer, digest) are passed in by the generated module.
+ */
+interface AstroEntry {
+  id: string;
+  collection: string;
+  data: Record<string, unknown>;
+  body?: string;
+  filePath?: string;
+  digest?: string;
+  rendered?: {
+    html: string;
+    metadata?: Record<string, unknown>;
+  };
+  deferredRender?: boolean;
+}
+interface SchemaLike {
+  safeParseAsync(data: unknown): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: {
+      message: string;
+    };
+  }>;
+}
+/** `dir` is relative to the root or absolute (a theme reading the site's entries); `rename` is site -> theme field. */
+type LiveCollection = {
+  name: string;
+  dir: string;
+  rename?: Record<string, string>;
+};
+interface LiveDeps {
+  root: string;
+  /** Defaults to the collections in the site's wuppy.config, read once at runtime. */
+  collections?: LiveCollection[];
+  /** The build-time collection: entries whose file did not change are returned from it as they are. */
+  built(name: string): Promise<AstroEntry[]>;
+  schema(name: string): SchemaLike | undefined;
+  parseFrontmatter(source: string): {
+    frontmatter: Record<string, unknown>;
+    content: string;
+  };
+  digest(source: string): Promise<string>;
+  renderMarkdown(body: string, frontmatter: Record<string, unknown>, filePath: string): Promise<AstroEntry["rendered"]>;
+}
+type PageBody = {
+  data: Record<string, unknown>;
+  headings: MarkdownHeading[];
+  html?: string;
+  Content?: unknown;
+};
+/**
+ * A theme's Markdown page body (`rel` like `about`), read on each request from the site's Pages entry, or from the theme
+ * file itself when the site has none. `.mdx` compiles to a component (theme components allowed); `.md` to HTML.
+ */
+declare function themePage(rel: string, themeFile: string, markdown?: MarkdownSettings): Promise<PageBody>;
+/**
+ * The blocks added in the admin to a theme `.astro` page: the body of the site's Pages entry that names the page as its
+ * `template`, or undefined when there is none.
+ */
+declare function themeBody(rel: string, markdown?: MarkdownSettings): Promise<PageBody | undefined>;
+/** Astro's default entry id: path without extension, each segment slugged like github-slugger. */
+declare function defaultId(path: string): string;
+declare function createLive(deps: LiveDeps): {
+  isLive: (name: string) => Promise<boolean>; /** Whether `render(entry)` must compile the body now instead of using Astro's built module. */
+  rendersAtRuntime: (entry: unknown) => boolean;
+  getCollection(name: string, filter?: (entry: AstroEntry) => unknown): Promise<AstroEntry[]>;
+  getEntry(name: string, id: string): Promise<AstroEntry | undefined>;
+};
+type Params = Record<string, string | number | undefined>;
+type Factory = ((result: {
+  params?: Params;
+}, props: Record<string, unknown>, slots: unknown) => unknown) & Record<string, unknown>;
+type StaticPath = {
+  params: Params;
+  props?: Record<string, unknown>;
+};
+/** Astro's `paginate()` for a page rendered on request: same shape, URLs built from the route pattern (no `base`). */
+declare function paginator(pattern: string): (data: unknown[], args?: {
+  pageSize?: number;
+  params?: Params;
+  props?: Record<string, unknown>;
+}) => {
+  params: {
+    page: string | undefined;
+  };
+  props: {
+    page: {
+      data: unknown[];
+      start: number;
+      end: number;
+      size: number;
+      total: number;
+      currentPage: number;
+      lastPage: number;
+      url: {
+        current: string;
+        next: string | undefined;
+        prev: string | undefined;
+        first: string | undefined;
+        last: string | undefined;
+      };
+    };
+  };
+}[];
+/**
+ * A page that used to be prerendered gets its props from `getStaticPaths()`. Rendered on request, Astro no longer
+ * calls it, so this wrapper does: it finds the path matching the request and passes its props, or answers 404.
+ */
+declare function livePage(factory: Factory, getStaticPaths: (opts: {
+  paginate: ReturnType<typeof paginator>;
+  routePattern: string;
+}) => Promise<StaticPath[]>, pattern: string): Factory;
+//#endregion
+export { AstroEntry, LiveDeps, createLive, defaultId, livePage, markdownRenderer, mdxContent, paginator, themeBody, themePage };

package/dist/live-runtime.mjs

@@ -0,0 +1,207 @@
+import { n as loadConfig } from "./config-CM8_-x_W.mjs";
+import { t as parseDocument } from "./frontmatter-DGaz9--t.mjs";
+import { a as pagesDir, i as loadSiteConfig, o as renameFields } from "./site-dF-xVPqe.mjs";
+import { n as markdownRenderer, r as mdxContent, t as markdownContent } from "./render-DzH7Wil3.mjs";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+
+//#region src/astro/live-runtime.ts
+/** The collections in wuppy.config; a theme run for a site (WUPPY_BASE_ROOT) reads them from the site's folders. */
+async function configured(root) {
+	const site = process.env.WUPPY_BASE_ROOT;
+	if (!site || resolve(site) === resolve(root)) return (await loadConfig(root)).collections;
+	const { links } = await loadSiteConfig(site, root);
+	return links.map((l) => ({
+		name: l.name,
+		dir: join(site, l.dir),
+		rename: l.rename
+	}));
+}
+let pages;
+/** The site's Pages entry files for a theme page `rel`, `.mdx` first. */
+async function entryFiles(rel) {
+	const site = process.env.WUPPY_BASE_ROOT || process.cwd();
+	pages ??= loadSiteConfig(site, process.cwd()).then((c) => pagesDir(c.collections));
+	const dir = await pages;
+	return dir ? [".mdx", ".md"].map((ext) => join(site, dir, rel + ext)) : [];
+}
+async function renderBody(file, source, markdown) {
+	const { data, body } = parseDocument(source);
+	const { layout: _layout, ...rest } = data;
+	if (file.endsWith(".md")) return {
+		data: rest,
+		...await markdownContent(body, {
+			root: process.cwd(),
+			markdown
+		})
+	};
+	return {
+		data: rest,
+		...await mdxContent(body, { markdown })
+	};
+}
+/**
+* A theme's Markdown page body (`rel` like `about`), read on each request from the site's Pages entry, or from the theme
+* file itself when the site has none. `.mdx` compiles to a component (theme components allowed); `.md` to HTML.
+*/
+async function themePage(rel, themeFile, markdown) {
+	for (const file of [...await entryFiles(rel), themeFile]) {
+		const source = await readFile(file, "utf8").catch(() => null);
+		if (source !== null) return renderBody(file, source, markdown);
+	}
+	throw new Error(`[wuppy] ${themeFile} is gone`);
+}
+/**
+* The blocks added in the admin to a theme `.astro` page: the body of the site's Pages entry that names the page as its
+* `template`, or undefined when there is none.
+*/
+async function themeBody(rel, markdown) {
+	for (const file of await entryFiles(rel)) {
+		const source = await readFile(file, "utf8").catch(() => null);
+		if (source === null) continue;
+		if (typeof parseDocument(source).data.template !== "string") return void 0;
+		return renderBody(file, source, markdown);
+	}
+}
+async function files(dir) {
+	return (await readdir(dir, { recursive: true }).catch(() => [])).filter((n) => /\.mdx?$/.test(n) && !n.split(/[\\/]/).some((part) => part.startsWith("_"))).toSorted().map((n) => join(dir, n));
+}
+/** Astro's default entry id: path without extension, each segment slugged like github-slugger. */
+function defaultId(path) {
+	return path.replace(/\.[^./]+$/, "").split("/").map((s) => s.toLowerCase().replace(/[^\p{L}\p{M}\p{N}\p{Pc}\s-]/gu, "").replace(/\s/g, "-")).join("/").replace(/\/index$/, "");
+}
+function createLive(deps) {
+	let collections;
+	const named = () => collections ??= (deps.collections ? Promise.resolve(deps.collections) : configured(deps.root)).then((list) => new Map(list.map((c) => [c.name, c])), (e) => {
+		console.error(`[wuppy] live content is off: ${e.message}`);
+		return /* @__PURE__ */ new Map();
+	});
+	const runtimeMdx = /* @__PURE__ */ new WeakSet();
+	const cache = /* @__PURE__ */ new Map();
+	async function build(name, filePath, source, built) {
+		const digest = await deps.digest(source);
+		if (built?.digest === digest) return built;
+		const collection = (await named()).get(name);
+		const doc = deps.parseFrontmatter(source);
+		const frontmatter = renameFields(doc.frontmatter, collection.rename ?? {});
+		const body = doc.content.trim();
+		const id = (typeof frontmatter.slug === "string" ? frontmatter.slug : void 0) ?? built?.id ?? defaultId(relative(resolve(deps.root, collection.dir), resolve(deps.root, filePath)).split(sep).join("/"));
+		let data = frontmatter;
+		const schema = deps.schema(name);
+		if (schema) {
+			const parsed = await schema.safeParseAsync(frontmatter);
+			if (!parsed.success) {
+				console.error(`[wuppy] ${filePath} does not match the collection schema: ${parsed.error?.message}`);
+				return built ?? null;
+			}
+			data = parsed.data;
+		}
+		const entry = {
+			id,
+			collection: name,
+			data,
+			body,
+			filePath,
+			digest
+		};
+		if (filePath.endsWith(".md")) entry.rendered = await deps.renderMarkdown(body, frontmatter, filePath);
+		else runtimeMdx.add(entry);
+		return entry;
+	}
+	async function load(name) {
+		const collection = (await named()).get(name);
+		const built = new Map((await deps.built(name).catch(() => [])).map((e) => [e.filePath, e]));
+		const out = [];
+		for (const abs of await files(resolve(deps.root, collection.dir))) {
+			const info = await stat(abs).catch(() => null);
+			if (!info) continue;
+			let hit = cache.get(abs);
+			if (!hit || hit.mtimeMs !== info.mtimeMs || hit.size !== info.size) {
+				const filePath = relative(deps.root, abs).split(sep).join("/");
+				const source = await readFile(abs, "utf8").catch(() => null);
+				if (source === null) continue;
+				hit = {
+					mtimeMs: info.mtimeMs,
+					size: info.size,
+					entry: await build(name, filePath, source, built.get(filePath))
+				};
+				cache.set(abs, hit);
+			}
+			if (hit.entry) out.push(hit.entry);
+		}
+		return out;
+	}
+	return {
+		isLive: async (name) => (await named()).has(name),
+		rendersAtRuntime: (entry) => typeof entry === "object" && entry !== null && runtimeMdx.has(entry),
+		async getCollection(name, filter) {
+			const all = await load(name);
+			return filter ? all.filter((e) => filter(e)) : all;
+		},
+		async getEntry(name, id) {
+			return (await load(name)).find((e) => e.id === id);
+		}
+	};
+}
+const same = (a, b) => [...new Set([...Object.keys(a), ...Object.keys(b)])].every((k) => String(a[k] ?? "") === String(b[k] ?? ""));
+/** Astro's `paginate()` for a page rendered on request: same shape, URLs built from the route pattern (no `base`). */
+function paginator(pattern) {
+	const rest = pattern.includes("[...page]");
+	const url = (params) => pattern.replace(/\[(?:\.\.\.)?(\w+)\]/g, (_, k) => params[k] === void 0 ? "" : String(params[k])).replace(/\/{2,}/g, "/").replace(/(.)\/$/, "$1");
+	const page = (n) => rest && n === 1 ? void 0 : n;
+	return (data, args = {}) => {
+		const size = args.pageSize || 10;
+		const last = Math.max(1, Math.ceil(data.length / size));
+		const at = (n) => ({
+			...args.params,
+			page: n === void 0 ? void 0 : String(n)
+		});
+		return Array.from({ length: last }, (_, i) => {
+			const n = i + 1;
+			const start = (n - 1) * size;
+			return {
+				params: at(page(n)),
+				props: {
+					...args.props,
+					page: {
+						data: data.slice(start, start + size),
+						start,
+						end: Math.min(start + size, data.length) - 1,
+						size,
+						total: data.length,
+						currentPage: n,
+						lastPage: last,
+						url: {
+							current: url(at(page(n))),
+							next: n === last ? void 0 : url(at(n + 1)),
+							prev: n === 1 ? void 0 : url(at(page(n - 1))),
+							first: n === 1 ? void 0 : url(at(page(1))),
+							last: n === last ? void 0 : url(at(last))
+						}
+					}
+				}
+			};
+		});
+	};
+}
+/**
+* A page that used to be prerendered gets its props from `getStaticPaths()`. Rendered on request, Astro no longer
+* calls it, so this wrapper does: it finds the path matching the request and passes its props, or answers 404.
+*/
+function livePage(factory, getStaticPaths, pattern) {
+	const wrapped = (async (result, props, slots) => {
+		const match = (await getStaticPaths({
+			paginate: paginator(pattern),
+			routePattern: pattern
+		})).flat().find((p) => same(p.params, result.params ?? {}));
+		if (!match) return new Response(null, { status: 404 });
+		return factory(result, {
+			...match.props,
+			...props
+		}, slots);
+	});
+	return Object.assign(wrapped, factory);
+}
+
+//#endregion
+export { createLive, defaultId, livePage, markdownRenderer, mdxContent, paginator, themeBody, themePage };

package/dist/markdown.mjs

@@ -0,0 +1,4 @@
+import "./config-CM8_-x_W.mjs";
+import { n as markdownRenderer, r as mdxContent, t as markdownContent } from "./render-DzH7Wil3.mjs";
+
+export { markdownContent, markdownRenderer, mdxContent };

package/dist/mdx.d.mts

@@ -0,0 +1,68 @@
+//#region src/markdown/render.d.ts
+interface MarkdownHeading {
+  depth: number;
+  slug: string;
+  text: string;
+}
+/** The JSON-safe parts of Astro's `markdown` config (see the live content shim). */
+interface MarkdownSettings {
+  features?: Record<string, unknown>;
+  shared?: Record<string, unknown>;
+}
+/** The JSON-safe parts of Astro's `markdown` config used by MDX. */
+interface MdxMarkdownSettings {
+  features?: Record<string, unknown>;
+  shared?: {
+    syntaxHighlight?: unknown;
+    shikiConfig?: unknown;
+    gfm?: boolean;
+    smartypants?: boolean;
+  };
+}
+interface MarkdownRenderer {
+  render(source: string, options: {
+    frontmatter: Record<string, unknown>;
+    fileURL?: URL;
+  }): Promise<{
+    code: string;
+    metadata: {
+      headings?: MarkdownHeading[];
+    } & Record<string, unknown>;
+  }>;
+}
+/**
+ * Astro's own Markdown renderer (heading ids, code highlighting, GFM), loaded from Astro's dependency at runtime: it
+ * has a native binding, which cannot be bundled.
+ */
+declare function markdownRenderer(root?: string, settings?: MarkdownSettings): Promise<MarkdownRenderer>;
+/**
+ * Markdown stored outside content collections (a section body, a custom widget) as HTML, the way Astro renders an
+ * `.md` entry: `const { html } = await markdownContent(section.body)` then `<Fragment set:html={html} />`. The text is
+ * checked first with the same rules as the admin, so a body changed outside the admin cannot inject scripts either.
+ */
+declare function markdownContent(source: string, options?: {
+  root?: string;
+  markdown?: MarkdownSettings;
+}): Promise<{
+  html: string;
+  headings: MarkdownHeading[];
+}>;
+/**
+ * MDX text stored at runtime (a section body, an entry edited since the last build) compiled to what Astro's `render()`
+ * gives: `const { Content, headings } = await mdxContent(section.body)` then `<Content components={{ Callout }} />`.
+ * The text is checked first with the same rules as the admin (no imports, exports or expressions; only the `components`
+ * listed in wuppy.config), so a body changed outside the admin cannot run code either. Headings get Astro's ids and
+ * code blocks its highlighting. Needs `@astrojs/mdx` in the site, which renders the result.
+ */
+declare function mdxContent(source: string, options?: {
+  allowed?: readonly string[];
+  root?: string;
+  markdown?: MdxMarkdownSettings;
+}): Promise<{
+  Content: (props?: {
+    components?: Record<string, unknown>;
+  } & Record<string, unknown>) => unknown;
+  headings: MarkdownHeading[];
+}>;
+//#endregion
+export { MarkdownHeading, MarkdownSettings, MdxMarkdownSettings, markdownContent, markdownRenderer, mdxContent };

package/dist/mdx.mjs

@@ -0,0 +1,4 @@
+import "./config-CM8_-x_W.mjs";
+import { n as markdownRenderer, r as mdxContent, t as markdownContent } from "./render-DzH7Wil3.mjs";
+
+export { markdownContent, markdownRenderer, mdxContent };