@forgebook/nuxt 0.0.0-stage → 0.2.0

package/dist/src/nuxtStore.d.ts

@@ -0,0 +1,144 @@
+/**
+ * A story's Nuxt, while it is drawn: its router, the calls it made, the data, state and cookies its composables share,
+ * its runtime and app config, and the app `useNuxtApp` returns.
+ *
+ * @remarks
+ * The router is vue-router's own, on a memory history, with a route for each of the project's pages and one that
+ * takes any other path: a link clicked in a story moves it, `useRoute` follows, `back()` returns, and the frame's own
+ * address never changes (it names the story). Each move and each `navigateTo` is told to the catalogue, which lists it
+ * among the story's events.
+ *
+ * A story's composables find its store through Vue's injection, so each cell of a matrix has its own. Outside a
+ * component's setup (an event handler, a play function) they read the frame's current store, the story drawn last, as
+ * Nuxt's composables read its one app; it sits on a global symbol, so two copies of this module share it.
+ *
+ * @module
+ */
+import { type App, type InjectionKey, type Ref } from "vue";
+import { type RouteLocationRaw, type Router } from "vue-router";
+import type { NuxtError } from "./nuxtError.ts";
+import { type NuxtProject, type PublicRuntimeConfig } from "./project.ts";
+import { type StoryFetch } from "./storyFetch.ts";
+/** A call a story made to Nuxt: its function (`router.push`, `navigateTo`) and what it was called with. */
+export type NuxtCall = {
+    /** The function, as the catalogue lists it. */
+    readonly name: string;
+    /** What it was called with: a location as its full path. */
+    readonly values: readonly unknown[];
+};
+/** Where an `useAsyncData` stands. */
+export type AsyncDataStatus = "idle" | "pending" | "success" | "error";
+/** What the `useAsyncData` and `useFetch` of one key share. */
+export type AsyncDataEntry = {
+    /** What the handler returned, or the story's data for the key. */
+    readonly data: Ref<unknown>;
+    /** Where it stands. */
+    readonly status: Ref<AsyncDataStatus>;
+    /** What the handler threw. */
+    readonly error: Ref<NuxtError | undefined>;
+    /** The data the key has before a handler returns, and after `clearNuxtData`: the first call's `default`. */
+    readonly defaultData: () => unknown;
+    /** The run under way, which a second call with the key waits for instead of calling its handler again. */
+    running: Promise<void> | undefined;
+    /** The number of the latest run: a run that is no longer the latest drops its result. */
+    runId: number;
+    /** What aborts the run under way, when a later one starts. */
+    controller: AbortController | undefined;
+    /** Runs the handler of the first call again; nothing until a call gives one. */
+    refresh: (() => Promise<void>) | undefined;
+};
+/** Tells the catalogue about a call: the drawing's `onEvent`, when the catalogue gives one. */
+export type CallReport = (name: string, values: readonly unknown[]) => void;
+/** The app `useNuxtApp` returns: what of Nuxt's a component reads from it. */
+export type NuxtAppStandIn = {
+    /** The story's Vue app, once the story's app is prepared. */
+    vueApp: App | undefined;
+    /** The payload: the data and state Nuxt would have sent from the server; empty, since there is no server. */
+    readonly payload: {
+        readonly data: Record<string, unknown>;
+        readonly state: Record<string, unknown>;
+    };
+    /** The public runtime config. */
+    readonly $config: PublicRuntimeConfig;
+    /** The story's router. */
+    readonly $router: Router;
+    /** Always `false`: a story is drawn in the page, never hydrated. */
+    readonly isHydrating: boolean;
+    /** Gives the app a value as `$name`, as a plugin's `provide` does. */
+    readonly provide: (name: string, value: unknown) => void;
+    /** Adds a listener to one of Nuxt's hooks; returns what removes it. */
+    readonly hook: (name: string, listener: (...values: unknown[]) => unknown) => () => void;
+    /** Calls the listeners of a hook, one after the other. */
+    readonly callHook: (name: string, ...values: unknown[]) => Promise<void>;
+    /** Runs a function, as it would run with the app as its context. */
+    readonly runWithContext: <TResult>(run: () => TResult) => TResult;
+    /** What `provide` gave, as `$name`. */
+    readonly provided: Record<string, unknown>;
+};
+/** A story's Nuxt. */
+export type NuxtStore = {
+    /** The story's router. */
+    readonly router: Router;
+    /** The app `useNuxtApp` returns. */
+    readonly nuxtApp: NuxtAppStandIn;
+    /** The runtime config: the project's, the story's public values over it. */
+    readonly runtimeConfig: PublicRuntimeConfig;
+    /** The app config: the project's, the story's over it; reactive, as `updateAppConfig` changes it. */
+    readonly appConfig: Record<string, unknown>;
+    /** The data the story gives `useAsyncData` and `useFetch`, by key. */
+    readonly storyData: Readonly<Record<string, unknown>>;
+    /** What `useAsyncData` and `useFetch` share, by key. */
+    readonly asyncData: Map<string, AsyncDataEntry>;
+    /** The values the story gives `useState`, by key. */
+    readonly storyState: Readonly<Record<string, unknown>>;
+    /** What `useState` shares, by key. */
+    readonly state: Map<string, Ref<unknown>>;
+    /** The values the story gives `useCookie`, by name. */
+    readonly storyCookies: Readonly<Record<string, unknown>>;
+    /** What `useCookie` shares, by name. */
+    readonly cookies: Map<string, Ref<unknown>>;
+    /** The error `showError` set and `useError` returns. */
+    readonly error: Ref<NuxtError | undefined>;
+    /** The keys `callOnce` ran. */
+    readonly once: Set<string>;
+    /** `$fetch`, with the app's base path. */
+    readonly fetch: StoryFetch;
+    /** Records a call and tells the catalogue. */
+    readonly record: (name: string, values: readonly unknown[]) => void;
+    /** The calls the story made, in order. */
+    readonly calls: () => readonly NuxtCall[];
+    /** A key of its own for a call that gives none, as Nuxt's compiler writes one per call site. */
+    readonly nextKey: (kind: string) => string;
+    /** Moves the router without recording the move: for a function that records a call of its own (`navigateTo`). */
+    readonly move: (to: RouteLocationRaw, isReplace: boolean) => Promise<unknown>;
+    /**
+     * Whether the story is drawn on the server (a generated server test): there is no server to answer a request there,
+     * so `useAsyncData` runs no handler, and draws what the story's data gives.
+     */
+    readonly isServer: boolean;
+    /** Gives a story's app the router and the store. */
+    readonly install: (app: App) => void;
+};
+/** The key a story's app provides its store under. */
+export declare const NUXT_STORE: InjectionKey<NuxtStore>;
+/** The name of the route that takes any path the project's pages do not. */
+export declare const ANY_PATH_NAME = "forgebook-any-path";
+/**
+ * A story's Nuxt.
+ *
+ * @param project - what the page knows of the project.
+ * @param parameters - the story's parameters, which give its route, data, state, cookies and config.
+ * @param onEvent - tells the catalogue about each call (the drawing's `onEvent`); none outside a catalogue.
+ * @param place - where the story is drawn: in the page, or on the server; the page by default.
+ */
+export declare const createNuxtStore: (project: NuxtProject, parameters: Readonly<Record<string, unknown>>, onEvent: CallReport | undefined, place?: "page" | "server") => NuxtStore;
+/**
+ * Makes a store the frame's current one: the story drawn last.
+ *
+ * @param store - the store.
+ */
+export declare const setCurrentStore: (store: NuxtStore) => void;
+/** The frame's current store: the story drawn last, or one made at `/` for code run outside a story. */
+export declare const currentStore: () => NuxtStore;
+/** The story's store: its app's, in a component's setup, else the frame's current one. */
+export declare const useNuxtStore: () => NuxtStore;

