vike 0.4.159 → 0.4.160-commit-a1101c1

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

@@ -28,7 +28,8 @@ const baseUrls_js_1 = require("./plugins/baseUrls.js");
 const envVars_js_1 = require("./plugins/envVars.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const fileEnv_js_1 = require("./plugins/fileEnv.js");
-(0, utils_js_2.markEnvAsVite)();
+assertNodeEnv();
+(0, utils_js_2.markEnvAsVikePluginLoaded)();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
@@ -70,3 +71,21 @@ Object.defineProperty(plugin, 'apply', {
         (0, utils_js_2.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
+function assertNodeEnv() {
+    const nodeEnv = (0, utils_js_2.getNodeEnv)();
+    if (nodeEnv === 'test')
+        return;
+    // We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value).
+    (0, utils_js_2.assertUsage)(
+    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
+    isNodeEnvDev() || isVikeCliBuild(),
+    /*/
+    (0, utils_js_2.isNodeEnvDev)() || true, 
+    ///*/
+    [
+        picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
+        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
+        'while the vike/plugin module is loaded.',
+        utils_js_2.vikeVitePluginLoadedInProductionError
+    ].join(' '));
+}

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

@@ -66,7 +66,7 @@ function devConfig() {
                 }
             },
             configureServer() {
-                (0, utils_js_1.markEnvAsDev)();
+                (0, utils_js_1.markEnvAsViteDev)();
             }
         },
         {

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

@@ -37,7 +37,7 @@ function importBuild() {
             getImporterCode: () => {
                 return getEntryCode(config, configVike);
             },
-            libraryName: utils_js_1.projectInfo.projectName
+            libraryName: 'Vike'
         })
     ];
 }

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigFileExport = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assertPlusFileExport_js_1 = require("../../../../../shared/page-configs/assertPlusFileExport.js");
+const utils_js_1 = require("../../../utils.js");
+function getConfigFileExport(fileExports, filePathToShowToUser) {
+    (0, assertPlusFileExport_js_1.assertPlusFileExport)(fileExports, filePathToShowToUser, 'config');
+    const fileExport = fileExports.default || fileExports.config;
+    (0, utils_js_1.assert)('default' in fileExports !== 'config' in fileExports);
+    const exportName = picocolors_1.default.cyan('default' in fileExports ? 'export default' : 'export { config }');
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(fileExport), `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportedValue === ${JSON.stringify(typeof fileExport)}`)} instead)`);
+    return fileExport;
+}
+exports.getConfigFileExport = getConfigFileExport;

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

@@ -0,0 +1,129 @@
+"use strict";
+// Files loadded at config time:
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigFile = exports.loadValueFile = exports.loadImportedFile = void 0;
+const utils_js_1 = require("../../../../utils.js");
+const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
+const assertPlusFileExport_js_1 = require("../../../../../../shared/page-configs/assertPlusFileExport.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const transformImports_js_1 = require("./transformImports.js");
+const getConfigFileExport_js_1 = require("../getConfigFileExport.js");
+const resolveImportPath_js_1 = require("./resolveImportPath.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+// Load fake import
+async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
+    const f = import_.filePathAbsoluteFilesystem;
+    if (!importedFilesLoaded[f]) {
+        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(import_, true, userRootDir).then((r) => r.fileExports);
+    }
+    const fileExports = await importedFilesLoaded[f];
+    const fileExport = fileExports[import_.fileExportName];
+    return fileExport;
+}
+exports.loadImportedFile = loadImportedFile;
+// Load +{configName}.js
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, true, userRootDir);
+    const { filePathToShowToUser } = interfaceValueFile.filePath;
+    (0, assertPlusFileExport_js_1.assertPlusFileExport)(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.fileExportsByConfigName[configName_] = { configValue };
+    });
+}
+exports.loadValueFile = loadValueFile;
+// Load +config.js, including all its extends fake imports
+async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir, isConfigOfExtension);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
+        ...visited,
+        filePathAbsoluteFilesystem
+    ]);
+    const configFile = {
+        fileExports,
+        filePath: configFilePath,
+        extendsFilePaths
+    };
+    return { configFile, extendsConfigs };
+}
+exports.loadConfigFile = loadConfigFile;
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
+    if (idx === -1)
+        return;
+    const loop = visited.slice(idx);
+    (0, utils_js_1.assert)(loop[0] === filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertUsage)(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
+}
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
+    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
+    const extendsConfigFiles = [];
+    extendsImportData.map((importData) => {
+        const { importPath: importPath } = importData;
+        const filePathAbsoluteFilesystem = (0, resolveImportPath_js_1.resolveImportPath)(importData, configFilePath);
+        (0, resolveImportPath_js_1.assertImportPath)(filePathAbsoluteFilesystem, importData, configFilePath);
+        warnUserLandExtension(importPath, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
+        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
+        extendsConfigFiles.push({
+            filePathAbsoluteFilesystem,
+            filePathAbsoluteVite,
+            filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathAbsoluteVite,
+            importPathAbsolute: importPath
+        });
+    });
+    const extendsConfigs = [];
+    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
+        const result = await loadConfigFile(configFilePath, userRootDir, visited, true);
+        extendsConfigs.push(result.configFile);
+        extendsConfigs.push(...result.extendsConfigs);
+    }));
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
+    return { extendsConfigs, extendsFilePaths };
+}
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        return null;
+    }
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathRelativeToUserRootDir.startsWith('/'))
+        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
+    return filePathRelativeToUserRootDir;
+}
+function warnUserLandExtension(importPath, configFilePath) {
+    (0, utils_js_1.assertWarning)((0, utils_js_1.isNpmPackageImport)(importPath), `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
+}
+function getExtendsImportData(configFileExports, configFilePath) {
+    const { filePathToShowToUser } = configFilePath;
+    const configFileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(configFileExports, filePathToShowToUser);
+    const wrongUsage = `${filePathToShowToUser} sets the config ${picocolors_1.default.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
+    let extendList;
+    if (!('extends' in configFileExport)) {
+        return [];
+    }
+    else if ((0, utils_js_1.hasProp)(configFileExport, 'extends', 'string')) {
+        extendList = [configFileExport.extends];
+    }
+    else if ((0, utils_js_1.hasProp)(configFileExport, 'extends', 'string[]')) {
+        extendList = configFileExport.extends;
+    }
+    else {
+        (0, utils_js_1.assertUsage)(false, wrongUsage);
+    }
+    const extendsImportData = extendList.map((importDataSerialized) => {
+        const importData = (0, transformImports_js_1.parseImportData)(importDataSerialized);
+        (0, utils_js_1.assertUsage)(importData, wrongUsage);
+        return importData;
+    });
+    return extendsImportData;
+}

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

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearFilesEnvMap = exports.assertImportPath = exports.resolveImportPath = exports.resolveImport = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_1 = require("../../../../utils.js");
+const transformImports_js_1 = require("./transformImports.js");
+const path_1 = __importDefault(require("path"));
+const filesEnvMap = new Map();
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
+    if (typeof configValue !== 'string')
+        return null;
+    const importData = (0, transformImports_js_1.parseImportData)(configValue);
+    if (!importData)
+        return null;
+    const { importPath, exportName } = importData;
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
+    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    if (importPath.startsWith('.')) {
+        // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
+        // ```
+        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
+        // ```
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteVite: filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+    else {
+        // importPath can be:
+        //  - an npm package import
+        //  - a path alias
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir: null,
+            filePathAbsoluteVite: importPath,
+            filePathToShowToUser: importPath,
+            importPathAbsolute: importPath
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+}
+exports.resolveImport = resolveImport;
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+    }
+    else {
+        (0, utils_js_1.assertUsage)(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${picocolors_1.default.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        // None of the following works. Seems to be a Vite bug?
+        // /*
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
+        // /*/
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
+        // //*/
+    }
+    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
+    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
+}
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
+    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
+    const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
+}
+exports.resolveImportPath = resolveImportPath;
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
+    const { filePathToShowToUser } = importerFilePath;
+    if (!filePathAbsoluteFilesystem) {
+        const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
+        const errIntro = importStringWasGenerated
+            ? `The import path ${importPathString} in ${filePathToShowToUser}`
+            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
+        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
+        if (importPath.startsWith('.')) {
+            (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
+        }
+        else {
+            (0, utils_js_1.assertUsage)(false, `${errIntro2} exist?`);
+        }
+    }
+}
+exports.assertImportPath = assertImportPath;
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
+    if (!filesEnvMap.has(filePathForEnvCheck)) {
+        filesEnvMap.set(filePathForEnvCheck, []);
+    }
+    const fileEnv = filesEnvMap.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
+    if (configDifferentEnv) {
+        (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'
+        ].join('\n'));
+    }
+}
+function clearFilesEnvMap() {
+    filesEnvMap.clear();
+}
+exports.clearFilesEnvMap = clearFilesEnvMap;
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPosixPath)(root);
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path_1.default.posix.relative(root, filePathAbsoluteFilesystem);
+    (0, utils_js_1.assert)(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
+    vitePath = '/' + vitePath;
+    return vitePath;
+}

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

