@travetto/compiler 3.0.0-rc.0 → 3.0.0-rc.11

package/README.md

@@ -1,7 +1,7 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
-<!-- Please modify https://github.com/travetto/travetto/tree/main/module/compiler/doc.ts and execute "npx trv doc" to rebuild -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/compiler/DOC.ts and execute "npx trv doc" to rebuild -->
 # Compiler
-## Node-integration of Typescript Compiler with advanced functionality for detecting changes in classes and methods.
+## Compiler
 
 **Install: @travetto/compiler**
 ```bash
@@ -17,9 +17,12 @@ This module expands upon [Typescript](https://typescriptlang.org), with suppleme
    *  Support for detecting changes in sources files at runtime
    *  Allows for hot-reloading of classes during development    
       *  Utilizes `es2015` `Proxy`s to allow for swapping out implementation at runtime
-
 Additionally, there is support for common AST transformations via [Transformation](https://github.com/travetto/travetto/tree/main/module/transformer#readme "Functionality for AST transformations, with transformer registration, and general utils")
-
 ## Debugging
-
 When dealing with transformers, logging is somewhat tricky as the compiler executes before the code is loaded.  To that end, the file `compiler.log` is created in the cache directory during the compilation process. This is a location that transformers should be free to log to, for debugging, and any additional feedback.
+
+## CLI
+
+The module provides the ability to clear the compilation cache to handle any inconsistencies that may arise.
+
+TODO: Describe cli behavior

package/__index__.ts

@@ -0,0 +1,3 @@
+export * from './src/compiler';
+export * from './src/state';
+export * from './src/util';

package/bin/transpile.d.ts

@@ -0,0 +1,32 @@
+import type { ManifestContext, Package } from '@travetto/manifest';
+
+declare namespace Transpile {
+  type CompileCommand = 'build' | 'watch' | 'clean' | 'manifest';
+
+  /**
+   * Writes a package json file
+   */
+  function writePackageJson(ctx: ManifestContext, inputFile: string, outputFile: string, transform?: (pkg: Package) => Package): Promise<void>;
+
+  /**
+   * Transpiles a file
+   */
+  function transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void>;
+
+  /**
+   * Write js file
+   */
+  function writeJsFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void>;
+
+  /**
+   * Build an entire package
+   */
+  function buildPackage(ctx: ManifestContext, name: string, sourcePath: string, mainSource: string, extraSource: string[]): Promise<string>;
+
+  /**
+   * Get Context for building
+   */
+  function getContext(folder?: string): Promise<ManifestContext>;
+}
+
+export = Transpile;

package/bin/transpile.js

@@ -0,0 +1,227 @@
+// @ts-check
+
+const _opts = {};
+
+/**
+ * @typedef {import('@travetto/manifest').Package} Pkg
+ * @typedef {import('@travetto/manifest').ManifestContext} ManifestContext
+ */
+
+function $imp(mod) {
+  try { return require(mod); } catch { return import(mod).then(x => x.default); }
+}
+
+/** @type {() => import('typescript')} */
+const $getTs = $imp.bind(null, 'typescript');
+/** @type {() => import('fs/promises')} */
+const $getFs = $imp.bind(null, 'fs/promises');
+/** @type {() => import('path')} */
+const $getPath = $imp.bind(null, 'path');
+/** @type {() => ({createRequire:(folder:string) => ({ resolve: (file:string)=>string})})} */
+const $getModule = $imp.bind(null, 'module');
+/** @param {string} x */
+const toPosix = x => x.replace(/\\/g, '/');
+
+/**
+ * Returns the package.json
+ * @param {string} inputFolder
+ * @returns {Promise<Pkg>}
+ */
+async function $getPkg(inputFolder) {
+  const fs = await $getFs();
+  const path = await $getPath();
+  if (!inputFolder.endsWith('.json')) {
+    inputFolder = path.resolve(inputFolder, 'package.json');
+  }
+  return JSON.parse(await fs.readFile(inputFolder, 'utf8'));
+}
+
+/**
+ * Get workspace root
+ * @return {Promise<string>}
+ */
+async function $getWorkspaceRoot() {
+  const path = await $getPath();
+  const fs = await $getFs();
+  let folder = process.cwd();
+  let prevFolder = '';
+  while (folder !== prevFolder) {
+    try {
+      const pkg = await $getPkg(folder);
+      if (!!pkg.workspaces || !!pkg.travetto?.isolated) {
+        return folder;
+      }
+    } catch { }
+    if (await fs.stat(path.resolve(folder, '.git')).catch(() => { })) {
+      break;
+    }
+    prevFolder = folder;
+    folder = path.dirname(folder);
+  }
+  return process.cwd();
+}
+
+/**
+ * Returns the compiler options
+ * @param {ManifestContext} ctx
+ * @returns
+ */
+async function $getOpts(ctx) {
+  if (!(ctx.workspacePath in _opts)) {
+    const path = await $getPath();
+    const fs = await $getFs();
+    const ts = await $getTs();
+    const mod = await $getModule();
+    const req = mod.createRequire(`${ctx.workspacePath}/node_modules`);
+
+    const framework = req.resolve('@travetto/compiler/tsconfig.trv.json');
+    const self = path.resolve(ctx.workspacePath, 'tsconfig.json');
+    const loc = (await fs.stat(self).catch(() => false)) ? self : framework;
+    const { options } = ts.parseJsonSourceFileConfigFileContent(
+      ts.readJsonConfigFile(loc, ts.sys.readFile), ts.sys, ctx.workspacePath
+    );
+    options.inlineSourceMap = true;
+    options.sourceMap = false;
+    try {
+      const { type } = await $getPkg(ctx.workspacePath);
+      if (type) {
+        options.module = type.toLowerCase() === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext;
+      }
+    } catch { }
+
+    _opts[ctx.workspacePath] = options;
+  }
+  return _opts[ctx.workspacePath];
+}
+
+/**
+ * Writes a package json file
+ * @param {ManifestContext} ctx
+ * @param {string} inputFile
+ * @param {string} outputFile
+ * @param {(pkg:Pkg) => Pkg} transform
+ */
+async function writePackageJson(ctx, inputFile, outputFile, transform) {
+  const opts = await $getOpts(ctx);
+  const ts = await $getTs();
+  const isEsm = opts.module !== ts.ModuleKind.CommonJS;
+  let pkg = await $getPkg(inputFile);
+  pkg = transform?.(pkg) ?? pkg;
+  pkg.main = pkg.main?.replace(/[.]ts$/, '.js');
+  pkg.type = isEsm ? 'module' : 'commonjs';
+  pkg.files = pkg.files?.map(x => x.replace('.ts', '.js'));
+
+  ts.sys.writeFile(outputFile, JSON.stringify(pkg, null, 2));
+}
+
+/**
+ * Transpiles a file
+ * @param {ManifestContext} ctx
+ * @param {string} inputFile
+ * @param {string} outputFile
+ */
+async function transpileFile(ctx, inputFile, outputFile) {
+  const ts = await $getTs();
+  const fs = await $getFs();
+
+  const opts = await $getOpts(ctx);
+  const content = ts.transpile(await fs.readFile(inputFile, 'utf8'), opts, inputFile)
+    .replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
+    .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
+
+  ts.sys.writeFile(outputFile, content);
+}
+
+/**
+ * Writes a js file
+ * @param {ManifestContext} ctx
+ * @param {string} inputFile
+ * @param {string} outputFile
+ */
+async function writeJsFile(ctx, inputFile, outputFile) {
+  const ts = await $getTs();
+  const fs = await $getFs();
+
+  const opts = await $getOpts(ctx);
+  const isEsm = opts.module !== ts.ModuleKind.CommonJS;
+
+  let content = await fs.readFile(inputFile, 'utf8');
+  if (isEsm) {
+    content = content
+      .replace(/^(?:async )?function [^$]/mg, a => `export ${a}`)
+      .replace(/^module.exports.*/mg, '');
+  }
+
+  await fs.writeFile(outputFile, content, 'utf8');
+}
+
+/**
+ * Write an entire package
+ * @param {ManifestContext} ctx
+ * @param {string} name
+ * @param {string} sourcePath
+ * @param {string} mainSource
+ * @param {string[]} extraSources
+ */
+async function buildPackage(ctx, name, sourcePath, mainSource, extraSources) {
+  const path = await $getPath();
+  const fs = await $getFs();
+
+  const files = [mainSource, ...extraSources].map(x => ({ src: x, out: x.replace(/[.]ts$/, '.js') }));
+  const main = files[0].out;
+  const outputPath = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', name);
+
+  for (const { src, out } of files) {
+    const inputFile = path.resolve(sourcePath, src);
+    const outputFile = path.resolve(outputPath, out);
+
+    const [outStat, inStat] = await Promise.all([
+      fs.stat(outputFile).catch(() => undefined),
+      fs.stat(inputFile)
+    ]);
+
+    if (!outStat || (outStat.mtimeMs < inStat.mtimeMs)) {
+      await fs.mkdir(path.dirname(outputFile), { recursive: true });
+
+      if (inputFile.endsWith('.ts')) {
+        await transpileFile(ctx, inputFile, outputFile);
+      } else if (inputFile.endsWith('.js')) {
+        await writeJsFile(ctx, inputFile, outputFile);
+      } else if (inputFile.endsWith('.json')) {
+        await writePackageJson(ctx, inputFile, outputFile,
+          (pkg) => ({ ...pkg, files: files.map(x => x.out), name, main }));
+      }
+    }
+  }
+
+  return path.resolve(outputPath, main);
+}
+
+/**
+ * Gets build context
+ * @return {Promise<ManifestContext>}
+ */
+async function getContext(folder = process.cwd()) {
+  const path = await $getPath();
+
+  const workspacePath = path.resolve(await $getWorkspaceRoot());
+  const mainPath = toPosix(folder);
+
+  const { name: mainModule, workspaces, travetto } = (await $getPkg(mainPath));
+  const monoRepo = workspacePath !== mainPath || !!workspaces;
+
+  // All relative to workspacePath
+  const manifestFile = `node_modules/${mainModule}/manifest.json`;
+
+  return {
+    mainModule,
+    mainPath,
+    workspacePath,
+    monoRepo,
+    manifestFile,
+    outputFolder: travetto?.outputFolder ?? '.trv_output',
+    compilerFolder: '.trv_compiler'
+  };
+}
+
+module.exports = { transpileFile, writePackageJson, writeJsFile, buildPackage, getContext };

package/bin/trv.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+// @ts-check
+
+/**
+ * @param {import('@travetto/manifest').ManifestContext} ctx
+ * @return {Promise<import('../support/bin/compiler-bootstrap')>}
+ */
+async function $getBootstrap(ctx) {
+  const path = require('path');
+  const { buildPackage } = require('./transpile');
+
+  const root = path.resolve(__dirname, '..');
+
+  const loc = await buildPackage(
+    ctx, '__compiler_bootstrap__', root, 'support/bin/compiler-bootstrap.ts',
+    ['support/bin/utils.ts', 'bin/transpile.js', 'package.json']
+  );
+
+  try { return require(loc); } catch { return import(loc); }
+}
+
+/**
+ * @param {import('@travetto/manifest').ManifestContext} ctx
+ * @param {boolean} [watch]
+ */
+const compile = (ctx, watch) => $getBootstrap(ctx).then(({ compile: go }) => go(ctx, watch));
+
+/** @param {string[]} args */
+async function exec(args) {
+  const { getContext } = require('./transpile');
+  const op = args.find(x => !x.startsWith('-'));
+  /** @type {{clean?: boolean, quiet?: boolean}} */
+  const flags = Object.fromEntries(args.filter(x => x.startsWith('-')).map(x => x.split('-').pop()).map(x => [x, true]));
+
+  const ctx = await getContext();
+  const message = flags.quiet ? () => { } : console.log.bind(console);
+
+  // Clean if needed
+  if (op === 'clean' || (op && flags.clean)) {
+    const fs = require('fs/promises');
+    await Promise.all([ctx.outputFolder, ctx.compilerFolder].map(folder =>
+      fs.rm(`${ctx.workspacePath}/${folder}`, { force: true, recursive: true })));
+    if (op === 'clean') {
+      message(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
+    }
+  }
+
+  switch (op) {
+    case 'clean': break;
+    case 'manifest': {
+      const { writeManifest, buildManifest } = await $getBootstrap(ctx);
+      const manifest = (await buildManifest(ctx)).manifest;
+      await writeManifest(ctx, manifest);
+      const output = `${ctx.workspacePath}/${ctx.outputFolder}/${ctx.manifestFile}`;
+      message(`Wrote manifest ${output}`);
+      break;
+    }
+    case 'watch':
+      message(`Watching ${ctx.workspacePath} for changes...`);
+      await compile(ctx, true);
+      return;
+    case 'build':
+      await compile(ctx);
+      message(`Built to ${ctx.workspacePath}/${ctx.outputFolder}`);
+      break;
+    default: {
+      const path = require('path/posix');
+      const { manifest } = await compile(ctx);
+      const out = path.join(ctx.workspacePath, ctx.outputFolder);
+      // TODO: Externalize somehow?
+      const cliMain = path.join(out, manifest.modules['@travetto/cli'].output, 'support', 'main.cli.js');
+      process.env.TRV_MANIFEST = ctx.mainModule;
+      process.env.TRV_OUTPUT = out;
+      await import(process.env.TRV_MAIN = cliMain);
+      return;
+    }
+  }
+}
+
+exec(process.argv.slice(2));

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@travetto/compiler",
-  "displayName": "Compiler",
-  "version": "3.0.0-rc.0",
-  "description": "Node-integration of Typescript Compiler with advanced functionality for detecting changes in classes and methods.",
+  "version": "3.0.0-rc.11",
+  "description": "Compiler",
   "keywords": [
-    "tsc",
-    "typescript",
     "compiler",
-    "caching",
-    "change-detection",
-    "real-time",
-    "travetto"
+    "travetto",
+    "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
@@ -19,20 +14,41 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.ts",
+    "__index__.ts",
     "src",
-    "support"
+    "bin",
+    "support",
+    "tsconfig.trv.json"
   ],
-  "main": "index.ts",
+  "main": "__index__.ts",
+  "bin": {
+    "trv": "bin/trv.js"
+  },
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/compiler"
   },
   "dependencies": {
-    "@travetto/base": "^3.0.0-rc.0",
-    "@travetto/transformer": "^3.0.0-rc.0",
-    "@travetto/watch": "^3.0.0-rc.0"
+    "@travetto/manifest": "^3.0.0-rc.6",
+    "@travetto/terminal": "^3.0.0-rc.5",
+    "@travetto/transformer": "^3.0.0-rc.9",
+    "@parcel/watcher": "^2.1.0"
+  },
+  "peerDependencies": {
+    "@travetto/cli": "^3.0.0-rc.8"
+  },
+  "peerDependenciesMeta": {
+    "@travetto/cli": {
+      "optional": true
+    }
+  },
+  "travetto": {
+    "displayName": "Compiler",
+    "profiles": [
+      "compile"
+    ]
   },
+  "private": false,
   "publishConfig": {
     "access": "public"
   }