@travetto/compiler 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/watch.ts

@@ -1,14 +1,13 @@
-import fs from 'node:fs/promises';
 import { watch } from 'node:fs';
+import fs from 'node:fs/promises';
 
 import { ManifestFileUtil, ManifestModuleUtil, ManifestUtil, PACKAGE_MANAGERS, PackageUtil, path } from '@travetto/manifest';
 
-import { CompilerReset, type CompilerWatchEvent, type CompileStateEntry } from './types.ts';
-import type { CompilerState } from './state.ts';
-
-import { AsyncQueue } from './queue.ts';
-import { IpcLogger } from './log.ts';
 import { EventUtil } from './event.ts';
+import { IpcLogger } from './log.ts';
+import { AsyncQueue } from './queue.ts';
+import type { CompilerState } from './state.ts';
+import { CompilerReset, type CompilerWatchEvent, type CompileStateEntry } from './types.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -16,7 +15,7 @@ type CompilerWatchEventCandidate = Omit<CompilerWatchEvent, 'entry'> & { entry?:
 
 export class CompilerWatcher {
   #state: CompilerState;
-  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary' | 'git', () => (void | Promise<void>)>> = {};
+  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary' | 'git', () => void | Promise<void>>> = {};
   #watchCanary: string = '.trv/canary.id';
   #lastWorkspaceModified = Date.now();
   #watchCanaryFrequency = 5;
@@ -27,22 +26,22 @@ export class CompilerWatcher {
     this.#state = state;
     this.#root = state.manifest.workspace.path;
     this.#queue = new AsyncQueue(signal);
-    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(fn => fn?.()));
+    signal.addEventListener('abort', () =>
+      Object.values(this.#cleanup).forEach(fn => {
+        fn?.();
+      })
+    );
   }
 
   async #getWatchIgnores(): Promise<string[]> {
     const pkg = PackageUtil.readPackage(this.#root);
-    const patterns = [
-      ...pkg?.travetto?.build?.watchIgnores ?? [],
-      '**/node_modules',
-      '.*/**/node_modules'
-    ];
+    const patterns = [...(pkg?.travetto?.build?.watchIgnores ?? []), '**/node_modules', '.*/**/node_modules'];
     const ignores = new Set(['node_modules', '.git', this.#state.resolveOutputFile('.')]);
     for (const item of patterns) {
       if (item.includes('*')) {
         for await (const sub of fs.glob(item, { cwd: this.#root })) {
           if (sub.startsWith('node_modules')) {
-            continue;
+            // Continue
           } else if (sub.endsWith('/node_modules')) {
             ignores.add(sub.split('/node_modules')[0]);
           } else {
@@ -53,7 +52,7 @@ export class CompilerWatcher {
         ignores.add(item);
       }
     }
-    return [...ignores].toSorted().map(ignore => ignore.endsWith('/') ? ignore : `${ignore}/`);
+    return [...ignores].toSorted().map(ignore => (ignore.endsWith('/') ? ignore : `${ignore}/`));
   }
 
   #toCandidateEvent({ action, file }: Pick<CompilerWatchEvent, 'action' | 'file'>): CompilerWatchEventCandidate {
@@ -68,7 +67,7 @@ export class CompilerWatcher {
       this.#state.removeSource(entry.sourceFile); // Ensure we remove it
     }
 
-    return { entry, file: entry?.sourceFile ?? file, action, moduleFile: entry?.moduleFile! };
+    return { entry, file: entry?.sourceFile ?? file, action, moduleFile: entry?.moduleFile ?? '' };
   }
 
   #isValidFile(file: string): boolean {
@@ -97,8 +96,7 @@ export class CompilerWatcher {
 
   async #updateManifestWithEvents(compilerEvents: CompilerWatchEvent[]): Promise<void> {
     const eventsByModule = this.#state.manifestIndex.groupByLineage(
-      compilerEvents.map(event => ({ item: event, module: event.entry!.module.name }))
-        .filter(x => x.item.action !== 'update')
+      compilerEvents.map(event => ({ item: event, module: event.entry!.module.name })).filter(x => x.item.action !== 'update')
     );
 
     for (const [moduleName, events] of eventsByModule.entries()) {
@@ -116,66 +114,76 @@ export class CompilerWatcher {
   async #listenWorkspace(): Promise<void> {
     const lib = await import('@parcel/watcher');
     const ignore = await this.#getWatchIgnores();
-    const packageFiles = new Set([
-      'package.json',
-      ...PACKAGE_MANAGERS.flatMap(x => [x.workspaceFile!, x.lock].filter(Boolean))
-    ].map(file => path.resolve(this.#root, file)));
+    const packageFiles = new Set(
+      ['package.json', ...PACKAGE_MANAGERS.flatMap(x => [x.workspaceFile!, x.lock].filter(Boolean))].map(file =>
+        path.resolve(this.#root, file)
+      )
+    );
 
     log.debug('Ignore Globs', ignore);
     log.debug('Watching', this.#root);
 
     await this.#cleanup.workspace?.();
 
-    const listener = await lib.subscribe(this.#root, async (error, events) => {
-      this.#lastWorkspaceModified = Date.now();
+    const listener = await lib.subscribe(
+      this.#root,
+      async (error, events) => {
+        this.#lastWorkspaceModified = Date.now();
 
-      try {
-        if (error) {
-          throw error instanceof Error ? error : new Error(`${error}`);
-        } else if (events.length > 25) {
-          throw new CompilerReset(`Large influx of file changes: ${events.length}`);
-        } else if (events.some(event => packageFiles.has(path.toPosix(event.path)))) {
-          throw new CompilerReset('Package information changed');
-        }
+        try {
+          if (error) {
+            throw error instanceof Error ? error : new Error(`${error}`);
+          } else if (events.length > 25) {
+            throw new CompilerReset(`Large influx of file changes: ${events.length}`);
+          } else if (events.some(event => packageFiles.has(path.toPosix(event.path)))) {
+            throw new CompilerReset('Package information changed');
+          }
 
-        // One event per file set
-        const filesChanged = events
-          .map(event => ({ file: path.toPosix(event.path), action: event.type }))
-          .filter(event => this.#isValidFile(event.file));
+          // One event per file set
+          const filesChanged = events
+            .map(event => ({ file: path.toPosix(event.path), action: event.type }))
+            .filter(event => this.#isValidFile(event.file));
 
-        if (filesChanged.length) {
-          EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
-        }
+          if (filesChanged.length) {
+            EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
+          }
 
-        if (filesChanged.some(item => this.#state.isCompilerFile(item.file))) {
-          throw new CompilerReset('Compiler has changed, restarting');
-        }
+          if (filesChanged.some(item => this.#state.isCompilerFile(item.file))) {
+            throw new CompilerReset('Compiler has changed, restarting');
+          }
 
-        const items = filesChanged
-          .map(event => this.#toCandidateEvent(event))
-          .filter(event => this.#isValidEvent(event));
+          const items = filesChanged.map(event => this.#toCandidateEvent(event)).filter(event => this.#isValidEvent(event));
 
-        if (items.length === 0) {
-          return;
-        }
+          if (items.length === 0) {
+            return;
+          }
 
-        try {
-          await this.#updateManifestWithEvents(items);
-        } catch (manifestError) {
-          log.info('Restarting due to manifest rebuild failure', manifestError);
-          throw new CompilerReset(`Manifest rebuild failure: ${manifestError} `);
-        }
+          try {
+            await this.#updateManifestWithEvents(items);
+          } catch (manifestError) {
+            log.info('Restarting due to manifest rebuild failure', manifestError);
+            throw new CompilerReset(`Manifest rebuild failure: ${manifestError} `);
+          }
 
-        for (const item of items) {
-          this.#queue.add(item);
-        }
-      } catch (out) {
-        if (out instanceof Error && out.message.includes('Events were dropped by the FSEvents client.')) {
-          out = new CompilerReset('FSEvents failure, requires restart');
+          for (const item of items) {
+            this.#queue.add(item);
+          }
+        } catch (out) {
+          let error: Error;
+          if (out instanceof Error) {
+            if (out.message.includes('Events were dropped by the FSEvents client.')) {
+              error = new CompilerReset('FSEvents failure, requires restart');
+            } else {
+              error = out;
+            }
+          } else {
+            error = new Error(`${out}`);
+          }
+          return this.#queue.throw(error);
         }
-        return this.#queue.throw(out instanceof Error ? out : new Error(`${out} `));
-      }
-    }, { ignore });
+      },
+      { ignore }
+    );
 
     this.#cleanup.workspace = (): Promise<void> => listener.unsubscribe();
   }
@@ -183,10 +191,12 @@ export class CompilerWatcher {
   async #listenToolFolder(): Promise<void> {
     const build = this.#state.manifest.build;
     const toolRootFolder = path.dirname(path.resolve(this.#root, build.outputFolder));
-    const toolFolders = new Set([toolRootFolder, build.typesFolder, build.outputFolder]
-      .map(folder => path.resolve(this.#root, folder)));
+    const toolFolders = new Set([toolRootFolder, build.typesFolder, build.outputFolder].map(folder => path.resolve(this.#root, folder)));
 
-    log.debug('Tooling Folders', [...toolFolders].map(folder => folder.replace(`${this.#root}/`, '')));
+    log.debug(
+      'Tooling Folders',
+      [...toolFolders].map(folder => folder.replace(`${this.#root}/`, ''))
+    );
 
     await this.#cleanup.tool?.();
 
@@ -195,7 +205,7 @@ export class CompilerWatcher {
         return;
       }
       const full = path.resolve(toolRootFolder, file);
-      const stat = await fs.stat(full).catch(() => null);
+      const stat = await fs.stat(full, { throwIfNoEntry: false });
       if (toolFolders.has(full) && !stat) {
         this.#queue.throw(new CompilerReset(`Tooling folder removal ${full}`));
       }
@@ -229,7 +239,9 @@ export class CompilerWatcher {
 
   async #listenGitChanges(): Promise<void> {
     const gitFolder = path.resolve(this.#root, '.git');
-    if (!await fs.stat(gitFolder).catch(() => false)) { return; }
+    if (!(await fs.stat(gitFolder, { throwIfNoEntry: false }))) {
+      return;
+    }
     log.debug('Starting git canary');
     const listener = watch(gitFolder, { encoding: 'utf8' }, async (event, file) => {
       if (!file) {
@@ -251,4 +263,4 @@ export class CompilerWatcher {
     }
     return this.#queue[Symbol.asyncIterator]();
   }
-}
+}

package/support/invoke.ts

@@ -1,48 +1,85 @@
 // @trv-no-transform
 import { getManifestContext, ManifestUtil } from '@travetto/manifest';
 
-import { Log } from '../src/log.ts';
-import { CompilerManager } from '../src/server/manager.ts';
-import { CompilerClient } from '../src/server/client.ts';
 import { CommonUtil } from '../src/common.ts';
 import { EventUtil } from '../src/event.ts';
+import { Log } from '../src/log.ts';
+import { CompilerClient } from '../src/server/client.ts';
+import { CompilerManager } from '../src/server/manager.ts';
 
-const HELP = `
-trvc [command]
+const hasColor = (process.stdout.isTTY && /^(0)*$/.test(process.env.NO_COLOR ?? '')) || /1\d*/.test(process.env.FORCE_COLOR ?? '');
+const color =
+  (code: number) =>
+  (value: string): string =>
+    hasColor ? `\x1b[${code}m${value}\x1b[0m` : `${value}`;
+const STYLE = { error: color(91), title: color(36), main: color(92), command: color(35), arg: color(37), description: color(33) };
 
-Available Commands:
- * start|watch                  - Run the compiler in watch mode
- * stop                         - Stop the compiler if running
- * restart                      - Restart the compiler in watch mode
- * build                        - Ensure the project is built and upto date
- * clean                        - Clean out the output and compiler caches
- * info                         - Retrieve the compiler information, if running
- * event <log|progress|state>   - Watch events in realtime as newline delimited JSON
- * exec <file> [...args]        - Allow for compiling and executing an entrypoint file
- * manifest [output]            - Generate the project manifest
- * manifest:production [output] - Generate the production project manifest
-`;
+const COMMANDS = {
+  start: { description: 'Run the compiler in watch mode' },
+  stop: { description: 'Stop the compiler if running' },
+  restart: { description: 'Restart the compiler in watch mode' },
+  build: { description: 'Ensure the project is built and upto date' },
+  clean: { description: 'Clean out the output and compiler caches' },
+  info: { description: 'Retrieve the compiler information, if running' },
+  event: { args: ['<log|progress|state>'], description: 'Watch events in realtime as newline delimited JSON' },
+  exec: { args: ['<file>', '[...args]'], description: 'Allow for compiling and executing an entrypoint file' },
+  manifest: { args: ['[output]'], description: 'Generate the project manifest' },
+  'manifest:production': { args: ['[output]'], description: 'Generate the production project manifest' }
+} as const;
+
+function showHelp(errorMessage?: string): void {
+  const PREPARED = Object.entries(COMMANDS)
+    .map(([name, config]) => ({ args: [], ...config, name }))
+    .map(config => ({ ...config, commandLength: [config.name, ...config.args].join(' ').length }));
+
+  const commandWidth = Math.max(...PREPARED.map(config => config.commandLength));
+
+  console.log(
+    [
+      ...(errorMessage ? ['', STYLE.error(errorMessage)] : []),
+      '',
+      `${STYLE.main('trvc')} ${STYLE.command('[command]')}`,
+      '',
+      STYLE.title('Available Commands'),
+      ...PREPARED.map(({ name, args, description, commandLength }) =>
+        [
+          '*',
+          STYLE.command(name),
+          ...args.map(arg => STYLE.arg(arg)),
+          ' '.repeat(commandWidth - commandLength),
+          '-',
+          STYLE.description(description)
+        ].join(' ')
+      ),
+      ''
+    ].join('\n')
+  );
+}
+
+const validateInputs = (value: string[]): value is [keyof typeof COMMANDS, ...string[]] => !!value.length && value[0] in COMMANDS;
 
 /**
  * Invoke the compiler
  */
-export async function invoke(operation?: string, args: string[] = []): Promise<unknown> {
-  if (operation === undefined) {
-    [operation, ...args] = process.argv.slice(2);
+export async function invoke(...input: string[]): Promise<unknown> {
+  if (!validateInputs(input)) {
+    return showHelp(input[0] ? `Unknown trvc command: ${input[0]}` : undefined);
   }
+
+  const [command, ...args] = input;
   const ctx = getManifestContext();
   const client = new CompilerClient(ctx, Log.scoped('client'));
 
   Log.initLevel('error');
   Log.root = ctx.workspace.path;
 
-  switch (operation) {
-    case undefined:
-    case 'help': console.log(HELP); break;
+  switch (command) {
     case 'start':
-    case 'watch': return CompilerManager.compile(ctx, client, { watch: true });
-    case 'build': return CompilerManager.compile(ctx, client, { watch: false });
-    case 'restart': return CompilerManager.compile(ctx, client, { watch: true, forceRestart: true });
+      return CompilerManager.compile(ctx, client, { watch: true });
+    case 'build':
+      return CompilerManager.compile(ctx, client, { watch: false });
+    case 'restart':
+      return CompilerManager.compile(ctx, client, { watch: true, forceRestart: true });
     case 'info': {
       const info = await client.info();
       return CommonUtil.writeStdout(2, info);
@@ -59,7 +96,7 @@ export async function invoke(operation?: string, args: string[] = []): Promise<u
     case 'manifest:production':
     case 'manifest': {
       let manifest = await ManifestUtil.buildManifest(ctx);
-      if (operation === 'manifest:production') {
+      if (command === 'manifest:production') {
         manifest = ManifestUtil.createProductionManifest(manifest);
       }
       if (args[0]) {
@@ -92,6 +129,5 @@ export async function invoke(operation?: string, args: string[] = []): Promise<u
       // Return function to run import on a module
       return import(importTarget);
     }
-    default: console.error(`\nUnknown trvc operation: ${operation}\n${HELP}`);
   }
-}
+}

package/tsconfig.trv.json

@@ -1,23 +1,18 @@
 {
   "compilerOptions": {
-    "module": "esnext",
-    "target": "esnext",
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
-    "lib": [
-      "ESNext",
-    ],
+    "lib": ["ESNext"],
+    "types": ["node"],
     "jsx": "react-jsx",
-    "stableTypeOrdering": true,
-    "strict": true,
     "declaration": true,
     "declarationMap": true,
-    "noUncheckedSideEffectImports": true,
-    "libReplacement": false,
+    "emitDeclarationOnly": false,
     "strictPropertyInitialization": false,
     "erasableSyntaxOnly": true,
     "experimentalDecorators": true,
     "noEmitOnError": false,
+    "allowJs": true,
     "noErrorTruncation": true,
     "resolveJsonModule": true,
     "sourceMap": true,
@@ -29,10 +24,6 @@
     "noEmit": true
   },
   "watchOptions": {
-    "excludeDirectories": [
-      "**/node_modules",
-      "**/.trv",
-      "**/.git",
-    ]
+    "excludeDirectories": ["**/node_modules", "**/.trv", "**/.git"]
   }
-}
+}