vike 0.4.160 → 0.4.161-commit-ba539a4

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

@@ -1,23 +1,29 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+export { manifestTempFile };
+import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput, assertNodeEnvIsNotDev, getOutDirs, isNpmPackageImport } from '../utils.js';
+import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
-import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
+import { getClientEntry } from '../../shared/getClientEntry.js';
 import fs from 'fs/promises';
 import path from 'path';
+import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { set_constant_ASSETS_MAP } from './importBuild/index.js';
+import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
 function buildConfig() {
-    let generateManifest;
+    let isServerAssetsFixEnabled;
+    let isSsrBuild;
+    let outDirs;
     return {
         name: 'vike:buildConfig',
         apply: 'build',
@@ -25,37 +31,56 @@ function buildConfig() {
         configResolved: {
             order: 'post',
             async handler(config) {
+                assertNodeEnv();
                 assertRollupInput(config);
                 const entries = await getEntries(config);
                 assert(Object.keys(entries).length > 0);
                 config.build.rollupOptions.input = injectRollupInputs(entries, config);
                 addLogHook();
+                outDirs = getOutDirs(config);
+                {
+                    isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                    if (isServerAssetsFixEnabled) {
+                        // https://github.com/vikejs/vike/issues/1339
+                        config.build.ssrEmitAssets = true;
+                        // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
+                        config.build.cssMinify = 'esbuild';
+                    }
+                }
             }
         },
         config(config) {
-            generateManifest = !viteIsSSR(config);
+            assertNodeEnv();
+            isSsrBuild = viteIsSSR(config);
             return {
                 build: {
                     outDir: resolveOutDir(config),
-                    manifest: generateManifest ? manifestTempFile : false,
-                    copyPublicDir: !viteIsSSR(config)
+                    manifest: manifestTempFile,
+                    copyPublicDir: !isSsrBuild
                 }
             };
         },
+        buildStart() {
+            assertNodeEnv();
+        },
         async writeBundle(options, bundle) {
-            const manifestEntry = bundle[manifestTempFile];
-            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
-            assert(generateManifest === !!manifestEntry)
-            */
-            if (manifestEntry) {
-                const { dir } = options;
-                assert(dir);
-                const manifestFilePathOld = path.join(dir, manifestEntry.fileName);
+            if (isSsrBuild) {
                 // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
                 //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
                 //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                const manifestFilePathNew = path.join(dir, '..', 'assets.json');
-                await fs.rename(manifestFilePathOld, manifestFilePathNew);
+                const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                if (!isServerAssetsFixEnabled) {
+                    await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                }
+                else {
+                    const clientManifestMod = await fixServerAssets(outDirs);
+                    await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                }
+                await fs.rm(clientManifestFilePath);
+                await fs.rm(serverManifestFilePath);
+                await set_constant_ASSETS_MAP(options, bundle);
             }
         }
     };
@@ -108,7 +133,7 @@ function analyzeClientEntries(pageConfigs, config) {
     let hasClientRouting = false;
     let hasServerRouting = false;
     let clientEntries = {};
-    let clientFilePaths = [];
+    let clientEntryList = [];
     pageConfigs.forEach((pageConfig) => {
         const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
         if (configValue?.value) {
@@ -123,15 +148,15 @@ function analyzeClientEntries(pageConfigs, config) {
             clientEntries[entryName] = entryTarget;
         }
         {
-            const clientFilePath = getClientEntryFilePath(pageConfig);
-            if (clientFilePath) {
-                clientFilePaths.push(clientFilePath);
+            const clientEntry = getClientEntry(pageConfig);
+            if (clientEntry) {
+                clientEntryList.push(clientEntry);
             }
         }
     });
-    clientFilePaths = unique(clientFilePaths);
-    clientFilePaths.forEach((pageFile) => {
-        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config);
+    clientEntryList = unique(clientEntryList);
+    clientEntryList.forEach((clientEntry) => {
+        const { entryName, entryTarget } = getEntryFromClientEntry(clientEntry, config);
         clientEntries[entryName] = entryTarget;
     });
     return { hasClientRouting, hasServerRouting, clientEntries };
@@ -153,12 +178,18 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
             assert(includeAssetsImportedByServer);
             addExtractAssetsQuery = true;
         }
-        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config, addExtractAssetsQuery);
+        const { entryName, entryTarget } = getEntryFromClientEntry(pageFile, config, addExtractAssetsQuery);
         pageFileEntries[entryName] = entryTarget;
     });
     return pageFileEntries;
 }
-function getEntryFromFilePath(filePath, config, addExtractAssetsQuery) {
+function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
+    if (isNpmPackageImport(clientEntry)) {
+        const entryTarget = clientEntry;
+        const entryName = prependEntriesDir(clientEntry);
+        return { entryName, entryTarget };
+    }
+    const filePath = clientEntry;
     assertPosixPath(filePath);
     assert(filePath.startsWith('/'));
     let entryTarget = getFilePathAbsolute(filePath, config);
@@ -178,14 +209,6 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     entryName = prependEntriesDir(entryName);
     return { entryName, entryTarget };
 }
-function prependEntriesDir(entryName) {
-    if (entryName.startsWith('/')) {
-        entryName = entryName.slice(1);
-    }
-    assert(!entryName.startsWith('/'));
-    entryName = `entries/${entryName}`;
-    return entryName;
-}
 function resolve(filePath) {
     assert(filePath.startsWith('dist/'));
     // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
@@ -224,3 +247,6 @@ function assertRollupInput(config) {
     const htmlInput = htmlInputs[0];
     assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
+function assertNodeEnv() {
+    assertNodeEnvIsNotDev('building');
+}

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

@@ -1,5 +1,5 @@
 export { commonConfig };
-import { assert, assertWarning, findUserPackageJsonPath } from '../utils.js';
+import { assert, assertWarning, findFile } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -26,7 +26,7 @@ function commonConfig() {
                     overrideViteDefaultPort(config);
                     /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
                     overrideViteDefaultSsrExternal(config)
-                    */
+                    //*/
                     workaroundCI(config);
                     assertRollupInput(config);
                     assertResolveAlias(config);
@@ -46,21 +46,13 @@ function overrideViteDefaultPort(config) {
     (_b = config.preview).port ?? (_b.port = 3000);
 }
 /*
+import { version } from 'vite'
 function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
-  if (!isViteVersionWithSsrExternalTrue()) return
+  if (!isVersionOrAbove(version, '5.0.12')) return
   // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
   config.ssr.external ??= true
 }
-import { version } from 'vite'
-function isViteVersionWithSsrExternalTrue(): boolean {
-  const versionParts = version.split('.').map((s) => parseInt(s, 10)) as [number, number, number]
-  assert(versionParts.length === 3)
-  if (versionParts[0] > 5) return true
-  if (versionParts[1] > 0) return true
-  if (versionParts[2] >= 12) return true
-  return false
-}
-*/
+//*/
 // Workaround GitHub Action failing to access the server
 function workaroundCI(config) {
     var _a, _b;
@@ -70,7 +62,7 @@ function workaroundCI(config) {
     }
 }
 function assertEsm(userViteRoot) {
-    const packageJsonPath = findUserPackageJsonPath(userViteRoot);
+    const packageJsonPath = findFile('package.json', userViteRoot);
     if (!packageJsonPath)
         return;
     const packageJson = require_(packageJsonPath);

package/dist/esm/node/plugin/plugins/config/stemUtils.js

@@ -1,7 +1,7 @@
 // Move to standalone package? E.g. https://www.npmjs.com/package/stem
 export { getStemPackages };
 import path from 'path';
-import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findUserPackageJsonPath } from '../../utils.js';
+import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findFile } from '../../utils.js';
 import { import_ } from '@brillout/import';
 import { createRequire } from 'module';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
@@ -48,7 +48,7 @@ async function getStemPackages(userAppRootDir) {
     return stemPackages;
 }
 function findUserRootDir(userAppRootDir) {
-    const userPkgJsonPath = findUserPackageJsonPath(userAppRootDir);
+    const userPkgJsonPath = findFile('package.json', userAppRootDir);
     assertUsage(userPkgJsonPath, `Couldn't find package.json in any parent directory starting from ${userAppRootDir}`);
     return toPosixPath(path.dirname(userPkgJsonPath));
 }

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

@@ -19,9 +19,17 @@ function distFileNames() {
                 if (!('chunkFileNames' in rollupOutput)) {
                     rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
                 }
-                if (!('assertUsage' in rollupOutput)) {
+                if (!('assetFileNames' in rollupOutput)) {
                     rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
                 }
+                else {
+                    // If a user needs this:
+                    //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
+                    //    - It's needed for getHash() of fixServerAssets()
+                    //    - Asset URLs should always contain a hash: it's paramount for caching assets.
+                    //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
+                    assertUsage(false, "Setting config.build.rollupOptions.output.assetFileNames is currently forbidden. (It's possible to support, thus contact a maintainer if you need this.)");
+                }
             });
         }
     };

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

@@ -1,6 +1,6 @@
-// Alternative: use `ssrEmitAssets: true`
-//  - See https://github.com/vitejs/vite/pull/11430
-// This plugin makes client-side bundles include the CSS imports living in server-side-only code.
+// Remove this workaround if the other workaround config.build.ssrEmitAssets turns out to be reliable.
+//  - Remove this file then revert this commit: https://github.com/vikejs/vike/commit/805a18974f13420a78fcc30fdd676696e405c3ca
+// Workaround to make client-side bundles include the CSS imports living in server-side-only code.
 //  - This is needed for HTML-only pages, and React Server Components.
 //  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vite build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
@@ -13,6 +13,8 @@ import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import { removeSourceMap } from '../shared/removeSourceMap.js';
 import pc from '@brillout/picocolors';
+import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -23,6 +25,7 @@ const debugEnabled = isDebugEnabled(debugNamespace);
 function extractAssetsPlugin() {
     let config;
     let configVike;
+    let isServerAssetsFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
         {
@@ -34,6 +37,7 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
+                assert(!isServerAssetsFixEnabled);
                 assert(configVike.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
@@ -131,6 +135,7 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 configVike = await getConfigVike(config_);
                 config = config_;
+                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
             },
             load(id) {
                 if (!isVirtualFileId(id))

package/dist/esm/node/plugin/plugins/importBuild/index.d.ts

@@ -1,3 +1,8 @@
 export { importBuild };
-import type { Plugin } from 'vite';
+export { set_constant_ASSETS_MAP };
+import type { Plugin, Rollup } from 'vite';
+type Bundle = Rollup.OutputBundle;
+type Options = Rollup.NormalizedOutputOptions;
 declare function importBuild(): Plugin[];
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+declare function set_constant_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -1,6 +1,7 @@
 export { importBuild };
+export { set_constant_ASSETS_MAP };
 import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
-import { assert, getOutDirs, toPosixPath, viteIsSSR } from '../../utils.js';
+import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
@@ -21,11 +22,6 @@ function importBuild() {
             async configResolved(config_) {
                 config = config_;
                 configVike = await getConfigVike(config);
-            },
-            async writeBundle(options, bundle) {
-                if (!viteIsSSR(config))
-                    return;
-                await replace_ASSETS_MAP(options, bundle);
             }
         },
         ...serverEntryPlugin({
@@ -58,7 +54,8 @@ function getEntryCode(config, configVike) {
     ].join('\n');
     return importerCode;
 }
-async function replace_ASSETS_MAP(options, bundle) {
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+async function set_constant_ASSETS_MAP(options, bundle) {
     const { dir } = options;
     assert(dir);
     // This will probably fail with @vitejs/plugin-legacy

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -1,6 +1,7 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
 export type { ConfigDefinition };
+export type { ConfigDefinitions };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
@@ -54,6 +55,7 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
+type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'extensions' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -1,5 +1,4 @@
 export { crawlPlusFiles };
 declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
     filePathRelativeToUserRootDir: string;
-    filePathAbsoluteFilesystem: string;
 }[]>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -44,11 +44,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
         p = toPosixPath(p);
         assert(!p.startsWith(userRootDir));
         const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem
-        };
+        return { filePathRelativeToUserRootDir };
     });
     return plusFiles;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.d.ts

@@ -5,26 +5,53 @@ export { getLocationId };
 export { sortAfterInheritanceOrder };
 export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
+export type { LocationId };
 export { getLogicalPath };
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * The `locationId` value is used for filesystem inheritance.
+ *
+ * Each config value is assigned with a `locationId` value. That's the source-of-truth for determining inheritance between config values.
+ *
+ * For Vike extensions, `locationId` is different than the config value's `definedAt`, for example the `onRenderHtml()` hook of `vike-react`:
+ *  - `locationId === '/pages'` (the directory of `/pages/+config.h.js` which extends `vike-react`)
+ *  - `definedAt.filePathAbsoluteFilesystem === '/home/rom/code/my-vike-app/node_modules/vike-react/dist/renderer/onRenderHtml.js'` (the file where the value is defined)
+ *
+ *  This is an important distinction because the Vike extension's config should only apply to where it's being extended from, for example:
+ *  ```js
+ *  // /pages/admin/+config.h.js
+ *  import vikeVue from 'vike-vue/config'
+ *  // Should only apply to /pages/admin/**
+ *  export default { extends: [vikeVue] }
+ *  ```
+ *  ```js
+ *  // /pages/marketing/+config.h.js
+ *  import vikeReact from 'vike-react/config'
+ *  // Should only apply to /pages/marketing/**
+ *  export default { extends: [vikeReact] }
+ *  ```
  */
-declare function getLocationId(filePathAbsoluteVite: string): string;
-/** Get URL determined by filesystem path */
-declare function getFilesystemRouteString(locationId: string): string;
+type LocationId = string & {
+    __brand: 'LocationId';
+};
+/**
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
+ */
+declare function getLocationId(filePathRelativeToUserRootDir: string): LocationId;
+/** Filesystem Routing: get the URL */
+declare function getFilesystemRouteString(locationId: LocationId): string;
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-declare function getLogicalPath(someDir: string, removeDirs: string[]): string;
+declare function getLogicalPath(locationId: LocationId, removeDirs: string[]): string;
 /** Whether configs defined in `locationId` apply in every `locationIds` */
-declare function isGlobalLocation(locationId: string, locationIds: string[]): boolean;
-declare function sortAfterInheritanceOrder(locationId1: string, locationId2: string, locationIdPage: string): -1 | 1 | 0;
+declare function isGlobalLocation(locationId: LocationId, locationIds: LocationId[]): boolean;
+declare function sortAfterInheritanceOrder(locationId1: LocationId, locationId2: LocationId, locationIdPage: LocationId): -1 | 1 | 0;
 /** Whether configs defined at `locationId1` also apply at `locationId2` */
-declare function isInherited(locationId1: string, locationId2: string): boolean;
-declare function getFilesystemRouteDefinedBy(locationId: string): string;
+declare function isInherited(locationId1: LocationId, locationId2: LocationId): boolean;
+declare function getFilesystemRouteDefinedBy(locationId: LocationId): string;
 declare function applyFilesystemRoutingRootEffect(routeFilesystem: string, filesystemRoutingRootEffect: {
     before: string;
     after: string;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js

@@ -7,40 +7,47 @@ export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
 // For ./filesystemRouting.spec.ts
 export { getLogicalPath };
-import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, higherFirst } from '../../../../utils.js';
+import { assert, assertPosixPath, higherFirst } from '../../../../utils.js';
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
-function getLocationId(filePathAbsoluteVite) {
-    const locationId = removeFilename(filePathAbsoluteVite, true);
+function getLocationId(
+// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.h.js` that extends the Vike extension.
+filePathRelativeToUserRootDir) {
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    const locationId = removeFilename(filePathRelativeToUserRootDir);
     assertLocationId(locationId);
     return locationId;
 }
-/** Get URL determined by filesystem path */
+/** Filesystem Routing: get the URL */
 function getFilesystemRouteString(locationId) {
     return getLogicalPath(locationId, ['renderer', 'pages', 'src', 'index']);
 }
-/** Get apply root for config inheritance */
-function getInheritanceRoot(someDir) {
-    return getLogicalPath(someDir, ['renderer']);
+/** Filesystem Inheritance: get the apply root */
+function getInheritanceRoot(locationId) {
+    return getLogicalPath(locationId, ['renderer']);
 }
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-function getLogicalPath(someDir, removeDirs) {
-    someDir = removeNpmPackageName(someDir);
-    someDir = removeDirectories(someDir, removeDirs);
-    assertIsPath(someDir);
-    return someDir;
+function getLogicalPath(locationId, removeDirs) {
+    let logicalPath = removeDirectories(locationId, removeDirs);
+    assertIsPath(logicalPath);
+    return logicalPath;
 }
 /** Whether configs defined in `locationId` apply in every `locationIds` */
 function isGlobalLocation(locationId, locationIds) {
     return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
 }
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
+    assertLocationId(locationId1);
+    assertLocationId(locationId2);
+    if (locationId1 === locationId2)
+        return 0;
     const inheritanceRoot1 = getInheritanceRoot(locationId1);
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     const inheritanceRootPage = getInheritanceRoot(locationIdPage);
@@ -56,15 +63,10 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
         assert(inheritanceRoot1.length !== inheritanceRoot2.length);
         return higherFirst((inheritanceRoot) => inheritanceRoot.length)(inheritanceRoot1, inheritanceRoot2);
     }
-    // Should be true since we aggregate interface files by locationId
-    assert(locationId1 !== locationId2);
     // locationId1 first, i.e. `indexOf(locationId1) < indexOf(locationId2)`
     const locationId1First = -1;
     // locationId2 first, i.e. `indexOf(locationId2) < indexOf(locationId1)`
     const locationId2First = 1;
-    if (locationIsNpmPackage(locationId1) !== locationIsNpmPackage(locationId2)) {
-        return locationIsNpmPackage(locationId1) ? locationId2First : locationId1First;
-    }
     if (locationIsRendererDir(locationId1) !== locationIsRendererDir(locationId2)) {
         return locationIsRendererDir(locationId1) ? locationId2First : locationId1First;
     }
@@ -75,9 +77,6 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     }
     return locationId1 > locationId2 ? locationId1First : locationId2First;
 }
-function locationIsNpmPackage(locationId) {
-    return !locationId.startsWith('/');
-}
 function locationIsRendererDir(locationId) {
     return locationId.split('/').includes('renderer');
 }
@@ -87,19 +86,6 @@ function isInherited(locationId1, locationId2) {
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     return startsWith(inheritanceRoot2, inheritanceRoot1);
 }
-function removeNpmPackageName(somePath) {
-    if (!isNpmPackageImport(somePath)) {
-        assert(somePath.startsWith('/'));
-        return somePath;
-    }
-    const importPath = getNpmPackageImportPath(somePath);
-    if (!importPath)
-        return '/';
-    assertPosixPath(importPath);
-    assert(!importPath.startsWith('/'));
-    somePath = '/' + importPath;
-    return somePath;
-}
 function removeDirectories(somePath, removeDirs) {
     assertPosixPath(somePath);
     somePath = somePath
@@ -110,17 +96,13 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePathAbsoluteVite, optional) {
-    assertPosixPath(filePathAbsoluteVite);
-    assert(filePathAbsoluteVite.startsWith('/') || isNpmPackageImport(filePathAbsoluteVite));
+function removeFilename(filePathRelativeToUserRootDir) {
+    const filePathParts = filePathRelativeToUserRootDir.split('/');
     {
-        const filename = filePathAbsoluteVite.split('/').slice(-1)[0];
-        if (!filename.includes('.')) {
-            assert(optional);
-            return filePathAbsoluteVite;
-        }
+        const filename = filePathParts.slice(-1)[0];
+        assert(filename.includes('.'));
     }
-    let locationId = filePathAbsoluteVite.split('/').slice(0, -1).join('/');
+    let locationId = filePathParts.slice(0, -1).join('/');
     if (locationId === '')
         locationId = '/';
     assertLocationId(locationId);
@@ -142,7 +124,7 @@ function applyFilesystemRoutingRootEffect(routeFilesystem, filesystemRoutingRoot
     return routeFilesystem;
 }
 function assertLocationId(locationId) {
-    assert(locationId.startsWith('/') || isNpmPackageImport(locationId));
+    assert(locationId.startsWith('/'));
     assert(!locationId.endsWith('/') || locationId === '/');
 }
 function assertIsPath(logicalPath) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{loadFileConfigEnv.js → loadFileAtConfigTime.js}

@@ -6,7 +6,7 @@ import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsN
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
-import { parseImportData } from './transformImports.js';
+import { parseImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
 assertIsNotProductionRuntime();
@@ -14,7 +14,7 @@ assertIsNotProductionRuntime();
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, true, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, false, userRootDir).then((r) => r.fileExports);
     }
     const fileExports = await importedFilesLoaded[f];
     const fileExport = fileExports[import_.fileExportName];
@@ -22,7 +22,7 @@ async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
 }
 // Load +{configName}.js
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, false, userRootDir);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -34,7 +34,7 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
 async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir, isConfigOfExtension);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveFilePath.d.ts

@@ -0,0 +1,5 @@
+export { resolveFilePathRelativeToUserRootDir };
+export { resolveFilePathAbsoluteFilesystem };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+declare function resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir: string, userRootDir: string): FilePathResolved;
+declare function resolveFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem: string, userRootDir: string): FilePathResolved;