@plugjs/plug 0.0.14 → 0.0.15

package/src/plugs/tsc/runner.ts

@@ -1,15 +1,14 @@
-import ts from 'typescript' // TypeScript does NOT support ESM modules
-
-import { failure } from '../../assert.js'
-import { Files } from '../../files.js'
-import { $p, log } from '../../log.js'
-import { AbsolutePath, resolveFile } from '../../paths.js'
-import { Plug } from '../../pipe.js'
-import { Run } from '../../run.js'
-import { parseOptions, ParseOptions } from '../../utils/options.js'
-import { TypeScriptHost } from './compiler.js'
-import { getCompilerOptions } from './options.js'
-import { updateReport } from './report.js'
+import ts from 'typescript'; // TypeScript does NOT support ESM modules
+
+import { failure } from '../../assert'
+import { Files } from '../../files'
+import { $p, log } from '../../log'
+import { AbsolutePath, resolveFile } from '../../paths'
+import { Context, PipeParameters, Plug } from '../../pipe'
+import { parseOptions } from '../../utils/options'
+import { TypeScriptHost } from './compiler'
+import { getCompilerOptions } from './options'
+import { updateReport } from './report'
 
 /* ========================================================================== *
  * WORKER PLUG                                                                *
@@ -19,20 +18,15 @@ export default class Tsc implements Plug<Files> {
   private readonly _tsconfig?: string
   private readonly _options: ts.CompilerOptions
 
-  constructor()
-  constructor(config: string)
-  constructor(options: ts.CompilerOptions)
-  constructor(config: string, options: ts.CompilerOptions)
-
-  constructor(...args: ParseOptions<ts.CompilerOptions>) {
+  constructor(...args: PipeParameters<'tsc'>) {
     const { params: [ tsconfig ], options } = parseOptions(args, {})
     this._tsconfig = tsconfig
     this._options = options
   }
 
-  async pipe(files: Files, run: Run): Promise<Files> {
-    const baseDir = run.resolve('.') // "this" directory, base of all relative paths
-    const report = run.report('TypeScript Report') // report used throughout
+  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 overrides = { ...this._options } // clone our options
 
     /*
@@ -40,13 +34,13 @@ export default class Tsc implements Plug<Files> {
      * alongside the sources, otherwise checked in the current directory.
      */
     const sourcesConfig = resolveFile(files.directory, 'tsconfig.json')
-    const tsconfig = this._tsconfig ? run.resolve(this._tsconfig) :
-      sourcesConfig || resolveFile(run.resolve('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 = run.resolve(overrides.rootDir)
+      rootDir = overrides.rootDir = context.resolve(overrides.rootDir)
     } else {
       rootDir = overrides.rootDir = files.directory
     }
@@ -54,24 +48,24 @@ export default class Tsc implements Plug<Files> {
     /* Output directory _also_ must always exist */
     let outDir: AbsolutePath
     if (overrides.outDir) {
-      outDir = overrides.outDir = run.resolve(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) => run.resolve(dir))
+      overrides.rootDirs = overrides.rootDirs.map((dir) => context.resolve(dir))
     }
 
     /* The baseURL is resolved, as well */
-    if (overrides.baseUrl) overrides.baseUrl = run.resolve(overrides.baseUrl)
+    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
-        run.buildFile, // the build file where the overrides were specified,
+        context.buildFile, // the build file where the overrides were specified,
         baseDir) // base dir where to resolve overrides
 
     /* Update report and fail on errors */
@@ -95,13 +89,13 @@ export default class Tsc implements Plug<Files> {
     if (report.errors) report.done(true)
 
     /* Write out all files asynchronously */
-    const builder = run.files(outDir)
+    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) => {
-        run.log.error('Error writing to', fileName, error)
+        context.log.error('Error writing to', fileName, error)
         throw failure() // no more logs!
       }))
     })

package/src/plugs/tsc.ts

