@forgebook/sveltekit 0.0.0-stage → 0.2.1

package/dist/src/vite/kitPlugin.js

@@ -0,0 +1,241 @@
+/**
+ * The Vite plugin that lets a SvelteKit project's components draw outside SvelteKit: `$app/*` resolved to stand-ins
+ * that work in a story, `$lib` and the project's aliases, the public environment, and the project's routes written in
+ * the frame's page.
+ *
+ * @remarks
+ * What a stand-in does and why is in each module of `src/app`. The settings the stand-ins read (the base path, the
+ * version, the routes) are written in the frame's page before any module runs (`appSettings.ts`), read again when a
+ * route or a static file is added or removed. The environment modules are written from the project's `.env` files and
+ * the environment as SvelteKit would give them to the browser (`envModules.ts`).
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { codeLiteral } from "forgebook/code-literal";
+import { VITE_PATHS } from "forgebook/vite/paths";
+import { loadEnv } from "vite";
+import { APP_SETTINGS_KEY, SETTINGS_CONSTANT } from "../appSettings.js";
+import { declaredPublicVariables, isServerOnly, kitModuleName, namedExports, namedServerImports, PUBLIC_ENV, publicVariables, refusedModule, serverOnlyModule } from "./envModules.js";
+import { projectRoutes, projectStaticFiles } from "./projectFiles.js";
+/** The modules a story gets Forgebook's stand-in for, by the stand-in's export of this package. */
+const STAND_INS = {
+    "$app/env": "app/env",
+    "$app/environment": "app/env",
+    "$app/forms": "app/forms",
+    "$app/manifest": "app/manifest",
+    "$app/navigation": "app/navigation",
+    "$app/paths": "app/paths",
+    "$app/state": "app/state",
+    "$app/stores": "app/stores"
+};
+/** The prefix of the modules this plugin writes. */
+const VIRTUAL = "\0forgebook-sveltekit:";
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * A text of SvelteKit's options, or a default.
+ *
+ * @param options - an object of the options.
+ * @param key - its key.
+ * @param fallback - the default.
+ */
+const textOption = (options, key, fallback) => {
+    const value = isRecord(options) ? options[key] : undefined;
+    return typeof value === "string" ? value : fallback;
+};
+/**
+ * A text written as a regular expression that matches it alone.
+ *
+ * @param name - the text.
+ */
+const exactly = (name) => new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")}$`);
+/**
+ * A module this package exports, as a file.
+ *
+ * @param subpath - the export (`app/state`).
+ */
+const ownExport = (subpath) => fileURLToPath(import.meta.resolve(`@forgebook/sveltekit/${subpath}`));
+/**
+ * The aliases of SvelteKit's `alias` option and of `$lib`, as SvelteKit writes them: a name for itself and what is
+ * below it, a name ending in `/*` for what is below it. Each leads to a path in Vite's form, with forward slashes on
+ * every system: what a name leads to is written after it (`$lib/site` to `<lib>/site`), so a Windows path would come
+ * out half in backslashes.
+ *
+ * @param project - the project.
+ * @param paths - the system's path functions; the running system's by default.
+ */
+export const projectAliases = (project, paths = VITE_PATHS) => {
+    const { kit, dir } = project;
+    const files = isRecord(kit["files"]) ? kit["files"] : {};
+    const aliases = [
+        // SvelteKit 3 has no `$lib`, which a project's own `#lib` import replaces: giving it costs nothing
+        ["$lib", textOption(files, "lib", "src/lib")],
+        ...(isRecord(kit["alias"])
+            ? Object.entries(kit["alias"]).filter((entry) => typeof entry[1] === "string")
+            : [])
+    ];
+    return aliases.flatMap(([name, target]) => {
+        const path = paths.isAbsolute(target) ? paths.normalize(target) : paths.resolve(dir, target);
+        if (name.endsWith("/*")) {
+            const prefix = name.slice(0, -2);
+            return [
+                {
+                    find: new RegExp(`^${exactly(prefix).source.slice(1, -1)}/`),
+                    replacement: `${path.replace(/\/\*$/, "")}/`
+                }
+            ];
+        }
+        return [
+            { find: exactly(name), replacement: path },
+            { find: new RegExp(`^${exactly(name).source.slice(1, -1)}/`), replacement: `${path}/` }
+        ];
+    });
+};
+/**
+ * Why a public environment module is not this SvelteKit's: each has its own, and the other's does not exist, so it
+ * gives nothing (SvelteKit 3 gives no variable by its prefix alone).
+ *
+ * @param module - the module.
+ * @param version - the project's SvelteKit.
+ * @returns the reason, or none for one of this SvelteKit's.
+ */
+const otherKitsModule = (module, version) => {
+    if (module === "$app/env/public")
+        return version === 2
+            ? `${module} is SvelteKit 3's: SvelteKit 2 gives the public variables through $env/static/public and $env/dynamic/public`
+            : undefined;
+    return version === 3
+        ? `${module} is SvelteKit 2's: SvelteKit 3 gives the variables src/env.ts declares public through $app/env/public`
+        : undefined;
+};
+/**
+ * The `.env` files Vite reads for a mode that exist, so an edit to one writes the environment modules again.
+ *
+ * @param envDir - the folder they are in.
+ * @param mode - the mode.
+ */
+const envFiles = (envDir, mode) => [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`]
+    .map((name) => join(envDir, name))
+    // a missing one is not watched: Vite would take it for an import the module makes
+    .filter((file) => existsSync(file));
+/**
+ * The script the frame's page runs before any module: the settings the stand-ins read. Set inline in the page, so
+ * every value is a `codeLiteral`: no text in it can close the script.
+ *
+ * @param settings - the settings.
+ */
+export const pageScript = (settings) => `globalThis[Symbol.for(${codeLiteral(APP_SETTINGS_KEY)})] = ${codeLiteral(settings)};`;
+/**
+ * The plugin of a SvelteKit catalogue.
+ *
+ * @param project - the project, read.
+ * @returns the plugin.
+ */
+export const kitPlugin = (project) => {
+    const { kit, dir } = project;
+    const files = isRecord(kit["files"]) ? kit["files"] : {};
+    const paths = isRecord(kit["paths"]) ? kit["paths"] : {};
+    const env = isRecord(kit["env"]) ? kit["env"] : {};
+    const srcDir = resolve(dir, textOption(files, "src", "src"));
+    const routesDir = resolve(dir, textOption(files, "routes", join(textOption(files, "src", "src"), "routes")));
+    const staticDir = resolve(dir, textOption(files, "assets", "static"));
+    const { extensions, version } = project;
+    let resolved;
+    let settings;
+    const settingsNow = () => {
+        settings ??= {
+            base: textOption(paths, "base", ""),
+            assets: textOption(paths, "assets", ""),
+            version: textOption(kit["version"], "name", ""),
+            routes: projectRoutes(routesDir, extensions),
+            staticFiles: projectStaticFiles(staticDir)
+        };
+        return settings;
+    };
+    const allVariables = () => resolved === undefined ? {} : loadEnv(resolved.mode, resolve(dir, textOption(env, "dir", ".")), "");
+    /**
+     * A public environment module: the variables this SvelteKit gives the browser, or a refusal for the other's module.
+     *
+     * @param name - the module's name, with the names it is imported with.
+     * @param module - the module.
+     * @param watch - adds a file whose edit writes the module again.
+     */
+    const publicEnvModule = async (name, module, watch) => {
+        const refusal = otherKitsModule(module, version);
+        if (refusal !== undefined)
+            return refusedModule(name, refusal);
+        for (const file of envFiles(resolve(dir, textOption(env, "dir", ".")), resolved?.mode ?? "development"))
+            watch(file);
+        const variables = allVariables();
+        if (module === "$app/env/public") {
+            const declared = await declaredPublicVariables(srcDir, variables, projectAliases(project));
+            if (declared === undefined)
+                return "";
+            watch(declared.file);
+            return namedExports(declared.values);
+        }
+        const values = publicVariables(variables, textOption(env, "publicPrefix", "PUBLIC_"), textOption(env, "privatePrefix", ""));
+        return module === "$env/static/public"
+            ? namedExports(values)
+            : `export const env = ${codeLiteral(values)};\n`;
+    };
+    return {
+        name: "forgebook:sveltekit",
+        enforce: "pre",
+        config: () => ({
+            // a server render has no page to write the settings in: the code this package compiles has them instead
+            define: { [SETTINGS_CONSTANT]: codeLiteral(settingsNow()) },
+            // compiled by Vite, so the settings are in it, rather than loaded by Node as it is published
+            ssr: { noExternal: ["@forgebook/sveltekit"] },
+            resolve: {
+                alias: [
+                    ...Object.entries(STAND_INS).map(([name, subpath]) => ({
+                        find: exactly(name),
+                        replacement: ownExport(subpath)
+                    })),
+                    ...projectAliases(project)
+                ]
+            }
+        }),
+        configResolved: (config) => {
+            resolved = config;
+            if (project.problem !== undefined)
+                config.logger.warn(`[forgebook] ${project.problem}`);
+        },
+        configureServer: (server) => {
+            // a route or a static file added or removed is in the next frame's settings
+            const renew = (path) => {
+                if (path.startsWith(routesDir) || path.startsWith(staticDir))
+                    settings = undefined;
+            };
+            for (const event of ["add", "unlink", "addDir", "unlinkDir"])
+                server.watcher.on(event, renew);
+        },
+        transformIndexHtml: (_html, context) => (context.path.split("?")[0] ?? "").endsWith("frame.html")
+            ? [{ tag: "script", children: pageScript(settingsNow()), injectTo: "head-prepend" }]
+            : [],
+        // an import of a server-only module names what it imports, so the module that refuses to load can declare it
+        transform: {
+            filter: { code: /\$(app|env|service-worker)/ },
+            handler: (code) => {
+                const rewritten = namedServerImports(code);
+                return rewritten === undefined ? undefined : { code: rewritten, map: null };
+            }
+        },
+        resolveId: (source) => kitModuleName(source) === undefined ? undefined : `${VIRTUAL}${source}`,
+        async load(id) {
+            if (!id.startsWith(VIRTUAL))
+                return undefined;
+            const name = id.slice(VIRTUAL.length);
+            if (isServerOnly(name))
+                return serverOnlyModule(name);
+            const module = PUBLIC_ENV.find((known) => known === kitModuleName(name));
+            if (module === undefined)
+                return undefined;
+            return publicEnvModule(name, module, (file) => this.addWatchFile(file));
+        }
+    };
+};

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

@@ -0,0 +1,27 @@
+import type { Options as SveltePluginOptions } from "@sveltejs/vite-plugin-svelte";
+import { type Plugin, type PluginOption } from "vite";
+/** What the catalogue reads of a SvelteKit project. */
+export type KitProject = {
+    /** The project's folder. */
+    readonly dir: string;
+    /** SvelteKit's options, as SvelteKit 3 writes them (SvelteKit 2's `kit` key, read the same). */
+    readonly kit: Readonly<Record<string, unknown>>;
+    /** Svelte's options (`preprocess`, `compilerOptions`, `extensions`) for Svelte's Vite plugin; none to read `svelte.config.js`. */
+    readonly svelte: Partial<SveltePluginOptions> | undefined;
+    /** SvelteKit's major version, as its options say: 2 holds them under `kit`, 3 has them at the top. */
+    readonly version: 2 | 3;
+    /** The extensions of the project's Svelte components (`.svelte`, `.svx`): its routes' pages may have any. */
+    readonly extensions: readonly string[];
+    /** The project's other Vite plugins. */
+    readonly plugins: readonly PluginOption[];
+    /** Why the project's configuration could not be read; none when it was. */
+    readonly problem: string | undefined;
+};
+/**
+ * Reads a SvelteKit project.
+ *
+ * @param dir - the project's folder.
+ * @param viteConfig - its Vite configuration, from the folder; the one Vite would find by default; `false` reads none.
+ * @param keepPlugin - whether to keep one of the project's own plugins; every one by default.
+ */
+export declare const loadKitProject: (dir: string, viteConfig: string | false | undefined, keepPlugin?: (plugin: Plugin) => boolean) => Promise<KitProject>;

package/dist/src/vite/kitProject.js

@@ -0,0 +1,176 @@
+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;
+};
+/**
+ * A SvelteKit project, as the catalogue reads it: SvelteKit's options, from the project's own Vite configuration
+ * (SvelteKit 3 keeps them there) or from `svelte.config.js` (SvelteKit 2), and the project's other Vite plugins.
+ *
+ * @remarks
+ * The project's `vite.config` is loaded, not run as a server: SvelteKit's plugin, made there, holds the options it read
+ * and checked (`api.options`), whichever version wrote them, so the catalogue reads what SvelteKit itself does. Its own
+ * plugins are left out, since they build an app; the project's other plugins (Tailwind CSS, an i18n compiler) are kept,
+ * so its components are drawn as the app draws them.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadConfigFromFile } from "vite";
+/** SvelteKit's plugin that holds the options it read. */
+const SETUP_PLUGIN = "vite-plugin-sveltekit-setup";
+/**
+ * The plugins SvelteKit's `sveltekit()` makes: its own (any whose name says SvelteKit, so one it adds later is left out
+ * too, its environment's among them), and Svelte's, which the catalogue makes itself.
+ */
+const KIT_PLUGIN = /sveltekit|^vite-plugin-svelte([-:]|$)/;
+/** The names `svelte.config` may have, in the order SvelteKit 2 looks for them. */
+const SVELTE_CONFIGS = ["svelte.config.js", "svelte.config.mjs", "svelte.config.ts", "svelte.config.mts"];
+/** The options of Svelte's Vite plugin read from SvelteKit's. */
+const SVELTE_KEYS = ["preprocess", "compilerOptions", "extensions"];
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether a value is one of Vite's plugins. */
+const isPlugin = (value) => isRecord(value) && typeof value["name"] === "string";
+/**
+ * A configuration's plugins as one list: Vite takes nested lists and promises of plugins.
+ *
+ * @param plugins - the plugins, as the configuration writes them.
+ */
+const flatPlugins = async (plugins) => {
+    const value = await plugins;
+    if (Array.isArray(value))
+        return (await Promise.all(value.map(flatPlugins))).flat();
+    return isPlugin(value) ? [value] : [];
+};
+/**
+ * SvelteKit's options held by its setup plugin.
+ *
+ * @param plugins - the project's plugins.
+ */
+const setupOptions = (plugins) => {
+    const setup = plugins.find((plugin) => plugin.name === SETUP_PLUGIN);
+    const api = setup?.api;
+    return isRecord(api) && isRecord(api["options"]) ? api["options"] : undefined;
+};
+/**
+ * The options of Svelte's Vite plugin a SvelteKit configuration gives, read as they are: Svelte's plugin reads no
+ * `svelte.config.js` then, since the configuration was it.
+ *
+ * @param options - SvelteKit's options, or `svelte.config.js`'s default export.
+ */
+const svelteOptionsOf = (options) => ({
+    configFile: false,
+    ...Object.fromEntries(SVELTE_KEYS.filter((key) => options[key] !== undefined).map((key) => [key, options[key]]))
+});
+/**
+ * SvelteKit's options from a SvelteKit 2 `svelte.config.js`, loaded as Node loads a module.
+ *
+ * @param dir - the project's folder.
+ */
+const svelteConfigOptions = async (dir) => {
+    const file = SVELTE_CONFIGS.map((name) => join(dir, name)).find((path) => existsSync(path));
+    if (file === undefined)
+        return { kit: {}, config: {}, problem: undefined };
+    try {
+        const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        const config = isRecord(loaded) && isRecord(loaded["default"]) ? loaded["default"] : {};
+        return { kit: isRecord(config["kit"]) ? config["kit"] : {}, config, problem: undefined };
+    }
+    catch (error) {
+        return {
+            kit: {},
+            config: {},
+            problem: `${file} could not be loaded: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+};
+/**
+ * The extensions of a project's Svelte components, from Svelte's options: `.svelte` by default.
+ *
+ * @param options - SvelteKit's options, or `svelte.config.js`'s default export.
+ */
+const extensionsOf = (options) => {
+    const { extensions } = options;
+    const listed = Array.isArray(extensions) ? extensions.filter((item) => typeof item === "string") : [];
+    return listed.length === 0 ? [".svelte"] : listed;
+};
+/**
+ * What is wrong with a SvelteKit 3 project `svelte-kit sync` has not run in: its `tsconfig.json` extends
+ * `$app/tsconfig`, which the command writes, so every module of the catalogue fails to compile without it.
+ *
+ * @param root - the project's folder.
+ * @param version - SvelteKit's major version.
+ * @param problem - what was found wrong before.
+ */
+const syncedProblem = (root, version, problem) => {
+    const isSynced = version === 2 || existsSync(join(root, "node_modules", "$app", "tsconfig.json"));
+    return {
+        problem: problem ??
+            (isSynced
+                ? undefined
+                : "SvelteKit has not written its types: run `svelte-kit sync` first (SvelteKit's templates run it on install, as `prepare`), since the project's tsconfig.json extends $app/tsconfig")
+    };
+};
+/**
+ * The plugins a project's Vite configuration writes, loaded as `vite dev` loads it.
+ *
+ * @param root - the project's folder.
+ * @param viteConfig - the configuration, from the folder; the one Vite would find by default; `false` reads none.
+ * @returns the plugins as written, and why the configuration could not be loaded.
+ */
+const viteConfigPlugins = async (root, viteConfig) => {
+    if (viteConfig === false)
+        return { plugins: [], problem: undefined };
+    try {
+        const loaded = await loadConfigFromFile({ command: "serve", mode: "development" }, viteConfig === undefined ? undefined : resolve(root, viteConfig), root, "silent");
+        return { plugins: loaded?.config.plugins, problem: undefined };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { plugins: [], problem: `The project's Vite configuration could not be loaded: ${reason}` };
+    }
+};
+/**
+ * Reads a SvelteKit project.
+ *
+ * @param dir - the project's folder.
+ * @param viteConfig - its Vite configuration, from the folder; the one Vite would find by default; `false` reads none.
+ * @param keepPlugin - whether to keep one of the project's own plugins; every one by default.
+ */
+export const loadKitProject = async (dir, viteConfig, keepPlugin = () => true) => {
+    const root = resolve(dir);
+    const { plugins: written, problem } = await viteConfigPlugins(root, viteConfig);
+    const plugins = await flatPlugins(written);
+    const options = setupOptions(plugins);
+    const others = plugins.filter((plugin) => !KIT_PLUGIN.test(plugin.name) && keepPlugin(plugin));
+    // SvelteKit 2's options hold SvelteKit's under `kit`, beside Svelte's; SvelteKit 3's are SvelteKit's alone
+    if (options !== undefined) {
+        const kit = options["kit"];
+        const version = isRecord(kit) ? 2 : 3;
+        return {
+            ...syncedProblem(root, version, problem),
+            dir: root,
+            kit: isRecord(kit) ? kit : options,
+            version,
+            extensions: extensionsOf(options),
+            svelte: svelteOptionsOf(options),
+            plugins: others
+        };
+    }
+    const fromSvelteConfig = await svelteConfigOptions(root);
+    return {
+        dir: root,
+        kit: fromSvelteConfig.kit,
+        version: 2,
+        extensions: extensionsOf(fromSvelteConfig.config),
+        svelte: undefined,
+        plugins: others,
+        problem: problem ?? fromSvelteConfig.problem
+    };
+};

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

