vike 0.4.220-commit-5c7810f → 0.4.220-commit-af5c91f

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

@@ -1,48 +1,45 @@
 // Files loaded at config time:
-export { loadImportedFile };
+export { loadPointerImport };
 export { loadValueFile };
-export { loadValueFiles };
 export { loadConfigFile };
-import { assert, assertUsage, assertIsNotProductionRuntime, isArrayOfStrings, isObject, genPromise } from '../../../../utils.js';
+import { assert, assertUsage, assertIsNotProductionRuntime, isArrayOfStrings, isObject } from '../../../../utils.js';
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
-import { getConfigDefinitionOptional, shouldBeLoadableAtBuildTime } from '../getVikeConfig.js';
+import { getConfigDefinitionOptional } from '../getVikeConfig.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
 import { parsePointerImportData } from './transformPointerImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
-import { resolvePointerImport } from './resolvePointerImport.js';
+import { resolvePointerImportData } from './resolvePointerImport.js';
+import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
 assertIsNotProductionRuntime();
 // Load pointer import
-async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
-    const f = import_.filePathAbsoluteFilesystem;
-    if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, userRootDir, false).then((r) => r.fileExports);
-    }
-    const fileExports = await importedFilesLoaded[f];
-    const fileExport = fileExports[import_.fileExportName];
-    return fileExport;
+async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache) {
+    // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+    if (configName === 'extends')
+        return;
+    const configDef = getConfigDefinitionOptional(configDefinitions, configName);
+    // Only load pointer import if `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
+        return;
+    const configDefinedAt = getConfigDefinedAt('Config', configName, pointerImport.fileExportPath);
+    assertUsage(pointerImport.fileExportPath.filePathAbsoluteFilesystem, `${configDefinedAt} cannot be defined over an aliased import`);
+    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, esbuildCache);
+    const fileExportValue = fileExports[pointerImport.fileExportPath.fileExportName];
+    pointerImport.fileExportValueLoaded = true;
+    assert(pointerImport.fileExportValueLoaded);
+    pointerImport.fileExportValue = fileExportValue;
 }
 // Load +{configName}.js
-async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir) {
+async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, esbuildCache) {
     const { configName } = interfaceValueFile;
     const configDef = getConfigDefinitionOptional(configDefinitions, configName);
-    if (!configDef || !shouldBeLoadableAtBuildTime(configDef)) {
-        // Only load value files with `env.config===true`
+    // Only load value files with `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
         return;
-    }
-    if (interfaceValueFile.isValueLoaded) {
-        await interfaceValueFile.isValueLoaded;
-        if (
-        // Help TS
-        true)
-            return;
-    }
-    const { promise, resolve } = genPromise();
-    interfaceValueFile.isValueLoaded = promise;
-    assert(interfaceValueFile.isValueLoaded);
+    interfaceValueFile.isValueFileLoaded = true;
+    assert(interfaceValueFile.isValueFileLoaded);
     interfaceValueFile.fileExportsByConfigName = {};
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false);
-    resolve();
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -50,21 +47,12 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir)
         interfaceValueFile.fileExportsByConfigName[configName_] = configValue;
     });
 }
-async function loadValueFiles(interfaceFiles, configDefinitions, userRootDir) {
-    await Promise.all(Object.values(interfaceFiles)
-        .flat(1)
-        .filter((interfaceFile) => interfaceFile.isValueFile)
-        .map(async (interfaceFile) => await loadValueFile(interfaceFile, configDefinitions, userRootDir)));
-}
 // Load +config.js, including all its extends pointer imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
