@plugjs/plug 0.0.26 → 0.1.0

package/src/plugs/mocha/reporter.ts

@@ -1,178 +0,0 @@
-import { diffJson } from 'diff'
-import RealMocha from 'mocha' // Mocha types pollute the global scope!
-
-import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, NOTICE, WARN } from '../../log'
-
-import type { Logger } from '../../log'
-import type { AssertionError } from 'node:assert'
-
-const _pending = '\u22EF' // middle ellipsis
-const _success = '\u2714' // heavy check mark
-const _failure = '\u2718' // heavy ballot x
-const _details = '\u21B3' // downwards arrow with tip rightwards
-
-/* ========================================================================== *
- * LOGGER / REPORTER                                                          *
- * ========================================================================== */
-
-/** Symbol to inject `Logger` in reporter options */
-export const logSymbol = Symbol()
-
-export class PlugReporter extends RealMocha.reporters.Base {
-  constructor(runner: RealMocha.Runner, options: RealMocha.MochaOptions) {
-    super(runner, options)
-
-    const showDiff = !! options.diff
-    const log = options.reporterOptions[logSymbol] as Logger
-    const failures: RealMocha.Test[] = []
-    const rootSuite = runner.suite
-    let slow = 0
-
-    // Enter a suite (increase indent)
-    runner.on('suite', (suite) => {
-      if (suite === rootSuite) return
-      log.notice('')
-      log.enter(NOTICE, `${$wht(suite.title)}`)
-    })
-
-    // Leave a suite (decrease indent)
-    runner.on('suite end', () => {
-      log.leave()
-    })
-
-    runner.on('fail', (test) => {
-      // Hooks fail here (not on "hook end")
-      if (test.type as any === 'hook') {
-        const number = failures.push(test)
-        const tag = $gry('[') + $red('failed') + $gry('] [') + $red(number) + $gry(']')
-        log.error(`${$red(_failure)} ${test.title} ${tag}`)
-      }
-    })
-
-    // Enter a test (increase indent)
-    runner.on('test', (test) => {
-      // mark that we _entered_ the test ('pending' might be called)
-      (<any> test).__plugjs__entered = true
-      log.enter(NOTICE, `${$blu(_pending)} ${test.title}`)
-    })
-
-    // Enter a pending test (increase indent)
-    runner.on('pending', (test) => {
-      // pending is also called when "this.skip" gets called inside the test
-      if ((<any> test).__plugjs__entered === true) return
-      log.enter(NOTICE, `${$blu(_pending)} ${test.title}`)
-    })
-
-    // Leave a test (handle warning/failures and decrease indent)
-    runner.on('test end', (test) => {
-      if (test.isPassed()) {
-        const duration = test.duration || 0
-        if (duration < test.slow()) {
-          log.leave(NOTICE, `${$grn(_success)} ${test.title}`)
-        } else {
-          log.leave(WARN, `${$ylw(_success)} ${test.title} ${$ms(duration, 'slow')}`)
-          slow ++
-        }
-      } else if (test.isPending()) {
-        const tag = $gry('[') + $ylw('skipped') + $gry(']')
-        log.leave(WARN, `${$ylw(_pending)} ${test.title} ${tag}`)
-      } else if (test.isFailed()) {
-        const number = failures.push(test)
-        const tag = $gry('[') + $red('failed') + $gry('] [') + $red(number) + $gry(']')
-        log.leave(ERROR, `${$red(_failure)} ${test.title} ${tag}`)
-      }
-    })
-
-    // Mocha finished running, dump our report
-    runner.once('end', () => {
-      // console.log('[end]')
-      try {
-        // Each failure gets dumped individually
-        for (let i = 0; i < failures.length; i ++) {
-          log.notice('')
-          const failure = failures[i]
-
-          // The titles (from the suite, up to the test)
-          const titles = [ failure.title ]
-          for (let parent = failure.parent; parent; parent = parent?.parent) {
-            if (parent.parent) titles.unshift(parent.title)
-          }
-
-          // Log out our titles (one per line, indented)
-          log.error(`${$gry('Failure [')}${$red(i + 1)}${$gry(']')}`)
-          titles.forEach((title, indent) => {
-            log.error(`  ${''.padStart(indent * 4)}${$gry(_details)} ${$wht(title)}`)
-          })
-
-          // If we have an error, luckily this is an `Error` instance
-          if (failure.err) {
-            const message = `${failure.err}` // this is the message, can be multiple lines
-            const messageOrStack = failure.err.stack || `${failure.err}` // maybe a stack?
-            const messageIndex = messageOrStack.indexOf(message)
-
-            // Subtrack the message from the stack
-            const stack =
-              messageOrStack === message ? '' :
-              messageIndex < 0 ? messageOrStack :
-              messageOrStack.substring(messageIndex + message.length)
-
-            // Split and clean up stack lines
-            const stackLines = stack.split('\n')
-                .map((line) => line.trim())
-                .filter((line) => !! line)
-
-            // Output the message
-            log.enter(ERROR, '')
-            log.error($red(message))
-
-            // Should we diff?
-            if (showDiff && ('actual' in failure.err) && ('expected' in failure.err)) {
-              const err = failure.err as AssertionError
-              const actual =
-                err.actual === undefined ? '[undefined]' :
-                err.actual === null ? '[null]' :
-                err.actual
-
-              const expected =
-                err.expected === undefined ? '[undefined]' :
-                err.expected === null ? '[null]' :
-                err.expected
-
-              const changes = diffJson(actual as any, expected as any)
-
-              const diff = changes.map((change): string => {
-                if (change.removed) return $red(change.value)
-                if (change.added) return $grn(change.value)
-                return $gry(change.value)
-              }).join('')
-
-              log.enter(ERROR, `${$gry('diff')} ${$grn('expected')}  ${$gry('/')} ${$red('actual')}`)
-              log.error(diff)
-              log.leave()
-            }
-
-            // Dump our stack trace and leave
-            stackLines.forEach((line) => log.error(line))
-            log.leave()
-          }
-        }
-
-        // If we have some statistics, then let's dump them out in pretty colors
-        if (runner.stats) {
-          log.notice('')
-          const { passes, pending, failures, duration = 0 } = runner.stats
-          const fmt = (n: number): string => n === 1 ? `${n} test` : `${n} tests`
-          if (passes) log.notice($grn(fmt(passes)), 'passing', $ms(duration))
-          if (slow) log.warn($ylw(fmt(slow)), 'slow')
-          if (pending) log.warn($ylw(fmt(pending)), 'pending')
-          if (failures) log.error($red(fmt(failures)), 'failed')
-        }
-
-        // Done...
-        log.notice('')
-      } catch (error) {
-        log.error('Error rendering Mocha report', error)
-      }
-    })
-  }
-}

