vike 0.4.159 → 0.4.160-commit-30d535e

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

@@ -1,21 +1,50 @@
-export { replaceImportStatements };
+export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 // Playground: https://github.com/brillout/acorn-playground
+// Import attributes support: https://github.com/acornjs/acorn/issues/983
+//  - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
 import { parse } from 'acorn';
-import { assert, assertUsage, assertWarning, styleFileRE } from '../../../utils.js';
+import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
 import pc from '@brillout/picocolors';
-function replaceImportStatements(code, filePathToShowToUser) {
+function transformFileImports(code, filePathToShowToUser2, 
+// For ./transformFileImports.spec.ts
+skipWarnings) {
     const spliceOperations = [];
-    const fileImports = [];
+    const fileImportsTransformed = [];
+    // Performance trick
+    if (!code.includes('import'))
+        return { noTransformation: true };
     const imports = getImports(code);
     if (imports.length === 0)
-        return { noImportStatement: true };
+        return { noTransformation: true };
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
         const importPath = node.source.value;
         assert(typeof importPath === 'string');
+        // - This doesn't work. To make it work we would need to run esbuild twice: esbuild for TypeScript to JavaScript => transformFileImports() => esbuild for bundling.
+        //   - Or we use an esbuild plugin to apply transformFileImports(). Maybe we can completely skip the need for acorn?
+        // - ?real breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
+        // - Import attributes would be the best.
+        //   - But it only works with Node.js >=21: https://nodejs.org/api/esm.html#import-attributes
+        //     - But it's probably ok to tell users "to use real imports you need Node.js 21 or above".
+        //   - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+        //   - Esbuid seems to support it: https://esbuild.github.io/plugins/#on-load-arguments:~:text=This%20contains%20a%20map%20of%20the%20import%20attributes%20that
+        //   - acorn supports it over an acorn plugin: https://github.com/acornjs/acorn/issues/983
+        //     - Maybe we can use an esbuild plugin instead of acorn to apply transformFileImports()?
+        // - Using a magic comment `// @vike-real-import` is tricky:
+        //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
+        //   - Using source maps to track these magic comments is brittle (source maps can easily break)
+        if (importPath.endsWith('?real')) {
+            const { start, end } = node.source;
+            spliceOperations.push({
+                start,
+                end,
+                replacement: importPath.slice(0, -1 * '?real'.length)
+            });
+            return;
+        }
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
         // No variable imported
@@ -29,13 +58,15 @@ function replaceImportStatements(code, filePathToShowToUser) {
                 quote = pc.bold(pc.red(quote));
             }
             const errMsg = [
-                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser} has no effect:`,
+                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser2} has no effect:`,
                 quote
             ].join('\n');
-            if (!isWarning) {
-                assertUsage(false, errMsg);
+            if (!skipWarnings) {
+                if (!isWarning) {
+                    assertUsage(false, errMsg);
+                }
+                assertWarning(false, errMsg, { onlyOnce: true });
             }
-            assertWarning(false, errMsg, { onlyOnce: true });
         }
         let replacement = '';
         node.specifiers.forEach((specifier) => {
@@ -57,7 +88,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImports.push({
+            fileImportsTransformed.push({
                 importStatementCode,
                 importString,
                 importLocalName
@@ -70,7 +101,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImports, noImportStatement: false };
+    return { code: codeMod, fileImportsTransformed, noTransformation: false };
 }
 function getImports(code) {
     const { body } = parse(code, {
@@ -137,7 +168,7 @@ function spliceMany(str, operations) {
                     .join('');
         endPrev = end;
     });
-    strMod += str.slice(endPrev, str.length - 1);
+    strMod += str.slice(endPrev, str.length);
     return strMod;
 }
 function indent(str) {

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

@@ -1,10 +1,10 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
-import type { FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
-declare function transpileAndExecuteFile(filePath: FilePathResolved, isValueFile: boolean, userRootDir: string): Promise<{
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+declare function transpileAndExecuteFile(filePath: FilePathResolved, transformImports: boolean, userRootDir: string, doNotTranspile?: boolean): Promise<{
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;

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

@@ -1,63 +1,73 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
-import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
-import { vikeConfigDependencies } from './getVikeConfig.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../../utils.js';
+import { isImportData, transformFileImports } from './transformFileImports.js';
+import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
-import { assertExportsOfConfigFile } from '../../../../../shared/page-configs/assertExports.js';
+import { getConfigFileExport } from '../getConfigFileExport.js';
 assertIsNotProductionRuntime();
-async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
-    const { code, fileImports } = await transpileFile(filePath, isValueFile, userRootDir);
-    const { fileExports } = await executeFile(filePath, code, fileImports, isValueFile);
-    return { fileExports };
+async function transpileAndExecuteFile(filePath, transformImports, userRootDir, doNotTranspile = false) {
+    if (doNotTranspile) {
+        assert(!transformImports);
+        const fileExports = await executeFile(filePath.filePathAbsoluteFilesystem, filePath);
+        if (isHeaderFile(filePath.filePathAbsoluteFilesystem)) {
+            const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+            assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files don't apply to the config files of extensions`, { onlyOnce: true });
+        }
+        return { fileExports };
+    }
+    else {
+        const { code, fileImportsTransformed } = await transpileFile(filePath, transformImports, userRootDir);
+        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed);
+        return { fileExports };
+    }
 }
-async function transpileFile(filePath, isValueFile, userRootDir) {
+async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem } = filePath;
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
-    let fileImports = null;
-    {
-        const res = transpileImports(code, filePath, isValueFile);
+    let code = await transpileWithEsbuild(filePath, userRootDir, transformImports);
+    let fileImportsTransformed = null;
+    if (transformImports) {
+        const res = transformFileImports_(code, filePath);
         if (res) {
             code = res.code;
-            fileImports = res.fileImports;
+            fileImportsTransformed = res.fileImportsTransformed;
         }
     }
-    return { code, fileImports };
-}
-function transpileImports(codeOriginal, filePath, isValueFile) {
-    // Do we need to remove the imports?
-    const { filePathAbsoluteFilesystem, filePathToShowToUser } = filePath;
-    assertPosixPath(filePathAbsoluteFilesystem);
-    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
-    const isPageConfigFile = !isValueFile;
-    if (!isHeader && !isPageConfigFile) {
-        return null;
+    else {
+        if (isHeaderFile(filePathAbsoluteFilesystem)) {
+            assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files only apply to +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
+        }
     }
-    assertWarning(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
-    // Remove the imports
-    const res = replaceImportStatements(codeOriginal, filePathToShowToUser);
-    if (res.noImportStatement) {
+    return { code, fileImportsTransformed };
+}
+function transformFileImports_(codeOriginal, filePath) {
+    const { filePathAbsoluteFilesystem } = filePath;
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    // Replace import statements with import strings
+    const res = transformFileImports(codeOriginal, filePathToShowToUser2);
+    if (res.noTransformation) {
         return null;
     }
-    const { code, fileImports } = res;
-    if (!isHeader) {
-        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
-        assertWarning(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, {
+    const { code, fileImportsTransformed } = res;
+    if (!isHeaderFile(filePathAbsoluteFilesystem)) {
+        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser2);
+        assertWarning(false, `Rename ${filePathToShowToUser2} to ${filePathCorrect}, see https://vike.dev/header-file`, {
             onlyOnce: true
         });
     }
-    return { code, fileImports };
+    return { code, fileImportsTransformed };
 }
-async function transpileWithEsbuild(filePath, bundle, userRootDir) {
+async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
     const options = {
@@ -73,22 +83,26 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         'NEVER_EMITTED.js'),
         logLevel: 'silent',
         format: 'esm',
-        bundle,
+        absWorkingDir: userRootDir,
+        // Disable tree-shaking to avoid dead-code elimination, so that unused imports aren't removed.
+        // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
+        treeShaking: false,
         minify: false,
-        metafile: bundle,
-        absWorkingDir: userRootDir
+        metafile: !transformImports,
+        // We cannot bundle imports that are meant to be transformed
+        bundle: !transformImports
     };
-    if (bundle) {
-        options.bundle = true;
+    // Track dependencies
+    if (!transformImports) {
         options.packages = 'external';
         options.plugins = [
             {
-                name: 'vike:import-hook',
+                name: 'vike:dependency-tracker',
                 setup(b) {
                     b.onLoad({ filter: /./ }, (args) => {
+                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
                         let { path } = args;
                         path = toPosixPath(path);
-                        // We collect the dependency args.path in case it fails to build (upon build error => error is thrown => no metafile)
                         vikeConfigDependencies.add(path);
                         return undefined;
                     });
@@ -105,11 +119,6 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
             }
         ];
     }
-    else {
-        // Avoid dead-code elimination to ensure unused imports aren't removed.
-        // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
-        options.treeShaking = false;
-    }
     let result;
     try {
         result = await build(options);
@@ -118,7 +127,8 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         await formatBuildErr(err, filePath);
         throw err;
     }
-    if (bundle) {
+    // Track dependencies
+    if (!transformImports) {
         assert(result.metafile);
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = toPosixPath(filePathRelative);
@@ -131,7 +141,7 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     assert(typeof code === 'string');
     return code;
 }
-async function executeFile(filePath, code, fileImports, isValueFile) {
+async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
     const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
@@ -140,28 +150,35 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
     try {
-        fileExports = await import_(filePathTmp);
+        fileExports = await executeFile(filePathTmp, filePath);
+    }
+    finally {
+        clean();
+    }
+    if (fileImportsTransformed) {
+        assert(filePathRelativeToUserRootDir !== undefined);
+        const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+        assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);
+    }
+    return fileExports;
+}
+async function executeFile(filePathToExecuteAbsoluteFilesystem, filePathSourceFile) {
+    let fileExports = {};
+    try {
+        fileExports = await import_(filePathToExecuteAbsoluteFilesystem);
     }
     catch (err) {
         triggerPrepareStackTrace(err);
-        const errIntroMsg = getErrIntroMsg('execute', filePath);
+        const errIntroMsg = getErrIntroMsg('execute', filePathSourceFile);
         assert(isObject(err));
         execErrIntroMsg.set(err, errIntroMsg);
         throw err;
     }
-    finally {
-        clean();
-    }
-    // Return a plain JavaScript object
+    // Return a plain JavaScript object:
     //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
-    //  - We don't need this special object
+    //  - We don't need this special object.
     fileExports = { ...fileExports };
-    if (fileImports && !isValueFile) {
-        assert(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
-        assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
-    }
-    return { fileExports };
+    return fileExports;
 }
 const formatted = '_formatted';
 function getConfigBuildErrorFormatted(err) {
@@ -191,10 +208,10 @@ function getConfigExecutionErrorIntroMsg(err) {
     return errIntroMsg ?? null;
 }
 const tmpPrefix = `[build-`;
-function getFilePathTmp(filePath) {
-    assertPosixPath(filePath);
-    const dirname = path.posix.dirname(filePath);
-    const filename = path.posix.basename(filePath);
+function getFilePathTmp(filePathAbsoluteFilesystem) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
+    const filename = path.posix.basename(filePathAbsoluteFilesystem);
     // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
     const tag = `${tmpPrefix}${getRandomId(12)}]`;
     const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);
@@ -205,29 +222,29 @@ function isTmpFile(filePath) {
     const fileName = path.posix.basename(filePath);
     return fileName.startsWith(tmpPrefix);
 }
-function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser) {
-    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
-    const exportedStrings = getExportedStrings(fileExports.default);
+function assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2) {
+    const fileExport = getConfigFileExport(fileExports, filePathToShowToUser2);
+    const exportedStrings = getExportedStrings(fileExport);
     Object.values(exportedStrings).forEach((exportVal) => {
         if (typeof exportVal !== 'string')
             return;
         if (!isImportData(exportVal))
             return;
         const importString = exportVal;
-        fileImports.forEach((fileImport) => {
+        fileImportsTransformed.forEach((fileImport) => {
             if (fileImport.importString === importString) {
                 fileImport.isReExported = true;
             }
         });
     });
-    const fileImportsUnused = fileImports.filter((fi) => !fi.isReExported);
-    if (fileImportsUnused.length === 0)
+    const fileImportsTransformedUnused = fileImportsTransformed.filter((fi) => !fi.isReExported);
+    if (fileImportsTransformedUnused.length === 0)
         return;
-    const importStatements = unique(fileImportsUnused.map((fi) => fi.importStatementCode));
-    const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
-    const singular = fileImportsUnused.length === 1;
-    assertWarning(fileImportsUnused.length === 0, [
-        `${filePathToShowToUser} imports the following:`,
+    const importStatements = unique(fileImportsTransformedUnused.map((fi) => fi.importStatementCode));
+    const importNamesUnused = fileImportsTransformedUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
+    const singular = fileImportsTransformedUnused.length === 1;
+    assertWarning(fileImportsTransformedUnused.length === 0, [
+        `${filePathToShowToUser2} imports the following:`,
         ...importStatements.map((s) => pc.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
     ].join('\n'), { onlyOnce: true });
@@ -249,6 +266,7 @@ function getExportedStrings(obj) {
     return exportedStrings;
 }
 function isHeaderFile(filePath) {
+    assertPosixPath(filePath);
     const basenameParts = path.posix.basename(filePath).split('.');
     return basenameParts.includes('h');
 }
@@ -269,10 +287,19 @@ function triggerPrepareStackTrace(err) {
     }
 }
 function getErrIntroMsg(operation, filePath) {
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     const msg = [
+        // prettier ignore
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePath.filePathToShowToUser)),
+        pc.bold(pc.red(filePathToShowToUser2)),
         pc.red(`because:`)
     ].join(' ');
     return msg;
 }
+/** `filePath.filePathToShowToUser` may show the import path of a package, use `filePathToShowToUser2` instead always show a file path instead. */
+function getFilePathToShowToUser2(filePath) {
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
+    const filePathToShowToUser2 = filePathRelativeToUserRootDir || filePathAbsoluteFilesystem;
+    assert(filePathToShowToUser2);
+    return filePathToShowToUser2;
+}

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

@@ -2,9 +2,24 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+export type { InterfaceValueFile };
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
+import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
+type InterfaceFileCommons = {
+    locationId: LocationId;
+    filePath: FilePathResolved;
+    fileExportsByConfigName: Record<ConfigName, {
+        configValue?: unknown;
+    }>;
+};
+type InterfaceValueFile = InterfaceFileCommons & {
+    isConfigFile: false;
+    isValueFile: true;
+    configName: string;
+};
+type ConfigName = string;
 type VikeConfig = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;