vike 0.4.168 → 0.4.170

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

@@ -3,7 +3,7 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -13,12 +13,12 @@ import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
+import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
+import { clearFilesEnvMap, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
@@ -127,6 +127,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
                         'vike-pinia',
                         'vike-solid'
                     ];
+                    assert(extendsConfig.filePath.importPathAbsolute);
                     const extensionName = extendsConfig.filePath.importPathAbsolute.split('/')[0];
                     const warnMsg = alreadyMigrated.includes(extensionName)
                         ? `You're using a deprecated version of the Vike extension ${extensionName}, update ${extensionName} to its latest version.`
@@ -265,6 +266,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);
@@ -301,6 +303,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);
@@ -387,7 +405,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            const { filePathToShowToUser } = configValueSource.definedAt;
+            const { filePathToShowToUser } = configValueSource.definedAtFilePath;
             assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
@@ -481,26 +499,26 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     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_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = getConfigDefinedAtString('Config', configName, { definedAt: definedAtConfigFile });
-            assertUsage(import_, `${configDefinedAt} should be an import`);
-            valueFilePath = import_.filePathAbsoluteVite;
-            definedAt = import_;
+            const pointerImport = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
+            assertUsage(pointerImport, `${configDefinedAt} should be an import`);
+            valueFilePath = pointerImport.filePathAbsoluteVite;
+            definedAtFilePath = pointerImport;
         }
         else {
             assert(interfaceFile.isValueFile);
             valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
-            definedAt = {
+            definedAtFilePath = {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: []
             };
@@ -512,7 +530,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: true,
             valueIsDefinedByValueFile: false,
-            definedAt
+            definedAtFilePath
         };
         return configValueSource;
     }
