@forgebook/nuxt 0.0.0-stage → 0.2.0

package/dist/src/vite/nuxtConfig.js

@@ -0,0 +1,261 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * The project's `nuxt.config`, as far as a catalogue reads it: its folders, its aliases, its components' and
+ * auto-imports' folders, its style sheets, its public runtime config and its app config.
+ *
+ * @remarks
+ * The file is loaded as Node loads a module (a `nuxt.config.ts` with its types stripped), with `defineNuxtConfig`
+ * given as Nuxt gives it, a function that returns its argument; what it returns is read, never trusted: a field of the
+ * wrong type is left out. Everything else in it (modules, Nitro, the server's routes, the build) concerns Nuxt's server
+ * or its own build, so a story does not need it. A file that cannot be loaded is a warning, not a failure: the
+ * catalogue still opens with Nuxt's defaults.
+ *
+ * The runtime config keeps its `public` part only, since that is all Nuxt sends to the browser; a `NUXT_PUBLIC_`
+ * variable of the environment or the `.env` files replaces the value it names, as Nuxt's does.
+ *
+ * Every path it gives is in Vite's form, with forward slashes on every system: the plugin compares them with the ids
+ * Vite hands it and writes them into the modules it makes, which on Windows would not meet a path with backslashes.
+ *
+ * @module
+ */
+import { existsSync, statSync } from "node:fs";
+import nodePath from "node:path";
+import { pathToFileURL } from "node:url";
+import { normalizePath } from "vite";
+/** The names `nuxt.config` may have, in the order Nuxt looks for them. */
+export const NUXT_CONFIG_FILES = [
+    "nuxt.config.ts",
+    "nuxt.config.mts",
+    "nuxt.config.js",
+    "nuxt.config.mjs",
+    "nuxt.config.cjs"
+];
+/** The names `app.config` may have. */
+const APP_CONFIG_FILES = ["app.config.ts", "app.config.mts", "app.config.js", "app.config.mjs"];
+/** The global function a `nuxt.config` calls without importing it. */
+const DEFINE_CONFIG = "defineNuxtConfig";
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * An object field, or an empty object.
+ *
+ * @param config - the object.
+ * @param name - the field.
+ */
+const objectField = (config, name) => {
+    const value = config[name];
+    return isRecord(value) ? value : {};
+};
+/**
+ * A text field, or none.
+ *
+ * @param config - the object.
+ * @param name - the field.
+ */
+const textField = (config, name) => {
+    const value = config[name];
+    return typeof value === "string" ? value : undefined;
+};
+/** `path.join`, in Vite's form. */
+const join = (...segments) => normalizePath(nodePath.join(...segments));
+/** `path.resolve`, in Vite's form. */
+const resolve = (...segments) => normalizePath(nodePath.resolve(...segments));
+/** Whether a path is a folder. */
+const isFolder = (path) => existsSync(path) && statSync(path).isDirectory();
+/**
+ * A path as Nuxt resolves one written in its config: `~`, `@`, `~~` and `@@` replaced, a relative path from the
+ * project's folder, a package left as it is.
+ *
+ * @param path - the path.
+ * @param rootDir - the project's folder.
+ * @param srcDir - its sources' folder.
+ */
+export const resolvedPath = (path, rootDir, srcDir) => {
+    const root = /^(~~|@@)(?=\/|$)/.exec(path);
+    if (root !== null)
+        return join(rootDir, path.slice(root[0].length));
+    const src = /^(~|@)(?=\/|$)/.exec(path);
+    if (src !== null)
+        return join(srcDir, path.slice(src[0].length));
+    if (nodePath.isAbsolute(path))
+        return normalizePath(path);
+    if (path.startsWith("."))
+        return resolve(rootDir, path);
+    return path;
+};
+/**
+ * A folder of `imports.dirs`: an alias as Nuxt resolves it, anything else from the sources' folder, as Nuxt reads it.
+ *
+ * @param path - the folder, as written.
+ * @param rootDir - the project's folder.
+ * @param srcDir - its sources' folder.
+ */
+const importsDir = (path, rootDir, srcDir) => {
+    const resolved = resolvedPath(path, rootDir, srcDir);
+    return nodePath.isAbsolute(resolved) && resolved !== resolve(rootDir, path)
+        ? resolved
+        : resolve(srcDir, path);
+};
+/**
+ * The components' folders a config gives: `components/` of the sources by default, none for `false`, else each entry
+ * of the list (or of `dirs`), a path or `{ path, prefix, pathPrefix }`.
+ *
+ * @param value - `components`.
+ * @param rootDir - the project's folder.
+ * @param srcDir - its sources' folder.
+ */
+const componentsDirsOf = (value, rootDir, srcDir) => {
+    if (value === false)
+        return [];
+    const entries = isRecord(value) ? value["dirs"] : value;
+    // Nuxt's own: the islands' and the global folders inside the components' one, each scanned before it
+    const list = Array.isArray(entries)
+        ? entries
+        : ["~/components/islands", "~/components/global", "~/components"];
+    return list.flatMap((entry) => {
+        if (typeof entry === "string")
+            return [{ path: resolvedPath(entry, rootDir, srcDir), prefix: "", pathPrefix: true }];
+        if (!isRecord(entry))
+            return [];
+        const path = textField(entry, "path");
+        if (path === undefined)
+            return [];
+        return [
+            {
+                path: resolvedPath(path, rootDir, srcDir),
+                prefix: textField(entry, "prefix") ?? "",
+                pathPrefix: entry["pathPrefix"] !== false
+            }
+        ];
+    });
+};
+/**
+ * What a catalogue reads of a configuration Nuxt would read.
+ *
+ * @param raw - what the file exported.
+ * @param file - the file.
+ * @param projectDir - the project's folder.
+ */
+export const readNuxtConfig = (raw, file, projectDir) => {
+    const rootDir = normalizePath(projectDir);
+    const config = isRecord(raw) ? raw : {};
+    const srcGiven = textField(config, "srcDir");
+    // Nuxt 4 keeps the sources in `app/`; a project laid out as Nuxt 3's has them at its root
+    const nuxt4Dir = join(rootDir, "app");
+    const defaultDir = isFolder(nuxt4Dir) ? nuxt4Dir : rootDir;
+    const srcDir = srcGiven === undefined ? defaultDir : resolve(rootDir, srcGiven);
+    const dir = objectField(config, "dir");
+    const app = objectField(config, "app");
+    const imports = objectField(config, "imports");
+    const extraImports = imports["dirs"];
+    const css = config["css"];
+    const appConfigFile = APP_CONFIG_FILES.map((name) => join(srcDir, name)).find((path) => existsSync(path));
+    return {
+        file,
+        rootDir,
+        srcDir,
+        pagesDir: join(srcDir, textField(dir, "pages") ?? "pages"),
+        alias: {
+            ...Object.fromEntries(Object.entries(objectField(config, "alias")).flatMap(([name, path]) => typeof path === "string" ? [[name, resolvedPath(path, rootDir, srcDir)]] : []))
+        },
+        componentsDirs: componentsDirsOf(config["components"], rootDir, srcDir),
+        importsDirs: [
+            join(srcDir, "composables"),
+            join(srcDir, "utils"),
+            join(rootDir, "shared", "utils"),
+            ...(Array.isArray(extraImports)
+                ? extraImports.flatMap((each) => typeof each === "string" ? [importsDir(each, rootDir, srcDir)] : [])
+                : [])
+        ],
+        isAutoImport: imports["autoImport"] !== false,
+        css: Array.isArray(css)
+            ? css.flatMap((each) => typeof each === "string" ? [resolvedPath(each, rootDir, srcDir)] : [])
+            : [],
+        publicRuntimeConfig: objectField(objectField(config, "runtimeConfig"), "public"),
+        baseURL: textField(app, "baseURL") ?? "/",
+        buildAssetsDir: textField(app, "buildAssetsDir") ?? "/_nuxt/",
+        appConfig: objectField(config, "appConfig"),
+        appConfigFile
+    };
+};
+/**
+ * The project's `nuxt.config` file: the first Nuxt would find in its folder.
+ *
+ * @param rootDir - the project's folder.
+ */
+export const nuxtConfigFile = (rootDir) => NUXT_CONFIG_FILES.map((name) => join(rootDir, name)).find((file) => existsSync(file));
+/**
+ * Loads a project's `nuxt.config`.
+ *
+ * @param rootDir - the project's folder.
+ * @returns what the catalogue reads of it, and why it could not be loaded when it could not.
+ */
+export const loadNuxtConfig = async (rootDir) => {
+    const file = nuxtConfigFile(rootDir);
+    if (file === undefined)
+        return { config: readNuxtConfig({}, undefined, rootDir), problem: undefined };
+    // Nuxt gives the file this function without an import; one the project already has (Nuxt's own) is left as it is
+    const isGiven = !(DEFINE_CONFIG in globalThis);
+    if (isGiven)
+        Reflect.set(globalThis, DEFINE_CONFIG, (config) => config);
+    try {
+        const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        const exported = isRecord(loaded) && "default" in loaded ? loaded["default"] : loaded;
+        const raw = typeof exported === "function" ? await Reflect.apply(exported, undefined, []) : exported;
+        return { config: readNuxtConfig(raw, file, rootDir), problem: undefined };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { config: readNuxtConfig({}, file, rootDir), problem: `${file} could not be loaded (${reason})` };
+    }
+    finally {
+        if (isGiven)
+            Reflect.deleteProperty(globalThis, DEFINE_CONFIG);
+    }
+};
+/**
+ * A key as Nuxt writes it in a variable's name: `apiBase` as `API_BASE`.
+ *
+ * @param key - the key.
+ */
+const envName = (key) => key
+    .replace(/([a-z\d])([A-Z])/g, "$1_$2")
+    .replace(/[-.]/g, "_")
+    .toUpperCase();
+/**
+ * A variable's value as Nuxt reads it: JSON when it is (a number, a boolean, an object), else the text.
+ *
+ * @param value - the variable's value.
+ */
+const envValue = (value) => {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed;
+    }
+    catch {
+        return value;
+    }
+};
+/**
+ * The public runtime config with the environment's variables over it: `NUXT_PUBLIC_API_BASE` replaces
+ * `public.apiBase`, a nested key adding its name (`NUXT_PUBLIC_MAP_KEY` for `public.map.key`). Only a key the config
+ * has is replaced, as Nuxt replaces it.
+ *
+ * @param config - the config's `public` part.
+ * @param env - the variables, by name.
+ * @param prefix - the variables' prefix for this level; `NUXT_PUBLIC_` at the top.
+ */
+export const withEnvironment = (config, env, prefix = "NUXT_PUBLIC_") => Object.fromEntries(Object.entries(config).map(([key, value]) => {
+    const name = `${prefix}${envName(key)}`;
+    const given = env[name];
+    if (given !== undefined)
+        return [key, envValue(given)];
+    return [key, isRecord(value) ? withEnvironment(value, env, `${name}_`) : value];
+}));

