vike 0.4.161 → 0.4.162-commit-8995471

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

@@ -6,10 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVirtualFileImportUserCode = void 0;
 const utils_js_1 = require("../../utils.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+const vite_1 = require("vite");
 const fileTypes_js_1 = require("../../../../shared/getPageFiles/fileTypes.js");
 const path_1 = __importDefault(require("path"));
 const getVirtualFilePageConfigs_js_1 = require("./v1-design/getVirtualFilePageConfigs.js");
-const generateEagerImport_js_1 = require("./generateEagerImport.js");
+const getVikeConfig_js_1 = require("./v1-design/getVikeConfig.js");
 async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
     const idParsed = (0, virtualFileImportUserCode_js_1.isVirtualFileIdImportUserCode)(id);
     (0, utils_js_1.assert)(idParsed);
@@ -27,53 +28,13 @@ async function getCode(config, configVike, isForClientSide, isClientRouting, isP
     (0, utils_js_1.assert)(isDev === !isBuild);
     let content = '';
     {
-        const globRoots = getGlobRoots(config, configVike);
+        const globRoots = getGlobRoots(config);
         (0, utils_js_1.debugGlob)('Glob roots: ', globRoots);
         content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
     }
-    {
-        const extensionsImportPaths = configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(utils_js_1.isNotNullish)
-            .map(({ importPath }) => importPath);
-        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
-    }
     (0, utils_js_1.debugGlob)(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
 }
-function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
-    let fileContent = '\n\n';
-    extensionsImportPaths
-        .filter((importPath) => {
-        (0, utils_js_1.assert)(
-        // V1 design
-        importPath.includes('+') ||
-            // V0.4 design
-            importPath.includes('.page.'));
-        return !importPath.includes('+');
-    })
-        .forEach((importPath) => {
-        const fileType = (0, fileTypes_js_1.determineFileType)(importPath);
-        const { includeImport, includeExportNames } = determineInjection({
-            fileType,
-            isForClientSide,
-            isClientRouting,
-            isPrerendering,
-            isBuild
-        });
-        if (includeImport) {
-            fileContent += addImport(importPath, fileType, false, isBuild);
-        }
-        if (includeExportNames) {
-            fileContent += addImport(importPath, fileType, true, isBuild);
-        }
-        if (!includeImport && !includeExportNames && !isForClientSide) {
-            fileContent += `pageFilesList.push("${importPath}");` + '\n';
-        }
-    });
-    return fileContent;
-}
 function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
     if (!isForClientSide) {
         return {
@@ -99,42 +60,6 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-function addImport(importPath, fileType, exportNames, isBuild) {
-    const pageFilesVar = (() => {
-        if (exportNames) {
-            if (isBuild) {
-                return 'pageFilesExportNamesEager';
-            }
-            else {
-                return 'pageFilesExportNamesLazy';
-            }
-        }
-        else {
-            if (fileType === '.page.route') {
-                return 'pageFilesEager';
-            }
-            else {
-                return 'pageFilesLazy';
-            }
-        }
-    })();
-    const query = !exportNames ? '' : '?extractExportNames';
-    let fileContent = '';
-    const mapVar = `${pageFilesVar}['${fileType}']`;
-    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
-    const value = (() => {
-        if (!pageFilesVar.endsWith('Eager')) {
-            return `() => import('${importPath}${query}')`;
-        }
-        else {
-            const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(`${importPath}${query}`);
-            fileContent += importStatement + '\n';
-            return importName;
-        }
-    })();
-    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
-    return fileContent;
-}
 async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
     let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
 
@@ -149,6 +74,8 @@ export const isGeneratedFile = true;
 ${await (0, getVirtualFilePageConfigs_js_1.getVirtualFilePageConfigs)(isForClientSide, isDev, id, isClientRouting, config)}
 
 `;
+    // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
+    const isV1Design = await (0, getVikeConfig_js_1.isV1Design)(config, isDev);
     fileTypes_js_1.fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
@@ -161,18 +88,18 @@ ${await (0, getVirtualFilePageConfigs_js_1.getVirtualFilePageConfigs)(isForClien
             isBuild
         });
         if (includeImport) {
-            fileContent += getGlobs(globRoots, isBuild, fileType);
+            fileContent += getGlobs(globRoots, isBuild, fileType, null, isV1Design);
         }
         if (includeExportNames) {
-            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames');
+            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
     if (configVike.includeAssetsImportedByServer && isForClientSide) {
-        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets');
+        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
     return fileContent;
 }
-function getGlobs(globRoots, isBuild, fileType, query) {
+function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
     const isEager = isBuild && (query === 'extractExportNames' || fileType === '.page.route');
     let pageFilesVar;
     if (query === 'extractExportNames') {
@@ -212,10 +139,26 @@ function getGlobs(globRoots, isBuild, fileType, query) {
             varNameLocals.push(varNameLocal);
             const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
-            const globOptions = JSON.stringify({ eager: isEager, as: query });
-            (0, utils_js_1.assert)(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globOptions = { eager: isEager };
+            if (query) {
+                const isNewViteInterface = (0, utils_js_1.isVersionOrAbove)(vite_1.version, '5.1.0');
+                if (isNewViteInterface &&
+                    // When used for the old design, the new syntax breaks Vike's CI (surprinsigly so). I couldn't reproduce locally (I didn't dig much).
+                    isV1Design) {
+                    globOptions.query = `?${query}`;
+                }
+                else {
+                    globOptions.as = query;
+                    const msg = [
+                        "Update to the new V1 design to get rid of Vite's warning:",
+                        'The glob option "as" has been deprecated in favour of "query".',
+                        'See https://vike.dev/migration/v1-design for how to migrate.'
+                    ].join(' ');
+                    (0, utils_js_1.assertWarning)(!isNewViteInterface, msg, { onlyOnce: true });
+                }
+            }
             const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${JSON.stringify(globOptions)});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -223,22 +166,13 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ''
     ].join('\n');
 }
-function getGlobRoots(config, configVike) {
+function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
             excludeDir: path_1.default.posix.relative(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot)
         }
     ];
-    configVike.extensions
-        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
-        .filter(utils_js_1.isNotNullish)
-        .forEach((pageConfigsSrcDir) => {
-        const globRoot = {
-            includeDir: path_1.default.posix.relative(config.root, pageConfigsSrcDir)
-        };
-        globRoots.push(globRoot);
-    });
     return globRoots;
 }
 function getGlobPath(globRootDir, fileType) {

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

@@ -38,7 +38,7 @@ function importUserCode() {
         },
         handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config, configVike);
+                return handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -62,12 +62,12 @@ function importUserCode() {
         },
         configureServer(server) {
             (0, utils_js_1.isDev1_onConfigureServer)();
-            handleFileAddRemove(server, config, configVike);
+            handleFileAddRemove(server, config);
         }
     };
 }
 exports.importUserCode = importUserCode;
-function handleFileAddRemove(server, config, configVike) {
+function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
     server.watcher.prependListener('unlink', (f) => listener(f, true));
     return;
@@ -79,11 +79,11 @@ function handleFileAddRemove(server, config, configVike) {
             virtualModules.forEach((mod) => {
                 server.moduleGraph.invalidateModule(mod);
             });
-            reloadConfig(file, config, configVike, isRemove ? 'removed' : 'created');
+            reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
-function handleHotUpdate(ctx, config, configVike) {
+function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     (0, utils_js_1.assertPosixPath)(file);
     getVikeConfig_js_1.vikeConfigDependencies.forEach((f) => (0, utils_js_1.assertPosixPath)(f));
@@ -114,7 +114,7 @@ function handleHotUpdate(ctx, config, configVike) {
         /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
         assert(!isViteModule)
         */
-        reloadConfig(file, config, configVike, 'modified');
+        reloadConfig(file, config, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;
     }
@@ -122,13 +122,13 @@ function handleHotUpdate(ctx, config, configVike) {
 function isVikeConfigModule(filePathAbsoluteFilesystem) {
     return getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
-function reloadConfig(filePath, config, configVike, op) {
+function reloadConfig(filePath, config, op) {
     {
         const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathRelativeToUserRootDir)(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }
-    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, configVike.extensions);
+    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

@@ -66,15 +66,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
         */
         const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
-        (0, utils_js_1.assertUsage)(false, [
-            `The code of ${picocolors_1.default.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
-            'see https://vike.dev/header-file#runtime-code'
-            /* I guess showing this is more confusing than adding value.
-            `(technically speaking: the value of ${pc.cyan(
-              configName
-            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
-            //*/
-        ].join(' '));
+        (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
     }
     configValueSerialized = JSON.stringify(configValueSerialized);
     return configValueSerialized;

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

@@ -89,6 +89,9 @@ const configDefinitionsBuiltIn = {
     },
     cacheControl: {
         env: { server: true }
+    },
+    name: {
+        env: { config: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;

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

@@ -9,7 +9,7 @@ const utils_js_1 = require("../../../../utils.js");
  * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
 function getLocationId(
-// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.h.js` that extends the Vike extension.
+// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.js` that extends the Vike extension.
 filePathRelativeToUserRootDir) {
     (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
     (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));

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

@@ -17,7 +17,7 @@ const resolveImportPath_js_1 = require("./resolveImportPath.js");
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(import_, false, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(import_, userRootDir, false).then((r) => r.fileExports);
     }
     const fileExports = await importedFilesLoaded[f];
     const fileExport = fileExports[import_.fileExportName];
@@ -26,7 +26,7 @@ async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
 exports.loadImportedFile = loadImportedFile;
 // Load +{configName}.js
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, false, userRootDir);
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, userRootDir, false);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     (0, assertPlusFileExport_js_1.assertPlusFileExport)(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -36,10 +36,10 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
 }
 exports.loadValueFile = loadValueFile;
 // Load +config.js, including all its extends fake imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

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

@@ -120,7 +120,7 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
         (0, utils_js_1.assertUsage)(false, [
             `${filePathForEnvCheck} defines the value of configs living in different environments:`,
             ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
+            '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'));
     }
 }

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

@@ -5,52 +5,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isImportData = exports.parseImportData = exports.transformFileImports = void 0;
 // 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
+// Notes about `with { type: 'pointer' }`
+// - 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
+// - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
+//   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
+//   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// - Using a import path suffix such as `import { Layout } from './Layout?real` breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
+// - Node.js >=21 supports import attribtues: https://nodejs.org/api/esm.html#import-attributes
+// - Esbuid supports
+//   - Blocker: https://github.com/evanw/esbuild/issues/3646
+//     - Ugly hack to make it work: https://github.com/brillout/esbuild-playground/tree/experiment/import-attribute
+//   - Discussion with esbuild maintainer: https://github.com/evanw/esbuild/issues/3384
+// - Using a magic comment `// @vike-real-import` is probably a bad idea:
+//   - 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)
 const acorn_1 = require("acorn");
 const utils_js_1 = require("../../../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function transformFileImports(code, filePathToShowToUser2, 
+// TODO: rename transformFileImports() => transformPointerImports()
+function transformFileImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformFileImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
-    const fileImportsTransformed = [];
     // Performance trick
     if (!code.includes('import'))
-        return { noTransformation: true };
+        return null;
     const imports = getImports(code);
     if (imports.length === 0)
-        return { noTransformation: true };
+        return null;
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
         const importPath = node.source.value;
         (0, utils_js_1.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;
+        if (pointerImports !== 'all') {
+            (0, utils_js_1.assert)(importPath in pointerImports);
+            const isPointerImport = pointerImports[importPath];
+            (0, utils_js_1.assert)(isPointerImport === true || isPointerImport === false);
+            if (!isPointerImport)
+                return;
         }
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
-        // No variable imported
+        /* Pointer import without importing any value => doesn't make sense and doesn't have any effect.
+        ```js
+        // Useless
+        import './some.css'
+        // Useless
+        import './Layout.jsx'
+        ``` */
         if (node.specifiers.length === 0) {
             const isWarning = !utils_js_1.styleFileRE.test(importPath);
             let quote = indent(importStatementCode);
@@ -61,8 +64,9 @@ skipWarnings) {
                 quote = picocolors_1.default.bold(picocolors_1.default.red(quote));
             }
             const errMsg = [
-                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser2} has no effect:`,
-                quote
+                `The following import in ${filePathToShowToUser2} has no effect:`,
+                quote,
+                'See https://vike.dev/config#pointer-imports'
             ].join('\n');
             if (!skipWarnings) {
                 if (!isWarning) {
@@ -91,11 +95,6 @@ skipWarnings) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImportsTransformed.push({
-                importStatementCode,
-                importString,
-                importLocalName
-            });
         });
         spliceOperations.push({
             start,
@@ -104,7 +103,7 @@ skipWarnings) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImportsTransformed, noTransformation: false };
+    return codeMod;
 }
 exports.transformFileImports = transformFileImports;
 function getImports(code) {