@travetto/compiler 8.0.0-alpha.20 → 8.0.0-alpha.22

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?.();
 
@@ -229,7 +239,9 @@ export class CompilerWatcher {
 
   async #listenGitChanges(): Promise<void> {
     const gitFolder = path.resolve(this.#root, '.git');
-    if (!await fs.stat(gitFolder, { throwIfNoEntry: 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,15 +1,18 @@
 // @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 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), };
+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) };
 
 const COMMANDS = {
   start: { description: 'Run the compiler in watch mode' },
@@ -31,17 +34,26 @@ function showHelp(errorMessage?: string): void {
 
   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'));
+  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;
@@ -51,7 +63,7 @@ const validateInputs = (value: string[]): value is [keyof typeof COMMANDS, ...st
  */
 export async function invoke(...input: string[]): Promise<unknown> {
   if (!validateInputs(input)) {
-    return showHelp(input[0] ? `Unknown trvc command: ${input[0]}` : undefined);;
+    return showHelp(input[0] ? `Unknown trvc command: ${input[0]}` : undefined);
   }
 
   const [command, ...args] = input;
@@ -62,9 +74,12 @@ export async function invoke(...input: string[]): Promise<unknown> {
   Log.root = ctx.workspace.path;
 
   switch (command) {
-    case 'start': 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 'start':
+      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);
@@ -115,4 +130,4 @@ export async function invoke(...input: string[]): Promise<unknown> {
       return import(importTarget);
     }
   }
-}
+}

package/tsconfig.trv.json

@@ -2,12 +2,8 @@
   "compilerOptions": {
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
-    "lib": [
-      "ESNext",
-    ],
-    "types": [
-      "node"
-    ],
+    "lib": ["ESNext"],
+    "types": ["node"],
     "jsx": "react-jsx",
     "declaration": true,
     "declarationMap": true,
@@ -28,10 +24,6 @@
     "noEmit": true
   },
   "watchOptions": {
-    "excludeDirectories": [
-      "**/node_modules",
-      "**/.trv",
-      "**/.git",
-    ]
+    "excludeDirectories": ["**/node_modules", "**/.trv", "**/.git"]
   }
-}
+}