This function defines a few properties on globalThis to be used in the example.

Notably, it injects TYPESCRIPT_LIB. On the Rust side, this is the embedded declaration files. On the JavaScript side, this is used to create the virtual file system.

pub fn inject_lib_dts(rt: &mut JsRuntime) -> Result<()> {
    #[js(global_this)]
    struct Global;

    #[js(interface)]
    impl Global {
        #[js(set_index)]
        fn define_object(&self, name: serde<&str>, value: v8::Global<v8::Object>) {}

        #[js(set_index)]
        fn define_string(&self, name: serde<&str>, value: serde<&str>) {}
    }

    let global = Global::new(rt);

    let dts = {
        let scope = &mut rt.handle_scope();
        dts::dts(scope)?
    };

    global.define_object("TYPESCRIPT_LIB", dts, rt)?;
    global.define_string("CARGO_MANIFEST_DIR", env!("CARGO_MANIFEST_DIR"), rt)?;

    Ok(())
}

lib.dts.rs is the generated file that embeds declaration files. See build.rs.

mod dts {
    include!(concat!(env!("OUT_DIR"), "/lib.dts.rs"));
}

use std::collections::HashMap;

use anyhow::Result;

use example_runtime::deno_core::{self, JsRuntime};

import ts from "npm:typescript";
import {
  createDefaultMapFromNodeModules,
  createSystem,
  createVirtualCompilerHost,
} from "npm:@typescript/vfs";

export function createProgram(root: Record<string, string>) {
  const options: ts.CompilerOptions = {
    strict: true,
    noEmit: true,
    lib: [ts.getDefaultLibFileName({ target: ts.ScriptTarget.ESNext })],
    target: ts.ScriptTarget.ESNext,
    module: ts.ModuleKind.ESNext,
    moduleResolution: ts.ModuleResolutionKind.Bundler,
    moduleDetection: ts.ModuleDetectionKind.Force,
  };

  let files: Map<string, string>;

  if (globalThis.TYPESCRIPT_LIB) {
    files = new Map();
    for (const [lib, dts] of Object.entries(globalThis.TYPESCRIPT_LIB)) {
      files.set(`/${lib}`, dts);
    }
  } else {
    files = createDefaultMapFromNodeModules(options, ts);
  }

  for (const [name, src] of Object.entries(root)) {
    files.set(name, src);
  }

  const { compilerHost } = createVirtualCompilerHost(createSystem(files), options, ts);

  const program = ts.createProgram(Object.keys(root), options, compilerHost);

  return {
    printDiagnostics: (colored = true) => {
      const diagnostics = [
        ...program.getGlobalDiagnostics(),
        ...program.getSyntacticDiagnostics(),
        ...program.getDeclarationDiagnostics(),
        ...program.getSemanticDiagnostics(),
      ];
      if (colored) {
        return ts.formatDiagnosticsWithColorAndContext(diagnostics, compilerHost);
      } else {
        return ts.formatDiagnostics(diagnostics, compilerHost);
      }
    },
  };
}

declare global {
  namespace globalThis {
    var TYPESCRIPT_LIB: Record<string, string> | undefined;
    var CARGO_MANIFEST_DIR: string | undefined;
  }
}

use std::{collections::HashMap, path::Path};

use anyhow::Result;

use example_runtime::deno;
use example_ts::Compiler;
use tap::Pipe;

import { build, relpath } from "../_runtime/src/lib.ts";

await build({
  entryPoints: [relpath("src/lib.ts", import.meta)],
  outdir: "dist",
  // since we are bundling for ESM, this is required for esbuild to consider
  // `typescript`, which is in CJS, to be importable
  mainFields: ["module", "main"],
  // these modules are made available at runtime
  external: ["npm:typescript", "npm:@typescript/vfs"],
  bundle: true,
});

await build({
  entryPoints: [
    relpath("src/deps/typescript.ts", import.meta),
    relpath("src/deps/typescript-vfs.ts", import.meta),
  ],
  outdir: "dist",
  external: ["fs", "path", "os", "inspector"],
  mainFields: ["module", "main"],
  bundle: true,
  minify: false,
  treeShaking: true,
});

use std::{
    path::Path,
    process::{Command, Stdio},
};

use anyhow::{bail, Context, Result};
use proc_macro2::TokenStream;
use quote::quote;

fn main() -> Result<()> {
    println!("cargo::rerun-if-changed=build.ts");

    let built = Command::new("deno")
        .args(["run", "--allow-all", "build.ts"])
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit())
        .spawn()
        .context("failed to bundle JavaScript resources, is Deno installed?")?
        .wait()?
        .success();

    if !built {
        bail!("failed to bundle JavaScript resources")
    }

    let lib_dts = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../node_modules/typescript/lib")
        .read_dir()?
        .filter_map(|entry| -> Option<TokenStream> {
            let path = entry.ok()?.path();
            let name = path.file_name()?.to_str()?;
            if !name.ends_with(".d.ts") {
                return None;
            }
            let text = std::fs::read_to_string(&path).ok()?;
            let path = path.to_string_lossy();
            println!("cargo::rerun-if-changed={path}");
            if text.is_ascii() {
                Some(quote! {
                    #[allow(long_running_const_eval)]
                    (ascii_str!(#name), FastString::from(ascii_str_include!(#path)))
                })
            } else {
                Some(quote! {
                    (ascii_str!(#name), FastString::from_static(include_str!(#path)))
                })
            }
        });

    let lib_dts = quote! {
        use ::example_runtime::deno_core::{
            anyhow::Result, v8,
            FastString, ascii_str, ascii_str_include,
        };

        pub fn dts(scope: &mut v8::HandleScope) -> Result<v8::Global<v8::Object>> {
            let obj = v8::Object::new(scope);
            let files = [ #(#lib_dts),* ];
            for (lib, dts) in files {
                let lib = lib.v8_string(scope)?;
                let dts = dts.v8_string(scope)?;
                obj.set(scope, lib.into(), dts.into()).unwrap();
            }
            Ok(v8::Global::new(scope, obj))
        }
    };

    std::fs::write(
        Path::new(&std::env::var("OUT_DIR")?).join("lib.dts.rs"),
        lib_dts.to_string(),
    )?;

    Ok(())
}

export { default } from "typescript";

export * from "@typescript/vfs";