feat: Allow JavaScript extensions for TypeScript imports (#2)

* feat(loader): map js -> ts when source is ts

* feat(require): map js -> ts when source is ts

* fix(require): work after minify

src/loader.ts

@@ -2,7 +2,7 @@ import * as url from 'url';
 import { existsSync } from 'fs';
 import * as tsm from './utils.js';
 
-import type { Config, Options } from 'tsm/config';
+import type { Config, Extension, Options } from 'tsm/config';
 type TSM = typeof import('./utils.d');
 
 let config: Config;
@@ -43,26 +43,59 @@ async function load(): Promise<Config> {
 }
 
 const EXTN = /\.\w+(?=\?|$)/;
+const isTS = /\.[mc]?tsx?(?=\?|$)/;
+const isJS = /\.([mc])?js$/;
 async function toOptions(uri: string): Promise<Options|void> {
 	config = config || await load();
 	let [extn] = EXTN.exec(uri) || [];
 	return config[extn as `.${string}`];
 }
 
+function check(fileurl: string): string | void {
+	let tmp = url.fileURLToPath(fileurl);
+	if (existsSync(tmp)) return fileurl;
+}
+
 const root = url.pathToFileURL(process.cwd() + '/');
 export const resolve: Resolve = async function (ident, context, fallback) {
 	// ignore "prefix:" and non-relative identifiers
 	if (/^\w+\:?/.test(ident)) return fallback(ident, context, fallback);
 
+	let match: RegExpExecArray | null;
+	let idx: number, ext: Extension, path: string | void;
 	let output = new url.URL(ident, context.parentURL || root);
-	if (EXTN.test(output.pathname)) return { url: output.href };
+
+	// source ident includes extension
+	if (match = EXTN.exec(output.href)) {
+		ext = match[0] as Extension;
+		if (!context.parentURL || isTS.test(ext)) {
+			return { url: output.href };
+		}
+		// source ident exists
+		path = check(output.href);
+		if (path) return { url: path };
+		// parent importer is a ts file
+		// source ident is js & NOT exists
+		if (isJS.test(ext) && isTS.test(context.parentURL)) {
+			// reconstruct ".js" -> ".ts" source file
+			path = output.href.substring(0, idx = match.index);
+			if (path = check(path + ext.replace('js', 'ts'))) {
+				idx += ext.length;
+				if (idx > output.href.length) {
+					path += output.href.substring(idx);
+				}
+				return { url: path };
+			}
+			// return original, let it error
+			return fallback(ident, context, fallback);
+		}
+	}
 
 	config = config || await load();
 
-	let tmp, ext, path;
 	for (ext in config) {
-		path = url.fileURLToPath(tmp = output.href + ext);
-		if (existsSync(path)) return { url: tmp };
+		path = check(output.href + ext);
+		if (path) return { url: path };
 	}
 
 	return fallback(ident, context, fallback);

src/require.ts

@@ -15,6 +15,40 @@ let env = (tsm as TSM).$defaults('cjs');
 let uconf = env.file && require(env.file);
 let config: Config = (tsm as TSM).$finalize(env, uconf);
 
+declare const $$req: NodeJS.Require;
+const tsrequire = 'var $$req=require;require=(' + function () {
+	let { existsSync } = $$req('fs');
+	let { URL, pathToFileURL } = $$req('url');
+
+	return new Proxy($$req, {
+		// NOTE: only here if source is TS
+		apply(req, ctx, args: [id: string]) {
+			let [ident] = args;
+			if (!ident) return req.apply(ctx || $$req, args);
+
+			// ignore "prefix:" and non-relative identifiers
+			if (/^\w+\:?/.test(ident)) return $$req(ident);
+
+			// exit early if no extension provided
+			let match = /\.([mc])?js(?=\?|$)/.exec(ident);
+			if (match == null) return $$req(ident);
+
+			let base = pathToFileURL(__filename) as import('url').URL;
+			let file = new URL(ident, base).pathname as string;
+			if (existsSync(file)) return $$req(ident);
+
+			// ?js -> ?ts file
+			file = file.replace(
+				new RegExp(match[0] + '$'),
+				match[0].replace('js', 'ts')
+			);
+
+			// return the new "[mc]ts" file, or let error
+			return existsSync(file) ? $$req(file) : $$req(ident);
+		}
+	})
+} + ')();'
+
 function loader(Module: Module, sourcefile: string) {
 	let extn = extname(sourcefile);
 	let pitch = Module._compile!.bind(Module);
@@ -23,8 +57,13 @@ function loader(Module: Module, sourcefile: string) {
 		let options = config[extn];
 		if (options == null) return pitch(source, sourcefile);
 
+		let banner = options.banner || '';
+		if (/\.[mc]?tsx?$/.test(extn)) {
+			banner = tsrequire + banner;
+		}
+
 		esbuild = esbuild || require('esbuild');
-		let result = esbuild.transformSync(source, { ...options, sourcefile });
+		let result = esbuild.transformSync(source, { ...options, banner, sourcefile });
 		return pitch(result.code, sourcefile);
 	};
 

src/utils.ts

@@ -5,7 +5,6 @@ import type { Format } from 'esbuild';
 import type * as tsm from 'tsm/config';
 import type { Defaults } from './utils.d';
 
-
 exports.$defaults = function (format: Format): Defaults {
 	let { FORCE_COLOR, NO_COLOR, NODE_DISABLE_COLORS, TERM } = process.env;
 

test/config/index.ts

@@ -1,10 +1,20 @@
 import * as assert from 'assert';
 
+// NOTE: doesn't actually exist yet
+import * as js from '../fixtures/math.js';
+
 // NOTE: avoid need for syntheticDefault + analysis
 import * as data from '../fixtures/data.json';
 assert.equal(typeof data, 'object');
 
 // @ts-ignore - generally doesn't exist
 assert.equal(typeof data.default, 'string');
 
+// NOTE: raw JS missing
+assert.equal(typeof js, 'object', 'JS :: typeof');
+assert.equal(typeof js.sum, 'function', 'JS :: typeof :: sum');
+assert.equal(typeof js.div, 'function', 'JS :: typeof :: div');
+assert.equal(typeof js.mul, 'function', 'JS :: typeof :: mul');
+assert.equal(js.foobar, 3, 'JS :: value :: foobar');
+
 console.log('DONE~!');