vike 0.4.168-commit-ce94f5c → 0.4.168-commit-42406a9

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

@@ -14,12 +14,12 @@ const globalContext_js_1 = require("../../../../runtime/globalContext.js");
 const loggerNotProd_js_1 = require("../../../shared/loggerNotProd.js");
 const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/removeSuperfluousViteLog.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
+const getConfigDefinedAt_js_1 = require("../../../../../shared/page-configs/getConfigDefinedAt.js");
 const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
 const getConfigFileExport_js_1 = require("./getConfigFileExport.js");
 const loadFileAtConfigTime_js_1 = require("./getVikeConfig/loadFileAtConfigTime.js");
-const resolveImportPath_js_1 = require("./getVikeConfig/resolveImportPath.js");
+const resolvePointerImport_js_1 = require("./getVikeConfig/resolvePointerImport.js");
 const getFilePath_js_1 = require("../../../shared/getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
@@ -29,7 +29,7 @@ const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
 function reloadVikeConfig(userRootDir, outDirRoot) {
     vikeConfigDependencies.clear();
-    (0, resolveImportPath_js_1.clearFilesEnvMap)();
+    (0, resolvePointerImport_js_1.clearFilesEnvMap)();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, true);
     handleReloadSideEffects();
 }
@@ -270,6 +270,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
+            configDef.env = deriveConfigEnvFromFileName(configDef.env, interfaceFile.filePath.fileName);
             if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
@@ -306,6 +307,22 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal, globalVikeConfig };
 }
