vike 0.4.158 → 0.4.159-commit-6bcb2fd

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -1,5 +1,5 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, markEnvAsPreview } from '../utils.js';
+import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview } from '../utils.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import fs from 'fs';
 import path from 'path';
@@ -28,7 +28,7 @@ function previewConfig() {
                - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
             config.appType = 'mpa'
             */
-            markEnvAsPreview();
+            markEnvAsVitePreview();
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.

package/dist/esm/node/plugin/shared/loggerNotProd/log.js

@@ -20,10 +20,10 @@ function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
 function getProjectTag(showVikeVersion) {
     let projectTag;
     if (showVikeVersion) {
-        projectTag = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+        projectTag = `[vike@${projectInfo.projectVersion}]`;
     }
     else {
-        projectTag = `[${projectInfo.npmPackageName}]`;
+        projectTag = `[vike]`;
     }
     return projectTag;
 }
@@ -83,7 +83,7 @@ function prependTags(msg, projectTag, category, logType) {
             return pc.yellow(s);
         if (projectTag === '[vite]')
             return pc.bold(pc.cyan(s));
-        if (projectTag.startsWith(`[${projectInfo.npmPackageName}`))
+        if (projectTag.startsWith(`[vike`))
             return pc.bold(pc.cyan(s));
         assert(false);
     };

package/dist/esm/node/runtime/globalContext.js

@@ -6,7 +6,7 @@ export { setGlobalContext_viteDevServer };
 export { setGlobalContext_vitePreviewServer };
 export { setGlobalContext_viteConfig };
 export { getRuntimeManifest };
-import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, getGlobalObject, getNodeEnv, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -151,7 +151,8 @@ function assertNodeEnv(hasViteDevServer) {
     const nodeEnv = getNodeEnv();
     if (nodeEnv === null || nodeEnv === 'test')
         return;
-    const isDevNodeEnv = [undefined, '', 'dev', 'development'].includes(nodeEnv);
-    // calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    assertWarning(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+    const isDevNodeEnv = isNodeEnvDev();
+    // - Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    // - We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value).
+    assertUsage(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`);
 }

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -53,6 +53,10 @@ type PageConfigGlobalRuntime = {
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
 };
+/** In what environment(s) the config value is loaded.
+ *
+ * https://vike.dev/meta
+ */
 type ConfigEnv = {
     client?: boolean;
     server?: boolean;

package/dist/esm/shared/page-configs/assertPlusFileExport.d.ts

@@ -0,0 +1,2 @@
+export { assertPlusFileExport };
+declare function assertPlusFileExport(fileExports: Record<string, unknown>, filePathToShowToUser: string, configName: string): void;

package/dist/esm/shared/page-configs/assertPlusFileExport.js

@@ -0,0 +1,38 @@
+export { assertPlusFileExport };
+import { assert, assertUsage, assertWarning } from '../utils.js';
+import pc from '@brillout/picocolors';
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports).filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsAll.filter((e) => e !== 'default' && e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsAll.length === 1) {
+            return;
+        }
+        const exportDefault = pc.cyan('export default');
+        const exportNamed = pc.cyan(`export { ${configName} }`);
+        if (exportsAll.length === 0) {
+            assertUsage(false, `${filePathToShowToUser} doesn't export any value, but it should have a ${exportNamed} or ${exportDefault}`);
+        }
+        else {
+            assert(exportsAll.length === 2); // because `exportsInvalid.length === 0`
+            assertWarning(false, `${filePathToShowToUser} remove ${exportNamed} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
+    }
+    else {
+        if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+            return;
+        exportsInvalid.forEach((exportInvalid) => {
+            assertWarning(false, `${filePathToShowToUser} should have only one export: move ${pc.cyan(`export { ${exportInvalid} }`)} to its own +${exportsInvalid}.js file`, { onlyOnce: true });
+        });
+    }
+}

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -1,6 +1,6 @@
 export { parseConfigValuesImported };
 import { assert } from '../../utils.js';
-import { assertExportsOfValueFile } from '../assertExports.js';
+import { assertPlusFileExport } from '../assertPlusFileExport.js';
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
     const addConfigValue = (configName, value, importPath, exportName) => {
@@ -21,7 +21,7 @@ function parseConfigValuesImported(configValuesImported) {
         if (configValueLoaded.isValueFile) {
             const { exportValues, importPath, configName } = configValueLoaded;
             if (configName !== 'client') {
-                assertExportsOfValueFile(exportValues, importPath, configName);
+                assertPlusFileExport(exportValues, importPath, configName);
             }
             Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`

package/dist/esm/shared/route/abort.js

@@ -7,7 +7,7 @@ export { logAbortErrorHandled };
 export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
-import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
+import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -132,7 +132,7 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
 }
 function assertStatusCode(statusCode, expected, caller) {
     const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');
-    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${projectInfo.githubRepository}/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
 }
 function getPageContextFromAllRewrites(pageContextsFromRewrite) {
     assertNoInfiniteLoop(pageContextsFromRewrite);

package/dist/esm/shared/types.d.ts

@@ -3,33 +3,26 @@ export { PageContextServer };
 export { PageContextClient };
 export { PageContextWithServerRouting };
 export { PageContextClientWithServerRouting };
-export { PageContextBuiltInServer };
 export { PageContextBuiltInServerInternal };
-export { PageContextBuiltInClientWithClientRouting };
-export { PageContextBuiltInClientWithServerRouting };
+export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
+export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
+export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlComputedPropsInternal, PageContextUrlComputedPropsClient, PageContextUrlComputedPropsServer } from './addUrlComputedProps.js';
 import type { ConfigEntries, ExportsAll } from './getPageFiles/getExports.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
-type PageContextServer = PageContextBuiltInServer & Vike.PageContext;
-type PageContext = PageContextClient | PageContextServer;
-type PageContextClient = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
-type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
-type PageContextClientWithServerRouting = PageContextBuiltInClientWithServerRouting & Vike.PageContext;
-/** Built-in `pageContext` properties set by vike.
- *
- * https://vike.dev/pageContext
- */
-type PageContextBuiltInServer<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsServer;
-/** For Vike internal use */
-type PageContextBuiltInServerInternal<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsInternal;
-type PageContextBuiltInCommon<Page = [never]> = {
+type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext;
+type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
+type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext;
+type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
+type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext;
+type PageContextBuiltInCommon<Data> = {
     /** The `export { Page }` of your `.page.js` file.
      *
      * https://vike.dev/Page
      */
-    Page: Page extends [never] ? Config['Page'] : Page;
+    Page: Config['Page'];
     /** Route Parameters, e.g. `pageContext.routeParams.productId` for a Route String `/product/@productId`.
      *
      * https://vike.dev/route-string
@@ -39,7 +32,7 @@ type PageContextBuiltInCommon<Page = [never]> = {
      *
      * https://vike.dev/data
      */
-    data?: unknown;
+    data: Data;
     /** The page's configuration values.
      *
      * https://vike.dev/config
@@ -100,11 +93,8 @@ type PageContextBuiltInCommon<Page = [never]> = {
     /** @deprecated */
     pageExports: Record<string, unknown>;
 };
-/** Client-side built-in `pageContext` properties set by vike (Client Routing).
- *
- * https://vike.dev/pageContext
- */
-type PageContextBuiltInClientWithClientRouting<Page = unknown> = Partial<PageContextBuiltInCommon<Page>> & Pick<PageContextBuiltInCommon<Page>, 'Page' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason'> & {
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlComputedPropsServer;
+type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data'> & {
     /** Whether the current page is already rendered to HTML */
     isHydration: boolean;
     /**
@@ -114,11 +104,7 @@ type PageContextBuiltInClientWithClientRouting<Page = unknown> = Partial<PageCon
      */
     isBackwardNavigation: boolean | null;
 } & PageContextUrlComputedPropsClient;
-/** Client-side built-in `pageContext` properties set by vike (Server Routing).
- *
- * https://vike.dev/pageContext
- */
-type PageContextBuiltInClientWithServerRouting<Page = unknown> = Partial<PageContextBuiltInCommon<Page>> & Pick<PageContextBuiltInCommon<Page>, 'Page' | 'pageExports' | 'exports' | 'abortReason'> & {
+type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'data'> & {
     /**
      * Whether the current page is already rendered to HTML.
      *
@@ -132,3 +118,44 @@ type PageContextBuiltInClientWithServerRouting<Page = unknown> = Partial<PageCon
      */
     isBackwardNavigation: null;
 };
+/** For Vike internal use */
+type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlComputedPropsInternal, 'data'>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInServer } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextServer } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInServer_deprecated<Page = never> = PageContextBuiltInServer<unknown>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClientWithClientRouting } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextClient } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInClientWithClientRouting_deprecated<Page = never> = PageContextBuiltInClientWithClientRouting<unknown>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClientWithServerRouting } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextClientWithServerRouting as PageContextClient } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInClientWithServerRouting_deprecated<Page = never> = PageContextBuiltInClientWithServerRouting<unknown>;

