vike 0.4.247 → 0.4.249-commit-775a43e

package/dist/node/vite/utils.d.ts

@@ -0,0 +1,25 @@
+export * from '../../server/utils.js';
+export * from '../../utils/requireResolve.js';
+export * from '../../utils/includes.js';
+export * from '../../utils/isDev.js';
+export * from '../../utils/getMostSimilar.js';
+export * from '../../utils/getRandomId.js';
+export * from '../../utils/escapeRegex.js';
+export * from '../../utils/trimWithAnsi.js';
+export * from '../../utils/removeEmptyLines.js';
+export * from '../../utils/findPackageJson.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertVersion.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
+export * from '../../utils/isEqualStringList.js';
+export * from '../../utils/isDocker.js';
+export * from '../../utils/isVitest.js';
+export * from '../../utils/rollupSourceMap.js';
+export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';
+export * from '../../utils/assertViteVersion.js';
+export * from '../../utils/getBetterError.js';

package/dist/node/vite/utils.js

@@ -0,0 +1,31 @@
+// Utils needed by Vike's Vite plugin
+// We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
+import { onLoad } from './onLoad.js';
+onLoad();
+// We can load all server/utils.ts since node/vite/ imports server/runime/ anyways.
+export * from '../../server/utils.js';
+// Utils only needed by `plugin/*`
+export * from '../../utils/requireResolve.js';
+export * from '../../utils/includes.js';
+export * from '../../utils/isDev.js';
+export * from '../../utils/getMostSimilar.js';
+export * from '../../utils/getRandomId.js';
+export * from '../../utils/escapeRegex.js';
+export * from '../../utils/trimWithAnsi.js';
+export * from '../../utils/removeEmptyLines.js';
+export * from '../../utils/findPackageJson.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertVersion.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
+export * from '../../utils/isEqualStringList.js';
+export * from '../../utils/isDocker.js';
+export * from '../../utils/isVitest.js';
+export * from '../../utils/rollupSourceMap.js';
+export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';
+export * from '../../utils/assertViteVersion.js';
+export * from '../../utils/getBetterError.js';

package/dist/server/__internal/index.d.ts

@@ -0,0 +1,20 @@
+export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
+export { route, getPagesAndRoutes };
+export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
+import { route as routeInternal, type PageRoutes } from '../../shared-server-client/route/index.js';
+import type { PageFile } from '../../shared-server-client/getPageFiles/getPageFileObject.js';
+import { PageConfigRuntime } from '../../types/PageConfig.js';
+/**
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
+ *
+ * TO-DO/eventually: remove
+ */
+declare function getPagesAndRoutes(): Promise<{
+    pageRoutes: PageRoutes;
+    pageFilesAll: PageFile[];
+    pageConfigs: PageConfigRuntime[];
+    allPageIds: string[];
+}>;
+declare function route(pageContext: Parameters<typeof routeInternal>[0]): Promise<{
+    pageContextAddendum: import("../../shared-server-client/route/index.js").PageContextAfterRoute;
+}>;

package/dist/server/__internal/index.js

@@ -0,0 +1,31 @@
+// Used by vike:build:pluginProdBuildEntry
+export { setGlobalContext_prodBuildEntry } from '../runtime/globalContext.js';
+// Used by vite-plugin-vercel
+export { route, getPagesAndRoutes };
+import { route as routeInternal } from '../../shared-server-client/route/index.js';
+import { getGlobalContextServerInternal, initGlobalContext_getPagesAndRoutes } from '../runtime/globalContext.js';
+import { setNodeEnvProductionIfUndefined } from '../../utils/assertSetup.js';
+/**
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
+ *
+ * TO-DO/eventually: remove
+ */
+async function getPagesAndRoutes() {
+    setNodeEnvProductionIfUndefined();
+    await initGlobalContext_getPagesAndRoutes();
+    const { globalContext } = await getGlobalContextServerInternal();
+    const { 
+    //
+    _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds, } = globalContext;
+    return {
+        pageRoutes,
+        pageFilesAll,
+        pageConfigs,
+        allPageIds,
+    };
+}
+async function route(pageContext) {
+    const pageContextFromRoute = await routeInternal(pageContext);
+    // Old interface
+    return { pageContextAddendum: pageContextFromRoute };
+}