package/src/plugs/mocha/runner.ts

@@ -1,66 +0,0 @@
-import RealMocha from 'mocha' // Mocha types pollute the global scope!
-
-import { assert } from '../../assert'
-import { BuildFailure } from '../../failure'
-import { $p, $wht, NOTICE } from '../../log'
-import { resolveFile } from '../../paths'
-import { logSymbol, PlugReporter } from './reporter'
-
-import type { Files } from '../../files'
-import type { Context, PipeParameters, Plug } from '../../pipe'
-import type { MochaOptions } from '../mocha'
-
-/** Writes some info about the current {@link Files} being passed around. */
-export default class Mocha implements Plug<void> {
-  constructor(...args: PipeParameters<'mocha'>)
-  constructor(private readonly _options: MochaOptions = {}) {}
-
-  async pipe(files: Files, context: Context): Promise<void> {
-    // Enter log here, so that log messages called when loading files get
-    // properly indented by our logger
-    context.log.notice('') // empty line
-    context.log.enter(NOTICE, $wht('Starting Mocha'))
-
-    // Expand our options
-    const { require, ...options } = this._options
-
-    // See if we require a setup script...
-    if (require) {
-      const requiredFile = context.resolve(require)
-      const scriptFile = resolveFile(requiredFile)
-      assert(scriptFile, `Mocha setup file ${$p(requiredFile)} not found`)
-      context.log.debug(`Importing setup script ${$p(requiredFile)}`)
-      await import(scriptFile)
-    }
-
-    // Create the mocha runner
-    const mocha = new RealMocha({
-      diff: true, // by defaut enable diffs
-      reporter: PlugReporter, // default to our reporter
-      ...options, // override defaults with all other options
-      reporterOptions: {
-        ...options.reporterOptions,
-        [logSymbol]: context.log, // always force a log
-      },
-      allowUncaught: false, // never allow uncaught exceptions
-      delay: false, // never delay running
-    })
-
-    // Tell mocha about all our files
-    for (const file of files.absolutePaths()) mocha.addFile(file)
-
-    await mocha.loadFilesAsync()
-
-    // Run mocha!
-    return new Promise((resolve, reject) => {
-      try {
-        mocha.run((failures) => {
-          if (failures) reject(BuildFailure.fail())
-          resolve(undefined)
-        })
-      } catch (error) {
-        reject(error)
-      }
-    })
-  }
-}