+function deriveConfigEnvFromFileName(env, fileName) {
+    env = { ...env };
+    if (fileName.includes('.server.')) {
+        env.server = true;
+        env.client = false;
+    }
+    else if (fileName.includes('.client.')) {
+        env.client = true;
+        env.server = false;
+    }
+    else if (fileName.includes('.shared.')) {
+        env.server = true;
+        env.client = true;
+    }
+    return env;
+}
 function assertPageConfigs(pageConfigs) {
     pageConfigs.forEach((pageConfig) => {
         assertOnBeforeRenderEnv(pageConfig);
@@ -392,7 +409,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             (0, utils_js_1.assert)('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            const { filePathToShowToUser } = configValueSource.definedAt;
+            const { filePathToShowToUser } = configValueSource.definedAtFilePath;
             (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
@@ -486,26 +503,26 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
     const { locationId } = interfaceFile;
-    const definedAtConfigFile = {
+    const definedAtFilePath_ = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
     // +client.js
     if (configDef._valueIsFilePath) {
-        let definedAt;
+        let definedAtFilePath;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, { definedAt: definedAtConfigFile });
-            (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
-            valueFilePath = import_.filePathAbsoluteVite;
-            definedAt = import_;
+            const pointerImport = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, definedAtFilePath_);
+            (0, utils_js_1.assertUsage)(pointerImport, `${configDefinedAt} should be an import`);
+            valueFilePath = pointerImport.filePathAbsoluteVite;
+            definedAtFilePath = pointerImport;
         }
         else {
             (0, utils_js_1.assert)(interfaceFile.isValueFile);
             valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
-            definedAt = {
+            definedAtFilePath = {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: []
             };
@@ -517,7 +534,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: true,
             valueIsDefinedByValueFile: false,
-            definedAt
+            definedAtFilePath
         };
         return configValueSource;
     }
@@ -525,28 +542,26 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        // fake import
-        const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-        if (import_) {
+        // Pointer import
+        const pointerImport = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+        if (pointerImport) {
             const configValueSource = {
                 locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByValueFile: false,
-                definedAt: import_
+                definedAtFilePath: pointerImport
             };
             // Load fake import
             if (isConfigEnv(configDef, configName) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
-                if (import_.filePathAbsoluteFilesystem) {
-                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathToShowToUserResolved', 'string')); // Help TS
-                    const fileExport = await (0, loadFileAtConfigTime_js_1.loadImportedFile)(import_, userRootDir, importedFilesLoaded);
+                if (pointerImport.filePathAbsoluteFilesystem) {
+                    const fileExport = await (0, loadFileAtConfigTime_js_1.loadImportedFile)(pointerImport, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
                 else {
-                    const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
+                    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, configValueSource.definedAtFilePath);
                     (0, utils_js_1.assertUsage)(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
                 }
             }
@@ -559,7 +574,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: false,
             valueIsDefinedByValueFile: false,
-            definedAt: definedAtConfigFile
+            definedAtFilePath: definedAtFilePath_
         };
         return configValueSource;
     }
@@ -572,7 +587,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByValueFile: true,
-            definedAt: {
+            definedAtFilePath: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName
                     ? []
@@ -610,12 +625,12 @@ function getConfigDefinitions(interfaceFilesRelevant) {
                 return;
             const meta = configMeta.configValue;
             assertMetaValue(meta, `Config ${picocolors_1.default.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
-            // Set configDef._userEffectDefinedAt
+            // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
                 if (!configDef.effect)
                     return;
                 (0, utils_js_1.assert)(interfaceFile.isConfigFile);
-                configDef._userEffectDefinedAt = {
+                configDef._userEffectDefinedAtFilePath = {
                     ...interfaceFile.filePath,
                     fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
                 };
@@ -632,24 +647,24 @@ function getConfigDefinitions(interfaceFilesRelevant) {
     const configDefinitions = configDefinitionsMerged;
     return configDefinitions;
 }
-function assertMetaValue(metaVal, configMetaDefinedAt) {
+function assertMetaValue(metaVal, metaConfigDefinedAt) {
     if (!(0, utils_js_1.isObject)(metaVal)) {
-        (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-        (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} has an invalid type ${picocolors_1.default.cyan(typeof metaVal)}: it should be an object instead.`);
+        (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+        (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} has an invalid type ${picocolors_1.default.cyan(typeof metaVal)}: it should be an object instead.`);
     }
     (0, utils_js_1.objectEntries)(metaVal).forEach(([configName, def]) => {
         if (!(0, utils_js_1.isObject)(def)) {
-            (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-            (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}`)} to a value with an invalid type ${picocolors_1.default.cyan(typeof def)}: it should be an object instead.`);
+            (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+            (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}`)} to a value with an invalid type ${picocolors_1.default.cyan(typeof def)}: it should be an object instead.`);
         }
         // env
         let configEnv;
         {
-            (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+            (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
             if (!('env' in def)) {
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required.`);
+                (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required.`);
             }
-            configEnv = getConfigEnvValue(def.env, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to`);
+            configEnv = getConfigEnvValue(def.env, `${metaConfigDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to`);
             // Overwrite deprecated value with valid value
             // TODO/v1-release: remove once support for the deprecated values is removed
             if (typeof def.env === 'string')
@@ -658,12 +673,12 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         // effect
         if ('effect' in def) {
             if (!(0, utils_js_1.hasProp)(def, 'effect', 'function')) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} to an invalid type ${picocolors_1.default.cyan(typeof def.effect)}: it should be a function instead`);
+                (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+                (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} to an invalid type ${picocolors_1.default.cyan(typeof def.effect)}: it should be a function instead`);
             }
             if (!configEnv.config) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${picocolors_1.default.cyan('{ config: true }')} (but it's ${picocolors_1.default.cyan(JSON.stringify(configEnv))} instead)`);
+                (0, utils_js_1.assert)(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+                (0, utils_js_1.assertUsage)(false, `${metaConfigDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${picocolors_1.default.cyan('{ config: true }')} (but it's ${picocolors_1.default.cyan(JSON.stringify(configEnv))} instead)`);
             }
         }
     });
@@ -685,7 +700,7 @@ function applyEffectsAll(configValueSources, configDefinitions) {
         // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
-            configDefinedAt: (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, source)
+            configDefinedAt: (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, source.definedAtFilePath)
         });
         if (!configModFromEffect)
             return;
@@ -697,16 +712,14 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
     const notSupported = `Effects currently only supports modifying the the ${picocolors_1.default.cyan('env')} of a config.`;
     (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            let configDefinedAtString;
-            if (configDefEffect._userEffectDefinedAt) {
-                configDefinedAtString = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, {
-                    definedAt: configDefEffect._userEffectDefinedAt
-                });
+            let configDefinedAt;
+            if (configDefEffect._userEffectDefinedAtFilePath) {
+                configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, configDefEffect._userEffectDefinedAtFilePath);
             }
             else {
-                configDefinedAtString = null;
+                configDefinedAt = null;
             }
-            assertMetaValue(configValue, configDefinedAtString);
+            assertMetaValue(configValue, configDefinedAt);
             (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -724,7 +737,7 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         else {
             (0, utils_js_1.assertUsage)(false, notSupported);
             // If we do end implementing being able to set the value of a config:
-            //  - For setting definedAt: we could take the definedAt of the effect config while appending '(effect)' to definedAt.fileExportPathToShowToUser
+            //  - For setting definedAtFile: we could take the definedAtFile of the effect config while appending '(effect)' to definedAtFile.fileExportPathToShowToUser
         }
     });
 }