@@ -0,0 +1,14 @@
+import type { AppRoute } from "../appSettings.ts";
+/**
+ * The routes of a project's routes folder: every folder with a page or an endpoint.
+ *
+ * @param routesDir - the routes folder (`src/routes`).
+ * @param extensions - the extensions of the project's Svelte components (`.svelte`).
+ */
+export declare const projectRoutes: (routesDir: string, extensions: readonly string[]) => AppRoute[];
+/**
+ * The files of a project's static folder, as paths from it.
+ *
+ * @param staticDir - the folder (`static`).
+ */
+export declare const projectStaticFiles: (staticDir: string) => string[];

package/dist/src/vite/projectFiles.js

@@ -0,0 +1,70 @@
+/**
+ * The routes and static files of a SvelteKit project, read from its folders: what `$app/state` matches a story's
+ * address against, and what `$app/manifest` lists.
+ *
+ * @module
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+/** A route's page: `+page.svelte`, or another extension the project compiles as Svelte. */
+const PAGE_FILE = /^\+page(@[^.]*)?\.[^.]+$/;
+/** A route's endpoint: `+server.js` or `+server.ts`. */
+const SERVER_FILE = /^\+server\.[cm]?[jt]s$/;
+/** The most static files listed: a folder of thousands of images is listed no further. */
+const MOST_STATIC_FILES = 5000;
+/**
+ * A folder's path from another, written with `/`.
+ *
+ * @param from - the folder it is relative to.
+ * @param path - the path.
+ */
+const slashed = (from, path) => relative(from, path).split(sep).join("/");
+/**
+ * The routes of a project's routes folder: every folder with a page or an endpoint.
+ *
+ * @param routesDir - the routes folder (`src/routes`).
+ * @param extensions - the extensions of the project's Svelte components (`.svelte`).
+ */
+export const projectRoutes = (routesDir, extensions) => {
+    if (!existsSync(routesDir))
+        return [];
+    const routes = [];
+    const visit = (dir) => {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+        const page = files.some((file) => PAGE_FILE.test(file) && extensions.some((extension) => file.endsWith(extension)));
+        const endpoint = files.some((file) => SERVER_FILE.test(file));
+        if (page || endpoint) {
+            const path = slashed(routesDir, dir);
+            routes.push({ id: path === "" ? "/" : `/${path}`, page, endpoint });
+        }
+        for (const entry of entries)
+            if (entry.isDirectory())
+                visit(join(dir, entry.name));
+    };
+    visit(routesDir);
+    return routes.sort((first, second) => first.id.localeCompare(second.id));
+};
+/**
+ * The files of a project's static folder, as paths from it.
+ *
+ * @param staticDir - the folder (`static`).
+ */
+export const projectStaticFiles = (staticDir) => {
+    if (!existsSync(staticDir))
+        return [];
+    const files = [];
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (files.length >= MOST_STATIC_FILES)
+                return;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (entry.isFile())
+                files.push(slashed(staticDir, path));
+        }
+    };
+    visit(staticDir);
+    return files.sort();
+};

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