package/dist/src/nuxtStore.js

@@ -0,0 +1,196 @@
+/**
+ * A story's Nuxt, while it is drawn: its router, the calls it made, the data, state and cookies its composables share,
+ * its runtime and app config, and the app `useNuxtApp` returns.
+ *
+ * @remarks
+ * The router is vue-router's own, on a memory history, with a route for each of the project's pages and one that
+ * takes any other path: a link clicked in a story moves it, `useRoute` follows, `back()` returns, and the frame's own
+ * address never changes (it names the story). Each move and each `navigateTo` is told to the catalogue, which lists it
+ * among the story's events.
+ *
+ * A story's composables find its store through Vue's injection, so each cell of a matrix has its own. Outside a
+ * component's setup (an event handler, a play function) they read the frame's current store, the story drawn last, as
+ * Nuxt's composables read its one app; it sits on a global symbol, so two copies of this module share it.
+ *
+ * @module
+ */
+import { defineComponent, hasInjectionContext, inject, reactive, ref } from "vue";
+import { createMemoryHistory, createRouter } from "vue-router";
+import { mergedRecords, storyNuxtOf } from "./parameters.js";
+import { EMPTY_PROJECT } from "./project.js";
+import { createStoryFetch } from "./storyFetch.js";
+/** The key a story's app provides its store under. */
+export const NUXT_STORE = Symbol("forgebook.nuxt.store");
+/** What a page's route draws: nothing, since a story draws its own component, not the page. */
+const EMPTY_PAGE = defineComponent({ name: "ForgebookNuxtPage", render: () => null });
+/** The name of the route that takes any path the project's pages do not. */
+export const ANY_PATH_NAME = "forgebook-any-path";
+/** The route that takes any path the project's pages do not. */
+const ANY_PATH = { path: "/:forgebookPath(.*)*", name: ANY_PATH_NAME, component: EMPTY_PAGE };
+/**
+ * The app `useNuxtApp` returns.
+ *
+ * @param router - the story's router.
+ * @param config - the runtime config.
+ */
+const createNuxtApp = (router, config) => {
+    const hooks = new Map();
+    const provided = {};
+    return {
+        vueApp: undefined,
+        payload: { data: {}, state: {} },
+        // biome-ignore lint/style/useNamingConvention: Nuxt's app names it so
+        $config: config,
+        // biome-ignore lint/style/useNamingConvention: Nuxt's app names it so
+        $router: router,
+        isHydrating: false,
+        provided,
+        provide: (name, value) => {
+            provided[`$${name}`] = value;
+        },
+        hook: (name, listener) => {
+            hooks.set(name, [...(hooks.get(name) ?? []), listener]);
+            return () => {
+                hooks.set(name, (hooks.get(name) ?? []).filter((each) => each !== listener));
+            };
+        },
+        callHook: async (name, ...values) => {
+            for (const listener of hooks.get(name) ?? [])
+                await listener(...values);
+        },
+        runWithContext: (run) => run()
+    };
+};
+/**
+ * The router's methods wrapped so each move is recorded, as a story's events list it.
+ *
+ * @param router - the router.
+ * @param record - records a call.
+ */
+const recordMoves = (router, record) => {
+    const { push, replace, go, back, forward } = router;
+    const pathOf = (to) => {
+        try {
+            return router.resolve(to).fullPath;
+        }
+        catch {
+            return typeof to === "string" ? to : JSON.stringify(to);
+        }
+    };
+    router.push = (to) => {
+        record("router.push", [pathOf(to)]);
+        return push(to);
+    };
+    router.replace = (to) => {
+        record("router.replace", [pathOf(to)]);
+        return replace(to);
+    };
+    router.go = (delta) => {
+        record("router.go", [delta]);
+        go(delta);
+    };
+    router.back = () => {
+        record("router.back", []);
+        back();
+    };
+    router.forward = () => {
+        record("router.forward", []);
+        forward();
+    };
+};
+/**
+ * A story's Nuxt.
+ *
+ * @param project - what the page knows of the project.
+ * @param parameters - the story's parameters, which give its route, data, state, cookies and config.
+ * @param onEvent - tells the catalogue about each call (the drawing's `onEvent`); none outside a catalogue.
+ * @param place - where the story is drawn: in the page, or on the server; the page by default.
+ */
+export const createNuxtStore = (project, parameters, onEvent, place = "page") => {
+    const read = storyNuxtOf(parameters);
+    const runtimeConfig = {
+        public: mergedRecords(project.runtimeConfig.public, read.publicRuntimeConfig),
+        app: project.runtimeConfig.app
+    };
+    const history = createMemoryHistory(runtimeConfig.app.baseURL);
+    const router = createRouter({
+        history,
+        routes: [...project.routes.map((route) => ({ ...route, component: EMPTY_PAGE })), ANY_PATH]
+    });
+    // the story's route before anything is drawn: a component reads its params once, in its setup
+    let start = router.resolve("/");
+    try {
+        start = router.resolve(read.route);
+    }
+    catch {
+        // a location naming no route stays at `/`
+    }
+    history.replace(start.fullPath);
+    // every route has a name (the project's pages and the one for any other path), which the current route requires
+    if (start.name !== null)
+        router.currentRoute.value = { ...start, name: start.name };
+    const { push, replace } = router;
+    const made = [];
+    const record = (name, values) => {
+        made.push({ name, values });
+        onEvent?.(name, values);
+    };
+    recordMoves(router, record);
+    let keys = 0;
+    const nuxtApp = createNuxtApp(router, runtimeConfig);
+    const store = {
+        router,
+        nuxtApp,
+        runtimeConfig,
+        appConfig: reactive([...project.appConfigs, read.appConfig].reduce(mergedRecords, {})),
+        storyData: read.data,
+        asyncData: new Map(),
+        storyState: read.state,
+        state: new Map(),
+        storyCookies: read.cookies,
+        cookies: new Map(),
+        error: ref(undefined),
+        once: new Set(),
+        fetch: createStoryFetch(runtimeConfig.app.baseURL),
+        record,
+        calls: () => [...made],
+        nextKey: (kind) => {
+            keys += 1;
+            return `$forgebook-${kind}-${keys}`;
+        },
+        isServer: place === "server",
+        move: (to, isReplace) => isReplace ? replace(to) : push(to),
+        install: (app) => {
+            nuxtApp.vueApp = app;
+            app.use(router);
+            app.provide(NUXT_STORE, store);
+            app.config.globalProperties["$nuxt"] = nuxtApp;
+            // the route is already set, so vue-router does not start; a navigation to it makes it ready and listening
+            void replace({ path: start.path, query: start.query, hash: start.hash, force: true }).catch(() => undefined);
+        }
+    };
+    return store;
+};
+/** Where the frame's current store is kept: one key for every copy of this module. */
+const CURRENT_KEY = Symbol.for("forgebook.nuxt.store");
+/**
+ * Makes a store the frame's current one: the story drawn last.
+ *
+ * @param store - the store.
+ */
+export const setCurrentStore = (store) => {
+    Reflect.set(globalThis, CURRENT_KEY, store);
+};
+/** Whether a value is a store this module made. */
+const isNuxtStore = (value) => typeof value === "object" && value !== null && "router" in value && "nuxtApp" in value && "record" in value;
+/** The frame's current store: the story drawn last, or one made at `/` for code run outside a story. */
+export const currentStore = () => {
+    const store = Reflect.get(globalThis, CURRENT_KEY);
+    if (isNuxtStore(store))
+        return store;
+    const idle = createNuxtStore(EMPTY_PROJECT, {}, undefined);
+    setCurrentStore(idle);
+    return idle;
+};
+/** The story's store: its app's, in a component's setup, else the frame's current one. */
+export const useNuxtStore = () => (hasInjectionContext() ? inject(NUXT_STORE, undefined) : undefined) ?? currentStore();