@@ -832,11 +845,11 @@ function determineRouteFilesystem(locationId, configValueSources) {
     if (configFilesystemRoutingRoot) {
         const routingRoot = getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName);
         if (routingRoot) {
-            const { filesystemRoutingRootEffect /*, filesystemRoutingRootDefinedAt*/ } = routingRoot;
+            const { filesystemRoutingRootEffect /*, filesystemRoutingRootConfigDefinedAt*/ } = routingRoot;
             const debugInfo = { locationId, routeFilesystem: filesystemRouteString, configFilesystemRoutingRoot };
             (0, utils_js_1.assert)(filesystemRouteString.startsWith(filesystemRoutingRootEffect.before), debugInfo);
             filesystemRouteString = (0, filesystemRouting_js_1.applyFilesystemRoutingRootEffect)(filesystemRouteString, filesystemRoutingRootEffect);
-            // filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootDefinedAt})`
+            // filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootConfigDefinedAt})`
         }
     }
     (0, utils_js_1.assert)(filesystemRouteString.startsWith('/'));
@@ -851,15 +864,15 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configFilesystemRoutingRoot);
+    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
     (0, utils_js_1.assertUsage)(typeof value === 'string', `${configDefinedAt} should be a string`);
     (0, utils_js_1.assertUsage)(value.startsWith('/'), `${configDefinedAt} is ${picocolors_1.default.cyan(value)} but it should start with a leading slash ${picocolors_1.default.cyan('/')}`);
-    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAt;
+    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAtFilePath;
     (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
     const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(filePathAbsoluteUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
-    return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
+    return { filesystemRoutingRootEffect, filesystemRoutingRootConfigDefinedAt: configDefinedAt };
 }
 function determineIsErrorPage(routeFilesystem) {
     (0, utils_js_1.assertPosixPath)(routeFilesystem);
@@ -873,8 +886,9 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
     const configValues = {};
     Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
         configValues[configName] = {
+            type: 'computed',
             value: configValueComputed.value,
-            definedAt: { isComputed: true }
+            definedAtData: null
         };
     });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
@@ -884,18 +898,20 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
                 configValues[configName] = {
+                    type: 'classic',
                     value: configValueSource.value,
-                    definedAt: getDefinedAt(configValueSource)
+                    definedAtData: getDefinedAtFile(configValueSource)
                 };
             }
         }
         else {
             const value = mergeCumulative(configName, sources);
+            const definedAtData = sources.map((source) => getDefinedAtFile(source));
+            (0, utils_js_1.assert)(value.length === definedAtData.length);
             configValues[configName] = {
+                type: 'cumulative',
                 value,
-                definedAt: {
-                    files: sources.map((source) => getDefinedAtFile(source))
-                }
+                definedAtData
             };
         }
     });
@@ -903,62 +919,21 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
 }
 function getDefinedAtFile(configValueSource) {
     return {
-        filePathToShowToUser: configValueSource.definedAt.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAt.fileExportPathToShowToUser
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
     };
 }
