@forgebook/nuxt 0.0.0-stage → 0.2.1

package/dist/src/stories.js

@@ -0,0 +1,11 @@
+/**
+ * The story types for a Nuxt project: Vue's, with the `parameters.nuxt` a story sets its route, data, state, cookies and
+ * config with (`import type { Meta, Story } from "@forgebook/nuxt"`).
+ *
+ * @remarks
+ * Types only. `route` is a path or a location by path or by name, resolved against the project's pages
+ * (`{ name: "blog-slug", params: { slug: "hello" } }` or `/blog/hello`); `data` is what `useAsyncData` and `useFetch`
+ * return by key instead of calling their handler (`useFetch`'s key is the request as it is made, its URL with its query, unless it is given one).
+ *
+ * @module
+ */

package/dist/src/storyCode.d.ts

@@ -0,0 +1,3 @@
+import type { StoryCodeWriter } from "forgebook/renderer";
+/** Writes a story drawn from its args as a template, as Vue's adapter writes it. */
+export declare const codeOf: StoryCodeWriter;

package/dist/src/storyCode.js

@@ -0,0 +1,9 @@
+/**
+ * The code writer of a Nuxt catalogue: Vue's template writer, since a Nuxt story is a Vue story. The shell's page
+ * imports it from this package, which a Nuxt catalogue installs, rather than from `@forgebook/vue`, which it need not.
+ *
+ * @module
+ */
+import { codeOf as vueCodeOf } from "@forgebook/vue/code";
+/** Writes a story drawn from its args as a template, as Vue's adapter writes it. */
+export const codeOf = vueCodeOf;

package/dist/src/storyFetch.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Nuxt's `$fetch` in a catalogue: the browser's `fetch` with what ofetch, Nuxt's `$fetch`, adds that a component relies
+ * on: the app's base path, a query, a body sent as JSON, the answer read as JSON or text, and an error that carries the
+ * status and the answer's data when the status is not a success.
+ *
+ * @remarks
+ * Written on `fetch` rather than taking ofetch, so a catalogue's page loads nothing it would have to find in the
+ * project's installed packages, and the catalogue's MSW handlers answer it as they answer `fetch`. ofetch's retries
+ * and interceptors are left out: a story's answers come at once.
+ *
+ * @module
+ */
+/** A query's values, by name. */
+export type FetchQuery = Readonly<Record<string, unknown>>;
+/** What `$fetch` takes besides the address. */
+export type StoryFetchOptions = {
+    /** The method; GET by default. */
+    readonly method?: string;
+    /** The search params, by name: a list repeats its name, `undefined` is left out. */
+    readonly query?: FetchQuery;
+    /** `query`'s other name. */
+    readonly params?: FetchQuery;
+    /** The body: an object or an array is sent as JSON. */
+    readonly body?: unknown;
+    /** The headers. */
+    readonly headers?: HeadersInit;
+    /** What a relative address is resolved against; the app's base path by default. */
+    readonly baseURL?: string;
+    /** How the answer is read; from its content type by default. */
+    readonly responseType?: "json" | "text" | "blob" | "arrayBuffer";
+    /** What aborts the request. */
+    readonly signal?: AbortSignal;
+};
+/** The error of an answer whose status is not a success. */
+export declare class FetchError extends Error {
+    /** The answer's status. */
+    readonly statusCode: number;
+    /** The answer's status text. */
+    readonly statusMessage: string;
+    /** The answer's body, read. */
+    readonly data: unknown;
+    /**
+     * The error of an answer.
+     *
+     * @param address - the address asked.
+     * @param response - the answer.
+     * @param data - its body, read.
+     */
+    constructor(address: string, response: Response, data: unknown);
+}
+/** Fetches an address, as Nuxt's `$fetch`. */
+export type StoryFetch = <TResult = unknown>(address: string, options?: StoryFetchOptions) => Promise<TResult>;
+/**
+ * An address with its base and query: a relative one resolved against the base, as ofetch does.
+ *
+ * @param address - the address.
+ * @param baseURL - the base.
+ * @param query - the search params.
+ */
+export declare const fetchAddress: (address: string, baseURL: string, query: FetchQuery) => string;
+/**
+ * An address with a query after it: a list repeats its name, `undefined` is left out.
+ *
+ * @param address - the address, which may have a search of its own.
+ * @param query - the search params.
+ */
+export declare const withSearch: (address: string, query: FetchQuery) => string;
+/**
+ * `$fetch` with a base path.
+ *
+ * @param baseURL - the app's base path.
+ * @returns the function.
+ */
+export declare const createStoryFetch: (baseURL: string) => StoryFetch;