package/dist/src/pageProject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The project the page knows, as the plugin writes it: in a catalogue, the plugin answers this module with the
+ * project's own (its routes, config and components, `nuxtPlugin.ts`); anywhere else it is an empty project.
+ *
+ * Internal: the code the plugin writes imports it (the renderer reads it); a story never imports this module, whose exports may change in any release.
+ *
+ * @module
+ */
+import { type NuxtProject } from "./project.ts";
+/** The project the page knows: replaced by the project's own in a catalogue. */
+export declare const project: NuxtProject;

package/dist/src/pageProject.js

@@ -0,0 +1,11 @@
+/**
+ * The project the page knows, as the plugin writes it: in a catalogue, the plugin answers this module with the
+ * project's own (its routes, config and components, `nuxtPlugin.ts`); anywhere else it is an empty project.
+ *
+ * Internal: the code the plugin writes imports it (the renderer reads it); a story never imports this module, whose exports may change in any release.
+ *
+ * @module
+ */
+import { EMPTY_PROJECT } from "./project.js";
+/** The project the page knows: replaced by the project's own in a catalogue. */
+export const project = EMPTY_PROJECT;

package/dist/src/parameters.d.ts

@@ -0,0 +1,67 @@
+/**
+ * A story's Nuxt settings (`parameters.nuxt`), read from the story's parameters: where it starts, the data, state and
+ * cookies its composables find, and the config over the project's.
+ *
+ * @remarks
+ * Pure: the parameters are values a story file wrote, typed `unknown` by the frame, so each is read with what it must
+ * be and anything else left out. A route is kept as a path, or as a location by path or by name, which is what
+ * vue-router resolves.
+ *
+ * @module
+ */
+/** A route's query or params: a text, or several, by name. */
+export type RouteValues = Record<string, string | string[]>;
+/** Where a story starts: a path (`/blog/hello?tab=1`), or a location by path or by a route's name. */
+export type StoryLocation = string | {
+    /** The path. */
+    readonly path: string;
+    /** The search params, by name. */
+    readonly query?: RouteValues;
+    /** The hash, with its `#`. */
+    readonly hash?: string;
+} | {
+    /** The route's name, as Nuxt names it from its file (`blog-slug`). */
+    readonly name: string;
+    /** The route's params (`{ slug: "hello" }`). */
+    readonly params?: RouteValues;
+    /** The search params, by name. */
+    readonly query?: RouteValues;
+    /** The hash, with its `#`. */
+    readonly hash?: string;
+};
+/** A story's Nuxt settings, read. */
+export type StoryNuxt = {
+    /** Where the story starts; `/` when it says nothing. */
+    readonly route: StoryLocation;
+    /** What `useAsyncData` and `useFetch` return, by key, instead of calling their handler. */
+    readonly data: Readonly<Record<string, unknown>>;
+    /** What `useState` starts with, by key. */
+    readonly state: Readonly<Record<string, unknown>>;
+    /** What `useCookie` reads, by name. */
+    readonly cookies: Readonly<Record<string, unknown>>;
+    /** The public runtime config over the project's. */
+    readonly publicRuntimeConfig: Readonly<Record<string, unknown>>;
+    /** The app config over the project's. */
+    readonly appConfig: Readonly<Record<string, unknown>>;
+};
+/** Whether a value is a plain object. */
+export declare const isRecord: (value: unknown) => value is Readonly<Record<string, unknown>>;
+/**
+ * Where a story starts, read from its `nuxt.route`: `/` for anything that is not a path or a location.
+ *
+ * @param value - `nuxt.route`.
+ */
+export declare const storyLocationOf: (value: unknown) => StoryLocation;
+/**
+ * A story's Nuxt settings, from its parameters (the preview's, the meta's and its own, merged).
+ *
+ * @param parameters - the story's parameters.
+ */
+export declare const storyNuxtOf: (parameters: Readonly<Record<string, unknown>>) => StoryNuxt;
+/**
+ * Two objects merged, the second's values over the first's and objects merged in depth, as Nuxt merges its configs.
+ *
+ * @param base - the first.
+ * @param over - the second.
+ */
+export declare const mergedRecords: (base: Readonly<Record<string, unknown>>, over: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;

package/dist/src/parameters.js

@@ -0,0 +1,89 @@
+/**
+ * A story's Nuxt settings (`parameters.nuxt`), read from the story's parameters: where it starts, the data, state and
+ * cookies its composables find, and the config over the project's.
+ *
+ * @remarks
+ * Pure: the parameters are values a story file wrote, typed `unknown` by the frame, so each is read with what it must
+ * be and anything else left out. A route is kept as a path, or as a location by path or by name, which is what
+ * vue-router resolves.
+ *
+ * @module
+ */
+/** Whether a value is a plain object. */
+export const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * An object read from a story's parameters, or an empty one.
+ *
+ * @param value - the value.
+ */
+const recordOf = (value) => (isRecord(value) ? value : {});
+/**
+ * A query or params read from a story's parameters: what is not a text, a number or a list of them left out.
+ *
+ * @param value - the value.
+ */
+const routeValues = (value) => Object.fromEntries(Object.entries(recordOf(value)).flatMap(([name, item]) => {
+    if (typeof item === "string" || typeof item === "number")
+        return [[name, String(item)]];
+    if (Array.isArray(item))
+        return [
+            [
+                name,
+                item.flatMap((each) => typeof each === "string" || typeof each === "number" ? [String(each)] : [])
+            ]
+        ];
+    return [];
+}));
+/**
+ * The hash of a location read from a story's parameters, when it gives one.
+ *
+ * @param location - the location.
+ */
+const hashOf = (location) => typeof location["hash"] === "string" ? { hash: location["hash"] } : {};
+/**
+ * Where a story starts, read from its `nuxt.route`: `/` for anything that is not a path or a location.
+ *
+ * @param value - `nuxt.route`.
+ */
+export const storyLocationOf = (value) => {
+    if (typeof value === "string")
+        return value;
+    if (!isRecord(value))
+        return "/";
+    const query = routeValues(value["query"]);
+    if (typeof value["name"] === "string")
+        return { name: value["name"], params: routeValues(value["params"]), query, ...hashOf(value) };
+    if (typeof value["path"] === "string")
+        return { path: value["path"], query, ...hashOf(value) };
+    return "/";
+};
+/**
+ * A story's Nuxt settings, from its parameters (the preview's, the meta's and its own, merged).
+ *
+ * @param parameters - the story's parameters.
+ */
+export const storyNuxtOf = (parameters) => {
+    const nuxt = recordOf(parameters["nuxt"]);
+    return {
+        route: storyLocationOf(nuxt["route"]),
+        data: recordOf(nuxt["data"]),
+        state: recordOf(nuxt["state"]),
+        cookies: recordOf(nuxt["cookies"]),
+        publicRuntimeConfig: recordOf(recordOf(nuxt["runtimeConfig"])["public"]),
+        appConfig: recordOf(nuxt["appConfig"])
+    };
+};
+/**
+ * Two objects merged, the second's values over the first's and objects merged in depth, as Nuxt merges its configs.
+ *
+ * @param base - the first.
+ * @param over - the second.
+ */
+export const mergedRecords = (base, over) => {
+    const merged = { ...base };
+    for (const [name, value] of Object.entries(over)) {
+        const known = merged[name];
+        merged[name] = isRecord(known) && isRecord(value) ? mergedRecords(known, value) : value;
+    }
+    return merged;
+};

package/dist/src/project.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What the page knows of a Nuxt project, as the plugin reads it on Node and hands it to the frame: its pages' routes,
+ * its public runtime config, its app config and its components.
+ *
+ * @remarks
+ * The plugin writes it as a module (`@forgebook/nuxt/project`, `pageProject.ts`), so it holds only what may reach a page: the
+ * runtime config's `public` part and `app`, never its private keys, which Nuxt keeps on the server too.
+ *
+ * @module
+ */
+import type { Component } from "vue";
+/** A route of the project's pages, as Nuxt names it from its file (`pages/blog/[slug].vue`). */
+export type ProjectRoute = {
+    /** The route's path, as vue-router writes it (`/blog/:slug()`). */
+    readonly path: string;
+    /** The route's name, as Nuxt writes it (`blog-slug`). */
+    readonly name: string;
+};
+/** The runtime config the page reads: `useRuntimeConfig()`. */
+export type PublicRuntimeConfig = {
+    /** The project's `runtimeConfig.public`, its `NUXT_PUBLIC_` variables over it. */
+    readonly public: Readonly<Record<string, unknown>>;
+    /** Where the app is served from. */
+    readonly app: {
+        /** The app's base path (`app.baseURL`); `/` by default. */
+        readonly baseURL: string;
+        /** Where Nuxt serves its built files from; `/_nuxt/` by default. */
+        readonly buildAssetsDir: string;
+        /** The CDN the files are served from; empty by default. */
+        readonly cdnURL: string;
+    };
+};
+/** Loads one of the project's components, for a component a story's template names without importing it. */
+export type ComponentLoader = () => Promise<Component | {
+    readonly default: Component;
+}>;
+/** What the page knows of a Nuxt project. */
+export type NuxtProject = {
+    /** The routes of its pages; none when it has no `pages` folder. */
+    readonly routes: readonly ProjectRoute[];
+    /** Its runtime config, as the page reads it. */
+    readonly runtimeConfig: PublicRuntimeConfig;
+    /** Its app configs, the later over the earlier: `nuxt.config`'s `appConfig`, then `app.config.ts`'s. */
+    readonly appConfigs: readonly Readonly<Record<string, unknown>>[];
+    /** Its components, by the name Nuxt gives each, loaded when a template names one. */
+    readonly components: Readonly<Record<string, ComponentLoader>>;
+};
+/** The project of a page with no Nuxt project read: no pages, an empty config, no components. */
+export declare const EMPTY_PROJECT: NuxtProject;

package/dist/src/project.js

@@ -0,0 +1,7 @@
+/** The project of a page with no Nuxt project read: no pages, an empty config, no components. */
+export const EMPTY_PROJECT = {
+    routes: [],
+    runtimeConfig: { public: {}, app: { baseURL: "/", buildAssetsDir: "/_nuxt/", cdnURL: "" } },
+    appConfigs: [],
+    components: {}
+};

package/dist/src/renderer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The renderer of a Nuxt catalogue, over the project the plugin read: what the frame page draws with, and what the
+ * generated server tests take (`storyServerTests(source, { renderer: nuxtRenderer })`).
+ *
+ * @module
+ */
+import type { StoryRenderer } from "forgebook/renderer";
+/** Vue's renderer, each story given its Nuxt. */
+export declare const nuxtRenderer: StoryRenderer;

package/dist/src/renderer.js

@@ -0,0 +1,10 @@
+/**
+ * The renderer of a Nuxt catalogue, over the project the plugin read: what the frame page draws with, and what the
+ * generated server tests take (`storyServerTests(source, { renderer: nuxtRenderer })`).
+ *
+ * @module
+ */
+import { project } from "@forgebook/nuxt/project";
+import { createNuxtRenderer } from "./nuxtRenderer.js";
+/** Vue's renderer, each story given its Nuxt. */
+export const nuxtRenderer = createNuxtRenderer(project);

package/dist/src/stories.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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
+ */
+import type { StoryParameters } from "@forgebook/story-format/csf";
+import type { AnyComponent, NoComponent, Meta as VueMeta, Preview as VuePreview, Story as VueStory } from "@forgebook/vue";
+import type { StoryLocation } from "./parameters.ts";
+/** A story's Nuxt settings: where it starts, what its composables find, the config over the project's. */
+export type NuxtParameters = {
+    /**
+     * Where the story starts: a path (`/blog/hello?tab=1`), a location by path (`{ path, query, hash }`) or by a page's
+     * name (`{ name: "blog-slug", params: { slug: "hello" } }`); `/` by default.
+     */
+    readonly route?: StoryLocation;
+    /** What `useAsyncData` and `useFetch` return, by key, without calling their handler. */
+    readonly data?: Readonly<Record<string, unknown>>;
+    /** What `useState` starts with, by key. */
+    readonly state?: Readonly<Record<string, unknown>>;
+    /** What `useCookie` reads, by name. */
+    readonly cookies?: Readonly<Record<string, unknown>>;
+    /** The runtime config's public values over the project's. */
+    readonly runtimeConfig?: {
+        readonly public?: Readonly<Record<string, unknown>>;
+    };
+    /** The app config over the project's. */
+    readonly appConfig?: Readonly<Record<string, unknown>>;
+};
+/** A story's parameters: the catalogue's settings, and its Nuxt ones. */
+export type NuxtStoryParameters = StoryParameters & {
+    /** The story's route, data, state, cookies and config. */
+    readonly nuxt?: NuxtParameters;
+};
+/** A story file's default export: `{ title, component, parameters: { nuxt } } satisfies Meta<typeof Nav>`. */
+export type Meta<TComponent extends AnyComponent = NoComponent> = Omit<VueMeta<TComponent>, "parameters"> & {
+    /** Settings for every story of the file, its Nuxt among them. */
+    readonly parameters?: NuxtStoryParameters;
+};
+/** A story: a named export of a story file. */
+export type Story<TComponent extends AnyComponent = NoComponent> = Omit<VueStory<TComponent>, "parameters"> & {
+    /** Settings over the meta's, its Nuxt among them. */
+    readonly parameters?: NuxtStoryParameters;
+};
+/** A Nuxt catalogue's preview (`forgebook.preview.ts`): Vue's, with Nuxt settings every story starts from. */
+export type Preview = Omit<VuePreview, "parameters"> & {
+    /** Settings every story starts from, its Nuxt among them. */
+    readonly parameters?: NuxtStoryParameters;
+};