-        ...visited,
-        filePathAbsoluteFilesystem
-    ]);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true, esbuildCache);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
     const configFile = {
         fileExports,
         filePath: configFilePath,
@@ -80,15 +68,15 @@ function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
     assert(loop[0] === filePathAbsoluteFilesystem);
     assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, esbuildCache) {
     const { extendsPointerImportData, extendsConfigs } = getExtendsPointerImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsPointerImportData.map((pointerImportData) => {
-        const filePath = resolvePointerImport(pointerImportData, configFilePath, userRootDir);
+        const filePath = resolvePointerImportData(pointerImportData, configFilePath, userRootDir);
         assert(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
-    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true)));
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, esbuildCache)));
     results.forEach((result) => {
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
@@ -131,3 +119,6 @@ function getExtendsPointerImportData(configFileExports, configFilePath) {
     }
     return { extendsPointerImportData, extendsConfigs };
 }
+function shouldBeLoadableAtBuildTime(configDef) {
+    return !!configDef.env.config && !configDef._valueIsFilePath;
+}

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

@@ -1,22 +1,12 @@
-export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
-export { clearFilesEnvMap };
-export { resolveConfigEnvWithFileName };
-import type { ConfigEnvInternal, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
+export { resolvePointerImportData };
+export type { PointerImport };
+import type { DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
 import { type PointerImportData } from './transformPointerImports.js';
 import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-type PointerImportResolved = DefinedAtFilePath & {
-    fileExportName: string;
-};
-declare function resolvePointerImportOfConfig(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | {
-    pointerImport: PointerImportResolved;
-    configEnvResolved: ConfigEnvInternal;
-};
-declare function resolvePointerImport(pointerImportData: PointerImportData, importerFilePath: FilePathResolved, userRootDir: string): FilePath;
-declare function clearFilesEnvMap(): void;
-declare function resolveConfigEnvWithFileName(configEnv: ConfigEnvInternal, filePath: FilePathResolved): {
-    server?: boolean | undefined;
-    config?: boolean | undefined;
-    client?: boolean | "if-client-routing";
-    production?: boolean;
+type PointerImport = {
+    fileExportPath: FileExportPath;
 };
+type FileExportPath = DefinedAtFilePath & Required<Pick<DefinedAtFilePath, 'fileExportName'>>;
+declare function resolvePointerImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configName: string): null | PointerImport;
+declare function resolvePointerImportData(pointerImportData: PointerImportData, importerFilePath: FilePathResolved, userRootDir: string): FilePath;

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

@@ -1,34 +1,27 @@
-export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
-export { clearFilesEnvMap };
-export { resolveConfigEnvWithFileName };
+export { resolvePointerImportData };
 import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
+import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, pathIsRelative, requireResolve } from '../../../../utils.js';
 import { parsePointerImportData } from './transformPointerImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
-const filesEnvMap = new Map();
-function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir, configEnv, configName) {
+function resolvePointerImport(configValue, importerFilePath, userRootDir, configName) {
     if (typeof configValue !== 'string')
         return null;
     const pointerImportData = parsePointerImportData(configValue);
     if (!pointerImportData)
         return null;
-    const { importPath, exportName } = pointerImportData;
-    const filePath = resolvePointerImport(pointerImportData, importerFilePath, userRootDir);
+    const { exportName } = pointerImportData;
+    const filePath = resolvePointerImportData(pointerImportData, importerFilePath, userRootDir);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    let configEnvResolved = configEnv;
-    if (filePath.filePathAbsoluteFilesystem)
-        configEnvResolved = resolveConfigEnvWithFileName(configEnv, filePath);
-    assertUsageFileEnv(filePath, importPath, configEnvResolved, configName);
-    const pointerImport = {
+    const fileExportPath = {
         ...filePath,
         fileExportName: exportName,
         fileExportPathToShowToUser
     };
-    return { pointerImport, configEnvResolved };
+    return { fileExportPath };
 }
-function resolvePointerImport(pointerImportData, importerFilePath, userRootDir) {
+function resolvePointerImportData(pointerImportData, importerFilePath, userRootDir) {
     // `importPath` should be one of the following:
     // - A relative import path
     // - A filesystem absolute path
@@ -39,7 +32,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     assertPosixPath(importPath);
     if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
         if (importPath.startsWith('.')) {
-            assertUsage(isRelativeImportPath(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
+            assertUsage(pathIsRelative(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
         }
         // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
         assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
@@ -95,7 +88,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             : `The import ${pc.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
-            assert(isRelativeImportPath(importPath));
+            assert(pathIsRelative(importPath));
             assertUsage(false, `${errIntro2} point to an existing file?`);
         }
         else {
@@ -103,51 +96,3 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
         }
     }
 }
-function assertUsageFileEnv(filePath, importPath, configEnvResolved, configName) {
-    let key;
-    if (filePath.filePathAbsoluteFilesystem) {
-        key = filePath.filePathAbsoluteFilesystem;
-    }
-    else {
-        // Path alias
-        assert(!isRelativeImportPath(importPath));
-        key = importPath;
-    }
-    assertPosixPath(key);
-    if (!filesEnvMap.has(key)) {
-        filesEnvMap.set(key, []);
-    }
-    const fileEnv = filesEnvMap.get(key);
-    fileEnv.push({ configEnvResolved, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnvResolved, configEnvResolved))[0];
-    if (configDifferentEnv) {
-        assertUsage(false, [
-            `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnvResolved }].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnvResolved))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
-        ].join('\n'));
-    }
-}
-function clearFilesEnvMap() {
-    filesEnvMap.clear();
-}
-function resolveConfigEnvWithFileName(configEnv, filePath) {
-    const { fileName } = filePath;
-    const configEnvResolved = { ...configEnv };
-    if (fileName.includes('.server.')) {
-        configEnvResolved.server = true;
-        configEnvResolved.client = false;
-    }
-    else if (fileName.includes('.client.')) {
-        configEnvResolved.client = true;
-        configEnvResolved.server = false;
-    }
-    else if (fileName.includes('.shared.')) {
-        configEnvResolved.server = true;
-        configEnvResolved.client = true;
-    }
-    return configEnvResolved;
-}
-function isRelativeImportPath(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
-}

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

@@ -2,11 +2,15 @@ export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTemporaryBuildFile };
+export type { EsbuildCache };
 import 'source-map-support/register.js';
 import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config'): Promise<{
+type FileExports = {
     fileExports: Record<string, unknown>;
-}>;
+};
+type EsbuildCache = Record<string, // filePathAbsoluteFilesystem
+Promise<FileExports>>;
+declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config', esbuildCache: EsbuildCache): Promise<FileExports>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;
 declare function isTemporaryBuildFile(filePath: string): boolean;

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, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise } from '../../../../utils.js';
 import { transformPointerImports } from './transformPointerImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -21,25 +21,31 @@ const debug = createDebugger('vike:pointer-imports');
 const debugEsbuildResolve = createDebugger('vike:esbuild-resolve');
 if (debugEsbuildResolve.isActivated)
     debugEsbuildResolve('esbuild version', version);