@@ -0,0 +1,45 @@
+import type { CompilerOptions } from 'typescript'
+
+import { requireResolve } from '../paths'
+import { installForking } from '../pipe'
+
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Compiler}
+     * over the input source files, using the default `tsconfig.json` file.
+     */
+    tsc(): Pipe
+
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Compiler}
+     * over the input source files, specifying the `tsconfig.json` file.
+     *
+     * @param configFile The `tsconfig.json` file to use.
+     */
+    tsc(configFile: string): Pipe
+
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Compiler}
+     * over the input source files, using the default `tsconfig.json` file
+     * and overriding some options
+     *
+     * @param options {@link CompilerOptions | Options} overriding what's
+     *                currently specified in the default `tsconfig.json`.
+     */
+    tsc(options: CompilerOptions): Pipe
+
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Compiler}
+     * over the input source files, specifying the `tsconfig.json` file
+     * and overriding some options
+     *
+     * @param configFile The `tsconfig.json` file to use.
+     * @param options {@link CompilerOptions | Options} overriding what's
+     *                currently specified in the specified `tsconfig.json`.
+     */
+    tsc(configFile: string, options: CompilerOptions): Pipe
+  }
+}
+
+installForking('tsc', requireResolve(__fileurl, './tsc/runner'))

package/src/plugs.ts

@@ -2,33 +2,18 @@
  * FORKING PLUGS                                                              *
  * ========================================================================== */
 
-import { installForking } from './fork.js'
-import { requireResolve } from './paths.js'
-
-import type ESLint from './plugs/eslint/runner.js'
-import type Mocha from './plugs/mocha/runner.js'
-import type Tsc from './plugs/tsc/runner.js'
-
-declare module './pipe.js' {
-  export interface Pipe {
-    eslint: PipeExtension<typeof ESLint>
-    mocha: PipeExtension<typeof Mocha>
-    tsc: PipeExtension<typeof Tsc>
-  }
-}
-
-installForking('eslint', requireResolve(__fileurl, './plugs/eslint/runner'))
-installForking('mocha', requireResolve(__fileurl, './plugs/mocha/runner'))
-installForking('tsc', requireResolve(__fileurl, './plugs/tsc/runner'))
+export * from './plugs/eslint'
+export * from './plugs/mocha'
+export * from './plugs/tsc'
 
 /* ========================================================================== *
  * STANDARD IN-PROCESS PLUGS                                                  *
  * ========================================================================== */
 
-export * from './plugs/copy.js'
-export * from './plugs/coverage.js'
-export * from './plugs/debug.js'
-export * from './plugs/esbuild.js'
-export * from './plugs/exec.js'
-export * from './plugs/filter.js'
-export * from './plugs/rmf.js'
+export * from './plugs/copy'
+export * from './plugs/coverage'
+export * from './plugs/debug'
+export * from './plugs/esbuild'
+export * from './plugs/exec'
+export * from './plugs/filter'
+export * from './plugs/rmf'

package/src/types.ts

