create-nextly-app 0.0.2-alpha.73 → 0.0.2-alpha.74

package/dist/{create-nextly-Q62KZJib.cjs → create-nextly-Decg8dye.cjs}

@@ -45986,41 +45986,56 @@ const SEARCH_INDEX_SCRIPT = path.default.join("scripts", "build-search-index.mjs
 async function projectHasSearchIndexScript(targetDir) {
 	return import_lib$1.default.pathExists(path.default.join(targetDir, SEARCH_INDEX_SCRIPT));
 }
-/**
-* The plugins a Nextly config registers, by package name: each binding it
-* imports from a `@nextlyhq/plugin-*` package (the SDK aside) that a
-* `plugins: [...]` list in it names, however deep in an element. Read with
-* the parser the Next config step uses, so nested brackets, either quote and
-* default or aliased imports are read as the compiler reads them. First-party
-* plugins register under their package name, which is what
-* `nextly plugins install` takes. Throws for a config that does not parse,
-* since every template's must.
-*
-* Exported for the test that holds every template's config to its build.
-*/
-function configuredPlugins(configText, file = "nextly.config.ts") {
-	let program;
+/** Parses a config, naming the file when it does not parse. */
+function parseConfigProgram(configText, file) {
 	try {
-		program = (0, import_lib.parse)(configText, {
+		return (0, import_lib.parse)(configText, {
 			sourceType: "module",
 			plugins: ["typescript", "jsx"]
 		}).program;
 	} catch (error) {
 		throw new Error(`${file} cannot be parsed (${error.message}), so the plugins its build must install cannot be read.`);
 	}
-	const fromPackage = /* @__PURE__ */ new Map();
+}
+/** Each binding imported from a module `matches` accepts, to that module's name. */
+function bindingsImportedFrom(program, matches) {
+	const bindings = /* @__PURE__ */ new Map();
 	for (const statement of program.body) {
 		if (statement.type !== "ImportDeclaration") continue;
-		const pkg = statement.source.value;
-		if (!pkg.startsWith("@nextlyhq/plugin-") || pkg === "@nextlyhq/plugin-sdk") continue;
-		for (const specifier of statement.specifiers) fromPackage.set(specifier.local.name, pkg);
+		if (!matches(statement.source.value)) continue;
+		for (const specifier of statement.specifiers) bindings.set(specifier.local.name, statement.source.value);
 	}
-	const found = [];
+	return bindings;
+}
+const isPluginPackage = (source) => source.startsWith("@nextlyhq/plugin-") && source !== "@nextlyhq/plugin-sdk";
+/** What a config's `plugins` lists hold: the packages, and whether a binding from its own source is among them. */
+function readPluginLists(configText, file) {
+	const program = parseConfigProgram(configText, file);
+	const fromPackage = bindingsImportedFrom(program, isPluginPackage);
+	const packages = /* @__PURE__ */ new Set();
 	for (const name of identifiersInPluginLists(program, file)) {
 		const pkg = fromPackage.get(name);
-		if (pkg !== void 0 && !found.includes(pkg)) found.push(pkg);
+		if (pkg !== void 0) packages.add(pkg);
 	}
-	return found;
+	const local = bindingsImportedFrom(program, (source) => source.startsWith("."));
+	const ownPlugin = namesInPluginEntries(program, file).some((name) => local.has(name) && !fromPackage.has(name));
+	return {
+		packages: [...packages],
+		ownPlugin
+	};
+}
+/**
+* The `nextly plugins install` steps a project's build runs, read from its
+* config. A plugin package is installed by name, and the build says which. A
+* plugin the site wrote itself has no package name to give, and a production
+* boot refuses it like any other when nothing has installed it, so a config
+* that lists one installs with `--all`, which reads the names from the config.
+* Exported for the test that holds every template's config to its build.
+*/
+function pluginInstallSteps(configText, file = "nextly.config.ts") {
+	const { packages, ownPlugin } = readPluginLists(configText, file);
+	if (ownPlugin) return ["nextly plugins install --all"];
+	return packages.map((pkg) => `nextly plugins install ${pkg}`);
 }
 /** Every identifier inside the value of each `plugins: [...]` property, in source order. */
 function identifiersInPluginLists(program, file) {
@@ -46034,6 +46049,20 @@ function identifiersInPluginLists(program, file) {
 	return names;
 }
 /**
+* The binding each entry of a `plugins: [...]` list is, as written: `seo` for
+* `seo` or `seo({ ... })`. Narrower than {@link identifiersInPluginLists},
+* which also sees the identifiers inside an entry's options.
+*/
+function namesInPluginEntries(program, file) {
+	const names = [];
+	walkNodes(program, (node) => {
+		if (!isPluginList(node, file) || node.value.type !== "ArrayExpression") return;
+		for (const element of node.value.elements) if (element?.type === "Identifier") names.push(element.name);
+		else if (element?.type === "CallExpression" && element.callee.type === "Identifier") names.push(element.callee.name);
+	});
+	return names;
+}
+/**
 * A `plugins: [...]` property, by an identifier or a string key. A `plugins`
 * property written any other way, such as a variable holding the list, a call
 * or a spread inside it, is
@@ -46065,16 +46094,15 @@ function isNode(value) {
 	return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 /**
-* The plugins the scaffolded PROJECT's config registers, read from the
-* finished project as {@link projectHasSearchIndexScript} is: a template
-* offers more than one config (the blog's visual one registers none), so
-* only the file the copy wrote can say. None when there is no config, or
-* no project on disk to ask.
+* The plugin install steps the scaffolded PROJECT's build needs, read from
+* the finished project as {@link projectHasSearchIndexScript} is: a template
+* offers more than one config, so only the file the copy wrote can say. None
+* when there is no config, or no project on disk to ask.
 */
-async function projectPlugins(targetDir) {
+async function projectPluginInstalls(targetDir) {
 	if (targetDir === void 0) return [];
 	const config = path.default.join(targetDir, "nextly.config.ts");
-	return await import_lib$1.default.pathExists(config) ? configuredPlugins(await import_lib$1.default.readFile(config, "utf-8"), config) : [];
+	return await import_lib$1.default.pathExists(config) ? pluginInstallSteps(await import_lib$1.default.readFile(config, "utf-8"), config) : [];
 }
 /**
 * Every file under `root` that could carry an import specifier.
@@ -46667,7 +46695,7 @@ async function generatePackageJson(projectName, database, source = nextlySource(
 		esbuild: PINNED_VERSIONS.esbuild
 	};
 	const shipsSearchIndex = targetDir ? await projectHasSearchIndexScript(targetDir) : false;
-	const plugins = await projectPlugins(targetDir);
+	const pluginInstalls = await projectPluginInstalls(targetDir);
 	if (shipsSearchIndex) devDependencies.pagefind = "^1.1.0";
 	const pkg = {
 		name: projectName,
@@ -46677,7 +46705,7 @@ async function generatePackageJson(projectName, database, source = nextlySource(
 			dev: "next dev --turbopack",
 			build: [
 				"nextly migrate",
-				...plugins.map((plugin) => `nextly plugins install ${plugin}`),
+				...pluginInstalls,
 				"next build",
 				...shipsSearchIndex ? ["node scripts/build-search-index.mjs"] : []
 			].join(" && "),
@@ -47333,6 +47361,15 @@ const ADMIN_LAYOUT = {
 	path: "admin/[[...params]]/layout.tsx",
 	importsConfig: true
 };
+/**
+* The admin component map's two generated files, under the app's source root,
+* as the base template commits them: the admin layout imports the list, and
+* the admin page imports the map that registers the components. Read with the
+* routes, so an app Nextly is added to starts from the template's own empty
+* map rather than a second one written out here, and `next dev` rewrites them
+* as plugins are added.
+*/
+const ADMIN_COMPONENT_MAP_FILES = ["types/generated/plugin-admin-components.generated.ts", "types/generated/plugin-admin-imports.generated.ts"];
 /** Every file the existing-app path writes from the templates, read together. */
 const ALL_ROUTES = [
 	...ROUTES,
@@ -47438,6 +47475,15 @@ async function readMediaRouteTemplates(templatesDir = resolveTemplatePath()) {
 		if (route.importsConfig && !CONFIG_IMPORT.test(text)) throw new Error(`The template's ${route.path} does not import the Nextly config, so no route that finds it can be written. Nothing was installed or written.`);
 		texts.set(route.path, text);
 	}
+	for (const file of ADMIN_COMPONENT_MAP_FILES) {
+		const relative = `base/src/${file}`;
+		try {
+			texts.set(file, await import_lib$1.default.readFile(path.default.join(templatesDir, relative), "utf-8"));
+		} catch (error) {
+			const code = error.code ?? "unreadable";
+			throw new Error(`The templates at ${templatesDir} have no readable ${relative} (${code}), so Nextly's admin component map cannot be added. Nothing was installed or written; check the --local-template path if one was given.`);
+		}
+	}
 	return texts;
 }
 /**
@@ -47888,10 +47934,71 @@ function skipped(cwd, left, target, text, role, reason) {
 function toPosix(p) {
 	return p.split(path.default.sep).join("/");
 }
+// src/generators/types.ts
+/**
+* Where the generated types file goes, relative to the project root: under
+* src/ when the app keeps its code there, at the root when it does not. The
+* config names this path and the types step creates it, so both read it here.
+*/
+function typesOutputFile(projectInfo) {
+	return `${projectInfo.srcDir ? "./src" : "."}/types/generated/nextly-types.ts`;
+}
+/**
+* The folder the generated files go in, relative to the project root, as
+* {@link typesOutputFile} names it: the admin layout and page import the
+* component map from here.
+*/
+function typesOutputFolder(projectInfo) {
+	return path.default.posix.dirname(path.default.posix.normalize(typesOutputFile(projectInfo)));
+}
+/**
+* Create the types directory structure for generated TypeScript types.
+* This mirrors what `nextly init` does - creates the directory and a placeholder file.
+* The actual types are generated when running `next dev` (which boots Nextly
+* and emits types lazily) or `npx nextly generate:types`.
+*/
+async function generateTypesDirectory(cwd, projectInfo, templates) {
+	const files = nothingYet();
+	const typesFile = path.default.posix.normalize(typesOutputFile(projectInfo));
+	const typesDir = typesOutputFolder(projectInfo);
+	await writeNew(cwd, `${typesDir}/.gitkeep`, "", files, { why: "it is already there" });
+	await writeNew(cwd, typesFile, `/**
+ * Nextly Generated Types
+ *
+ * This file will be auto-generated when you run:
+ *   next dev          (Nextly emits types on first boot)
+ *   npx nextly generate:types
+ *
+ * Do not edit this file manually - it will be overwritten.
+ */
+
+// Types will be generated here after running next dev
+export {};
+`, files, { why: "it is already there; Nextly writes the types into it when they are generated" });
+	for (const file of ADMIN_COMPONENT_MAP_FILES) {
+		const text = templates.get(file);
+		if (text === void 0) throw new Error(`The templates read for this app hold no ${file}, so Nextly's admin component map cannot be written.`);
+		await writeNew(cwd, `${typesDir}/${path.default.posix.basename(file)}`, text, files, { why: "it is already there; `next dev` and `nextly generate:types` keep it current" });
+	}
+	return files;
+}
 // src/generators/admin.ts
-const ADMIN_PAGE_TEMPLATE = `"use client";
+/**
+* The generated component map's two files, by the name a module imports them
+* as: the list the layout reads, and the map the page loads to register the
+* components.
+*/
+const COMPONENT_LIST = "plugin-admin-components.generated";
+const COMPONENT_MAP = "plugin-admin-imports.generated";
+/** How the file at `target` imports `name` from the app's generated types folder. */
+function generatedImport(cwd, target, projectInfo, name) {
+	const relative = path.default.relative(path.default.dirname(target), path.default.join(cwd, typesOutputFolder(projectInfo), name)).split(path.default.sep).join("/");
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+const adminPageTemplate = (componentMap) => `"use client";
 
 import "@nextlyhq/admin/style.css";
+import "${componentMap}";
 import { RootLayout, QueryProvider, ErrorBoundary } from "@nextlyhq/admin";
 
 export default function AdminPage() {
@@ -47910,14 +48017,16 @@ export default function AdminPage() {
 `;
 /**
 * The admin layout, as the base template holds it, with its config import
-* pointing at the project's `nextly.config` from where the layout is written.
-* One source with a new project's layout, so an app Nextly is added to gets
-* the same per-request admin.
+* pointing at the project's `nextly.config`, and its component-list import at
+* the app's generated types folder, from where the layout is written. One
+* source with a new project's layout, so an app Nextly is added to gets the
+* same per-request admin.
 */
-function adminLayout(cwd, adminDir, templates) {
+function adminLayout(cwd, adminDir, projectInfo, templates) {
 	const text = templates.get(ADMIN_LAYOUT.path);
 	if (text === void 0) throw new Error(`The templates read for this app hold no ${ADMIN_LAYOUT.path}, so Nextly's admin layout cannot be written.`);
-	return withRelativeConfigImport(text, cwd, path.default.join(cwd, adminDir, "layout.tsx"), ADMIN_LAYOUT.path);
+	const target = path.default.join(cwd, adminDir, "layout.tsx");
+	return withRelativeConfigImport(text, cwd, target, ADMIN_LAYOUT.path).replace(new RegExp(`"[^"]*/${COMPONENT_LIST.replaceAll(".", "\\.")}"`), `"${generatedImport(cwd, target, projectInfo, COMPONENT_LIST)}"`);
 }
 /**
 * Generate the admin panel page and layout.
@@ -47926,56 +48035,23 @@ function adminLayout(cwd, adminDir, templates) {
 async function generateAdminPage(cwd, projectInfo, templates) {
 	const files = nothingYet();
 	const adminDir = `${projectInfo.appDir}/admin/[[...params]]`;
-	const layout = adminLayout(cwd, adminDir, templates);
+	const layout = adminLayout(cwd, adminDir, projectInfo, templates);
+	const page = adminPageTemplate(generatedImport(cwd, path.default.join(cwd, adminDir, "page.tsx"), projectInfo, COMPONENT_MAP));
 	const pages = await appPageExtensions(cwd);
 	if (pages.extensions !== "absent") {
 		const { configName, extensions } = pages;
-		for (const [name, text] of [["page", ADMIN_PAGE_TEMPLATE], ["layout", layout]]) files.skipped.push(pageExtensionsSkip(`${adminDir}/${name}`, text, {
+		for (const [name, text] of [["page", page], ["layout", layout]]) files.skipped.push(pageExtensionsSkip(`${adminDir}/${name}`, text, {
 			configName,
 			extensions
 		}, TSX_FILE));
 		return files;
 	}
-	for (const [name, text] of [["page.tsx", ADMIN_PAGE_TEMPLATE], ["layout.tsx", layout]]) await writeNew(cwd, `${adminDir}/${name}`, text, files, {
+	for (const [name, text] of [["page.tsx", page], ["layout.tsx", layout]]) await writeNew(cwd, `${adminDir}/${name}`, text, files, {
 		why: `the app already has one; Nextly's admin needs its own ${name}, which is`,
 		toAdd: text
 	});
 	return files;
 }
-// src/generators/types.ts
-/**
-* Where the generated types file goes, relative to the project root: under
-* src/ when the app keeps its code there, at the root when it does not. The
-* config names this path and the types step creates it, so both read it here.
-*/
-function typesOutputFile(projectInfo) {
-	return `${projectInfo.srcDir ? "./src" : "."}/types/generated/nextly-types.ts`;
-}
-/**
-* Create the types directory structure for generated TypeScript types.
-* This mirrors what `nextly init` does - creates the directory and a placeholder file.
-* The actual types are generated when running `next dev` (which boots Nextly
-* and emits types lazily) or `npx nextly generate:types`.
-*/
-async function generateTypesDirectory(cwd, projectInfo) {
-	const files = nothingYet();
-	const typesFile = path.default.posix.normalize(typesOutputFile(projectInfo));
-	await writeNew(cwd, `${path.default.posix.dirname(typesFile)}/.gitkeep`, "", files, { why: "it is already there" });
-	await writeNew(cwd, typesFile, `/**
- * Nextly Generated Types
- *
- * This file will be auto-generated when you run:
- *   next dev          (Nextly emits types on first boot)
- *   npx nextly generate:types
- *
- * Do not edit this file manually - it will be overwritten.
- */
-
-// Types will be generated here after running next dev
-export {};
-`, files, { why: "it is already there; Nextly writes the types into it when they are generated" });
-	return files;
-}
 // src/generators/config.ts
 /**
 * Base templates for project types that use inline config generation.
@@ -48208,7 +48284,7 @@ async function generateIntoExistingApp(cwd, projectType, projectInfo, database,
 		await generateMediaRoutes(cwd, projectInfo, templates),
 		await generateUploadsRoute(cwd, projectInfo, templates),
 		await generateInstrumentation(cwd, projectInfo),
-		await generateTypesDirectory(cwd, projectInfo),
+		await generateTypesDirectory(cwd, projectInfo, templates),
 		nextConfigFiles(await patchNextConfig(cwd, database)),
 		cacheComponentsFiles(await turnOnCacheComponents(cwd))
 	];
@@ -53074,4 +53150,4 @@ Object.defineProperty(exports, "validateTemplateName", {
 	}
 });
 
-//# sourceMappingURL=create-nextly-Q62KZJib.cjs.map
+//# sourceMappingURL=create-nextly-Decg8dye.cjs.map