package/src/plugs/mocha.ts

@@ -1,43 +0,0 @@
-import { installForking } from '../fork'
-import { requireResolve } from '../paths'
-
-/** Options to construct our {@link Mocha} plug. */
-export interface MochaOptions {
-  /** Specify the directory where coverage data will be saved */
-  coverageDir?: string,
-  /** Bail after first test failure? */
-  bail?: boolean,
-  /** Show diff on failure? */
-  diff?: boolean,
-  /** Report tests without running them? */
-  dryRun?: boolean,
-  /** Tests marked `only` fail the suite? */
-  forbidOnly?: boolean,
-  /** Pending tests fail the suite? */
-  forbidPending?: false,
-  /** Reporter name. */
-  reporter?: string
-  /** Options for the reporter */
-  reporterOptions?: Record<string, any>,
-  /** Number of times to retry failed tests. */
-  retries?: number,
-  /** Slow threshold value. */
-  slow?: number,
-  /** Setup file to import before running Mocha. */
-  require?: string,
-  /** Timeout threshold value. */
-  timeout?: number,
-}
-
-declare module '../pipe' {
-  export interface Pipe {
-    /**
-     * Run tests using {@link https://mochajs.org/ _Mocha_}.
-     *
-     * @param options Optional {@link MochaOptions | options} for _Mocha_.
-     */
-    mocha(options?: MochaOptions): Promise<undefined>
-  }
-}
-
-installForking('mocha', requireResolve(__fileurl, './mocha/runner'))

package/src/plugs/tsc/compiler.ts

@@ -1,68 +0,0 @@
-import ts from 'typescript' // TypeScript does NOT support ESM modules
-
-import { resolveAbsolutePath } from '../../paths'
-
-import type { AbsolutePath } from '../../paths'
-
-export class TypeScriptHost
-implements ts.CompilerHost {
-  constructor(directory: AbsolutePath)
-  constructor(private readonly _directory: AbsolutePath) {}
-
-  /* ======================================================================== */
-
-  /** Get a source file parsing one of our virtual files */
-  getSourceFile(
-      fileName: string,
-      languageVersion: ts.ScriptTarget,
-  ): ts.SourceFile | undefined {
-    const code = this.readFile(fileName)
-    return code ? ts.createSourceFile(fileName, code, languageVersion) : void 0
-  }
-
-  /** Never write any files */
-  writeFile(fileName: string): void {
-    throw new Error(`Cowardly refusing to write "${fileName}"`)
-  }
-
-  /** Get the default library associated with the given options */
-  getDefaultLibFileName(options: ts.CompilerOptions): string {
-    return ts.getDefaultLibFilePath(options)
-  }
-
-  /** Check for filesystem case sensitivity */
-  useCaseSensitiveFileNames(): boolean {
-    return ts.sys.useCaseSensitiveFileNames
-  }
-
-  /** Check for the existence of a given file */
-  fileExists(fileName: string): boolean {
-    return ts.sys.fileExists(resolveAbsolutePath(this.getCurrentDirectory(), fileName))
-  }
-
-  /** Read the file if it exists, otherwise return undefined */
-  readFile(fileName: string): string | undefined {
-    return ts.sys.readFile(resolveAbsolutePath(this.getCurrentDirectory(), fileName))
-  }
-
-  /** Return the current working directory */
-  getCurrentDirectory(): AbsolutePath {
-    return this._directory
-  }
-
-  /** Return the canonical name for the specified file */
-  getCanonicalFileName(fileName: string): string {
-    if (ts.sys.useCaseSensitiveFileNames) return fileName
-
-    // Lifted from TypeScript sources
-    const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_. ]+/g
-    return fileNameLowerCaseRegExp.test(fileName) ?
-      fileName.replace(fileNameLowerCaseRegExp, (s) => s.toLowerCase()) :
-      fileName
-  }
-
-  /** Return the new line sequence used by this platform */
-  getNewLine(): string {
-    return ts.sys.newLine
-  }
-}

