vike 0.4.247 → 0.4.249

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

@@ -1,230 +0,0 @@
-export { pluginVirtualFiles };
-import { normalizePath } from 'vite';
-import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
-import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
-import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, escapeRegex, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../utils.js';
-import { parseVirtualFileId } from '../../shared/virtualFileId.js';
-import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
-import pc from '@brillout/picocolors';
-import { logConfigInfo } from '../shared/loggerNotProd.js';
-import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
-import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
-import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
-import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
-import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
-const filterRolldown = {
-    id: {
-        include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
-    },
-};
-const filterFunction = (id) => isVirtualFileId(id);
-function pluginVirtualFiles() {
-    let config;
-    return [
-        {
-            name: 'vike:pluginVirtualFiles',
-            configResolved: {
-                async handler(config_) {
-                    config = config_;
-                    // TO-DO/next-major-release: remove
-                    if (!isV1Design())
-                        config.experimental.importGlobRestoreExtension = true;
-                },
-            },
-            resolveId: {
-                filter: filterRolldown,
-                handler(id) {
-                    assert(filterFunction(id));
-                    return addVirtualFileIdPrefix(id);
-                },
-            },
-            handleHotUpdate: {
-                async handler(ctx) {
-                    try {
-                        return await handleHotUpdate(ctx, config);
-                    }
-                    catch (err) {
-                        // Vite swallows errors thrown by handleHotUpdate()
-                        console.error(err);
-                        throw err;
-                    }
-                },
-            },
-            load: {
-                filter: filterRolldown,
-                async handler(id, options) {
-                    assert(filterFunction(id));
-                    id = removeVirtualFileIdPrefix(id);
-                    const isDev = config._isDev;
-                    assert(typeof isDev === 'boolean');
-                    const idParsed = parseVirtualFileId(id);
-                    if (idParsed) {
-                        if (idParsed.type === 'page-entry') {
-                            const code = await generateVirtualFilePageEntry(id, isDev);
-                            return code;
-                        }
-                        if (idParsed.type === 'global-entry') {
-                            const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
-                            return code;
-                        }
-                    }
-                },
-            },
-            configureServer: {
-                handler(server) {
-                    handleFileAddRemove(server, config);
-                },
-            },
-        },
-    ];
-}
-function handleFileAddRemove(server, config) {
-    server.watcher.prependListener('add', (f) => listener(f, false));
-    server.watcher.prependListener('unlink', (f) => listener(f, true));
-    return;
-    async function listener(file, isRemove) {
-        file = normalizePath(file);
-        if (isTemporaryBuildFile(file))
-            return;
-        const { moduleGraph } = server;
-        const isVikeConfigDep = await isVikeConfigDependency(file, moduleGraph);
-        const reload = () => reloadConfig(file, config, isRemove ? 'removed' : 'created', server);
-        // Config code
-        if (isVikeConfigDep && !isVikeConfigDep.isProcessedByVite) {
-            reload();
-            return;
-        }
-        // New or deleted + file
-        if (isPlusFile(file)) {
-            reload();
-            return;
-        }
-        // Runtime code => let Vite handle it
-        if (isVikeConfigDep && isVikeConfigDep.isProcessedByVite) {
-            assert(existsInViteModuleGraph(file, moduleGraph));
-            return;
-        }
-        // Trick: when importing a file that doesn't exist => we don't know whether `file` is that missing file => we take a leap of faith when the conditions below are met.
-        // - Not sure how reliable that trick is.
-        // - Reloading Vike's config is cheap and file creation/removal is rare => the trick is worth it.
-        // - Reproduction:
-        //   ```bash
-        //   rm someDep.js && sleep 2 && git checkout someDep.js
-        //   ```
-        if (isScriptFile(file) && getVikeConfigError() && !existsInViteModuleGraph(file, moduleGraph)) {
-            reload();
-            return;
-        }
-    }
-}
-function invalidateVikeVirtualFiles(server) {
-    const vikeVirtualFiles = getVikeVirtualFiles(server);
-    vikeVirtualFiles.forEach((mod) => {
-        server.moduleGraph.invalidateModule(mod);
-    });
-}
-// Vite calls its hook handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as `pages/+config.js`
-async function handleHotUpdate(ctx, config) {
-    const { file, server } = ctx;
-    const isVikeConfigDep = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
-    if (isVikeConfigDep) {
-        if (!isVikeConfigDep.isProcessedByVite) {
-            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
-            const isViteModule = ctx.modules.length > 0
-            assert(!isViteModule)
-            */
-            reloadConfig(file, config, 'modified', server);
-            // Files such as `pages/+config.js` can potentially modify Vike's virtual files.
-            // Triggers a full page reload
-            const vikeVirtualFiles = getVikeVirtualFiles(server);
-            return vikeVirtualFiles;
-        }
-        else {
-            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
-            // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
-            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            if (isRunnable(server)) {
-                await updateUserFiles();
-            }
-        }
-    }
-}
-async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
-    // Non-runtime Vike config files such as `pages/+config.js` which aren't processed by Vite.
-    // - They're missing in Vite's module graph.
-    // - Potentially modifies Vike's virtual files.
-    // - Same for all `pages/+config.js` dependencies.
-    assertPosixPath(filePathAbsoluteFilesystem);
-    const vikeConfigObject = await getVikeConfigInternalOptional();
-    if (vikeConfigObject) {
-        const { _vikeConfigDependencies: vikeConfigDependencies } = vikeConfigObject;
-        vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-        if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-            return { isProcessedByVite: false };
-    }
-    // Runtime Vike config files such as +data.js which are processed by Vite.
-    // - They're included in Vite's module graph.
-    // - They never modify Vike's virtual files.
-    // - Same for all `+data.js` dependencies.
-    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
-    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
-    if (isPlusValueFileDependency)
-        return { isProcessedByVite: true };
-    return null;
-}
-function reloadConfig(filePath, config, op, server) {
-    // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
-    invalidateVikeVirtualFiles(server);
-    {
-        const filePathToShowToUserResolved = getFilePathToShowToUserModule(filePath, config);
-        const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
-        logConfigInfo(msg, 'info');
-    }
-    reloadVikeConfig();
-    updateUserFiles();
-}
-function getVikeVirtualFiles(server) {
-    const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
-        .filter((url) => parseVirtualFileId(url))
-        .map((url) => {
-        const mod = server.moduleGraph.urlToModuleMap.get(url);
-        assert(mod);
-        return mod;
-    });
-    return vikeVirtualFiles;
-}
-// Get all transitive importers (including the module itself)
-function getImporters(file, moduleGraph) {
-    const importers = new Set();
-    const mods = moduleGraph.getModulesByFile(file);
-    if (!mods)
-        return importers;
-    for (const mod of mods) {
-        getModuleImporters(mod).forEach((importer) => {
-            if (importer)
-                importers.add(importer);
-        });
-    }
-    return importers;
-}
-function getModuleImporters(mod, seen = new Set()) {
-    if (seen.has(mod))
-        return new Set();
-    seen.add(mod);
-    const importers = new Set();
-    if (mod.id)
-        importers.add(mod);
-    // Traverse through the importers (modules that import this module)
-    for (const importer of mod.importers) {
-        if (importer.id)
-            importers.add(importer);
-        getModuleImporters(importer, seen).forEach((importerTransitive) => {
-            if (importerTransitive)
-                importers.add(importerTransitive);
-        });
-    }
-    return importers;
-}
-function existsInViteModuleGraph(file, moduleGraph) {
-    return !!moduleGraph.getModulesByFile(file);
-}

