Interface IOptions

Hierarchy

Properties

absolute? cache? cwd? debug? dot? flipNegate? follow? fs? ignore? mark? matchBase? nobrace? nocase? nocomment? nodir? noext? noglobstar? nomount? nonegate? nonull? nosort? nounique? partial? realpath? realpathCache? root? silent? stat? statCache? strict? symlinks? sync? windowsPathsNoEscape?

Properties

Optional absolute

absolute?: boolean

Optional cache

cache?: {
    [path: string]: boolean | "DIR" | "FILE" | ReadonlyArray<string>;
}

Type declaration

  • [path: string]: boolean | "DIR" | "FILE" | ReadonlyArray<string>

Optional cwd

cwd?: string

Optional debug

debug?: boolean

Dump a ton of stuff to stderr.

Default

false

Optional dot

dot?: boolean

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

Optional flipNegate

flipNegate?: boolean

Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.)

Default

false

Optional follow

follow?: boolean

Optional fs

fs?: "fs"

Optional ignore

ignore?: string | readonly string[]

Optional mark

mark?: boolean

Optional matchBase

matchBase?: any

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

Optional nobrace

nobrace?: boolean

Do not expand {a,b} and {1..3} brace sets.

Default

false

Optional nocase

nocase?: boolean

Perform a case-insensitive match.

Default

false

Optional nocomment

nocomment?: boolean

Suppress the behavior of treating # at the start of a pattern as a comment.

Default

false

Optional nodir

nodir?: boolean

Optional noext

noext?: boolean

Disable "extglob" style patterns like +(a|b).

Default

false

Optional noglobstar

noglobstar?: boolean

Disable ** matching against multiple folder names.

Default

false

Optional nomount

nomount?: boolean

Optional nonegate

nonegate?: boolean

Suppress the behavior of treating a leading ! character as negation.

Default

false

Optional nonull

nonull?: boolean

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

Optional nosort

nosort?: boolean

Optional nounique

nounique?: boolean

Optional partial

partial?: boolean

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

Optional realpath

realpath?: boolean

Optional realpathCache

realpathCache?: {
    [path: string]: string;
}

Type declaration

  • [path: string]: string

Optional root

root?: string

Optional silent

silent?: boolean

Optional stat

stat?: boolean

Optional statCache

statCache?: {
    [path: string]: false | {
        isDirectory(): boolean;
    } | undefined;
}

Type declaration

  • [path: string]: false | {
        isDirectory(): boolean;
    } | undefined

Optional strict

strict?: boolean

Optional symlinks

symlinks?: {
    [path: string]: boolean | undefined;
}

Type declaration

  • [path: string]: boolean | undefined

Optional sync

sync?: boolean

Optional windowsPathsNoEscape

windowsPathsNoEscape?: 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

Settings

Member Visibility

Theme