vike 0.4.186 → 0.4.188-commit-373ae21

package/dist/cjs/node/plugin/index.js

@@ -30,6 +30,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const fileEnv_js_1 = require("./plugins/fileEnv.js");
 const getPageAssets_js_1 = require("../runtime/renderPage/getPageAssets.js");
 const resolveClientEntriesDev_js_1 = require("./resolveClientEntriesDev.js");
+const workaroundCssModuleHmr_js_1 = require("./plugins/workaroundCssModuleHmr.js");
 (0, utils_js_2.assertNodeEnv_onVikePluginLoad)();
 (0, utils_js_2.markEnvAsVikePluginLoaded)();
 assertViteVersion();
@@ -54,7 +55,8 @@ function plugin(vikeConfig) {
         ...(0, index_js_4.importBuild)(),
         (0, baseUrls_js_1.baseUrls)(vikeConfig),
         (0, envVars_js_1.envVarsPlugin)(),
-        (0, fileEnv_js_1.fileEnv)()
+        (0, fileEnv_js_1.fileEnv)(),
+        (0, workaroundCssModuleHmr_js_1.workaroundCssModuleHmr)()
     ];
     return plugins;
 }

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

@@ -9,7 +9,9 @@ exports.distFileNames = void 0;
 //  - Blocker: https://github.com/rollup/rollup/issues/4724
 const utils_js_1 = require("../utils.js");
 const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
 const getAssetsDir_js_1 = require("../shared/getAssetsDir.js");
+const getFilePath_js_1 = require("../shared/getFilePath.js");
 function distFileNames() {
     return {
         name: 'vike:distFileNames',
@@ -39,16 +41,52 @@ function distFileNames() {
                 {
                     const manualChunksOriginal = rollupOutput.manualChunks;
                     rollupOutput.manualChunks = function (id, ...args) {
-                        if (id.endsWith('.css') && id.includes('node_modules'))
-                            return 'vendor';
                         if (manualChunksOriginal) {
                             if ((0, utils_js_1.isCallable)(manualChunksOriginal)) {
-                                return manualChunksOriginal.call(this, id, ...args);
+                                const result = manualChunksOriginal.call(this, id, ...args);
+                                if (result !== undefined)
+                                    return result;
                             }
                             else {
                                 (0, utils_js_1.assertUsage)(false, "The Vite's configuration build.rollupOptions.output.manualChunks must be a function. Reach out if you need to set it to another value.");
                             }
                         }
+                        // Disable CSS bundling to workaround https://github.com/vikejs/vike/issues/1815
+                        if (id.endsWith('.css')) {
+                            if ((0, utils_js_1.isFilePathAbsolute)(id)) {
+                                (0, utils_js_1.assertPosixPath)(id);
+                                (0, getFilePath_js_1.assertModuleId)(id);
+                                let name;
+                                const isNodeModules = id.match(/node_modules\/([^\/]+)\/(?!.*node_modules)/);
+                                if (isNodeModules) {
+                                    name = isNodeModules[1];
+                                }
+                                else {
+                                    const filePath = (0, getFilePath_js_1.getModuleFilePathAbsolute)(id, config);
+                                    name = filePath;
+                                    name = name.split('.').slice(0, -1).join('.'); // remove file extension
+                                    name = name.split('/').join('_');
+                                }
+                                // Make fileHash the same between local development and CI
+                                const idStable = path_1.default.posix.relative(config.root, id);
+                                // Don't remove `?` queries because each `id` should belong to a unique bundle.
+                                const hash = getIdHash(idStable);
+                                return `${name}-${hash}`;
+                            }
+                            else {
+                                let name;
+                                const isVirtualModule = id.match(/virtual:([^:]+):/);
+                                if (!isVirtualModule) {
+                                    name = 'style';
+                                }
+                                else {
+                                    name = isVirtualModule[1];
+                                    (0, utils_js_1.assert)(name);
+                                }
+                                const hash = getIdHash(id);
+                                return `${name}-${hash}`;
+                            }
+                        }
                     };
                 }
             });
@@ -56,6 +94,9 @@ function distFileNames() {
     };
 }
 exports.distFileNames = distFileNames;