@@ -0,0 +1,26 @@
+import type { FrameworkAdapter } from "forgebook/vite/adapter";
+import type { Plugin } from "vite";
+/** The options of `sveltekit()`. */
+export type SveltekitOptions = {
+    /** The SvelteKit project's folder; the folder the command runs in by default. */
+    readonly dir?: string;
+    /**
+     * The project's Vite configuration, from its folder, where SvelteKit 3 keeps its options; the one Vite would find
+     * by default; `false` reads none (SvelteKit 2's `svelte.config.js` is read then, and the project's other plugins
+     * are left out).
+     */
+    readonly viteConfig?: string | false;
+    /**
+     * Whether to keep one of the app's own Vite plugins (SvelteKit's are always left out); every one by default. A
+     * catalogue runs them as `vite dev` would, its build too: leave out one that only an app's build needs (a source-map
+     * upload, a service-worker generator).
+     */
+    readonly keepPlugin?: (plugin: Plugin) => boolean;
+};
+/**
+ * SvelteKit, as the plugin reads and draws its components.
+ *
+ * @param options - the project's folder and its Vite configuration.
+ * @returns the adapter.
+ */
+export declare const sveltekit: (options?: SveltekitOptions) => FrameworkAdapter;

package/dist/src/vite/sveltekit.js

