@goodfellow-cms/next 0.4.0 → 0.6.0

package/dist/plugins-eLJalBij.js

@@ -0,0 +1,191 @@
+import { EDITOR_PRELUDE, INSTALLED_PLUGINS_INDEX, PLUGINS_PATH, framedPlugins, pluginFrameEntry, pluginFramePage, pluginId } from "@goodfellow-cms/core";
+import { LICENSES_FILE, licensesPlugin } from "@goodfellow-cms/core/node";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/plugins.ts
+/**
+* Plugins on Next.js sites: their admin frames, bundled with Rolldown as
+* `next dev` bundles the editor's frames, and their build steps, both run by
+* `goodfellow-next finish` from the site's config, which Next.js alone
+* bundles otherwise. Node only.
+*/
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	buildPluginFrame: () => buildPluginFrame,
+	buildPluginFrames: () => buildPluginFrames,
+	configHasPlugins: () => configHasPlugins,
+	findConfigFile: () => findConfigFile,
+	loadSiteConfig: () => loadSiteConfig
+});
+const CONFIG_FILES = [
+	"goodfellow.config.tsx",
+	"goodfellow.config.ts",
+	"goodfellow.config.jsx",
+	"goodfellow.config.js"
+];
+const FRAME_ENTRY = "\0goodfellow:plugin-frame";
+function findConfigFile(root) {
+	return CONFIG_FILES.map((name) => join(root, name)).find((file) => existsSync(file));
+}
+/**
+* Whether the site's config lists plugins, read from its text, so builds of
+* sites without any never load the config outside Next.js: plugins of its
+* own, or any installed from the admin panel, which `plugins/installed/`
+* lists.
+*/
+async function configHasPlugins(root) {
+	const file = findConfigFile(root);
+	const listed = file && /\bplugins\s*:\s*([^\n]*)/.exec(await readFile(file, "utf8"))?.[1];
+	if (!listed) return false;
+	if (!/^installedPlugins\s*,?$/.test(listed.trim())) return true;
+	const index = join(root, INSTALLED_PLUGINS_INDEX);
+	return existsSync(index) && /\binstalledPlugin\(/.test(await readFile(index, "utf8"));
+}
+/**
+* The site's config, loaded in Node: bundled with Rolldown, with the
+* packages it imports left for Node to load and stylesheets left out, then
+* imported. Only what plugins need is read from it.
+*/
+async function loadSiteConfig(root) {
+	const configFile = findConfigFile(root);
+	if (!configFile) throw new Error(`No goodfellow.config.tsx in ${root}.`);
+	const { build } = await import("rolldown");
+	const outDir = join(root, "node_modules/.goodfellow");
+	await mkdir(outDir, { recursive: true });
+	const file = join(outDir, `config-${process.pid}-${Date.now()}.mjs`);
+	await build({
+		input: configFile,
+		cwd: root,
+		platform: "node",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: { jsx: { runtime: "automatic" } },
+		external: (id, _importer, resolved) => resolved ? /[\\/]node_modules[\\/]/.test(id) : !id.startsWith(".") && !isAbsolute(id) && !id.startsWith("@/"),
+		plugins: [{
+			name: "goodfellow:no-styles",
+			load: (id) => id.endsWith(".css") ? {
+				code: "",
+				moduleType: "js"
+			} : void 0
+		}],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			file,
+			format: "esm",
+			codeSplitting: false
+		}
+	});
+	try {
+		return (await import(pathToFileURL(file).href)).default;
+	} finally {
+		await rm(file, { force: true });
+	}
+}
+/** A plugin's admin module as the bundler imports it: a package's export, or a path from the site's root. */
+function adminModule(root, specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../") ? resolve(root, specifier) : specifier;
+}
+/**
+* Bundles a plugin's admin module into its frame, at `admin/plugins/<id>/`
+* under `outDir`: one classic script starting with `EDITOR_PRELUDE`, its
+* stylesheets in one file, `pluginFramePage()`, whose Content Security
+* Policy reaches only the addresses the plugin declared, and the notices of
+* what it bundles (`LICENSES_FILE`). Answers a function that stops rebuilding.
+*/
+async function buildPluginFrame(plugin, { root, dir, watch }) {
+	if (!plugin.admin) throw new Error(`${plugin.name} has no admin module.`);
+	const rolldown = await import("rolldown");
+	await mkdir(dir, { recursive: true });
+	const stylesheets = /* @__PURE__ */ new Set();
+	const writePage = async () => {
+		const css = await Promise.all([...stylesheets].map((file) => readFile(file, "utf8")));
+		await writeFile(join(dir, "plugin.css"), css.join("\n"));
+		await writeFile(join(dir, "index.html"), pluginFramePage({
+			permissions: plugin.permissions ?? {},
+			scripts: ["plugin.js"],
+			stylesheets: ["plugin.css"],
+			licenses: LICENSES_FILE
+		}));
+	};
+	const options = {
+		input: { plugin: FRAME_ENTRY },
+		cwd: root,
+		platform: "browser",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: {
+			jsx: { runtime: "automatic" },
+			define: { "process.env.NODE_ENV": JSON.stringify(watch ? "development" : "production") }
+		},
+		plugins: [{
+			name: "goodfellow:plugin-frame",
+			resolveId: (id) => id === FRAME_ENTRY ? id : void 0,
+			load(id) {
+				if (id === FRAME_ENTRY) return pluginFrameEntry(adminModule(root, plugin.admin ?? ""));
+				if (id.endsWith(".css")) {
+					stylesheets.add(id);
+					return {
+						code: "",
+						moduleType: "js"
+					};
+				}
+			}
+		}, licensesPlugin(plugin.title, LICENSES_FILE)],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			dir,
+			format: "iife",
+			codeSplitting: false,
+			entryFileNames: "plugin.js",
+			banner: EDITOR_PRELUDE,
+			...watch ? { sourcemap: true } : { minify: true }
+		}
+	};
+	if (!watch) {
+		await rolldown.build(options);
+		await writePage();
+		return async () => {};
+	}
+	const watcher = rolldown.watch(options);
+	watcher.on("event", (event) => {
+		if (event.code === "BUNDLE_END") {
+			event.result.close();
+			writePage().then(() => watch.onBuilt(), (error) => watch.onBuilt(error));
+		} else if (event.code === "ERROR") {
+			event.result?.close();
+			watch.onBuilt(event.error);
+		}
+	});
+	return () => watcher.close();
+}
+/** Builds every plugin's admin frame into `admin/plugins/<id>/` in `outDir`. Answers the plugins' names. */
+async function buildPluginFrames(plugins, { root, outDir }) {
+	const built = [];
+	for (const plugin of framedPlugins(plugins)) {
+		await buildPluginFrame(plugin, {
+			root,
+			dir: join(outDir, PLUGINS_PATH, pluginId(plugin.name))
+		});
+		built.push(plugin.name);
+	}
+	return built;
+}
+//#endregion
+export { plugins_exports as a, loadSiteConfig as i, buildPluginFrames as n, configHasPlugins as r, buildPluginFrame as t };