package/dist/server/__internal/vite.d.ts

@@ -0,0 +1 @@
+export { startupLog } from '../../node/api/dev.js';

package/dist/server/__internal/vite.js

@@ -0,0 +1 @@
+export { startupLog } from '../../node/api/dev.js';

package/dist/server/createPageRenderer.d.ts

@@ -0,0 +1,12 @@
+import { renderPageServer } from './runtime/renderPageServer.js';
+export { createPageRenderer };
+type Options = {
+    viteDevServer?: unknown;
+    root?: string;
+    outDir?: string;
+    isProduction?: boolean;
+    base?: string;
+    baseAssets?: string | null;
+};
+/** @deprecated */
+declare function createPageRenderer(options: Options): typeof renderPageServer;

package/dist/server/createPageRenderer.js

@@ -0,0 +1,131 @@
+// TO-DO/next-major-release: remove this file
+//import { SsrEnv, setSsrEnv } from './ssrEnv.js'
+import { renderPageServer } from './runtime/renderPageServer.js';
+import { assertWarning } from './utils.js';
+//import { importBuildWasLoaded } from './importBuild.js'
+export { createPageRenderer };
+/** @deprecated */
+function createPageRenderer(options) {
+    showWarnings(options);
+    return renderPageServer;
+}
+function showWarnings(options) {
+    assertWarning(false, '`createPageRenderer()` is outdated, use `renderPage()` instead. See https://vike.dev/renderPage', { onlyOnce: true, showStackTrace: true });
+    const { viteDevServer, root, outDir, isProduction, base, baseAssets } = options;
+    {
+        const opts = [
+            viteDevServer !== undefined && 'viteDevServer',
+            root !== undefined && 'root',
+            outDir !== undefined && 'outDir',
+            isProduction !== undefined && 'isProduction',
+        ].filter(notFalse);
+        assertWarning(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect anymore: they are now automatically determined.`, { onlyOnce: true });
+    }
+    {
+        const opts = [base !== undefined && 'base', baseAssets !== undefined && 'baseAssets'].filter(notFalse);
+        assertWarning(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect. See https://vike.dev/migration-0.4`, { onlyOnce: true });
+    }
+}
+function str(opts) {
+    return opts
+        .map((opt) => '`' + opt + '`')
+        .join(', ')
+        .replace(/,(?=[^,]*$)/, ' and');
+}
+function notFalse(val) {
+    return val !== false;
+}
+/*
+function assertArguments(
+  ssrEnv: {
+    viteDevServer?: unknown
+    root?: unknown
+    outDir?: unknown
+    isProduction?: unknown
+    baseServer?: unknown
+    baseAssets?: unknown
+  },
+  args: unknown[],
+): asserts ssrEnv is SsrEnv {
+  const { viteDevServer, root, outDir, isProduction, baseServer, baseAssets } = ssrEnv
+  assertUsage(
+    root === undefined || typeof root === 'string',
+    '`createPageRenderer({ root })`: argument `root` should be a string.',
+  )
+  assertUsage(typeof outDir === 'string', '`createPageRenderer({ outDir })`: argument `outDir` should be a string.')
+  assertUsage(typeof baseServer === 'string', '`createPageRenderer({ base })`: argument `base` should be a string.')
+  assertUsage(
+    baseAssets === null || typeof baseAssets === 'string',
+    '`createPageRenderer({ baseAssets })`: argument `baseAssets` should be a string.',
+  )
+  assertUsageBaseServer(baseServer, '`createPageRenderer({ base })`: ')
+  assertUsage(
+    isProduction === true || isProduction === false || isProduction === undefined,
+    '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true`, `false`, or `undefined`.',
+  )
+  if (importBuildWasLoaded()) {
+    assertUsage(
+      isProduction,
+      '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true` if `dist/server/importBuild.js` is loaded. (You should load `dist/server/importBuild.js` only in production.)',
+    )
+    assertUsage(
+      root === undefined,
+      '`createPageRenderer({ root })`: argument `root` has no effect if `dist/server/importBuild.js` is loaded. Remove the `root` argument.',
+    )
+  }
+  if (isProduction === true) {
+    assertUsage(
+      viteDevServer === undefined,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is `true`, then `viteDevServer` should be `undefined`.',
+    )
+    assertUsage(
+      root || importBuildWasLoaded(),
+      "`createPageRenderer({ root })`: argument `root` is missing. (Alternatively, if `root` doesn't exist because you are bundling your server code into a single file, then load `dist/server/importBuild.js`.)",
+    )
+  } else {
+    assertUsage(root, '`createPageRenderer({ root })`: argument `root` is missing.')
+
+    assertUsage(
+      !!viteDevServer,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` cannot be `undefined`.',
+    )
+
+    const wrongViteDevServerValueError =
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` should be `viteDevServer = await vite.createServer()`.'
+    assertUsage(
+      hasProp(viteDevServer, 'config') &&
+        hasProp(viteDevServer.config, 'root') &&
+        typeof viteDevServer.config.root === 'string',
+      wrongViteDevServerValueError,
+    )
+    {
+      const rootVite = resolve(viteDevServer.config.root)
+      const rootResolved = resolve(root)
+      assertUsage(
+        rootVite === rootResolved,
+        '`createPageRenderer({ viteDevServer, root })`: wrong `root` value, make sure it matches `viteDevServer.config.root`. ' +
+          `The \`root\` you provided resolves to \`'${rootResolved}'\` while \`viteDevServer.config.root\` resolves to \`${rootVite}\`.`,
+      )
+    }
+
+    assertUsage(
+      hasProp(viteDevServer, 'config', 'object') && hasProp(viteDevServer.config, 'plugins', 'array'),
+      wrongViteDevServerValueError,
+    )
+    assertUsage(
+      (viteDevServer as any as ViteDevServer).config.plugins.find((plugin) =>
+        plugin.name.startsWith('vike'),
+      ),
+      "Vike's Vite plugin is not installed. Make sure to add it to your `vite.config.js`.",
+    )
+  }
+  assertUsage(args.length === 1, '`createPageRenderer()`: all arguments should be passed as a single argument object.')
+  assert(typeof args[0] === 'object' && args[0] !== null)
+  Object.keys(args[0]).forEach((argName) => {
+    assertUsage(
+      ['viteDevServer', 'root', 'outDir', 'isProduction', 'base', 'baseAssets'].includes(argName),
+      '`createPageRenderer()`: Unknown argument `' + argName + '`.',
+    )
+  })
+}
+    */

