vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginDistPackageJsonFile.js

@@ -28,9 +28,9 @@ function pluginDistPackageJsonFile() {
             this.emitFile({
                 fileName,
                 type: 'asset',
-                source: getPackageJsonContent(isEsm)
+                source: getPackageJsonContent(isEsm),
             });
-        }
+        },
     };
 }
 function getPackageJsonContent(isEsm) {

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginModuleBanner.js

@@ -1,13 +1,13 @@
 export { pluginModuleBanner };
 import MagicString from 'magic-string';
-import { removeVirtualIdTag } from '../../../shared/virtual-files.js';
+import { removeVirtualIdTag } from '../../../shared/virtualFiles.js';
 import { isViteServerBuild_safe } from '../../shared/isViteServerBuild.js';
 // Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
 function pluginModuleBanner() {
     let config;
     return {
-        name: 'vike:pluginModuleBanner',
+        name: 'vike:build:pluginModuleBanner',
         enforce: 'post',
         apply: 'build',
         configResolved(config_) {
@@ -34,9 +34,9 @@ function pluginModuleBanner() {
                 magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
                 return {
                     code: magicString.toString(),
-                    map: magicString.generateMap({ hires: true, source: id })
+                    map: magicString.generateMap({ hires: true, source: id }),
                 };
-            }
-        }
+            },
+        },
     };
 }

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginSuppressRollupWarning.js

@@ -23,14 +23,14 @@ function pluginSuppressRollupWarning() {
                     warn(warning);
                 }
             };
-        }
+        },
     };
 }
 /** Suppress warning about Rollup removing the React Server Components `"use client";` directives */
 function suppressUseClientDirective(warning) {
     return warning.code === 'MODULE_LEVEL_DIRECTIVE' && warning.message.includes('"use client"');
 }
-/** Suppress warning about generating emtpy chunks in dist/ */
+/** Suppress warning about generating empty chunks in dist/ */
 function suppressEmptyBundle(warning) {
     return warning.code === 'EMPTY_BUNDLE';
 }