@@ -0,0 +1,39 @@
+/**
+ * Forgebook's adapter for SvelteKit, for the Vite plugin: `defineConfig({ framework: sveltekit() })`.
+ *
+ * @remarks
+ * SvelteKit is Svelte: the props are read as Svelte's, and the stories drawn with Svelte's renderer, wrapped so each
+ * has its page, its data and its links (`@forgebook/sveltekit/frame`). What SvelteKit adds is Vite's work: Svelte's
+ * plugin with the project's own Svelte options, the project's other plugins, and this package's plugin for SvelteKit's
+ * modules, aliases and environment (`kitPlugin.ts`). SvelteKit's own plugins are left out: they build an app, and a
+ * catalogue draws components.
+ *
+ * @module
+ */
+import { extname } from "node:path";
+import { svelte } from "@forgebook/svelte/vite";
+import { kitPlugin } from "./kitPlugin.js";
+import { loadKitProject } from "./kitProject.js";
+/**
+ * SvelteKit, as the plugin reads and draws its components.
+ *
+ * @param options - the project's folder and its Vite configuration.
+ * @returns the adapter.
+ */
+export const sveltekit = (options = {}) => {
+    const base = svelte();
+    return {
+        name: "sveltekit",
+        // 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,
+        // the catalogue imports this package only: its own pages, which use Svelte's
+        pages: { frame: "@forgebook/sveltekit/frame", code: "@forgebook/sveltekit/code" },
+        browserDependencies: base.browserDependencies ?? [],
+        ...(base.componentFiles === undefined ? {} : { componentFiles: base.componentFiles }),
+        vitePlugins: async () => {
+            const project = await loadKitProject(options.dir ?? process.cwd(), options.viteConfig, options.keepPlugin);
+            const withSvelte = project.svelte === undefined ? base : svelte({ plugin: project.svelte });
+            return [...((await withSvelte.vitePlugins?.()) ?? []), ...project.plugins, kitPlugin(project)];
+        }
+    };
+};