package/src/plugs/tsc/options.ts

@@ -1,100 +0,0 @@
-import ts from 'typescript' // TypeScript does NOT support ESM modules
-
-import { getAbsoluteParent, resolveAbsolutePath } from '../../paths'
-import { readFile } from '../../utils/asyncfs'
-
-import type { AbsolutePath } from '../../paths'
-
-/* ========================================================================== */
-
-export type CompilerOptionsAndDiagnostics = {
-  options: ts.CompilerOptions,
-  errors: readonly ts.Diagnostic[],
-}
-
-/* ========================================================================== */
-
-function mergeResults(
-    base: CompilerOptionsAndDiagnostics,
-    override: CompilerOptionsAndDiagnostics,
-): CompilerOptionsAndDiagnostics {
-  return {
-    options: { ...base.options, ...override.options },
-    errors: [ ...base.errors, ...override.errors ],
-  }
-}
-
-/* ========================================================================== */
-
-async function loadOptions(
-    file: AbsolutePath,
-    stack: AbsolutePath[] = [ file ],
-): Promise<CompilerOptionsAndDiagnostics> {
-  const dir = getAbsoluteParent(file)
-
-  // Load up our config file and convert is wicked JSON
-  const data = await readFile(file, 'utf-8')
-  const { config, error } = ts.parseConfigFileTextToJson(file, data)
-  if (error) return { options: {}, errors: [ error ] }
-
-  // Parse up the configuration file as options
-  const { compilerOptions = {}, extends: extendsPath } = config
-  const result = ts.convertCompilerOptionsFromJson(compilerOptions, dir, file)
-  if (result.errors.length) return result
-
-  // If we don't extend, we can return our result
-  if (!extendsPath) return result
-
-  // Resolve the name of the file this config extends
-  const ext = resolveAbsolutePath(dir, extendsPath)
-
-  // Triple check that we are not recursively importing this file
-  if (stack.includes(ext)) {
-    return { options: {}, errors: [ {
-      messageText: `Circularity detected extending from "${ext}"`,
-      category: ts.DiagnosticCategory.Error,
-      code: 18000, // copied from typescript internals...
-      file: ts.createSourceFile(file, data, ts.ScriptTarget.JSON, false, ts.ScriptKind.JSON),
-      start: undefined,
-      length: undefined,
-    } ] }
-  }
-
-  // Push our file in the stack and load recursively
-  return mergeResults(await loadOptions(ext, [ ...stack, ext ]), result)
-}
-
-/* ========================================================================== */
-
-export async function getCompilerOptions(
-  file?: AbsolutePath,
-): Promise<CompilerOptionsAndDiagnostics>
-
-export async function getCompilerOptions(
-  file: AbsolutePath | undefined,
-  overrides: ts.CompilerOptions,
-  overridesFile: AbsolutePath,
-  overridesBasePath: AbsolutePath,
-): Promise<CompilerOptionsAndDiagnostics>
-
-/** Load compiler options from a JSON file, and merge in the overrides */
-export async function getCompilerOptions(
-    file?: AbsolutePath,
-    ...override: [ ts.CompilerOptions, AbsolutePath, AbsolutePath ] | []
-): Promise<CompilerOptionsAndDiagnostics> {
-  let result: CompilerOptionsAndDiagnostics = { options: ts.getDefaultCompilerOptions(), errors: [] }
-
-  // If we have a file to parse, load it, otherwise try "tsconfig.json"
-  if (file) result = mergeResults(result, await loadOptions(file))
-
-  // If we have overrides, merge them
-  if (override.length) {
-    const [ overrides, overridesFile, overridesDir ] = override
-    const options = ts.convertCompilerOptionsFromJson(overrides, overridesDir, overridesFile)
-    delete options.options.configFilePath // remove build file name...
-    result = mergeResults(result, options)
-  }
-
-  // Return all we have
-  return result
-}