package/dist/server/onLoad.js

@@ -0,0 +1,30 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../utils/assertIsNotBrowser.js';
+import { assertNodeVersion } from '../utils/assertNodeVersion.js';
+import { setAlwaysShowStackTrace } from '../utils/assert.js';
+import { installRequireShim } from '@brillout/require-shim';
+import { isDebugError } from '../utils/debug.js';
+function onLoad() {
+    assertIsNotBrowser();
+    assertNodeVersion();
+    if (isDebugError()) {
+        // Is also executed upon `$ vike build` because node/vite/utils.ts imports server/utils.ts
+        Error.stackTraceLimit = Infinity;
+        setAlwaysShowStackTrace();
+    }
+    addEcosystemStamp();
+    installRequireShim();
+}
+// Used by:
+// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
+function addEcosystemStamp() {
+    const g = globalThis;
+    g._isVikeApp =
+        /* Don't set to true so that consumers do `!!globalThis._isVikeApp` instead of `globalThis._isVikeApp === true`.
+        true
+        */
+        // We use an object so that we can eventually, in the future, add helpful information as needed. (E.g. the Vike version, or global settings.)
+        {};
+    // We keep the old stamp for older Telefunc versions
+    g._isVitePluginSsr = true;
+}

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

@@ -0,0 +1,12 @@
+export { getPageContext_withAsyncHook };
+export { getRequestId_withAsyncHook };
+export { getAsyncLocalStorage };
+export type { AsyncStore };
+import type { AsyncLocalStorage as AsyncLocalStorageType } from 'node:async_hooks';
+type AsyncStore = null | {
+    requestId: number;
+    pageContext?: Record<string, unknown>;
+};
+declare function getAsyncLocalStorage(): Promise<AsyncLocalStorageType<AsyncStore> | null>;
+declare function getRequestId_withAsyncHook(): number | null;
+declare function getPageContext_withAsyncHook(): any;

