@plugjs/plug 0.4.27 → 0.4.29

package/src/helpers.ts

@@ -2,11 +2,11 @@ import { mkdtempSync, readFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { assert, assertPromises } from './asserts'
+import { BuildFailure, assert, assertPromises } from './asserts'
 import { requireContext } from './async'
 import { Files } from './files'
 import { rm } from './fs'
-import { $p, log } from './logging'
+import { $gry, $p, $plur, $wht, $ylw, log } from './logging'
 import {
   commonPath,
   getAbsoluteParent,
@@ -16,6 +16,7 @@ import {
 } from './paths'
 import { PipeImpl } from './pipe'
 import { RunBuild } from './plugs/build'
+import { JsoncError, parseJsonc } from './utils'
 import { execChild } from './utils/exec'
 import { parseOptions } from './utils/options'
 import { walk } from './utils/walk'
@@ -260,11 +261,11 @@ export function exec(
 }
 
 /**
- * Read and parse a JSON file, throwing an error if not found.
+ * Read and parse a JSON/JSONC file, throwing an error if not found.
  *
  * @params file The JSON file to parse
  */
-export function parseJson(file: string): any {
+export function parseJson(file: string, strict: boolean = false): any {
   const jsonFile = requireContext().resolve(file)
   let jsonText: string
   try {
@@ -276,8 +277,19 @@ export function parseJson(file: string): any {
   }
 
   try {
-    return JSON.parse(jsonText)
+    return parseJsonc(jsonText, {
+      disallowComments: strict,
+      allowTrailingComma: ! strict,
+    })
   } catch (error) {
-    log.fail(`Error parsing ${$p(jsonFile)}`, error)
+    if (error instanceof JsoncError) {
+      const errors = error.errors
+      log.error(`Found ${$plur(errors.length, 'error', 'errors')} parsing ${$p(jsonFile)}`)
+      for (const e of errors) {
+        log.error(`  ${$wht(e.code)} ${$gry('at line')} ${$ylw(e.line)}${$gry(', column')} ${$ylw(e.column)}`)
+      }
+
+      throw new BuildFailure()
+    } else throw error
   }
 }

package/src/logging/colors.ts

@@ -127,3 +127,14 @@ export function $wht(string: any): string {
 export function $und(string: any): string {
   return colorize(und, string)
 }
+
+/** Pluralize (not really colors, but peace, love unity and respect). */
+export function $plur(number: number, singular: string, plural: string, colorize: boolean = _colors): string {
+  return colorize ?
+    number === 1 ?
+      `${$ylw(number)} ${singular}` :
+      `${$ylw(number)} ${plural}` :
+    number === 1 ?
+      `${number} ${singular}` :
+      `${number} ${plural}`
+}

package/src/logging/report.ts

@@ -1,9 +1,9 @@
 import { BuildFailure } from '../asserts'
 import { readFile } from '../fs'
-import { $blu, $cyn, $gry, $red, $und, $wht, $ylw } from './colors'
-import { ERROR, logLevels, NOTICE, WARN } from './levels'
-import { logOptions } from './options'
+import { $blu, $cyn, $gry, $plur, $red, $und, $wht, $ylw } from './colors'
 import { githubAnnotation } from './github'
+import { ERROR, NOTICE, WARN, logLevels } from './levels'
+import { logOptions } from './options'
 
 import type { AbsolutePath } from '../paths'
 import type { LogEmitter } from './emit'
@@ -427,12 +427,12 @@ export class ReportImpl implements Report {
 
     const status: any[] = [ 'Found' ]
     if (this.errors) {
-      status.push($red(this.errors), this.errors === 1 ? 'error' : 'errors' )
+      status.push($plur(this.errors, 'error', 'errors'))
     }
 
     if (this.warnings) {
       if (this.errors) status.push('and')
-      status.push($ylw(this.warnings), this.warnings === 1 ? 'warning' : 'warnings' )
+      status.push($plur(this.warnings, 'warning', 'warnings'))
     }
 
     if (this.errors || this.warnings) {

package/src/logging/spinner.ts

@@ -1,7 +1,7 @@
 /* coverage ignore file */
 
 import { runningTasks } from '../async'
-import { $cyn, $gry, $t } from './colors'
+import { $cyn, $gry, $plur, $t } from './colors'
 import { logOptions } from './options'
 
 /* ========================================================================== */
@@ -60,11 +60,11 @@ function spin(): void {
   const pad = ''.padStart(_taskLength, ' ')
   const names = tasks.map((task) => $t(task)).join($gry(', '))
 
-  const task = tasks.length > 1 ? 'tasks' : 'task'
+  const task = $plur(tasks.length, 'task', 'tasks')
 
   _nextSpin = (++ _nextSpin) % _spins.length
 
-  _output.write(`${zapSpinner}${pad} ${_spins[_nextSpin]}  Running ${tasks.length} ${task}: ${$gry(names)}`)
+  _output.write(`${zapSpinner}${pad} ${_spins[_nextSpin]}  Running ${task}: ${$gry(names)}`)
 }
 
 /* Start or stop the spinner */

package/src/types.ts

@@ -123,25 +123,11 @@ export type ThisBuild<D extends BuildDef> = {
     never
 }
 
-/**
- * Symbol indicating that an object is a {@link Build}.
- *
- * In a compiled {@link Build} this symbol will be associated with a function
- * taking an array of strings (task names) and record of props to override
- */
-export const buildMarker = Symbol.for('plugjs:plug:types:Build')
-
 /**
  * The {@link Build} type represents the collection of {@link Task}s
  * and _properties_ compiled from a {@link BuildDef | build definition}.
  */
-export type Build<D extends BuildDef = BuildDef> = Props<D> & Tasks<D> & {
-  readonly [buildMarker]: (
-    tasks: readonly string[],
-    props?: Record<string, string | undefined>,
-  ) => Promise<void>
-}
-
+export type Build<D extends BuildDef = BuildDef> = Props<D> & Tasks<D>
 /** A type identifying all _task names_ in a {@link Build}. */
 export type BuildTasks<B extends Build> = string & keyof {
   [ name in keyof B as B[name] extends Function ? name : never ] : any

package/src/utils/jsonc.ts

@@ -0,0 +1,62 @@
+import { EOL } from 'node:os'
+
+import { parse, printParseErrorCode } from 'jsonc-parser'
+
+import { $plur } from '../logging/colors'
+
+import type { ParseError } from 'jsonc-parser'
+
+export interface JsoncOptions {
+  disallowComments?: boolean;
+  allowTrailingComma?: boolean;
+}
+
+export class JsoncError extends Error {
+  constructor(public errors: { code: string, line: number, column: number } []) {
+    const message = [ `Found ${$plur(errors.length, 'error', 'errors', false)} parsing` ]
+
+    for (const { code, line, column } of errors) {
+      message.push(`  ${code} at line ${line}, column ${column}`)
+    }
+
+    super(message.join('\n'))
+  }
+}
+
+export function parseJsonc<T = any>(
+    data: string | null | undefined,
+    options: JsoncOptions = {},
+): T {
+  const { disallowComments = false, allowTrailingComma = true } = options
+
+  if (! data) return undefined as T
+  const errors: ParseError[] = []
+  const result = parse(data, errors, {
+    disallowComments,
+    allowTrailingComma,
+    allowEmptyContent: false,
+  })
+
+  if (errors.length === 0) return result
+
+  const offsets = data.split(EOL).reduce(({ offsets, offset }, line) => {
+    offset += line.length + EOL.length
+    offsets.push(offset)
+    return { offsets, offset }
+  }, { offset: 0, offsets: [ 0 ] }).offsets
+
+  function resolveOffset(offset: number): { line: number, column: number } {
+    for (let i = offsets.length - 1; i > 0; i--) {
+      const lineOffset = offsets[i]!
+      if (offset < lineOffset) continue
+      return { line: i + 1, column: offset - lineOffset + 1 }
+    }
+
+    return { line: 1, column: offset + 1 }
+  }
+
+  throw new JsoncError(errors.map((error) => {
+    const code = printParseErrorCode(error.error)
+    return { code, ...resolveOffset(error.offset) }
+  }))
+}

package/src/utils.ts

@@ -1,5 +1,6 @@
 export * from './utils/diff'
 export * from './utils/exec'
+export * from './utils/jsonc'
 export * from './utils/match'
 export * from './utils/options'
 export * from './utils/singleton'