@danielx/civet 0.2.14 → 0.3.0

package/dist/types.d.ts

@@ -1,18 +1,37 @@
 declare module "@danielx/civet" {
-  export type CivetAST = unknown;
+  export type CivetAST = unknown
   export type CompileOptions = {
     filename?: string
     js?: boolean
+    sourceMap?: boolean
   }
 
-  export function compile(source: string, options?: CompileOptions): string
+  export type SourceMapping = [number] | [number, number, number, number]
+
+  export interface SourceMap {
+    updateSourceMap?(outputStr: string, inputPos: number): void
+    json(srcFileName: string, outFileName: string): unknown
+    data: {
+      lines: SourceMapping[][]
+    }
+  }
+
+  export function compile<T extends CompileOptions>(source: string, options?: T): T extends { sourceMap: true } ? {
+    code: string,
+    sourceMap: SourceMap,
+  } : string
   export function parse(source: string): CivetAST
   export function generate(ast: CivetAST, options?: CompileOptions): string
 
   const Civet: {
-    compile: typeof compile;
-    parse: typeof parse;
-    generate: typeof generate;
+    compile: typeof compile
+    parse: typeof parse
+    generate: typeof generate
+    util: {
+      locationTable(input: string): number[]
+      lookupLineColumn(table: number[], pos: number): [number, number]
+      SourceMap(input: string): SourceMap
+    }
   }
 
   export default Civet;

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@danielx/civet",
-  "version": "0.2.14",
+  "version": "0.3.0",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
+  "exports": {
+    ".": "./dist/main.js",
+    "./esm": "./register.mjs"
+  },
   "types": "dist/types.d.ts",
   "bin": {
     "civet": "dist/civet"
@@ -13,6 +17,9 @@
     "register.js",
     "register.mjs"
   ],
+  "engines": {
+    "node": "^18.6.0 || ^16.17.0"
+  },
   "scripts": {
     "prepublishOnly": "yarn build && yarn test",
     "build": "bash ./build/build.sh",

package/register.mjs

@@ -1,40 +1,68 @@
+import { readFile } from 'fs/promises';
 import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
+import { pathToFileURL, fileURLToPath } from 'url';
 
 import { compile } from "./dist/main.js";
 
 const baseURL = pathToFileURL(process.cwd() + '/').href;
-
 const extensionsRegex = /\.civet$/;
 
-export async function resolve(specifier, context, defaultResolve) {
+const cache = new Map
+
+export async function resolve(specifier, context, next) {
   const { parentURL = baseURL } = context;
 
   if (extensionsRegex.test(specifier)) {
     return {
+      shortCircuit: true,
       format: "civet",
       url: new URL(specifier, parentURL).href,
     };
   }
 
   // Let Node.js handle all other specifiers.
-  return defaultResolve(specifier, context, defaultResolve);
+  return next(specifier, context);
 }
 
-export async function load(url, context, defaultLoad) {
-  if (extensionsRegex.test(url)) {
-    const { source: rawSource } = await defaultLoad(url, { format: "civet" });
+export async function load(url, context, next) {
+  if (context.format === "civet") {
+    const path = fileURLToPath(url)
+    const source = await readFile(path, "utf8")
+    const tsSource = compile(source)
 
-    return {
+    // NOTE: Assuming ts-node hook follows load hook
+    // NOTE: This causes .civet files to show up as .ts in ts-node error reporting (TODO: May be able to add a sourcemapping)
+    const result = await next(url.replace(extensionsRegex, ".ts"), {
+      // ts-node won't transpile unless this is module
+      // can't use commonjs since we don't rewrite imports
       format: "module",
-      source: compile(rawSource.toString(), { js: true }),
-    };
+      // NOTE: Setting the source in the context makes it available when ts-node uses defaultLoad
+      source: tsSource
+    });
+
+    // NOTE: If I don't set the format to 'commonjs' then I get
+    // "ReferenceError: exports is not defined in ES module scope"
+    // setting the format to commonjs causes the require.extensions
+    // handler to be invoked. So we cache the ts-node transpilation
+    // result, hook into require.extensions, and return the result there.
+    // Hopefully node loaders simplify this in the future.
+    result.format = "commonjs"
+    cache.set(path, result.source)
+
+    return result
   }
 
   // Let Node.js handle all other URLs.
-  return defaultLoad(url, context, defaultLoad);
+  return next(url, context);
 }
 
-// Also transform CommonJS files.
+// Cache our double transpiled sources (.civet -> .ts -> .js)
 const require = createRequire(import.meta.url);
-require("./register.js")
+require.extensions[".civet"] = function (m, filename) {
+  const code = cache.get(filename)
+  if (!code) throw new Error(`Code for ${filename} wasn't in transpiled cache.`)
+
+  m._compile(code, filename)
+  // Module should be cached after the first load so we can release the memory
+  cache.delete(filename)
+}