tungsten 0.1.6 → 0.1.24

package/dist/babelPlugins/BabelTransformPackageImports.js

@@ -0,0 +1,680 @@
+// BabelTransformPackgeImports
+// exports MakeBabelTransformPackgeImports (function)
+//
+// Update bare imports to point to a local copy of the pack
+// e.g. 'tungsten' to './.packages/tungsten/index.js'
+// The end of the page ('index.js') is determining through import
+// resolution
+import { join, dirname, relative } from 'path';
+import slash from 'slash';
+import precinct from 'precinct';
+import cabinet from 'sxy-filing-cabinet';
+import { existsSync, mkdirSync, promises as fsPromises, readFileSync, writeFileSync } from 'fs';
+import { createRequire } from 'module';
+import { transformFileAsync as babelTransformFileAsync, transformAsync as babelTransformAsync } from '@babel/core';
+import babelPluginSyntaxImportAssertionsModule from '@babel/plugin-syntax-import-assertions';
+import { arrays } from 'sxy-lib';
+const babelPluginSyntaxImportAssertions = babelPluginSyntaxImportAssertionsModule.default;
+import { init as lexerInit, parse as lexerParse } from 'cjs-module-lexer';
+lexerInit();
+import { MakeBabelTransformCjsToFunction } from "./BabelTransformCjsToFunction.js";
+import { MakeBabelTransformDependencyImportsEsm } from "./BabelTransformDependencyImportsEsm.js";
+import { MakeBabelTransformDependencyImportsCjs } from "./BabelTransformDependencyImportsCjs.js";
+import { devBuildFolder, frameworkDistFolder, packageName as frameworkPackageName, packageName, packagesCacheFolder, packagesFolder /*, packagesCacheInfoName*/ } from "../settings.js";
+import { findProjectDir } from "../findProjectDir.js";
+import { cliError, cliWarn, cliNote } from "../cliOutput.js";
+import { isBareImport } from "./isBareImport.js";
+import { TungstenError } from "../TungstenError.js";
+import { throwError } from "../throwError.js";
+import { errorOut } from "../output.js";
+//import { copyPackageModulesToPackagesFolder } from '../build/copyPackageModulesToPackagesFolder.js'
+const require = createRequire(import.meta.url);
+function debug(...texts) {
+  //console.log(...texts)
+}
+export function MakeBabelTransformPackageImports(opts) {
+  const buildLocation = join(opts.projectDir, devBuildFolder);
+  const packagesLocation = join(buildLocation, packagesFolder);
+  // get info about the packages cache
+  const packagesCacheLocation = join(opts.projectDir, packagesCacheFolder);
+  const packages = {};
+  const nonEsmPackages = {};
+  function applyImportAliases(location, fileType) {
+    // we probably need to apply an alias from jsx-runtime to jsxRuntime.js at some point
+    if (location.startsWith('./') || location.startsWith('../')) {
+      throw new TungstenError(`applyImportAliases() error: received a relative import, expected a bare import: ${location}`);
+    }
+    const segments = location.split('/');
+    const [packageName, remaining] = location.startsWith('@') ? [segments[0] + '/' + segments[1], segments.slice(2).join('/')] : [segments[0], segments.slice(1).join('/')];
+    if (packageName === 'react') {
+      const sxyFrameworkBase = fileType === 'esm' ? 'tungsten/' : 'tungsten/sync/';
+      if (location === 'react') location = sxyFrameworkBase + 'index.js';else location = sxyFrameworkBase + remaining;
+    }
+    return location;
+  }
+  const externalImportFinalImportLocationCache = {};
+  const getExternalImportFinalImportLocation = function getExternalImportFinalImportLocation(location, sourceFile, sourcePackageDir, fileType) {
+    const cache = externalImportFinalImportLocationCache;
+    //const key = sourcePackageDir + ':' + location
+    const key = fileType + ':' + sourcePackageDir + ':' + location; // include module type in key to switch between CJS entry and CJS normal
+    const cachedResult = cache[key];
+    if (cachedResult !== undefined) {
+      return cachedResult;
+    } else {
+      // aliases - at this point just redirecting react imports to tungsten
+      location = applyImportAliases(location, fileType);
+      const fullLocation = require.resolve(location, {
+        paths: [sourcePackageDir]
+      });
+      if (fullLocation === location) {
+        return fullLocation;
+      }
+      const targetPackageInfo = getPackageInfoForFile(fullLocation);
+      const targetFileInfo = resolveFile(fullLocation);
+      let finalLocation;
+      if (fileType === 'esm' && targetFileInfo.type !== 'esm') {
+        //console.log('cjs entry full', fullLocation)
+        //console.log('cjs entry web', targetFileInfo.webLocation)
+        //     ? do we need to calculate the new location now??
+        //     ?? then pass along to the next script (TransformDependencyImports?)
+        finalLocation = join(buildLocation, makeCjsEntryFile(fullLocation, targetFileInfo.webLocation));
+      } else {
+        finalLocation = getFileFinalLocation(fullLocation, targetPackageInfo);
+      }
+      //console.log('final', finalLocation)
+      return cache[key] = finalLocation;
+    }
+  };
+  const cjsRequireCache = {};
+  function getCjsRequire(file) {
+    if (file in cjsRequireCache) {
+      return cjsRequireCache[file];
+    } else {
+      return cjsRequireCache[file] = createRequire(file);
+    }
+  }
+  const cjsRelativeImportSourceImportLocationCache = {};
+  const getCjsRelativeImportSourceLocation = function getCjsRelativeImportSourceLocation(location, source /*, sourcePackageDir*/) {
+    const cache = cjsRelativeImportSourceImportLocationCache;
+    const key = source + ':' + location;
+    const cachedResult = cache[key];
+    if (cachedResult !== undefined) {
+      return cachedResult;
+    } else {
+      const require = getCjsRequire(source);
+      const fullLocation = require.resolve(location);
+      return cache[key] = fullLocation;
+    }
+  };
+  const cjsRelativeImportFinalImportLocationCache = {};
+  const getCjsRelativeImportFinalImportLocation = function getCjsRelativeImportFinalImportLocation(location, source /*, sourcePackageDir*/) {
+    const cache = cjsRelativeImportFinalImportLocationCache;
+    const key = source + ':' + location;
+    const cachedResult = cache[key];
+    if (cachedResult !== undefined) {
+      return cachedResult;
+    } else {
+      const require = getCjsRequire(source);
+      const fullLocation = require.resolve(location);
+      const targetPackageInfo = getPackageInfoForFile(fullLocation); // seems expensive
+      // can we use the package dir instead?
+      const finalLocation = getFileFinalLocation(fullLocation, targetPackageInfo);
+      return cache[key] = finalLocation;
+    }
+  };
+  function resolvePrecinctDependencies(deps, file, packageDir, sourceFilename) {
+    const out = [];
+    for (const dep of deps) {
+      if (dep.startsWith('node:')) continue;
+      try {
+        const f = cabinet({
+          partial: dep,
+          filename: file,
+          directory: packageDir
+        });
+        if (f === '') throw new TungstenError(`resolvePrecinctDependencies() err: cabinet returned empty string for ${dep} in ${packageDir}`);
+        out.push(f);
+      } catch (error) {
+        errorOut(`dependency lookup failed for dependency "${dep}" in file "${file}" originating in file ${sourceFilename}`);
+        throw error;
+      }
+    }
+    return out;
+  }
+  function getFileDependencies(fileInfo, packageDir, sourceFilename) {
+    const {
+      file
+    } = fileInfo;
+    const precinctResults = precinct.paperwork(file, {
+      includeCore: false
+    });
+    const deps = precinctResults.map(d => {
+      //console.log('getFileDependencies', 'd', d)
+      return isBareImport(d) ? applyImportAliases(d, fileInfo.type) : d;
+    });
+    const resolved = resolvePrecinctDependencies(deps, file, packageDir, sourceFilename);
+    return resolved;
+  }
+  function getFileEsmGenIntermediateCacheLocation(file, packageInfo) {
+    const rel = file.slice(packageInfo.packageDir.length);
+    return packageInfo.cacheLocation + '-cjs-mod' + rel;
+  }
+  const getFileFinalLocation = function getFileFinalLocation(file, packageInfo) {
+    const rel = file.slice(packageInfo.packageDir.length);
+    return packageInfo.finalLocation + rel;
+  };
+  const getPackageDirForDirCache = {};
+  function getPackageDirForDir(dir) {
+    if (dir in getPackageDirForDirCache) {
+      return getPackageDirForDirCache[dir];
+    } else {
+      return getPackageDirForDirCache[dir] = findProjectDir(dir);
+    }
+  }
+  const getPackageDirForFile = function getPackageDirForFile(file) {
+    return getPackageDirForDir(dirname(file));
+  };
+  function packageIsEsm(packageJson) {
+    return packageJson.type === 'module';
+  }
+  const importedPackageLocations = {};
+  function getPackageInfo(packageDir) {
+    //console.log('getPackageInfo', packageDir)
+    if (packageDir in importedPackageLocations) {
+      return importedPackageLocations[packageDir];
+    } else {
+      const packageJson = require(join(packageDir, 'package.json'));
+      const packageName = packageJson.name;
+      const version = packageJson.version;
+      const packageIdentifier = `${packageName}@${version}`;
+      const packageType = packageIsEsm(packageJson) ? 'esm' : 'non-esm';
+      const cacheLocation = join(packagesCacheLocation, packageIdentifier);
+      const finalLocation = join(packagesLocation, packageIdentifier);
+      const packageInfo = {
+        packageDir,
+        packageJson,
+        packageName,
+        version,
+        packageIdentifier,
+        type: packageType,
+        cacheLocation,
+        finalLocation
+        //dependencyPackagesInfo
+      };
+      if (packageIdentifier in packages) {
+        if (packages[packageIdentifier].packageDir !== packageDir) {
+          cliWarn(`BabelTransformPackageImports found the same package in 2 different locations:` + `\n${packages[packageIdentifier].packageDir}` + `\nand\n${packageDir}`);
+        }
+      }
+      if (!(packageIdentifier in packages)) {
+        const packageLogItem = {
+          ...packageInfo,
+          files: []
+        };
+        packages[packageIdentifier] = packageLogItem;
+        if (packageType !== 'esm') {
+          nonEsmPackages[packageIdentifier] = packageLogItem;
+        }
+      }
+      return importedPackageLocations[packageDir] = {
+        packageDir,
+        packageJson,
+        packageName,
+        version,
+        packageIdentifier,
+        type: packageType,
+        cacheLocation,
+        finalLocation
+        //dependencyPackagesInfo
+      };
+    }
+  }
+  const getPackageInfoForFile = function getPackageInfoForFile(file) {
+    const packageDir = getPackageDirForFile(file);
+    //console.log('packageDir', packageDir)
+    return getPackageInfo(packageDir);
+  };
+  function makeModifyImportsEsmBabelOptions(nonEsmDeps) {
+    return {
+      plugins: [babelPluginSyntaxImportAssertions, MakeBabelTransformDependencyImportsEsm({
+        nonEsmDeps
+      }, {
+        getPackageDirForFile,
+        getPackageInfoForFile,
+        getExternalImportFinalImportLocation,
+        getFileFinalLocation,
+        makeCjsEntryFile
+      })]
+    };
+  }
+  async function babelFileEsm(file /*, packageInfo*/, nonEsmDeps) {
+    const result = await babelTransformFileAsync(file, makeModifyImportsEsmBabelOptions(nonEsmDeps.map(d => d.webLocation)));
+    if (result === null) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (1) returned null: ${file}`);
+    }
+    if (result.code === null || result.code === undefined) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (1) returned code was null or undefined: ${typeof result.code}, ${file}`);
+    }
+    return result.code;
+  }
+  function makeCjsToEsmBabelOptions(dependencies) {
+    return {
+      plugins: [MakeBabelTransformCjsToFunction({
+        dependencies
+      })]
+    };
+  }
+  function makeModifyImportsCjsBabelOptions(nonEsmDeps) {
+    return {
+      plugins: [babelPluginSyntaxImportAssertions, MakeBabelTransformDependencyImportsCjs({
+        nonEsmDeps
+      }, {
+        getPackageDirForFile,
+        getPackageInfoForFile,
+        getExternalImportFinalImportLocation,
+        getCjsRelativeImportFinalImportLocation,
+        getFileFinalLocation
+      })]
+    };
+  }
+  // parent func is writing to these locations -
+  // these vars just for testing for now
+  async function babelFileCjs(file, cacheDest, finalDest, packageInfo, nonEsmDeps) {
+    //console.log(chalk.yellow`cjs file ${file}`)
+    const nonEsmDepsWebPath = nonEsmDeps.map(fi => fi.webLocation);
+    let result = await babelTransformFileAsync(file, makeCjsToEsmBabelOptions(nonEsmDepsWebPath));
+    if (result === null) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (2) returned null: ${file}`);
+    }
+    if (result.code === null || result.code === undefined) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (2) returned code was null or undefined: ${typeof result.code}, ${file}`);
+    }
+    const intermedCacheLocation = getFileEsmGenIntermediateCacheLocation(file, packageInfo);
+    await fsPromises.mkdir(dirname(intermedCacheLocation), {
+      recursive: true
+    });
+    await fsPromises.writeFile(intermedCacheLocation, result.code); // rel contains the slash at start
+    result = await babelTransformAsync(result.code, {
+      filename: file,
+      ...makeModifyImportsCjsBabelOptions(nonEsmDepsWebPath)
+    });
+    if (result === null) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (3) returned null: ${file}`);
+    }
+    if (result.code === null || result.code === undefined) {
+      throw new TungstenError(`BabelTransformPackageImports error: sub file babel transform (3) returned code was null or undefined: ${typeof result.code}, ${file}`);
+    }
+    //if (file.includes('domexception')) console.log('transformed imports', code)
+    return result.code;
+  }
+  function addToDependencyGraphFromFileInfo(fileInfo, dependencies) {
+    return addToDependencyGraph(fileInfo.fileIdentifier, fileInfo.file, fileInfo.cacheDest, fileInfo.finalDest, fileInfo.packageInfo.type, dependencies);
+  }
+  function addToDependencyGraphFromCacheNode(fileIdentifier, cacheNode, dependencies) {
+    //throw new TungstenError(`addToDependencyGraphFromCacheNode() not implemented yet`)
+    return addToDependencyGraph(fileIdentifier, cacheNode.originalLocation, cacheNode.cacheLocation, cacheNode.finalLocation, cacheNode.type, dependencies);
+  }
+  function addToDependencyGraph(fileIdentifier, file, cacheLocation, finalLocation, fileType, dependencies) {
+    //console.log('addToDependencyGraph')
+    //console.log(type, file, dependencies.length)
+    opts.dependencyGraph[fileIdentifier] = {
+      type: fileType,
+      originalLocation: file,
+      cacheLocation: cacheLocation,
+      finalLocation: finalLocation
+    };
+    if (dependencies) opts.dependencyGraph[fileIdentifier].dependencies = dependencies;
+  }
+  function resolveFile(file) {
+    //console.log('resolve file', file)
+    const packageDir = getPackageDirForFile(file);
+    const packageInfo = getPackageInfo(packageDir);
+    const relFile = file.slice(packageInfo.packageDir.length + 1);
+    const fileIdentifier = `${packageInfo.packageIdentifier}/${slash(relFile)}`;
+    const cacheDest = join(packageInfo.cacheLocation, relFile);
+    const finalDest = join(packageInfo.finalLocation, relFile);
+    const webLocation = `/${packagesFolder}/${packageInfo.packageIdentifier}/${slash(relFile)}`;
+    const syncFile = packageInfo.packageName === frameworkPackageName && slash(relFile).startsWith(`${frameworkDistFolder}/sync/`);
+    //console.log('resolving file', file)
+    return {
+      file,
+      relFile,
+      fileIdentifier,
+      cacheDest,
+      finalDest,
+      webLocation,
+      type: file.endsWith('.json') ? 'json' : syncFile ? 'cmp-cjs' : file.endsWith('.mjs') ? 'esm' : file.endsWith('.cjs') ? 'cjs' : packageInfo.type,
+      packageInfo
+    };
+  }
+  async function doProcessFile(fileInfo, sourceFilename) {
+    try {
+      const {
+        file,
+        cacheDest,
+        finalDest,
+        packageInfo
+      } = fileInfo;
+      const dependencies = getFileDependencies(fileInfo, packageInfo.packageDir, sourceFilename);
+      const dependenciesFull = dependencies.map(d => resolveFile(d));
+      const nonEsmDependenciesFull = dependenciesFull.filter(fi => fi.type !== 'esm');
+      //await recordFileInPackagesLog(relFile, packageInfo)
+      await fsPromises.mkdir(dirname(cacheDest), {
+        recursive: true
+      });
+      await fsPromises.mkdir(dirname(finalDest), {
+        recursive: true
+      });
+      //if (file.endsWith('index.cjs')) console.log('checking type for *index.cjs file:', packageInfo.type)
+      if (packageInfo.type === 'esm' && file.endsWith('.js') || file.endsWith('.mjs')) {
+        const code = await babelFileEsm(file /*, packageInfo*/, nonEsmDependenciesFull);
+        await fsPromises.writeFile(cacheDest, code); // rel contains the slash at start
+        await fsPromises.writeFile(finalDest, code); // rel contains the slash at start
+      } else {
+        //if (file.endsWith('index.cjs')) console.log('trying to transform a *index.cjs file:', file)
+        const code = await babelFileCjs(file, cacheDest, finalDest, packageInfo, nonEsmDependenciesFull);
+        //if (file.endsWith('index.cjs')) console.log('writing a transformed *index.cjs file to cache:', cacheDest)
+        await fsPromises.writeFile(cacheDest, code); // rel contains the slash at start
+        //if (file.endsWith('index.cjs')) console.log('writing a transformed *index.cjs file to final:', finalDest)
+        await fsPromises.writeFile(finalDest, code); // rel contains the slash at start
+      }
+      const dependenciesFileIndentifiers = dependenciesFull.map(d => d.fileIdentifier);
+      addToDependencyGraphFromFileInfo(fileInfo, dependenciesFileIndentifiers);
+      // add deps to dependencyGraph
+      // returns the deps
+      await processDependencies(dependenciesFull /*, dependenciesMap*/, sourceFilename);
+      //console.log('Files outstanding', filesNum)
+      return processedFilesCache[file];
+    } catch (e) {
+      cliError(`process file err`, e);
+      throw e;
+    }
+  }
+  async function copyFileFromCache(fileIdentifier, cacheNode) {
+    //
+    await fsPromises.mkdir(dirname(cacheNode.finalLocation), {
+      recursive: true
+    });
+    await fsPromises.copyFile(cacheNode.cacheLocation, cacheNode.finalLocation);
+    if (cacheNode.dependencies) {
+      processCacheDependencies(cacheNode.dependencies);
+    }
+    addToDependencyGraphFromCacheNode(fileIdentifier, cacheNode, cacheNode.dependencies);
+  }
+  async function processCacheDependencies(dependencies) {
+    for (const dep of dependencies) {
+      if (!(dep in opts.oldDependencyGraph)) {
+        throw new TungstenError(`processCacheDependencies() Error: ${dep} not found in existing dependency graph`);
+      }
+      const cacheNode = opts.oldDependencyGraph[dep];
+      if (existsSync(cacheNode.originalLocation)) {
+        await copyFileFromCache(dep, cacheNode);
+      } else {
+        throw new TungstenError(`processCacheDependencies() Error: source file ${cacheNode.originalLocation} for ${dep} does not exist` + `perhaps the package version was increased, and we need to process anew`);
+        // find the import/require specification
+        // resolve with sxy-filing-cabinet
+        // resolveFile
+        // processFile
+      }
+    }
+  }
+  const processedFilesCache = {};
+  async function processFile(fileInfo /*, dependenciesMap*/, sourceFilename) {
+    const {
+      file
+    } = fileInfo;
+    if (file in processedFilesCache) {
+      return processedFilesCache[file];
+    } else {
+      processedFilesCache[file] = fileInfo.packageInfo;
+      await doProcessFile(fileInfo, sourceFilename);
+      return processedFilesCache[file];
+    }
+  }
+  // get file info
+  const processedJsonFilesCache = {};
+  async function processJsonFile(fileInfo) {
+    const {
+      file
+    } = fileInfo;
+    if (file in processedJsonFilesCache) {
+      return processedJsonFilesCache[file];
+    } else {
+      //// Do we need to save these json files in dep chart?
+      //// Probably??
+      const packageDir = getPackageDirForFile(file);
+      const packageInfo = getPackageInfo(packageDir);
+      const relFile = file.slice(packageDir.length); // we're keeping the slash at the start
+      const cacheDest = packageInfo.cacheLocation + relFile;
+      const finalDest = packageInfo.finalLocation + relFile;
+      await fsPromises.mkdir(dirname(cacheDest), {
+        recursive: true
+      });
+      await fsPromises.mkdir(dirname(finalDest), {
+        recursive: true
+      });
+      await fsPromises.copyFile(file, cacheDest);
+      await fsPromises.copyFile(file, finalDest);
+      addToDependencyGraphFromFileInfo(fileInfo);
+      return processedJsonFilesCache[file] = packageInfo;
+    }
+  }
+  async function processDependencies(dependencies /*, dependenciesMap*/, sourceFilename) {
+    for (const fileInfo of dependencies) {
+      const file = fileInfo.file;
+      if (file === '') {
+        cliNote(`Dep was empty`);
+        continue;
+      }
+      // regex: ends with .js , .cjs or .mjs
+      if (/\.(c|m)?js$/.test(file)) {
+        await processFile(fileInfo, sourceFilename);
+      } else if (file.endsWith('.json')) {
+        await processJsonFile(fileInfo);
+      } else {
+        cliWarn(`BabelTransformPackageImports warning: depended on file ends with unknown extension: ${file}`);
+      }
+    }
+  }
+  const importedPackageFiles = {};
+  function processPackageFile(file, sourceFilename) {
+    //console.log('processPackageFile', file)
+    if (file in importedPackageFiles) {
+      return importedPackageFiles[file];
+    } else {
+      const fileInfo = resolveFile(file);
+      opts.promises.push(processFile(fileInfo, sourceFilename));
+      return importedPackageFiles[file] = fileInfo;
+    }
+  }
+  function addImportAlias(source, dest) {
+    if (!(source in opts.importAliases) && source !== 'tungsten' && !source.startsWith('tungsten/')) {
+      opts.importAliases[source] = dest;
+    }
+  }
+  // find the dependencies CJS of a module using node's dependency detection algorithm
+  // use to create static exports to CJS entry files that match those that node discovers
+  function lex(file) {
+    const exportsMap = lexInternal(file);
+    //console.log('lex exportsMap', exportsMap)
+    const exports = Object.keys(exportsMap);
+    //console.log('lex exports', exports)
+    return exports;
+  }
+  // we are going to work with a map instead of array for performance, then convert it to an array in the outer function lex
+  const lexInnerCache = {};
+  function lexInternal(file) {
+    const cache = lexInnerCache;
+    if (file in cache) {
+      return cache[file];
+    } else {
+      const code = readFileSync(file, 'utf8');
+      const {
+        exports,
+        reexports
+      } = lexerParse(code);
+      //console.log('lexInner exports', exports)
+      const exportsMap = arrays.mapToObject(exports, value => [value, true]);
+      //console.log('lexInner exports map', exportsMap)
+      for (const re of reexports) {
+        const reFullLocation = getCjsRelativeImportSourceLocation(re, file);
+        const reLexExportsMap = lexInternal(reFullLocation);
+        Object.assign(exportsMap, reLexExportsMap);
+      }
+      return cache[file] = exportsMap;
+    }
+  }
+  //
+  const makeCjsEntryFileCache = {};
+  const makeCjsEntryFile = function makeCjsEntryFile(orginalFile, newLocationSiteRel) {
+    //console.log('makeCjsEntryFile', 'orginalFile', orginalFile, 'newLocationSiteRel', newLocationSiteRel)
+    const cache = makeCjsEntryFileCache;
+    if (newLocationSiteRel in cache) {
+      return cache[newLocationSiteRel];
+    } else {
+      const entryFile = newLocationSiteRel.slice(0, newLocationSiteRel.lastIndexOf('.')) + '.sxy-entry.js';
+      const entryFileAbs = join(buildLocation, entryFile);
+      //console.log('lex', orginalFile)
+      const namedExports = lex(orginalFile);
+      //console.log('named exports', namedExports)
+      let entryFileContent = `const e = await __tungsten_cjs_import('${newLocationSiteRel}')\n`;
+      entryFileContent += `export default e;\n`;
+      //console.log(chalk.red`namedExports`, namedExports)
+      // ensure this code matches the filtering for 'default' below
+      const hasNamedExports = namedExports.length >= 2 || namedExports.length === 1 && namedExports[0] !== 'default';
+      if (hasNamedExports) {
+        namedExports.forEach(ex => {
+          if (ex === 'default') return; // filtering here to avoid a second loop. Maybe we should edit cjs-module-lexer to do this
+          //entryFileContent += `export const ${ex} = e['${ex}'];\n`
+          entryFileContent += `const _${ex} = e['${ex}'];\n`;
+        });
+        entryFileContent += `export { `;
+        let first = true;
+        namedExports.forEach(ex => {
+          if (ex === 'default') return; // filtering here to avoid a second loop. Maybe we should edit cjs-module-lexer to do this
+          if (first) {
+            entryFileContent += `_${ex} as ${ex}`;
+            first = false;
+          } else {
+            entryFileContent += `, _${ex} as ${ex}`;
+          }
+        });
+        entryFileContent += ` }\n`;
+      }
+      mkdirSync(dirname(entryFileAbs), {
+        recursive: true
+      });
+      writeFileSync(entryFileAbs, entryFileContent);
+      return cache[newLocationSiteRel] = entryFile;
+    }
+  };
+  return function BabelTransformPackageImports( /*babel*/
+  ) {
+    //const t = babel.types
+    let filename;
+    let destinationFilename;
+    let require;
+    //let dependencyChart
+    // function processExport(path: NodePath<ExportNamedDeclaration> | NodePath<ExportAllDeclaration>) {
+    //     const source = path.node.source
+    //     if (source !== null) {
+    //         const location = source.value
+    //     }
+    // }
+    return {
+      pre(state) {
+        filename = slash(state.opts.filename);
+        //console.log('BabelTransformPackageImports on', filename)
+        const relativeFilename = filename.slice(opts.codeDir.length + 1);
+        destinationFilename = join(buildLocation, relativeFilename);
+        //console.log('filename', filename, 'destinationFilename', destinationFilename)
+        require = createRequire(filename);
+        //console.log(chalk.blue`require created for ${filename}`)
+      },
+      visitor: {
+        ImportDeclaration: function (path) {
+          try {
+            let location = path.node.source.value;
+            //console.log('BabelTransformPackageImports', 'ImportDeclaration', location)
+            // see if it is a bare import
+            if (isBareImport(location)) {
+              //if (location.startsWith('@')) console.log('import starts with @', location)
+              //console.log(chalk.blue('Bare PackageImport found'), location, 'from', filename)
+              // if ('location'.startsWith('node:')) {
+              //     throwError('BabelTransformPackageImports', 'Found an import to a node package in user code.')
+              // }
+              //console.log('*', filename, 'processing bare import', location)
+              // hacky alias
+              if (location === 'tungsten/jsx-runtime') {
+                //console.log(chalk.orange`We did the hacky jsx runtime alias in BabelTransformPackageImports`)
+                location = 'tungsten/jsxRuntime.js';
+              }
+              // the real file location of the file being imported
+              const importTarget = require.resolve(location);
+              // Should do some checking here to show helpful errors about bad imports
+              if (importTarget === location) {
+                //console.log()
+                // errorOut(errorMessage(
+                //     'BabelTransformPackageImports',
+                //     `import '${location}' in '${filename}' appears to refer to a node package.`
+                //     + ` This file is being processed as client-side code.`
+                //     + ` Client-side code cannot import node packages.`
+                //     + `\nIf you need to exclude files from client side compilation,`
+                //     + ` use exclude: glob-pattern in the project's ${packageName} config.`
+                // ))
+                throwError('BabelTransformPackageImports', `import '${location}' in '${filename}' appears to refer to a node package.` + ` This file is being processed as client-side code.` + ` Client-side code cannot import node packages.` + `\nIf you need to exclude files from client side compilation,` + ` use exclude: glob-pattern in the project's ${packageName} config.`);
+                return;
+              }
+              //console.log('** importTarget', importTarget)
+              const fileInfo = processPackageFile(importTarget, filename);
+              const {
+                file: sourceFile,
+                finalDest,
+                webLocation,
+                type
+              } = fileInfo;
+              //const { packageIdentifier } = fileInfo.packageInfo
+              //// location relative to this file
+              // relative assumes to source to be a dir, so use only the dirname not the full path
+              let newLocationRelative = relative(dirname(destinationFilename), finalDest);
+              if (!newLocationRelative.startsWith('../')) newLocationRelative = './' + newLocationRelative;
+              //console.log('bare import type', type)
+              if (type === 'esm') {
+                addImportAlias(location, webLocation);
+                //console.log('add alias for', location)
+              } else {
+                const entryFile = makeCjsEntryFile(sourceFile, webLocation);
+                addImportAlias(location, entryFile);
+                //console.log('add alias for', location)
+              }
+            }
+          } catch (e) {
+            //(() => {})()
+            //console.log('state.filename', state.filename)
+            //console.log(e.stack)
+            cliError('there was an error in BabelTransformPackageImports\' visitor\n', e.stack);
+            //throw e
+          }
+        }
+        // !!!!!! TODO ExportDeclaration
+        // ExportNamedDeclaration: function (path: NodePath<ExportNamedDeclaration>) {
+        //     processExport(path)
+        // },
+        // ExportAllDeclaration : function (path: NodePath<ExportAllDeclaration>) {
+        //     processExport(path)
+        // }
+      },
+      post() {
+        //promises.push(destinationFilename)
+        //console.log(promises)
+        //setTimeout(() => console.log('post'), 0)
+        //debug(chalk.orange('TransformPackageImports Post'))
+        //Promise.all(processPackagePromises).then( results => {
+        //debug(chalk.orange('Writing info to', packagesCacheInfoLocation))
+        //fsPromises.writeFile(packagesCacheInfoLocation, JSON.stringify(packagesCacheInfo))
+        //})
+        //console.log(state.opts.filename, 'done')
+      }
+    };
+  };
+}