@@ -0,0 +1,123 @@
+import type { Files } from './files'
+import type { AbsolutePath } from './paths'
+import type { Pipe } from './pipe'
+
+/**
+ * A type describing the ultimate result of a {@link Plug}, {@link Pipe} or
+ * {@link Task}, that is either a {@link Files} instance or `undefined`.
+ */
+export type Result = Files | undefined
+
+/* ========================================================================== *
+ * STATE AND CONTEXT                                                          *
+ * ========================================================================== */
+
+/**
+ * The {@link State} interface defines a component tracking the current
+ * _state_ of a build, caching the result of {@link Task}s, and tracking their
+ * invocation stack to avoid infinite loops.
+ */
+export interface State {
+  /** The cache of the result of {@link Task}s execution */
+  readonly cache: Map<Task, Promise<Result>>
+  /** The current {@link Task} invocation stack (to avoid infinite loops) */
+  readonly stack: Task[],
+  /** All {@link Tasks} available in this {@link State} */
+  readonly tasks: Tasks
+  /** All _properties_ available in this {@link State} */
+  readonly props: Props
+}
+
+/* ========================================================================== *
+ * TASKS                                                                      *
+ * ========================================================================== */
+
+/**
+ * The {@link Task} interface normalizes a task definition, associating it with
+ * its build file, its sibling {@link Task}s and available _properties_.
+ */
+export interface Task<T extends Result = Result> {
+  /** All _properties_ siblings to this {@link Task} */
+  readonly props: Props
+  /** All {@link Tasks} sibling to this {@link Task} */
+  readonly tasks: Tasks
+  /** The absolute file name where this {@link Task} was defined */
+  readonly buildFile: AbsolutePath,
+  /** Invoke a task from (possibly) a different {@link Context} */
+  call(state: State, taskName: string): Promise<T>
+}
+
+/**
+ * The {@link TaskResult} type identifies _what_ can be returned by a
+ * {@link TaskDef | _task definition_}.
+ */
+export type TaskResult = Pipe | Promise<undefined> | Files | void | undefined
+
+/** The {@link TaskDef} type identifies the _definition_ of a task. */
+export type TaskDef<R extends TaskResult = TaskResult> = () => R | Promise<R>
+
+/* ========================================================================== *
+ * TASKS AND PROPERTIES                                                       *
+ * ========================================================================== */
+
+/** A type identifying all _properties_ of a {@link Context}. */
+export type Props<D extends BuildDef = BuildDef> = {
+  readonly [ k in string & keyof D as D[k] extends string ? k : never ] : string
+}
+
+/** A type identifying all _tasks_ in a {@link Context} */
+export type Tasks<D extends BuildDef = BuildDef> = {
+  readonly [ k in string & keyof D as D[k] extends TaskDef | Task ? k : never ] :
+    D[k] extends TaskDef<infer R> ?
+      R extends void | undefined ? Task<undefined> :
+      R extends Promise<undefined> ? Task<undefined> :
+      R extends Pipe ? Task<Files> :
+      R extends Files ? Task<Files> :
+      never :
+    D[k] extends Task ? D[k] :
+    never
+}
+
+/* ========================================================================== *
+ * BUILD                                                                      *
+ * ========================================================================== */
+
+/**
+ * The {@link BuildDef} interface describes the _definition_ of a
+ * {@link Context}, that is the object passed to {@link build} to produce
+ * a {@link Build}.
+ */
+export interface BuildDef {
+  [ k : string ] : string | TaskDef | Task
+}
+
+/**
+ * The type that will be used for `this` when invoking
+ * {@link TaskDef | task definitions }.
+ */
+export type ThisBuild<D extends BuildDef> = {
+  readonly [ k in keyof D ] :
+    k extends string ?
+      D[k] extends TaskDef<infer R> ?
+        R extends Promise<undefined> | void | undefined ? () => Promise<undefined> :
+        R extends Pipe | Files ? () => Pipe & Promise<Files> :
+        never :
+      D[k] extends Task<infer R> ?
+        R extends undefined ? () => Promise<undefined> :
+        R extends Files ? () => Pipe & Promise<Files> :
+        never :
+      D[k] extends string ?
+        string :
+      never :
+    never
+}
+
+/**
+ * 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,
+  T extends Tasks<D> = Tasks<D>,
+  P extends Props<D> = Props<D>,
+> = T & P

package/src/utils/caller.ts

@@ -1,44 +1,33 @@
 import { statSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { assert } from '../assert.js'
-import { AbsolutePath, assertAbsolutePath } from '../paths.js'
+import { assert } from '../assert'
+import { $p } from '../log'
+import { AbsolutePath, assertAbsolutePath } from '../paths'
 
-export interface Location {
-  file: AbsolutePath,
-  line?: number | undefined,
-  column?: number | undefined,
-}
-
-export function findCaller(of: (...args: any[]) => any): Location {
+export function findCaller(of: (...args: any[]) => any): AbsolutePath {
   const oldPrepareStackTrace = Error.prepareStackTrace
 
   try {
-    Error.prepareStackTrace = (_, stackTraces): Location | undefined => {
+    Error.prepareStackTrace = (_, stackTraces): AbsolutePath | undefined => {
       const nullableFileOrUrl = stackTraces[0].getFileName()
       if (! nullableFileOrUrl) return
 
-      const nullableLine = stackTraces[0].getColumnNumber()
-      const nullableColumn = stackTraces[0].getColumnNumber()
-
-      const line = typeof nullableLine === 'number' ? nullableLine : undefined
-      const column = typeof nullableColumn === 'number' ? nullableColumn : undefined
-
       const file =
         nullableFileOrUrl.startsWith('file:/') ?
           fileURLToPath(nullableFileOrUrl) :
           nullableFileOrUrl
 
       assertAbsolutePath(file)
-      return { file, line, column }
+      return file
     }
 
-    const record: { stack?: Location } = {}
+    const record: { stack?: AbsolutePath } = {}
     Error.captureStackTrace(record, of)
-    const location = record.stack
+    const file = record.stack
 
-    assert(location, 'Unable to determine build file name')
-    assert(statSync(location.file).isFile(), `Build file "${location.file}" not found`)
-    return location
+    assert(file, 'Unable to determine build file name')
+    assert(statSync(file).isFile(), `Build file ${$p(file)} not found`)
+    return file
   } finally {
     Error.prepareStackTrace = oldPrepareStackTrace
   }

package/src/utils/options.ts

@@ -1,22 +1,54 @@
-export type ParsedOptions<Options> = { params: string[], options: Options }
-export type ParsedOptionalOptions<Options> = { params: string[], options?: Options | undefined }
-export type ParseOptions<Options> = string[] | [ ...string[], Options ] | [ Options ]
-
-/** Parse an array of at least one string, followed by an optional `Options` argument. */
-export function parseOptions<Options>(args: ParseOptions<Options>): ParsedOptionalOptions<Options>
-/** Parse an array of at least one string, followed by an optional `Options` argument. */
-export function parseOptions<Options>(args: ParseOptions<Options>, defaults?: undefined): ParsedOptionalOptions<Options>
-/** Parse an array of at least one string, followed by an optional `Options` argument, ensuring some defaults are present. */
-export function parseOptions<Options, Defaults extends Options>(args: ParseOptions<Options>, defaults: Defaults): ParsedOptions<Options & Defaults>
-// overloaded implementation
-export function parseOptions<Options, Defaults extends Options>(args: ParseOptions<Options>, defaults?: Defaults): ParsedOptions<any> {
+/** A type extacting string parameters from an arguments array */
+export type ParsedParams<Args extends readonly any[]> =
+  // Normal tuple, we stop processing if the _first_ argument is not a string!
+  Args extends readonly [ infer First, ...infer Rest ] ?
+    First extends string ? [ First, ...ParsedParams<Rest> ] : [] :
+
+  // If not caught above, here "first" is the rest parameter in the tuple
+  Args extends readonly [ ...infer First, infer Rest ] ?
+    Rest extends string ? [ ...ParsedParams<First>, Rest ] : [ ...ParsedParams<First> ] :
+
+  // Not a tuple: normal string array or the end of our arguments
+  Args extends readonly string[] ? [ ...Args ] : []
+
+/** A type extacting the (last) options type from an arguments array */
+export type ParsedOptions<Args extends readonly any[]> = // , Defaults> =
+  Args extends readonly [ ...string[], infer Last ] ?
+    Last extends object ? // Record<any, any> ?
+      Last : // last arg is a record, defaults is null or undefined
+      never : // last arg is a string, defaults is null or undefined
+  never // args is not an array
+
+/** Parserable arguments: a number of strings, followed by optional options */
+export type ParseOptions<Options extends Record<any, any>> =
+  readonly [ ...params: string[] ] | readonly [ ...params: string[], options: Options ]
+
+/** The return type from {@link ParseOptions} */
+export interface ParsedResult<Args extends readonly any [], Options, Defaults> {
+  params: ParsedParams<Args>,
+  options: Defaults extends null | undefined ? Options | undefined : Options & Defaults
+}
+
+/**
+ * Parse an array of arguments (a number of strings optionally followed by an
+ * options object into parameters and options.
+ */
+export function parseOptions<
+  Args extends ParseOptions<any>,
+  Options extends ParsedOptions<Args> = ParsedOptions<Args>,
+  Defaults extends ParsedOptions<Args> | null | undefined = undefined,
+>(args: Args, defaults?: Defaults): ParsedResult<Args, Options, Defaults> {
   const params: string[] = []
-  const options: any = { ...defaults }
+  const clone: any[] = [ ...args ]
 
-  for (const arg of args) {
-    if (typeof arg === 'string') params.push(arg)
-    else Object.assign(options, arg)
+  // Collect all strings at the beginning of our arguments array
+  while (typeof clone[0] === 'string') {
+    params.push(clone.shift())
   }
 
-  return { params, options }
+  // The options is the _last_ element in our arguments array (if any)
+  const options = Object.assign({}, defaults, clone.pop())
+
+  // All done
+  return { params, options } as ParsedResult<Args, Options, Defaults>
 }

package/src/utils/walk.ts

@@ -1,9 +1,9 @@
 import { Dir } from 'node:fs'
 import { basename, join } from 'node:path'
-import { $p, log } from '../log.js'
-import { AbsolutePath, resolveAbsolutePath } from '../paths.js'
-import { opendir, stat } from './asyncfs.js'
-import { match, MatchOptions } from './match.js'
+import { $p, log } from '../log'
+import { AbsolutePath, resolveAbsolutePath } from '../paths'
+import { opendir, stat } from './asyncfs'
+import { match, MatchOptions } from './match'
 
 /** Specific options for walking a directory */
 export interface WalkOptions extends MatchOptions {

package/dist/run.cjs

@@ -1,90 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// run.ts
-var run_exports = {};
-__export(run_exports, {
-  RunImpl: () => RunImpl
-});
-module.exports = __toCommonJS(run_exports);
-var import_node_path = require("node:path");
-var import_files = require("./files.cjs");
-var import_log = require("./log.cjs");
-var import_paths = require("./paths.cjs");
-var import_pipe = require("./pipe.cjs");
-var import_options = require("./utils/options.cjs");
-var import_walk = require("./utils/walk.cjs");
-var RunImpl = class {
-  taskName;
-  buildFile;
-  buildDir;
-  log;
-  constructor({ taskName, buildDir, buildFile, log }) {
-    this.taskName = taskName;
-    this.buildDir = buildDir;
-    this.buildFile = buildFile;
-    this.log = log || (0, import_log.getLogger)(taskName);
-  }
-  setLogLevel(level) {
-    this.log.level = (0, import_log.getLevelNumber)(level);
-  }
-  report(title) {
-    return (0, import_log.createReport)(title, this.taskName);
-  }
-  resolve(path, ...paths) {
-    if (path && path.startsWith("@")) {
-      const components = path.substring(1).split(import_node_path.sep).filter((s) => !!s);
-      return (0, import_paths.resolveAbsolutePath)(this.buildDir, ...components, ...paths);
-    }
-    if (!path)
-      return (0, import_paths.getCurrentWorkingDirectory)();
-    return (0, import_paths.resolveAbsolutePath)((0, import_paths.getCurrentWorkingDirectory)(), path, ...paths);
-  }
-  files(first, ...paths) {
-    if (typeof first === "string") {
-      return import_files.Files.builder(this.resolve(first, ...paths));
-    } else if (first) {
-      return import_files.Files.builder(first);
-    } else {
-      return import_files.Files.builder(this.resolve());
-    }
-  }
-  find(glob, ...args) {
-    const { params, options: { directory, ...options } } = (0, import_options.parseOptions)(args, {});
-    const promise = Promise.resolve().then(async () => {
-      const builder = this.files(directory || ".");
-      for await (const file of (0, import_walk.walk)(builder.directory, [glob, ...params], options)) {
-        builder.unchecked(file);
-      }
-      return builder.build();
-    });
-    return this.pipe(promise);
-  }
-  pipe(files) {
-    return new import_pipe.PipeImpl(files, this);
-  }
-  call(name) {
-    throw new Error(`Unable to call task "${name}"`);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RunImpl
-});
-//# sourceMappingURL=run.cjs.map

package/dist/run.cjs.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/run.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAoB;AACpB,mBAAoC;AACpC,iBAAwF;AACxF,mBAA8E;AAC9E,kBAA+B;AAC/B,qBAA2C;AAC3C,kBAAkC;AAgF3B,IAAM,UAAN,MAA6B;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAIT,YAAY,EAAE,UAAU,UAAU,WAAW,IAAI,GAA2B;AAC1E,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,YAAY;AACjB,SAAK,MAAM,WAAO,sBAAU,QAAQ;AAAA,EACtC;AAAA,EAGA,YAAY,OAA6B;AACvC,SAAK,IAAI,YAAQ,2BAAe,KAAK;AAAA,EACvC;AAAA,EAEA,OAAO,OAAuB;AAC5B,eAAO,yBAAa,OAAO,KAAK,QAAQ;AAAA,EAC1C;AAAA,EAEA,QAAQ,SAAkB,OAA+B;AAEvD,QAAI,QAAQ,KAAK,WAAW,GAAG,GAAG;AAEhC,YAAM,aAAa,KAAK,UAAU,CAAC,EAAE,MAAM,oBAAG,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AACjE,iBAAO,kCAAoB,KAAK,UAAU,GAAG,YAAY,GAAG,KAAK;AAAA,IACnE;AAGA,QAAI,CAAE;AAAM,iBAAO,yCAA2B;AAG9C,eAAO,sCAAoB,yCAA2B,GAAG,MAAM,GAAG,KAAK;AAAA,EACzE;AAAA,EAIA,MAAM,UAAsC,OAA+B;AACzE,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,mBAAM,QAAQ,KAAK,QAAQ,OAAO,GAAG,KAAK,CAAC;AAAA,IACpD,WAAW,OAAO;AAChB,aAAO,mBAAM,QAAQ,KAAK;AAAA,IAC5B,OAAO;AACL,aAAO,mBAAM,QAAQ,KAAK,QAAQ,CAAC;AAAA,IACrC;AAAA,EACF;AAAA,EAEA,KAAK,SAAiB,MAAwD;AAC5E,UAAM,EAAE,QAAQ,SAAS,EAAE,cAAc,QAAQ,EAAE,QAAI,6BAAa,MAAM,CAAC,CAAC;AAE5E,UAAM,UAAU,QAAQ,QAAQ,EAAE,KAAK,YAAY;AACjD,YAAM,UAAU,KAAK,MAAM,aAAa,GAAG;AAC3C,uBAAiB,YAAQ,kBAAK,QAAQ,WAAW,CAAE,MAAM,GAAG,MAAO,GAAG,OAAO,GAAG;AAC9E,gBAAQ,UAAU,IAAI;AAAA,MACxB;AACA,aAAO,QAAQ,MAAM;AAAA,IACvB,CAAC;AAED,WAAO,KAAK,KAAK,OAAO;AAAA,EAC1B;AAAA,EAEA,KAAK,OAAsD;AACzD,WAAO,IAAI,qBAAS,OAAO,IAAI;AAAA,EACjC;AAAA,EAEA,KAAK,MAA0C;AAC7C,UAAM,IAAI,MAAM,wBAAwB,OAAO;AAAA,EACjD;AACF;",
-  "names": []
-}

package/dist/run.d.ts

@@ -1,89 +0,0 @@
-import { Files, FilesBuilder } from './files.js';
-import { Logger, LogLevelString, Report } from './log.js';
-import { AbsolutePath } from './paths.js';
-import { Pipe } from './pipe.js';
-import { ParseOptions } from './utils/options.js';
-import { WalkOptions } from './utils/walk.js';
-/** The {@link FindOptions} interface defines the options for finding files. */
-export interface FindOptions extends WalkOptions {
-    /**
-     * The directory where to start looking for files according to the rules
-     * specified in {@link Run.resolve}.
-     */
-    directory?: string;
-}
-/**
- * The {@link Run} interface defines the context in which a {@link Task} is
- * invoked.
- *
- * Runs keep track of the invocation stack (to avoid circular dependencies) and
- * of the cached results for {@link Task} invocations.
- */
-export interface Run {
-    /**
-     * The _name_ of the task associated with this {@link Run} (if one is).
-     *
-     * Tasks can have different names in different builds, this refers to the
-     * _task name_ in the build being executed.
-     */
-    readonly taskName: string;
-    /** The absolute file name of the build */
-    readonly buildFile: AbsolutePath;
-    /** For convenience, the directory of the build file */
-    readonly buildDir: AbsolutePath;
-    /** The {@link Logger} associated with this instance. */
-    readonly log: Logger;
-    /** Set the logging level within this {@link Run} */
-    setLogLevel(level: LogLevelString): void;
-    /** Call another {@link Task} from this one. */
-    call(name: string): Promise<Files | undefined>;
-    /** Create a new {@link Report} with the given _title_ */
-    report(title: string): Report;
-    /**
-     * Resolve a path in the context of this {@link Run}.
-     *
-     * If the path starts with `@...` it is considered to be relative to the
-     * _directory containing the build file where the task was defined_, otherwise
-     * it will be relative to the {@link process.cwd | current working directory}.
-     */
-    resolve(...paths: string[]): AbsolutePath;
-    /** Create a {@link FilesBuilder} cloning an existing {@link Files}. */
-    files(files: Files): FilesBuilder;
-    /**
-     * Create a {@link FilesBuilder} instance resolving the directory specified
-     * according to the rules specified in {@link Run.resolve}.
-     */
-    files(...paths: string[]): FilesBuilder;
-    /**
-     * Find files according to the globs and {@link FindOptions} specified.
-     */
-    find(glob: string, ...args: ParseOptions<FindOptions>): Pipe & Promise<Files>;
-    /**
-     * Create a new {@link Pipe} wrapping the specified {@link Files}.
-     */
-    pipe(files: Files | Promise<Files>): Pipe & Promise<Files>;
-}
-/** Constructor options for our default {@link Run} implementation */
-export interface RunConstructionOptions {
-    readonly taskName: string;
-    readonly buildDir: AbsolutePath;
-    readonly buildFile: AbsolutePath;
-    readonly log?: Logger;
-}
-/** Our default {@link Run} implementation */
-export declare class RunImpl implements Run {
-    readonly taskName: string;
-    readonly buildFile: AbsolutePath;
-    readonly buildDir: AbsolutePath;
-    readonly log: Logger;
-    constructor(options: RunConstructionOptions);
-    /** Set the logging level within this {@link Run} */
-    setLogLevel(level: LogLevelString): void;
-    report(title: string): Report;
-    resolve(path?: string, ...paths: string[]): AbsolutePath;
-    files(files: Files): FilesBuilder;
-    files(...paths: string[]): FilesBuilder;
-    find(glob: string, ...args: ParseOptions<FindOptions>): Pipe & Promise<Files>;
-    pipe(files: Files | Promise<Files>): Pipe & Promise<Files>;
-    call(name: string): Promise<Files | undefined>;
-}