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

package/bin/transpile.js

@@ -1,227 +0,0 @@
-// @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/support/bin/compiler-bootstrap.ts

@@ -1,151 +0,0 @@
-import path from 'path';
-import fs from 'fs/promises';
-import cp from 'child_process';
-
-import type { ManifestState, ManifestContext, ManifestRoot } from '@travetto/manifest';
-
-import { log, compileIfStale, getProjectSources, addNodePath, importManifest } from './utils';
-
-const PRECOMPILE_MODS = [
-  '@travetto/terminal',
-  '@travetto/manifest',
-  '@travetto/transformer',
-  '@travetto/compiler'
-];
-
-let manifestTemp;
-
-/**
- * Step 0
- */
-export async function precompile(ctx: ManifestContext): Promise<void> {
-  for (const mod of PRECOMPILE_MODS) {
-    await compileIfStale(ctx, `[0] Compiling ${mod}`, await getProjectSources(ctx, mod),);
-  }
-}
-
-export async function writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<void> {
-  const { ManifestUtil } = await importManifest(ctx);
-  return ManifestUtil.writeManifest(ctx, manifest);
-}
-
-async function rewriteManifests(ctx: ManifestContext, state: ManifestState): Promise<void> {
-  const { ManifestUtil } = await importManifest(ctx);
-
-  // Write out all changed manifests
-  const { getContext } = await import('../../bin/transpile');
-
-  const dirtyModules = [...Object.entries(state.delta)].filter(x => x[1].length > 0).map(([mod]) => mod);
-  for (const module of dirtyModules) {
-    const subCtx = await getContext(state.manifest.modules[module].source);
-    await ManifestUtil.createAndWriteManifest(subCtx);
-  }
-}
-
-/**
- *  Step 1
- */
-export async function buildManifest(ctx: ManifestContext): Promise<ManifestState> {
-  log('[1] Manifest Generation');
-  const { ManifestUtil } = await importManifest(ctx);
-  return ManifestUtil.produceState(ctx);
-}
-
-function shouldRebuildCompiler({ delta }: ManifestState): { total: boolean, transformers: [string, string][] } {
-  // Did enough things change to re-stage and build the compiler
-  const transformersChanged = Object.entries(delta)
-    .flatMap(([mod, files]) => files.map(x => [mod, x.file]))
-    .filter((ev): ev is [string, string] => ev[1].startsWith('support/transform'));
-  const transformerChanged = (delta['@travetto/transformer'] ?? []);
-  const compilerChanged = delta['@travetto/compiler'] ?? [];
-
-  const changed = transformerChanged.length || transformersChanged.length || compilerChanged.length;
-  if (changed) {
-    if (compilerChanged.length) {
-      log('[2] Compiler source changed @travetto/compiler', compilerChanged);
-    }
-    if (transformerChanged.length) {
-      log('[2] Compiler source changed @travetto/transformer', transformerChanged);
-    }
-    if (transformersChanged.length) {
-      log('[2] Compiler source changed */support/transform', transformersChanged);
-    }
-  }
-  return { total: changed > 0, transformers: transformersChanged };
-}
-
-/**
- *  Step 2
- */
-async function buildCompiler(state: ManifestState, ctx: ManifestContext): Promise<void> {
-  const changed = shouldRebuildCompiler(state);
-
-  if (changed.transformers.length) {
-    state = await buildManifest(ctx);
-    let x = 0;
-    for (const [mod, file] of changed.transformers) {
-      await compileIfStale(
-        ctx,
-        `[2.${x += 1}] ${file} Bootstrapping`,
-        await getProjectSources(ctx, mod, ['package.json', file])
-      );
-    }
-  }
-
-  log('[2] Compiler Ready');
-}
-
-/**
- *  Step 4
- */
-async function compileOutput(state: ManifestState, ctx: ManifestContext, watch?: boolean): Promise<void> {
-  let changes = Object.values(state.delta).flat();
-
-  // Remove files that should go away
-  await Promise.all(changes.filter(x => x.type === 'removed')
-    .map(x => fs.unlink(path.resolve(ctx.workspacePath, ctx.outputFolder, x.file)).catch(() => { })));
-
-  changes = changes.filter(x => x.type !== 'removed');
-
-  const { ManifestUtil } = await importManifest(ctx);
-  const resolve = ManifestUtil.resolveFile.bind(null, ctx, state.manifest, '@travetto/compiler');
-
-  manifestTemp ??= await ManifestUtil.writeState(state);
-  const cwd = path.resolve(ctx.workspacePath, ctx.compilerFolder);
-
-  if (changes.length) {
-    log('[3] Changed Sources', changes);
-
-    // Blocking call, compile only
-    const res = cp.spawnSync(process.argv0,
-      [resolve('support/main.output'), manifestTemp],
-      { cwd, stdio: 'inherit', encoding: 'utf8' }
-    );
-
-    if (res.status) {
-      throw new Error(res.stderr);
-    }
-
-    await rewriteManifests(ctx, state);
-  }
-
-  if (watch) {
-    // Rewrite state with updated manifest
-    const newState = await ManifestUtil.produceState(ctx);
-    manifestTemp = await ManifestUtil.writeState(newState);
-
-    // Run with watching
-    cp.spawnSync(process.argv0,
-      [resolve('support/main.output'), manifestTemp, 'true'], { cwd, stdio: 'inherit' }
-    );
-  }
-}
-
-export async function compile(ctx: ManifestContext, watch?: boolean): Promise<ManifestState> {
-  await precompile(ctx); // Step 0
-  const state = await buildManifest(ctx); // Step 1
-  await buildCompiler(state, ctx); // Step 2
-  await compileOutput(state, ctx, watch); // Step 3
-  await addNodePath(path.resolve(ctx.workspacePath, ctx.outputFolder));
-  return state;
-}