package/dist/esm/utils/assert.js

@@ -25,8 +25,8 @@ const globalObject = getGlobalObject('utils/assert.ts', {
     },
     showStackTraceList: new WeakSet()
 });
-const projectTag = `[${projectInfo.npmPackageName}]`;
-const projectTagWithVersion = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const projectTag = `[vike]`;
+const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -36,12 +36,11 @@ function assert(condition, debugInfo) {
             return null;
         }
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
-        return pc.dim(`Debug info (for ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+        return pc.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = `${projectInfo.githubRepository}/issues/new`;
     let errMsg = [
-        `You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
-        `Go to ${pc.blue(link)} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
+        `You stumbled upon a Vike bug.`,
+        `Go to ${pc.blue('https://github.com/vikejs/vike/issues/new')} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
         debugStr
     ]
         .filter(Boolean)

package/dist/esm/utils/assertIsNotProductionRuntime.d.ts

@@ -1,10 +1,12 @@
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
+export { vikeVitePluginLoadedInProductionError };
+declare const vikeVitePluginLoadedInProductionError = "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.";
 declare function assertIsNotProductionRuntime(): void | undefined;
-declare function markEnvAsDev(): void | undefined;
-declare function markEnvAsPreview(): void | undefined;
-declare function markEnvAsVite(): void;
+declare function markEnvAsViteDev(): void | undefined;
+declare function markEnvAsVitePreview(): void | undefined;
+declare function markEnvAsVikePluginLoaded(): void;
 declare function assertEnv(): void | undefined;

