export async function redirectImport()

in packages/shared-config/src/unPlugins/redirectImport.ts [90:166]
70 lines of code
15 McCabe index (conditional complexity)

export async function redirectImport(code: string, options: Options): Promise<string> {
  const { exportData, targetSource } = options;
  const redirectData = parseRedirectData(exportData);
  await init;
  let imports: readonly ImportSpecifier[] = [];
  try {
    imports = parse(code)[0];
  } catch (error) {
    consola.error('Parse error when redirect import.');
    consola.error(error);
  }
  if (!imports.length) {
    return code;
  }

  let s: MagicString | undefined;
  const str = () => s || (s = new MagicString(code));
  imports.forEach((targetImport) => {
    if (targetImport.n === targetSource) {
      let importStr = code.substring(targetImport.ss, targetImport.se);
      const matched = importStr.match(ICE_REG_EXP);
      const missMatchedIdentifiers = [];
      if (matched) {
        let matchedImports: MatchedImports = {};
        const [, identifiers] = matched;
        identifiers.trim().split(',').forEach((str) => {
          let identifier = str.trim();
          let localIdentifier = '';
          const matchedLocalAlias = identifier.match(AS_ALIAS_REG_EXP);
          if (matchedLocalAlias) {
            [, identifier, localIdentifier] = matchedLocalAlias;
          }
          if (redirectData[identifier]) {
            const { isDefault, alias, source } = redirectData[identifier];
            if (!matchedImports[source]) {
              matchedImports[source] = [];
            }
            const redirectAlias = {};
            if (localIdentifier) {
              // add additional alias for as, such as:
              // import { runApp as run } from 'ice';
              redirectAlias[localIdentifier] = alias[identifier] || identifier;
              // replace identifier with aliased string
              identifier = localIdentifier;
            }
            matchedImports[source].push({
              isDefault,
              identifier,
              alias: {
                ...(alias || {}),
                ...redirectAlias,
              },
            });
          } else {
            missMatchedIdentifiers.push(identifier);
          }
        });

        if (Object.keys(matchedImports).length > 0) {
          const transformedImport = generateImport(matchedImports);
          // TODO: Add file name detail.
          consola.debug(`transform ${importStr} to ${transformedImport}`);

          if (missMatchedIdentifiers.length > 0) {
            const replacedImportStr = importStr.replace(ICE_REG_EXP, (str, matchStr) => {
              return str.replace(matchStr, ` ${missMatchedIdentifiers.join(',')} `);
            });
            str().overwrite(targetImport.ss, targetImport.se, `${replacedImportStr};\n${transformedImport}`);
          } else {
            str().overwrite(targetImport.ss, targetImport.se, transformedImport);
          }
        }
      }
    }
  });
  return s ? s.toString() : code;
}