@plugjs/plug 0.0.12 → 0.0.15

package/dist/task.mjs

@@ -1,14 +0,0 @@
-// task.ts
-var TaskImpl = class {
-  constructor(context, _definition) {
-    this.context = context;
-    this._definition = _definition;
-  }
-  async call(self, run) {
-    return await this._definition.call(self, self, run) || void 0;
-  }
-};
-export {
-  TaskImpl
-};
-//# sourceMappingURL=task.mjs.map

package/dist/task.mjs.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/task.ts"],
-  "mappings": ";AAgBO,IAAM,WAAN,MAAkD;AAAA,EACvD,YACa,SACQ,aACnB;AAFW;AACQ;AAAA,EAClB;AAAA,EAEH,MAAM,KAAK,MAAsB,KAAsC;AACrE,WAAQ,MAAM,KAAK,YAAY,KAAK,MAAM,MAAM,GAAG,KAAM;AAAA,EAC3D;AACF;",
-  "names": []
-}

package/src/run.ts

@@ -1,159 +0,0 @@
-import { sep } from 'node:path'
-import { Files, FilesBuilder } from './files.js'
-import { createReport, getLevelNumber, getLogger, Logger, LogLevelString, Report } from './log.js'
-import { AbsolutePath, getCurrentWorkingDirectory, resolveAbsolutePath } from './paths.js'
-import { Pipe, PipeImpl } from './pipe.js'
-import { ParseOptions, parseOptions } from './utils/options.js'
-import { walk, 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 class RunImpl implements Run {
-  readonly taskName: string
-  readonly buildFile: AbsolutePath
-  readonly buildDir: AbsolutePath
-  readonly log: Logger
-
-  constructor(options: RunConstructionOptions)
-
-  constructor({ taskName, buildDir, buildFile, log }: RunConstructionOptions) {
-    this.taskName = taskName
-    this.buildDir = buildDir
-    this.buildFile = buildFile
-    this.log = log || getLogger(taskName)
-  }
-
-  /** Set the logging level within this {@link Run} */
-  setLogLevel(level: LogLevelString): void {
-    this.log.level = getLevelNumber(level)
-  }
-
-  report(title: string): Report {
-    return createReport(title, this.taskName)
-  }
-
-  resolve(path?: string, ...paths: string[]): AbsolutePath {
-    // Paths starting with "@" are relative to the build file directory
-    if (path && path.startsWith('@')) {
-      // We can have paths like "@/../foo/bar" or "@../foo/bar"... both are ok
-      const components = path.substring(1).split(sep).filter((s) => !!s)
-      return resolveAbsolutePath(this.buildDir, ...components, ...paths)
-    }
-
-    // No path? Resolve to the CWD!
-    if (! path) return getCurrentWorkingDirectory()
-
-    // For all the rest, normal resolution!
-    return resolveAbsolutePath(getCurrentWorkingDirectory(), path, ...paths)
-  }
-
-  files(files: Files): FilesBuilder
-  files(...paths: string[]): FilesBuilder
-  files(first: Files | string | undefined, ...paths: string[]): FilesBuilder {
-    if (typeof first === 'string') {
-      return Files.builder(this.resolve(first, ...paths))
-    } else if (first) {
-      return Files.builder(first)
-    } else {
-      return Files.builder(this.resolve())
-    }
-  }
-
-  find(glob: string, ...args: ParseOptions<FindOptions>): Pipe & Promise<Files> {
-    const { params, options: { directory, ...options } } = parseOptions(args, {})
-
-    const promise = Promise.resolve().then(async () => {
-      const builder = this.files(directory || '.')
-      for await (const file of walk(builder.directory, [ glob, ...params ], options)) {
-        builder.unchecked(file)
-      }
-      return builder.build()
-    })
-
-    return this.pipe(promise)
-  }
-
-  pipe(files: Files | Promise<Files>): Pipe & Promise<Files> {
-    return new PipeImpl(files, this)
-  }
-
-  call(name: string): Promise<Files | undefined> {
-    throw new Error(`Unable to call task "${name}"`)
-  }
-}

package/src/task.ts

@@ -1,26 +0,0 @@
-import type { BuildContext, TaskDefinition, ThisBuild } from './build.js'
-import type { Files } from './files.js'
-import type { Run } from './run.js'
-
-/* ========================================================================== *
- * TASK                                                                       *
- * ========================================================================== */
-
-export interface Task<T extends Files | undefined = Files | undefined> {
-  /** The {@link BuildContext} of where this task was originally defined */
-  readonly context: BuildContext
-
-  /** Invoked by the {@link Run} when actually executing this {@link Task} */
-  call(thisBuild: ThisBuild<any>, run: Run): Promise<T>
-}
-
-export class TaskImpl implements Task<Files | undefined> {
-  constructor(
-      readonly context: BuildContext,
-      private readonly _definition: TaskDefinition<any>,
-  ) {}
-
-  async call(self: ThisBuild<any>, run: Run): Promise<Files | undefined> {
-    return (await this._definition.call(self, self, run)) || undefined
-  }
-}

package/types/async.d.ts

@@ -1,20 +0,0 @@
-import { Run } from './run.js';
-/**
- * Run the specified `callback` associating the specified {@link Run} and task
- * name with the current asynchronous invocation context.
- */
-export declare function runAsync<T>(run: Run, task: string, callback: () => Promise<T>): Promise<T>;
-/**
- * Returns the _task name_ associated with the current asynchronous invocation
- * context or `undefined`.
- */
-export declare function currentTask(): string | undefined;
-/**
- * Returns the {@link Run} associated with the current asynchronous invocation
- * context or `undefined`.
- */
-export declare function currentRun(): Run | undefined;
-/**
- * Return an array of all _task names_ currently running
- */
-export declare function runningTasks(): string[];

package/types/build.d.ts

@@ -1,56 +0,0 @@
-import { Files } from './files.js';
-import { AbsolutePath } from './paths.js';
-import { Pipe } from './pipe.js';
-import { Run } from './run.js';
-import { Task } from './task.js';
-/**
- * The {@link BuildContext} interface exposes the _internal_ representation of
- * a build file, including all {@link Task | Tasks}.
- */
-export declare type BuildContext = {
-    /** The absolute file name of the build */
-    readonly buildFile: AbsolutePath;
-    /** For convenience, the directory of the build file */
-    readonly buildDir: AbsolutePath;
-    /** A record of all tasks keyed by name */
-    readonly tasks: Readonly<Record<string, Task>>;
-};
-/**
- * A {@link TaskDefinition} is a _function_ defining a {@link Task}.
- */
-export declare type TaskDefinition<B> = (this: ThisBuild<B>, self: ThisBuild<B>, run: Run) => Files | undefined | void | Promise<Files | undefined | void>;
-/**
- * A {@link TaskCall} describes a _function_ calling a {@link Task}, and
- * it is exposed to outside users of the {@link Build}.
- */
-export declare type TaskCall<T extends Files | undefined> = ((run?: Run) => Promise<Run>) & {
-    readonly task: Task<T>;
-};
-/**
- * A {@link Build} is a collection of {@link TaskCall | TaskCalls}, as produced
- * by the {@link build} function from a {@link BuildDefinition}.
- */
-export declare type Build<B> = {
-    [K in keyof B]: B[K] extends TaskCall<infer T> ? TaskCall<T> : B[K] extends () => Files | Promise<Files> ? TaskCall<Files> : B[K] extends () => undefined | void | Promise<undefined | void> ? TaskCall<undefined> : never;
-};
-/**
- * The type supplied as `this` to a {@link TaskDefinition} when invoking it.
- */
-export declare type ThisBuild<B> = {
-    [K in keyof B]: B[K] extends () => Files | Promise<Files> ? () => Pipe & Promise<Files> : B[K] extends () => undefined | void | Promise<undefined | void> ? () => Promise<undefined> : B[K] extends TaskCall<infer T> ? () => T : never;
-};
-/**
- * A {@link BuildDefinition} is a collection of
- * {@link TaskDefinition | TaskDefinitions} that the {@link build} function will
- * use to create a {@link Build}.
- *
- * A {@link BuildDefinition} can also include other {@link TaskCall | TaskCalls},
- * thus giving the ability to extend other {@link Build | Builds}.
- */
-export declare type BuildDefinition<B> = {
-    [K in keyof B]: TaskDefinition<B> | TaskCall<Files | undefined>;
-};
-/** Check if the specified build is actually a {@link Build} */
-export declare function isBuild(build: any): build is Build<any>;
-/** Create a new {@link Build} from its {@link BuildDefinition}. */
-export declare function build<D extends BuildDefinition<D>>(definition: D & ThisType<ThisBuild<D>>): Build<D>;

package/types/fork.d.ts

@@ -1,57 +0,0 @@
-import { Files } from './files.js';
-import { LogOptions } from './log.js';
-import { AbsolutePath } from './paths.js';
-import { Plug, PlugName } from './pipe.js';
-import { Run } from './run.js';
-/** Fork data, from parent to child process */
-export interface ForkData {
-    /** Script name for the Plug to execute */
-    scriptFile: AbsolutePath;
-    /** Plug constructor arguments */
-    constructorArgs: any[];
-    /** Task name (for logs) */
-    taskName: string;
-    /** Build file name */
-    buildFile: AbsolutePath;
-    /** Build directory */
-    buildDir: AbsolutePath;
-    /** Files directory */
-    filesDir: AbsolutePath;
-    /** All files to pipe */
-    filesList: AbsolutePath[];
-    /** Options for our logger in the child process */
-    logOpts: Partial<LogOptions>;
-}
-/** Fork result, from child to parent process */
-export interface ForkResult {
-    /** If this is `true` we _might_ have `filesDir` and `filesList` */
-    failed: boolean;
-    /** Files directory of the result */
-    filesDir?: AbsolutePath | undefined;
-    /** All files returned by the plug */
-    filesList?: AbsolutePath[] | undefined;
-}
-/**
- * Install a _forking_ {@link Plug} in the {@link Pipe}, in other words
- * execute the plug in a separate process.
- *
- * As a contract, if the _last non-null_ parameter of the constructor is an
- * object and contains the key `coverageDir`, the process will be forked with
- * the approptiately resolved `NODE_V8_COVERAGE` environment variable.
- *
- * Also, forking plugs require some special attention:
- *
- * * plug functions are not supported, only classes implementing the
- *   {@link Plug} interface can be used with this.
- *
- * * the class itself _MUST_ be exported as the _default_ export for the
- *   `scriptFile` specified below. This is to simplify interoperability between
- *   CommonJS and ESM modules as we use dynamic `import(...)` statements.
- */
-export declare function installForking(plugName: PlugName, scriptFile: AbsolutePath): void;
-export declare abstract class ForkingPlug implements Plug<Files | undefined> {
-    private readonly _scriptFile;
-    private readonly _arguments;
-    constructor(_scriptFile: AbsolutePath, _arguments: any[]);
-    pipe(files: Files, run: Run): Promise<Files | undefined>;
-}

package/types/helpers.d.ts

@@ -1,43 +0,0 @@
-import { AbsolutePath } from './paths.js';
-import { Files, FilesBuilder } from './files.js';
-import { LogLevelString } from './log.js';
-import { Pipe } from './pipe.js';
-import { FindOptions } from './run.js';
-import { ParseOptions } from './utils/options.js';
-/**
- * Recursively remove the specified directory _**(use with care)**_.
- */
-export declare function rmrf(directory: string): Promise<void>;
-/**
- * Set the current _log level_.
- *
- * The _level_ will be applied _only_ within the execution of the current task.
- */
-export declare function setLogLevel(level: LogLevelString): void;
-/**
- * Resolve a path into an {@link AbsolutePath}.
- *
- * 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}.
- */
-export declare function resolve(...paths: string[]): AbsolutePath;
-/**
- * Create a new {@link Files} instance.
- */
-export declare function files(files: Files): FilesBuilder;
-export declare function files(directory: string, ...paths: string[]): FilesBuilder;
-/**
- * Merge multiple {@link Files} instance.
- */
-export declare function merge(args: (Files | Promise<Files>)[]): Promise<Files> & Pipe;
-/**
- * Find files according to the globs and {@link FindOptions} specified.
- */
-export declare function find(glob: string, ...args: ParseOptions<FindOptions>): Pipe & Promise<Files>;
-/** Create a {@link Pipe} from a {@link Files} instance. */
-export declare function pipe(files: Files | Promise<Files>): Pipe & Promise<Files>;
-/** Return an absolute path of the file if it exist on disk */
-export declare function isFile(...paths: string[]): AbsolutePath | undefined;
-/** Return an absolute path of the file if it exist on disk */
-export declare function isDirectory(...paths: string[]): AbsolutePath | undefined;

package/types/index.d.ts

@@ -1,14 +0,0 @@
-/// <reference path="../extra/webassembly.d.ts" />
-export * from './assert.js';
-export * from './build.js';
-export * from './plugs.js';
-export * from './log.js';
-export * from './helpers.js';
-export type { MatchOptions, MatchResult } from './utils/match.js';
-export type { ParseOptions } from './utils/options.js';
-export type { WalkOptions } from './utils/walk.js';
-export type { AbsolutePath } from './paths.js';
-export type { Files, FilesBuilder } from './files.js';
-export type { FindOptions, Run } from './run.js';
-export type { Pipe, Plug, PlugFunction } from './pipe.js';
-export type { Task } from './task.js';

package/types/pipe.d.ts

@@ -1,152 +0,0 @@
-import { Files } from './files.js';
-import { Run } from './run.js';
-/**
- * The {@link Plug} interface describes an extension mechanism for our build.
- */
-export interface Plug<T extends Files | undefined> {
-    pipe(files: Files, run: Run): T | Promise<T>;
-}
-/**
- * A type identifying a {@link Plug} as a `function`
- */
-export declare type PlugFunction<T extends Files | undefined> = Plug<T>['pipe'];
-/**
- * A {@link Pipe} represents a sequence of operations performed by
- * a series of {@link Plug | Plugs}.
- */
-export interface Pipe {
-}
-/**
- * The {@link Pipe} abstract class exposes the prototype upon which all
- * extension plugs will be installed on.
- */
-export declare abstract class Pipe implements Pipe {
-    abstract plug(plug: Plug<Files> | PlugFunction<Files>): Pipe & Promise<Files>;
-    abstract plug(plug: Plug<undefined> | PlugFunction<undefined>): Promise<undefined>;
-}
-/** Implementation of our {@link Pipe}. */
-export declare class PipeImpl<T extends Files | undefined> extends Pipe implements Promise<T> {
-    #private;
-    constructor(start: T | Promise<T>, run: Run);
-    plug<T extends Files | undefined>(arg: Plug<T> | PlugFunction<T>): Pipe & Promise<T>;
-    then<T1 = T, T2 = never>(onfulfilled?: ((value: T) => T1 | PromiseLike<T1>) | null | undefined, onrejected?: ((reason: any) => T2 | PromiseLike<T2>) | null | undefined): Promise<T1 | T2>;
-    catch<T0 = never>(onrejected?: ((reason: any) => T0 | PromiseLike<T0>) | null | undefined): Promise<T0 | T>;
-    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
-    [Symbol.toStringTag]: string;
-}
-/** The names which can be installed as direct plugs. */
-export declare type PlugName = string & Exclude<keyof Pipe, 'plug' | keyof Promise<Files>>;
-/** A convenience type identifying a {@link Plug} constructor. */
-export declare type PlugConstructor = new (...args: any) => Plug<Files | undefined>;
-/** Convert the resulting type of a {@link Plug} for use in a {@link Pipe} */
-declare type PlugReturnForPipe<T> = T extends Plug<infer R> ? R extends Files ? Promise<Files> & Pipe : R extends undefined ? Promise<undefined> : never : never;
-/**
- * Map constructors into an array of all known overloads.
- *
- * This is a _royal_ pain in the ass, as we need to distinguish between
- * all possible number of overloads of a constructor... Limit to 5 of them!
- *
- * Also, the empty constructor (when specified in the overloads) will simply
- * match the first case (most overloads) and generate functions somewhat like
- *
- * (...args: unknown[]) => never
- * (...args: unknown[]) => never
- * (...args: unknown[]) => never
- * () => PlugReturnForPipe<R3>
- * (arg: Options) => PlugReturnForPipe<R4>
- *
- * Somehow inferring the result to `Function` or the right type and ANDing all
- * those together here doesn't work, so we create this array and we'll AND
- * all its members in the PipeExtension<...> type.
- */
-declare type PlugConstructorOverloads<T extends PlugConstructor> = T extends {
-    new (...args: infer A0): infer R0;
-    new (...args: infer A1): infer R1;
-    new (...args: infer A2): infer R2;
-    new (...args: infer A3): infer R3;
-    new (...args: infer A4): infer R4;
-} ? [
-    R0 extends Plug<Files | undefined> ? ((...args: A0) => PlugReturnForPipe<R0>) : Function,
-    R1 extends Plug<Files | undefined> ? ((...args: A1) => PlugReturnForPipe<R1>) : Function,
-    R2 extends Plug<Files | undefined> ? ((...args: A2) => PlugReturnForPipe<R2>) : Function,
-    R3 extends Plug<Files | undefined> ? ((...args: A3) => PlugReturnForPipe<R3>) : Function,
-    R4 extends Plug<Files | undefined> ? ((...args: A4) => PlugReturnForPipe<R4>) : Function
-] : T extends {
-    new (...args: infer A0): infer R0;
-    new (...args: infer A1): infer R1;
-    new (...args: infer A2): infer R2;
-    new (...args: infer A3): infer R3;
-} ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function,
-    R2 extends Plug<Files | undefined> ? (...args: A2) => PlugReturnForPipe<R2> : Function,
-    R3 extends Plug<Files | undefined> ? (...args: A3) => PlugReturnForPipe<R3> : Function
-] : T extends {
-    new (...args: infer A0): infer R0;
-    new (...args: infer A1): infer R1;
-    new (...args: infer A2): infer R2;
-} ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function,
-    R2 extends Plug<Files | undefined> ? (...args: A2) => PlugReturnForPipe<R2> : Function
-] : T extends {
-    new (...args: infer A0): infer R0;
-    new (...args: infer A1): infer R1;
-} ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function
-] : T extends {
-    new (...args: infer A0): infer R0;
-} ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function
-] : never;
-/**
- * A convenience type to easily annotate installed {@link Plug Plugs}.
- *
- * See also {@link install}.
- *
- * ```
- * export class Write implements Plug {
- *   // ... the plug implementation lives here
- * }
- *
- * install('write', Write)
- *
- * declare module '../pipe' {
- *   export interface Pipe {
- *     write: PipeExtension<typeof Write>
- *   }
- * }
- * ```
- */
-export declare type PipeExtension<T extends PlugConstructor, A = PlugConstructorOverloads<T>> = A extends readonly [infer First, ...infer Rest] ? First & PipeExtension<T, Rest> : A extends readonly [infer Only] ? Only : Function;
-/**
- * Install a {@link Plug} into our {@link Pipe} prototype, and return a static
- * creator function for the {@link Plug} itself.
- *
- * This allows our shorthand syntax for well-defined plugs such as:
- *
- * ```
- * find('./src', '*.ts').write('./target')
- * // Nicer and easier than...
- * find('./src', '*.ts').plug(new Write('./target'))
- * ```
- *
- * Use this alongside interface merging like:
- *
- * ```
- * export class Write implements Plug {
- *   // ... the plug implementation lives here
- * }
- *
- * install('write', Write)
- *
- * declare module '../pipe' {
- *   export interface Pipe {
- *     write: PipeExtension<typeof Write>
- *   }
- * }
- * ```
- */
-export declare function install<C extends PlugConstructor>(name: PlugName, ctor: C): void;
-export {};

