You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
9.4 KiB
301 lines
9.4 KiB
// 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: string, pattern: readonly string[], 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;
|