Function loadModuleSync

packages/remote-module/src/apis/loadModuleSync.ts:31–97

(
  urlOrAlias: string,
  options?: ModuleConfig,
)

};

export function loadModuleSync(
  urlOrAlias: string,
  options?: ModuleConfig,
): Record<string, any> | null {
  const data = hooks.lifecycle.beforeLoadModule.emit({
    options,
    url: urlOrAlias,
  });
  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}"`,
  );

  let result: Record<string, any> | null = null;
  const info = purifyOptions(url, options);
  const { cache, version, externals, error, adapter } = info;
  const urlWithVersion = `${version || 'latest'}@${url}`;
  const module = cacheModules[urlWithVersion];
  const alias = segments ? segments[0] : '';

  if (cache && module) {
    isPromise(module) && throwWarn(alias, url);
    result = getValueInObject(module, segments);
  } else {
    const manager = getModuleManager(url);
    assert(
      manager,
      `Synchronously load module must load resources in advance. "${url}"`,
    );

    try {
      const actuator = new Actuator(manager, externals);
      cacheModules[urlWithVersion] = actuator.env.exports;
      let exports = actuator.execScript().exports;

      if (typeof adapter === 'function') {
        exports = adapter(exports);
      }
      exports = hooks.lifecycle.afterLoadModule.emit({
        url,
        exports,
        code: manager.moduleCode,
      }).exports;

      isPromise(exports) && throwWarn(alias, url);
      cacheModules[urlWithVersion] = exports;
      result = getValueInObject(exports, segments);
    } catch (e) {
      delete cacheModules[urlWithVersion];