package/dist/esm/node/vite/shared/addSsrMiddleware.js

@@ -1,55 +0,0 @@
-export { addSsrMiddleware };
-import { renderPage } from '../../runtime/renderPage.js';
-import { assertWarning } from '../utils.js';
-import pc from '@brillout/picocolors';
-function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
-    middlewares.use(async (req, res, next) => {
-        if (res.headersSent)
-            return next();
-        const url = req.originalUrl || req.url;
-        if (!url)
-            return next();
-        const { headers } = req;
-        const pageContextInit = {
-            urlOriginal: url,
-            headersOriginal: headers,
-        };
-        Object.defineProperty(pageContextInit, 'userAgent', {
-            get() {
-                // TO-DO/next-major-release: assertUsage() instead of assertWarning()
-                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
-                    showStackTrace: true,
-                    onlyOnce: true,
-                });
-                return headers['user-agent'];
-            },
-            enumerable: false,
-        });
-        let pageContext;
-        try {
-            pageContext = await renderPage(pageContextInit);
-        }
-        catch (err) {
-            // Throwing an error in a connect middleware shut downs the server
-            console.error(err);
-            // - next(err) automatically uses buildErrorMessage() (pretty formatting of Rollup errors)
-            //   - But it only works for users using Vite's standalone dev server (it doesn't work for users using Vite's dev middleware)
-            // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
-            return next();
-        }
-        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
-            // Serve /dist/client/404.html instead
-            return next();
-        }
-        const configHeaders = (isPreview && config?.preview?.headers) || config?.server?.headers;
-        if (configHeaders) {
-            for (const [name, value] of Object.entries(configHeaders))
-                if (value)
-                    res.setHeader(name, value);
-        }
-        const { httpResponse } = pageContext;
-        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
-        res.statusCode = httpResponse.statusCode;
-        httpResponse.pipe(res);
-    });
-}