package/dist/server.d.ts

@@ -31,6 +31,13 @@ export interface GoodfellowApiOptions {
   ai?: ServerKeys;
   /** Told about failures editors only hear about as "something went wrong". Defaults to `console.error`. */
   onError?: (error: unknown) => void;
+  /**
+   * The server modules of the config's plugins, by plugin name, imported in
+   * the route's file, such as `{ "goodfellow-plugin-s3": s3Server }` from
+   * `import s3Server from "goodfellow-plugin-s3/server"`. Each answers
+   * `plugins/<id>/…`, and runs with everything the server has.
+   */
+  plugins?: AppApiOptions["plugins"];
 }
 /** The route parameters of a catch-all route named `[...path]`. */
 interface RouteContext {

package/dist/server.js

@@ -31,7 +31,8 @@ function goodfellowApi(options) {
 			signIn: options.signIn,
 			...options.signOut && { signOut: options.signOut },
 			...ai && ai.services.length > 0 && { ai },
-			...options.onError && { onError: options.onError }
+			...options.onError && { onError: options.onError },
+			...options.plugins && { plugins: options.plugins }
 		});
 		return api;
 	}

package/dist/site-files-BeLnLxCl.js

@@ -0,0 +1,50 @@
+//#region src/site-files.ts
+/** The release whose Next.js sites have the editor's sandboxed frames at `app/admin/editor/`. */
+const FRAMES_RELEASE = "0.5.0";
+/** `app/admin/page.tsx` as every release before the frames wrote it, loading the site's config itself. */
+const CLIENT_ADMIN_PAGE = `"use client";
+
+import { GoodfellowAdmin } from "@goodfellow-cms/next/admin";
+import config from "@/goodfellow.config";
+
+export default function AdminPage() {
+  return <GoodfellowAdmin config={config} />;
+}
+`;
+const ADMIN_PAGE = `import { GoodfellowAdmin } from "@goodfellow-cms/next/admin";
+import { site } from "@/lib/site";
+
+// The admin panel's page never loads the site's config: it's told about the site's blocks here, on the server,
+// and the blocks themselves run in the editor's frames, at /admin/editor/.
+export default function AdminPage() {
+  return <GoodfellowAdmin site={site.admin()} />;
+}
+`;
+const EDITOR_PAGE = `"use client";
+
+import { GoodfellowEditor } from "@goodfellow-cms/next/editor";
+import config from "@/goodfellow.config";
+
+// The editor's frames: Puck and the site's blocks, sandboxed away from the admin panel's page.
+export default function EditorPage() {
+  return <GoodfellowEditor config={config} />;
+}
+`;
+/**
+* The Next.js starter's files that `goodfellow-next update` keeps up to date
+* where nobody has changed them, as the starter now has them. A test checks
+* they match `templates/next`.
+*/
+const NEXT_SITE_FILES = [{
+	path: "app/admin/page.tsx",
+	since: FRAMES_RELEASE,
+	content: ADMIN_PAGE,
+	earlier: [CLIENT_ADMIN_PAGE]
+}, {
+	path: "app/admin/editor/page.tsx",
+	since: FRAMES_RELEASE,
+	content: EDITOR_PAGE,
+	earlier: []
+}];
+//#endregion
+export { EDITOR_PAGE as n, NEXT_SITE_FILES as r, ADMIN_PAGE as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/next",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Goodfellow pages and the admin panel in a Next.js site.",
   "keywords": [
     "goodfellow",
@@ -38,6 +38,11 @@
       "import": "./dist/admin.js",
       "default": "./dist/admin.js"
     },
+    "./editor": {
+      "types": "./dist/editor.d.ts",
+      "import": "./dist/editor.js",
+      "default": "./dist/editor.js"
+    },
     "./export": {
       "types": "./dist/export.d.ts",
       "import": "./dist/export.js",
@@ -58,31 +63,33 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/ai": "0.4.0",
-    "@goodfellow-cms/react": "0.4.0",
-    "@goodfellow-cms/core": "0.4.0"
+    "@goodfellow-cms/ai": "0.6.0",
+    "@goodfellow-cms/core": "0.6.0",
+    "@goodfellow-cms/react": "0.6.0",
+    "rolldown": "1.2.12"
   },
   "peerDependencies": {
+    "@goodfellow-cms/admin": "0.6.0",
     "@puckeditor/core": "0.23.0",
     "next": "^16.0.0",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "@goodfellow-cms/admin": "0.4.0"
+    "react-dom": "^19.0.0"
   },
   "devDependencies": {
+    "@goodfellow-cms/admin": "0.6.0",
+    "@goodfellow-cms/bitbucket": "0.6.0",
+    "@goodfellow-cms/github": "0.6.0",
+    "@goodfellow-cms/gitlab": "0.6.0",
     "@puckeditor/core": "0.23.0",
     "@tailwindcss/browser": "4.3.3",
     "@types/react": "^19.2.0",
     "@types/react-dom": "^19.2.0",
-    "next": "16.3.8",
+    "next": "16.4.3",
     "react": "19.3.0",
-    "react-dom": "19.3.0",
-    "@goodfellow-cms/admin": "0.4.0",
-    "@goodfellow-cms/github": "0.4.0",
-    "@goodfellow-cms/gitlab": "0.4.0"
+    "react-dom": "19.3.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": "^22.23.4 || ^24.22.1 || >=26.12.1"
   },
   "publishConfig": {
     "access": "public"