-async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
+async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
+    if (esbuildCache[filePathAbsoluteFilesystem]) {
+        return await esbuildCache[filePathAbsoluteFilesystem];
+    }
+    const { promise, resolve } = genPromise();
+    esbuildCache[filePathAbsoluteFilesystem] = promise;
     assertUsage(isPlainJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
         assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
     }
+    let fileExports;
     if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
         // This doesn't track dependencies => we should never use this for user land configs
-        const fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
-        return { fileExports };
+        fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
     }
     else {
         const transformImports = isConfigFile && (isHeader ? 'all' : true);
         const code = await transpileFile(filePath, transformImports, userRootDir);
-        const fileExports = await executeTranspiledFile(filePath, code);
-        return { fileExports };
+        fileExports = await executeTranspiledFile(filePath, code);
     }
+    resolve({ fileExports });
+    return { fileExports };
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;

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

@@ -6,7 +6,6 @@ export { isVikeConfigFile };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
-export { shouldBeLoadableAtBuildTime };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
 export type { InterfaceFile };
@@ -15,6 +14,7 @@ import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../..
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
+import { type PointerImportLoaded } from './getVikeConfig/loadFileAtConfigTime.js';
 import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
@@ -26,21 +26,24 @@ type InterfaceConfigFile = InterfaceFileCommons & {
     isConfigFile: true;
     isValueFile: false;
     extendsFilePaths: string[];
-    isConfigExtend: boolean;
-    isValueLoaded: true;
+    isConfigExtension: boolean;
+    isValueFileLoaded: true;
     fileExportsByConfigName: Record<string, // configName
     unknown>;
+    pointerImportsByConfigName: Record<string, // configValue
+    PointerImportLoaded>;
 };
 type InterfaceValueFile = InterfaceFileCommons & {
     isConfigFile: false;
     isValueFile: true;
+    isConfigExtension?: undefined;
     configName: string;
 } & ({
-    isValueLoaded: Promise<void>;
+    isValueFileLoaded: true;
     fileExportsByConfigName: Record<string, // configName
     unknown>;
 } | {
-    isValueLoaded: false;
+    isValueFileLoaded: false;
 });
 type InterfaceFilesByLocationId = Record<LocationId, InterfaceFile[]>;
 type VikeConfigObject = {
@@ -57,7 +60,6 @@ declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePlu
 declare function isV1Design(config: ResolvedConfig): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitions, configName: string): ConfigDefinitionInternal | null;
-declare function shouldBeLoadableAtBuildTime(configDef: ConfigDefinitionInternal): boolean;
 declare function getConfVal(interfaceFile: InterfaceFile, configName: string): null | {
     configValue: unknown;
     configValueLoaded: true;