@@ -3,22 +3,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImportData = exports.parseImportData = exports.replaceImportStatements = void 0;
+exports.isImportData = exports.parseImportData = exports.transformImports = 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
 const acorn_1 = require("acorn");
-const utils_js_1 = require("../../../utils.js");
+const utils_js_1 = require("../../../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function replaceImportStatements(code, filePathToShowToUser) {
+function transformImports(code, filePathToShowToUser2, 
+// For ./transformImports.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;
         (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 => transformImports() => esbuild for bundling.
+        //   - Or we use an esbuild plugin to apply transformImports(). 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 transformImports()?
+        // - 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
@@ -32,13 +61,15 @@ function replaceImportStatements(code, filePathToShowToUser) {
                 quote = picocolors_1.default.bold(picocolors_1.default.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) {
-                (0, utils_js_1.assertUsage)(false, errMsg);
+            if (!skipWarnings) {
+                if (!isWarning) {
+                    (0, utils_js_1.assertUsage)(false, errMsg);
+                }
+                (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
             }
-            (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
         }
         let replacement = '';
         node.specifiers.forEach((specifier) => {
@@ -60,7 +91,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImports.push({
+            fileImportsTransformed.push({
                 importStatementCode,
                 importString,
                 importLocalName
@@ -73,9 +104,9 @@ function replaceImportStatements(code, filePathToShowToUser) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImports, noImportStatement: false };
+    return { code: codeMod, fileImportsTransformed, noTransformation: false };
 }
-exports.replaceImportStatements = replaceImportStatements;
+exports.transformImports = transformImports;
 function getImports(code) {
     const { body } = (0, acorn_1.parse)(code, {
         ecmaVersion: 'latest',
@@ -143,7 +174,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) {