package/dist/src/storyFetch.js

@@ -0,0 +1,146 @@
+/**
+ * Nuxt's `$fetch` in a catalogue: the browser's `fetch` with what ofetch, Nuxt's `$fetch`, adds that a component relies
+ * on: the app's base path, a query, a body sent as JSON, the answer read as JSON or text, and an error that carries the
+ * status and the answer's data when the status is not a success.
+ *
+ * @remarks
+ * Written on `fetch` rather than taking ofetch, so a catalogue's page loads nothing it would have to find in the
+ * project's installed packages, and the catalogue's MSW handlers answer it as they answer `fetch`. ofetch's retries
+ * and interceptors are left out: a story's answers come at once.
+ *
+ * @module
+ */
+/** The error of an answer whose status is not a success. */
+export class FetchError extends Error {
+    /** The answer's status. */
+    statusCode;
+    /** The answer's status text. */
+    statusMessage;
+    /** The answer's body, read. */
+    data;
+    /**
+     * The error of an answer.
+     *
+     * @param address - the address asked.
+     * @param response - the answer.
+     * @param data - its body, read.
+     */
+    constructor(address, response, data) {
+        super(`[${response.status}] ${response.statusText} ${address}`.replace(/\s+/g, " ").trim());
+        this.name = "FetchError";
+        this.statusCode = response.status;
+        this.statusMessage = response.statusText;
+        this.data = data;
+    }
+}
+/**
+ * An address with its base and query: a relative one resolved against the base, as ofetch does.
+ *
+ * @param address - the address.
+ * @param baseURL - the base.
+ * @param query - the search params.
+ */
+export const fetchAddress = (address, baseURL, query) => {
+    const isAbsolute = /^[a-z][a-z\d+.-]*:/i.test(address) || address.startsWith("//");
+    const joined = isAbsolute ? address : `${baseURL.replace(/\/+$/, "")}/${address.replace(/^\/+/, "")}`;
+    return withSearch(joined, query);
+};
+/**
+ * An address with a query after it: a list repeats its name, `undefined` is left out.
+ *
+ * @param address - the address, which may have a search of its own.
+ * @param query - the search params.
+ */
+export const withSearch = (address, query) => {
+    const search = new URLSearchParams();
+    for (const [name, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        for (const item of Array.isArray(value) ? value : [value])
+            search.append(name, String(item));
+    }
+    const text = search.toString();
+    if (text === "")
+        return address;
+    return `${address}${address.includes("?") ? "&" : "?"}${text}`;
+};
+/**
+ * A body as `fetch` sends it: an object or an array as JSON, anything else as it is.
+ *
+ * @param body - the body.
+ */
+const sentBody = (body) => {
+    if (body === undefined || body === null)
+        return { body: undefined, isJson: false };
+    if (typeof body === "string" || body instanceof Blob || body instanceof FormData)
+        return { body, isJson: false };
+    if (body instanceof URLSearchParams || body instanceof ArrayBuffer)
+        return { body, isJson: false };
+    return { body: JSON.stringify(body), isJson: true };
+};
+/**
+ * An answer's body, read as its type or its content type says.
+ *
+ * @param response - the answer.
+ * @param type - how to read it; from the content type when none.
+ */
+const readBody = async (response, type) => {
+    if (type === "blob")
+        return response.blob();
+    if (type === "arrayBuffer")
+        return response.arrayBuffer();
+    const text = await response.text();
+    const isJson = type === "json" || (type === undefined && /json/i.test(response.headers.get("content-type") ?? ""));
+    if (!isJson || text === "")
+        return text;
+    try {
+        const parsed = JSON.parse(text);
+        return parsed;
+    }
+    catch {
+        return text;
+    }
+};
+/**
+ * A request as `fetch` takes it: its address, with its base and query, and its method, headers and body.
+ *
+ * @param address - the address.
+ * @param baseURL - the app's base path.
+ * @param options - the method, query, body, headers.
+ */
+const requestOf = (address, baseURL, options) => {
+    const url = fetchAddress(address, options.baseURL ?? baseURL, options.query ?? options.params ?? {});
+    const { body, isJson } = sentBody(options.body);
+    const headers = new Headers(options.headers);
+    if (isJson && !headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    if (!headers.has("accept"))
+        headers.set("accept", "application/json");
+    const method = options.method ?? (body === undefined ? "GET" : "POST");
+    return {
+        url,
+        init: {
+            method: method.toUpperCase(),
+            headers,
+            ...(body === undefined ? {} : { body }),
+            ...(options.signal === undefined ? {} : { signal: options.signal })
+        }
+    };
+};
+/**
+ * `$fetch` with a base path.
+ *
+ * @param baseURL - the app's base path.
+ * @returns the function.
+ */
+export const createStoryFetch = (baseURL) => {
+    async function storyFetch(address, options = {}) {
+        const { url, init } = requestOf(address, baseURL, options);
+        const response = await fetch(url, init);
+        const data = await readBody(response, options.responseType);
+        if (!response.ok)
+            throw new FetchError(url, response, data);
+        return data;
+    }
+    return storyFetch;
+};

package/dist/src/storyNuxt.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What a play function reads of a Nuxt story: where its links and router calls took it, the calls it made
+ * (`router.push`, `navigateTo`), and its state, cookies and data, to assert on.
+ *
+ * @example
+ * ```ts
+ * import { storyNuxt } from "@forgebook/nuxt/story";
+ *
+ * export const GoesToAbout: Story<typeof Nav> = {
+ *   play: async ({ canvasElement }) => {
+ *     await userEvent.click(within(canvasElement).getByRole("link", { name: "About" }));
+ *     await waitFor(() => expect(storyNuxt().route.path).toBe("/about"));
+ *   }
+ * };
+ * ```
+ *
+ * @module
+ */
+import type { LocationQuery, RouteParamsGeneric } from "vue-router";
+import { type NuxtCall } from "./nuxtStore.ts";
+/** A Nuxt story's route and what it made, as a play function reads them. */
+export type StoryNuxtState = {
+    /** Where the story is. */
+    readonly route: {
+        /** The path (`/blog/hello`). */
+        readonly path: string;
+        /** The path with its search and hash. */
+        readonly fullPath: string;
+        /** The route's name (`blog-slug`), or none for a path no page has. */
+        readonly name: string | undefined;
+        /** The route's params. */
+        readonly params: RouteParamsGeneric;
+        /** The search params. */
+        readonly query: LocationQuery;
+        /** The hash, with its `#`, or empty. */
+        readonly hash: string;
+    };
+    /** The calls the story made to Nuxt, in order. */
+    readonly calls: readonly NuxtCall[];
+    /** The values of `useState`, by key. */
+    readonly state: Readonly<Record<string, unknown>>;
+    /** The values of `useCookie`, by name. */
+    readonly cookies: Readonly<Record<string, unknown>>;
+    /** The data of `useAsyncData` and `useFetch`, by key. */
+    readonly data: Readonly<Record<string, unknown>>;
+};
+/** The route of the story drawn now, and what it made. */
+export declare const storyNuxt: () => StoryNuxtState;

package/dist/src/storyNuxt.js

@@ -0,0 +1,26 @@
+import { ANY_PATH_NAME, currentStore } from "./nuxtStore.js";
+/**
+ * The values of refs, by key.
+ *
+ * @param refs - the refs.
+ */
+const valuesOf = (refs) => Object.fromEntries([...refs].map(([key, ref]) => [key, ref.value]));
+/** The route of the story drawn now, and what it made. */
+export const storyNuxt = () => {
+    const store = currentStore();
+    const route = store.router.currentRoute.value;
+    return {
+        route: {
+            path: route.path,
+            fullPath: route.fullPath,
+            name: typeof route.name === "string" && route.name !== ANY_PATH_NAME ? route.name : undefined,
+            params: route.params,
+            query: route.query,
+            hash: route.hash
+        },
+        calls: store.calls(),
+        state: valuesOf(store.state),
+        cookies: valuesOf(store.cookies),
+        data: Object.fromEntries([...store.asyncData].map(([key, entry]) => [key, entry.data.value]))
+    };
+};

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

@@ -0,0 +1,36 @@
+/**
+ * The names Nuxt gives a project's components from their files: `components/base/Button.vue` is `BaseButton`, and
+ * `components/base/BaseButton.vue` is `BaseButton` too, the folder's part not repeated.
+ *
+ * @remarks
+ * Pure: paths in, names out, as Nuxt's components module names them: the folders' names before the file's (unless
+ * `pathPrefix: false`), the folder's `prefix` first, the words a file's name repeats from its folders dropped, an
+ * `index` file named by its folder, `.client`, `.server` and `.global` left out of the name. Stories, tests,
+ * declaration files and mixins in a components' folder are not components, as Nuxt ignores them.
+ *
+ * @module
+ */
+/** The extensions of a component. */
+export declare const COMPONENT_EXTENSIONS: RegExp;
+/** A component's name and its file. */
+export type ProjectComponent = {
+    /** Its name (`BaseButton`). */
+    readonly name: string;
+    /** Its file, absolute. */
+    readonly file: string;
+};
+/**
+ * A name split into its words, at a dash, an underscore, a dot or a change of case (`baseButton` is `base`, `Button`).
+ *
+ * @param name - the name.
+ */
+export declare const wordsOf: (name: string) => string[];
+/**
+ * A component's name, from its path in its folder.
+ *
+ * @param file - its path from the folder, with `/` (`base/Button.vue`).
+ * @param prefix - what every name of the folder starts with.
+ * @param pathPrefix - whether its folders are part of its name.
+ * @returns its name, or none for a file that is not a component.
+ */
+export declare const componentName: (file: string, prefix: string, pathPrefix: boolean) => string | undefined;

package/dist/src/vite/componentNames.js

@@ -0,0 +1,72 @@
+/**
+ * The names Nuxt gives a project's components from their files: `components/base/Button.vue` is `BaseButton`, and
+ * `components/base/BaseButton.vue` is `BaseButton` too, the folder's part not repeated.
+ *
+ * @remarks
+ * Pure: paths in, names out, as Nuxt's components module names them: the folders' names before the file's (unless
+ * `pathPrefix: false`), the folder's `prefix` first, the words a file's name repeats from its folders dropped, an
+ * `index` file named by its folder, `.client`, `.server` and `.global` left out of the name. Stories, tests,
+ * declaration files and mixins in a components' folder are not components, as Nuxt ignores them.
+ *
+ * @module
+ */
+/** The extensions of a component. */
+export const COMPONENT_EXTENSIONS = /\.(vue|tsx|jsx|ts|js|mjs)$/;
+/** Files in a components' folder that are not components. */
+const NOT_COMPONENTS = /\.(stories|story|test|spec)\.[^.]+$|\.d\.[cm]?ts$|(?:M|\.m|-m)ixin\.[jt]sx?$/;
+/**
+ * A name split into its words, at a dash, an underscore, a dot or a change of case (`baseButton` is `base`, `Button`).
+ *
+ * @param name - the name.
+ */
+export const wordsOf = (name) => name
+    .replace(/([a-z\d])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .split(/[\s\-_.]+/)
+    .filter((word) => word !== "");
+/**
+ * Words joined as a component's name: each starting with a capital.
+ *
+ * @param words - the words.
+ */
+const pascalOf = (words) => words.map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join("");
+/**
+ * The words of a component's name: its folders' words, the ones its file's name repeats at the end dropped, then the
+ * file's.
+ *
+ * @param fileWords - the file name's words.
+ * @param prefixWords - the folders' words, the prefix's first.
+ */
+const nameWords = (fileWords, prefixWords) => {
+    const file = fileWords.map((word) => word.toLowerCase());
+    // the longest end of the folders' words the file's name starts with is said once
+    for (let start = 0; start < prefixWords.length; start += 1) {
+        const end = prefixWords.slice(start).map((word) => word.toLowerCase());
+        if (end.every((word, index) => file[index] === word))
+            return [...prefixWords.slice(0, start), ...fileWords];
+    }
+    return [...prefixWords, ...fileWords];
+};
+/**
+ * A component's name, from its path in its folder.
+ *
+ * @param file - its path from the folder, with `/` (`base/Button.vue`).
+ * @param prefix - what every name of the folder starts with.
+ * @param pathPrefix - whether its folders are part of its name.
+ * @returns its name, or none for a file that is not a component.
+ */
+export const componentName = (file, prefix, pathPrefix) => {
+    if (!COMPONENT_EXTENSIONS.test(file) || NOT_COMPONENTS.test(file))
+        return undefined;
+    const parts = file
+        .replace(COMPONENT_EXTENSIONS, "")
+        .replace(/\.(client|server|global|island)$/, "")
+        .split("/");
+    const base = parts.at(-1) ?? "";
+    const folders = parts.slice(0, -1);
+    // an `index` file is named by its folder, which the folders' words then say once
+    const fileWords = wordsOf(base === "index" ? (folders.at(-1) ?? "") : base);
+    const prefixWords = [...wordsOf(prefix), ...(pathPrefix ? folders.flatMap(wordsOf) : [])];
+    const words = nameWords(fileWords, prefixWords);
+    return words.length === 0 ? undefined : pascalOf(words);
+};

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

@@ -0,0 +1,16 @@
+import type { ExtractFileComponent, ExtractStoryComponent, StoryFileShape } from "forgebook/vite/adapter";
+/** The module a new story file imports its types from. */
+export declare const storyTypesModule = "@forgebook/nuxt";
+/** Reads a story file's component, as Vue's adapter reads it. */
+export declare const extractStoryComponent: ExtractStoryComponent;
+/** Reads a component a file exports, as Vue's adapter reads it. */
+export declare const extractFileComponent: ExtractFileComponent;
+/**
+ * How `forgebook new` writes a component's stories: as Vue's adapter writes them.
+ *
+ * @param name - the component's name.
+ * @param file - the component's file, absolute.
+ */
+export declare const storyFileShape: (name: string, file: string) => StoryFileShape;
+/** The worker heard that a source changed: Vue's checkers read again on their next read. */
+export declare const sourcesChanged: () => void;

package/dist/src/vite/extractDocs.js

@@ -0,0 +1,22 @@
+/**
+ * The docs module of a Nuxt catalogue: Vue's, since a Nuxt project's components are Vue components, with the story types
+ * a new story file imports being this package's (`forgebook new` writes `@forgebook/nuxt`).
+ *
+ * @module
+ */
+import { extractFileComponent as extractVueFileComponent, extractStoryComponent as extractVueStoryComponent, sourcesChanged as vueSourcesChanged, storyFileShape as vueStoryFileShape } from "@forgebook/vue/docs";
+/** The module a new story file imports its types from. */
+export const storyTypesModule = "@forgebook/nuxt";
+/** Reads a story file's component, as Vue's adapter reads it. */
+export const extractStoryComponent = (storyFile) => extractVueStoryComponent(storyFile);
+/** Reads a component a file exports, as Vue's adapter reads it. */
+export const extractFileComponent = (file, exportName) => extractVueFileComponent(file, exportName);
+/**
+ * How `forgebook new` writes a component's stories: as Vue's adapter writes them.
+ *
+ * @param name - the component's name.
+ * @param file - the component's file, absolute.
+ */
+export const storyFileShape = (name, file) => vueStoryFileShape(name, file);
+/** The worker heard that a source changed: Vue's checkers read again on their next read. */
+export const sourcesChanged = () => vueSourcesChanged();

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

@@ -0,0 +1,13 @@
+import type { FrameworkAdapter } from "forgebook/vite/adapter";
+/** The options of `nuxt()`. */
+export type NuxtOptions = {
+    /** The Nuxt project's folder, from the catalogue's; the catalogue's own folder by default. */
+    readonly dir?: string;
+};
+/**
+ * Nuxt, as the plugin reads and draws its components.
+ *
+ * @param options - the Nuxt project's folder, when it is not the catalogue's.
+ * @returns the adapter.
+ */
+export declare const nuxt: (options?: NuxtOptions) => FrameworkAdapter;

package/dist/src/vite/nuxt.js

@@ -0,0 +1,36 @@
+/**
+ * Forgebook's adapter for Nuxt, for the Vite plugin: `defineConfig({ framework: nuxt() })`.
+ *
+ * @remarks
+ * Nuxt is Vue: the props are read as Vue's, and the stories drawn with Vue's renderer, each story's app given its Nuxt
+ * (its router, data, state and config). What Nuxt adds is Vite's work: Vue's plugin, and this package's plugin for
+ * Nuxt's aliases, auto-imports, components and `#imports` (`nuxtPlugin.ts`). Forgebook stays on Vite and does not run
+ * Nuxt's build: a Nuxt module's or plugin's work is not done.
+ *
+ * @module
+ */
+import { extname } from "node:path";
+import { vue } from "@forgebook/vue/vite";
+import { FRAME_MODULE, nuxtPlugins } from "./nuxtPlugin.js";
+/**
+ * Nuxt, as the plugin reads and draws its components.
+ *
+ * @param options - the Nuxt project's folder, when it is not the catalogue's.
+ * @returns the adapter.
+ */
+export const nuxt = (options = {}) => {
+    const base = vue();
+    return {
+        name: "nuxt",
+        // beside this module, with its extension: `.ts` in the sources, `.js` once built for npm
+        docsModule: new URL(`./extractDocs${extname(import.meta.url)}`, import.meta.url).href,
+        // both are this package's: a catalogue resolves only the packages it installs, and it need not install Vue's adapter
+        pages: { frame: FRAME_MODULE, code: "@forgebook/nuxt/code" },
+        browserDependencies: [...(base.browserDependencies ?? []), "vue-router", "forgebook/frame"],
+        ...(base.componentFiles === undefined ? {} : { componentFiles: base.componentFiles }),
+        vitePlugins: async () => [
+            ...((await base.vitePlugins?.()) ?? []),
+            ...nuxtPlugins(options)
+        ]
+    };
+};

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

@@ -0,0 +1,85 @@
+/** A folder of components, as the catalogue reads it. */
+export type ComponentsDir = {
+    /** The folder, absolute. */
+    readonly path: string;
+    /** What every name in it starts with; none by default. */
+    readonly prefix: string;
+    /** Whether a component's folders are part of its name (`base/Button.vue` is `BaseButton`); `true` by default. */
+    readonly pathPrefix: boolean;
+};
+/** What a catalogue reads of a Nuxt project. */
+export type NuxtProjectConfig = {
+    /** The file read, or none. */
+    readonly file: string | undefined;
+    /** The project's folder. */
+    readonly rootDir: string;
+    /** Its sources' folder: `app/` in Nuxt 4's layout, the project's folder in Nuxt 3's. */
+    readonly srcDir: string;
+    /** Its pages' folder. */
+    readonly pagesDir: string;
+    /** The aliases, by name, each to an absolute path or a package. */
+    readonly alias: Readonly<Record<string, string>>;
+    /** Its components' folders. */
+    readonly componentsDirs: readonly ComponentsDir[];
+    /** The folders whose exports are auto-imported. */
+    readonly importsDirs: readonly string[];
+    /** Whether auto-imports are on; `imports.autoImport: false` turns them off. */
+    readonly isAutoImport: boolean;
+    /** The style sheets every page loads (`css`), as paths or packages. */
+    readonly css: readonly string[];
+    /** The runtime config's `public` part, before the environment's variables. */
+    readonly publicRuntimeConfig: Readonly<Record<string, unknown>>;
+    /** The app's base path; `/` by default. */
+    readonly baseURL: string;
+    /** Where Nuxt serves its built files from; `/_nuxt/` by default. */
+    readonly buildAssetsDir: string;
+    /** `appConfig`: the app config's values `nuxt.config` gives. */
+    readonly appConfig: Readonly<Record<string, unknown>>;
+    /** The project's `app.config` file, or none. */
+    readonly appConfigFile: string | undefined;
+};
+/** The names `nuxt.config` may have, in the order Nuxt looks for them. */
+export declare const NUXT_CONFIG_FILES: readonly ["nuxt.config.ts", "nuxt.config.mts", "nuxt.config.js", "nuxt.config.mjs", "nuxt.config.cjs"];
+/**
+ * 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 declare const resolvedPath: (path: string, rootDir: string, srcDir: string) => string;
+/**
+ * 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 declare const readNuxtConfig: (raw: unknown, file: string | undefined, projectDir: string) => NuxtProjectConfig;
+/**
+ * The project's `nuxt.config` file: the first Nuxt would find in its folder.
+ *
+ * @param rootDir - the project's folder.
+ */
+export declare const nuxtConfigFile: (rootDir: string) => string | undefined;
+/**
+ * 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 declare const loadNuxtConfig: (rootDir: string) => Promise<{
+    readonly config: NuxtProjectConfig;
+    readonly problem: string | undefined;
+}>;
+/**
+ * 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 declare const withEnvironment: (config: Readonly<Record<string, unknown>>, env: Readonly<Record<string, string>>, prefix?: string) => Readonly<Record<string, unknown>>;