package/types/plugs/copy.d.ts

@@ -1,27 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-/** Options for copying files */
-export interface CopyOptions {
-    /** Whether to allow overwriting or not (default `false`). */
-    overwrite?: boolean;
-    /** If specified, use this `mode` (octal string) when creating files. */
-    mode?: string | number;
-    /** If specified, use this `mode` (octal string) when creating directories. */
-    dirMode?: string | number;
-    /** If specified, this function will be invoked to rename files. */
-    rename?: (relative: string) => string;
-}
-/** Copy the curent {@link Files} to a different directory */
-export declare class Copy implements Plug<Files> {
-    private readonly _directory;
-    private readonly _options;
-    constructor(directory: string, options?: CopyOptions);
-    pipe(files: Files, run: Run): Promise<Files>;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /** Copy the curent {@link Files} to a different directory */
-        copy: PipeExtension<typeof Copy>;
-    }
-}

package/types/plugs/coverage.d.ts

@@ -1,46 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-import { SourceMapBias } from './coverage/analysis.js';
-/** Options to analyse coverage reports */
-export interface CoverageOptions {
-    /** The bias for source map analisys (defaults to `greatest_lower_bound`) */
-    sourceMapBias?: SourceMapBias;
-    /** Minimum _overall_ coverage (as a percentage) */
-    minimumCoverage?: number;
-    /** Optimal _overall_ coverage (as a percentage)  */
-    optimalCoverage?: number;
-    /** Minimum _per-file_ coverage (as a percentage) */
-    minimumFileCoverage?: number;
-    /** Optimal _per-file_ coverage (as a percentage) */
-    optimalFileCoverage?: number;
-}
-export interface CoverageReportOptions extends CoverageOptions {
-    /** If specified, a JSON and HTML report will be written to this directory */
-    reportDir: string;
-}
-/**
- * The {@link Coverage} plug type is inferred from the constructor, so this
- * type helps to declare the correct types as we can't really infer them from
- * `typeof Coverage`...
- */
-declare type CoverageConstructor = {
-    new (coverageDir: string): Coverage<CoverageOptions>;
-    new (coverageDir: string, options: CoverageOptions): Coverage<CoverageOptions>;
-    new (coverageDir: string, options: CoverageReportOptions): Coverage<CoverageReportOptions>;
-};
-/** Analyse coverage using files generated by V8/NodeJS. */
-export declare class Coverage<T extends CoverageOptions | CoverageReportOptions> implements Plug<T extends CoverageReportOptions ? Files : undefined> {
-    private readonly _coverageDir;
-    private readonly _options;
-    constructor(coverageDir: string);
-    constructor(coverageDir: string, options?: T);
-    pipe(files: Files, run: Run): Promise<T extends CoverageReportOptions ? Files : undefined>;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /** Analyse coverage using files generated by V8/NodeJS. */
-        coverage: PipeExtension<CoverageConstructor>;
-    }
-}
-export {};

package/types/plugs/debug.d.ts

@@ -1,14 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-/** Writes some info about the current {@link Files} being passed around. */
-export declare class Debug implements Plug<Files> {
-    constructor();
-    pipe(files: Files, run: Run): Promise<Files>;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /** Writes some info about the current {@link Files} being passed around. */
-        debug: PipeExtension<typeof Debug>;
-    }
-}

package/types/plugs/esbuild.d.ts

@@ -1,23 +0,0 @@
-import { BuildOptions } from 'esbuild';
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-export declare type ESBuildOptions = Omit<BuildOptions, 'absWorkingDir' | 'entryPoints' | 'watch'>;
-/**
- * Transpile and bundle files with {@link https://esbuild.github.io/ | esbuild}.
- */
-export declare class ESBuild implements Plug<Files> {
-    private readonly _options;
-    constructor(options: ESBuildOptions);
-    pipe(files: Files, run: Run): Promise<Files>;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /**
-         * Transpile and bundle files with {@link https://esbuild.github.io/ esbuild}.
-         */
-        esbuild: PipeExtension<typeof ESBuild>;
-    }
-}
-export * from './esbuild/bundle-locals.js';
-export * from './esbuild/fix-extensions.js';