@plugjs/typescript 0.1.0

package/src/options.ts

@@ -0,0 +1,93 @@
+import ts from 'typescript' // TypeScript does NOT support ESM modules
+import { getAbsoluteParent, resolveAbsolutePath } from '@plugjs/plug/paths'
+
+import type { AbsolutePath } from '@plugjs/plug/paths'
+
+/* ========================================================================== */
+
+export type CompilerOptionsAndDiagnostics = {
+  options: ts.CompilerOptions,
+  errors: readonly ts.Diagnostic[],
+}
+
+/* ========================================================================== */
+
+function mergeResults(
+    base: CompilerOptionsAndDiagnostics,
+    override: CompilerOptionsAndDiagnostics,
+): CompilerOptionsAndDiagnostics {
+  const options = { ...base.options, ...override.options }
+  const errors = [ ...base.errors, ...override.errors ]
+  return errors.length ? { options: {}, errors } : { options, 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 { config, error } = ts.readConfigFile(file, ts.sys.readFile)
+  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)) {
+    const data = ts.sys.readFile(file)
+    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,
+): Promise<CompilerOptionsAndDiagnostics>
+
+/** Load compiler options from a JSON file, and merge in the overrides */
+export async function getCompilerOptions(
+    file?: AbsolutePath,
+    overrides?: ts.CompilerOptions,
+): Promise<CompilerOptionsAndDiagnostics> {
+  const options = ts.getDefaultCompilerOptions()
+  let result: CompilerOptionsAndDiagnostics = { options, 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 (overrides) {
+    result = mergeResults(result, { options: overrides, errors: [] })
+  }
+
+  // Return all we have
+  return result
+}

package/src/report.ts

@@ -0,0 +1,80 @@
+import ts from 'typescript' // TypeScript does NOT support ESM modules
+import { ERROR, NOTICE, WARN } from '@plugjs/plug/logging'
+import { resolveAbsolutePath } from '@plugjs/plug/paths'
+
+import type { Report, ReportLevel, ReportRecord } from '@plugjs/plug/logging'
+import type { AbsolutePath } from '@plugjs/plug/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
+      // coverage ignore next / generally not emitted
+      case ts.DiagnosticCategory.Warning: level = WARN; break
+      // coverage ignore next / message and suggestion
+      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()
+
+      // coverage ignore else
+      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/typescript.ts

@@ -0,0 +1,137 @@
+// Reference ourselves, so that the constructor's parameters are correct
+/// <reference path="./index.ts"/>
+
+import ts from 'typescript' // TypeScript does NOT support ESM modules
+import { assertPromises, BuildFailure } from '@plugjs/plug/asserts'
+import { Files } from '@plugjs/plug/files'
+import { $p } from '@plugjs/plug/logging'
+import { resolveAbsolutePath, resolveFile } from '@plugjs/plug/paths'
+import { parseOptions, walk } from '@plugjs/plug/utils'
+
+import { TypeScriptHost } from './compiler'
+import { getCompilerOptions } from './options'
+import { updateReport } from './report'
+
+import type { AbsolutePath } from '@plugjs/plug/paths'
+import type { Context, PipeParameters, Plug } from '@plugjs/plug/pipe'
+import type { ExtendedCompilerOptions } from './index'
+
+
+/* ========================================================================== *
+ * WORKER PLUG                                                                *
+ * ========================================================================== */
+
+export 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)
+
+    /* The baseURL is resolved, as well */
+    if (overrides.outFile) overrides.outFile = context.resolve(overrides.outFile)
+
+    /* 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
+
+    /* 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) context.log.trace(`Compiling "${$p(path)}"`)
+    context.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)
+        context.log.debug(`Including extra type file "${$p(path)}"`)
+        paths.push(path)
+      }
+    }
+
+    /* Log out what we'll be our final compilation options */
+    context.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) => {
+        context.log.trace('Written', $p(file))
+      }).catch(/* coverage ignore next */ (error) => {
+        const outFile = resolveAbsolutePath(outDir, fileName)
+        context.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)
+    /* coverage ignore if / only on write errors */
+    if (report.errors) report.done(true)
+
+    /* All done, build our files and return it */
+    const outputs = builder.build()
+    context.log.info('TSC produced', outputs.length, 'files into', $p(outputs.directory))
+    return outputs
+  }
+}