-function getDefinedAt(configValueSource) {
-    return getDefinedAtFile(configValueSource);
-}
 function mergeCumulative(configName, configValueSources) {
-    const valuesArr = [];
-    const valuesSet = [];
-    let configValueSourcePrevious = null;
+    const configValues = [];
     configValueSources.forEach((configValueSource) => {
-        const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
         // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
         (0, utils_js_1.assert)('value' in configValueSource);
         // Make sure configValueSource.value is serializable
-        (0, getConfigValuesSerialized_js_1.assertConfigValueIsSerializable)(configValueSource.value, configName, getDefinedAt(configValueSource));
-        const assertNoMixing = (isSet) => {
-            const vals1 = isSet ? valuesSet : valuesArr;
-            const t1 = isSet ? 'a Set' : 'an array';
-            const vals2 = !isSet ? valuesSet : valuesArr;
-            const t2 = !isSet ? 'a Set' : 'an array';
-            (0, utils_js_1.assert)(vals1.length > 0);
-            if (vals2.length === 0)
-                return;
-            (0, utils_js_1.assert)(configValueSourcePrevious);
-            const configPreviousDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSourcePrevious);
-            (0, utils_js_1.assertUsage)(false, `${configDefinedAt} sets ${t1} but another ${configPreviousDefinedAt} sets ${t2} which is forbidden: the values must be all arrays or all sets (you cannot mix).`);
-        };
+        (0, getConfigValuesSerialized_js_1.assertConfigValueIsSerializable)(configValueSource.value, configName, getDefinedAtFile(configValueSource));
         const { value } = configValueSource;
-        if (Array.isArray(value)) {
-            valuesArr.push(value);
-            assertNoMixing(false);
-        }
-        else if (value instanceof Set) {
-            valuesSet.push(value);
-            assertNoMixing(true);
-        }
-        else {
-            (0, utils_js_1.assertUsage)(false, `${configDefinedAt} must be an array or a Set`);
-        }
-        configValueSourcePrevious = configValueSource;
+        configValues.push(value);
     });