package/dist/server/runtime/asyncHook.js

@@ -0,0 +1,43 @@
+export { getPageContext_withAsyncHook };
+export { getRequestId_withAsyncHook };
+export { getAsyncLocalStorage };
+import { preparePageContextForPublicUsageServer } from './renderPageServer/preparePageContextForPublicUsageServer.js';
+import { assert, assertIsNotBrowser, getGlobalObject, isObject } from '../utils.js';
+import { import_ } from '@brillout/import';
+assertIsNotBrowser();
+const globalObject = getGlobalObject('server/runtime/asyncHook.ts', {
+    asyncLocalStorage: null,
+    installPromise: install(),
+});
+async function install() {
+    let mod;
+    try {
+        mod = await import_('node:async_hooks');
+    }
+    catch {
+        return;
+    }
+    globalObject.asyncLocalStorage = new mod.AsyncLocalStorage();
+}
+async function getAsyncLocalStorage() {
+    await globalObject.installPromise;
+    return globalObject.asyncLocalStorage;
+}
+function getAsyncStore() {
+    if (globalObject.asyncLocalStorage === null)
+        return null;
+    const asyncStore = globalObject.asyncLocalStorage.getStore();
+    assert(asyncStore === undefined || isObject(asyncStore));
+    return asyncStore ?? null;
+}
+function getRequestId_withAsyncHook() {
+    const asyncStore = getAsyncStore();
+    return asyncStore?.requestId ?? null;
+}
+function getPageContext_withAsyncHook() {
+    const asyncStore = getAsyncStore();
+    const pageContext = asyncStore?.pageContext;
+    if (!pageContext)
+        return null;
+    return preparePageContextForPublicUsageServer(pageContext);
+}

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

@@ -0,0 +1,3 @@
+export { createDevMiddleware_ as createDevMiddleware };
+import type { createDevMiddleware as createDevMiddlewareType } from '../../node/createDevMiddleware.js';
+declare const createDevMiddleware_: typeof createDevMiddlewareType;

package/dist/server/runtime/createDevMiddleware.js

@@ -0,0 +1,6 @@
+export { createDevMiddleware_ as createDevMiddleware };
+const createDevMiddleware_ = async (...args) => {
+    const p = '../../node/createDevMiddleware.js';
+    const { createDevMiddleware } = await import(/*webpackIgnore: true*/ /* @vite-ignore */ p);
+    return createDevMiddleware(...args);
+};

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

@@ -0,0 +1,14 @@
+export { getPageContext };
+export { providePageContext };
+export type { GetPageContextParams };
+import { providePageContext } from '../../shared-server-client/hooks/execHook.js';
+import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
+type GetPageContextParams = Parameters<typeof getPageContext>[0];
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function getPageContext<PageContext = PageContextClient | PageContextServer>({ asyncHook, }?: {
+    asyncHook?: boolean;
+}): null | PageContext;

package/dist/server/runtime/getPageContext.js

@@ -0,0 +1,22 @@
+export { getPageContext };
+export { providePageContext };
+import { getPageContext_withAsyncHook } from './asyncHook.js';
+import { getPageContext_sync, providePageContext } from '../../shared-server-client/hooks/execHook.js';
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext({ asyncHook, } = {}) {
+    {
+        const pageContext = getPageContext_sync();
+        if (pageContext)
+            return pageContext;
+    }
+    if (asyncHook) {
+        const pageContext = getPageContext_withAsyncHook();
+        if (pageContext)
+            return pageContext;
+    }
+    return null;
+}