resolveId: async()

in packages/ice/src/service/ServerRunner.ts [176:250]
66 lines of code
23 McCabe index (conditional complexity)

      resolveId: async (id, importer) => {
        // Call esbuild lifecycle `onResolve` of esbuild plugin.
        let resolvedId = id;
        let resolveNamespace = '';
        firstResolve = false;

        // Resolve aliased id.
        if (!path.isAbsolute(resolvedId)) {
          if (resolvedId.startsWith('.')) {
            resolvedId = path.resolve(path.dirname(importer), resolvedId);
          } else {
            const id = resolveWithAlias(resolvedId, task.config.alias || {});
            if (id) {
              resolvedId = id.startsWith('.') ? path.resolve(rootDir, id) : id;
            } else {
              resolveNamespace = 'empty-content';
            }
          }
        }

        for (const plugin of esbuildPlugins) {
          let res: OnResolveResult;
          const lifecycles = getPluginLifecycle(plugin, 'onResolve');
          for (const [options, callback] of lifecycles) {
            if (options && callback) {
              const { filter, namespace } = options;
              if (namespace ? namespace == resolveNamespace : filter && filter.test(resolvedId)) {
                try {
                  res = await callback({
                    path: resolvedId,
                    importer,
                    namespace: resolveNamespace,
                    resolveDir: path.dirname(importer),
                    // Add kind of entry-point or import-statement to distinguish the type of resolve.
                    kind: firstResolve ? 'entry-point' : 'import-statement',
                    pluginData: {},
                  });

                  if (res) {
                    const { path: resolvedPath, namespace: resolvedNamespace, external } = res;
                    resolvedId = resolvedPath || resolvedId;
                    resolveNamespace = resolvedNamespace || '';
                    if (external) {
                      externals.push(resolvedId);
                    }
                    break;
                  }
                } catch (err) {
                  logger.error(`Failed to resolve module ${id} from ${importer}, Esbuild name ${plugin.name}: ${err}`);
                  throw err;
                }
              }
            }
          }
          if (res) break;
        }

        // Glob specified file module aliased with absolute path.
        if (!path.extname(resolvedId) && path.isAbsolute(resolvedId)) {
          const basename = path.basename(resolvedId);
          const patterns = [`${basename}.{js,ts,jsx,tsx,mjs}`, `${basename}/index.{js,ts,jsx,tsx,mjs}`];
          const absoluteId = fg.sync(patterns, {
            cwd: path.dirname(resolvedId),
            absolute: true,
          })[0];

          if (absoluteId) {
            resolvedId = absoluteId;
          }
        }
        return {
          id: resolvedId,
          namespace: resolveNamespace,
        };
      },