@@ -38,7 +38,7 @@ function suppressEmptyBundle(warning) {
 function suppressUnusedImport(warning) {
     if (warning.code !== 'UNUSED_EXTERNAL_IMPORT')
         return false;
-    // I guess it's expected that JSX contains unsused `import React from 'react'`
+    // I guess it's expected that JSX contains unused `import React from 'react'`
     if (warning.exporter === 'react' && warning.names?.includes('default')) {
         warning.names = warning.names.filter((n) => n !== 'default');
         if (warning.names.length === 0)

package/dist/esm/node/vite/plugins/pluginBuild.d.ts

@@ -0,0 +1,3 @@
+export { pluginBuild };
+import type { Plugin } from 'vite';
+declare function pluginBuild(): Plugin[];

package/dist/esm/node/vite/plugins/pluginBuild.js

@@ -0,0 +1,21 @@
+export { pluginBuild };
+import { pluginBuildApp } from './pluginBuild/pluginBuildApp.js';
+import { pluginDistPackageJsonFile } from './pluginBuild/pluginDistPackageJsonFile.js';
+import { pluginSuppressRollupWarning } from './pluginBuild/pluginSuppressRollupWarning.js';
+import { pluginDistFileNames } from './pluginBuild/pluginDistFileNames.js';
+import { pluginAutoFullBuild } from './pluginBuild/pluginAutoFullBuild.js';
+import { pluginBuildEntry } from './pluginBuild/pluginBuildEntry.js';
+import { pluginBuildConfig } from './pluginBuild/pluginBuildConfig.js';
+import { pluginModuleBanner } from './pluginBuild/pluginModuleBanner.js';
+function pluginBuild() {
+    return [
+        ...pluginBuildConfig(),
+        ...pluginBuildApp(),
+        ...pluginAutoFullBuild(),
+        ...pluginBuildEntry(),
+        pluginDistPackageJsonFile(),
+        pluginSuppressRollupWarning(),
+        pluginDistFileNames(),
+        pluginModuleBanner(),
+    ];
+}

package/dist/esm/node/{plugin/plugins/commonConfig → vite/plugins/pluginCommon}/assertResolveAlias.js

@@ -20,7 +20,7 @@ function assertResolveAlias(config) {
     const errPrefix = config.configFile || 'Your Vite configuration';
     const errSuffix1 = 'see https://vike.dev/path-aliases#vite';
     const deprecation = 'which will be deprecated in the next major release';
-    const errSuffix2 = `${deprecation}, use a string insead and ${errSuffix1}`;
+    const errSuffix2 = `${deprecation}, use a string instead and ${errSuffix1}`;
     aliases.forEach((alias) => {
         const { customResolver, find } = alias;
         {
@@ -40,7 +40,7 @@ function assertResolveAlias(config) {
             {
                 const msg = `${errPrefix} defines resolve.alias with a regular expression ${errSuffix2}`;
                 assertWarning(false, msg, {
-                    onlyOnce: true
+                    onlyOnce: true,
                 });
             }
         }

package/dist/esm/node/vite/plugins/pluginCommon.d.ts

@@ -0,0 +1,13 @@
+export { pluginCommon };
+import { type InlineConfig, type Plugin } from 'vite';
+import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
+declare module 'vite' {
+    interface UserConfig {
+        vitePluginServerEntry?: VitePluginServerEntryOptions;
+        _isDev?: boolean;
+        _rootResolvedEarly?: string;
+        _baseViteOriginal?: string;
+        _viteConfigFromUserEnhanced?: InlineConfig;
+    }
+}
+declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];

package/dist/esm/node/{plugin/plugins/commonConfig.js → vite/plugins/pluginCommon.js}

@@ -1,22 +1,17 @@
-export { commonConfig };
-export { getVikeConfigPublic };
-export { getVikeConfigInternal };
-import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
-import { assertRollupInput } from './build/pluginBuildConfig.js';
+export { pluginCommon };
+import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject, isVitest, } from '../utils.js';
+import { assertRollupInput } from './pluginBuild/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
-import path from 'path';
-import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
+import path from 'node:path';
+import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
-import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
-import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
-const pluginName = 'vike:commonConfig';
-function commonConfig(vikeVitePluginOptions) {
-    // We cache it => makes sure we only generate one object => we can mutate it at runPrerender()
-    let prerenderContext;
+const pluginName = 'vike:pluginCommon';
+function pluginCommon(vikeVitePluginOptions) {
     return [
         {
             name: `${pluginName}:pre`,
@@ -26,50 +21,38 @@ function commonConfig(vikeVitePluginOptions) {
                 async handler(configFromUser, env) {
                     const isDev = isDevCheck(env);
                     const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
-                    const root = configFromUser.root ? normalizeViteRoot(configFromUser.root) : await getViteRoot(operation);
-                    assert(root);
-                    const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
-                    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
-                    prerenderContext ?? (prerenderContext = {
-                        isPrerenderingEnabled,
-                        isPrerenderingEnabledForAllPages,
-                        output: null,
-                        pageContexts: null
-                    });
-                    assert(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
-                    assert(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);
+                    const rootResolvedEarly = configFromUser.root
+                        ? normalizeViteRoot(configFromUser.root)
+                        : await getViteRoot(operation);
+                    assert(rootResolvedEarly);
+                    // TODO/v1-release: we can remove setVikeConfigContext() call here since with Vike's CLI it's already called at vike/node/api/prepareViteApiCall.ts
+                    setVikeConfigContext({ userRootDir: rootResolvedEarly, isDev, vikeVitePluginOptions });
+                    const vikeConfig = await getVikeConfigInternal();
                     return {
                         _isDev: isDev,
-                        _root: root,
-                        _vikeVitePluginOptions: vikeVitePluginOptions,
-                        _vikeConfigObject: vikeConfig,
-                        _vike: {
-                            pages: vikeConfig.pages,
-                            config: vikeConfig.global.config,
-                            prerenderContext
-                        },
+                        _rootResolvedEarly: rootResolvedEarly,
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: isPrerenderingEnabled
-                        })
+                            prerender: vikeConfig.prerenderContext.isPrerenderingEnabled,
+                        }),
                     };
-                }
-            }
+                },
+            },
         },
         {
             name: pluginName,
             configResolved(config) {
-                assertViteRoot(config._root, config);
+                assertViteRoot(config._rootResolvedEarly, config);
                 assertSingleInstance(config);
                 installRequireShim_setUserRootDir(config.root);
-            }
+            },
         },
         {
             name: `${pluginName}:post`,
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                handler(config) {
+                async handler(config) {
                     /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
                     overrideViteDefaultSsrExternal(config)
                     //*/
@@ -79,34 +62,34 @@ function commonConfig(vikeVitePluginOptions) {
                     assertEsm(config.root);
                     assertVikeCliOrApi(config);
                     temp_supportOldInterface(config);
-                    emitServerEntryOnlyIfNeeded(config);
-                }
+                    await emitServerEntryOnlyIfNeeded(config);
+                },
             },
             config: {
                 order: 'post',
-                handler(configFromUser) {
+                async handler(configFromUser) {
                     let configFromVike = { server: {}, preview: {} };
-                    const vike = getVikeConfigInternal(configFromUser);
-                    if (vike.config.port !== undefined) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    if (vikeConfig.config.port !== undefined) {
                         // https://vike.dev/port
-                        setDefault('port', vike.config.port, configFromUser, configFromVike);
+                        setDefault('port', vikeConfig.config.port, configFromUser, configFromVike);
                     }
                     else {
                         // Change Vite's default port
                         setDefault('port', 3000, configFromUser, configFromVike);
                     }
-                    if (vike.config.host) {
+                    if (vikeConfig.config.host) {
                         // https://vike.dev/host
-                        setDefault('host', vike.config.host, configFromUser, configFromVike);
+                        setDefault('host', vikeConfig.config.host, configFromUser, configFromVike);
                     }
                     else if (isDocker()) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
                     return configFromVike;
-                }
-            }
-        }
+                },
+            },
+        },
     ];
 }
 // Override Vite's default value without overriding user settings
