lio/benji.monster
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

upload site

Browse source
This commit is contained in:
ry 2020-01-03 21:48:09 +01:00
commit 69c5b90d6a
3300 changed files with 224783 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

21
node_modules/readdirp/LICENSE generated vendored Normal file
View file

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
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.

122
node_modules/readdirp/README.md generated vendored Normal file
View file

@ -0,0 +1,122 @@
# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
> Recursive version of [fs.readdir](https://nodejs.org/api/fs.html#fs_fs_readdir_path_options_callback). Exposes a **stream api** and a **promise api**.
[![NPM](https://nodei.co/npm/readdirp.png?downloads=true&stars=true)](https://www.npmjs.com/package/readdirp)
```sh
npm install readdirp
```
```javascript
const readdirp = require('readdirp');
// Use streams to achieve small RAM & CPU footprint.
// 1) Streams example with for-await. Node.js 10+ only.
for await (const entry of readdirp('.')) {
const {path} = entry;
console.log(`${JSON.stringify({path})}`);
}
// 2) Streams example, non for-await.
// Print out all JS files along with their size within the current folder & subfolders.
readdirp('.', {fileFilter: '*.js', alwaysStat: true})
.on('data', (entry) => {
const {path, stats: {size}} = entry;
console.log(`${JSON.stringify({path, size})}`);
})
// Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted
.on('warn', error => console.error('non-fatal error', error))
.on('error', error => console.error('fatal error', error))
.on('end', () => console.log('done'));
// 3) Promise example. More RAM and CPU than streams.
const files = await readdirp.promise('.');
console.log(files.map(file => file.path));
// Other options.
readdirp('test', {
fileFilter: '*.js',
directoryFilter: ['!.git', '!*modules']
// directoryFilter: (di) => di.basename.length === 9
type: 'files_directories',
depth: 1
});
```
For more examples, check out `examples` directory.
# API
`const stream = readdirp(root[, options])` — **Stream API**
- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo)
- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`).
- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir.
- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user.
- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed.
- `on('end')` — we are done. Called when all entries were found and no more will be emitted.
- `on('close')` — stream is destroyed via `stream.destroy()`.
Could be useful if you want to manually abort even on a non fatal error.
At that point the stream is no longer `readable` and no more entries, warning or errors are emitted
- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html)
or the [stream-handbook](https://github.com/substack/stream-handbook)
`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo).
First argument is awalys `root`, path in which to start reading and recursing into subdirectories.
### options
- `fileFilter: ["*.js"]`: filter to include or exclude files. A `Function`, Glob string or Array of glob strings.
- **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry
- **Glob string**: a string (e.g., `*.js`) which is matched using [picomatch](https://github.com/micromatch/picomatch), so go there for more
information. Globstars (`**`) are not supported since specifying a recursive pattern for an already recursive function doesn't make sense. Negated globs (as explained in the minimatch documentation) are allowed, e.g., `!*.txt` matches everything but text files.
- **Array of glob strings**: either need to be all inclusive or all exclusive (negated) patterns otherwise an error is thrown.
`['*.json', '*.js']` includes all JavaScript and Json files.
`['!.git', '!node_modules']` includes all directories except the '.git' and 'node_modules'.
- Directories that do not pass a filter will not be recursed into.
- `directoryFilter: ['!.git']`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into.
- `depth: 5`: depth at which to stop recursing even if more subdirectories are found
- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes.
- `alwaysStat: false`: always return `stats` property for every file. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0.
- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat`
### `EntryInfo`
Has the following properties:
- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root)
- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found
- `basename: 'react.js'`: name of the file/directory
- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false`
- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true`
# Changelog
3.1 (Jul 7, 2019) brings `bigint` support to `stat` outputs on windows. This is backwards-incompatible for some cases.
Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions".
Version 3 brings huge performance improvements and stream backpressure support.
- Upgrading 2.x to 3.x:
- Signature changed from `readdirp(options)` to `readdirp(root, options)`
- Replaced callback API with promise API.
- Renamed `entryType` option to `type`
- Renamed `entryType: 'both'` to `'files_directories'`
- `EntryInfo`
- Renamed `stat` to `stats`
- Emitted only when `alwaysStat: true`
- `dirent` is emitted instead of `stats` by default with `alwaysStat: false`
- Renamed `name` to `basename`
- Removed `parentDir` and `fullParentDir` properties
- Supported node.js versions:
- 3.x: node 8+
- 2.x: node 0.6+
# License
Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
MIT License, see LICENSE file.

43
node_modules/readdirp/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,43 @@
// TypeScript Version: 3.2
/// <reference types="node" lib="esnext" />
import * as fs from 'fs';
import { Readable } from 'stream';
declare namespace readdir {
interface EntryInfo {
path: string;
fullPath: string;
basename: string;
stats?: fs.Stats;
dirent?: fs.Dirent;
}
interface ReaddirpOptions {
root?: string;
fileFilter?: string | string[] | ((entry: EntryInfo) => boolean);
directoryFilter?: (entry: EntryInfo) => boolean;
type?: 'files' | 'directories' | 'files_directories' | 'all';
lstat?: boolean;
depth?: number;
alwaysStat?: boolean;
}
interface ReaddirpStream extends Readable, AsyncIterable<EntryInfo> {
read(): EntryInfo;
[Symbol.asyncIterator](): AsyncIterableIterator<EntryInfo>;
}
function promise(
root: string,
options?: ReaddirpOptions
): Promise<EntryInfo[]>;
}
declare function readdir(
root: string,
options?: readdir.ReaddirpOptions
): readdir.ReaddirpStream;
export = readdir;

316
node_modules/readdirp/index.js generated vendored Normal file
View file

@ -0,0 +1,316 @@
'use strict';
const fs = require('fs');
const { Readable } = require('stream');
const sysPath = require('path');
const picomatch = require('picomatch');
const { promisify } = require('util');
const [readdir, stat, lstat] = [promisify(fs.readdir), promisify(fs.stat), promisify(fs.lstat)];
const supportsDirent = 'Dirent' in fs;
/**
* @typedef {Object} EntryInfo
* @property {String} path
* @property {String} fullPath
* @property {fs.Stats=} stats
* @property {fs.Dirent=} dirent
* @property {String} basename
*/
const isWindows = process.platform === 'win32';
const supportsBigint = typeof BigInt === 'function';
const BANG = '!';
const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP']);
const STAT_OPTIONS_SUPPORT_LENGTH = 3;
const FILE_TYPE = 'files';
const DIR_TYPE = 'directories';
const FILE_DIR_TYPE = 'files_directories';
const EVERYTHING_TYPE = 'all';
const FILE_TYPES = new Set([FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
const DIR_TYPES = new Set([DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
const isNormalFlowError = errorCode => NORMAL_FLOW_ERRORS.has(errorCode);
const checkBasename = f => f(entry.basename);
const normalizeFilter = filter => {
if (filter === undefined) return;
if (typeof filter === 'function') return filter;
if (typeof filter === 'string') {
const glob = picomatch(filter.trim());
return entry => glob(entry.basename);
}
if (Array.isArray(filter)) {
const positive = [];
const negative = [];
for (const item of filter) {
const trimmed = item.trim();
if (trimmed.charAt(0) === BANG) {
negative.push(picomatch(trimmed.slice(1)));
} else {
positive.push(picomatch(trimmed));
}
}
if (negative.length > 0) {
if (positive.length > 0) {
return entry =>
positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
} else {
return entry => !negative.some(f => f(entry.basename));
}
} else {
return entry => positive.some(f => f(entry.basename));
}
}
};
class ExploringDir {
constructor(path, depth) {
this.path = path;
this.depth = depth;
}
}
class ReaddirpStream extends Readable {
static get defaultOptions() {
return {
root: '.',
fileFilter: path => true,
directoryFilter: path => true,
type: 'files',
lstat: false,
depth: 2147483648,
alwaysStat: false
};
}
constructor(options = {}) {
super({ objectMode: true, highWaterMark: 1, autoDestroy: true });
const opts = Object.assign({}, ReaddirpStream.defaultOptions, options);
const { root } = opts;
this._fileFilter = normalizeFilter(opts.fileFilter);
this._directoryFilter = normalizeFilter(opts.directoryFilter);
this._statMethod = opts.lstat ? lstat : stat;
this._statOpts = { bigint: isWindows };
this._maxDepth = opts.depth;
this._entryType = opts.type;
this._root = sysPath.resolve(root);
this._isDirent = !opts.alwaysStat && supportsDirent;
this._statsProp = this._isDirent ? 'dirent' : 'stats';
this._readdir_options = { encoding: 'utf8', withFileTypes: this._isDirent };
// Launch stream with one parent, the root dir.
/** @type Array<[string, number]> */
this.parents = [new ExploringDir(root, 0)];
this.filesToRead = 0;
}
async _read() {
do {
// If the stream was destroyed, we must not proceed.
if (this.destroyed) return;
const parent = this.parents.pop();
if (!parent) {
// ...we have files to process; but not directories.
// hence, parent is undefined; and we cannot execute fs.readdir().
// The files are being processed anywhere.
break;
}
await this._exploreDirectory(parent);
} while (!this.isPaused() && !this._isQueueEmpty());
this._endStreamIfQueueIsEmpty();
}
async _exploreDirectory(parent) {
/** @type Array<fs.Dirent|string> */
let files = [];
// To prevent race conditions, we increase counter while awaiting readdir.
this.filesToRead++;
try {
files = await readdir(parent.path, this._readdir_options);
} catch (error) {
if (isNormalFlowError(error.code)) {
this._handleError(error);
} else {
this._handleFatalError(error);
}
}
this.filesToRead--;
// If the stream was destroyed, after readdir is completed
if (this.destroyed) return;
this.filesToRead += files.length;
const entries = await Promise.all(files.map(dirent => this._formatEntry(dirent, parent)));
if (this.destroyed) return;
for (let i = 0; i < entries.length; i++) {
const entry = entries[i];
this.filesToRead--;
if (!entry) {
continue;
}
if (this._isDirAndMatchesFilter(entry)) {
this._pushNewParentIfLessThanMaxDepth(entry.fullPath, parent.depth + 1);
this._emitPushIfUserWantsDir(entry);
} else if (this._isFileAndMatchesFilter(entry)) {
this._emitPushIfUserWantsFile(entry);
}
}
}
_isStatOptionsSupported() {
return this._statMethod.length === STAT_OPTIONS_SUPPORT_LENGTH;
}
_stat(fullPath) {
if (isWindows && this._isStatOptionsSupported()) {
return this._statMethod(fullPath, this._statOpts);
} else {
return this._statMethod(fullPath);
}
}
async _formatEntry(dirent, parent) {
const basename = this._isDirent ? dirent.name : dirent;
const fullPath = sysPath.resolve(sysPath.join(parent.path, basename));
let stats;
if (this._isDirent) {
stats = dirent;
} else {
try {
stats = await this._stat(fullPath);
} catch (error) {
if (isNormalFlowError(error.code)) {
this._handleError(error);
} else {
this._handleFatalError(error);
}
return;
}
}
const path = sysPath.relative(this._root, fullPath);
/** @type {EntryInfo} */
const entry = { path, fullPath, basename, [this._statsProp]: stats };
return entry;
}
_isQueueEmpty() {
return this.parents.length === 0 && this.filesToRead === 0 && this.readable;
}
_endStreamIfQueueIsEmpty() {
if (this._isQueueEmpty()) {
this.push(null);
}
}
_pushNewParentIfLessThanMaxDepth(parentPath, depth) {
if (depth <= this._maxDepth) {
this.parents.push(new ExploringDir(parentPath, depth));
return true;
} else {
return false;
}
}
_isDirAndMatchesFilter(entry) {
return entry[this._statsProp].isDirectory() && this._directoryFilter(entry);
}
_isFileAndMatchesFilter(entry) {
const stats = entry[this._statsProp];
const isFileType =
(this._entryType === EVERYTHING_TYPE && !stats.isDirectory()) ||
(stats.isFile() || stats.isSymbolicLink());
return isFileType && this._fileFilter(entry);
}
_emitPushIfUserWantsDir(entry) {
if (DIR_TYPES.has(this._entryType)) {
// TODO: Understand why this happens.
const fn = () => {
this.push(entry);
};
if (this._isDirent) setImmediate(fn);
else fn();
}
}
_emitPushIfUserWantsFile(entry) {
if (FILE_TYPES.has(this._entryType)) {
this.push(entry);
}
}
_handleError(error) {
if (!this.destroyed) {
this.emit('warn', error);
}
}
_handleFatalError(error) {
this.destroy(error);
}
}
/**
* @typedef {Object} ReaddirpArguments
* @property {Function=} fileFilter
* @property {Function=} directoryFilter
* @property {String=} type
* @property {Number=} depth
* @property {String=} root
* @property {Boolean=} lstat
* @property {Boolean=} bigint
*/
/**
* Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
* @param {String} root Root directory
* @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
*/
const readdirp = (root, options = {}) => {
let type = options['entryType'] || options.type;
if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
if (type) options.type = type;
if (root == null || typeof root === 'undefined') {
throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
} else if (typeof root !== 'string') {
throw new Error(`readdirp: root argument must be a string. Usage: readdirp(root, options)`);
} else if (type && !ALL_TYPES.includes(type)) {
throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
}
options.root = root;
return new ReaddirpStream(options);
};
const readdirpPromise = (root, options = {}) => {
return new Promise((resolve, reject) => {
const files = [];
readdirp(root, options)
.on('data', entry => files.push(entry))
.on('end', () => resolve(files))
.on('error', error => reject(error));
});
};
readdirp.promise = readdirpPromise;
readdirp.ReaddirpStream = ReaddirpStream;
readdirp.default = readdirp;
module.exports = readdirp;

92
node_modules/readdirp/package.json generated vendored Normal file
View file

@ -0,0 +1,92 @@
{
"_args": [
[
"readdirp@3.2.0",
"/home/ry/Desktop/Work/benji.monster"
]
],
"_from": "readdirp@3.2.0",
"_id": "readdirp@3.2.0",
"_inBundle": false,
"_integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==",
"_location": "/readdirp",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "readdirp@3.2.0",
"name": "readdirp",
"escapedName": "readdirp",
"rawSpec": "3.2.0",
"saveSpec": null,
"fetchSpec": "3.2.0"
},
"_requiredBy": [
"/chokidar"
],
"_resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz",
"_spec": "3.2.0",
"_where": "/home/ry/Desktop/Work/benji.monster",
"author": {
"name": "Thorsten Lorenz",
"email": "thlorenz@gmx.de",
"url": "thlorenz.com"
},
"bugs": {
"url": "https://github.com/paulmillr/readdirp/issues"
},
"contributors": [
{
"name": "Thorsten Lorenz",
"email": "thlorenz@gmx.de",
"url": "thlorenz.com"
},
{
"name": "Paul Miller",
"url": "https://paulmillr.com"
}
],
"dependencies": {
"picomatch": "^2.0.4"
},
"description": "Recursive version of fs.readdir with streaming api.",
"devDependencies": {
"@types/chai": "^4.1",
"@types/mocha": "^5.2",
"@types/node": "^12",
"chai": "^4.2",
"chai-subset": "^1.6",
"dtslint": "^0.9.8",
"mocha": "~6.1.3",
"nyc": "^14.1.1",
"rimraf": "^2.6.3"
},
"engines": {
"node": ">= 8"
},
"files": [
"index.js",
"index.d.ts"
],
"homepage": "https://github.com/paulmillr/readdirp",
"keywords": [
"recursive",
"fs",
"stream",
"streams",
"readdir",
"filesystem",
"find",
"filter"
],
"license": "MIT",
"name": "readdirp",
"repository": {
"type": "git",
"url": "git://github.com/paulmillr/readdirp.git"
},
"scripts": {
"test": "nyc mocha && dtslint"
},
"version": "3.2.0"
}