package/support/bin/utils.ts

@@ -1,116 +0,0 @@
-import fs from 'fs/promises';
-
-import path from 'path';
-import { type Stats } from 'fs';
-import { createRequire } from 'module';
-
-import type { ManifestContext, ManifestUtil } from '@travetto/manifest';
-
-import { transpileFile, writePackageJson } from '../../bin/transpile';
-
-const req = createRequire(`${process.cwd()}/node_modules`);
-
-type ModFile = { input: string, output: string, stale: boolean };
-
-const SOURCE_SEED = ['package.json', 'index.ts', '__index__.ts', 'src', 'support', 'bin'];
-
-export const IS_DEBUG = /\b([*]|build)\b/.test(process.env.DEBUG ?? '');
-
-const resolveImport = (lib: string): string => req.resolve(lib);
-const recentStat = (stat: Stats): number => Math.max(stat.ctimeMs, stat.mtimeMs);
-
-/**
- * Common logging support
- */
-export const log = IS_DEBUG ?
-  (...args: unknown[]): void => console.debug(new Date().toISOString(), ...args) :
-  (): void => { };
-
-/**
- * Scan directory to find all project sources for comparison
- */
-export async function getProjectSources(
-  ctx: ManifestContext, module: string, seed: string[] = SOURCE_SEED
-): Promise<ModFile[]> {
-  const inputFolder = (ctx.mainModule === module) ?
-    process.cwd() :
-    path.dirname(resolveImport(`${module}/package.json`));
-
-  const folders = seed.filter(x => !/[.]/.test(x)).map(x => path.resolve(inputFolder, x));
-  const files = seed.filter(x => /[.]/.test(x)).map(x => path.resolve(inputFolder, x));
-
-  while (folders.length) {
-    const sub = folders.pop();
-    if (!sub) {
-      continue;
-    }
-
-    for (const file of await fs.readdir(sub).catch(() => [])) {
-      if (file.startsWith('.')) {
-        continue;
-      }
-      const resolvedInput = path.resolve(sub, file);
-      const stat = await fs.stat(resolvedInput);
-
-      if (stat.isDirectory()) {
-        folders.push(resolvedInput);
-      } else if (file.endsWith('.d.ts')) {
-        // Do nothing
-      } else if (file.endsWith('.ts') || file.endsWith('.js')) {
-        files.push(resolvedInput);
-      }
-    }
-  }
-
-  const outputFolder = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', module);
-  const out: ModFile[] = [];
-  for (const input of files) {
-    const output = input.replace(inputFolder, outputFolder).replace(/[.]ts$/, '.js');
-    const inputTs = await fs.stat(input).then(recentStat, () => 0);
-    if (inputTs) {
-      const outputTs = await fs.stat(output).then(recentStat, () => 0);
-      await fs.mkdir(path.dirname(output), { recursive: true, });
-      out.push({ input, output, stale: inputTs > outputTs });
-    }
-  }
-
-  return out;
-}
-
-/**
- * Recompile folder if stale
- */
-export async function compileIfStale(ctx: ManifestContext, prefix: string, files: ModFile[]): Promise<void> {
-  try {
-    if (files.some(f => f.stale)) {
-      log(`${prefix} Starting`);
-      for (const file of files.filter(x => x.stale)) {
-        if (file.input.endsWith('package.json')) {
-          await writePackageJson(ctx, file.input, file.output);
-        } else {
-          await transpileFile(ctx, file.input, file.output);
-        }
-      }
-    } else {
-      log(`${prefix} Skipped`);
-    }
-  } catch (err) {
-    console.error(err);
-  }
-}
-
-/**
- * Add node path at runtime
- */
-export async function addNodePath(folder: string): Promise<void> {
-  process.env.NODE_PATH = [`${folder}/node_modules`, process.env.NODE_PATH].join(path.delimiter);
-  const { Module } = await import('module');
-  // @ts-expect-error
-  Module._initPaths();
-}
-
-/**
- * Import the manifest utils once compiled
- */
-export const importManifest = (ctx: ManifestContext): Promise<{ ManifestUtil: typeof ManifestUtil }> =>
-  import(path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto', 'manifest', '__index__.js'));

package/support/main.output.ts

@@ -1,11 +0,0 @@
-import { readFileSync } from 'fs';
-import { install } from 'source-map-support';
-
-import { ManifestState } from '@travetto/manifest';
-
-import { Compiler } from '../src/compiler';
-
-install();
-const [manifestState, watch] = process.argv.slice(2);
-const state: ManifestState = JSON.parse(readFileSync(manifestState, 'utf8'));
-new Compiler().init(state).run(watch === 'true');