Function loadModule

packages/remote-module/src/apis/loadModule.ts:15–108

(
  urlOrAlias: string,
  options?: ModuleConfig,
)

import { processAlias, getValueInObject } from './setModuleConfig';

export async function loadModule(
  urlOrAlias: string,
  options?: ModuleConfig,
): Promise<Record<string, any> | null> {
  const data = await hooks.lifecycle.asyncBeforeLoadModule.emit({
    options,
    url: urlOrAlias,
  });
  if (data === false) {
    return null;
  }

  urlOrAlias = data.url;
  options = data.options;

  assert(urlOrAlias, 'Missing url for loading remote module.');
  assert(
    typeof urlOrAlias === 'string',
    'The type of URL needs to be a string.',
  );
  const [url, segments] = processAlias(urlOrAlias);
  assert(
    isAbsolute(url) || url.startsWith('//'),
    `The loading of the remote module must be an absolute path. "${url}"`,
  );

  const info = purifyOptions(url, options);
  const { cache, version, externals, error, adapter } = info;
  const urlWithVersion = `${version || 'latest'}@${url}`; // `latest@https://xx.js`

  const asyncLoadProcess = async () => {
    let result: Record<string, any> | null = null;
    let module = cacheModules[urlWithVersion];

    if (cache && module) {
      if (isPromise(module)) {
        module = await module;
      }
      result = getValueInObject(module, segments);
    } else {
      try {
        const data = await loader.loadModule(url);
        if (data.resourceManager) {
          const actuator = new Actuator(data.resourceManager, externals);
          cacheModules[urlWithVersion] = actuator.env.exports;
          let exports = actuator.execScript().exports;

          if (typeof adapter === 'function') {
            exports = adapter(exports);
          }
          const hookResult = await hooks.lifecycle.asyncAfterLoadModule.emit({
            url,
            exports,
            code: data.resourceManager.moduleCode,
          });
          if (hookResult === false) {
            return null;
          }