package/dist/esm/node/vite/shared/findPageFiles.d.ts

@@ -1,4 +0,0 @@
-export { findPageFiles };
-import type { ResolvedConfig } from 'vite';
-import type { FileType } from '../../../shared/getPageFiles/fileTypes.js';
-declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;

package/dist/esm/node/vite/shared/getClientEntrySrcDev.js

@@ -1,40 +0,0 @@
-export { getClientEntrySrcDev };
-import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveDistFile, } from '../utils.js';
-assertIsNotProductionRuntime();
-function getClientEntrySrcDev(clientEntry, viteDevServer) {
-    let userRootDir = viteDevServer.config.root;
-    assert(userRootDir);
-    userRootDir = toPosixPath(userRootDir);
-    // The `?import` suffix is needed for MDX to be transpiled:
-    //   - Not transpiled: `/pages/markdown.page.mdx`
-    //   - Transpiled: `/pages/markdown.page.mdx?import`
-    // But `?import` doesn't work with `/@fs/`:
-    //   - Not transpiled: /@fs/home/runner/work/vike/packages/vike/examples/react-full/pages/markdown.page.mdx
-    //   - Not transpiled: /@fs/home/runner/work/vike/packages/vike/examples/react-full/pages/markdown.page.mdx?import
-    if (clientEntry.endsWith('?import')) {
-        assert(clientEntry.startsWith('/'));
-        return clientEntry;
-    }
-    assertPosixPath(clientEntry);
-    let filePath;
-    if (clientEntry.startsWith('/')) {
-        filePath = pathJoin(userRootDir, clientEntry);
-    }
-    else {
-        if (clientEntry.startsWith('@@vike/')) {
-            assert(clientEntry.endsWith('.js'));
-            filePath = requireResolveDistFile(`dist/esm/${clientEntry.replace('@@vike/dist/esm/', '')}`);
-        }
-        else {
-            assertIsImportPathNpmPackage(clientEntry);
-            filePath = requireResolveNpmPackage({ importPathNpmPackage: clientEntry, userRootDir });
-        }
-    }
-    if (!filePath.startsWith('/')) {
-        assert(process.platform === 'win32');
-        filePath = '/' + filePath;
-    }
-    filePath = '/@fs' + filePath;
-    assertPosixPath(filePath);
-    return filePath;
-}

package/dist/esm/node/vite/shared/getHttpRequestAsyncStore.d.ts

@@ -1,10 +0,0 @@
-export { getHttpRequestAsyncStore };
-export { installHttpRequestAsyncStore };
-type HttpRequestAsyncStore = {
-    httpRequestId: number;
-    shouldErrorBeSwallowed: (err: unknown) => boolean;
-    markErrorAsLogged: (err: unknown) => void;
-    errorDebugNoteAlreadyShown: boolean;
-};
-declare function installHttpRequestAsyncStore(): Promise<void>;
-declare function getHttpRequestAsyncStore(): null | undefined | HttpRequestAsyncStore;

package/dist/esm/node/vite/shared/getHttpRequestAsyncStore.js

