path: root/node_modules/@types/minimatch/index.d.ts

// Type definitions for minimatch 5.1
// Project: https://github.com/isaacs/minimatch
// Definitions by: vvakame <https://github.com/vvakame>
//                 Shant Marouti <https://github.com/shantmarouti>
//                 BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/**
 * Tests a path against the pattern using the options.
 *
 * @example
 * import minimatch = require("minimatch");
 *
 * const isJS = minimatch(file, "*.js", { matchBase: true });
 */
declare function minimatch(target: string, pattern: string, options?: minimatch.IOptions): boolean;

declare namespace minimatch {
    /**
     * Match against the list of files, in the style of fnmatch or glob.
     * If nothing is matched, and options.nonull is set,
     * then return a list containing the pattern itself.
     *
     * @example
     * import minimatch = require("minimatch");
     *
     * const javascripts = minimatch.match(fileList, "*.js", {matchBase: true});
     */
    function match(list: readonly string[], pattern: string, options?: IOptions): string[];

    /**
     * @return A function that tests its supplied argument, suitable for use with `Array.filter`.
     *
     * @example
     * import minimatch = require("minimatch");
     *
     * const javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}));
     */
    function filter(
        pattern: string,
        options?: IOptions,
    ): (element: string, indexed: number, array: readonly string[]) => boolean;

    /**
     * Make a regular expression object from the pattern.
     */
    function makeRe(pattern: string, options?: IOptions): RegExp | false;

    function defaults(defaultOptions: IOptions): typeof minimatch;

    function braceExpand(pattern: string, options?: IOptions): string[];

    const sep: string;
    const GLOBSTAR: unique symbol;

    interface IOptions {
        /**
         * Dump a ton of stuff to stderr.
         *
         * @default false
         */
        debug?: boolean | undefined;

        /**
         * Do not expand `{a,b}` and `{1..3}` brace sets.
         *
         * @default false
         */
        nobrace?: boolean | undefined;

        /**
         * Disable `**` matching against multiple folder names.
         *
         * @default false
         */
        noglobstar?: boolean | undefined;

        /**
         * Allow patterns to match filenames starting with a period,
         * even if the pattern does not explicitly have a period in that spot.
         *
         * Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
         *
         * @default false
         */
        dot?: boolean | undefined;

        /**
         * Disable "extglob" style patterns like `+(a|b)`.
         *
         * @default false
         */
        noext?: boolean | undefined;

        /**
         * Perform a case-insensitive match.
         *
         * @default false
         */
        nocase?: boolean | undefined;

        /**
         * When a match is not found by `minimatch.match`,
         * return a list containing the pattern itself if this option is set.
         * Otherwise, an empty list is returned if there are no matches.
         *
         * @default false
         */
        nonull?: boolean | undefined;

        /**
         * If set, then patterns without slashes will be matched
         * against the basename of the path if it contains slashes. For example,
         * `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
         *
         * @default false
         */
        matchBase?: boolean | undefined;

        /**
         * Suppress the behavior of treating `#` at the start of a pattern as a comment.
         *
         * @default false
         */
        nocomment?: boolean | undefined;

        /**
         * Suppress the behavior of treating a leading `!` character as negation.
         *
         * @default false
         */
        nonegate?: boolean | undefined;

        /**
         * Returns from negate expressions the same as if they were not negated.
         * (Ie, true on a hit, false on a miss.)
         *
         * @default false
         */
        flipNegate?: boolean | undefined;

        /**
         * Compare a partial path to a pattern.  As long as the parts of the path that
         * are present are not contradicted by the pattern, it will be treated as a
         * match. This is useful in applications where you're walking through a
         * folder structure, and don't yet have the full path, but want to ensure that
         * you do not walk down paths that can never be a match.
         *
         * @default false
         *
         * @example
         * import minimatch = require("minimatch");
         *
         * minimatch('/a/b', '/a/*' + '/c/d', { partial: true })  // true, might be /a/b/c/d
         * minimatch('/a/b', '/**' + '/d', { partial: true })     // true, might be /a/b/.../d
         * minimatch('/x/y/z', '/a/**' + '/z', { partial: true }) // false, because x !== a
         */
        partial?: boolean;

        /**
         * Use `\\` as a path separator _only_, and _never_ as an escape
         * character. If set, all `\\` characters are replaced with `/` in
         * the pattern. Note that this makes it **impossible** to match
         * against paths containing literal glob pattern characters, but
         * allows matching with patterns constructed using `path.join()` and
         * `path.resolve()` on Windows platforms, mimicking the (buggy!)
         * behavior of earlier versions on Windows. Please use with
         * caution, and be mindful of the caveat about Windows paths
         *
         * For legacy reasons, this is also set if
         * `options.allowWindowsEscape` is set to the exact value `false`.
         *
         * @default false
         */
        windowsPathsNoEscape?: boolean;
    }

    /**
     * @deprecated Keep legacy interface to prevent unnecessary breakage.
     */
    type IMinimatchStatic = typeof Minimatch;
    /**
     * @deprecated Keep legacy interface to prevent unnecessary breakage.
     */
    type IMinimatch = Minimatch;

    /**
     * Create a minimatch object by instantiating the `minimatch.Minimatch` class.
     *
     * @example
     * import { Minimatch } from "minimatch";
     *
     * const mm = new Minimatch(pattern, options);
     */
    class Minimatch {
        constructor(pattern: string, options?: IOptions);

        static defaults(defaultOptions: IOptions): typeof Minimatch;

        /**
         * The original pattern the minimatch object represents.
         */
        pattern: string;

        /**
         * The options supplied to the constructor.
         */
        options: IOptions;

        /**
         * A 2-dimensional array of regexp or string expressions. Each row in the array corresponds
         * to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For
         * example, the pattern `{a,b/c}/d` would expand to a set of patterns like:
         *
         * ```
         *   [ [ a, d ]
         *   , [ b, c, d ] ]
         * ```
         *
         * If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"``
         * rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression.
         */
        set: Array<Array<RegExp | string>>;

        /**
         * Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is
         * useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
         */
        regexp: RegExp | false | null;

        /**
         * True if the pattern is negated.
         */
        negate: boolean;

        /**
         * True if the pattern is a comment.
         */
        comment: boolean;

        /**
         * True if the pattern is `""`.
         */
        empty: boolean;

        /**
         * True if windows path delimiters shouldn't be interpreted as escape characters.
         */
        windowsPathsNoEscape: boolean;

        /**
         * True if partial paths should be compared to a pattern.
         */
        partial: boolean;

        /**
         * Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid.
         */
        makeRe(): RegExp | false;

        /**
         * @return `true` if the filename matches the pattern, or `false` otherwise.
         */
        match(fname: string, partial?: boolean): boolean;

        /**
         * Take a `/`-split filename, and match it against a single row in the `regExpSet`.
         * This method is mainly for internal use, but is exposed so that it can be used
         * by a glob-walker that needs to avoid excessive filesystem calls.
         */
        matchOne(file: readonly string[], pattern: ReadonlyArray<string | RegExp>, partial: boolean): boolean;

        /**
         * @deprecated. For internal use.
         */
        debug(): void;

        /**
         * @deprecated. For internal use.
         */
        make(): void;

        /**
         * @deprecated. For internal use.
         */
        parseNegate(): void;

        /**
         * @deprecated. For internal use.
         */
        braceExpand(): string[];

        /**
         * @deprecated. For internal use.
         */
        parse(pattern: string, isSub?: boolean): string | false | [string, boolean] | RegExp | typeof GLOBSTAR;
    }
}

export = minimatch;