vike 0.4.255 → 0.4.256-commit-414bdc0

package/dist/node/vite/index.js

@@ -40,6 +40,7 @@ import { pluginStripPointerImportAttribute } from './plugins/pluginStripPointerI
 import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 import './assertEnvVite.js';
 import { isStorybook } from '../../utils/isStorybook.js';
+import { pluginUniversalDeploy } from './plugins/pluginUniversalDeploy.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
@@ -70,6 +71,7 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginStaticReplace(vikeConfig),
             ...pluginNonRunnabeDev(),
             ...pluginStripPointerImportAttribute(),
+            ...pluginUniversalDeploy(vikeConfig),
             ...(await pluginViteConfigVikeExtensions(vikeConfig)),
         ];
         Object.assign(plugin, pluginAddendum);

package/dist/node/vite/plugins/pluginExtractAssets.js

@@ -41,6 +41,8 @@ const filterFunction = (id) => extractAssetsRE.test(id);
 function pluginExtractAssets() {
     let config;
     let vikeConfig;
+    if (handleAssetsManifest_isFixEnabled())
+        return [];
     let isFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also static files imports e.g. `import logoURL from './logo.svg.js'`).

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -39,9 +39,11 @@ function pluginReplaceConstantsGlobalThis() {
                 },
             },
             configEnvironment: {
+                order: 'pre',
                 handler(name, config) {
                     const isClientSide = !isViteServerSide_configEnvironment(name, config);
                     return {
+                        consumer: isClientSide ? 'client' : 'server',
                         define: {
                             'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
                         },

package/dist/node/vite/plugins/pluginUniversalDeploy/common.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+export declare const pluginCommon: {
+    applyToEnvironment(env: {
+        name: string;
+        getTopLevelConfig(): import("vite").ResolvedConfig;
+        config: import("vite").ResolvedConfig & {
+            define?: Record<string, any>;
+            resolve: Required<import("vite").ResolveOptions>;
+            consumer: "client" | "server";
+            keepProcessEnv?: boolean;
+            optimizeDeps: import("vite").DepOptimizationOptions;
+            dev: import("vite").ResolvedDevEnvironmentOptions;
+            build: import("vite").ResolvedBuildEnvironmentOptions;
+            plugins: readonly Plugin[];
+        };
+        logger: import("vite").Logger;
+    }): boolean;
+    sharedDuringBuild: true;
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/common.js

@@ -0,0 +1,7 @@
+import '../../assertEnvVite.js';
+export const pluginCommon = {
+    applyToEnvironment(env) {
+        return env.config.consumer === 'server';
+    },
+    sharedDuringBuild: true,
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.d.ts

@@ -0,0 +1,3 @@
+import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+export declare function hasVikeServerOrVikePhoton(vikeConfig: VikeConfigInternal): true | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.js

@@ -0,0 +1,15 @@
+import { assertWarning } from '../../../../utils/assert.js';
+import pc from '@brillout/picocolors';
+import '../../assertEnvVite.js';
+export function hasVikeServerOrVikePhoton(vikeConfig) {
+    const vikeExtendsNames = new Set(vikeConfig._extensions.map((plusFile) => ('fileExportsByConfigName' in plusFile ? plusFile.fileExportsByConfigName : {}).name));
+    const vikeServerOrVikePhoton = vikeExtendsNames.has('vike-server')
+        ? 'vike-server'
+        : vikeExtendsNames.has('vike-photon')
+            ? 'vike-photon'
+            : null;
+    if (vikeServerOrVikePhoton) {
+        assertWarning(false, `${pc.cyan(vikeServerOrVikePhoton)} is deprecated, see ${pc.underline('https://vike.dev/migration/universal-deploy')}`, { onlyOnce: true });
+        return true;
+    }
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfigs.d.ts

@@ -0,0 +1,27 @@
+export { getDeployConfigs };
+import type { fromVike } from 'convert-route';
+import type { PageConfigPublicWithRoute } from '../../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import '../../assertEnvVite.js';
+declare function getDeployConfigs(pageId: string, page: PageConfigPublicWithRoute): {
+    route: string;
+    vercel: {
+        isr: {
+            expiration: number;
+        } | undefined;
+        edge: boolean;
+    };
+} | null;
+export declare function getPageContextRoute(routeIr: ReturnType<typeof fromVike>): {
+    pathname: ({
+        optional: boolean;
+    } & ({
+        value: string;
+        catchAll?: never;
+    } | {
+        value?: never;
+        catchAll: {
+            name?: string;
+            greedy: boolean;
+        };
+    }))[];
+} | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfigs.js

@@ -0,0 +1,70 @@
+import pc from '@brillout/picocolors';
+export { getDeployConfigs };
+import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
+import { isObject } from '../../../../utils/isObject.js';
+import '../../assertEnvVite.js';
+function getDeployConfigs(pageId, page) {
+    const route = typeof page.route === 'string' ? page.route : null;
+    // Vercel specific configs
+    const rawIsr = extractIsr(page.config);
+    let isr = assertIsr(rawIsr);
+    const edge = extractEdge(page.config);
+    const isrOrEdge = isr ? 'isr' : edge ? 'edge' : null;
+    if (typeof page.route === 'function' && isrOrEdge) {
+        assertWarning(false, `Page ${pageId}: ${pc.cyan(isrOrEdge)} is not supported when using route function. Remove ${pc.cyan(isrOrEdge)} config or use a route string if possible.`, { onlyOnce: true });
+        isr = null;
+    }
+    if (edge && rawIsr !== null && typeof rawIsr === 'object') {
+        assertUsage(false, `Page ${pageId}: ISR cannot be enabled for edge functions. Remove ${pc.cyan('isr')} config or set \`{ edge: false }\`.`);
+    }
+    if (isrOrEdge && route) {
+        return {
+            route,
+            // route: [...new Set([...toRou3(routeIr), ...getPageContextRoute(routeIr)])],
+            // Supported by vite-plugin-vercel@11
+            vercel: {
+                isr: isr ? { expiration: isr } : undefined,
+                edge: Boolean(edge),
+            },
+        };
+    }
+    return null;
+}
+function extractIsr(pageConfig) {
+    if (!pageConfig.isr)
+        return null;
+    const isr = pageConfig.isr;
+    assertUsage(isObject(isr) &&
+        typeof isr.expiration === 'number' &&
+        isr.expiration > 0, ' `{ expiration }` must be a positive number');
+    return isr;
+}
+function assertIsr(isr) {
+    if (isr === null || isr === undefined)
+        return null;
+    return isr.expiration;
+}
+function extractEdge(exports) {
+    if (exports === null || typeof exports !== 'object')
+        return null;
+    if (!('edge' in exports))
+        return null;
+    const edge = exports.edge;
+    assertUsage(typeof edge === 'boolean', ' `{ edge }` must be a boolean');
+    return edge;
+}
+export function getPageContextRoute(routeIr) {
+    const lastSegment = routeIr.pathname.at(-1);
+    assert(lastSegment);
+    if (lastSegment.catchAll)
+        return;
+    return {
+        pathname: [
+            ...routeIr.pathname.slice(0, -1),
+            {
+                ...lastSegment,
+                value: `${lastSegment.value}.pageContext.json`,
+            },
+        ],
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerInfo.d.ts

@@ -0,0 +1,7 @@
+import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+export declare function getServerInfo(vikeConfig: VikeConfigInternal): {
+    serverEntryId: string;
+    serverEntryVike: string;
+    serverFilePath: string | null;
+} | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerInfo.js

@@ -0,0 +1,33 @@
+import { assert } from '../../../../utils/assert.js';
+import { catchAllEntry } from '@universal-deploy/store';
+import '../../assertEnvVite.js';
+export function getServerInfo(vikeConfig) {
+    let serverEntryId;
+    let serverFilePath = null;
+    const serverConfig = vikeConfig.config.server;
+    // universal-deploy support manually disabled by user
+    if (serverConfig === false)
+        return;
+    const serverPlusFile = vikeConfig._pageConfigGlobal.configValueSources.server?.[0];
+    if (serverPlusFile) {
+        assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
+        serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
+        assert(serverFilePath);
+        serverEntryId = serverFilePath;
+    }
+    else {
+        serverEntryId = catchAllEntry;
+    }
+    if (serverConfig !== true && !serverFilePath)
+        return;
+    const serverEntryVike = serverFilePath ?? 'vike/fetch';
+    return {
+        // Used to filter which module ID to transform.
+        // It points to a fully resolved server entry or the virtual universal-deploy catchAll entry.
+        serverEntryId,
+        // This entry will be pushed to universal-deploy via `addEntry`.
+        // It either points to the default fetchable endpoint (vike/fetch), or one defined by the user through +server.
+        serverEntryVike,
+        serverFilePath,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolveAlias.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+export declare function pluginResolveAlias(): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolveAlias.js

@@ -0,0 +1,19 @@
+import { pluginCommon } from './common.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import { catchAllEntry } from '@universal-deploy/store';
+import '../../assertEnvVite.js';
+export function pluginResolveAlias() {
+    return {
+        name: 'vike:pluginUniversalDeploy:alias',
+        resolveId: {
+            filter: {
+                // User facing alias for virtual:ud:catch-all
+                id: new RegExp(escapeRegex('vike:server-entry')),
+            },
+            handler() {
+                return this.resolve(catchAllEntry);
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+/**
+ * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
+ */
+export declare function pluginVikeVirtualEntry(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.js

@@ -0,0 +1,22 @@
+import { pluginCommon } from './common.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+/**
+ * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
+ */
+export function pluginVikeVirtualEntry(serverFilePath) {
+    return {
+        name: 'vike:pluginUniversalDeploy:server',
+        resolveId: {
+            order: 'pre',
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+            handler() {
+                // Will resolve the entry from the users project root
+                return this.resolve(serverFilePath);
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+export declare function pluginUnwrapProdOptions(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.js

@@ -0,0 +1,19 @@
+import { wrapper } from 'vite-plugin-wrapper';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+export function pluginUnwrapProdOptions(serverFilePath) {
+    return wrapper({
+        resolveId: {
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+        },
+        // Unwrap all prod.* options
+        load(id) {
+            return `
+import mod from ${JSON.stringify(id)};
+export default { ...mod, ...mod?.prod };
+`;
+        },
+    });
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginVikeVirtualEntry.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+export declare function pluginVikeVirtualEntry(serverEntryId: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginVikeVirtualEntry.js

@@ -0,0 +1,25 @@
+import { getMagicString } from '../../shared/getMagicString.js';
+import { serverEntryVirtualId as vikeVirtualEntry } from '@brillout/vite-plugin-server-entry/plugin';
+import { pluginCommon } from './common.js';
+import '../../assertEnvVite.js';
+export function pluginVikeVirtualEntry(serverEntryId) {
+    return {
+        name: 'vike:pluginUniversalDeploy:serverEntry',
+        apply: 'build',
+        transform: {
+            order: 'post',
+            filter: {
+                id: {
+                    include: [serverEntryId],
+                },
+            },
+            handler(code, id) {
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                // Inject Vike virtual server entry
+                magicString.prepend(`import "${vikeVirtualEntry}";\n`);
+                return getMagicStringResult();
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy.d.ts

@@ -0,0 +1,5 @@
+export { pluginUniversalDeploy };
+import type { Plugin } from 'vite';
+import type { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+import '../assertEnvVite.js';
+declare function pluginUniversalDeploy(vikeConfig: VikeConfigInternal): Plugin[];

package/dist/node/vite/plugins/pluginUniversalDeploy.js

@@ -0,0 +1,58 @@
+import { toRou3 } from 'convert-route';
+export { pluginUniversalDeploy };
+import { addEntry } from '@universal-deploy/store';
+import universalDeploy from '@universal-deploy/vite';
+import { fromVike } from 'convert-route/vike';
+import { pluginVikeVirtualEntry } from './pluginUniversalDeploy/pluginVikeVirtualEntry.js';
+import { getDeployConfigs, getPageContextRoute } from './pluginUniversalDeploy/getDeployConfigs.js';
+import { pluginCommon } from './pluginUniversalDeploy/common.js';
+import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
+import { getServerInfo } from './pluginUniversalDeploy/getServerInfo.js';
+import { pluginResolveAlias } from './pluginUniversalDeploy/pluginResolveAlias.js';
+import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import '../assertEnvVite.js';
+import { unique } from '../../../utils/unique.js';
+function pluginUniversalDeploy(vikeConfig) {
+    if (hasVikeServerOrVikePhoton(vikeConfig))
+        return [];
+    const serverInfo = getServerInfo(vikeConfig);
+    if (!serverInfo)
+        return [];
+    const { serverEntryVike, serverEntryId, serverFilePath } = serverInfo;
+    const plugins = [
+        ...universalDeploy(),
+        {
+            name: 'vike:pluginUniversalDeploy:entries',
+            config() {
+                // Map each Vike route to universal-deploy
+                for (const [pageId, page] of Object.entries(vikeConfig.pages)) {
+                    const deployConfigs = getDeployConfigs(pageId, page);
+                    // Skip pages without deploy configs, as they will be handled by the catch-all route
+                    if (deployConfigs !== null) {
+                        const { route, ...additionalConfigs } = deployConfigs;
+                        const routeIr = fromVike(route);
+                        const pageContextRouteIr = getPageContextRoute(routeIr);
+                        addEntry({
+                            ...additionalConfigs,
+                            id: serverEntryVike,
+                            // Map Vike routes to rou3 format
+                            route: unique([...toRou3(routeIr), ...(pageContextRouteIr ? toRou3(pageContextRouteIr) : [])]),
+                        });
+                    }
+                }
+                // Default catch-all route
+                addEntry({
+                    id: serverEntryVike,
+                    route: '/**',
+                });
+            },
+            ...pluginCommon,
+        },
+        pluginVikeVirtualEntry(serverFilePath ?? serverEntryId),
+        pluginResolveAlias(),
+    ];
+    if (serverFilePath) {
+        plugins.push(pluginUnwrapProdOptions(serverFilePath));
+    }
+    return plugins;
+}

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

@@ -14,6 +14,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const pageContextInit = {
             urlOriginal: url,
             headersOriginal: headers,
+            _reqDev: req,
         };
         Object.defineProperty(pageContextInit, 'userAgent', {
             get() {

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -4,6 +4,7 @@ import { getConfigDefinedAt, } from '../../../../shared-server-client/page-confi
 import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 import '../../assertEnvVite.js';
+// TODO/after-PR-merge: rename_full configDefinitionsBuiltIn metaBuiltIn
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -225,6 +226,10 @@ const configDefinitionsBuiltIn = {
         eager: true,
         global: true,
     },
+    server: {
+        env: { server: true },
+        global: true,
+    },
     cli: {
         env: { config: true },
         global: true,
@@ -301,6 +306,19 @@ const configDefinitionsBuiltIn = {
         global: true,
         vite: true,
     },
+    license: {
+        env: { config: true },
+        global: true,
+    },
+    // -- Vercel --
+    isr: {
+        env: { server: true, config: true },
+        eager: true,
+    },
+    edge: {
+        env: { server: true, config: true },
+        eager: true,
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/server/assertEnvServer.js

@@ -20,7 +20,7 @@ function onLoad() {
     addEcosystemStamp();
 }
 // Used by:
-// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
+// - Telefunc (to detect the user's stack https://github.com/telefunc/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
 function addEcosystemStamp() {
     const g = globalThis;
     g._isVikeApp =

package/dist/server/runtime/fetch.d.ts

@@ -0,0 +1,10 @@
+import '../assertEnvServer.js';
+declare const _default: {
+    fetch: (<T extends string>(request: Request, context: Universal.Context, runtime: import("@universal-middleware/core").RuntimeAdapterTarget<T>) => Promise<Response>) & import("@universal-middleware/core").WithUniversalSymbols<{
+        name: string;
+        method: ("GET" | "HEAD" | "POST" | "PUT" | "OPTIONS" | "PATCH")[];
+        path: string;
+        immutable: true;
+    }>;
+};
+export default _default;

package/dist/server/runtime/fetch.js

@@ -0,0 +1,5 @@
+import '../assertEnvServer.js';
+import vikeHandler from './universal-middleware.js';
+export default {
+    fetch: vikeHandler,
+};