@@ -1,95 +0,0 @@
-// Purpose of this file:
-//  - Swallow redundant error messages (Vite is buggy and emits the same error multiple times)
-//  - Prepend "[request(n)]" tag to Vite logs
-// The mechanism is skipped if the development environment doesn't support Async Hooks.
-// We purposely don't use config.logger.hasErrorLogged(err) because:
-// - We don't trust Vite with such details
-//   - Example of Vite bug leading to swallowing of errors: https://github.com/vitejs/vite/issues/12631
-// - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
-export { getHttpRequestAsyncStore };
-export { installHttpRequestAsyncStore };
-import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
-import { assert, assertIsNotProductionRuntime, getGlobalObject, isObject, unique } from '../utils.js';
-import { getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
-import { logErrorDebugNote } from './loggerNotProd.js';
-import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { isDeepStrictEqual } from 'node:util';
-assertIsNotProductionRuntime();
-const globalObject = getGlobalObject('getHttpRequestAsyncStore.ts', {
-    asyncLocalStorage: null,
-});
-async function installHttpRequestAsyncStore() {
-    let mod;
-    try {
-        mod = await import('node:async_hooks');
-    }
-    catch {
-        return;
-    }
-    globalObject.asyncLocalStorage = new mod.AsyncLocalStorage();
-    renderPage_addAsyncHookwrapper(async (httpRequestId, renderPage) => {
-        assert(globalObject.asyncLocalStorage);
-        const loggedErrors = new Set();
-        const markErrorAsLogged = (err) => {
-            loggedErrors.add(err);
-        };
-        const shouldErrorBeSwallowed = (err) => {
-            if (loggedErrors.has(err) ||
-                Array.from(loggedErrors).some((errAlreadyLogged) => isEquivalent(err, errAlreadyLogged))) {
-                // In principle, some random message can be shown between the non-swallowed error and this logErrorDebugNote() call.
-                // We take a leap of faith that it happens only seldom and that it's worth the risk.
-                logErrorDebugNote();
-                return true;
-            }
-            else {
-                return false;
-            }
-        };
-        const store = {
-            httpRequestId,
-            markErrorAsLogged,
-            shouldErrorBeSwallowed,
-            errorDebugNoteAlreadyShown: false,
-        };
-        const pageContextReturn = await globalObject.asyncLocalStorage.run(store, renderPage);
-        return { pageContextReturn };
-    });
-    return;
-}
-function getHttpRequestAsyncStore() {
-    if (globalObject.asyncLocalStorage === null)
-        return null;
-    const store = globalObject.asyncLocalStorage.getStore();
-    assert(store === undefined || isObject(store));
-    return store;
-}
-function isEquivalent(err1, err2) {
-    if (err1 === err2)
-        return true;
-    if (!isObject(err1) || !isObject(err2))
-        return false;
-    {
-        const errMsgFormatted1 = getConfigBuildErrorFormatted(err1);
-        const errMsgFormatted2 = getConfigBuildErrorFormatted(err2);
-        if (errMsgFormatted1 && errMsgFormatted1 === errMsgFormatted2)
-            return true;
-    }
-    if (isEquivalentErrorWithCodeSnippet(err1, err2))
-        return true;
-    if (unique([
-        // error.message and error.stack aren't enumerable and therefore not listed by Object.keys()
-        'message',
-        'stack',
-        ...Object.keys(err1),
-        ...Object.keys(err2),
-    ]).every((k) => {
-        // isDeepStrictEqual() need to compare error.position which is an object.
-        if (isDeepStrictEqual(err1[k], err2[k]))
-            return true;
-        // console.log('diff', k)
-        return false;
-    })) {
-        return true;
-    }
-    return false;
-}

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -1,141 +0,0 @@
-export { getOutDirs };
-export { resolveOutDir };
-import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerSide_viteEnvOptional } from './isViteServerSide.js';
-const debug = createDebugger('vike:outDir');
-function getOutDirs(configGlobal, viteEnv) {
-    debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
-    assertOutDirResolved(outDir, configGlobal, viteEnv);
-    const outDirs = getOutDirsAll(outDir, configGlobal.root);
-    assertNormalization(outDirs.outDirRoot);
-    assertNormalization(outDirs.outDirClient);
-    assertNormalization(outDirs.outDirServer);
-    return outDirs;
-}
-/** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config, isServerSide) {
-    debug('resolveOutDir()');
-    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
-    debug('outDir', outDir);
-    const { outDirClient, outDirServer } = getOutDirsAll(outDir);
-    if (isServerSide) {
-        debug('outDirServer', 'outDirServer');
-        return outDirServer;
-    }
-    else {
-        debug('outDirClient', 'outDirClient');
-        return outDirClient;
-    }
-}
-function determineOutDirs(outDirRoot) {
-    assertPosixPath(outDirRoot);
-    assert(isOutDirRoot(outDirRoot));
-    const outDirClient = pathJoin(outDirRoot, 'client');
-    const outDirServer = pathJoin(outDirRoot, 'server');
-    assertIsNotOutDirRoot(outDirClient);
-    assertIsNotOutDirRoot(outDirServer);
-    return { outDirClient, outDirServer };
-}
-function getOutDirsAll(outDir, root) {
-    let outDirRoot;
-    {
-        if (isOutDirRoot(outDir)) {
-            outDirRoot = outDir;
-        }
-        else {
-            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
-            assert('/client'.length === '/server'.length);
-            outDirRoot = outDir.slice(0, -1 * '/client'.length);
-        }
-    }
-    debug('outDirRoot', outDirRoot);
-    let outDirs;
-    if (root) {
-        outDirs = getOutDirsAllFromRootNormalized(outDirRoot, root);
-    }
-    else {
-        outDirs = getOutDirsAllFromRoot(outDirRoot);
-    }
-    debug('outDirs', outDirs);
-    return outDirs;
-}
-function getOutDirsAllFromRoot(outDirRoot) {
-    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
-    return { outDirRoot, outDirClient, outDirServer };
-}
-function getOutDirsAllFromRootNormalized(outDirRoot, root) {
-    if (root && !outDirIsAbsolutePath(outDirRoot)) {
-        assertPosixPath(outDirRoot);
-        assertPosixPath(root);
-        outDirRoot = pathJoin(root, outDirRoot);
-    }
-    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
-    outDirRoot = outDirRoot + '/';
-    outDirClient = outDirClient + '/';
-    outDirServer = outDirServer + '/';
-    assertNormalization(outDirRoot);
-    assertNormalization(outDirClient);
-    assertNormalization(outDirServer);
-    return { outDirRoot, outDirClient, outDirServer };
-}
-function assertNormalization(outDirAny) {
-    assertPosixPath(outDirAny);
-    assert(outDirIsAbsolutePath(outDirAny), outDirAny);
-    assert(outDirAny.endsWith('/'), outDirAny);
-    assert(!outDirAny.endsWith('//'), outDirAny);
-}
-function isOutDirRoot(outDirRot) {
-    const p = outDirRot.split('/').filter(Boolean);
-    const lastDir = p[p.length - 1];
-    return lastDir !== 'client' && lastDir !== 'server';
-}
-function assertIsNotOutDirRoot(outDir) {
-    assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
-}
-/** Assert that `outDir` ends with the correct directory `/server` or `/client` */
-function assertOutDirResolved(outDir, configGlobal, viteEnv) {
-    assertPosixPath(outDir);
-    if (isOutDirRoot(outDir))
-        return;
-    assert(outDir.endsWith('/client') || outDir.endsWith('/server')); // we normalized outDir
-    assert('/client'.length === '/server'.length);
-    const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
-    const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    const isServerSide = isViteServerSide_viteEnvOptional(configGlobal, viteEnv);
-    if (isServerSide) {
-        assertUsage(outDir.endsWith('/server'), wrongUsage);
-    }
-    else {
-        assertUsage(outDir.endsWith('/client'), wrongUsage);
-    }
-}
-function getOutDirFromViteUserConfig(config) {
-    let outDir = config.build?.outDir;
-    if (outDir === undefined)
-        return undefined;
-    outDir = normalizeOutDir(outDir);
-    return outDir;
-}
-function getOutDirFromResolvedConfig(config, viteEnv) {
-    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
-    assert(outDir);
-    outDir = normalizeOutDir(outDir);
-    return outDir;
-}
-function normalizeOutDir(outDir) {
-    outDir = toPosixPath(outDir);
-    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
-    return outDir;
-}
-function outDirIsAbsolutePath(outDir) {
-    // There doesn't seem to be a better alternative to determine whether `outDir` is an absolute path
-    //  - Very unlikely that `outDir`'s first dir matches the filesystem's first dir
-    //    - Although more likely to happen with Docker
-    return getFirstDir(outDir) === getFirstDir(process.cwd());
-}
-function getFirstDir(p) {
-    const firstDir = p.split(/\/|\\/).filter(Boolean)[0];
-    return firstDir;
-}

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -1,75 +0,0 @@
-export { isViteServerSide };
-export { isViteServerSide_viteEnvOptional };
-export { isViteServerSide_onlySsrEnv };
-export { isViteServerSide_extraSafe };
-export { isViteServerSide_applyToEnvironment };
-export { isViteServerSide_configEnvironment };
-import { assert } from '../../../utils/assert.js';
-function isViteServerSide_impl(configGlobal, viteEnv) {
-    assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
-    const debug = {
-        viteEnvIsUndefined: !viteEnv,
-        viteEnvName: viteEnv?.name ?? null,
-        viteEnvConsumer: viteEnv?.config.consumer ?? null,
-        configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
-        configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
-    };
-    if (!viteEnv) {
-        const isServerSide = getBuildSsrValue(configGlobal.build?.ssr);
-        assert(typeof isServerSide === 'boolean', debug);
-        return isServerSide;
-    }
-    else {
-        const isServerSide1 = !viteEnv.config.consumer ? null : viteEnv.config.consumer !== 'client';
-        const isServerSide2 = getBuildSsrValue(viteEnv.config.build?.ssr);
-        const isServerSide3 = viteEnv.name === 'ssr' ? true : viteEnv.name === 'client' ? false : null;
-        const isServerSide = isServerSide1 ?? isServerSide2;
-        assert(isServerSide === isServerSide1 || isServerSide1 === null, debug);
-        assert(isServerSide === isServerSide2 || isServerSide2 === null, debug);
-        assert(isServerSide === isServerSide3 || isServerSide3 === null, debug);
-        assert(isServerSide !== null);
-        return isServerSide;
-    }
-}
-function getBuildSsrValue(buildSsr) {
-    if (buildSsr === undefined)
-        return null;
-    assert(typeof buildSsr === 'boolean' || typeof buildSsr === 'string');
-    return !!buildSsr;
-}
-function isViteServerSide(configGlobal, viteEnv) {
-    return isViteServerSide_impl(configGlobal, viteEnv);
-}
-function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
-    return isViteServerSide_impl(configGlobal, viteEnv);
-}
-// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
-function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
-    return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
-}
-// Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
-function isViteServerSide_extraSafe(config, viteEnv, options) {
-    const isServerSide = isViteServerSide(config, viteEnv);
-    const debug = {
-        isServerSide,
-        configCommand: config.command,
-        configBuildSsr: getBuildSsrValue(config.build.ssr),
-        optionsIsUndefined: options === undefined,
-        optionsSsr: options?.ssr ?? null,
-    };
-    assert(options, debug);
-    assert(typeof options.ssr === 'boolean', debug);
-    assert(options.ssr === isServerSide, debug);
-    return isServerSide;
-}
-function isViteServerSide_applyToEnvironment(env) {
-    const { consumer } = env.config;
-    return isViteServerSide_consumer(consumer);
-}
-function isViteServerSide_configEnvironment(name, config) {
-    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
-    return isViteServerSide_consumer(consumer);
-}
-function isViteServerSide_consumer(consumer) {
-    return consumer !== 'client';
-}

package/dist/esm/node/vite/shared/loggerNotProd/errorWithCodeSnippet.d.ts

@@ -1,15 +0,0 @@
-export { getPrettyErrorWithCodeSnippet };
-export { isErrorWithCodeSnippet };
-export { isEquivalentErrorWithCodeSnippet };
-export type { ErrorWithCodeSnippet };
-export { getPrettyErrMessage };
-type ErrorWithCodeSnippet = {
-    id: string;
-    frame?: string;
-    message?: string;
-    plugin?: string;
-};
-declare function isErrorWithCodeSnippet(err: unknown): err is ErrorWithCodeSnippet;
-declare function getPrettyErrorWithCodeSnippet(err: ErrorWithCodeSnippet, userRootDir: string): string;
-declare function getPrettyErrMessage(err: ErrorWithCodeSnippet): string | null;
-declare function isEquivalentErrorWithCodeSnippet(err1: unknown, err2: unknown): boolean;