@plugjs/plug 0.0.12 → 0.0.15

package/types/plugs/eslint/runner.d.ts

@@ -1,22 +0,0 @@
-import { Files } from '../../files.js';
-import { Plug } from '../../pipe.js';
-import { Run } from '../../run.js';
-export interface ESLintOptions {
-    /** ESLint's own _current working directory_, where config files are. */
-    directory?: string;
-    /** Show sources in report? */
-    showSources?: boolean;
-    /**
-     * ESLint's _override_ configuration file: configurations specified in this
-     * file will override any other configuration specified elsewhere.
-     */
-    configFile?: string;
-}
-/** Writes some info about the current {@link Files} being passed around. */
-export default class ESLint implements Plug<undefined> {
-    private readonly _options;
-    constructor();
-    constructor(configFile: string);
-    constructor(options: ESLintOptions);
-    pipe(files: Files, run: Run): Promise<undefined>;
-}

package/types/plugs/exec.d.ts

@@ -1,90 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-import { ParseOptions } from '../utils/options.js';
-/** Options for executing scripts */
-export interface ExecOptions {
-    /** Extra environment variables, or overrides for existing ones */
-    env?: Record<string, any>;
-    /** Whether to run in the context of a _shell_ or not */
-    shell?: string | boolean;
-    /**
-     * The current working directory of the process to execute.
-     *
-     * Defaults to the current {@link Files.directory | Files' directory} when
-     * used as a {@link Plug} or `process.cwd()` when used from {@link exec}.
-     */
-    cwd?: string;
-    /**
-     * When used as a {@link Plug}, the {@link Files} will be appended to the
-     * current arguments as _relative_ files (default) or _absolute_ (if false).
-     */
-    relativePaths?: boolean;
-}
-/**
- * Execute a shell command, adding to its _arguments_ the list of files from
- * the current pipe (much like `xargs` does on Unix systems).
- *
- * This {@link Plug} returns the same {@link Files} it was given, so that
- * executing a shell command doesn't interrupt a {@link Pipe}.
- *
- * For example:
- *
- * ```
- * import { find, exec } from '@plugjs/plugjs'
- *
- * export default build({
- *   async runme() {
- *     find('*.ts', { directory: 'src' })
- *       .plug(new Exec('chmod', '755' }))
- *       .plug(new Exec('chown root:root', { shell: true }))
- *   },
- * })
- * ```
- */
-export declare class Exec implements Plug<Files> {
-    private readonly _cmd;
-    private readonly _args;
-    private readonly _options;
-    constructor(cmd: string, ...args: ParseOptions<ExecOptions>);
-    pipe(files: Files, run: Run): Promise<Files>;
-}
-/**
- * Execute a command and await for its result from within a task.
- *
- * For example:
- *
- * ```
- * import { exec } from '@plugjs/plugjs'
- *
- * export default build({
- *   async runme() {
- *     await exec('ls', '-la', '/')
- *   },
- * })
- * ```
- */
-export declare function exec(cmd: string, ...args: ParseOptions<ExecOptions>): Promise<void>;
-declare module '../pipe.js' {
-    interface Pipe {
-        /**
-         * Execute a shell command, adding to its _arguments_ the list of files
-         * from the current pipe (much like `xargs` does on Unix systems).
-         *
-         * For example:
-         *
-         * ```
-         * import { find, exec } from '@plugjs/plugjs'
-         *
-         * export default build({
-         *   async runme() {
-         *     find('*.ts', { directory: 'src' })
-         *       .exec('chmod', '755' })
-         *       .exec('chown root:root', { shell: true })
-         *   },
-         * })
-         * ```
-         */
-        exec: PipeExtension<typeof Exec>;
-    }
-}

package/types/plugs/filter.d.ts

@@ -1,23 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-import { MatchOptions } from '../utils/match.js';
-import { ParseOptions } from '../utils/options.js';
-/** Options for filtering {@link Files}. */
-export interface FilterOptions extends MatchOptions {
-    /** The base directory for filtering, and relativising the resulting files. */
-    directory?: string;
-}
-/** Filter the current {@link Files} using globs. */
-export declare class Filter implements Plug<Files> {
-    private readonly _globs;
-    private readonly _options;
-    constructor(glob: string, ...args: ParseOptions<FilterOptions>);
-    pipe(files: Files, run: Run): Files;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /** Filter the current {@link Files} using globs. */
-        filter: PipeExtension<typeof Filter>;
-    }
-}

package/types/plugs/rmf.d.ts

@@ -1,15 +0,0 @@
-import { Files } from '../files.js';
-import { Plug } from '../pipe.js';
-import { Run } from '../run.js';
-/** Remove some files using globs. */
-export declare class Rmf implements Plug<undefined> {
-    private readonly _dryRun;
-    constructor(dryRun?: boolean);
-    pipe(files: Files, run: Run): Promise<undefined>;
-}
-declare module '../pipe.js' {
-    interface Pipe {
-        /** Remove all {@link Files} piped in. */
-        rmf: PipeExtension<typeof Rmf>;
-    }
-}

package/types/plugs/tsc/runner.d.ts

@@ -1,13 +0,0 @@
-import ts from 'typescript';
-import { Files } from '../../files.js';
-import { Plug } from '../../pipe.js';
-import { Run } from '../../run.js';
-export default class Tsc implements Plug<Files> {
-    private readonly _tsconfig?;
-    private readonly _options;
-    constructor();
-    constructor(config: string);
-    constructor(options: ts.CompilerOptions);
-    constructor(config: string, options: ts.CompilerOptions);
-    pipe(files: Files, run: Run): Promise<Files>;
-}

package/types/plugs.d.ts

@@ -1,17 +0,0 @@
-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' {
-    interface Pipe {
-        eslint: PipeExtension<typeof ESLint>;
-        mocha: PipeExtension<typeof Mocha>;
-        tsc: PipeExtension<typeof Tsc>;
-    }
-}
-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';

package/types/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>;
-}

package/types/task.d.ts

@@ -1,15 +0,0 @@
-import type { BuildContext, TaskDefinition, ThisBuild } from './build.js';
-import type { Files } from './files.js';
-import type { Run } from './run.js';
-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 declare class TaskImpl implements Task<Files | undefined> {
-    readonly context: BuildContext;
-    private readonly _definition;
-    constructor(context: BuildContext, _definition: TaskDefinition<any>);
-    call(self: ThisBuild<any>, run: Run): Promise<Files | undefined>;
-}

package/types/utils/caller.d.ts

@@ -1,7 +0,0 @@
-import { AbsolutePath } from '../paths.js';
-export interface Location {
-    file: AbsolutePath;
-    line?: number | undefined;
-    column?: number | undefined;
-}
-export declare function findCaller(of: (...args: any[]) => any): Location;

package/types/utils/options.d.ts

@@ -1,15 +0,0 @@
-export declare type ParsedOptions<Options> = {
-    params: string[];
-    options: Options;
-};
-export declare type ParsedOptionalOptions<Options> = {
-    params: string[];
-    options?: Options | undefined;
-};
-export declare type ParseOptions<Options> = string[] | [...string[], Options] | [Options];
-/** Parse an array of at least one string, followed by an optional `Options` argument. */
-export declare function parseOptions<Options>(args: ParseOptions<Options>): ParsedOptionalOptions<Options>;
-/** Parse an array of at least one string, followed by an optional `Options` argument. */
-export declare 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 declare function parseOptions<Options, Defaults extends Options>(args: ParseOptions<Options>, defaults: Defaults): ParsedOptions<Options & Defaults>;