feat: create amaro loader

README.md

@@ -21,10 +21,19 @@ Stack traces are preserved, by replacing removed types with white spaces.
 
 ```javascript
 const amaro = require('amaro');
-const { code } = amaro.transformSync("const foo: string = 'bar';");
+const { code } = amaro.transformSync("const foo: string = 'bar';", { mode: "strip-only" });
 console.log(code); // "const foo         = 'bar';"
 ```
 
+### Loader
+
+It is possible to use Amaro as an external loader to execute TypeScript files.
+This allows the installed Amaro to override the Amaro version used by Node.js.
+
+```bash
+node --experimental-strip-types --import="amaro/register" script.ts
+```
+
 ### How to update SWC
 
 To update the SWC version, run:

esbuild.config.js

@@ -0,0 +1,18 @@
+const { copy } = require("esbuild-plugin-copy");
+const esbuild = require("esbuild");
+
+esbuild.build({
+	entryPoints: ["src/index.ts"],
+	bundle: true,
+	platform: "node",
+	target: "node20",
+	outdir: "dist",
+	plugins: [
+		copy({
+			assets: {
+				from: ["./src/register/register.mjs"],
+				to: ["."],
+			},
+		}),
+	],
+});

package.json

@@ -21,18 +21,22 @@
 		"ci:fix": "biome check --write",
 		"prepack": "npm run build",
 		"postpack": "npm run clean",
-		"build": "rspack build",
+		"build": "node esbuild.config.js",
 		"typecheck": "tsc --noEmit",
 		"test": "node --test --experimental-test-snapshots \"**/*.test.js\"",
 		"test:regenerate": "node --test --experimental-test-snapshots --test-update-snapshots \"**/*.test.js\""
 	},
 	"devDependencies": {
 		"@biomejs/biome": "1.8.3",
-		"@rspack/cli": "^0.7.5",
-		"@rspack/core": "^0.7.5",
 		"@types/node": "^20.14.11",
+		"esbuild": "^0.23.0",
+		"esbuild-plugin-copy": "^2.1.1",
 		"rimraf": "^6.0.1",
 		"typescript": "^5.5.3"
 	},
+	"exports": {
+		".": "./dist/index.js",
+		"./register": "./dist/register.mjs"
+	},
 	"files": ["dist", "LICENSE.md"]
 }

src/index.ts

@@ -1,18 +1,2 @@
-import type { Options, TransformOutput } from "../lib/wasm";
-import swc from "../lib/wasm.js";
-
-const DEFAULT_OPTIONS: Options = {
-	mode: "strip-only",
-};
-
-export function transformSync(
-	source: string,
-	options: Options,
-): TransformOutput {
-	// Ensure that the source code is a string
-	const input = `${source ?? ""}`;
-	return swc.transformSync(input, {
-		...DEFAULT_OPTIONS,
-		...options,
-	});
-}
+export { transformSync } from "./transform.ts";
+export { load } from "./loader.ts";

src/loader.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import type { LoadFnOutput, LoadHookContext } from "node:module";
+import { transformSync } from "./index.ts";
+
+type NextLoad = (
+	url: string,
+	context?: LoadHookContext,
+) => LoadFnOutput | Promise<LoadFnOutput>;
+
+export async function load(
+	url: string,
+	context: LoadHookContext,
+	nextLoad: NextLoad,
+) {
+	const { format } = context;
+	if (format.endsWith("-typescript")) {
+		// Use format 'module' so it returns the source as-is, without stripping the types.
+		// Format 'commonjs' would not return the source for historical reasons.
+		const { source } = await nextLoad(url, {
+			...context,
+			format: "module",
+		});
+		if (source == null)
+			throw new Error("Source code cannot be null or undefined");
+		const { code } = transformSync(source.toString(), { mode: "strip-only" });
+		return {
+			format: format.replace("-typescript", ""),
+			source: code,
+		};
+	}
+	return nextLoad(url, context);
+}

src/register/register.mjs

@@ -0,0 +1,3 @@
+import { register } from "node:module";
+
+register("./index.js", import.meta.url);

src/transform.ts

@@ -0,0 +1,18 @@
+import type { Options, TransformOutput } from "../lib/wasm";
+import swc from "../lib/wasm.js";
+
+const DEFAULT_OPTIONS: Options = {
+	mode: "strip-only",
+};
+
+export function transformSync(
+	source: string,
+	options?: Options,
+): TransformOutput {
+	// Ensure that the source code is a string
+	const input = `${source ?? ""}`;
+	return swc.transformSync(input, {
+		...DEFAULT_OPTIONS,
+		...options,
+	});
+}

test/fixtures/enum.ts

@@ -0,0 +1,4 @@
+enum Foo {
+	A = "Hello, TypeScript!",
+}
+console.log(Foo.A);

test/fixtures/hello.ts

@@ -0,0 +1 @@
+console.log("Hello, TypeScript!");

test/loader.test.js

@@ -0,0 +1,29 @@
+const { spawnPromisified, fixturesPath } = require("./util/util.js");
+const { test } = require("node:test");
+const { match, strictEqual } = require("node:assert");
+
+test("should work as a loader", async () => {
+	const result = await spawnPromisified(process.execPath, [
+		"--experimental-strip-types",
+		"--no-warnings",
+		"--import=./dist/register.mjs",
+		fixturesPath("hello.ts"),
+	]);
+
+	strictEqual(result.stderr, "");
+	match(result.stdout, /Hello, TypeScript!/);
+	strictEqual(result.code, 0);
+});
+
+test("should work with enums", async () => {
+	const result = await spawnPromisified(process.execPath, [
+		"--experimental-strip-types",
+		"--no-warnings",
+		"--import=./dist/register.mjs",
+		fixturesPath("enum.ts"),
+	]);
+
+	strictEqual(result.stdout, "");
+	match(result.stderr, /TypeScript enum is not supported in strip-only mode/);
+	strictEqual(result.code, 1);
+});

test/util/util.js

@@ -0,0 +1,44 @@
+const { spawn } = require("node:child_process");
+const path = require("node:path");
+
+function spawnPromisified(...args) {
+	let stderr = "";
+	let stdout = "";
+
+	const child = spawn(...args);
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (data) => {
+		stderr += data;
+	});
+	child.stdout.setEncoding("utf8");
+	child.stdout.on("data", (data) => {
+		stdout += data;
+	});
+
+	return new Promise((resolve, reject) => {
+		child.on("close", (code, signal) => {
+			resolve({
+				code,
+				signal,
+				stderr,
+				stdout,
+			});
+		});
+		child.on("error", (code, signal) => {
+			reject({
+				code,
+				signal,
+				stderr,
+				stdout,
+			});
+		});
+	});
+}
+
+const fixturesDir = path.join(__dirname, "..", "fixtures");
+
+function fixturesPath(...args) {
+	return path.join(fixturesDir, ...args);
+}
+
+module.exports = { spawnPromisified, fixturesPath };