const filename = "/math.ts";

function logBranches(label, coverageMap) {
  console.log(label);
  console.log(JSON.stringify(coverageMap.data[filename].branchMap, null, 2));
  console.log(coverageMap.data[filename].b);
}

async function run() {
  const sourceCode = `
function add(a: number, b: number): number {
    type SomeType = typeof a | string;

    console.log('Running add');

    if(a === 20) {
        return b;
    }
}

add(1, 2);
`;

  const transpiled = require("esbuild").transformSync(sourceCode, {
    loader: "ts",
    sourcemap: true,
    sourcefile: filename,
  });
  transpiled.map = JSON.parse(transpiled.map);

  const instrumenter = require("istanbul-lib-instrument").createInstrumenter({
    produceSourceMap: true,
    autoWrap: false,
    compact: false,
    coverageVariable: "__coverage__",
    coverageGlobalScope: "globalThis",
  });

  const instrumented = instrumenter.instrumentSync(
    transpiled.code,
    filename,
    transpiled.map
  );

  // Run instrumented code to populate globalThis.__coverage__
  eval(instrumented);
  const __coverage__ = globalThis.__coverage__;

  const { createCoverageMap } = require("istanbul-lib-coverage");
  const coverageMap = createCoverageMap(__coverage__);

  const { createSourceMapStore } = require("istanbul-lib-source-maps");
  const sourceMapStore = createSourceMapStore();
  const transformedCoverage = await sourceMapStore.transformCoverage(
    coverageMap
  );

  logBranches("coveragemap before transforming back to sources", coverageMap);
  logBranches("coveragemap after transforming to sources", transformedCoverage);
}

run();