Deployed the page to Github Pages.
This commit is contained in:
parent
1d79754e93
commit
2c89899458
SSH key fingerprint:
SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
21
node_modules/fast-glob/LICENSE
generated
vendored
Normal file
21
node_modules/fast-glob/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Denis Malinochkin
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
830
node_modules/fast-glob/README.md
generated
vendored
Normal file
830
node_modules/fast-glob/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,830 @@
|
|||
# fast-glob
|
||||
|
||||
> It's a very fast and efficient [glob][glob_definition] library for [Node.js][node_js].
|
||||
|
||||
This package provides methods for traversing the file system and returning pathnames that matched a defined set of a specified pattern according to the rules used by the Unix Bash shell with some simplifications, meanwhile results are returned in **arbitrary order**. Quick, simple, effective.
|
||||
|
||||
## Table of Contents
|
||||
|
||||
<details>
|
||||
<summary><strong>Details</strong></summary>
|
||||
|
||||
* [Highlights](#highlights)
|
||||
* [Old and modern mode](#old-and-modern-mode)
|
||||
* [Pattern syntax](#pattern-syntax)
|
||||
* [Basic syntax](#basic-syntax)
|
||||
* [Advanced syntax](#advanced-syntax)
|
||||
* [Installation](#installation)
|
||||
* [API](#api)
|
||||
* [Asynchronous](#asynchronous)
|
||||
* [Synchronous](#synchronous)
|
||||
* [Stream](#stream)
|
||||
* [patterns](#patterns)
|
||||
* [[options]](#options)
|
||||
* [Helpers](#helpers)
|
||||
* [generateTasks](#generatetaskspatterns-options)
|
||||
* [isDynamicPattern](#isdynamicpatternpattern-options)
|
||||
* [escapePath](#escapepathpath)
|
||||
* [convertPathToPattern](#convertpathtopatternpath)
|
||||
* [Options](#options-3)
|
||||
* [Common](#common)
|
||||
* [concurrency](#concurrency)
|
||||
* [cwd](#cwd)
|
||||
* [deep](#deep)
|
||||
* [followSymbolicLinks](#followsymboliclinks)
|
||||
* [fs](#fs)
|
||||
* [ignore](#ignore)
|
||||
* [suppressErrors](#suppresserrors)
|
||||
* [throwErrorOnBrokenSymbolicLink](#throwerroronbrokensymboliclink)
|
||||
* [Output control](#output-control)
|
||||
* [absolute](#absolute)
|
||||
* [markDirectories](#markdirectories)
|
||||
* [objectMode](#objectmode)
|
||||
* [onlyDirectories](#onlydirectories)
|
||||
* [onlyFiles](#onlyfiles)
|
||||
* [stats](#stats)
|
||||
* [unique](#unique)
|
||||
* [Matching control](#matching-control)
|
||||
* [braceExpansion](#braceexpansion)
|
||||
* [caseSensitiveMatch](#casesensitivematch)
|
||||
* [dot](#dot)
|
||||
* [extglob](#extglob)
|
||||
* [globstar](#globstar)
|
||||
* [baseNameMatch](#basenamematch)
|
||||
* [FAQ](#faq)
|
||||
* [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
|
||||
* [How to write patterns on Windows?](#how-to-write-patterns-on-windows)
|
||||
* [Why are parentheses match wrong?](#why-are-parentheses-match-wrong)
|
||||
* [How to exclude directory from reading?](#how-to-exclude-directory-from-reading)
|
||||
* [How to use UNC path?](#how-to-use-unc-path)
|
||||
* [Compatible with `node-glob`?](#compatible-with-node-glob)
|
||||
* [Benchmarks](#benchmarks)
|
||||
* [Server](#server)
|
||||
* [Nettop](#nettop)
|
||||
* [Changelog](#changelog)
|
||||
* [License](#license)
|
||||
|
||||
</details>
|
||||
|
||||
## Highlights
|
||||
|
||||
* Fast. Probably the fastest.
|
||||
* Supports multiple and negative patterns.
|
||||
* Synchronous, Promise and Stream API.
|
||||
* Object mode. Can return more than just strings.
|
||||
* Error-tolerant.
|
||||
|
||||
## Old and modern mode
|
||||
|
||||
This package works in two modes, depending on the environment in which it is used.
|
||||
|
||||
* **Old mode**. Node.js below 10.10 or when the [`stats`](#stats) option is *enabled*.
|
||||
* **Modern mode**. Node.js 10.10+ and the [`stats`](#stats) option is *disabled*.
|
||||
|
||||
The modern mode is faster. Learn more about the [internal mechanism][nodelib_fs_scandir_old_and_modern_modern].
|
||||
|
||||
## Pattern syntax
|
||||
|
||||
> :warning: Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters.
|
||||
|
||||
There is more than one form of syntax: basic and advanced. Below is a brief overview of the supported features. Also pay attention to our [FAQ](#faq).
|
||||
|
||||
> :book: This package uses [`micromatch`][micromatch] as a library for pattern matching.
|
||||
|
||||
### Basic syntax
|
||||
|
||||
* An asterisk (`*`) — matches everything except slashes (path separators), hidden files (names starting with `.`).
|
||||
* A double star or globstar (`**`) — matches zero or more directories.
|
||||
* Question mark (`?`) – matches any single character except slashes (path separators).
|
||||
* Sequence (`[seq]`) — matches any character in sequence.
|
||||
|
||||
> :book: A few additional words about the [basic matching behavior][picomatch_matching_behavior].
|
||||
|
||||
Some examples:
|
||||
|
||||
* `src/**/*.js` — matches all files in the `src` directory (any level of nesting) that have the `.js` extension.
|
||||
* `src/*.??` — matches all files in the `src` directory (only first level of nesting) that have a two-character extension.
|
||||
* `file-[01].js` — matches files: `file-0.js`, `file-1.js`.
|
||||
|
||||
### Advanced syntax
|
||||
|
||||
* [Escapes characters][micromatch_backslashes] (`\\`) — matching special characters (`$^*+?()[]`) as literals.
|
||||
* [POSIX character classes][picomatch_posix_brackets] (`[[:digit:]]`).
|
||||
* [Extended globs][micromatch_extglobs] (`?(pattern-list)`).
|
||||
* [Bash style brace expansions][micromatch_braces] (`{}`).
|
||||
* [Regexp character classes][micromatch_regex_character_classes] (`[1-5]`).
|
||||
* [Regex groups][regular_expressions_brackets] (`(a|b)`).
|
||||
|
||||
> :book: A few additional words about the [advanced matching behavior][micromatch_extended_globbing].
|
||||
|
||||
Some examples:
|
||||
|
||||
* `src/**/*.{css,scss}` — matches all files in the `src` directory (any level of nesting) that have the `.css` or `.scss` extension.
|
||||
* `file-[[:digit:]].js` — matches files: `file-0.js`, `file-1.js`, …, `file-9.js`.
|
||||
* `file-{1..3}.js` — matches files: `file-1.js`, `file-2.js`, `file-3.js`.
|
||||
* `file-(1|2)` — matches files: `file-1.js`, `file-2.js`.
|
||||
|
||||
## Installation
|
||||
|
||||
```console
|
||||
npm install fast-glob
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### Asynchronous
|
||||
|
||||
```js
|
||||
fg(patterns, [options])
|
||||
fg.async(patterns, [options])
|
||||
fg.glob(patterns, [options])
|
||||
```
|
||||
|
||||
Returns a `Promise` with an array of matching entries.
|
||||
|
||||
```js
|
||||
const fg = require('fast-glob');
|
||||
|
||||
const entries = await fg(['.editorconfig', '**/index.js'], { dot: true });
|
||||
|
||||
// ['.editorconfig', 'services/index.js']
|
||||
```
|
||||
|
||||
### Synchronous
|
||||
|
||||
```js
|
||||
fg.sync(patterns, [options])
|
||||
fg.globSync(patterns, [options])
|
||||
```
|
||||
|
||||
Returns an array of matching entries.
|
||||
|
||||
```js
|
||||
const fg = require('fast-glob');
|
||||
|
||||
const entries = fg.sync(['.editorconfig', '**/index.js'], { dot: true });
|
||||
|
||||
// ['.editorconfig', 'services/index.js']
|
||||
```
|
||||
|
||||
### Stream
|
||||
|
||||
```js
|
||||
fg.stream(patterns, [options])
|
||||
fg.globStream(patterns, [options])
|
||||
```
|
||||
|
||||
Returns a [`ReadableStream`][node_js_stream_readable_streams] when the `data` event will be emitted with matching entry.
|
||||
|
||||
```js
|
||||
const fg = require('fast-glob');
|
||||
|
||||
const stream = fg.stream(['.editorconfig', '**/index.js'], { dot: true });
|
||||
|
||||
for await (const entry of stream) {
|
||||
// .editorconfig
|
||||
// services/index.js
|
||||
}
|
||||
```
|
||||
|
||||
#### patterns
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string | string[]`
|
||||
|
||||
Any correct pattern(s).
|
||||
|
||||
> :1234: [Pattern syntax](#pattern-syntax)
|
||||
>
|
||||
> :warning: This package does not respect the order of patterns. First, all the negative patterns are applied, and only then the positive patterns. If you want to get a certain order of records, use sorting or split calls.
|
||||
|
||||
#### [options]
|
||||
|
||||
* Required: `false`
|
||||
* Type: [`Options`](#options-3)
|
||||
|
||||
See [Options](#options-3) section.
|
||||
|
||||
### Helpers
|
||||
|
||||
#### `generateTasks(patterns, [options])`
|
||||
|
||||
Returns the internal representation of patterns ([`Task`](./src/managers/tasks.ts) is a combining patterns by base directory).
|
||||
|
||||
```js
|
||||
fg.generateTasks('*');
|
||||
|
||||
[{
|
||||
base: '.', // Parent directory for all patterns inside this task
|
||||
dynamic: true, // Dynamic or static patterns are in this task
|
||||
patterns: ['*'],
|
||||
positive: ['*'],
|
||||
negative: []
|
||||
}]
|
||||
```
|
||||
|
||||
##### patterns
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string | string[]`
|
||||
|
||||
Any correct pattern(s).
|
||||
|
||||
##### [options]
|
||||
|
||||
* Required: `false`
|
||||
* Type: [`Options`](#options-3)
|
||||
|
||||
See [Options](#options-3) section.
|
||||
|
||||
#### `isDynamicPattern(pattern, [options])`
|
||||
|
||||
Returns `true` if the passed pattern is a dynamic pattern.
|
||||
|
||||
> :1234: [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
|
||||
|
||||
```js
|
||||
fg.isDynamicPattern('*'); // true
|
||||
fg.isDynamicPattern('abc'); // false
|
||||
```
|
||||
|
||||
##### pattern
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string`
|
||||
|
||||
Any correct pattern.
|
||||
|
||||
##### [options]
|
||||
|
||||
* Required: `false`
|
||||
* Type: [`Options`](#options-3)
|
||||
|
||||
See [Options](#options-3) section.
|
||||
|
||||
#### `escapePath(path)`
|
||||
|
||||
Returns the path with escaped special characters depending on the platform.
|
||||
|
||||
* Posix:
|
||||
* `*?|(){}[]`;
|
||||
* `!` at the beginning of line;
|
||||
* `@+!` before the opening parenthesis;
|
||||
* `\\` before non-special characters;
|
||||
* Windows:
|
||||
* `(){}[]`
|
||||
* `!` at the beginning of line;
|
||||
* `@+!` before the opening parenthesis;
|
||||
* Characters like `*?|` cannot be used in the path ([windows_naming_conventions][windows_naming_conventions]), so they will not be escaped;
|
||||
|
||||
```js
|
||||
fg.escapePath('!abc');
|
||||
// \\!abc
|
||||
fg.escapePath('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac'
|
||||
// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac
|
||||
|
||||
fg.posix.escapePath('C:\\Program Files (x86)\\**\\*');
|
||||
// C:\\\\Program Files \\(x86\\)\\*\\*\\*
|
||||
fg.win32.escapePath('C:\\Program Files (x86)\\**\\*');
|
||||
// Windows: C:\\Program Files \\(x86\\)\\**\\*
|
||||
```
|
||||
|
||||
#### `convertPathToPattern(path)`
|
||||
|
||||
Converts a path to a pattern depending on the platform, including special character escaping.
|
||||
|
||||
* Posix. Works similarly to the `fg.posix.escapePath` method.
|
||||
* Windows. Works similarly to the `fg.win32.escapePath` method, additionally converting backslashes to forward slashes in cases where they are not escape characters (`!()+@{}[]`).
|
||||
|
||||
```js
|
||||
fg.convertPathToPattern('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac';
|
||||
// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac
|
||||
|
||||
fg.convertPathToPattern('C:/Program Files (x86)/**/*');
|
||||
// Posix: C:/Program Files \\(x86\\)/\\*\\*/\\*
|
||||
// Windows: C:/Program Files \\(x86\\)/**/*
|
||||
|
||||
fg.convertPathToPattern('C:\\Program Files (x86)\\**\\*');
|
||||
// Posix: C:\\\\Program Files \\(x86\\)\\*\\*\\*
|
||||
// Windows: C:/Program Files \\(x86\\)/**/*
|
||||
|
||||
fg.posix.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
|
||||
// Posix: \\\\\\?\\\\c:\\\\Program Files \\(x86\\)/**/* (broken pattern)
|
||||
fg.win32.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
|
||||
// Windows: //?/c:/Program Files \\(x86\\)/**/*
|
||||
```
|
||||
|
||||
## Options
|
||||
|
||||
### Common options
|
||||
|
||||
#### concurrency
|
||||
|
||||
* Type: `number`
|
||||
* Default: `os.cpus().length`
|
||||
|
||||
Specifies the maximum number of concurrent requests from a reader to read directories.
|
||||
|
||||
> :book: The higher the number, the higher the performance and load on the file system. If you want to read in quiet mode, set the value to a comfortable number or `1`.
|
||||
|
||||
<details>
|
||||
|
||||
<summary>More details</summary>
|
||||
|
||||
In Node, there are [two types of threads][nodejs_thread_pool]: Event Loop (code) and a Thread Pool (fs, dns, …). The thread pool size controlled by the `UV_THREADPOOL_SIZE` environment variable. Its default size is 4 ([documentation][libuv_thread_pool]). The pool is one for all tasks within a single Node process.
|
||||
|
||||
Any code can make 4 real concurrent accesses to the file system. The rest of the FS requests will wait in the queue.
|
||||
|
||||
> :book: Each new instance of FG in the same Node process will use the same Thread pool.
|
||||
|
||||
But this package also has the `concurrency` option. This option allows you to control the number of concurrent accesses to the FS at the package level. By default, this package has a value equal to the number of cores available for the current Node process. This allows you to set a value smaller than the pool size (`concurrency: 1`) or, conversely, to prepare tasks for the pool queue more quickly (`concurrency: Number.POSITIVE_INFINITY`).
|
||||
|
||||
So, in fact, this package can **only make 4 concurrent requests to the FS**. You can increase this value by using an environment variable (`UV_THREADPOOL_SIZE`), but in practice this does not give a multiple advantage.
|
||||
|
||||
</details>
|
||||
|
||||
#### cwd
|
||||
|
||||
* Type: `string`
|
||||
* Default: `process.cwd()`
|
||||
|
||||
The current working directory in which to search.
|
||||
|
||||
#### deep
|
||||
|
||||
* Type: `number`
|
||||
* Default: `Infinity`
|
||||
|
||||
Specifies the maximum depth of a read directory relative to the start directory.
|
||||
|
||||
For example, you have the following tree:
|
||||
|
||||
```js
|
||||
dir/
|
||||
└── one/ // 1
|
||||
└── two/ // 2
|
||||
└── file.js // 3
|
||||
```
|
||||
|
||||
```js
|
||||
// With base directory
|
||||
fg.sync('dir/**', { onlyFiles: false, deep: 1 }); // ['dir/one']
|
||||
fg.sync('dir/**', { onlyFiles: false, deep: 2 }); // ['dir/one', 'dir/one/two']
|
||||
|
||||
// With cwd option
|
||||
fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 1 }); // ['one']
|
||||
fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 2 }); // ['one', 'one/two']
|
||||
```
|
||||
|
||||
> :book: If you specify a pattern with some base directory, this directory will not participate in the calculation of the depth of the found directories. Think of it as a [`cwd`](#cwd) option.
|
||||
|
||||
#### followSymbolicLinks
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Indicates whether to traverse descendants of symbolic link directories when expanding `**` patterns.
|
||||
|
||||
> :book: Note that this option does not affect the base directory of the pattern. For example, if `./a` is a symlink to directory `./b` and you specified `['./a**', './b/**']` patterns, then directory `./a` will still be read.
|
||||
|
||||
> :book: If the [`stats`](#stats) option is specified, the information about the symbolic link (`fs.lstat`) will be replaced with information about the entry (`fs.stat`) behind it.
|
||||
|
||||
#### fs
|
||||
|
||||
* Type: `FileSystemAdapter`
|
||||
* Default: `fs.*`
|
||||
|
||||
Custom implementation of methods for working with the file system.
|
||||
|
||||
```ts
|
||||
export interface FileSystemAdapter {
|
||||
lstat?: typeof fs.lstat;
|
||||
stat?: typeof fs.stat;
|
||||
lstatSync?: typeof fs.lstatSync;
|
||||
statSync?: typeof fs.statSync;
|
||||
readdir?: typeof fs.readdir;
|
||||
readdirSync?: typeof fs.readdirSync;
|
||||
}
|
||||
```
|
||||
|
||||
#### ignore
|
||||
|
||||
* Type: `string[]`
|
||||
* Default: `[]`
|
||||
|
||||
An array of glob patterns to exclude matches. This is an alternative way to use negative patterns.
|
||||
|
||||
```js
|
||||
dir/
|
||||
├── package-lock.json
|
||||
└── package.json
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync(['*.json', '!package-lock.json']); // ['package.json']
|
||||
fg.sync('*.json', { ignore: ['package-lock.json'] }); // ['package.json']
|
||||
```
|
||||
|
||||
#### suppressErrors
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
By default this package suppress only `ENOENT` errors. Set to `true` to suppress any error.
|
||||
|
||||
> :book: Can be useful when the directory has entries with a special level of access.
|
||||
|
||||
#### throwErrorOnBrokenSymbolicLink
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
|
||||
|
||||
> :book: This option has no effect on errors when reading the symbolic link directory.
|
||||
|
||||
### Output control
|
||||
|
||||
#### absolute
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Return the absolute path for entries.
|
||||
|
||||
```js
|
||||
fg.sync('*.js', { absolute: false }); // ['index.js']
|
||||
fg.sync('*.js', { absolute: true }); // ['/home/user/index.js']
|
||||
```
|
||||
|
||||
> :book: This option is required if you want to use negative patterns with absolute path, for example, `!${__dirname}/*.js`.
|
||||
|
||||
#### markDirectories
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Mark the directory path with the final slash.
|
||||
|
||||
```js
|
||||
fg.sync('*', { onlyFiles: false, markDirectories: false }); // ['index.js', 'controllers']
|
||||
fg.sync('*', { onlyFiles: false, markDirectories: true }); // ['index.js', 'controllers/']
|
||||
```
|
||||
|
||||
#### objectMode
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Returns objects (instead of strings) describing entries.
|
||||
|
||||
```js
|
||||
fg.sync('*', { objectMode: false }); // ['src/index.js']
|
||||
fg.sync('*', { objectMode: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent> }]
|
||||
```
|
||||
|
||||
The object has the following fields:
|
||||
|
||||
* name (`string`) — the last part of the path (basename)
|
||||
* path (`string`) — full path relative to the pattern base directory
|
||||
* dirent ([`fs.Dirent`][node_js_fs_class_fs_dirent]) — instance of `fs.Dirent`
|
||||
|
||||
> :book: An object is an internal representation of entry, so getting it does not affect performance.
|
||||
|
||||
#### onlyDirectories
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Return only directories.
|
||||
|
||||
```js
|
||||
fg.sync('*', { onlyDirectories: false }); // ['index.js', 'src']
|
||||
fg.sync('*', { onlyDirectories: true }); // ['src']
|
||||
```
|
||||
|
||||
> :book: If `true`, the [`onlyFiles`](#onlyfiles) option is automatically `false`.
|
||||
|
||||
#### onlyFiles
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Return only files.
|
||||
|
||||
```js
|
||||
fg.sync('*', { onlyFiles: false }); // ['index.js', 'src']
|
||||
fg.sync('*', { onlyFiles: true }); // ['index.js']
|
||||
```
|
||||
|
||||
#### stats
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Enables an [object mode](#objectmode) with an additional field:
|
||||
|
||||
* stats ([`fs.Stats`][node_js_fs_class_fs_stats]) — instance of `fs.Stats`
|
||||
|
||||
```js
|
||||
fg.sync('*', { stats: false }); // ['src/index.js']
|
||||
fg.sync('*', { stats: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent>, stats: <fs.Stats> }]
|
||||
```
|
||||
|
||||
> :book: Returns `fs.stat` instead of `fs.lstat` for symbolic links when the [`followSymbolicLinks`](#followsymboliclinks) option is specified.
|
||||
>
|
||||
> :warning: Unlike [object mode](#objectmode) this mode requires additional calls to the file system. On average, this mode is slower at least twice. See [old and modern mode](#old-and-modern-mode) for more details.
|
||||
|
||||
#### unique
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Ensures that the returned entries are unique.
|
||||
|
||||
```js
|
||||
fg.sync(['*.json', 'package.json'], { unique: false }); // ['package.json', 'package.json']
|
||||
fg.sync(['*.json', 'package.json'], { unique: true }); // ['package.json']
|
||||
```
|
||||
|
||||
If `true` and similar entries are found, the result is the first found.
|
||||
|
||||
### Matching control
|
||||
|
||||
#### braceExpansion
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Enables Bash-like brace expansion.
|
||||
|
||||
> :1234: [Syntax description][bash_hackers_syntax_expansion_brace] or more [detailed description][micromatch_braces].
|
||||
|
||||
```js
|
||||
dir/
|
||||
├── abd
|
||||
├── acd
|
||||
└── a{b,c}d
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('a{b,c}d', { braceExpansion: false }); // ['a{b,c}d']
|
||||
fg.sync('a{b,c}d', { braceExpansion: true }); // ['abd', 'acd']
|
||||
```
|
||||
|
||||
#### caseSensitiveMatch
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Enables a [case-sensitive][wikipedia_case_sensitivity] mode for matching files.
|
||||
|
||||
```js
|
||||
dir/
|
||||
├── file.txt
|
||||
└── File.txt
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('file.txt', { caseSensitiveMatch: false }); // ['file.txt', 'File.txt']
|
||||
fg.sync('file.txt', { caseSensitiveMatch: true }); // ['file.txt']
|
||||
```
|
||||
|
||||
#### dot
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Allow patterns to match entries that begin with a period (`.`).
|
||||
|
||||
> :book: Note that an explicit dot in a portion of the pattern will always match dot files.
|
||||
|
||||
```js
|
||||
dir/
|
||||
├── .editorconfig
|
||||
└── package.json
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('*', { dot: false }); // ['package.json']
|
||||
fg.sync('*', { dot: true }); // ['.editorconfig', 'package.json']
|
||||
```
|
||||
|
||||
#### extglob
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Enables Bash-like `extglob` functionality.
|
||||
|
||||
> :1234: [Syntax description][micromatch_extglobs].
|
||||
|
||||
```js
|
||||
dir/
|
||||
├── README.md
|
||||
└── package.json
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('*.+(json|md)', { extglob: false }); // []
|
||||
fg.sync('*.+(json|md)', { extglob: true }); // ['README.md', 'package.json']
|
||||
```
|
||||
|
||||
#### globstar
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Enables recursively repeats a pattern containing `**`. If `false`, `**` behaves exactly like `*`.
|
||||
|
||||
```js
|
||||
dir/
|
||||
└── a
|
||||
└── b
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('**', { onlyFiles: false, globstar: false }); // ['a']
|
||||
fg.sync('**', { onlyFiles: false, globstar: true }); // ['a', 'a/b']
|
||||
```
|
||||
|
||||
#### baseNameMatch
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
If set to `true`, then patterns without slashes will be matched against the basename of the path if it contains slashes.
|
||||
|
||||
```js
|
||||
dir/
|
||||
└── one/
|
||||
└── file.md
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync('*.md', { baseNameMatch: false }); // []
|
||||
fg.sync('*.md', { baseNameMatch: true }); // ['one/file.md']
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
## What is a static or dynamic pattern?
|
||||
|
||||
All patterns can be divided into two types:
|
||||
|
||||
* **static**. A pattern is considered static if it can be used to get an entry on the file system without using matching mechanisms. For example, the `file.js` pattern is a static pattern because we can just verify that it exists on the file system.
|
||||
* **dynamic**. A pattern is considered dynamic if it cannot be used directly to find occurrences without using a matching mechanisms. For example, the `*` pattern is a dynamic pattern because we cannot use this pattern directly.
|
||||
|
||||
A pattern is considered dynamic if it contains the following characters (`…` — any characters or their absence) or options:
|
||||
|
||||
* The [`caseSensitiveMatch`](#casesensitivematch) option is disabled
|
||||
* `\\` (the escape character)
|
||||
* `*`, `?`, `!` (at the beginning of line)
|
||||
* `[…]`
|
||||
* `(…|…)`
|
||||
* `@(…)`, `!(…)`, `*(…)`, `?(…)`, `+(…)` (respects the [`extglob`](#extglob) option)
|
||||
* `{…,…}`, `{…..…}` (respects the [`braceExpansion`](#braceexpansion) option)
|
||||
|
||||
## How to write patterns on Windows?
|
||||
|
||||
Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters. With the [`cwd`](#cwd) option use a convenient format.
|
||||
|
||||
**Bad**
|
||||
|
||||
```ts
|
||||
[
|
||||
'directory\\*',
|
||||
path.join(process.cwd(), '**')
|
||||
]
|
||||
```
|
||||
|
||||
**Good**
|
||||
|
||||
```ts
|
||||
[
|
||||
'directory/*',
|
||||
fg.convertPathToPattern(process.cwd()) + '/**'
|
||||
]
|
||||
```
|
||||
|
||||
> :book: Use the [`.convertPathToPattern`](#convertpathtopatternpath) package to convert Windows-style path to a Unix-style path.
|
||||
|
||||
Read more about [matching with backslashes][micromatch_backslashes].
|
||||
|
||||
## Why are parentheses match wrong?
|
||||
|
||||
```js
|
||||
dir/
|
||||
└── (special-*file).txt
|
||||
```
|
||||
|
||||
```js
|
||||
fg.sync(['(special-*file).txt']) // []
|
||||
```
|
||||
|
||||
Refers to Bash. You need to escape special characters:
|
||||
|
||||
```js
|
||||
fg.sync(['\\(special-*file\\).txt']) // ['(special-*file).txt']
|
||||
```
|
||||
|
||||
Read more about [matching special characters as literals][picomatch_matching_special_characters_as_literals]. Or use the [`.escapePath`](#escapepathpath).
|
||||
|
||||
## How to exclude directory from reading?
|
||||
|
||||
You can use a negative pattern like this: `!**/node_modules` or `!**/node_modules/**`. Also you can use [`ignore`](#ignore) option. Just look at the example below.
|
||||
|
||||
```js
|
||||
first/
|
||||
├── file.md
|
||||
└── second/
|
||||
└── file.txt
|
||||
```
|
||||
|
||||
If you don't want to read the `second` directory, you must write the following pattern: `!**/second` or `!**/second/**`.
|
||||
|
||||
```js
|
||||
fg.sync(['**/*.md', '!**/second']); // ['first/file.md']
|
||||
fg.sync(['**/*.md'], { ignore: ['**/second/**'] }); // ['first/file.md']
|
||||
```
|
||||
|
||||
> :warning: When you write `!**/second/**/*` it means that the directory will be **read**, but all the entries will not be included in the results.
|
||||
|
||||
You have to understand that if you write the pattern to exclude directories, then the directory will not be read under any circumstances.
|
||||
|
||||
## How to use UNC path?
|
||||
|
||||
You cannot use [Uniform Naming Convention (UNC)][unc_path] paths as patterns (due to syntax) directly, but you can use them as [`cwd`](#cwd) directory or use the `fg.convertPathToPattern` method.
|
||||
|
||||
```ts
|
||||
// cwd
|
||||
fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
|
||||
fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });
|
||||
|
||||
// .convertPathToPattern
|
||||
fg.sync(fg.convertPathToPattern('\\\\?\\c:\\Python27') + '/*');
|
||||
```
|
||||
|
||||
## Compatible with `node-glob`?
|
||||
|
||||
| node-glob | fast-glob |
|
||||
| :----------: | :-------: |
|
||||
| `cwd` | [`cwd`](#cwd) |
|
||||
| `root` | – |
|
||||
| `dot` | [`dot`](#dot) |
|
||||
| `nomount` | – |
|
||||
| `mark` | [`markDirectories`](#markdirectories) |
|
||||
| `nosort` | – |
|
||||
| `nounique` | [`unique`](#unique) |
|
||||
| `nobrace` | [`braceExpansion`](#braceexpansion) |
|
||||
| `noglobstar` | [`globstar`](#globstar) |
|
||||
| `noext` | [`extglob`](#extglob) |
|
||||
| `nocase` | [`caseSensitiveMatch`](#casesensitivematch) |
|
||||
| `matchBase` | [`baseNameMatch`](#basenamematch) |
|
||||
| `nodir` | [`onlyFiles`](#onlyfiles) |
|
||||
| `ignore` | [`ignore`](#ignore) |
|
||||
| `follow` | [`followSymbolicLinks`](#followsymboliclinks) |
|
||||
| `realpath` | – |
|
||||
| `absolute` | [`absolute`](#absolute) |
|
||||
|
||||
## Benchmarks
|
||||
|
||||
You can see results [here](https://github.com/mrmlnc/fast-glob/actions/workflows/benchmark.yml?query=branch%3Amaster) for every commit into the `main` branch.
|
||||
|
||||
* **Product benchmark** – comparison with the main competitors.
|
||||
* **Regress benchmark** – regression between the current version and the version from the npm registry.
|
||||
|
||||
## Changelog
|
||||
|
||||
See the [Releases section of our GitHub project][github_releases] for changelog for each release version.
|
||||
|
||||
## License
|
||||
|
||||
This software is released under the terms of the MIT license.
|
||||
|
||||
[bash_hackers_syntax_expansion_brace]: https://wiki.bash-hackers.org/syntax/expansion/brace
|
||||
[github_releases]: https://github.com/mrmlnc/fast-glob/releases
|
||||
[glob_definition]: https://en.wikipedia.org/wiki/Glob_(programming)
|
||||
[glob_linux_man]: http://man7.org/linux/man-pages/man3/glob.3.html
|
||||
[micromatch_backslashes]: https://github.com/micromatch/micromatch#backslashes
|
||||
[micromatch_braces]: https://github.com/micromatch/braces
|
||||
[micromatch_extended_globbing]: https://github.com/micromatch/micromatch#extended-globbing
|
||||
[micromatch_extglobs]: https://github.com/micromatch/micromatch#extglobs
|
||||
[micromatch_regex_character_classes]: https://github.com/micromatch/micromatch#regex-character-classes
|
||||
[micromatch]: https://github.com/micromatch/micromatch
|
||||
[node_js_fs_class_fs_dirent]: https://nodejs.org/api/fs.html#fs_class_fs_dirent
|
||||
[node_js_fs_class_fs_stats]: https://nodejs.org/api/fs.html#fs_class_fs_stats
|
||||
[node_js_stream_readable_streams]: https://nodejs.org/api/stream.html#stream_readable_streams
|
||||
[node_js]: https://nodejs.org/en
|
||||
[nodelib_fs_scandir_old_and_modern_modern]: https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode
|
||||
[npm_normalize_path]: https://www.npmjs.com/package/normalize-path
|
||||
[npm_unixify]: https://www.npmjs.com/package/unixify
|
||||
[picomatch_matching_behavior]: https://github.com/micromatch/picomatch#matching-behavior-vs-bash
|
||||
[picomatch_matching_special_characters_as_literals]: https://github.com/micromatch/picomatch#matching-special-characters-as-literals
|
||||
[picomatch_posix_brackets]: https://github.com/micromatch/picomatch#posix-brackets
|
||||
[regular_expressions_brackets]: https://www.regular-expressions.info/brackets.html
|
||||
[unc_path]: https://learn.microsoft.com/openspecs/windows_protocols/ms-dtyp/62e862f4-2a51-452e-8eeb-dc4ff5ee33cc
|
||||
[wikipedia_case_sensitivity]: https://en.wikipedia.org/wiki/Case_sensitivity
|
||||
[nodejs_thread_pool]: https://nodejs.org/en/docs/guides/dont-block-the-event-loop
|
||||
[libuv_thread_pool]: http://docs.libuv.org/en/v1.x/threadpool.html
|
||||
[windows_naming_conventions]: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
|
||||
40
node_modules/fast-glob/out/index.d.ts
generated
vendored
Normal file
40
node_modules/fast-glob/out/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/// <reference types="node" />
|
||||
import * as taskManager from './managers/tasks';
|
||||
import { Options as OptionsInternal } from './settings';
|
||||
import { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
|
||||
type EntryObjectModePredicate = {
|
||||
[TKey in keyof Pick<OptionsInternal, 'objectMode'>]-?: true;
|
||||
};
|
||||
type EntryStatsPredicate = {
|
||||
[TKey in keyof Pick<OptionsInternal, 'stats'>]-?: true;
|
||||
};
|
||||
type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
|
||||
declare function FastGlob(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): Promise<EntryInternal[]>;
|
||||
declare function FastGlob(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Promise<string[]>;
|
||||
declare namespace FastGlob {
|
||||
type Options = OptionsInternal;
|
||||
type Entry = EntryInternal;
|
||||
type Task = taskManager.Task;
|
||||
type Pattern = PatternInternal;
|
||||
type FileSystemAdapter = FileSystemAdapterInternal;
|
||||
const glob: typeof FastGlob;
|
||||
const globSync: typeof sync;
|
||||
const globStream: typeof stream;
|
||||
const async: typeof FastGlob;
|
||||
function sync(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): EntryInternal[];
|
||||
function sync(source: PatternInternal | PatternInternal[], options?: OptionsInternal): string[];
|
||||
function stream(source: PatternInternal | PatternInternal[], options?: OptionsInternal): NodeJS.ReadableStream;
|
||||
function generateTasks(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Task[];
|
||||
function isDynamicPattern(source: PatternInternal, options?: OptionsInternal): boolean;
|
||||
function escapePath(source: string): PatternInternal;
|
||||
function convertPathToPattern(source: string): PatternInternal;
|
||||
namespace posix {
|
||||
function escapePath(source: string): PatternInternal;
|
||||
function convertPathToPattern(source: string): PatternInternal;
|
||||
}
|
||||
namespace win32 {
|
||||
function escapePath(source: string): PatternInternal;
|
||||
function convertPathToPattern(source: string): PatternInternal;
|
||||
}
|
||||
}
|
||||
export = FastGlob;
|
||||
102
node_modules/fast-glob/out/index.js
generated
vendored
Normal file
102
node_modules/fast-glob/out/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
"use strict";
|
||||
const taskManager = require("./managers/tasks");
|
||||
const async_1 = require("./providers/async");
|
||||
const stream_1 = require("./providers/stream");
|
||||
const sync_1 = require("./providers/sync");
|
||||
const settings_1 = require("./settings");
|
||||
const utils = require("./utils");
|
||||
async function FastGlob(source, options) {
|
||||
assertPatternsInput(source);
|
||||
const works = getWorks(source, async_1.default, options);
|
||||
const result = await Promise.all(works);
|
||||
return utils.array.flatten(result);
|
||||
}
|
||||
// https://github.com/typescript-eslint/typescript-eslint/issues/60
|
||||
// eslint-disable-next-line no-redeclare
|
||||
(function (FastGlob) {
|
||||
FastGlob.glob = FastGlob;
|
||||
FastGlob.globSync = sync;
|
||||
FastGlob.globStream = stream;
|
||||
FastGlob.async = FastGlob;
|
||||
function sync(source, options) {
|
||||
assertPatternsInput(source);
|
||||
const works = getWorks(source, sync_1.default, options);
|
||||
return utils.array.flatten(works);
|
||||
}
|
||||
FastGlob.sync = sync;
|
||||
function stream(source, options) {
|
||||
assertPatternsInput(source);
|
||||
const works = getWorks(source, stream_1.default, options);
|
||||
/**
|
||||
* The stream returned by the provider cannot work with an asynchronous iterator.
|
||||
* To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
|
||||
* This affects performance (+25%). I don't see best solution right now.
|
||||
*/
|
||||
return utils.stream.merge(works);
|
||||
}
|
||||
FastGlob.stream = stream;
|
||||
function generateTasks(source, options) {
|
||||
assertPatternsInput(source);
|
||||
const patterns = [].concat(source);
|
||||
const settings = new settings_1.default(options);
|
||||
return taskManager.generate(patterns, settings);
|
||||
}
|
||||
FastGlob.generateTasks = generateTasks;
|
||||
function isDynamicPattern(source, options) {
|
||||
assertPatternsInput(source);
|
||||
const settings = new settings_1.default(options);
|
||||
return utils.pattern.isDynamicPattern(source, settings);
|
||||
}
|
||||
FastGlob.isDynamicPattern = isDynamicPattern;
|
||||
function escapePath(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.escape(source);
|
||||
}
|
||||
FastGlob.escapePath = escapePath;
|
||||
function convertPathToPattern(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.convertPathToPattern(source);
|
||||
}
|
||||
FastGlob.convertPathToPattern = convertPathToPattern;
|
||||
let posix;
|
||||
(function (posix) {
|
||||
function escapePath(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.escapePosixPath(source);
|
||||
}
|
||||
posix.escapePath = escapePath;
|
||||
function convertPathToPattern(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.convertPosixPathToPattern(source);
|
||||
}
|
||||
posix.convertPathToPattern = convertPathToPattern;
|
||||
})(posix = FastGlob.posix || (FastGlob.posix = {}));
|
||||
let win32;
|
||||
(function (win32) {
|
||||
function escapePath(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.escapeWindowsPath(source);
|
||||
}
|
||||
win32.escapePath = escapePath;
|
||||
function convertPathToPattern(source) {
|
||||
assertPatternsInput(source);
|
||||
return utils.path.convertWindowsPathToPattern(source);
|
||||
}
|
||||
win32.convertPathToPattern = convertPathToPattern;
|
||||
})(win32 = FastGlob.win32 || (FastGlob.win32 = {}));
|
||||
})(FastGlob || (FastGlob = {}));
|
||||
function getWorks(source, _Provider, options) {
|
||||
const patterns = [].concat(source);
|
||||
const settings = new settings_1.default(options);
|
||||
const tasks = taskManager.generate(patterns, settings);
|
||||
const provider = new _Provider(settings);
|
||||
return tasks.map(provider.read, provider);
|
||||
}
|
||||
function assertPatternsInput(input) {
|
||||
const source = [].concat(input);
|
||||
const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
|
||||
if (!isValidSource) {
|
||||
throw new TypeError('Patterns must be a string (non empty) or an array of strings');
|
||||
}
|
||||
}
|
||||
module.exports = FastGlob;
|
||||
22
node_modules/fast-glob/out/managers/tasks.d.ts
generated
vendored
Normal file
22
node_modules/fast-glob/out/managers/tasks.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
import Settings from '../settings';
|
||||
import { Pattern, PatternsGroup } from '../types';
|
||||
export type Task = {
|
||||
base: string;
|
||||
dynamic: boolean;
|
||||
patterns: Pattern[];
|
||||
positive: Pattern[];
|
||||
negative: Pattern[];
|
||||
};
|
||||
export declare function generate(input: Pattern[], settings: Settings): Task[];
|
||||
/**
|
||||
* Returns tasks grouped by basic pattern directories.
|
||||
*
|
||||
* Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
|
||||
* This is necessary because directory traversal starts at the base directory and goes deeper.
|
||||
*/
|
||||
export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): Task[];
|
||||
export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
|
||||
export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
|
||||
export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
|
||||
export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): Task[];
|
||||
export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): Task;
|
||||
110
node_modules/fast-glob/out/managers/tasks.js
generated
vendored
Normal file
110
node_modules/fast-glob/out/managers/tasks.js
generated
vendored
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
|
||||
const utils = require("../utils");
|
||||
function generate(input, settings) {
|
||||
const patterns = processPatterns(input, settings);
|
||||
const ignore = processPatterns(settings.ignore, settings);
|
||||
const positivePatterns = getPositivePatterns(patterns);
|
||||
const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
|
||||
const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
|
||||
const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
|
||||
const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
|
||||
const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
|
||||
return staticTasks.concat(dynamicTasks);
|
||||
}
|
||||
exports.generate = generate;
|
||||
function processPatterns(input, settings) {
|
||||
let patterns = input;
|
||||
/**
|
||||
* The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
|
||||
* and some problems with the micromatch package (see fast-glob issues: #365, #394).
|
||||
*
|
||||
* To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
|
||||
* in matching in the case of a large set of patterns after expansion.
|
||||
*/
|
||||
if (settings.braceExpansion) {
|
||||
patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
|
||||
}
|
||||
/**
|
||||
* If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
|
||||
* at any nesting level.
|
||||
*
|
||||
* We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
|
||||
* the pattern in the filter before creating a regular expression. There is no need to change the patterns
|
||||
* in the application. Only on the input.
|
||||
*/
|
||||
if (settings.baseNameMatch) {
|
||||
patterns = patterns.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`);
|
||||
}
|
||||
/**
|
||||
* This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
|
||||
*/
|
||||
return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
|
||||
}
|
||||
/**
|
||||
* Returns tasks grouped by basic pattern directories.
|
||||
*
|
||||
* Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
|
||||
* This is necessary because directory traversal starts at the base directory and goes deeper.
|
||||
*/
|
||||
function convertPatternsToTasks(positive, negative, dynamic) {
|
||||
const tasks = [];
|
||||
const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
|
||||
const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
|
||||
const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
|
||||
const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
|
||||
tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
|
||||
/*
|
||||
* For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
|
||||
* into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
|
||||
*/
|
||||
if ('.' in insideCurrentDirectoryGroup) {
|
||||
tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
|
||||
}
|
||||
else {
|
||||
tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
|
||||
}
|
||||
return tasks;
|
||||
}
|
||||
exports.convertPatternsToTasks = convertPatternsToTasks;
|
||||
function getPositivePatterns(patterns) {
|
||||
return utils.pattern.getPositivePatterns(patterns);
|
||||
}
|
||||
exports.getPositivePatterns = getPositivePatterns;
|
||||
function getNegativePatternsAsPositive(patterns, ignore) {
|
||||
const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
|
||||
const positive = negative.map(utils.pattern.convertToPositivePattern);
|
||||
return positive;
|
||||
}
|
||||
exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
|
||||
function groupPatternsByBaseDirectory(patterns) {
|
||||
const group = {};
|
||||
return patterns.reduce((collection, pattern) => {
|
||||
const base = utils.pattern.getBaseDirectory(pattern);
|
||||
if (base in collection) {
|
||||
collection[base].push(pattern);
|
||||
}
|
||||
else {
|
||||
collection[base] = [pattern];
|
||||
}
|
||||
return collection;
|
||||
}, group);
|
||||
}
|
||||
exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
|
||||
function convertPatternGroupsToTasks(positive, negative, dynamic) {
|
||||
return Object.keys(positive).map((base) => {
|
||||
return convertPatternGroupToTask(base, positive[base], negative, dynamic);
|
||||
});
|
||||
}
|
||||
exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
|
||||
function convertPatternGroupToTask(base, positive, negative, dynamic) {
|
||||
return {
|
||||
dynamic,
|
||||
positive,
|
||||
negative,
|
||||
base,
|
||||
patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
|
||||
};
|
||||
}
|
||||
exports.convertPatternGroupToTask = convertPatternGroupToTask;
|
||||
9
node_modules/fast-glob/out/providers/async.d.ts
generated
vendored
Normal file
9
node_modules/fast-glob/out/providers/async.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
import { Task } from '../managers/tasks';
|
||||
import { Entry, EntryItem, ReaderOptions } from '../types';
|
||||
import ReaderAsync from '../readers/async';
|
||||
import Provider from './provider';
|
||||
export default class ProviderAsync extends Provider<Promise<EntryItem[]>> {
|
||||
protected _reader: ReaderAsync;
|
||||
read(task: Task): Promise<EntryItem[]>;
|
||||
api(root: string, task: Task, options: ReaderOptions): Promise<Entry[]>;
|
||||
}
|
||||
23
node_modules/fast-glob/out/providers/async.js
generated
vendored
Normal file
23
node_modules/fast-glob/out/providers/async.js
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const async_1 = require("../readers/async");
|
||||
const provider_1 = require("./provider");
|
||||
class ProviderAsync extends provider_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._reader = new async_1.default(this._settings);
|
||||
}
|
||||
async read(task) {
|
||||
const root = this._getRootDirectory(task);
|
||||
const options = this._getReaderOptions(task);
|
||||
const entries = await this.api(root, task, options);
|
||||
return entries.map((entry) => options.transform(entry));
|
||||
}
|
||||
api(root, task, options) {
|
||||
if (task.dynamic) {
|
||||
return this._reader.dynamic(root, options);
|
||||
}
|
||||
return this._reader.static(task.patterns, options);
|
||||
}
|
||||
}
|
||||
exports.default = ProviderAsync;
|
||||
16
node_modules/fast-glob/out/providers/filters/deep.d.ts
generated
vendored
Normal file
16
node_modules/fast-glob/out/providers/filters/deep.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
import { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
|
||||
import Settings from '../../settings';
|
||||
export default class DeepFilter {
|
||||
private readonly _settings;
|
||||
private readonly _micromatchOptions;
|
||||
constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
|
||||
getFilter(basePath: string, positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
|
||||
private _getMatcher;
|
||||
private _getNegativePatternsRe;
|
||||
private _filter;
|
||||
private _isSkippedByDeep;
|
||||
private _getEntryLevel;
|
||||
private _isSkippedSymbolicLink;
|
||||
private _isSkippedByPositivePatterns;
|
||||
private _isSkippedByNegativePatterns;
|
||||
}
|
||||
62
node_modules/fast-glob/out/providers/filters/deep.js
generated
vendored
Normal file
62
node_modules/fast-glob/out/providers/filters/deep.js
generated
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils = require("../../utils");
|
||||
const partial_1 = require("../matchers/partial");
|
||||
class DeepFilter {
|
||||
constructor(_settings, _micromatchOptions) {
|
||||
this._settings = _settings;
|
||||
this._micromatchOptions = _micromatchOptions;
|
||||
}
|
||||
getFilter(basePath, positive, negative) {
|
||||
const matcher = this._getMatcher(positive);
|
||||
const negativeRe = this._getNegativePatternsRe(negative);
|
||||
return (entry) => this._filter(basePath, entry, matcher, negativeRe);
|
||||
}
|
||||
_getMatcher(patterns) {
|
||||
return new partial_1.default(patterns, this._settings, this._micromatchOptions);
|
||||
}
|
||||
_getNegativePatternsRe(patterns) {
|
||||
const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
|
||||
return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
|
||||
}
|
||||
_filter(basePath, entry, matcher, negativeRe) {
|
||||
if (this._isSkippedByDeep(basePath, entry.path)) {
|
||||
return false;
|
||||
}
|
||||
if (this._isSkippedSymbolicLink(entry)) {
|
||||
return false;
|
||||
}
|
||||
const filepath = utils.path.removeLeadingDotSegment(entry.path);
|
||||
if (this._isSkippedByPositivePatterns(filepath, matcher)) {
|
||||
return false;
|
||||
}
|
||||
return this._isSkippedByNegativePatterns(filepath, negativeRe);
|
||||
}
|
||||
_isSkippedByDeep(basePath, entryPath) {
|
||||
/**
|
||||
* Avoid unnecessary depth calculations when it doesn't matter.
|
||||
*/
|
||||
if (this._settings.deep === Infinity) {
|
||||
return false;
|
||||
}
|
||||
return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
|
||||
}
|
||||
_getEntryLevel(basePath, entryPath) {
|
||||
const entryPathDepth = entryPath.split('/').length;
|
||||
if (basePath === '') {
|
||||
return entryPathDepth;
|
||||
}
|
||||
const basePathDepth = basePath.split('/').length;
|
||||
return entryPathDepth - basePathDepth;
|
||||
}
|
||||
_isSkippedSymbolicLink(entry) {
|
||||
return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
|
||||
}
|
||||
_isSkippedByPositivePatterns(entryPath, matcher) {
|
||||
return !this._settings.baseNameMatch && !matcher.match(entryPath);
|
||||
}
|
||||
_isSkippedByNegativePatterns(entryPath, patternsRe) {
|
||||
return !utils.pattern.matchAny(entryPath, patternsRe);
|
||||
}
|
||||
}
|
||||
exports.default = DeepFilter;
|
||||
16
node_modules/fast-glob/out/providers/filters/entry.d.ts
generated
vendored
Normal file
16
node_modules/fast-glob/out/providers/filters/entry.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
import Settings from '../../settings';
|
||||
import { EntryFilterFunction, MicromatchOptions, Pattern } from '../../types';
|
||||
export default class EntryFilter {
|
||||
private readonly _settings;
|
||||
private readonly _micromatchOptions;
|
||||
readonly index: Map<string, undefined>;
|
||||
constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
|
||||
getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
|
||||
private _filter;
|
||||
private _isDuplicateEntry;
|
||||
private _createIndexRecord;
|
||||
private _onlyFileFilter;
|
||||
private _onlyDirectoryFilter;
|
||||
private _isSkippedByAbsoluteNegativePatterns;
|
||||
private _isMatchToPatterns;
|
||||
}
|
||||
63
node_modules/fast-glob/out/providers/filters/entry.js
generated
vendored
Normal file
63
node_modules/fast-glob/out/providers/filters/entry.js
generated
vendored
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils = require("../../utils");
|
||||
class EntryFilter {
|
||||
constructor(_settings, _micromatchOptions) {
|
||||
this._settings = _settings;
|
||||
this._micromatchOptions = _micromatchOptions;
|
||||
this.index = new Map();
|
||||
}
|
||||
getFilter(positive, negative) {
|
||||
const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
|
||||
const negativeRe = utils.pattern.convertPatternsToRe(negative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }));
|
||||
return (entry) => this._filter(entry, positiveRe, negativeRe);
|
||||
}
|
||||
_filter(entry, positiveRe, negativeRe) {
|
||||
const filepath = utils.path.removeLeadingDotSegment(entry.path);
|
||||
if (this._settings.unique && this._isDuplicateEntry(filepath)) {
|
||||
return false;
|
||||
}
|
||||
if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
|
||||
return false;
|
||||
}
|
||||
if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
|
||||
return false;
|
||||
}
|
||||
const isDirectory = entry.dirent.isDirectory();
|
||||
const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
|
||||
if (this._settings.unique && isMatched) {
|
||||
this._createIndexRecord(filepath);
|
||||
}
|
||||
return isMatched;
|
||||
}
|
||||
_isDuplicateEntry(filepath) {
|
||||
return this.index.has(filepath);
|
||||
}
|
||||
_createIndexRecord(filepath) {
|
||||
this.index.set(filepath, undefined);
|
||||
}
|
||||
_onlyFileFilter(entry) {
|
||||
return this._settings.onlyFiles && !entry.dirent.isFile();
|
||||
}
|
||||
_onlyDirectoryFilter(entry) {
|
||||
return this._settings.onlyDirectories && !entry.dirent.isDirectory();
|
||||
}
|
||||
_isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
|
||||
if (!this._settings.absolute) {
|
||||
return false;
|
||||
}
|
||||
const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
|
||||
return utils.pattern.matchAny(fullpath, patternsRe);
|
||||
}
|
||||
_isMatchToPatterns(filepath, patternsRe, isDirectory) {
|
||||
// Trying to match files and directories by patterns.
|
||||
const isMatched = utils.pattern.matchAny(filepath, patternsRe);
|
||||
// A pattern with a trailling slash can be used for directory matching.
|
||||
// To apply such pattern, we need to add a tralling slash to the path.
|
||||
if (!isMatched && isDirectory) {
|
||||
return utils.pattern.matchAny(filepath + '/', patternsRe);
|
||||
}
|
||||
return isMatched;
|
||||
}
|
||||
}
|
||||
exports.default = EntryFilter;
|
||||
8
node_modules/fast-glob/out/providers/filters/error.d.ts
generated
vendored
Normal file
8
node_modules/fast-glob/out/providers/filters/error.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
import Settings from '../../settings';
|
||||
import { ErrorFilterFunction } from '../../types';
|
||||
export default class ErrorFilter {
|
||||
private readonly _settings;
|
||||
constructor(_settings: Settings);
|
||||
getFilter(): ErrorFilterFunction;
|
||||
private _isNonFatalError;
|
||||
}
|
||||
15
node_modules/fast-glob/out/providers/filters/error.js
generated
vendored
Normal file
15
node_modules/fast-glob/out/providers/filters/error.js
generated
vendored
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils = require("../../utils");
|
||||
class ErrorFilter {
|
||||
constructor(_settings) {
|
||||
this._settings = _settings;
|
||||
}
|
||||
getFilter() {
|
||||
return (error) => this._isNonFatalError(error);
|
||||
}
|
||||
_isNonFatalError(error) {
|
||||
return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
|
||||
}
|
||||
}
|
||||
exports.default = ErrorFilter;
|
||||
33
node_modules/fast-glob/out/providers/matchers/matcher.d.ts
generated
vendored
Normal file
33
node_modules/fast-glob/out/providers/matchers/matcher.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
import { Pattern, MicromatchOptions, PatternRe } from '../../types';
|
||||
import Settings from '../../settings';
|
||||
export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
|
||||
type StaticPatternSegment = {
|
||||
dynamic: false;
|
||||
pattern: Pattern;
|
||||
};
|
||||
type DynamicPatternSegment = {
|
||||
dynamic: true;
|
||||
pattern: Pattern;
|
||||
patternRe: PatternRe;
|
||||
};
|
||||
export type PatternSection = PatternSegment[];
|
||||
export type PatternInfo = {
|
||||
/**
|
||||
* Indicates that the pattern has a globstar (more than a single section).
|
||||
*/
|
||||
complete: boolean;
|
||||
pattern: Pattern;
|
||||
segments: PatternSegment[];
|
||||
sections: PatternSection[];
|
||||
};
|
||||
export default abstract class Matcher {
|
||||
private readonly _patterns;
|
||||
private readonly _settings;
|
||||
private readonly _micromatchOptions;
|
||||
protected readonly _storage: PatternInfo[];
|
||||
constructor(_patterns: Pattern[], _settings: Settings, _micromatchOptions: MicromatchOptions);
|
||||
private _fillStorage;
|
||||
private _getPatternSegments;
|
||||
private _splitSegmentsIntoSections;
|
||||
}
|
||||
export {};
|
||||
45
node_modules/fast-glob/out/providers/matchers/matcher.js
generated
vendored
Normal file
45
node_modules/fast-glob/out/providers/matchers/matcher.js
generated
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils = require("../../utils");
|
||||
class Matcher {
|
||||
constructor(_patterns, _settings, _micromatchOptions) {
|
||||
this._patterns = _patterns;
|
||||
this._settings = _settings;
|
||||
this._micromatchOptions = _micromatchOptions;
|
||||
this._storage = [];
|
||||
this._fillStorage();
|
||||
}
|
||||
_fillStorage() {
|
||||
for (const pattern of this._patterns) {
|
||||
const segments = this._getPatternSegments(pattern);
|
||||
const sections = this._splitSegmentsIntoSections(segments);
|
||||
this._storage.push({
|
||||
complete: sections.length <= 1,
|
||||
pattern,
|
||||
segments,
|
||||
sections
|
||||
});
|
||||
}
|
||||
}
|
||||
_getPatternSegments(pattern) {
|
||||
const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
|
||||
return parts.map((part) => {
|
||||
const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
|
||||
if (!dynamic) {
|
||||
return {
|
||||
dynamic: false,
|
||||
pattern: part
|
||||
};
|
||||
}
|
||||
return {
|
||||
dynamic: true,
|
||||
pattern: part,
|
||||
patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
|
||||
};
|
||||
});
|
||||
}
|
||||
_splitSegmentsIntoSections(segments) {
|
||||
return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
|
||||
}
|
||||
}
|
||||
exports.default = Matcher;
|
||||
4
node_modules/fast-glob/out/providers/matchers/partial.d.ts
generated
vendored
Normal file
4
node_modules/fast-glob/out/providers/matchers/partial.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
import Matcher from './matcher';
|
||||
export default class PartialMatcher extends Matcher {
|
||||
match(filepath: string): boolean;
|
||||
}
|
||||
38
node_modules/fast-glob/out/providers/matchers/partial.js
generated
vendored
Normal file
38
node_modules/fast-glob/out/providers/matchers/partial.js
generated
vendored
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const matcher_1 = require("./matcher");
|
||||
class PartialMatcher extends matcher_1.default {
|
||||
match(filepath) {
|
||||
const parts = filepath.split('/');
|
||||
const levels = parts.length;
|
||||
const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
|
||||
for (const pattern of patterns) {
|
||||
const section = pattern.sections[0];
|
||||
/**
|
||||
* In this case, the pattern has a globstar and we must read all directories unconditionally,
|
||||
* but only if the level has reached the end of the first group.
|
||||
*
|
||||
* fixtures/{a,b}/**
|
||||
* ^ true/false ^ always true
|
||||
*/
|
||||
if (!pattern.complete && levels > section.length) {
|
||||
return true;
|
||||
}
|
||||
const match = parts.every((part, index) => {
|
||||
const segment = pattern.segments[index];
|
||||
if (segment.dynamic && segment.patternRe.test(part)) {
|
||||
return true;
|
||||
}
|
||||
if (!segment.dynamic && segment.pattern === part) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
if (match) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
exports.default = PartialMatcher;
|
||||
19
node_modules/fast-glob/out/providers/provider.d.ts
generated
vendored
Normal file
19
node_modules/fast-glob/out/providers/provider.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
import { Task } from '../managers/tasks';
|
||||
import Settings from '../settings';
|
||||
import { MicromatchOptions, ReaderOptions } from '../types';
|
||||
import DeepFilter from './filters/deep';
|
||||
import EntryFilter from './filters/entry';
|
||||
import ErrorFilter from './filters/error';
|
||||
import EntryTransformer from './transformers/entry';
|
||||
export default abstract class Provider<T> {
|
||||
protected readonly _settings: Settings;
|
||||
readonly errorFilter: ErrorFilter;
|
||||
readonly entryFilter: EntryFilter;
|
||||
readonly deepFilter: DeepFilter;
|
||||
readonly entryTransformer: EntryTransformer;
|
||||
constructor(_settings: Settings);
|
||||
abstract read(_task: Task): T;
|
||||
protected _getRootDirectory(task: Task): string;
|
||||
protected _getReaderOptions(task: Task): ReaderOptions;
|
||||
protected _getMicromatchOptions(): MicromatchOptions;
|
||||
}
|
||||
48
node_modules/fast-glob/out/providers/provider.js
generated
vendored
Normal file
48
node_modules/fast-glob/out/providers/provider.js
generated
vendored
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const path = require("path");
|
||||
const deep_1 = require("./filters/deep");
|
||||
const entry_1 = require("./filters/entry");
|
||||
const error_1 = require("./filters/error");
|
||||
const entry_2 = require("./transformers/entry");
|
||||
class Provider {
|
||||
constructor(_settings) {
|
||||
this._settings = _settings;
|
||||
this.errorFilter = new error_1.default(this._settings);
|
||||
this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
|
||||
this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
|
||||
this.entryTransformer = new entry_2.default(this._settings);
|
||||
}
|
||||
_getRootDirectory(task) {
|
||||
return path.resolve(this._settings.cwd, task.base);
|
||||
}
|
||||
_getReaderOptions(task) {
|
||||
const basePath = task.base === '.' ? '' : task.base;
|
||||
return {
|
||||
basePath,
|
||||
pathSegmentSeparator: '/',
|
||||
concurrency: this._settings.concurrency,
|
||||
deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
|
||||
entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
|
||||
errorFilter: this.errorFilter.getFilter(),
|
||||
followSymbolicLinks: this._settings.followSymbolicLinks,
|
||||
fs: this._settings.fs,
|
||||
stats: this._settings.stats,
|
||||
throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
|
||||
transform: this.entryTransformer.getTransformer()
|
||||
};
|
||||
}
|
||||
_getMicromatchOptions() {
|
||||
return {
|
||||
dot: this._settings.dot,
|
||||
matchBase: this._settings.baseNameMatch,
|
||||
nobrace: !this._settings.braceExpansion,
|
||||
nocase: !this._settings.caseSensitiveMatch,
|
||||
noext: !this._settings.extglob,
|
||||
noglobstar: !this._settings.globstar,
|
||||
posix: true,
|
||||
strictSlashes: false
|
||||
};
|
||||
}
|
||||
}
|
||||
exports.default = Provider;
|
||||
11
node_modules/fast-glob/out/providers/stream.d.ts
generated
vendored
Normal file
11
node_modules/fast-glob/out/providers/stream.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
/// <reference types="node" />
|
||||
import { Readable } from 'stream';
|
||||
import { Task } from '../managers/tasks';
|
||||
import ReaderStream from '../readers/stream';
|
||||
import { ReaderOptions } from '../types';
|
||||
import Provider from './provider';
|
||||
export default class ProviderStream extends Provider<Readable> {
|
||||
protected _reader: ReaderStream;
|
||||
read(task: Task): Readable;
|
||||
api(root: string, task: Task, options: ReaderOptions): Readable;
|
||||
}
|
||||
31
node_modules/fast-glob/out/providers/stream.js
generated
vendored
Normal file
31
node_modules/fast-glob/out/providers/stream.js
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const stream_1 = require("stream");
|
||||
const stream_2 = require("../readers/stream");
|
||||
const provider_1 = require("./provider");
|
||||
class ProviderStream extends provider_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._reader = new stream_2.default(this._settings);
|
||||
}
|
||||
read(task) {
|
||||
const root = this._getRootDirectory(task);
|
||||
const options = this._getReaderOptions(task);
|
||||
const source = this.api(root, task, options);
|
||||
const destination = new stream_1.Readable({ objectMode: true, read: () => { } });
|
||||
source
|
||||
.once('error', (error) => destination.emit('error', error))
|
||||
.on('data', (entry) => destination.emit('data', options.transform(entry)))
|
||||
.once('end', () => destination.emit('end'));
|
||||
destination
|
||||
.once('close', () => source.destroy());
|
||||
return destination;
|
||||
}
|
||||
api(root, task, options) {
|
||||
if (task.dynamic) {
|
||||
return this._reader.dynamic(root, options);
|
||||
}
|
||||
return this._reader.static(task.patterns, options);
|
||||
}
|
||||
}
|
||||
exports.default = ProviderStream;
|
||||
9
node_modules/fast-glob/out/providers/sync.d.ts
generated
vendored
Normal file
9
node_modules/fast-glob/out/providers/sync.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
import { Task } from '../managers/tasks';
|
||||
import ReaderSync from '../readers/sync';
|
||||
import { Entry, EntryItem, ReaderOptions } from '../types';
|
||||
import Provider from './provider';
|
||||
export default class ProviderSync extends Provider<EntryItem[]> {
|
||||
protected _reader: ReaderSync;
|
||||
read(task: Task): EntryItem[];
|
||||
api(root: string, task: Task, options: ReaderOptions): Entry[];
|
||||
}
|
||||
23
node_modules/fast-glob/out/providers/sync.js
generated
vendored
Normal file
23
node_modules/fast-glob/out/providers/sync.js
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const sync_1 = require("../readers/sync");
|
||||
const provider_1 = require("./provider");
|
||||
class ProviderSync extends provider_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._reader = new sync_1.default(this._settings);
|
||||
}
|
||||
read(task) {
|
||||
const root = this._getRootDirectory(task);
|
||||
const options = this._getReaderOptions(task);
|
||||
const entries = this.api(root, task, options);
|
||||
return entries.map(options.transform);
|
||||
}
|
||||
api(root, task, options) {
|
||||
if (task.dynamic) {
|
||||
return this._reader.dynamic(root, options);
|
||||
}
|
||||
return this._reader.static(task.patterns, options);
|
||||
}
|
||||
}
|
||||
exports.default = ProviderSync;
|
||||
8
node_modules/fast-glob/out/providers/transformers/entry.d.ts
generated
vendored
Normal file
8
node_modules/fast-glob/out/providers/transformers/entry.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
import Settings from '../../settings';
|
||||
import { EntryTransformerFunction } from '../../types';
|
||||
export default class EntryTransformer {
|
||||
private readonly _settings;
|
||||
constructor(_settings: Settings);
|
||||
getTransformer(): EntryTransformerFunction;
|
||||
private _transform;
|
||||
}
|
||||
26
node_modules/fast-glob/out/providers/transformers/entry.js
generated
vendored
Normal file
26
node_modules/fast-glob/out/providers/transformers/entry.js
generated
vendored
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils = require("../../utils");
|
||||
class EntryTransformer {
|
||||
constructor(_settings) {
|
||||
this._settings = _settings;
|
||||
}
|
||||
getTransformer() {
|
||||
return (entry) => this._transform(entry);
|
||||
}
|
||||
_transform(entry) {
|
||||
let filepath = entry.path;
|
||||
if (this._settings.absolute) {
|
||||
filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
|
||||
filepath = utils.path.unixify(filepath);
|
||||
}
|
||||
if (this._settings.markDirectories && entry.dirent.isDirectory()) {
|
||||
filepath += '/';
|
||||
}
|
||||
if (!this._settings.objectMode) {
|
||||
return filepath;
|
||||
}
|
||||
return Object.assign(Object.assign({}, entry), { path: filepath });
|
||||
}
|
||||
}
|
||||
exports.default = EntryTransformer;
|
||||
10
node_modules/fast-glob/out/readers/async.d.ts
generated
vendored
Normal file
10
node_modules/fast-glob/out/readers/async.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
import * as fsWalk from '@nodelib/fs.walk';
|
||||
import { Entry, ReaderOptions, Pattern } from '../types';
|
||||
import Reader from './reader';
|
||||
import ReaderStream from './stream';
|
||||
export default class ReaderAsync extends Reader<Promise<Entry[]>> {
|
||||
protected _walkAsync: typeof fsWalk.walk;
|
||||
protected _readerStream: ReaderStream;
|
||||
dynamic(root: string, options: ReaderOptions): Promise<Entry[]>;
|
||||
static(patterns: Pattern[], options: ReaderOptions): Promise<Entry[]>;
|
||||
}
|
||||
35
node_modules/fast-glob/out/readers/async.js
generated
vendored
Normal file
35
node_modules/fast-glob/out/readers/async.js
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const fsWalk = require("@nodelib/fs.walk");
|
||||
const reader_1 = require("./reader");
|
||||
const stream_1 = require("./stream");
|
||||
class ReaderAsync extends reader_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._walkAsync = fsWalk.walk;
|
||||
this._readerStream = new stream_1.default(this._settings);
|
||||
}
|
||||
dynamic(root, options) {
|
||||
return new Promise((resolve, reject) => {
|
||||
this._walkAsync(root, options, (error, entries) => {
|
||||
if (error === null) {
|
||||
resolve(entries);
|
||||
}
|
||||
else {
|
||||
reject(error);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
async static(patterns, options) {
|
||||
const entries = [];
|
||||
const stream = this._readerStream.static(patterns, options);
|
||||
// After #235, replace it with an asynchronous iterator.
|
||||
return new Promise((resolve, reject) => {
|
||||
stream.once('error', reject);
|
||||
stream.on('data', (entry) => entries.push(entry));
|
||||
stream.once('end', () => resolve(entries));
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.default = ReaderAsync;
|
||||
15
node_modules/fast-glob/out/readers/reader.d.ts
generated
vendored
Normal file
15
node_modules/fast-glob/out/readers/reader.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
/// <reference types="node" />
|
||||
import * as fs from 'fs';
|
||||
import * as fsStat from '@nodelib/fs.stat';
|
||||
import Settings from '../settings';
|
||||
import { Entry, ErrnoException, Pattern, ReaderOptions } from '../types';
|
||||
export default abstract class Reader<T> {
|
||||
protected readonly _settings: Settings;
|
||||
protected readonly _fsStatSettings: fsStat.Settings;
|
||||
constructor(_settings: Settings);
|
||||
abstract dynamic(root: string, options: ReaderOptions): T;
|
||||
abstract static(patterns: Pattern[], options: ReaderOptions): T;
|
||||
protected _getFullEntryPath(filepath: string): string;
|
||||
protected _makeEntry(stats: fs.Stats, pattern: Pattern): Entry;
|
||||
protected _isFatalError(error: ErrnoException): boolean;
|
||||
}
|
||||
33
node_modules/fast-glob/out/readers/reader.js
generated
vendored
Normal file
33
node_modules/fast-glob/out/readers/reader.js
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const path = require("path");
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const utils = require("../utils");
|
||||
class Reader {
|
||||
constructor(_settings) {
|
||||
this._settings = _settings;
|
||||
this._fsStatSettings = new fsStat.Settings({
|
||||
followSymbolicLink: this._settings.followSymbolicLinks,
|
||||
fs: this._settings.fs,
|
||||
throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
|
||||
});
|
||||
}
|
||||
_getFullEntryPath(filepath) {
|
||||
return path.resolve(this._settings.cwd, filepath);
|
||||
}
|
||||
_makeEntry(stats, pattern) {
|
||||
const entry = {
|
||||
name: pattern,
|
||||
path: pattern,
|
||||
dirent: utils.fs.createDirentFromStats(pattern, stats)
|
||||
};
|
||||
if (this._settings.stats) {
|
||||
entry.stats = stats;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
_isFatalError(error) {
|
||||
return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
|
||||
}
|
||||
}
|
||||
exports.default = Reader;
|
||||
14
node_modules/fast-glob/out/readers/stream.d.ts
generated
vendored
Normal file
14
node_modules/fast-glob/out/readers/stream.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
/// <reference types="node" />
|
||||
import { Readable } from 'stream';
|
||||
import * as fsStat from '@nodelib/fs.stat';
|
||||
import * as fsWalk from '@nodelib/fs.walk';
|
||||
import { Pattern, ReaderOptions } from '../types';
|
||||
import Reader from './reader';
|
||||
export default class ReaderStream extends Reader<Readable> {
|
||||
protected _walkStream: typeof fsWalk.walkStream;
|
||||
protected _stat: typeof fsStat.stat;
|
||||
dynamic(root: string, options: ReaderOptions): Readable;
|
||||
static(patterns: Pattern[], options: ReaderOptions): Readable;
|
||||
private _getEntry;
|
||||
private _getStat;
|
||||
}
|
||||
55
node_modules/fast-glob/out/readers/stream.js
generated
vendored
Normal file
55
node_modules/fast-glob/out/readers/stream.js
generated
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const stream_1 = require("stream");
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const fsWalk = require("@nodelib/fs.walk");
|
||||
const reader_1 = require("./reader");
|
||||
class ReaderStream extends reader_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._walkStream = fsWalk.walkStream;
|
||||
this._stat = fsStat.stat;
|
||||
}
|
||||
dynamic(root, options) {
|
||||
return this._walkStream(root, options);
|
||||
}
|
||||
static(patterns, options) {
|
||||
const filepaths = patterns.map(this._getFullEntryPath, this);
|
||||
const stream = new stream_1.PassThrough({ objectMode: true });
|
||||
stream._write = (index, _enc, done) => {
|
||||
return this._getEntry(filepaths[index], patterns[index], options)
|
||||
.then((entry) => {
|
||||
if (entry !== null && options.entryFilter(entry)) {
|
||||
stream.push(entry);
|
||||
}
|
||||
if (index === filepaths.length - 1) {
|
||||
stream.end();
|
||||
}
|
||||
done();
|
||||
})
|
||||
.catch(done);
|
||||
};
|
||||
for (let i = 0; i < filepaths.length; i++) {
|
||||
stream.write(i);
|
||||
}
|
||||
return stream;
|
||||
}
|
||||
_getEntry(filepath, pattern, options) {
|
||||
return this._getStat(filepath)
|
||||
.then((stats) => this._makeEntry(stats, pattern))
|
||||
.catch((error) => {
|
||||
if (options.errorFilter(error)) {
|
||||
return null;
|
||||
}
|
||||
throw error;
|
||||
});
|
||||
}
|
||||
_getStat(filepath) {
|
||||
return new Promise((resolve, reject) => {
|
||||
this._stat(filepath, this._fsStatSettings, (error, stats) => {
|
||||
return error === null ? resolve(stats) : reject(error);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.default = ReaderStream;
|
||||
12
node_modules/fast-glob/out/readers/sync.d.ts
generated
vendored
Normal file
12
node_modules/fast-glob/out/readers/sync.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
import * as fsStat from '@nodelib/fs.stat';
|
||||
import * as fsWalk from '@nodelib/fs.walk';
|
||||
import { Entry, Pattern, ReaderOptions } from '../types';
|
||||
import Reader from './reader';
|
||||
export default class ReaderSync extends Reader<Entry[]> {
|
||||
protected _walkSync: typeof fsWalk.walkSync;
|
||||
protected _statSync: typeof fsStat.statSync;
|
||||
dynamic(root: string, options: ReaderOptions): Entry[];
|
||||
static(patterns: Pattern[], options: ReaderOptions): Entry[];
|
||||
private _getEntry;
|
||||
private _getStat;
|
||||
}
|
||||
43
node_modules/fast-glob/out/readers/sync.js
generated
vendored
Normal file
43
node_modules/fast-glob/out/readers/sync.js
generated
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const fsWalk = require("@nodelib/fs.walk");
|
||||
const reader_1 = require("./reader");
|
||||
class ReaderSync extends reader_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._walkSync = fsWalk.walkSync;
|
||||
this._statSync = fsStat.statSync;
|
||||
}
|
||||
dynamic(root, options) {
|
||||
return this._walkSync(root, options);
|
||||
}
|
||||
static(patterns, options) {
|
||||
const entries = [];
|
||||
for (const pattern of patterns) {
|
||||
const filepath = this._getFullEntryPath(pattern);
|
||||
const entry = this._getEntry(filepath, pattern, options);
|
||||
if (entry === null || !options.entryFilter(entry)) {
|
||||
continue;
|
||||
}
|
||||
entries.push(entry);
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
_getEntry(filepath, pattern, options) {
|
||||
try {
|
||||
const stats = this._getStat(filepath);
|
||||
return this._makeEntry(stats, pattern);
|
||||
}
|
||||
catch (error) {
|
||||
if (options.errorFilter(error)) {
|
||||
return null;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
_getStat(filepath) {
|
||||
return this._statSync(filepath, this._fsStatSettings);
|
||||
}
|
||||
}
|
||||
exports.default = ReaderSync;
|
||||
164
node_modules/fast-glob/out/settings.d.ts
generated
vendored
Normal file
164
node_modules/fast-glob/out/settings.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,164 @@
|
|||
import { FileSystemAdapter, Pattern } from './types';
|
||||
export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
|
||||
export type Options = {
|
||||
/**
|
||||
* Return the absolute path for entries.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
absolute?: boolean;
|
||||
/**
|
||||
* If set to `true`, then patterns without slashes will be matched against
|
||||
* the basename of the path if it contains slashes.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
baseNameMatch?: boolean;
|
||||
/**
|
||||
* Enables Bash-like brace expansion.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
braceExpansion?: boolean;
|
||||
/**
|
||||
* Enables a case-sensitive mode for matching files.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
caseSensitiveMatch?: boolean;
|
||||
/**
|
||||
* Specifies the maximum number of concurrent requests from a reader to read
|
||||
* directories.
|
||||
*
|
||||
* @default os.cpus().length
|
||||
*/
|
||||
concurrency?: number;
|
||||
/**
|
||||
* The current working directory in which to search.
|
||||
*
|
||||
* @default process.cwd()
|
||||
*/
|
||||
cwd?: string;
|
||||
/**
|
||||
* Specifies the maximum depth of a read directory relative to the start
|
||||
* directory.
|
||||
*
|
||||
* @default Infinity
|
||||
*/
|
||||
deep?: number;
|
||||
/**
|
||||
* Allow patterns to match entries that begin with a period (`.`).
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
dot?: boolean;
|
||||
/**
|
||||
* Enables Bash-like `extglob` functionality.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
extglob?: boolean;
|
||||
/**
|
||||
* Indicates whether to traverse descendants of symbolic link directories.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
followSymbolicLinks?: boolean;
|
||||
/**
|
||||
* Custom implementation of methods for working with the file system.
|
||||
*
|
||||
* @default fs.*
|
||||
*/
|
||||
fs?: Partial<FileSystemAdapter>;
|
||||
/**
|
||||
* Enables recursively repeats a pattern containing `**`.
|
||||
* If `false`, `**` behaves exactly like `*`.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
globstar?: boolean;
|
||||
/**
|
||||
* An array of glob patterns to exclude matches.
|
||||
* This is an alternative way to use negative patterns.
|
||||
*
|
||||
* @default []
|
||||
*/
|
||||
ignore?: Pattern[];
|
||||
/**
|
||||
* Mark the directory path with the final slash.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
markDirectories?: boolean;
|
||||
/**
|
||||
* Returns objects (instead of strings) describing entries.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
objectMode?: boolean;
|
||||
/**
|
||||
* Return only directories.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
onlyDirectories?: boolean;
|
||||
/**
|
||||
* Return only files.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
onlyFiles?: boolean;
|
||||
/**
|
||||
* Enables an object mode (`objectMode`) with an additional `stats` field.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
stats?: boolean;
|
||||
/**
|
||||
* By default this package suppress only `ENOENT` errors.
|
||||
* Set to `true` to suppress any error.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
suppressErrors?: boolean;
|
||||
/**
|
||||
* Throw an error when symbolic link is broken if `true` or safely
|
||||
* return `lstat` call if `false`.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
throwErrorOnBrokenSymbolicLink?: boolean;
|
||||
/**
|
||||
* Ensures that the returned entries are unique.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
unique?: boolean;
|
||||
};
|
||||
export default class Settings {
|
||||
private readonly _options;
|
||||
readonly absolute: boolean;
|
||||
readonly baseNameMatch: boolean;
|
||||
readonly braceExpansion: boolean;
|
||||
readonly caseSensitiveMatch: boolean;
|
||||
readonly concurrency: number;
|
||||
readonly cwd: string;
|
||||
readonly deep: number;
|
||||
readonly dot: boolean;
|
||||
readonly extglob: boolean;
|
||||
readonly followSymbolicLinks: boolean;
|
||||
readonly fs: FileSystemAdapter;
|
||||
readonly globstar: boolean;
|
||||
readonly ignore: Pattern[];
|
||||
readonly markDirectories: boolean;
|
||||
readonly objectMode: boolean;
|
||||
readonly onlyDirectories: boolean;
|
||||
readonly onlyFiles: boolean;
|
||||
readonly stats: boolean;
|
||||
readonly suppressErrors: boolean;
|
||||
readonly throwErrorOnBrokenSymbolicLink: boolean;
|
||||
readonly unique: boolean;
|
||||
constructor(_options?: Options);
|
||||
private _getValue;
|
||||
private _getFileSystemMethods;
|
||||
}
|
||||
59
node_modules/fast-glob/out/settings.js
generated
vendored
Normal file
59
node_modules/fast-glob/out/settings.js
generated
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
|
||||
const fs = require("fs");
|
||||
const os = require("os");
|
||||
/**
|
||||
* The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
|
||||
* https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
|
||||
*/
|
||||
const CPU_COUNT = Math.max(os.cpus().length, 1);
|
||||
exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
|
||||
lstat: fs.lstat,
|
||||
lstatSync: fs.lstatSync,
|
||||
stat: fs.stat,
|
||||
statSync: fs.statSync,
|
||||
readdir: fs.readdir,
|
||||
readdirSync: fs.readdirSync
|
||||
};
|
||||
class Settings {
|
||||
constructor(_options = {}) {
|
||||
this._options = _options;
|
||||
this.absolute = this._getValue(this._options.absolute, false);
|
||||
this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
|
||||
this.braceExpansion = this._getValue(this._options.braceExpansion, true);
|
||||
this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
|
||||
this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
|
||||
this.cwd = this._getValue(this._options.cwd, process.cwd());
|
||||
this.deep = this._getValue(this._options.deep, Infinity);
|
||||
this.dot = this._getValue(this._options.dot, false);
|
||||
this.extglob = this._getValue(this._options.extglob, true);
|
||||
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
|
||||
this.fs = this._getFileSystemMethods(this._options.fs);
|
||||
this.globstar = this._getValue(this._options.globstar, true);
|
||||
this.ignore = this._getValue(this._options.ignore, []);
|
||||
this.markDirectories = this._getValue(this._options.markDirectories, false);
|
||||
this.objectMode = this._getValue(this._options.objectMode, false);
|
||||
this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
|
||||
this.onlyFiles = this._getValue(this._options.onlyFiles, true);
|
||||
this.stats = this._getValue(this._options.stats, false);
|
||||
this.suppressErrors = this._getValue(this._options.suppressErrors, false);
|
||||
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
|
||||
this.unique = this._getValue(this._options.unique, true);
|
||||
if (this.onlyDirectories) {
|
||||
this.onlyFiles = false;
|
||||
}
|
||||
if (this.stats) {
|
||||
this.objectMode = true;
|
||||
}
|
||||
// Remove the cast to the array in the next major (#404).
|
||||
this.ignore = [].concat(this.ignore);
|
||||
}
|
||||
_getValue(option, value) {
|
||||
return option === undefined ? value : option;
|
||||
}
|
||||
_getFileSystemMethods(methods = {}) {
|
||||
return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
|
||||
}
|
||||
}
|
||||
exports.default = Settings;
|
||||
31
node_modules/fast-glob/out/types/index.d.ts
generated
vendored
Normal file
31
node_modules/fast-glob/out/types/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/// <reference types="node" />
|
||||
import * as fsWalk from '@nodelib/fs.walk';
|
||||
export type ErrnoException = NodeJS.ErrnoException;
|
||||
export type Entry = fsWalk.Entry;
|
||||
export type EntryItem = string | Entry;
|
||||
export type Pattern = string;
|
||||
export type PatternRe = RegExp;
|
||||
export type PatternsGroup = Record<string, Pattern[]>;
|
||||
export type ReaderOptions = fsWalk.Options & {
|
||||
transform(entry: Entry): EntryItem;
|
||||
deepFilter: DeepFilterFunction;
|
||||
entryFilter: EntryFilterFunction;
|
||||
errorFilter: ErrorFilterFunction;
|
||||
fs: FileSystemAdapter;
|
||||
stats: boolean;
|
||||
};
|
||||
export type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
|
||||
export type EntryFilterFunction = fsWalk.EntryFilterFunction;
|
||||
export type DeepFilterFunction = fsWalk.DeepFilterFunction;
|
||||
export type EntryTransformerFunction = (entry: Entry) => EntryItem;
|
||||
export type MicromatchOptions = {
|
||||
dot?: boolean;
|
||||
matchBase?: boolean;
|
||||
nobrace?: boolean;
|
||||
nocase?: boolean;
|
||||
noext?: boolean;
|
||||
noglobstar?: boolean;
|
||||
posix?: boolean;
|
||||
strictSlashes?: boolean;
|
||||
};
|
||||
export type FileSystemAdapter = fsWalk.FileSystemAdapter;
|
||||
2
node_modules/fast-glob/out/types/index.js
generated
vendored
Normal file
2
node_modules/fast-glob/out/types/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
2
node_modules/fast-glob/out/utils/array.d.ts
generated
vendored
Normal file
2
node_modules/fast-glob/out/utils/array.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
export declare function flatten<T>(items: T[][]): T[];
|
||||
export declare function splitWhen<T>(items: T[], predicate: (item: T) => boolean): T[][];
|
||||
22
node_modules/fast-glob/out/utils/array.js
generated
vendored
Normal file
22
node_modules/fast-glob/out/utils/array.js
generated
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.splitWhen = exports.flatten = void 0;
|
||||
function flatten(items) {
|
||||
return items.reduce((collection, item) => [].concat(collection, item), []);
|
||||
}
|
||||
exports.flatten = flatten;
|
||||
function splitWhen(items, predicate) {
|
||||
const result = [[]];
|
||||
let groupIndex = 0;
|
||||
for (const item of items) {
|
||||
if (predicate(item)) {
|
||||
groupIndex++;
|
||||
result[groupIndex] = [];
|
||||
}
|
||||
else {
|
||||
result[groupIndex].push(item);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
exports.splitWhen = splitWhen;
|
||||
2
node_modules/fast-glob/out/utils/errno.d.ts
generated
vendored
Normal file
2
node_modules/fast-glob/out/utils/errno.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
import { ErrnoException } from '../types';
|
||||
export declare function isEnoentCodeError(error: ErrnoException): boolean;
|
||||
7
node_modules/fast-glob/out/utils/errno.js
generated
vendored
Normal file
7
node_modules/fast-glob/out/utils/errno.js
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isEnoentCodeError = void 0;
|
||||
function isEnoentCodeError(error) {
|
||||
return error.code === 'ENOENT';
|
||||
}
|
||||
exports.isEnoentCodeError = isEnoentCodeError;
|
||||
4
node_modules/fast-glob/out/utils/fs.d.ts
generated
vendored
Normal file
4
node_modules/fast-glob/out/utils/fs.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
/// <reference types="node" />
|
||||
import * as fs from 'fs';
|
||||
import { Dirent } from '@nodelib/fs.walk';
|
||||
export declare function createDirentFromStats(name: string, stats: fs.Stats): Dirent;
|
||||
19
node_modules/fast-glob/out/utils/fs.js
generated
vendored
Normal file
19
node_modules/fast-glob/out/utils/fs.js
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createDirentFromStats = void 0;
|
||||
class DirentFromStats {
|
||||
constructor(name, stats) {
|
||||
this.name = name;
|
||||
this.isBlockDevice = stats.isBlockDevice.bind(stats);
|
||||
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
|
||||
this.isDirectory = stats.isDirectory.bind(stats);
|
||||
this.isFIFO = stats.isFIFO.bind(stats);
|
||||
this.isFile = stats.isFile.bind(stats);
|
||||
this.isSocket = stats.isSocket.bind(stats);
|
||||
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
|
||||
}
|
||||
}
|
||||
function createDirentFromStats(name, stats) {
|
||||
return new DirentFromStats(name, stats);
|
||||
}
|
||||
exports.createDirentFromStats = createDirentFromStats;
|
||||
8
node_modules/fast-glob/out/utils/index.d.ts
generated
vendored
Normal file
8
node_modules/fast-glob/out/utils/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
import * as array from './array';
|
||||
import * as errno from './errno';
|
||||
import * as fs from './fs';
|
||||
import * as path from './path';
|
||||
import * as pattern from './pattern';
|
||||
import * as stream from './stream';
|
||||
import * as string from './string';
|
||||
export { array, errno, fs, path, pattern, stream, string };
|
||||
17
node_modules/fast-glob/out/utils/index.js
generated
vendored
Normal file
17
node_modules/fast-glob/out/utils/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
|
||||
const array = require("./array");
|
||||
exports.array = array;
|
||||
const errno = require("./errno");
|
||||
exports.errno = errno;
|
||||
const fs = require("./fs");
|
||||
exports.fs = fs;
|
||||
const path = require("./path");
|
||||
exports.path = path;
|
||||
const pattern = require("./pattern");
|
||||
exports.pattern = pattern;
|
||||
const stream = require("./stream");
|
||||
exports.stream = stream;
|
||||
const string = require("./string");
|
||||
exports.string = string;
|
||||
13
node_modules/fast-glob/out/utils/path.d.ts
generated
vendored
Normal file
13
node_modules/fast-glob/out/utils/path.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
import { Pattern } from '../types';
|
||||
/**
|
||||
* Designed to work only with simple paths: `dir\\file`.
|
||||
*/
|
||||
export declare function unixify(filepath: string): string;
|
||||
export declare function makeAbsolute(cwd: string, filepath: string): string;
|
||||
export declare function removeLeadingDotSegment(entry: string): string;
|
||||
export declare const escape: typeof escapeWindowsPath;
|
||||
export declare function escapeWindowsPath(pattern: Pattern): Pattern;
|
||||
export declare function escapePosixPath(pattern: Pattern): Pattern;
|
||||
export declare const convertPathToPattern: typeof convertWindowsPathToPattern;
|
||||
export declare function convertWindowsPathToPattern(filepath: string): Pattern;
|
||||
export declare function convertPosixPathToPattern(filepath: string): Pattern;
|
||||
68
node_modules/fast-glob/out/utils/path.js
generated
vendored
Normal file
68
node_modules/fast-glob/out/utils/path.js
generated
vendored
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
|
||||
const os = require("os");
|
||||
const path = require("path");
|
||||
const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
|
||||
const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
|
||||
/**
|
||||
* All non-escaped special characters.
|
||||
* Posix: ()*?[]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
|
||||
* Windows: (){}[], !+@ before (, ! at the beginning.
|
||||
*/
|
||||
const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
|
||||
const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
|
||||
/**
|
||||
* The device path (\\.\ or \\?\).
|
||||
* https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
|
||||
*/
|
||||
const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
|
||||
/**
|
||||
* All backslashes except those escaping special characters.
|
||||
* Windows: !()+@{}
|
||||
* https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
|
||||
*/
|
||||
const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
|
||||
/**
|
||||
* Designed to work only with simple paths: `dir\\file`.
|
||||
*/
|
||||
function unixify(filepath) {
|
||||
return filepath.replace(/\\/g, '/');
|
||||
}
|
||||
exports.unixify = unixify;
|
||||
function makeAbsolute(cwd, filepath) {
|
||||
return path.resolve(cwd, filepath);
|
||||
}
|
||||
exports.makeAbsolute = makeAbsolute;
|
||||
function removeLeadingDotSegment(entry) {
|
||||
// We do not use `startsWith` because this is 10x slower than current implementation for some cases.
|
||||
// eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
|
||||
if (entry.charAt(0) === '.') {
|
||||
const secondCharactery = entry.charAt(1);
|
||||
if (secondCharactery === '/' || secondCharactery === '\\') {
|
||||
return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
|
||||
}
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
exports.removeLeadingDotSegment = removeLeadingDotSegment;
|
||||
exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
|
||||
function escapeWindowsPath(pattern) {
|
||||
return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
|
||||
}
|
||||
exports.escapeWindowsPath = escapeWindowsPath;
|
||||
function escapePosixPath(pattern) {
|
||||
return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
|
||||
}
|
||||
exports.escapePosixPath = escapePosixPath;
|
||||
exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
|
||||
function convertWindowsPathToPattern(filepath) {
|
||||
return escapeWindowsPath(filepath)
|
||||
.replace(DOS_DEVICE_PATH_RE, '//$1')
|
||||
.replace(WINDOWS_BACKSLASHES_RE, '/');
|
||||
}
|
||||
exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
|
||||
function convertPosixPathToPattern(filepath) {
|
||||
return escapePosixPath(filepath);
|
||||
}
|
||||
exports.convertPosixPathToPattern = convertPosixPathToPattern;
|
||||
47
node_modules/fast-glob/out/utils/pattern.d.ts
generated
vendored
Normal file
47
node_modules/fast-glob/out/utils/pattern.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
import { MicromatchOptions, Pattern, PatternRe } from '../types';
|
||||
type PatternTypeOptions = {
|
||||
braceExpansion?: boolean;
|
||||
caseSensitiveMatch?: boolean;
|
||||
extglob?: boolean;
|
||||
};
|
||||
export declare function isStaticPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
|
||||
export declare function isDynamicPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
|
||||
export declare function convertToPositivePattern(pattern: Pattern): Pattern;
|
||||
export declare function convertToNegativePattern(pattern: Pattern): Pattern;
|
||||
export declare function isNegativePattern(pattern: Pattern): boolean;
|
||||
export declare function isPositivePattern(pattern: Pattern): boolean;
|
||||
export declare function getNegativePatterns(patterns: Pattern[]): Pattern[];
|
||||
export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
|
||||
/**
|
||||
* Returns patterns that can be applied inside the current directory.
|
||||
*
|
||||
* @example
|
||||
* // ['./*', '*', 'a/*']
|
||||
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
|
||||
*/
|
||||
export declare function getPatternsInsideCurrentDirectory(patterns: Pattern[]): Pattern[];
|
||||
/**
|
||||
* Returns patterns to be expanded relative to (outside) the current directory.
|
||||
*
|
||||
* @example
|
||||
* // ['../*', './../*']
|
||||
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
|
||||
*/
|
||||
export declare function getPatternsOutsideCurrentDirectory(patterns: Pattern[]): Pattern[];
|
||||
export declare function isPatternRelatedToParentDirectory(pattern: Pattern): boolean;
|
||||
export declare function getBaseDirectory(pattern: Pattern): string;
|
||||
export declare function hasGlobStar(pattern: Pattern): boolean;
|
||||
export declare function endsWithSlashGlobStar(pattern: Pattern): boolean;
|
||||
export declare function isAffectDepthOfReadingPattern(pattern: Pattern): boolean;
|
||||
export declare function expandPatternsWithBraceExpansion(patterns: Pattern[]): Pattern[];
|
||||
export declare function expandBraceExpansion(pattern: Pattern): Pattern[];
|
||||
export declare function getPatternParts(pattern: Pattern, options: MicromatchOptions): Pattern[];
|
||||
export declare function makeRe(pattern: Pattern, options: MicromatchOptions): PatternRe;
|
||||
export declare function convertPatternsToRe(patterns: Pattern[], options: MicromatchOptions): PatternRe[];
|
||||
export declare function matchAny(entry: string, patternsRe: PatternRe[]): boolean;
|
||||
/**
|
||||
* This package only works with forward slashes as a path separator.
|
||||
* Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
|
||||
*/
|
||||
export declare function removeDuplicateSlashes(pattern: string): string;
|
||||
export {};
|
||||
188
node_modules/fast-glob/out/utils/pattern.js
generated
vendored
Normal file
188
node_modules/fast-glob/out/utils/pattern.js
generated
vendored
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
|
||||
const path = require("path");
|
||||
const globParent = require("glob-parent");
|
||||
const micromatch = require("micromatch");
|
||||
const GLOBSTAR = '**';
|
||||
const ESCAPE_SYMBOL = '\\';
|
||||
const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
|
||||
const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
|
||||
const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
|
||||
const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
|
||||
const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
|
||||
/**
|
||||
* Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
|
||||
* The latter is due to the presence of the device path at the beginning of the UNC path.
|
||||
*/
|
||||
const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
|
||||
function isStaticPattern(pattern, options = {}) {
|
||||
return !isDynamicPattern(pattern, options);
|
||||
}
|
||||
exports.isStaticPattern = isStaticPattern;
|
||||
function isDynamicPattern(pattern, options = {}) {
|
||||
/**
|
||||
* A special case with an empty string is necessary for matching patterns that start with a forward slash.
|
||||
* An empty string cannot be a dynamic pattern.
|
||||
* For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
|
||||
*/
|
||||
if (pattern === '') {
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
|
||||
* filepath directly (without read directory).
|
||||
*/
|
||||
if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
|
||||
return true;
|
||||
}
|
||||
if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
|
||||
return true;
|
||||
}
|
||||
if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
|
||||
return true;
|
||||
}
|
||||
if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
exports.isDynamicPattern = isDynamicPattern;
|
||||
function hasBraceExpansion(pattern) {
|
||||
const openingBraceIndex = pattern.indexOf('{');
|
||||
if (openingBraceIndex === -1) {
|
||||
return false;
|
||||
}
|
||||
const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
|
||||
if (closingBraceIndex === -1) {
|
||||
return false;
|
||||
}
|
||||
const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
|
||||
return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
|
||||
}
|
||||
function convertToPositivePattern(pattern) {
|
||||
return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
|
||||
}
|
||||
exports.convertToPositivePattern = convertToPositivePattern;
|
||||
function convertToNegativePattern(pattern) {
|
||||
return '!' + pattern;
|
||||
}
|
||||
exports.convertToNegativePattern = convertToNegativePattern;
|
||||
function isNegativePattern(pattern) {
|
||||
return pattern.startsWith('!') && pattern[1] !== '(';
|
||||
}
|
||||
exports.isNegativePattern = isNegativePattern;
|
||||
function isPositivePattern(pattern) {
|
||||
return !isNegativePattern(pattern);
|
||||
}
|
||||
exports.isPositivePattern = isPositivePattern;
|
||||
function getNegativePatterns(patterns) {
|
||||
return patterns.filter(isNegativePattern);
|
||||
}
|
||||
exports.getNegativePatterns = getNegativePatterns;
|
||||
function getPositivePatterns(patterns) {
|
||||
return patterns.filter(isPositivePattern);
|
||||
}
|
||||
exports.getPositivePatterns = getPositivePatterns;
|
||||
/**
|
||||
* Returns patterns that can be applied inside the current directory.
|
||||
*
|
||||
* @example
|
||||
* // ['./*', '*', 'a/*']
|
||||
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
|
||||
*/
|
||||
function getPatternsInsideCurrentDirectory(patterns) {
|
||||
return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
|
||||
}
|
||||
exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
|
||||
/**
|
||||
* Returns patterns to be expanded relative to (outside) the current directory.
|
||||
*
|
||||
* @example
|
||||
* // ['../*', './../*']
|
||||
* getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
|
||||
*/
|
||||
function getPatternsOutsideCurrentDirectory(patterns) {
|
||||
return patterns.filter(isPatternRelatedToParentDirectory);
|
||||
}
|
||||
exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
|
||||
function isPatternRelatedToParentDirectory(pattern) {
|
||||
return pattern.startsWith('..') || pattern.startsWith('./..');
|
||||
}
|
||||
exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
|
||||
function getBaseDirectory(pattern) {
|
||||
return globParent(pattern, { flipBackslashes: false });
|
||||
}
|
||||
exports.getBaseDirectory = getBaseDirectory;
|
||||
function hasGlobStar(pattern) {
|
||||
return pattern.includes(GLOBSTAR);
|
||||
}
|
||||
exports.hasGlobStar = hasGlobStar;
|
||||
function endsWithSlashGlobStar(pattern) {
|
||||
return pattern.endsWith('/' + GLOBSTAR);
|
||||
}
|
||||
exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
|
||||
function isAffectDepthOfReadingPattern(pattern) {
|
||||
const basename = path.basename(pattern);
|
||||
return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
|
||||
}
|
||||
exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
|
||||
function expandPatternsWithBraceExpansion(patterns) {
|
||||
return patterns.reduce((collection, pattern) => {
|
||||
return collection.concat(expandBraceExpansion(pattern));
|
||||
}, []);
|
||||
}
|
||||
exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
|
||||
function expandBraceExpansion(pattern) {
|
||||
const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: true });
|
||||
/**
|
||||
* Sort the patterns by length so that the same depth patterns are processed side by side.
|
||||
* `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
|
||||
*/
|
||||
patterns.sort((a, b) => a.length - b.length);
|
||||
/**
|
||||
* Micromatch can return an empty string in the case of patterns like `{a,}`.
|
||||
*/
|
||||
return patterns.filter((pattern) => pattern !== '');
|
||||
}
|
||||
exports.expandBraceExpansion = expandBraceExpansion;
|
||||
function getPatternParts(pattern, options) {
|
||||
let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
|
||||
/**
|
||||
* The scan method returns an empty array in some cases.
|
||||
* See micromatch/picomatch#58 for more details.
|
||||
*/
|
||||
if (parts.length === 0) {
|
||||
parts = [pattern];
|
||||
}
|
||||
/**
|
||||
* The scan method does not return an empty part for the pattern with a forward slash.
|
||||
* This is another part of micromatch/picomatch#58.
|
||||
*/
|
||||
if (parts[0].startsWith('/')) {
|
||||
parts[0] = parts[0].slice(1);
|
||||
parts.unshift('');
|
||||
}
|
||||
return parts;
|
||||
}
|
||||
exports.getPatternParts = getPatternParts;
|
||||
function makeRe(pattern, options) {
|
||||
return micromatch.makeRe(pattern, options);
|
||||
}
|
||||
exports.makeRe = makeRe;
|
||||
function convertPatternsToRe(patterns, options) {
|
||||
return patterns.map((pattern) => makeRe(pattern, options));
|
||||
}
|
||||
exports.convertPatternsToRe = convertPatternsToRe;
|
||||
function matchAny(entry, patternsRe) {
|
||||
return patternsRe.some((patternRe) => patternRe.test(entry));
|
||||
}
|
||||
exports.matchAny = matchAny;
|
||||
/**
|
||||
* This package only works with forward slashes as a path separator.
|
||||
* Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
|
||||
*/
|
||||
function removeDuplicateSlashes(pattern) {
|
||||
return pattern.replace(DOUBLE_SLASH_RE, '/');
|
||||
}
|
||||
exports.removeDuplicateSlashes = removeDuplicateSlashes;
|
||||
4
node_modules/fast-glob/out/utils/stream.d.ts
generated
vendored
Normal file
4
node_modules/fast-glob/out/utils/stream.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
/// <reference types="node" />
|
||||
/// <reference types="node" />
|
||||
import { Readable } from 'stream';
|
||||
export declare function merge(streams: Readable[]): NodeJS.ReadableStream;
|
||||
17
node_modules/fast-glob/out/utils/stream.js
generated
vendored
Normal file
17
node_modules/fast-glob/out/utils/stream.js
generated
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.merge = void 0;
|
||||
const merge2 = require("merge2");
|
||||
function merge(streams) {
|
||||
const mergedStream = merge2(streams);
|
||||
streams.forEach((stream) => {
|
||||
stream.once('error', (error) => mergedStream.emit('error', error));
|
||||
});
|
||||
mergedStream.once('close', () => propagateCloseEventToSources(streams));
|
||||
mergedStream.once('end', () => propagateCloseEventToSources(streams));
|
||||
return mergedStream;
|
||||
}
|
||||
exports.merge = merge;
|
||||
function propagateCloseEventToSources(streams) {
|
||||
streams.forEach((stream) => stream.emit('close'));
|
||||
}
|
||||
2
node_modules/fast-glob/out/utils/string.d.ts
generated
vendored
Normal file
2
node_modules/fast-glob/out/utils/string.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
export declare function isString(input: unknown): input is string;
|
||||
export declare function isEmpty(input: string): boolean;
|
||||
11
node_modules/fast-glob/out/utils/string.js
generated
vendored
Normal file
11
node_modules/fast-glob/out/utils/string.js
generated
vendored
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isEmpty = exports.isString = void 0;
|
||||
function isString(input) {
|
||||
return typeof input === 'string';
|
||||
}
|
||||
exports.isString = isString;
|
||||
function isEmpty(input) {
|
||||
return input === '';
|
||||
}
|
||||
exports.isEmpty = isEmpty;
|
||||
81
node_modules/fast-glob/package.json
generated
vendored
Normal file
81
node_modules/fast-glob/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
{
|
||||
"name": "fast-glob",
|
||||
"version": "3.3.2",
|
||||
"description": "It's a very fast and efficient glob library for Node.js",
|
||||
"license": "MIT",
|
||||
"repository": "mrmlnc/fast-glob",
|
||||
"author": {
|
||||
"name": "Denis Malinochkin",
|
||||
"url": "https://mrmlnc.com"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=8.6.0"
|
||||
},
|
||||
"main": "out/index.js",
|
||||
"typings": "out/index.d.ts",
|
||||
"files": [
|
||||
"out",
|
||||
"!out/{benchmark,tests}",
|
||||
"!out/**/*.map",
|
||||
"!out/**/*.spec.*"
|
||||
],
|
||||
"keywords": [
|
||||
"glob",
|
||||
"patterns",
|
||||
"fast",
|
||||
"implementation"
|
||||
],
|
||||
"devDependencies": {
|
||||
"@nodelib/fs.macchiato": "^1.0.1",
|
||||
"@types/glob-parent": "^5.1.0",
|
||||
"@types/merge2": "^1.1.4",
|
||||
"@types/micromatch": "^4.0.0",
|
||||
"@types/mocha": "^5.2.7",
|
||||
"@types/node": "^14.18.53",
|
||||
"@types/picomatch": "^2.3.0",
|
||||
"@types/sinon": "^7.5.0",
|
||||
"bencho": "^0.1.1",
|
||||
"eslint": "^6.5.1",
|
||||
"eslint-config-mrmlnc": "^1.1.0",
|
||||
"execa": "^7.1.1",
|
||||
"fast-glob": "^3.0.4",
|
||||
"fdir": "^6.0.1",
|
||||
"glob": "^10.0.0",
|
||||
"hereby": "^1.8.1",
|
||||
"mocha": "^6.2.1",
|
||||
"rimraf": "^5.0.0",
|
||||
"sinon": "^7.5.0",
|
||||
"snap-shot-it": "^7.9.10",
|
||||
"typescript": "^4.9.5"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nodelib/fs.stat": "^2.0.2",
|
||||
"@nodelib/fs.walk": "^1.2.3",
|
||||
"glob-parent": "^5.1.2",
|
||||
"merge2": "^1.3.0",
|
||||
"micromatch": "^4.0.4"
|
||||
},
|
||||
"scripts": {
|
||||
"clean": "rimraf out",
|
||||
"lint": "eslint \"src/**/*.ts\" --cache",
|
||||
"compile": "tsc",
|
||||
"test": "mocha \"out/**/*.spec.js\" -s 0",
|
||||
"test:e2e": "mocha \"out/**/*.e2e.js\" -s 0",
|
||||
"test:e2e:sync": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(sync\\)\"",
|
||||
"test:e2e:async": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(async\\)\"",
|
||||
"test:e2e:stream": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(stream\\)\"",
|
||||
"build": "npm run clean && npm run compile && npm run lint && npm test",
|
||||
"watch": "npm run clean && npm run compile -- --sourceMap --watch",
|
||||
"bench:async": "npm run bench:product:async && npm run bench:regression:async",
|
||||
"bench:stream": "npm run bench:product:stream && npm run bench:regression:stream",
|
||||
"bench:sync": "npm run bench:product:sync && npm run bench:regression:sync",
|
||||
"bench:product": "npm run bench:product:async && npm run bench:product:sync && npm run bench:product:stream",
|
||||
"bench:product:async": "hereby bench:product:async",
|
||||
"bench:product:sync": "hereby bench:product:sync",
|
||||
"bench:product:stream": "hereby bench:product:stream",
|
||||
"bench:regression": "npm run bench:regression:async && npm run bench:regression:sync && npm run bench:regression:stream",
|
||||
"bench:regression:async": "hereby bench:regression:async",
|
||||
"bench:regression:sync": "hereby bench:regression:sync",
|
||||
"bench:regression:stream": "hereby bench:regression:stream"
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue