compile an es module

The makeESModule function creates an ES module from a given code string by first checking for a cached module, then setting up a context object, creating a new ES module instance, caching and exporting the module, linking and exporting dependencies, and optionally logging the process.

Run example

What the code could have been:

const path = require('path');
const vm = require('vm');
const { resolveModuleSpecifier, Core } = require('../Core');

class ESModuleCompiler {
  constructor() {
    this.console = Core.CONSOLE;
  }

  async makeESModule(code, filename, context = {}) {
    const filepath = path.resolve(process.cwd(), filename);

    // Check if module is already cached
    if (Module._cache[filepath]) {
      return Module._cache[filepath].namespace.default || Module._cache[filepath].namespace;
    }

    // Prepare context for execution
    context = {...context, importer: Core, __dirname: path.dirname(filename), __filename: filename.split('[')[0], global: context, console: this.console };

    // Create VM context and module
    const vmModule = new vm.SourceTextModule(code, {
      identifier: filename,
      context: await vm.createContext(context),
      initializeImportMeta(meta) {
        meta.url = filename;
      },
      async importModuleDynamically(specifier) {
        return await import(resolveModuleSpecifier(specifier, path.dirname(filename)));
      }
    });

    // Cache module and prepare it for execution
    Module._cache[filepath] = vmModule;
    Module._cache[filepath].exports = {};

    // Log compilation info
    if (!filename.includes('Core')) {
      this.console.info(`Compiling ES ${filename} with ${Object.keys(context)}`);
    }

    // Define linker function for importing modules
    const linker = async (specifier) => {
      // Resolve and import module
      const resolvedSpecifier = specifier;
      const targetModule = await import(resolveModuleSpecifier(specifier, path.dirname(filename)));
      context['__INTERNAL_IMPORTS_FROM_STRING'][specifier] = targetModule;

      // Create stringified specifier and exported names
      const stringifiedSpecifier = JSON.stringify(specifier);
      const exportedNames = Object.keys(targetModule);
      const targetModuleContent = `${exportedNames.includes('default')
       ? `export default __INTERNAL_IMPORTS_FROM_STRING[${stringifiedSpecifier}].default;\n`
        : ''
      }export const { ${exportedNames
         .filter(exportedName => exportedName!== 'default')
         .join(', ')} } = __INTERNAL_IMPORTS_FROM_STRING[${stringifiedSpecifier}];`;

      // Create new VM module for imported module
      return new vm.SourceTextModule(targetModuleContent, {
        identifier: resolvedSpecifier,
        context
      });
    };

    // Link and evaluate module
    await vmModule.link(linker);
    await vmModule.evaluate();

    // Assign exports and mark module as loaded
    Object.assign(Module._cache[filepath].exports, vmModule.namespace.default);
    Module._cache[filepath].loaded = true;

    // Return module
    return vmModule.namespace.default || vmModule.namespace;
  }
}

module.exports = new ESModuleCompiler();

The makeESModule function is an asynchronous function that creates an ES module from a given code string. Here's a step-by-step breakdown of what it does:

1. Caching

The function first checks if a module with the given filepath already exists in the Module._cache cache. If it does, it returns the cached module.

2. Context Setup

If the module doesn't exist in the cache, the function sets up a context object with the following properties:

3. ES Module Creation

The function creates a new vm.SourceTextModule instance from the given code string. It passes the following options to the constructor:

4. Cache and Export Setup

The function adds the created module to the Module._cache cache and sets its exports property to an empty object.

5. Linking and Exporting

The function defines a linker function that takes a specifier as an argument. It resolves the specifier, imports the module, and adds it to the cache. It then stringifies the specifier and exports its names using the export const {... } syntax.

6. Logging

If the filename doesn't include the string "Core", the function logs a message indicating that it's compiling the ES module with the given context.