@lovrozagar/honey 0.6.8 → 0.7.1

package/dist/plugin.js

@@ -0,0 +1,649 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import { createModuleLoader, honeyConfigOf } from "./codegen-load.js";
+import { generateManifest, generateOpenApi, generateRouteTree, generateRouteTreeFromApp, generateRouteTreeFromRouteTree, generateTypes, prepareCodegen, sanitizeOpenApiSpec, } from "./codegen.js";
+import { detectFeaturesInSource, featurePrelude, importsFeatureEntry } from "./feature-detect.js";
+import { runCli } from "./gen-process.js";
+import { writeGenFile, writeGenJsonFile, writeGenYamlFile, writeOutputDir } from "./gen-write.js";
+import { WATCH_IGNORE_RE, compileGlobs } from "./glob.js";
+import { overlaySchemas } from "./tree.js";
+import { openApiOutputPaths, toYaml } from "./yaml.js";
+export async function generateFromApp(app, options) {
+    const host = app;
+    const artifacts = {
+        routeTree: generateRouteTreeFromApp(host),
+    };
+    if (options?.manifest) {
+        const manifest = generateManifest(host);
+        artifacts.manifest = JSON.stringify(manifest, null, 2);
+    }
+    if (options?.openApi) {
+        const spec = await generateOpenApi(host, { info: options.openApi.info });
+        artifacts.openApi = JSON.stringify(spec, null, 2);
+        artifacts.openApiYaml = toYaml(spec);
+    }
+    return artifacts;
+}
+export function resolveHoneyConfig(raw) {
+    const c = raw.codegen;
+    const resolvePathFlag = (val, defaultPath, defaultEnabled) => {
+        if (val === false)
+            return false;
+        if (val === true || (val === undefined && defaultEnabled))
+            return defaultPath;
+        if (typeof val === "string")
+            return val;
+        return false;
+    };
+    let types = false;
+    if (c?.types !== undefined && c.types !== false) {
+        if (typeof c.types === "string") {
+            types = { baseCtxName: undefined, path: c.types };
+        }
+        else if (c.types === true) {
+            types = { baseCtxName: undefined, path: "src/_gen/types.gen.d.ts" };
+        }
+        else {
+            types = {
+                baseCtxName: c.types.baseCtxName,
+                path: c.types.path ?? "src/_gen/types.gen.d.ts",
+            };
+        }
+    }
+    let sdk = false;
+    if (c?.sdk !== undefined && c.sdk !== false) {
+        if (typeof c.sdk === "string") {
+            throw new Error("codegen.sdk string form removed — pass object { name?, specs?, ports }");
+        }
+        if (c.sdk === true) {
+            sdk = { name: "SDK", ports: { typescript: { outDir: "src/_gen" } } };
+        }
+        else {
+            const rawPorts = c.sdk.ports ?? { typescript: true };
+            const ports = {};
+            if (rawPorts.typescript !== undefined && rawPorts.typescript !== false) {
+                if (rawPorts.typescript === true) {
+                    ports.typescript = { outDir: "src/_gen" };
+                }
+                else {
+                    ports.typescript = { outDir: rawPorts.typescript.outDir ?? "src/_gen" };
+                }
+            }
+            if (rawPorts.python) {
+                ports.python = { outDir: rawPorts.python.outDir };
+            }
+            if (rawPorts.go) {
+                ports.go = { modulePath: rawPorts.go.modulePath, outDir: rawPorts.go.outDir };
+            }
+            if (rawPorts.rust) {
+                ports.rust = { crateName: rawPorts.rust.crateName, outDir: rawPorts.rust.outDir };
+            }
+            sdk = {
+                name: c.sdk.name ?? "SDK",
+                ports,
+                specs: c.sdk.specs,
+            };
+        }
+    }
+    let openApi = false;
+    if (c?.openApi) {
+        const entries = Array.isArray(c.openApi) ? c.openApi : [c.openApi];
+        openApi = entries.map((entry) => ({
+            description: entry.description,
+            filterRoutes: entry.filterRoutes,
+            path: entry.path ?? "src/_gen/openapi.gen.json",
+            profile: entry.profile,
+            sanitize: entry.sanitize,
+            securitySchemes: entry.securitySchemes,
+            title: entry.title,
+            version: entry.version,
+        }));
+    }
+    let cli = false;
+    if (c?.cli !== undefined && c.cli !== false) {
+        if (c.cli === true) {
+            throw new Error("codegen.cli=true requires `out` and `binaryName` — pass an object { out, binaryName }");
+        }
+        if (!c.cli.out || !c.cli.binaryName) {
+            throw new Error("codegen.cli requires `out` and `binaryName`");
+        }
+        cli = {
+            binaryName: c.cli.binaryName,
+            configName: c.cli.configName,
+            defaultBaseURL: c.cli.defaultBaseURL,
+            envPrefix: c.cli.envPrefix,
+            modulePath: c.cli.modulePath,
+            out: c.cli.out,
+            sdkModulePath: c.cli.sdkModulePath,
+        };
+    }
+    return {
+        app: raw.app,
+        codegen: {
+            cli,
+            invalidate: c?.invalidate,
+            manifest: resolvePathFlag(c?.manifest, "src/_gen/manifest.gen.json", false),
+            mergeTree: c?.mergeTree,
+            openApi,
+            sdk,
+            tree: resolvePathFlag(c?.tree, "src/_gen/routes.gen.ts", true),
+            types,
+        },
+        watch: raw.watch ?? [],
+    };
+}
+/* ---- Config stash ---- */
+let _lastConfig;
+/**
+ * Config of the most recent `honey()` call in this module instance.
+ * @deprecated Read the config off the plugin object (`plugin.api.honeyConfig`); this is a single
+ * global and does not survive a second module instance.
+ */
+export function getLastHoneyConfig() {
+    return _lastConfig;
+}
+/* ---- Outputs ---- */
+const TS_SDK_FILES = [
+    "sdk.types.gen.ts",
+    "sdk.map.gen.ts",
+    "sdk.client.gen.ts",
+    "sdk.index.gen.ts",
+    "sdk.runtime.gen.ts",
+];
+/** Every file and directory a generation writes, as absolute paths. Watchers must ignore these. */
+export function generatedOutputs(config, root) {
+    const cg = config.codegen;
+    const files = [];
+    const dirs = [];
+    if (cg.tree)
+        files.push(resolve(root, cg.tree));
+    if (cg.types)
+        files.push(resolve(root, cg.types.path));
+    if (cg.manifest)
+        files.push(resolve(root, cg.manifest));
+    for (const entry of cg.openApi || []) {
+        const out = openApiOutputPaths(resolve(root, entry.path));
+        if (out.json)
+            files.push(out.json);
+        files.push(out.yaml);
+    }
+    if (cg.sdk) {
+        const ports = cg.sdk.ports;
+        if (ports.typescript) {
+            const outDir = resolve(root, ports.typescript.outDir);
+            files.push(...TS_SDK_FILES.map((name) => resolve(outDir, name)));
+        }
+        if (ports.python)
+            dirs.push(resolve(root, ports.python.outDir));
+        if (ports.go)
+            dirs.push(resolve(root, ports.go.outDir));
+        if (ports.rust)
+            dirs.push(resolve(root, ports.rust.outDir));
+    }
+    if (cg.cli)
+        dirs.push(resolve(root, cg.cli.out));
+    return { dirs, files };
+}
+export function isGeneratedOutput(file, outputs) {
+    const abs = resolve(file);
+    if (outputs.files.includes(abs))
+        return true;
+    return outputs.dirs.some((dir) => abs === dir || abs.startsWith(dir + sep));
+}
+async function loadAppOrTree(load, entryPath) {
+    const mod = await load(entryPath);
+    /* prefer named exports, then unwrap interop default */
+    if (mod.app && isHoneyApp(mod.app))
+        return mod.app;
+    if (mod.tree && isRouteTree(mod.tree))
+        return mod.tree;
+    if (mod.default) {
+        const def = mod.default;
+        /* interopDefault may wrap: { default: { app: Honey } } */
+        if (isHoneyApp(def))
+            return def;
+        if (isRouteTree(def))
+            return def;
+        if (def.app && isHoneyApp(def.app))
+            return def.app;
+        if (def.tree && isRouteTree(def.tree))
+            return def.tree;
+    }
+    return undefined;
+}
+function isHoneyApp(val) {
+    if (val === null || typeof val !== "object")
+        return false;
+    return typeof val.fetch === "function";
+}
+function isRouteTree(val) {
+    if (val === null || typeof val !== "object")
+        return false;
+    const obj = val;
+    return obj.root !== undefined && typeof obj.root === "object";
+}
+/* ---- Generation ---- */
+/**
+ * The tree a `codegen.mergeTree` gateway serves: the merged downstream tree plus the routes
+ * the gateway app registers itself. Its root wildcard stays out — the downstream leaves
+ * delegate to it. Without a configured app the merged tree is served as is.
+ */
+async function gatewayTree(load, source, appPath) {
+    if (appPath === undefined)
+        return source;
+    const exported = await loadAppOrTree(load, appPath);
+    if (!isHoneyApp(exported))
+        throw new Error(`Expected Honey app default export in ${appPath}`);
+    return exported._gatewayTree(source);
+}
+export async function generateAndWrite(config, root, options = {}) {
+    await prepareCodegen();
+    const cg = config.codegen;
+    let load = options.load ?? (await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") }));
+    /* phase 1: route tree — from mergeTree source or app */
+    let mergeSource;
+    if (cg.tree && (cg.mergeTree || config.app)) {
+        const treeSrc = resolve(root, cg.mergeTree ?? config.app ?? "");
+        const exported = await loadAppOrTree(load, treeSrc);
+        let treeCode;
+        if (isHoneyApp(exported)) {
+            treeCode = generateRouteTreeFromApp(exported);
+        }
+        else if (isRouteTree(exported)) {
+            const appPath = cg.mergeTree && config.app ? resolve(root, config.app) : undefined;
+            const treePath = resolve(root, cg.tree);
+            let tree;
+            try {
+                tree = await gatewayTree(load, exported, appPath);
+            }
+            catch (err) {
+                /* first run: the gateway app imports the tree this pass writes. Write the merged
+                   downstream tree, then load the app again over it to add its own routes. */
+                if (appPath === undefined || existsSync(treePath))
+                    throw err;
+                writeGenFile(treePath, generateRouteTreeFromRouteTree(exported), "honey");
+                load = await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") });
+                tree = await gatewayTree(load, exported, appPath);
+            }
+            treeCode = generateRouteTreeFromRouteTree(tree);
+            mergeSource = exported;
+        }
+        else {
+            throw new Error(`Expected Honey app or RouteTree default export in ${treeSrc}`);
+        }
+        writeGenFile(resolve(root, cg.tree), treeCode, "honey");
+    }
+    else if (cg.mergeTree && cg.openApi) {
+        const exported = await loadAppOrTree(load, resolve(root, cg.mergeTree));
+        if (isRouteTree(exported))
+            mergeSource = exported;
+    }
+    /* phase 2: types, manifest, openapi, sdk, cli — app needed unless sdk has specs */
+    const sdkHasSpecs = cg.sdk && cg.sdk.specs && cg.sdk.specs.length > 0;
+    const needsApp = cg.types || cg.manifest || cg.openApi || (cg.sdk && !sdkHasSpecs) || cg.cli;
+    let app;
+    let appPath;
+    if (needsApp) {
+        if (!config.app) {
+            throw new Error("No app configured — required for types/manifest/openapi/sdk without specs/cli");
+        }
+        appPath = resolve(root, config.app);
+        /* the loader evaluates each file once, so the tree pass above did not cost a second load */
+        const appExported = await loadAppOrTree(load, appPath);
+        if (!isHoneyApp(appExported)) {
+            throw new Error(`Expected Honey app default export in ${appPath}`);
+        }
+        app = appExported;
+        /* the app serves the intern tree (no schemas); document merged routes from their source */
+        if (mergeSource)
+            overlaySchemas(app, mergeSource);
+    }
+    /* manifest */
+    if (cg.manifest) {
+        if (!app)
+            throw new Error("Manifest generation requires a configured app");
+        const manifest = generateManifest(app);
+        writeGenJsonFile(resolve(root, cg.manifest), manifest, "honey");
+    }
+    /* openapi */
+    if (cg.openApi) {
+        if (!app)
+            throw new Error("OpenAPI generation requires a configured app");
+        for (const entry of cg.openApi) {
+            let spec = await generateOpenApi(app, {
+                filterRoutes: entry.filterRoutes,
+                info: {
+                    description: entry.description,
+                    title: entry.title,
+                    version: entry.version,
+                },
+                /* one report per generate, not one per emitted document */
+                invalidate: entry === cg.openApi[0] ? cg.invalidate : "off",
+                profile: entry.profile,
+                securitySchemes: entry.securitySchemes,
+            });
+            if (entry.sanitize) {
+                spec = sanitizeOpenApiSpec(spec, entry.sanitize);
+            }
+            const out = openApiOutputPaths(resolve(root, entry.path));
+            if (out.json)
+                writeGenJsonFile(out.json, spec, "honey");
+            writeGenYamlFile(out.yaml, spec, "honey");
+        }
+    }
+    /* types */
+    if (cg.types) {
+        const typesPath = resolve(root, cg.types.path);
+        const typesDir = dirname(typesPath);
+        if (!appPath) {
+            throw new Error("Type generation requires a configured app");
+        }
+        const { extractChainTypes } = await import("./type-extractor.js").catch(() => {
+            throw new Error('Type generation requires "ts-morph" — install it as a dev dependency');
+        });
+        /* prefer appBase (middleware-only, simpler type) over app (with routes) */
+        const appModule = await load(appPath);
+        const exportName = "appBase" in appModule ? "appBase" : "app";
+        const extracted = await extractChainTypes({
+            entryPath: appPath,
+            exportName,
+            outputDir: typesDir,
+        });
+        if (!app)
+            throw new Error("Type generation requires a configured app");
+        const typesCode = generateTypes(app, {
+            baseCtxName: cg.types.baseCtxName,
+            inlineEnvType: extracted.base.envType,
+            inlineMiddlewareType: extracted.base.middlewareType,
+            inlineTapsType: extracted.base.tapsType,
+            routeMiddleware: extracted.routeMiddleware,
+            routeMiddlewareProps: extracted.routeMiddlewareProps,
+        });
+        writeGenFile(typesPath, typesCode, "honey");
+    }
+    /* The SDK and Go CLI share one unfiltered document. With openApi outputs the invalidate check
+     * already ran on the first of them, so it is not reported again; without, it runs here once. */
+    let unfiltered;
+    const unfilteredSpec = (what) => {
+        if (!app)
+            throw new Error(`${what} generation requires a configured app`);
+        const primaryOA = cg.openApi && cg.openApi.length > 0 ? cg.openApi[0] : null;
+        unfiltered ??= generateOpenApi(app, {
+            info: primaryOA ? { title: primaryOA.title, version: primaryOA.version } : { title: "API", version: "1.0.0" },
+            invalidate: primaryOA ? "off" : cg.invalidate,
+        });
+        return unfiltered;
+    };
+    /* sdk */
+    if (cg.sdk) {
+        const { generateSDK: genSDK, mergeSpecs } = await import("./codegen.js");
+        let spec;
+        if (cg.sdk.specs && cg.sdk.specs.length > 0) {
+            const specs = cg.sdk.specs.map((s) => {
+                const abs = resolve(root, s);
+                return JSON.parse(readFileSync(abs, "utf-8"));
+            });
+            spec = mergeSpecs(...specs);
+        }
+        else {
+            spec = await unfilteredSpec("SDK");
+        }
+        const ports = cg.sdk.ports;
+        if (ports.typescript) {
+            const tsOutDir = resolve(root, ports.typescript.outDir);
+            const { files } = genSDK(spec, { name: cg.sdk.name, stem: "sdk" });
+            writeGenFile(resolve(tsOutDir, "sdk.types.gen.ts"), files.types, "honey");
+            writeGenFile(resolve(tsOutDir, "sdk.map.gen.ts"), files.map, "honey");
+            writeGenFile(resolve(tsOutDir, "sdk.client.gen.ts"), files.client, "honey");
+            writeGenFile(resolve(tsOutDir, "sdk.index.gen.ts"), files.index, "honey");
+            if (files.runtime) {
+                writeGenFile(resolve(tsOutDir, "sdk.runtime.gen.ts"), files.runtime, "honey");
+            }
+        }
+        if (ports.python) {
+            const { generatePythonSDK } = await import("./codegen-python.js");
+            const { files } = generatePythonSDK(spec, { name: cg.sdk.name });
+            writeOutputDir(resolve(root, ports.python.outDir), files);
+        }
+        if (ports.go) {
+            const { generateGoSDK } = await import("./codegen-go.js");
+            const { files } = generateGoSDK(spec, { modulePath: ports.go.modulePath });
+            writeOutputDir(resolve(root, ports.go.outDir), files);
+        }
+        if (ports.rust) {
+            const { generateRustSDK } = await import("./codegen-rust.js");
+            const { files } = generateRustSDK(spec, { crateName: ports.rust.crateName });
+            writeOutputDir(resolve(root, ports.rust.outDir), files);
+        }
+    }
+    /* cli */
+    if (cg.cli) {
+        const { generateGoCLI } = await import("./codegen-go-cli.js");
+        const spec = await unfilteredSpec("CLI");
+        const { files } = generateGoCLI(spec, {
+            binaryName: cg.cli.binaryName,
+            configName: cg.cli.configName,
+            defaultBaseURL: cg.cli.defaultBaseURL,
+            envPrefix: cg.cli.envPrefix,
+            modulePath: cg.cli.modulePath,
+            sdkModulePath: cg.cli.sdkModulePath,
+        });
+        writeOutputDir(resolve(root, cg.cli.out), files);
+    }
+}
+/* ---- Vite plugin ---- */
+const VIRTUAL_ROUTES = "virtual:honey/routes";
+const VIRTUAL_MANIFEST = "virtual:honey/manifest";
+const VIRTUAL_OPENAPI = "virtual:honey/openapi";
+const RESOLVED_ROUTES = `\0${VIRTUAL_ROUTES}`;
+const RESOLVED_MANIFEST = `\0${VIRTUAL_MANIFEST}`;
+const RESOLVED_OPENAPI = `\0${VIRTUAL_OPENAPI}`;
+/* the route tree codegen emits TypeScript; a virtual module must be JavaScript in dev */
+async function toJavaScript(code) {
+    try {
+        const vite = (await import("vite"));
+        if (vite.transformWithOxc) {
+            const out = await vite.transformWithOxc(code, "routes.gen.ts", { lang: "ts", sourcemap: false });
+            return { code: out.code, moduleType: "js" };
+        }
+    }
+    catch {
+        /* no Vite 8 transform available — let the bundler strip types */
+    }
+    return { code, moduleType: "ts" };
+}
+export function honey(config) {
+    _lastConfig = config;
+    const resolved = resolveHoneyConfig(config);
+    const watchPatterns = config.watch ?? [];
+    const matchesWatch = compileGlobs(watchPatterns);
+    let root = "";
+    let configFile;
+    let pluginIndex = -1;
+    let command = "build";
+    let mode = "production";
+    let outputs = { dirs: [], files: [] };
+    /* one generation at a time; any request during a run schedules exactly one more */
+    let running;
+    let rerun;
+    let starting;
+    const savesSeen = new Map();
+    async function generateOnce() {
+        if (configFile && pluginIndex >= 0) {
+            /* a child process: fresh module graph, and the app's side effects die with it */
+            await runCli(["generate", "--config", configFile, "--plugin", String(pluginIndex)], {
+                cwd: root,
+                env: { HONEY_VITE_COMMAND: command, HONEY_VITE_MODE: mode },
+            });
+            return;
+        }
+        await generateAndWrite(resolved, root);
+    }
+    function regenerate() {
+        if (!running) {
+            running = generateOnce().finally(() => {
+                running = undefined;
+            });
+            return running;
+        }
+        if (!rerun) {
+            rerun = running
+                .catch(() => undefined)
+                .then(() => {
+                rerun = undefined;
+                return regenerate();
+            });
+        }
+        return rerun;
+    }
+    const plugin = {
+        /** Read by `honey generate` to find this plugin's config in a loaded Vite config. */
+        api: { honeyConfig: config },
+        /* Vite calls this once per environment, back to back: the second joins the running
+         * generation instead of queueing another. A later buildStart (a watch rebuild) runs anew. */
+        async buildStart() {
+            starting ??= regenerate().finally(() => {
+                starting = undefined;
+            });
+            await starting;
+        },
+        configResolved(cfg) {
+            root = cfg.root;
+            configFile = cfg.configFile;
+            command = cfg.command ?? "build";
+            mode = cfg.mode ?? (command === "serve" ? "development" : "production");
+            outputs = generatedOutputs(resolved, root);
+            const honeyPlugins = (cfg.plugins ?? []).filter((p) => honeyConfigOf(p) !== undefined);
+            pluginIndex = honeyPlugins.findIndex((p) => p === plugin || honeyConfigOf(p) === config);
+        },
+        /**
+         * Regenerates when a watched file changes, then lets Vite's normal HMR proceed, adding the
+         * virtual route tree to the update. Vite calls this once per environment; the generation
+         * runs once per save.
+         */
+        async hotUpdate(ctx) {
+            if (watchPatterns.length === 0)
+                return undefined;
+            if (WATCH_IGNORE_RE.test(ctx.file) || isGeneratedOutput(ctx.file, outputs))
+                return undefined;
+            if (!matchesWatch(ctx.file, root))
+                return undefined;
+            const key = `${ctx.file}\0${ctx.timestamp ?? Date.now()}`;
+            let run = savesSeen.get(key);
+            if (!run) {
+                run = regenerate().catch((err) => {
+                    console.error("honey: generation failed", err);
+                });
+                savesSeen.set(key, run);
+                if (savesSeen.size > 64)
+                    savesSeen.delete(savesSeen.keys().next().value);
+            }
+            await run;
+            const graph = (this && this.environment?.moduleGraph) || ctx.server.moduleGraph;
+            const routes = graph.getModuleById(RESOLVED_ROUTES);
+            if (!routes || ctx.modules.includes(routes))
+                return undefined;
+            return [...ctx.modules, routes];
+        },
+        async load(id) {
+            if (id === RESOLVED_ROUTES) {
+                if (!resolved.codegen.mergeTree && !config.app) {
+                    throw new Error("Route tree virtual module requires app or mergeTree");
+                }
+                const treeSrc = resolved.codegen.mergeTree
+                    ? resolve(root, resolved.codegen.mergeTree)
+                    : resolve(root, config.app ?? "");
+                const load = await createModuleLoader({ fresh: true, from: treeSrc });
+                const exported = await loadAppOrTree(load, treeSrc);
+                let code;
+                if (isHoneyApp(exported)) {
+                    code = generateRouteTreeFromApp(exported);
+                }
+                else if (isRouteTree(exported)) {
+                    const appPath = resolved.codegen.mergeTree && config.app ? resolve(root, config.app) : undefined;
+                    code = generateRouteTreeFromRouteTree(await gatewayTree(load, exported, appPath));
+                }
+                else {
+                    throw new Error(`Expected Honey app or RouteTree in ${treeSrc}`);
+                }
+                return toJavaScript(code);
+            }
+            if (id === RESOLVED_MANIFEST && resolved.codegen.manifest) {
+                if (!config.app)
+                    throw new Error("Manifest virtual module requires app");
+                const appPath = resolve(root, config.app);
+                const exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath);
+                if (isHoneyApp(exported)) {
+                    const manifest = generateManifest(exported);
+                    return {
+                        code: `export default ${JSON.stringify(manifest, null, 2)};`,
+                        moduleType: "js",
+                    };
+                }
+            }
+            if (id === RESOLVED_OPENAPI && resolved.codegen.openApi) {
+                const primary = resolved.codegen.openApi[0];
+                if (!config.app)
+                    throw new Error("OpenAPI virtual module requires app");
+                const appPath = resolve(root, config.app);
+                const exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath);
+                if (isHoneyApp(exported)) {
+                    let spec = await generateOpenApi(exported, {
+                        filterRoutes: primary.filterRoutes,
+                        info: {
+                            description: primary.description,
+                            title: primary.title,
+                            version: primary.version,
+                        },
+                        /* generation already reported; a virtual module load must not repeat it */
+                        invalidate: "off",
+                        profile: primary.profile,
+                        securitySchemes: primary.securitySchemes,
+                    });
+                    if (primary.sanitize) {
+                        spec = sanitizeOpenApiSpec(spec, primary.sanitize);
+                    }
+                    return {
+                        code: `export default ${JSON.stringify(spec, null, 2)};`,
+                        moduleType: "js",
+                    };
+                }
+            }
+            return undefined;
+        },
+        name: "honey",
+        /**
+         * Imports the entries of optional features a module uses, ahead of its code, on the same
+         * line so line numbers stay put. Server environments only: browser code never serves.
+         */
+        transform(code, id) {
+            if (this && this.environment?.config?.consumer === "client")
+                return undefined;
+            if (id.includes("\0") || id.includes("node_modules"))
+                return undefined;
+            const features = [...detectFeaturesInSource(code)].filter((f) => !importsFeatureEntry(code, f));
+            if (features.length === 0)
+                return undefined;
+            const prelude = featurePrelude(features);
+            if (code.startsWith("#!")) {
+                const eol = code.indexOf("\n");
+                if (eol === -1)
+                    return { code: `${code}\n${prelude}`, map: null };
+                return { code: `${code.slice(0, eol + 1)}${prelude} ${code.slice(eol + 1)}`, map: null };
+            }
+            return { code: `${prelude} ${code}`, map: null };
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ROUTES)
+                return RESOLVED_ROUTES;
+            if (id === VIRTUAL_MANIFEST && resolved.codegen.manifest)
+                return RESOLVED_MANIFEST;
+            if (id === VIRTUAL_OPENAPI && resolved.codegen.openApi)
+                return RESOLVED_OPENAPI;
+            return undefined;
+        },
+    };
+    return [plugin];
+}
+export { generateRouteTree };
+//# sourceMappingURL=plugin.js.map