package/dist/esm/utils/assertIsNotProductionRuntime.js

@@ -1,41 +1,59 @@
 // Mechanism to ensure code isn't loaded by production runtime
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
-import { assert } from './assert.js';
+export { vikeVitePluginLoadedInProductionError };
+import { assert, assertUsage } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { createDebugger } from './debug.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { isVitest } from './isVitest.js';
 assertIsNotBrowser();
+const debug = createDebugger('vike:setup');
+const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
 const env = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
-// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
-    env.shouldBeVite = true;
+    if (debug.isEnabled)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    env.shouldNotBeProduction = true;
 }
 // Called by Vite hook configureServer()
-function markEnvAsDev() {
-    env.isDev = true;
+function markEnvAsViteDev() {
+    if (debug.isEnabled)
+        debug('markEnvAsViteDev()', new Error().stack);
+    env.isViteDev = true;
 }
 // Called by Vite hook configurePreviewServer()
-function markEnvAsPreview() {
-    env.isPreview = true;
+function markEnvAsVitePreview() {
+    if (debug.isEnabled)
+        debug('markEnvAsVitePreview()', new Error().stack);
+    env.isVitePreview = true;
 }
 // Called by ../node/plugin/index.ts
-function markEnvAsVite() {
-    env.isVite = true;
+function markEnvAsVikePluginLoaded() {
+    if (debug.isEnabled)
+        debug('markEnvAsVikePluginLoaded()', new Error().stack);
+    env.isVikePluginLoaded = true;
 }
 // Called by ../node/runtime/index.ts
 function assertEnv() {
+    if (debug.isEnabled)
+        debug('assertEnv()', new Error().stack);
     if (isVitest())
         return;
-    if (env.isDev || env.isPreview) {
-        assert(env.isVite);
-        assert(env.shouldBeVite);
+    const isProduction = !env.isViteDev && !env.isVitePreview;
+    if (isProduction) {
+        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
+        assertUsage(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
+        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
+        assert(!env.shouldNotBeProduction);
     }
     else {
-        assert(!env.isVite);
-        assert(!env.shouldBeVite);
+        // This assert() is obious and boring
+        assert(env.shouldNotBeProduction);
+        assert(env.isVikePluginLoaded);
     }
 }

package/dist/esm/utils/debug.d.ts

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugEnabled };
 export type { Debug };
-type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem';
+type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem' | 'vike:setup';
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {
     serialization?: {

package/dist/esm/utils/nodeEnv.d.ts

@@ -1,4 +1,6 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
+export { isNodeEnvDev };
 declare function getNodeEnv(): null | undefined | string;
 declare function setNodeEnvToProduction(): void | undefined;
+declare function isNodeEnvDev(): boolean;

package/dist/esm/utils/nodeEnv.js

@@ -1,5 +1,6 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
+export { isNodeEnvDev };
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -11,3 +12,12 @@ function setNodeEnvToProduction() {
     const { env } = proc;
     env.NODE_ENV = 'production';
 }
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnv();
+    if (!nodeEnv)
+        return true;
+    if (['development', 'dev'].includes(nodeEnv))
+        return true;
+    // That's quite aggressive, let's see if some user complains
+    return false;
+}

package/dist/esm/utils/projectInfo.d.ts

@@ -1,13 +1,7 @@
 export { projectInfo };
-export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.158";
-type PackageName = typeof projectInfo.npmPackageName;
-type ProjectVersion = typeof projectInfo.projectVersion;
-type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
+declare const PROJECT_VERSION: "0.4.159-commit-6bcb2fd";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.158";
-    npmPackageName: "vike";
-    githubRepository: "https://github.com/vikejs/vike";
+    projectVersion: "0.4.159-commit-6bcb2fd";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,12 +1,10 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.158';
+const PROJECT_VERSION = '0.4.159-commit-6bcb2fd';
 const projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION,
-    npmPackageName: 'vike',
-    githubRepository: 'https://github.com/vikejs/vike'
+    projectVersion: PROJECT_VERSION
 };
 // Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)
 onProjectInfo(projectInfo.projectVersion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.158",
+  "version": "0.4.159-commit-6bcb2fd",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/shared/page-configs/assertExports.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExportsOfConfigFile = exports.assertExportsOfValueFile = void 0;
-const utils_js_1 = require("../utils.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const EXPORTS_IGNORE = [
-    // vite-plugin-solid adds `export { $$registrations }`
-    '$$registrations',
-    // @vitejs/plugin-vue adds `export { _rerender_only }`
-    '_rerender_only'
-];
-// Tolerate `export { frontmatter }` in .mdx files
-const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
-function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
-    assertExports(fileExports, filePathToShowToUser, configName);
-}
-exports.assertExportsOfValueFile = assertExportsOfValueFile;
-function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
-    assertExports(fileExports, filePathToShowToUser);
-    const exportDefault = fileExports.default;
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
-}
-exports.assertExportsOfConfigFile = assertExportsOfConfigFile;
-function assertExports(fileExports, filePathToShowToUser, configName) {
-    const exportsAll = Object.keys(fileExports);
-    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
-    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
-        // !!configName => isValueFile
-        e !== configName);
-    if (exportsInvalid.length === 0) {
-        if (exportsRelevant.length === 1) {
-            return;
-        }
-        const exportDefault = picocolors_1.default.cyan('export default');
-        const exportConfigName = picocolors_1.default.cyan(`export { ${configName} }`);
-        if (exportsRelevant.length === 0) {
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
-            if (configName)
-                errMsg += ` or ${exportConfigName}`;
-            (0, utils_js_1.assertUsage)(false, errMsg);
-        }
-        else {
-            (0, utils_js_1.assert)(exportsRelevant.length === 2);
-            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
-                onlyOnce: true
-            });
-        }
-    }
-    else {
-        // !configName => isConfigFile
-        if (!configName) {
-            const exportsInvalidStr = exportsInvalid.join(', ');
-            (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`);
-        }
-        // !!configName => isValueFile
-        else {
-            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
-                return;
-            exportsInvalid.forEach((exportInvalid) => {
-                (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} should have only a single export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
-            });
-        }
-    }
-}

package/dist/esm/shared/page-configs/assertExports.d.ts

@@ -1,6 +0,0 @@
-export { assertExportsOfValueFile };
-export { assertExportsOfConfigFile };
-declare function assertExportsOfValueFile(fileExports: Record<string, unknown>, filePathToShowToUser: string, configName: string): void;
-declare function assertExportsOfConfigFile(fileExports: Record<string, unknown>, filePathToShowToUser: string): asserts fileExports is {
-    default: Record<string, unknown>;
-};

package/dist/esm/shared/page-configs/assertExports.js

@@ -1,61 +0,0 @@
-export { assertExportsOfValueFile };
-export { assertExportsOfConfigFile };
-import { assert, assertUsage, assertWarning, isObject } from '../utils.js';
-import pc from '@brillout/picocolors';
-const EXPORTS_IGNORE = [
-    // vite-plugin-solid adds `export { $$registrations }`
-    '$$registrations',
-    // @vitejs/plugin-vue adds `export { _rerender_only }`
-    '_rerender_only'
-];
-// Tolerate `export { frontmatter }` in .mdx files
-const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
-function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
-    assertExports(fileExports, filePathToShowToUser, configName);
-}
-function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
-    assertExports(fileExports, filePathToShowToUser);
-    const exportDefault = fileExports.default;
-    assertUsage(isObject(exportDefault), `The ${pc.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
-}
-function assertExports(fileExports, filePathToShowToUser, configName) {
-    const exportsAll = Object.keys(fileExports);
-    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
-    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
-        // !!configName => isValueFile
-        e !== configName);
-    if (exportsInvalid.length === 0) {
-        if (exportsRelevant.length === 1) {
-            return;
-        }
-        const exportDefault = pc.cyan('export default');
-        const exportConfigName = pc.cyan(`export { ${configName} }`);
-        if (exportsRelevant.length === 0) {
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
-            if (configName)
-                errMsg += ` or ${exportConfigName}`;
-            assertUsage(false, errMsg);
-        }
-        else {
-            assert(exportsRelevant.length === 2);
-            assertWarning(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
-                onlyOnce: true
-            });
-        }
-    }
-    else {
-        // !configName => isConfigFile
-        if (!configName) {
-            const exportsInvalidStr = exportsInvalid.join(', ');
-            assertUsage(false, `${filePathToShowToUser} replace ${pc.cyan(`export { ${exportsInvalidStr} }`)} with ${pc.cyan(`export default { ${exportsInvalidStr} }`)}`);
-        }
-        // !!configName => isValueFile
-        else {
-            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
-                return;
-            exportsInvalid.forEach((exportInvalid) => {
-                assertWarning(false, `${filePathToShowToUser} should have only a single export: move ${pc.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
-            });
-        }
-    }
-}