package/dist/src/vite/nuxtPlugin.d.ts

@@ -0,0 +1,51 @@
+import MagicString from "magic-string";
+import { type PluginOption } from "vite";
+import { type ProjectComponent } from "./componentNames.ts";
+import type { NuxtOptions } from "./nuxt.ts";
+import { type NuxtProjectConfig } from "./nuxtConfig.ts";
+/** The frame page's module: Forgebook's frame with the Nuxt renderer, after the project's style sheets. */
+export declare const FRAME_MODULE = "virtual:forgebook-nuxt/frame";
+/**
+ * The project's components, by name: the first folder that names one wins, as in Nuxt. A file whose name makes no
+ * JavaScript name (`a;b.vue`) is left out, since its name is written into code.
+ *
+ * @param config - the project's config.
+ */
+export declare const componentsOf: (config: NuxtProjectConfig) => {
+    readonly components: Map<string, ProjectComponent>;
+    readonly skipped: string[];
+};
+/**
+ * A template's components given their imports, as Nuxt's loader writes them: Nuxt's own, the project's, and a project
+ * component's `Lazy` form loaded when it is first drawn.
+ *
+ * @param code - the compiled component.
+ * @param components - the project's components, by name.
+ * @returns the code changed, or none when it names no component the plugin knows.
+ */
+export declare const withComponentImports: (code: MagicString, components: ReadonlyMap<string, ProjectComponent>) => MagicString | undefined;
+/**
+ * Nuxt 3's `process.client`, `process.server`, `process.browser` and `process.dev` written as their values in a
+ * project's file. Only there: given to the whole page (Vite's `define`), they would reach the libraries the frame
+ * loads, and one that reads `process.browser` would then read `process.env`, which the page does not have.
+ *
+ * @param code - the file's code, changed in place.
+ * @param isDev - whether the catalogue runs in development.
+ * @returns whether one was written.
+ */
+export declare const withProcessFlags: (code: MagicString, isDev: boolean) => boolean;
+/**
+ * Whether a file is one of the project's own: inside its folder, not in a folder beside it whose name starts the same
+ * (`app-admin` beside `app`).
+ *
+ * @param file - the file, as Vite names it.
+ * @param rootDir - the project's folder.
+ */
+export declare const isProjectFile: (file: string, rootDir: string) => boolean;
+/**
+ * The plugins of a Nuxt catalogue.
+ *
+ * @param options - the options of `nuxt()`.
+ * @returns the plugins.
+ */
+export declare const nuxtPlugins: (options?: NuxtOptions) => PluginOption[];