package/src/plugs/tsc/report.ts

@@ -1,77 +0,0 @@
-import ts from 'typescript' // TypeScript does NOT support ESM modules
-
-import { ERROR, NOTICE, WARN } from '../../log'
-import { resolveAbsolutePath } from '../../paths'
-
-import type { Report, ReportLevel, ReportRecord } from '../../log'
-import type { AbsolutePath } from '../../paths'
-
-function convertMessageChain(chain: ts.DiagnosticMessageChain, indent = 0): string[] {
-  const message = `${''.padStart(indent * 2)}${chain.messageText}`
-
-  if (chain.next) {
-    const next = chain.next.map((c) => convertMessageChain(c, indent + 1))
-    return [ message, ...next.flat(1) ]
-  } else {
-    return [ message ]
-  }
-}
-
-function convertDiagnostics(
-    diagnostics: readonly ts.Diagnostic[],
-    directory: AbsolutePath,
-): ReportRecord[] {
-  return diagnostics.map((diagnostic): ReportRecord => {
-    // console.log(diagnostic)
-    void directory
-
-    // Convert the `DiagnosticCategory` to our level
-    let level: ReportLevel
-    switch (diagnostic.category) {
-      case ts.DiagnosticCategory.Error: level = ERROR; break
-      case ts.DiagnosticCategory.Warning: level = WARN; break
-      default: level = NOTICE
-    }
-
-    // Convert the `messageText` to a string
-    let message: string | string[]
-    if (typeof diagnostic.messageText === 'string') {
-      message = diagnostic.messageText
-    } else {
-      message = convertMessageChain(diagnostic.messageText)
-    }
-
-    // Simple variables
-    const tags = `TS${diagnostic.code}`
-
-
-    if (diagnostic.file) {
-      const { file: sourceFile, start, length } = diagnostic
-      const file = resolveAbsolutePath(directory, sourceFile.fileName)
-      const source = sourceFile.getFullText()
-
-      if (start !== undefined) {
-        const position = sourceFile.getLineAndCharacterOfPosition(start)
-        let { line, character: column } = position
-        column += 1
-        line += 1
-
-        return { level, message, tags, file, source, line, column, length }
-      } else {
-        return { level, message, tags, file, source }
-      }
-    } else {
-      return { level, message, tags }
-    }
-  })
-}
-
-/** Update a report, adding records from an array of {@link ts.Diagnostic} */
-export function updateReport(
-    report: Report,
-    diagnostics: readonly ts.Diagnostic[],
-    directory: AbsolutePath,
-): void {
-  const records = convertDiagnostics(diagnostics, directory)
-  report.add(...records)
-}

package/src/plugs/tsc/runner.ts

