Patching ESM imports with oxc

/// Rewrite bare module specifiers (`"lodash"`) to `<prefix>lodash`, leaving
/// relative (`./x`), absolute (`/x`), and already-URL imports untouched.
pub fn rewrite_imports<'a>(allocator: &'a Allocator, program: &mut Program<'a>, prefix: &str) {
    for stmt in program.body.iter_mut() {
        let source = match stmt {
            Statement::ImportDeclaration(d) => Some(&mut d.source),
            Statement::ExportNamedDeclaration(d) => d.source.as_mut(),
            Statement::ExportAllDeclaration(d) => Some(&mut d.source),
            _ => None,
        };
        if let Some(lit) = source {
            if is_bare(lit.value.as_str()) {
                // Allocate the new string in the arena and clear `raw` so codegen
                // re-quotes from `value` rather than reprinting the original text.
                let rewritten = format!("{prefix}{}", lit.value.as_str());
                lit.value = rewritten.into_in(allocator);
                lit.raw = None;
            }
        }
    }
}

/// A bare specifier is a package name: not relative, absolute, or a URL.
pub fn is_bare(spec: &str) -> bool {
    !(spec.starts_with('.')
        || spec.starts_with('/')
        || spec.contains("://")
        || spec.starts_with("node:"))
}

/** Mirror the Rust `is_bare`: a package name, not relative/absolute/URL/node:. */
function isBare(spec: string): boolean {
  return !(
    spec.startsWith('.') ||
    spec.startsWith('/') ||
    spec.includes('://') ||
    spec.startsWith('node:')
  );
}

// Walk the top-level module edges and rewrite each bare specifier in place.
function rewriteImports(program: Program, prefix: string): void {
  for (const node of program.body) {
    const isModuleEdge =
      node.type === 'ImportDeclaration' ||
      node.type === 'ExportNamedDeclaration' ||
      node.type === 'ExportAllDeclaration';
    if (!isModuleEdge || !node.source) continue;
    const value = node.source.value;
    if (typeof value === 'string' && isBare(value)) {
      node.source.value = prefix + value;
      delete node.source.raw; // force astring to re-quote from `value`
    }
  }
}

// Stripping types is just walking the AST and dropping the type-only nodes and
// fields. Removable statements (interfaces, type aliases, `import type`) are
// filtered out of their arrays; type annotations and type parameters are deleted
// off the nodes that carry them; and TS-only expression wrappers (`x as T`,
// `x!`) are replaced by the expression inside. What's left is plain ESTree that
// astring can print. (This covers the *erasable* subset — enums, namespaces, and
// parameter properties need real emit, which is where a full transformer earns
// its keep.)
const TYPE_ONLY_NODE = new Set([
  'TSInterfaceDeclaration', 'TSTypeAliasDeclaration', 'TSModuleDeclaration',
  'TSDeclareFunction', 'TSImportEqualsDeclaration',
]);
const UNWRAP = new Set([
  'TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression',
  'TSTypeAssertion', 'TSInstantiationExpression',
]);
const TYPE_FIELDS = [
  'typeAnnotation', 'returnType', 'typeParameters', 'typeArguments',
  'accessibility', 'definite', 'readonly', 'declare', 'optional', 'override',
];

function isTypeOnly(n: { type?: string; importKind?: string; exportKind?: string; declaration?: unknown }): boolean {
  if (!n || !n.type) return false;
  if (TYPE_ONLY_NODE.has(n.type)) return true;
  if (n.type === 'ImportDeclaration' && n.importKind === 'type') return true;
  if (n.type === 'ExportNamedDeclaration' && n.exportKind === 'type' && !n.declaration) return true;
  if ((n.type === 'ImportSpecifier' || n.type === 'ExportSpecifier') && n.importKind === 'type') return true;
  return false;
}

function stripTypes<T>(node: T): T {
  if (!node || typeof node !== 'object') return node;
  const n = node as Record<string, unknown>;
  if (typeof n.type === 'string' && UNWRAP.has(n.type)) return stripTypes(n.expression) as T;
  for (const f of TYPE_FIELDS) delete n[f];
  for (const key of Object.keys(n)) {
    const v = n[key];
    if (Array.isArray(v)) {
      n[key] = v.filter((c) => !isTypeOnly(c)).map((c) => stripTypes(c));
    } else if (v && typeof v === 'object' && typeof (v as { type?: unknown }).type === 'string') {
      n[key] = stripTypes(v);
    }
  }
  return node;
}

// Setting source_map_path turns codegen's mapping on and names the source.
// The returned value then carries both the generated code and a SourceMap you
// serialize to the v3 JSON the browser reads.
let codegen = Codegen::new().with_options(CodegenOptions {
    source_map_path: Some(path.to_path_buf()),
    ..CodegenOptions::default()
});
let out = codegen.build(&program);
let map = out.map.map(|m| m.to_json_string()).unwrap_or_default();

// astring writes a source map by calling `sourceMap.addMapping({ original,
// generated, source, name })` and reading `sourceMap.file`. @jridgewell/gen-mapping
// uses standalone functions instead of methods, so this thin shim adapts its
// GenMapping to the shape astring expects. (oxc needs no equivalent — it emits the
// map natively from Rust codegen.)
interface AstringMapping {
  original: { line: number; column: number } | null;
  generated: { line: number; column: number };
  source: string;
  name?: string;
}

class AstringGenMapping {
  readonly file: string;
  private readonly map: GenMapping;
  constructor(file: string) {
    this.file = file;
    this.map = new GenMapping({ file });
  }
  addMapping(m: AstringMapping): void {
    const { original, generated, source, name } = m;
    if (!original) return; // astring only maps nodes that carry a location
    if (name) {
      addMapping(this.map, { generated, original, source, name });
    } else {
      addMapping(this.map, { generated, original, source });
    }
  }
  toString(): string {
    return JSON.stringify(toEncodedMap(this.map));
  }
}

// astring takes each mapping's generated position from its own writer and the
// original position from node.loc.start, so parsing with `locations: true` is
// what makes the map possible. The source name comes from the generator's `file`.
export function transformMap(source: string, prefix = '', ts = false): MapResult {
  try {
    const ast = parseSource(source, ts, true) as unknown as Program;
    if (ts) stripTypes(ast);
    if (prefix) rewriteImports(ast, prefix);
    const map = new AstringGenMapping('input.js');
    const code = generate(ast as never, { sourceMap: map as never });
    return { ok: true, code, map: map.toString() };
  } catch (e) {
    return { ok: false, code: (e as Error).message, map: '' };
  }
}

// @jridgewell/sourcemap-codec does the actual work: `decode` VLQ-decodes the
// mappings string AND un-deltas it, returning, per generated line, segments of
// [genColumn, sourceIndex, srcLine, srcColumn, nameIndex] as absolute values.
// All that's left is to flatten the ones that carry an original position.
export function decodeMappings(mappingsField: string): Mapping[] {
  const out: Mapping[] = [];
  decode(mappingsField).forEach((line, genLine) => {
    for (const seg of line) {
      if (seg.length >= 4) {
        out.push({ genLine, genCol: seg[0], srcLine: seg[2]!, srcCol: seg[3]! });
      }
    }
  });
  return out;
}