@@ -520,28 +538,26 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     if (interfaceFile.isConfigFile) {
         assert('configValue' in conf);
         const { configValue } = conf;
-        // fake import
-        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-        if (import_) {
+        // Pointer import
+        const pointerImport = 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) {
-                    assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    assert(hasProp(import_, 'filePathToShowToUserResolved', 'string')); // Help TS
-                    const fileExport = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                if (pointerImport.filePathAbsoluteFilesystem) {
+                    const fileExport = await loadImportedFile(pointerImport, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
                 else {
-                    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
+                    const configDefinedAt = getConfigDefinedAt('Config', configName, configValueSource.definedAtFilePath);
                     assertUsage(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
                 }
             }
@@ -554,7 +570,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: false,
             valueIsDefinedByValueFile: false,
-            definedAt: definedAtConfigFile
+            definedAtFilePath: definedAtFilePath_
         };
         return configValueSource;
     }
@@ -567,7 +583,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByValueFile: true,
-            definedAt: {
+            definedAtFilePath: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName
                     ? []
@@ -605,12 +621,12 @@ function getConfigDefinitions(interfaceFilesRelevant) {
                 return;
             const meta = configMeta.configValue;
             assertMetaValue(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
-            // Set configDef._userEffectDefinedAt
+            // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
                 if (!configDef.effect)
                     return;
                 assert(interfaceFile.isConfigFile);
-                configDef._userEffectDefinedAt = {
+                configDef._userEffectDefinedAtFilePath = {
                     ...interfaceFile.filePath,
                     fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
                 };
@@ -627,24 +643,24 @@ function getConfigDefinitions(interfaceFilesRelevant) {
     const configDefinitions = configDefinitionsMerged;
     return configDefinitions;
 }
-function assertMetaValue(metaVal, configMetaDefinedAt) {
+function assertMetaValue(metaVal, metaConfigDefinedAt) {
     if (!isObject(metaVal)) {
-        assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-        assertUsage(false, `${configMetaDefinedAt} has an invalid type ${pc.cyan(typeof metaVal)}: it should be an object instead.`);
+        assert(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+        assertUsage(false, `${metaConfigDefinedAt} has an invalid type ${pc.cyan(typeof metaVal)}: it should be an object instead.`);
     }
     objectEntries(metaVal).forEach(([configName, def]) => {
         if (!isObject(def)) {
-            assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-            assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}`)} to a value with an invalid type ${pc.cyan(typeof def)}: it should be an object instead.`);
+            assert(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+            assertUsage(false, `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}`)} to a value with an invalid type ${pc.cyan(typeof def)}: it should be an object instead.`);
         }
         // env
         let configEnv;
         {
-            assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
+            assert(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
             if (!('env' in def)) {
-                assertUsage(false, `${configMetaDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required.`);
+                assertUsage(false, `${metaConfigDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required.`);
             }
-            configEnv = getConfigEnvValue(def.env, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to`);
+            configEnv = getConfigEnvValue(def.env, `${metaConfigDefinedAt} sets ${pc.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')
@@ -653,12 +669,12 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         // effect
         if ('effect' in def) {
             if (!hasProp(def, 'effect', 'function')) {
-                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} to an invalid type ${pc.cyan(typeof def.effect)}: it should be a function instead`);
+                assert(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} to an invalid type ${pc.cyan(typeof def.effect)}: it should be a function instead`);
             }
             if (!configEnv.config) {
-                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${pc.cyan('{ config: true }')} (but it's ${pc.cyan(JSON.stringify(configEnv))} instead)`);
+                assert(metaConfigDefinedAt); // We expect internal effects to return a valid meta value
+                assertUsage(false, `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${pc.cyan('{ config: true }')} (but it's ${pc.cyan(JSON.stringify(configEnv))} instead)`);
             }
         }
     });
@@ -680,7 +696,7 @@ function applyEffectsAll(configValueSources, configDefinitions) {
         // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
-            configDefinedAt: getConfigDefinedAtString('Config', configName, source)
+            configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAtFilePath)
         });
         if (!configModFromEffect)
             return;
@@ -692,16 +708,14 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
     const notSupported = `Effects currently only supports modifying the the ${pc.cyan('env')} of a config.`;
     objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            let configDefinedAtString;
-            if (configDefEffect._userEffectDefinedAt) {
-                configDefinedAtString = getConfigDefinedAtString('Config', configName, {
-                    definedAt: configDefEffect._userEffectDefinedAt
-                });
+            let configDefinedAt;
+            if (configDefEffect._userEffectDefinedAtFilePath) {
+                configDefinedAt = getConfigDefinedAt('Config', configName, configDefEffect._userEffectDefinedAtFilePath);
             }
             else {
-                configDefinedAtString = null;
+                configDefinedAt = null;
             }
-            assertMetaValue(configValue, configDefinedAtString);
+            assertMetaValue(configValue, configDefinedAt);
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -719,7 +733,7 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         else {
             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
         }
     });
 }
@@ -827,11 +841,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 };
             assert(filesystemRouteString.startsWith(filesystemRoutingRootEffect.before), debugInfo);
             filesystemRouteString = applyFilesystemRoutingRootEffect(filesystemRouteString, filesystemRoutingRootEffect);
-            // filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootDefinedAt})`
+            // filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootConfigDefinedAt})`
         }
     }
     assert(filesystemRouteString.startsWith('/'));
@@ -846,15 +860,15 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigDefinedAtString('Config', configName, configFilesystemRoutingRoot);
+    const configDefinedAt = getConfigDefinedAt('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAt;
+    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAtFilePath;
     assert(filePathAbsoluteUserRootDir);
     const before = getFilesystemRouteString(getLocationId(filePathAbsoluteUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
-    return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
+    return { filesystemRoutingRootEffect, filesystemRoutingRootConfigDefinedAt: configDefinedAt };
 }
 function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
@@ -867,8 +881,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]) => {
@@ -878,18 +893,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));
+            assert(value.length === definedAtData.length);
             configValues[configName] = {
+                type: 'cumulative',
                 value,
-                definedAt: {
-                    files: sources.map((source) => getDefinedAtFile(source))
-                }
+                definedAtData
             };
         }
     });
@@ -897,62 +914,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 = 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.
         assert('value' in configValueSource);
         // Make sure configValueSource.value is serializable