@@ -1,133 +0,0 @@
-import ts from 'typescript' // TypeScript does NOT support ESM modules
-
-import { assertPromises } from '../../assert'
-import { BuildFailure } from '../../failure'
-import { Files } from '../../files'
-import { $p, log } from '../../log'
-import { resolveAbsolutePath, resolveFile } from '../../paths'
-import { parseOptions } from '../../utils/options'
-import { walk } from '../../utils/walk'
-import { TypeScriptHost } from './compiler'
-import { getCompilerOptions } from './options'
-import { updateReport } from './report'
-
-import type { AbsolutePath } from '../../paths'
-import type { Context, PipeParameters, Plug } from '../../pipe'
-import type { ExtendedCompilerOptions } from '../tsc'
-
-/* ========================================================================== *
- * WORKER PLUG                                                                *
- * ========================================================================== */
-
-export default class Tsc implements Plug<Files> {
-  private readonly _tsconfig?: string
-  private readonly _options: ExtendedCompilerOptions
-
-  constructor(...args: PipeParameters<'tsc'>) {
-    const { params: [ tsconfig ], options } = parseOptions(args, {})
-    this._tsconfig = tsconfig
-    this._options = options
-  }
-
-  async pipe(files: Files, context: Context): Promise<Files> {
-    const baseDir = context.resolve('.') // "this" directory, base of all relative paths
-    const report = context.log.report('TypeScript Report') // report used throughout
-    const { extraTypesDir, ...overrides } = { ...this._options } // clone our options
-
-    /*
-     * The "tsconfig" file is either specified, or (if existing) first checked
-     * alongside the sources, otherwise checked in the current directory.
-     */
-    const sourcesConfig = resolveFile(files.directory, 'tsconfig.json')
-    const tsconfig = this._tsconfig ? context.resolve(this._tsconfig) :
-      sourcesConfig || resolveFile(context.resolve('tsconfig.json'))
-
-    /* Root directory must always exist */
-    let rootDir: AbsolutePath
-    if (overrides.rootDir) {
-      rootDir = overrides.rootDir = context.resolve(overrides.rootDir)
-    } else {
-      rootDir = overrides.rootDir = files.directory
-    }
-
-    /* Output directory _also_ must always exist */
-    let outDir: AbsolutePath
-    if (overrides.outDir) {
-      outDir = overrides.outDir = context.resolve(overrides.outDir)
-    } else {
-      outDir = overrides.outDir = rootDir // default to the root directory
-    }
-
-    /* All other root paths */
-    if (overrides.rootDirs) {
-      overrides.rootDirs = overrides.rootDirs.map((dir) => context.resolve(dir))
-    }
-
-    /* The baseURL is resolved, as well */
-    if (overrides.baseUrl) overrides.baseUrl = context.resolve(overrides.baseUrl)
-
-    /* We can now get our compiler options, and check any and all overrides */
-    const { errors, options } = await getCompilerOptions(
-        tsconfig, // resolved tsconfig.json from constructor, might be undefined
-        overrides, // overrides from constructor, might be an empty object
-        context.buildFile, // the build file where the overrides were specified,
-        baseDir) // base dir where to resolve overrides
-
-    /* Update report and fail on errors */
-    updateReport(report, errors, baseDir)
-    if (report.errors) report.done(true)
-
-    /* Prep for compilation */
-    const paths = [ ...files.absolutePaths() ]
-    for (const path of paths) log.trace(`Compiling "${$p(path)}"`)
-    log.info('Compiling', paths.length, 'files')
-
-    /* If we have an extra types directory, add all the .d.ts files in there */
-    if (extraTypesDir) {
-      const directory = context.resolve(extraTypesDir)
-
-      for await (const file of walk(directory, [ '**/*.d.ts' ])) {
-        const path = resolveAbsolutePath(directory, file)
-        log.debug(`Including extra type file "${$p(path)}"`)
-        paths.push(path)
-      }
-    }
-
-    /* Log out what we'll be our final compilation options */
-    log.debug('Compliation options', options)
-
-    /* Typescript host, create program and compile */
-    const host = new TypeScriptHost(rootDir)
-    const program = ts.createProgram(paths, options, host, undefined, errors)
-    const diagnostics = ts.getPreEmitDiagnostics(program)
-
-    /* Update report and fail on errors */
-    updateReport(report, diagnostics, rootDir)
-    if (report.errors) report.done(true)
-
-    /* Write out all files asynchronously */
-    const builder = Files.builder(outDir)
-    const promises: Promise<void>[] = []
-    const result = program.emit(undefined, (fileName, code) => {
-      promises.push(builder.write(fileName, code).then((file) => {
-        log.trace('Written', $p(file))
-      }).catch((error) => {
-        const outFile = resolveAbsolutePath(outDir, fileName)
-        log.error('Error writing to', $p(outFile), error)
-        throw BuildFailure.fail()
-      }))
-    })
-
-    /* Await for all files to be written and check */
-    await assertPromises(promises)
-
-    /* Update report and fail on errors */
-    updateReport(report, result.diagnostics, rootDir)
-    if (report.errors) report.done(true)
-
-    /* All done, build our files and return it */
-    const outputs = builder.build()
-    log.info('TSC produced', outputs.length, 'files into', $p(outputs.directory))
-    return outputs
-  }
-}