-    if (valuesArr.length > 0) {
-        (0, utils_js_1.assert)(valuesSet.length === 0);
-        const result = (0, utils_js_1.mergeCumulativeValues)(valuesArr);
-        (0, utils_js_1.assert)(result !== null);
-        return result;
-    }
-    if (valuesSet.length > 0) {
-        (0, utils_js_1.assert)(valuesArr.length === 0);
-        const result = (0, utils_js_1.mergeCumulativeValues)(valuesSet);
-        (0, utils_js_1.assert)(result !== null);
-        return result;
-    }
-    (0, utils_js_1.assert)(false);
+    return configValues;
 }
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${picocolors_1.default.cyan(JSON.stringify(val))}`;
@@ -1028,10 +1003,10 @@ function assertConfigExists(configName, configNamesRelevant, filePathToShowToUse
 function sortConfigValueSources(configValueSources, locationIdPage) {
     return Object.fromEntries(Object.entries(configValueSources)
         // Make order deterministic (no other purpose)
-        .sort(([, [source1]], [, [source2]]) => source1.definedAt.filePathAbsoluteVite < source2.definedAt.filePathAbsoluteVite ? -1 : 1)
+        .sort(([, [source1]], [, [source2]]) => source1.definedAtFilePath.filePathAbsoluteVite < source2.definedAtFilePath.filePathAbsoluteVite ? -1 : 1)
         // Sort after whether the config value was defined by an npm package
         .sort((0, utils_js_1.makeFirst)(([, [source]]) => {
-        const { importPathAbsolute } = source.definedAt;
+        const { importPathAbsolute } = source.definedAtFilePath;
         return (!!importPathAbsolute &&
             (0, utils_js_1.isNpmPackageImport)(importPathAbsolute, {
                 // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)

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

@@ -6,7 +6,7 @@ const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
-const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
+const getConfigValue_js_1 = require("../../../../../shared/page-configs/getConfigValue.js");
 const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
 const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
@@ -35,7 +35,7 @@ exports.getVirtualFilePageConfigValuesAll = getVirtualFilePageConfigValuesAll;
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
     const lines = [];
     const importStatements = [];
-    const isClientRouting = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+    const isClientRouting = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesImported = [');
     lines.push(getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements));
     lines.push('];');

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

@@ -3,16 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanFilePathUnkown = exports.getFilePathToShowToUserFromUnkown = exports.getModuleFilePath = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
+exports.getFilePathAbsoluteUserRootDir = exports.cleanFilePathUnkown = exports.getFilePathToShowToUserFromUnkown = exports.getModuleFilePath = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
 const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../utils.js");
-function getFilePathUnresolved({ importPathAbsolute }) {
-    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
-}
-exports.getFilePathUnresolved = getFilePathUnresolved;
 function getFilePathResolved(args) {
     const { userRootDir } = args;
-    const importPathAbsolute = args.importPathAbsolute ?? null;
     let filePathAbsoluteFilesystem;
     let filePathAbsoluteUserRootDir;
     if ('filePathAbsoluteFilesystem' in args) {
@@ -23,68 +18,68 @@ function getFilePathResolved(args) {
         filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
-    let filePath;
-    const common = {
-        filePathAbsoluteUserRootDir,
-        importPathAbsolute,
-        userRootDir
-    };
-    if (importPathAbsolute) {
-        filePath = getFilePath({
-            ...common,
-            importPathAbsolute
-        });
-    }
-    else {
-        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
-        filePath = getFilePath({
-            ...common,
-            filePathAbsoluteUserRootDir
-        });
-    }
     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
     const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
     (0, utils_js_1.assert)(filePathToShowToUserResolved);
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    const fileName = path_1.default.posix.basename(filePathAbsoluteFilesystem);
     const filePathResolved = {
-        ...filePath,
+        ...getComputedProps(args),
         filePathAbsoluteFilesystem,
-        filePathToShowToUserResolved
+        filePathToShowToUserResolved,
+        fileName
     };
     return filePathResolved;
 }
 exports.getFilePathResolved = getFilePathResolved;
-function getFilePath(args) {
-    let filePathAbsoluteVite;
-    if (args.filePathAbsoluteUserRootDir !== null) {
-        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+function getComputedProps(args) {
+    if ('filePathAbsoluteUserRootDir' in args) {
+        const importPathAbsolute = args.importPathAbsolute ?? null;
+        const { filePathAbsoluteUserRootDir } = args;
+        if (importPathAbsolute)
+            (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
+        return {
+            importPathAbsolute,
+            filePathAbsoluteUserRootDir,
+            filePathAbsoluteVite: filePathAbsoluteUserRootDir,
+            filePathToShowToUser: filePathAbsoluteUserRootDir
+        };
     }
     else {
-        (0, utils_js_1.assert)(args.importPathAbsolute !== null); // Help TS
-        filePathAbsoluteVite = args.importPathAbsolute;
+        return getComputedPropsImportPathAbsolute(args);
     }
-    const filePathToShowToUser = filePathAbsoluteVite;
-    (0, utils_js_1.assert)(filePathToShowToUser);
+}
+function getComputedPropsImportPathAbsolute(args) {
+    const { importPathAbsolute } = args;
+    (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
     return {
-        ...args,
-        filePathAbsoluteFilesystem: null,
-        filePathAbsoluteVite,
-        filePathToShowToUser
+        filePathAbsoluteUserRootDir: null,
+        importPathAbsolute,
+        filePathAbsoluteVite: importPathAbsolute,
+        filePathToShowToUser: importPathAbsolute
     };
 }
+function getFilePathUnresolved(args) {
+    return {
+        ...getComputedPropsImportPathAbsolute(args),
+        filePathAbsoluteFilesystem: null
+    };
+}
+exports.getFilePathUnresolved = getFilePathUnresolved;
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
     const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
     const filePathRelative = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         (0, utils_js_1.assert)(filePathRelative.startsWith('../'));
@@ -100,21 +95,22 @@ function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDi
     (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
     return filePathAbsoluteUserRootDir;
 }
+exports.getFilePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir;
 function getModuleFilePath(moduleId, config) {
     const userRootDir = config.root;
     (0, utils_js_1.assertPosixPath)(moduleId);
     (0, utils_js_1.assertPosixPath)(userRootDir);
     const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
-    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
-    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
-    return filePath.filePathToShowToUserResolved;
+    (0, utils_js_1.assertPathFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
 }
 exports.getModuleFilePath = getModuleFilePath;
 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.assertPathIsFilesystemAbsolute)(userRootDir);
+    (0, utils_js_1.assertPathFilesystemAbsolute)(userRootDir);
     filePathUnkown = cleanFilePathUnkown(filePathUnkown);
     if (!filePathUnkown.startsWith(userRootDir)) {
         return filePathUnkown;

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

@@ -34,11 +34,11 @@ __exportStar(require("../../utils/trimWithAnsi.js"), exports);
 __exportStar(require("../../utils/removeEmptyLines.js"), exports);
 __exportStar(require("../../utils/findFile.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
-__exportStar(require("../../utils/mergeCumulativeValues.js"), exports);
 __exportStar(require("../../utils/deepEqual.js"), exports);
 __exportStar(require("../../utils/assertKeys.js"), exports);
 __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/assertPathIsFilesystemAbsolute.js"), exports);
+__exportStar(require("../../utils/assertPathFilesystemAbsolute.js"), exports);
+__exportStar(require("../../utils/isArray.js"), exports);