+function getIdHash(id) {
+    return crypto_1.default.createHash('md5').update(id).digest('hex').slice(0, 8);
+}
 function getAssetFileName(assetInfo, config) {
     const assetsDir = (0, getAssetsDir_js_1.getAssetsDir)(config);
     const dir = assetsDir + '/static';

package/dist/cjs/node/plugin/plugins/envVars.js

@@ -51,7 +51,7 @@ function envVarsPlugin() {
                     if (isPrivate && isClientSide) {
                         if (!envStatementRegEx.test(code))
                             return;
-                        const modulePath = (0, getFilePath_js_1.getModuleFilePath)(id, config);
+                        const modulePath = (0, getFilePath_js_1.getModuleFilePathAbsolute)(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
                         const keyPublic = `${PUBLIC_ENV_PREFIX}${envName}`;
                         const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;

package/dist/cjs/node/plugin/plugins/fileEnv.js

@@ -67,7 +67,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = (0, getFilePath_js_1.getModuleFilePath)(moduleId, config);
+                let modulePathPretty = (0, getFilePath_js_1.getModuleFilePathAbsolute)(moduleId, config);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, picocolors_1.default.bold(suffix));
                 errMsg = `${(0, utils_js_1.capitalizeFirstLetter)(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -75,7 +75,7 @@ function fileEnv() {
                     !importer.includes('virtual:vike:') &&
                     // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
                     importer !== '<stdin>') {
-                    const importerPath = (0, getFilePath_js_1.getModuleFilePath)(importer, config);
+                    const importerPath = (0, getFilePath_js_1.getModuleFilePathAbsolute)(importer, config);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -126,7 +126,7 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUserResolved = (0, getFilePath_js_1.getModuleFilePath)(filePath, config);
+        const filePathToShowToUserResolved = (0, getFilePath_js_1.getModuleFilePathAbsolute)(filePath, config);
         const msg = `${op} ${picocolors_1.default.dim(filePathToShowToUserResolved)}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolvePointerImport.js

@@ -37,7 +37,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     //   - An npm package import
     // - importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
     (0, utils_js_1.assertPosixPath)(importPath);
-    if (importPath.startsWith('.') || (0, utils_js_1.isPathFilesystemAbsolute)(importPath)) {
+    if (importPath.startsWith('.') || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
         if (importPath.startsWith('.')) {
             (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
         }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -123,7 +123,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     //   isNpmPackageImport(str, { cannotBePathAlias: true })
                     //   assertIsNpmPackageImport()
                     //   ```
-                    (0, utils_js_1.assertPathFilesystemAbsolute)(importPathResolved);
+                    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(importPathResolved);
                     // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                     //  - This is temporary, see comment below.
                     const isVikeExtensionConfigImport = importPathResolved.endsWith('+config.js');

package/dist/cjs/node/plugin/plugins/workaroundCssModuleHmr.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workaroundCssModuleHmr = void 0;
+function workaroundCssModuleHmr() {
+    return {
+        name: 'vike:workaroundCssModuleHmr',
+        handleHotUpdate(ctx) {
+            // prevent full reload due to non self-accepting css module.
+            // here only "?direct" module should be filtered out as it doesn't have a parent module.
+            if (ctx.file.includes('module.css')) {
+                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+            }
+        }
+    };
+}
+exports.workaroundCssModuleHmr = workaroundCssModuleHmr;

package/dist/cjs/node/plugin/shared/getFilePath.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilePathAbsoluteUserRootDir = exports.cleanFilePathUnkown = exports.getFilePathToShowToUserFromUnkown = exports.getModuleFilePath = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
+exports.assertModuleId = exports.cleanFilePathUnkown = exports.getModuleFilePathRelative = exports.getModuleFilePathAbsolute = exports.getFilePathToShowToUserFromUnkown = exports.getFilePathAbsoluteUserRootDir = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
 const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../utils.js");
 function getFilePathResolved(args) {
@@ -19,7 +19,7 @@ function getFilePathResolved(args) {
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
     const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
     (0, utils_js_1.assert)(filePathToShowToUserResolved);
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
@@ -70,47 +70,77 @@ exports.getFilePathUnresolved = getFilePathUnresolved;
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
     const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    const { filePathAbsoluteUserRootDir } = getFilePathRelative({
+        filePathAbsoluteFilesystem,
+        userRootDir
+    });
+    return filePathAbsoluteUserRootDir;
+}
+exports.getFilePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir;
+function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
-    const filePathRelative = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
+    const filePathRelativeUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        (0, utils_js_1.assert)(filePathRelative.startsWith('../'));
-        return null;
+        (0, utils_js_1.assert)(filePathRelativeUserRootDir.startsWith('../'));
+        return {
+            filePathAbsoluteUserRootDir: null,
+            filePathRelativeUserRootDir
+        };
+    }
+    else {
+        (0, utils_js_1.assert)(!filePathRelativeUserRootDir.startsWith('/') &&
+            /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+            !filePathRelative.startsWith('.') &&
+            */
+            !filePathRelativeUserRootDir.startsWith('./') &&
+            !filePathRelativeUserRootDir.startsWith('../'));
+        const filePathAbsoluteUserRootDir = `/${filePathRelativeUserRootDir}`;
+        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+        return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
     }
-    (0, utils_js_1.assert)(!filePathRelative.startsWith('/') &&
-        /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
-        !filePathRelative.startsWith('.') &&
-        */
-        !filePathRelative.startsWith('./') &&
-        !filePathRelative.startsWith('../'));
-    const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
-    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
-    return filePathAbsoluteUserRootDir;
 }
-exports.getFilePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir;
+function getModuleFilePathAbsolute(moduleId, config) {
+    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getModuleFilePath(moduleId, config);
+    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+}
+exports.getModuleFilePathAbsolute = getModuleFilePathAbsolute;
+function getModuleFilePathRelative(moduleId, config) {
+    const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
+    return filePathRelativeUserRootDir;
+}
+exports.getModuleFilePathRelative = getModuleFilePathRelative;
 function getModuleFilePath(moduleId, config) {
     const userRootDir = config.root;
-    (0, utils_js_1.assertPosixPath)(moduleId);
+    assertModuleId(moduleId);
     (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
     const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
-    const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
-    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
+    const { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir } = getFilePathRelative({
+        filePathAbsoluteFilesystem,
+        userRootDir
+    });
+    return { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
+}
+function assertModuleId(moduleId) {
+    (0, utils_js_1.assertPosixPath)(moduleId);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(moduleId); // Can moduleId be something else than the filesystem absolute path?
 }
-exports.getModuleFilePath = getModuleFilePath;
+exports.assertModuleId = assertModuleId;
 function getFilePathToShowToUserFromUnkown(
 // We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
 filePathUnkown, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
     filePathUnkown = cleanFilePathUnkown(filePathUnkown);
     if (!filePathUnkown.startsWith(userRootDir)) {
         return filePathUnkown;

package/dist/cjs/node/plugin/utils.js

@@ -40,6 +40,6 @@ __exportStar(require("../../utils/injectRollupInputs.js"), exports);
 __exportStar(require("../../utils/humanizeTime.js"), exports);
 __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/assertVersion.js"), exports);
-__exportStar(require("../../utils/assertPathFilesystemAbsolute.js"), exports);
+__exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);

package/dist/cjs/node/prerender/runPrerender.js

@@ -105,7 +105,7 @@ async function runPrerender(options, manuallyTriggered) {
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
-    (0, utils_js_1.assertPathFilesystemAbsolute)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
     await (0, globalContext_js_1.initGlobalContext)(true, outDirRoot);
     const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     renderContext.pageFilesAll.forEach(assertExportNames);

package/dist/cjs/node/prerender/utils.js

@@ -29,6 +29,6 @@ __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/isPlainObject.js"), exports);
 __exportStar(require("../../utils/assertNodeEnv.js"), exports);
 __exportStar(require("../../utils/pLimit.js"), exports);
-__exportStar(require("../../utils/assertPathFilesystemAbsolute.js"), exports);
+__exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.186';
+exports.PROJECT_VERSION = '0.4.188-commit-373ae21';

package/dist/cjs/utils/isFilePathAbsoluteFilesystem.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFilePathAbsolute = exports.assertFilePathAbsoluteFilesystem = void 0;
+const path_1 = __importDefault(require("path"));
+const assert_js_1 = require("./assert.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+/**
+ * Asserts that `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * It isn't reliable for Linux users, but that's okay because the assertion will eventually fail on windows.
+ */
+function assertFilePathAbsoluteFilesystem(filePath) {
+    // The assert is "eventually reliable":
+    // - For Windows users, the assert is correct.
+    // - For Linux users assertFilePathAbsoluteFilesystem() will erroneously succeed if `p` is a path absolute from the user root dir.
+    //   - But that's okay because the assertion will eventually fail for Windows users.
+    (0, assert_js_1.assert)(isFilePathAbsoluteFilesystem(filePath));
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePath);
+}
+exports.assertFilePathAbsoluteFilesystem = assertFilePathAbsoluteFilesystem;
+/**
+ * Whether `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * Isn't reliable for Linux users: it returns `true` for an absolute path starting from the user root dir.
+ */
+function isFilePathAbsoluteFilesystem(filePath) {
+    (0, assert_js_1.assert)(!filePath.startsWith('/@fs/'));
+    if (process.platform !== 'win32') {
+        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
+        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
+        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
+        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
+        // - Using require.resolve() would be a solution but probably too slow?
+        return filePath.startsWith('/');
+    }
+    else {
+        const yes = path_1.default.win32.isAbsolute(filePath);
+        // Ensure isFilePathAbsoluteFilesystem() returns `false` if path is absolute starting from the user root dir (see comments above).
+        if (yes)
+            (0, assert_js_1.assert)(!filePath.startsWith('/'));
+        return yes;
+    }
+}
+/**
+ * Whether `filePath` is an absolute file path.
+ *
+ * Returns `true` regardless whether it starts from the user root dir or filesystem root.
+ */
+function isFilePathAbsolute(filePath) {
+    (0, assert_js_1.assert)(!filePath.startsWith('/@fs/'));
+    // Absolute path starting from the user root dir.
+    if (filePath.startsWith('/'))
+        return true;
+    // Seems to be reliable: https://nodejs.org/api/path.html#pathisabsolutepath
+    return path_1.default.isAbsolute(filePath);
+}
+exports.isFilePathAbsolute = isFilePathAbsolute;

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

@@ -26,6 +26,7 @@ import pc from '@brillout/picocolors';
 import { fileEnv } from './plugins/fileEnv.js';
 import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
+import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 assertNodeEnv_onVikePluginLoad();
 markEnvAsVikePluginLoaded();
 assertViteVersion();
@@ -50,7 +51,8 @@ function plugin(vikeConfig) {
         ...importBuild(),
         baseUrls(vikeConfig),
         envVarsPlugin(),
-        fileEnv()
+        fileEnv(),
+        workaroundCssModuleHmr()
     ];
     return plugins;
 }

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

@@ -2,9 +2,11 @@ export { distFileNames };
 // Attempt to preserve file structure of `.page.js` files:
 //  - https://github.com/vikejs/vike/commit/11a4c49e5403aa7c37c8020c462b499425b41854
 //  - Blocker: https://github.com/rollup/rollup/issues/4724
-import { assertPosixPath, assert, assertUsage, isArray, isCallable } from '../utils.js';
+import { assertPosixPath, assert, assertUsage, isArray, isCallable, isFilePathAbsolute } from '../utils.js';
 import path from 'path';
+import crypto from 'crypto';
 import { getAssetsDir } from '../shared/getAssetsDir.js';
+import { assertModuleId, getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 function distFileNames() {
     return {
         name: 'vike:distFileNames',
@@ -34,22 +36,61 @@ function distFileNames() {
                 {
                     const manualChunksOriginal = rollupOutput.manualChunks;
                     rollupOutput.manualChunks = function (id, ...args) {
-                        if (id.endsWith('.css') && id.includes('node_modules'))
-                            return 'vendor';
                         if (manualChunksOriginal) {
                             if (isCallable(manualChunksOriginal)) {
-                                return manualChunksOriginal.call(this, id, ...args);
+                                const result = manualChunksOriginal.call(this, id, ...args);
+                                if (result !== undefined)
+                                    return result;
                             }
                             else {
                                 assertUsage(false, "The Vite's configuration build.rollupOptions.output.manualChunks must be a function. Reach out if you need to set it to another value.");
                             }
                         }
+                        // Disable CSS bundling to workaround https://github.com/vikejs/vike/issues/1815
+                        if (id.endsWith('.css')) {
+                            if (isFilePathAbsolute(id)) {
+                                assertPosixPath(id);
+                                assertModuleId(id);
+                                let name;
+                                const isNodeModules = id.match(/node_modules\/([^\/]+)\/(?!.*node_modules)/);
+                                if (isNodeModules) {
+                                    name = isNodeModules[1];
+                                }
+                                else {
+                                    const filePath = getModuleFilePathAbsolute(id, config);
+                                    name = filePath;
+                                    name = name.split('.').slice(0, -1).join('.'); // remove file extension
+                                    name = name.split('/').join('_');
+                                }
+                                // Make fileHash the same between local development and CI
+                                const idStable = path.posix.relative(config.root, id);
+                                // Don't remove `?` queries because each `id` should belong to a unique bundle.
+                                const hash = getIdHash(idStable);
+                                return `${name}-${hash}`;
+                            }
+                            else {
+                                let name;
+                                const isVirtualModule = id.match(/virtual:([^:]+):/);
+                                if (!isVirtualModule) {
+                                    name = 'style';
+                                }
+                                else {
+                                    name = isVirtualModule[1];
+                                    assert(name);
+                                }
+                                const hash = getIdHash(id);
+                                return `${name}-${hash}`;
+                            }
+                        }
                     };
                 }
             });
         }
     };
 }
+function getIdHash(id) {
+    return crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
+}
 function getAssetFileName(assetInfo, config) {
     const assetsDir = getAssetsDir(config);
     const dir = assetsDir + '/static';

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

@@ -2,7 +2,7 @@ export { envVarsPlugin };
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
-import { getModuleFilePath } from '../shared/getFilePath.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -49,7 +49,7 @@ function envVarsPlugin() {
                     if (isPrivate && isClientSide) {
                         if (!envStatementRegEx.test(code))
                             return;
-                        const modulePath = getModuleFilePath(id, config);
+                        const modulePath = getModuleFilePathAbsolute(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
                         const keyPublic = `${PUBLIC_ENV_PREFIX}${envName}`;
                         const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;

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

@@ -3,7 +3,7 @@ import { assert, assertUsage, assertWarning, capitalizeFirstLetter } from '../ut
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
-import { getModuleFilePath } from '../shared/getFilePath.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 function fileEnv() {
     let config;
     let isDev = false;
@@ -62,7 +62,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = getModuleFilePath(moduleId, config);
+                let modulePathPretty = getModuleFilePathAbsolute(moduleId, config);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
                 errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -70,7 +70,7 @@ function fileEnv() {
                     !importer.includes('virtual:vike:') &&
                     // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
                     importer !== '<stdin>') {
-                    const importerPath = getModuleFilePath(importer, config);
+                    const importerPath = getModuleFilePathAbsolute(importer, config);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

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

@@ -9,7 +9,7 @@ import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/vir
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo, clearLogs } from '../../shared/loggerNotProd.js';
-import { getModuleFilePath } from '../../shared/getFilePath.js';
+import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
     let configVike;
@@ -120,7 +120,7 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUserResolved = getModuleFilePath(filePath, config);
+        const filePathToShowToUserResolved = getModuleFilePathAbsolute(filePath, config);
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }

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

@@ -2,7 +2,7 @@ export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
 export { clearFilesEnvMap };
 import pc from '@brillout/picocolors';
-import { assert, assertIsNpmPackageImport, assertPosixPath, assertUsage, deepEqual, isPathFilesystemAbsolute, requireResolve } from '../../../../utils.js';
+import { assert, assertIsNpmPackageImport, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
 import { parsePointerImportData } from './transformFileImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
@@ -33,7 +33,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     //   - An npm package import
     // - importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
     assertPosixPath(importPath);
-    if (importPath.startsWith('.') || isPathFilesystemAbsolute(importPath)) {
+    if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
         if (importPath.startsWith('.')) {
             assert(importPath.startsWith('./') || importPath.startsWith('../'));
         }

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

@@ -7,7 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger, assertPathFilesystemAbsolute, assertIsNpmPackageImport } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport } from '../../../../utils.js';
 import { transformFileImports } from './transformFileImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -120,7 +120,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     //   isNpmPackageImport(str, { cannotBePathAlias: true })
                     //   assertIsNpmPackageImport()
                     //   ```
-                    assertPathFilesystemAbsolute(importPathResolved);
+                    assertFilePathAbsoluteFilesystem(importPathResolved);
                     // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                     //  - This is temporary, see comment below.
                     const isVikeExtensionConfigImport = importPathResolved.endsWith('+config.js');

package/dist/esm/node/plugin/plugins/workaroundCssModuleHmr.d.ts

@@ -0,0 +1,3 @@
+export { workaroundCssModuleHmr };
+import type { Plugin } from 'vite';
+declare function workaroundCssModuleHmr(): Plugin;

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

@@ -0,0 +1,13 @@
+export { workaroundCssModuleHmr };
+function workaroundCssModuleHmr() {
+    return {
+        name: 'vike:workaroundCssModuleHmr',
+        handleHotUpdate(ctx) {
+            // prevent full reload due to non self-accepting css module.
+            // here only "?direct" module should be filtered out as it doesn't have a parent module.
+            if (ctx.file.includes('module.css')) {
+                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+            }
+        }
+    };
+}

package/dist/esm/node/plugin/shared/getFilePath.d.ts

@@ -1,9 +1,11 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
-export { getModuleFilePath };
+export { getFilePathAbsoluteUserRootDir };
 export { getFilePathToShowToUserFromUnkown };
+export { getModuleFilePathAbsolute };
+export { getModuleFilePathRelative };
 export { cleanFilePathUnkown };
-export { getFilePathAbsoluteUserRootDir };
+export { assertModuleId };
 import type { FilePathResolved, FilePathUnresolved } from '../../../shared/page-configs/FilePath.js';
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathResolved(args: {
@@ -22,6 +24,8 @@ declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, us
     filePathAbsoluteFilesystem: string;
     userRootDir: string;
 }): string | null;
-declare function getModuleFilePath(moduleId: string, config: ResolvedConfig): string;
+declare function getModuleFilePathAbsolute(moduleId: string, config: ResolvedConfig): string;
+declare function getModuleFilePathRelative(moduleId: string, config: ResolvedConfig): string;
+declare function assertModuleId(moduleId: string): void;
 declare function getFilePathToShowToUserFromUnkown(filePathUnkown: string, userRootDir: string): string;
 declare function cleanFilePathUnkown(filePathUnknown: string): string;

package/dist/esm/node/plugin/shared/getFilePath.js

@@ -1,11 +1,13 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
-export { getModuleFilePath };
+export { getFilePathAbsoluteUserRootDir };
 export { getFilePathToShowToUserFromUnkown };
+export { getModuleFilePathAbsolute };
+export { getModuleFilePathRelative };
 export { cleanFilePathUnkown };
-export { getFilePathAbsoluteUserRootDir };
+export { assertModuleId };
 import path from 'path';
-import { assert, assertIsNpmPackageImport, assertPathFilesystemAbsolute, assertPosixPath, toPosixPath } from '../utils.js';
+import { assert, assertIsNpmPackageImport, assertFilePathAbsoluteFilesystem, assertPosixPath, toPosixPath } from '../utils.js';
 function getFilePathResolved(args) {
     const { userRootDir } = args;
     let filePathAbsoluteFilesystem;
@@ -19,7 +21,7 @@ function getFilePathResolved(args) {
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
     assert(filePathAbsoluteFilesystem);
-    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
+    assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
     const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
     assert(filePathToShowToUserResolved);
     assertPosixPath(filePathAbsoluteFilesystem);
@@ -68,45 +70,73 @@ function getFilePathUnresolved(args) {
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     assertPosixPath(filePathAbsoluteUserRootDir);
     assertPosixPath(userRootDir);
-    assertPathFilesystemAbsolute(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
     const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
-    assertPathFilesystemAbsolute(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    const { filePathAbsoluteUserRootDir } = getFilePathRelative({
+        filePathAbsoluteFilesystem,
+        userRootDir
+    });
+    return filePathAbsoluteUserRootDir;
+}
+function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir }) {
     assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
-    assertPathFilesystemAbsolute(userRootDir);
-    const filePathRelative = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
+    assertFilePathAbsoluteFilesystem(userRootDir);
+    const filePathRelativeUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        assert(filePathRelative.startsWith('../'));
-        return null;
+        assert(filePathRelativeUserRootDir.startsWith('../'));
+        return {
+            filePathAbsoluteUserRootDir: null,
+            filePathRelativeUserRootDir
+        };
     }
-    assert(!filePathRelative.startsWith('/') &&
-        /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
-        !filePathRelative.startsWith('.') &&
-        */
-        !filePathRelative.startsWith('./') &&
-        !filePathRelative.startsWith('../'));
-    const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
-    assert(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
-    return filePathAbsoluteUserRootDir;
+    else {
+        assert(!filePathRelativeUserRootDir.startsWith('/') &&
+            /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+            !filePathRelative.startsWith('.') &&
+            */
+            !filePathRelativeUserRootDir.startsWith('./') &&
+            !filePathRelativeUserRootDir.startsWith('../'));
+        const filePathAbsoluteUserRootDir = `/${filePathRelativeUserRootDir}`;
+        assert(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+        return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
+    }
+}
+function getModuleFilePathAbsolute(moduleId, config) {
+    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getModuleFilePath(moduleId, config);
+    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+}
+function getModuleFilePathRelative(moduleId, config) {
+    const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
+    return filePathRelativeUserRootDir;
 }
 function getModuleFilePath(moduleId, config) {
     const userRootDir = config.root;
-    assertPosixPath(moduleId);
+    assertModuleId(moduleId);
     assertPosixPath(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
     const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
-    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
-    const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
-    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    assertFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem);
+    const { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir } = getFilePathRelative({
+        filePathAbsoluteFilesystem,
+        userRootDir
+    });
+    return { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
+}
+function assertModuleId(moduleId) {
+    assertPosixPath(moduleId);
+    assertFilePathAbsoluteFilesystem(moduleId); // Can moduleId be something else than the filesystem absolute path?
 }
 function getFilePathToShowToUserFromUnkown(
 // We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
 filePathUnkown, userRootDir) {
     assertPosixPath(userRootDir);
-    assertPathFilesystemAbsolute(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
     filePathUnkown = cleanFilePathUnkown(filePathUnkown);
     if (!filePathUnkown.startsWith(userRootDir)) {
         return filePathUnkown;

package/dist/esm/node/plugin/utils.d.ts

@@ -18,6 +18,6 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
-export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/PROJECT_VERSION.js';

package/dist/esm/node/plugin/utils.js

@@ -24,6 +24,6 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
-export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/PROJECT_VERSION.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertPathFilesystemAbsolute, isArray, changeEnumerable } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertFilePathAbsoluteFilesystem, isArray, changeEnumerable } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -77,7 +77,7 @@ async function runPrerender(options, manuallyTriggered) {
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
-    assertPathFilesystemAbsolute(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
     await initGlobalContext(true, outDirRoot);
     const renderContext = await getRenderContext();
     renderContext.pageFilesAll.forEach(assertExportNames);

package/dist/esm/node/prerender/utils.d.ts

@@ -11,6 +11,6 @@ export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/changeEnumerable.js';

package/dist/esm/node/prerender/utils.js

@@ -13,6 +13,6 @@ export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/changeEnumerable.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.186";
+export declare const PROJECT_VERSION: "0.4.188-commit-373ae21";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.186';
+export const PROJECT_VERSION = '0.4.188-commit-373ae21';

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

@@ -0,0 +1,14 @@
+export { assertFilePathAbsoluteFilesystem };
+export { isFilePathAbsolute };
+/**
+ * Asserts that `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * It isn't reliable for Linux users, but that's okay because the assertion will eventually fail on windows.
+ */
+declare function assertFilePathAbsoluteFilesystem(filePath: string): void;
+/**
+ * Whether `filePath` is an absolute file path.
+ *
+ * Returns `true` regardless whether it starts from the user root dir or filesystem root.
+ */
+declare function isFilePathAbsolute(filePath: string): boolean;

package/dist/esm/utils/isFilePathAbsoluteFilesystem.js

@@ -0,0 +1,54 @@
+export { assertFilePathAbsoluteFilesystem };
+export { isFilePathAbsolute };
+import path from 'path';
+import { assert } from './assert.js';
+import { assertPosixPath } from './filesystemPathHandling.js';
+/**
+ * Asserts that `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * It isn't reliable for Linux users, but that's okay because the assertion will eventually fail on windows.
+ */
+function assertFilePathAbsoluteFilesystem(filePath) {
+    // The assert is "eventually reliable":
+    // - For Windows users, the assert is correct.
+    // - For Linux users assertFilePathAbsoluteFilesystem() will erroneously succeed if `p` is a path absolute from the user root dir.
+    //   - But that's okay because the assertion will eventually fail for Windows users.
+    assert(isFilePathAbsoluteFilesystem(filePath));
+    assertPosixPath(filePath);
+}
+/**
+ * Whether `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * Isn't reliable for Linux users: it returns `true` for an absolute path starting from the user root dir.
+ */
+function isFilePathAbsoluteFilesystem(filePath) {
+    assert(!filePath.startsWith('/@fs/'));
+    if (process.platform !== 'win32') {
+        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
+        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
+        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
+        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
+        // - Using require.resolve() would be a solution but probably too slow?
+        return filePath.startsWith('/');
+    }
+    else {
+        const yes = path.win32.isAbsolute(filePath);
+        // Ensure isFilePathAbsoluteFilesystem() returns `false` if path is absolute starting from the user root dir (see comments above).
+        if (yes)
+            assert(!filePath.startsWith('/'));
+        return yes;
+    }
+}
+/**
+ * Whether `filePath` is an absolute file path.
+ *
+ * Returns `true` regardless whether it starts from the user root dir or filesystem root.
+ */
+function isFilePathAbsolute(filePath) {
+    assert(!filePath.startsWith('/@fs/'));
+    // Absolute path starting from the user root dir.
+    if (filePath.startsWith('/'))
+        return true;
+    // Seems to be reliable: https://nodejs.org/api/path.html#pathisabsolutepath
+    return path.isAbsolute(filePath);
+}

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

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.186";
+    projectVersion: "0.4.188-commit-373ae21";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.186",
+  "version": "0.4.188-commit-373ae21",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/utils/assertPathFilesystemAbsolute.js

@@ -1,39 +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.isPathFilesystemAbsolute = exports.assertPathFilesystemAbsolute = void 0;
-const path_1 = __importDefault(require("path"));
-const assert_js_1 = require("./assert.js");
-const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
-/** Assert path is absolute starting from the filesystem root. */
-function assertPathFilesystemAbsolute(p) {
-    // The assert is "eventually reliable":
-    // - For Windows users, the assert is correct.
-    // - For Linux users assertPathFilesystemAbsolute() will erroneously succeed if `p` is a path absolute from the user root dir.
-    //   - But that's okay because the assertion will eventually fail for Windows users.
-    (0, assert_js_1.assert)(isPathFilesystemAbsolute(p));
-}
-exports.assertPathFilesystemAbsolute = assertPathFilesystemAbsolute;
-/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
-function isPathFilesystemAbsolute(p) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(p);
-    (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
-        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
-        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
-        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
-        // - Using require.resolve() would be a solution but probably too slow?
-        return p.startsWith('/');
-    }
-    else {
-        const yes = path_1.default.win32.isAbsolute(p);
-        // Ensure isPathFilesystemAbsolute() returns `false` if path is absolute starting from the user root dir (see comments above).
-        if (yes)
-            (0, assert_js_1.assert)(!p.startsWith('/'));
-        return yes;
-    }
-}
-exports.isPathFilesystemAbsolute = isPathFilesystemAbsolute;

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

@@ -1,6 +0,0 @@
-export { assertPathFilesystemAbsolute };
-export { isPathFilesystemAbsolute };
-/** Assert path is absolute starting from the filesystem root. */
-declare function assertPathFilesystemAbsolute(p: string): void;
-/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
-declare function isPathFilesystemAbsolute(p: string): boolean;

package/dist/esm/utils/assertPathFilesystemAbsolute.js

@@ -1,33 +0,0 @@
-export { assertPathFilesystemAbsolute };
-export { isPathFilesystemAbsolute };
-import path from 'path';
-import { assert } from './assert.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
-/** Assert path is absolute starting from the filesystem root. */
-function assertPathFilesystemAbsolute(p) {
-    // The assert is "eventually reliable":
-    // - For Windows users, the assert is correct.
-    // - For Linux users assertPathFilesystemAbsolute() will erroneously succeed if `p` is a path absolute from the user root dir.
-    //   - But that's okay because the assertion will eventually fail for Windows users.
-    assert(isPathFilesystemAbsolute(p));
-}
-/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
-function isPathFilesystemAbsolute(p) {
-    assertPosixPath(p);
-    assert(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
-        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
-        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
-        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
-        // - Using require.resolve() would be a solution but probably too slow?
-        return p.startsWith('/');
-    }
-    else {
-        const yes = path.win32.isAbsolute(p);
-        // Ensure isPathFilesystemAbsolute() returns `false` if path is absolute starting from the user root dir (see comments above).
-        if (yes)
-            assert(!p.startsWith('/'));
-        return yes;
-    }
-}