-        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';
-            assert(vals1.length > 0);
-            if (vals2.length === 0)
-                return;
-            assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigDefinedAtString('Config', configName, configValueSourcePrevious);
-            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).`);
-        };
+        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 {
-            assertUsage(false, `${configDefinedAt} must be an array or a Set`);
-        }
-        configValueSourcePrevious = configValueSource;
+        configValues.push(value);
     });
-    if (valuesArr.length > 0) {
-        assert(valuesSet.length === 0);
-        const result = mergeCumulativeValues(valuesArr);
-        assert(result !== null);
-        return result;
-    }
-    if (valuesSet.length > 0) {
-        assert(valuesArr.length === 0);
-        const result = mergeCumulativeValues(valuesSet);
-        assert(result !== null);
-        return result;
-    }
-    assert(false);
+    return configValues;
 }
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
@@ -1022,10 +998,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(makeFirst(([, [source]]) => {
-        const { importPathAbsolute } = source.definedAt;
+        const { importPathAbsolute } = source.definedAtFilePath;
         return (!!importPathAbsolute &&
             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/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -4,7 +4,7 @@ import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { getConfigValue } from '../../../../../shared/page-configs/helpers.js';
+import { getConfigValue } from '../../../../../shared/page-configs/getConfigValue.js';
 import { getConfigValueSourcesNotOverriden } from '../../../shared/getConfigValueSourcesNotOverriden.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';

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

@@ -3,19 +3,25 @@ export { getFilePathUnresolved };
 export { getModuleFilePath };
 export { getFilePathToShowToUserFromUnkown };
 export { cleanFilePathUnkown };
-import type { FilePath, FilePathResolved } from '../../../shared/page-configs/FilePath.js';
+export { getFilePathAbsoluteUserRootDir };
+import type { FilePathResolved, FilePathUnresolved } from '../../../shared/page-configs/FilePath.js';
 import type { ResolvedConfig } from 'vite';
-declare function getFilePathUnresolved({ importPathAbsolute }: {
-    importPathAbsolute: string;
-}): FilePath;
 declare function getFilePathResolved(args: {
     userRootDir: string;
-    importPathAbsolute?: string;
 } & ({
     filePathAbsoluteFilesystem: string;
+    importPathAbsolute: string;
 } | {
     filePathAbsoluteUserRootDir: string;
+    importPathAbsolute?: string;
 })): FilePathResolved;
+declare function getFilePathUnresolved(args: {
+    importPathAbsolute: string;
+}): FilePathUnresolved;
+declare function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }: {
+    filePathAbsoluteFilesystem: string;
+    userRootDir: string;
+}): string | null;
 declare function getModuleFilePath(moduleId: string, config: ResolvedConfig): string;
 declare function getFilePathToShowToUserFromUnkown(filePathUnkown: string, userRootDir: string): string;
 declare function cleanFilePathUnkown(filePathUnknown: string): string;

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

@@ -3,14 +3,11 @@ export { getFilePathUnresolved };
 export { getModuleFilePath };
 export { getFilePathToShowToUserFromUnkown };
 export { cleanFilePathUnkown };
+export { getFilePathAbsoluteUserRootDir };
 import path from 'path';
-import { assert, assertPathIsFilesystemAbsolute, assertPosixPath, toPosixPath } from '../utils.js';
-function getFilePathUnresolved({ importPathAbsolute }) {
-    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
-}
+import { assert, assertIsNpmPackageImport, assertPathFilesystemAbsolute, assertPosixPath, toPosixPath } from '../utils.js';
 function getFilePathResolved(args) {
     const { userRootDir } = args;
-    const importPathAbsolute = args.importPathAbsolute ?? null;
     let filePathAbsoluteFilesystem;
     let filePathAbsoluteUserRootDir;
     if ('filePathAbsoluteFilesystem' in args) {
@@ -21,73 +18,77 @@ function getFilePathResolved(args) {
         filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
-    let filePath;
-    const common = {
-        filePathAbsoluteUserRootDir,
-        importPathAbsolute,
-        userRootDir
-    };
-    if (importPathAbsolute) {
-        filePath = getFilePath({
-            ...common,
-            importPathAbsolute
-        });
-    }
-    else {
-        assert(filePathAbsoluteUserRootDir);
-        filePath = getFilePath({
-            ...common,
-            filePathAbsoluteUserRootDir
-        });
-    }
     assert(filePathAbsoluteFilesystem);
-    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
     const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
     assert(filePathToShowToUserResolved);
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const fileName = path.posix.basename(filePathAbsoluteFilesystem);
     const filePathResolved = {
-        ...filePath,
+        ...getComputedProps(args),
         filePathAbsoluteFilesystem,
-        filePathToShowToUserResolved
+        filePathToShowToUserResolved,
+        fileName
     };
     return filePathResolved;
 }
-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)
+            assertIsNpmPackageImport(importPathAbsolute);
+        return {
+            importPathAbsolute,
+            filePathAbsoluteUserRootDir,
+            filePathAbsoluteVite: filePathAbsoluteUserRootDir,
+            filePathToShowToUser: filePathAbsoluteUserRootDir
+        };
     }
     else {
-        assert(args.importPathAbsolute !== null); // Help TS
-        filePathAbsoluteVite = args.importPathAbsolute;
+        return getComputedPropsImportPathAbsolute(args);
     }
-    const filePathToShowToUser = filePathAbsoluteVite;
-    assert(filePathToShowToUser);
+}
+function getComputedPropsImportPathAbsolute(args) {
+    const { importPathAbsolute } = args;
+    assertIsNpmPackageImport(importPathAbsolute);
+    return {
+        filePathAbsoluteUserRootDir: null,
+        importPathAbsolute,
+        filePathAbsoluteVite: importPathAbsolute,
+        filePathToShowToUser: importPathAbsolute
+    };
+}
+function getFilePathUnresolved(args) {
     return {
-        ...args,
-        filePathAbsoluteFilesystem: null,
-        filePathAbsoluteVite,
-        filePathToShowToUser
+        ...getComputedPropsImportPathAbsolute(args),
+        filePathAbsoluteFilesystem: null
     };
 }
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     assertPosixPath(filePathAbsoluteUserRootDir);
     assertPosixPath(userRootDir);
-    assertPathIsFilesystemAbsolute(userRootDir);
+    assertPathFilesystemAbsolute(userRootDir);
     const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
-    assertPathIsFilesystemAbsolute(userRootDir);
+    assertPathFilesystemAbsolute(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
     assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
-    assertPathIsFilesystemAbsolute(userRootDir);
+    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
+    assertPathFilesystemAbsolute(userRootDir);
     const filePathRelative = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         assert(filePathRelative.startsWith('../'));
         return null;
     }
-    assert(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
+    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;
@@ -97,15 +98,15 @@ function getModuleFilePath(moduleId, config) {
     assertPosixPath(moduleId);
     assertPosixPath(userRootDir);
     const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
-    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
-    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
-    return filePath.filePathToShowToUserResolved;
+    assertPathFilesystemAbsolute(filePathAbsoluteFilesystem);
+    const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
 }
 function getFilePathToShowToUserFromUnkown(
 // We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
 filePathUnkown, userRootDir) {
     assertPosixPath(userRootDir);
-    assertPathIsFilesystemAbsolute(userRootDir);
+    assertPathFilesystemAbsolute(userRootDir);
     filePathUnkown = cleanFilePathUnkown(filePathUnkown);
     if (!filePathUnkown.startsWith(userRootDir)) {
         return filePathUnkown;

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

@@ -12,11 +12,11 @@ export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
-export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
-export * from '../../utils/assertPathIsFilesystemAbsolute.js';
+export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isArray.js';

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

@@ -18,11 +18,11 @@ export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
-export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
-export * from '../../utils/assertPathIsFilesystemAbsolute.js';
+export * from '../../utils/assertPathFilesystemAbsolute.js';
+export * from '../../utils/isArray.js';