@@ -156,7 +139,7 @@ function assertVikeCliOrApi(config) {
     if (isViteCliCall()) {
         assert(!isVitest());
         assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
-            onlyOnce: true
+            onlyOnce: true,
         });
         return;
     }
@@ -166,12 +149,12 @@ function assertVikeCliOrApi(config) {
     }
     if (config.server.middlewareMode) {
         assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
-            onlyOnce: true
+            onlyOnce: true,
         });
         return;
     }
     assertWarning(false, `Vite's JavaScript API is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
-        onlyOnce: true
+        onlyOnce: true,
     });
 }
 // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
@@ -195,30 +178,10 @@ function temp_supportOldInterface(config) {
     }
     assert(false);
 }
-// TODO/soon rename:
-// - `getVikeConfig()` => `resolveVikeConfig()` ?
-// - `getVikeConfigInternal()` => `getVikeConfig()`
-// - `VikeConfigPublic` => `VikeConfig` ?
-// - `VikeConfigObject` => `VikeConfigInternal` ?
-/**
- * Get all the information Vike knows about the app in your Vite plugin.
- *
- * https://vike.dev/getVikeConfig
- */
-function getVikeConfigInternal(config) {
-    const vikeConfig = config._vike;
-    assert(vikeConfig);
-    return vikeConfig;
-}
-function getVikeConfigPublic(config) {
-    const vikeConfig = config._vike;
-    assertUsage(vikeConfig, "getVikeConfig() can only be used when Vite is running with Vike's Vite plugin");
-    return vikeConfig;
-}
 // Only emit dist/server/entry.mjs if necessary
-function emitServerEntryOnlyIfNeeded(config) {
-    if (config.vitePluginServerEntry?.inject &&
-        !resolvePrerenderConfigGlobal(config._vikeConfigObject).isPrerenderingEnabled) {
+async function emitServerEntryOnlyIfNeeded(config) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (config.vitePluginServerEntry?.inject && !vikeConfig.prerenderContext.isPrerenderingEnabled) {
         config.vitePluginServerEntry.disableServerEntryEmit = true;
     }
 }

package/dist/esm/node/{plugin/plugins/devConfig → vite/plugins/pluginDev}/determineFsAllowList.js

@@ -2,7 +2,7 @@ export { determineFsAllowList };
 import { searchForWorkspaceRoot } from 'vite';
 import path from 'node:path';
 import { assert, assertPosixPath, getVikeNodeModulesRoot } from '../../utils.js';
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from 'node:url';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
 assertPosixPath(importMetaUrl);

package/dist/esm/node/{plugin/plugins/devConfig → vite/plugins/pluginDev}/determineOptimizeDeps.js

@@ -1,13 +1,14 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, unique } from '../../utils.js';
-import { getVikeConfig, isOverriden } from '../importUserCode/v1-design/getVikeConfig.js';
-import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
-import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, unique, } from '../../utils.js';
+import { getVikeConfigInternal, isOverridden } from '../../shared/resolveVikeConfigInternal.js';
+import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
+import { virtualFileIdEntryClientCR, virtualFileIdEntryClientSR, } from '../../../shared/virtualFiles/virtualFileEntry.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
-    const { pageConfigs } = await getVikeConfig(config);
+    const vikeConfig = await getVikeConfigInternal();
+    const { _pageConfigs: pageConfigs } = vikeConfig;
     const { entries, include } = await getPageDeps(config, pageConfigs);
     {
         // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
@@ -25,7 +26,7 @@ async function determineOptimizeDeps(config) {
     if (debug.isActivated)
         debug('config.optimizeDeps', {
             'config.optimizeDeps.entries': config.optimizeDeps.entries,
-            'config.optimizeDeps.include': config.optimizeDeps.include
+            'config.optimizeDeps.include': config.optimizeDeps.include,
         });
 }
 async function getPageDeps(config, pageConfigs) {
@@ -46,7 +47,7 @@ async function getPageDeps(config, pageConfigs) {
         pageConfigs.forEach((pageConfig) => {
             Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
                 sources
-                    .filter((source) => !isOverriden(source, configName, pageConfig))
+                    .filter((source) => !isOverridden(source, configName, pageConfig))
                     .forEach((configValueSource) => {
                     if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                         return;
@@ -90,9 +91,9 @@ function getVirtualFiles(config, pageConfigs) {
     const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
     const entriesVirtualFiles = Object.values(clientEntries);
     if (hasClientRouting)
-        entriesVirtualFiles.push(virtualFileIdImportUserCodeClientCR);
+        entriesVirtualFiles.push(virtualFileIdEntryClientCR);
     if (hasServerRouting)
-        entriesVirtualFiles.push(virtualFileIdImportUserCodeClientSR);
+        entriesVirtualFiles.push(virtualFileIdEntryClientSR);
     return entriesVirtualFiles;
 }
 function normalizeEntries(entries) {

package/dist/esm/node/{plugin/plugins/devConfig/index.d.ts → vite/plugins/pluginDev.d.ts}

@@ -1,5 +1,5 @@
-export { devConfig };
+export { pluginDev };
 export { logDockerHint };
 import type { Plugin, ResolvedConfig } from 'vite';
-declare function devConfig(): Plugin[];
+declare function pluginDev(): Plugin[];
 declare function logDockerHint(configHost: ResolvedConfig['server']['host']): void;

package/dist/esm/node/{plugin/plugins/devConfig/index.js → vite/plugins/pluginDev.js}

@@ -1,21 +1,21 @@
-export { devConfig };
+export { pluginDev };
 export { logDockerHint };
-import { determineOptimizeDeps } from './determineOptimizeDeps.js';
-import { determineFsAllowList } from './determineFsAllowList.js';
-import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
-import { applyDev, assertWarning, isDocker } from '../../utils.js';
-import { improveViteLogs } from '../../shared/loggerVite.js';
-import { isErrorDebug } from '../../../shared/isErrorDebug.js';
-import { installHttpRequestAsyncStore } from '../../shared/getHttpRequestAsyncStore.js';
+import { determineOptimizeDeps } from './pluginDev/determineOptimizeDeps.js';
+import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
+import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
+import { applyDev, assertWarning, isDocker } from '../utils.js';
+import { improveViteLogs } from '../shared/loggerVite.js';
+import { isErrorDebug } from '../../shared/isErrorDebug.js';
+import { installHttpRequestAsyncStore } from '../shared/getHttpRequestAsyncStore.js';
 import pc from '@brillout/picocolors';
 if (isErrorDebug()) {
     Error.stackTraceLimit = Infinity;
 }
-function devConfig() {
+function pluginDev() {
     let config;
     return [
         {
-            name: 'vike:devConfig',
+            name: 'vike:pluginDev',
             apply: applyDev,
             config() {
                 return {
@@ -51,9 +51,9 @@ function devConfig() {
                             // // ../../node_modules/.pnpm/react-streaming@0.3.16_react-dom@18.2.0_react@18.2.0/node_modules/react-streaming/dist/esm/client/useAsync.js
                             // import { parse as parse2 } from "@brillout/json-serializer/parse";
                             // ```
-                            'react-streaming'
-                        ]
-                    }
+                            'react-streaming',
+                        ],
+                    },
                 };
             },
             async configResolved(config_) {
@@ -65,10 +65,10 @@ function devConfig() {
                     improveViteLogs(config);
                 }
                 logDockerHint(config.server.host);
-            }
+            },
         },
         {
-            name: 'vike:devConfig:addSsrMiddleware',
+            name: 'vike:pluginDev:addSsrMiddleware',
             apply: applyDev,
             // The SSR middleware should be last middleware
             enforce: 'post',
@@ -81,7 +81,7 @@ function devConfig() {
                     return () => {
                         addSsrMiddleware(server.middlewares, config, false, null);
                     };
-                }
+                },
             },
             // Setting `configResolved.clearScreen = false` doesn't work
             config: {
@@ -90,9 +90,9 @@ function devConfig() {
                     if (isErrorDebug()) {
                         return { clearScreen: false };
                     }
-                }
-            }
-        }
+                },
+            },
+        },
     ];
 }
 function logDockerHint(configHost) {

package/dist/esm/node/vite/plugins/pluginEnvVars.d.ts

@@ -0,0 +1,3 @@
+export { pluginEnvVars };
+import type { Plugin } from 'vite';
+declare function pluginEnvVars(): Plugin;

package/dist/esm/node/{plugin/plugins/envVars.js → vite/plugins/pluginEnvVars.js}

@@ -1,7 +1,7 @@
-export { envVarsPlugin };
+export { pluginEnvVars };
 import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
@@ -9,17 +9,17 @@ import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.
 // TODO/enventually:
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
-//   - Or stop using Vite's `mode` implemention and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
 const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
 const PUBLIC_ENV_ALLOWLIST = [
     // https://github.com/vikejs/vike/issues/1724
-    'STORYBOOK'
+    'STORYBOOK',
 ];
-function envVarsPlugin() {
+function pluginEnvVars() {
     let envsAll;
     let config;
     return {
-        name: 'vike:envVars',
+        name: 'vike:pluginEnvVars',
         enforce: 'post',
         configResolved(config_) {
             config = config_;
@@ -82,8 +82,8 @@ function envVarsPlugin() {
                 return null;
             return {
                 code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id })
+                map: magicString.generateMap({ hires: true, source: id }),
             };
-        }
+        },
     };
 }

package/dist/esm/node/{plugin/plugins/extractAssetsPlugin.d.ts → vite/plugins/pluginExtractAssets.d.ts}

@@ -1,5 +1,5 @@
-export { extractAssetsPlugin };
+export { pluginExtractAssets };
 export { extractAssetsRE };
 import type { Plugin } from 'vite';
 declare const extractAssetsRE: RegExp;
-declare function extractAssetsPlugin(): Plugin[];
+declare function pluginExtractAssets(): Plugin[];