Mirrors/doipjs
1
0
Fork 1
mirror of https://codeberg.org/keyoxide/doipjs.git synced 2024-12-22 14:39:28 -07:00
Code Issues Projects Releases Packages Wiki Activity

Remove node_modules

Browse source
This commit is contained in:
Yarmo Mackenbach 2020-10-23 22:57:39 +02:00
parent e996bc8023
commit dc92b52660
1629 changed files with 0 additions and 320420 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
node_modules/.bin/_mocha generated vendored
View file

@ -1 +0,0 @@
../mocha/bin/_mocha

1
node_modules/.bin/esparse generated vendored
View file

@ -1 +0,0 @@
../esprima/bin/esparse.js

1
node_modules/.bin/esvalidate generated vendored
View file

@ -1 +0,0 @@
../esprima/bin/esvalidate.js

1
node_modules/.bin/flat generated vendored
View file

@ -1 +0,0 @@
../flat/cli.js

1
node_modules/.bin/he generated vendored
View file

@ -1 +0,0 @@
../he/bin/he

1
node_modules/.bin/js-yaml generated vendored
View file

@ -1 +0,0 @@
../js-yaml/bin/js-yaml.js

1
node_modules/.bin/license-check-and-add generated vendored
View file

@ -1 +0,0 @@
../license-check-and-add/dist/src/cli.js

1
node_modules/.bin/mime generated vendored
View file

@ -1 +0,0 @@
../mime/cli.js

1
node_modules/.bin/mocha generated vendored
View file

@ -1 +0,0 @@
../mocha/bin/mocha

1
node_modules/.bin/nanoid generated vendored
View file

@ -1 +0,0 @@
../nanoid/bin/nanoid.cjs

1
node_modules/.bin/node-which generated vendored
View file

@ -1 +0,0 @@
../which/bin/node-which

1
node_modules/.bin/semver generated vendored
View file

@ -1 +0,0 @@
../semver/bin/semver.js

21
node_modules/@nodelib/fs.scandir/LICENSE generated vendored
View file

@ -1,21 +0,0 @@
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.

171
node_modules/@nodelib/fs.scandir/README.md generated vendored
View file

@ -1,171 +0,0 @@
# @nodelib/fs.scandir
> List files and directories inside the specified directory.
## :bulb: Highlights
The package is aimed at obtaining information about entries in the directory.
* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
* :gear: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type. See [`old` and `modern` mode](#old-and-modern-mode).
* :link: Can safely work with broken symbolic links.
## Install
```console
npm install @nodelib/fs.scandir
```
## Usage
```ts
import * as fsScandir from '@nodelib/fs.scandir';
fsScandir.scandir('path', (error, stats) => { /* … */ });
```
## API
### .scandir(path, [optionsOrSettings], callback)
Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path with standard callback-style.
```ts
fsScandir.scandir('path', (error, entries) => { /* … */ });
fsScandir.scandir('path', {}, (error, entries) => { /* … */ });
fsScandir.scandir('path', new fsScandir.Settings(), (error, entries) => { /* … */ });
```
### .scandirSync(path, [optionsOrSettings])
Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path.
```ts
const entries = fsScandir.scandirSync('path');
const entries = fsScandir.scandirSync('path', {});
const entries = fsScandir.scandirSync(('path', new fsScandir.Settings());
```
#### path
* Required: `true`
* Type: `string | Buffer | URL`
A path to a file. If a URL is provided, it must use the `file:` protocol.
#### optionsOrSettings
* Required: `false`
* Type: `Options | Settings`
* Default: An instance of `Settings` class
An [`Options`](#options) object or an instance of [`Settings`](#settingsoptions) class.
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
### Settings([options])
A class of full settings of the package.
```ts
const settings = new fsScandir.Settings({ followSymbolicLinks: false });
const entries = fsScandir.scandirSync('path', settings);
```
## Entry
* `name` — The name of the entry (`unknown.txt`).
* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class. On Node.js below 10.10 will be emulated by [`DirentFromStats`](./src/utils/fs.ts) class.
* `stats` (optional) — An instance of `fs.Stats` class.
For example, the `scandir` call for `tools` directory with one directory inside:
```ts
{
dirent: Dirent { name: 'typedoc', /* … */ },
name: 'typedoc',
path: 'tools/typedoc'
}
```
## Options
### stats
* Type: `boolean`
* Default: `false`
Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
> :book: Always use `fs.readdir` without the `withFileTypes` option. ??TODO??
### followSymbolicLinks
* Type: `boolean`
* Default: `false`
Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
### `throwErrorOnBrokenSymbolicLink`
* Type: `boolean`
* Default: `true`
Throw an error when symbolic link is broken if `true` or safely use `lstat` call if `false`.
### `pathSegmentSeparator`
* Type: `string`
* Default: `path.sep`
By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
### `fs`
* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
* Default: A default FS methods
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
```ts
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;
}
const settings = new fsScandir.Settings({
fs: { lstat: fakeLstat }
});
```
## `old` and `modern` mode
This package has two modes that are used depending on the environment and parameters of use.
### old
* Node.js below `10.10` or when the `stats` option is enabled
When working in the old mode, the directory is read first (`fs.readdir`), then the type of entries is determined (`fs.lstat` and/or `fs.stat` for symbolic links).
### modern
* Node.js 10.10+ and the `stats` option is disabled
In the modern mode, reading the directory (`fs.readdir` with the `withFileTypes` option) is combined with obtaining information about its entries. An additional call for symbolic links (`fs.stat`) is still present.
This mode makes fewer calls to the file system. It's faster.
## Changelog
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
## License
This software is released under the terms of the MIT license.

13
node_modules/@nodelib/fs.scandir/out/adapters/fs.d.ts generated vendored
View file

@ -1,13 +0,0 @@
/// <reference types="node" />
import * as fs from 'fs';
export declare type 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;
};
export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
//# sourceMappingURL=fs.d.ts.map

18
node_modules/@nodelib/fs.scandir/out/adapters/fs.js generated vendored
View file

@ -1,18 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs.lstat,
stat: fs.stat,
lstatSync: fs.lstatSync,
statSync: fs.statSync,
readdir: fs.readdir,
readdirSync: fs.readdirSync
};
function createFileSystemAdapter(fsMethods) {
if (fsMethods === undefined) {
return exports.FILE_SYSTEM_ADAPTER;
}
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter;

5
node_modules/@nodelib/fs.scandir/out/constants.d.ts generated vendored
View file

@ -1,5 +0,0 @@
/**
* IS `true` for Node.js 10.10 and greater.
*/
export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;
//# sourceMappingURL=constants.d.ts.map

13
node_modules/@nodelib/fs.scandir/out/constants.js generated vendored
View file

@ -1,13 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
const SUPPORTED_MAJOR_VERSION = 10;
const SUPPORTED_MINOR_VERSION = 10;
const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
/**
* IS `true` for Node.js 10.10 and greater.
*/
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;

13
node_modules/@nodelib/fs.scandir/out/index.d.ts generated vendored
View file

@ -1,13 +0,0 @@
import { FileSystemAdapter } from './adapters/fs';
import * as async from './providers/async';
import Settings, { Options } from './settings';
import { Dirent, Entry } from './types';
declare type AsyncCallback = async.AsyncCallback;
declare function scandir(path: string, callback: AsyncCallback): void;
declare function scandir(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
declare namespace scandir {
function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
}
declare function scandirSync(path: string, optionsOrSettings?: Options | Settings): Entry[];
export { scandir, scandirSync, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, Options };
//# sourceMappingURL=index.d.ts.map

24
node_modules/@nodelib/fs.scandir/out/index.js generated vendored
View file

@ -1,24 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async = require("./providers/async");
const sync = require("./providers/sync");
const settings_1 = require("./settings");
exports.Settings = settings_1.default;
function scandir(path, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === 'function') {
return async.read(path, getSettings(), optionsOrSettingsOrCallback);
}
async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
}
exports.scandir = scandir;
function scandirSync(path, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
return sync.read(path, settings);
}
exports.scandirSync = scandirSync;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}

8
node_modules/@nodelib/fs.scandir/out/providers/async.d.ts generated vendored
View file

@ -1,8 +0,0 @@
/// <reference types="node" />
import Settings from '../settings';
import { Entry } from '../types';
export declare type AsyncCallback = (err: NodeJS.ErrnoException, entries: Entry[]) => void;
export declare function read(directory: string, settings: Settings, callback: AsyncCallback): void;
export declare function readdirWithFileTypes(directory: string, settings: Settings, callback: AsyncCallback): void;
export declare function readdir(directory: string, settings: Settings, callback: AsyncCallback): void;
//# sourceMappingURL=async.d.ts.map

90
node_modules/@nodelib/fs.scandir/out/providers/async.js generated vendored
View file

@ -1,90 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fsStat = require("@nodelib/fs.stat");
const rpl = require("run-parallel");
const constants_1 = require("../constants");
const utils = require("../utils");
function read(directory, settings, callback) {
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
return readdirWithFileTypes(directory, settings, callback);
}
return readdir(directory, settings, callback);
}
exports.read = read;
function readdirWithFileTypes(directory, settings, callback) {
settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
if (readdirError !== null) {
return callFailureCallback(callback, readdirError);
}
const entries = dirents.map((dirent) => ({
dirent,
name: dirent.name,
path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
}));
if (!settings.followSymbolicLinks) {
return callSuccessCallback(callback, entries);
}
const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
rpl(tasks, (rplError, rplEntries) => {
if (rplError !== null) {
return callFailureCallback(callback, rplError);
}
callSuccessCallback(callback, rplEntries);
});
});
}
exports.readdirWithFileTypes = readdirWithFileTypes;
function makeRplTaskEntry(entry, settings) {
return (done) => {
if (!entry.dirent.isSymbolicLink()) {
return done(null, entry);
}
settings.fs.stat(entry.path, (statError, stats) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
return done(statError);
}
return done(null, entry);
}
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
return done(null, entry);
});
};
}
function readdir(directory, settings, callback) {
settings.fs.readdir(directory, (readdirError, names) => {
if (readdirError !== null) {
return callFailureCallback(callback, readdirError);
}
const filepaths = names.map((name) => `${directory}${settings.pathSegmentSeparator}${name}`);
const tasks = filepaths.map((filepath) => {
return (done) => fsStat.stat(filepath, settings.fsStatSettings, done);
});
rpl(tasks, (rplError, results) => {
if (rplError !== null) {
return callFailureCallback(callback, rplError);
}
const entries = [];
names.forEach((name, index) => {
const stats = results[index];
const entry = {
name,
path: filepaths[index],
dirent: utils.fs.createDirentFromStats(name, stats)
};
if (settings.stats) {
entry.stats = stats;
}
entries.push(entry);
});
callSuccessCallback(callback, entries);
});
});
}
exports.readdir = readdir;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, result) {
callback(null, result);
}

6
node_modules/@nodelib/fs.scandir/out/providers/sync.d.ts generated vendored
View file

@ -1,6 +0,0 @@
import Settings from '../settings';
import { Entry } from '../types';
export declare function read(directory: string, settings: Settings): Entry[];
export declare function readdirWithFileTypes(directory: string, settings: Settings): Entry[];
export declare function readdir(directory: string, settings: Settings): Entry[];
//# sourceMappingURL=sync.d.ts.map

52
node_modules/@nodelib/fs.scandir/out/providers/sync.js generated vendored
View file

@ -1,52 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fsStat = require("@nodelib/fs.stat");
const constants_1 = require("../constants");
const utils = require("../utils");
function read(directory, settings) {
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
return readdirWithFileTypes(directory, settings);
}
return readdir(directory, settings);
}
exports.read = read;
function readdirWithFileTypes(directory, settings) {
const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
return dirents.map((dirent) => {
const entry = {
dirent,
name: dirent.name,
path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
};
if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
try {
const stats = settings.fs.statSync(entry.path);
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
}
catch (error) {
if (settings.throwErrorOnBrokenSymbolicLink) {
throw error;
}
}
}
return entry;
});
}
exports.readdirWithFileTypes = readdirWithFileTypes;
function readdir(directory, settings) {
const names = settings.fs.readdirSync(directory);
return names.map((name) => {
const entryPath = `${directory}${settings.pathSegmentSeparator}${name}`;
const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
const entry = {
name,
path: entryPath,
dirent: utils.fs.createDirentFromStats(name, stats)
};
if (settings.stats) {
entry.stats = stats;
}
return entry;
});
}
exports.readdir = readdir;

21
node_modules/@nodelib/fs.scandir/out/settings.d.ts generated vendored
View file

@ -1,21 +0,0 @@
import * as fsStat from '@nodelib/fs.stat';
import * as fs from './adapters/fs';
export declare type Options = {
followSymbolicLinks?: boolean;
fs?: Partial<fs.FileSystemAdapter>;
pathSegmentSeparator?: string;
stats?: boolean;
throwErrorOnBrokenSymbolicLink?: boolean;
};
export default class Settings {
private readonly _options;
readonly followSymbolicLinks: boolean;
readonly fs: fs.FileSystemAdapter;
readonly pathSegmentSeparator: string;
readonly stats: boolean;
readonly throwErrorOnBrokenSymbolicLink: boolean;
readonly fsStatSettings: fsStat.Settings;
constructor(_options?: Options);
private _getValue;
}
//# sourceMappingURL=settings.d.ts.map

24
node_modules/@nodelib/fs.scandir/out/settings.js generated vendored
View file

@ -1,24 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fsStat = require("@nodelib/fs.stat");
const fs = require("./adapters/fs");
class Settings {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
this.fs = fs.createFileSystemAdapter(this._options.fs);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
this.stats = this._getValue(this._options.stats, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
this.fsStatSettings = new fsStat.Settings({
followSymbolicLink: this.followSymbolicLinks,
fs: this.fs,
throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option === undefined ? value : option;
}
}
exports.default = Settings;

20
node_modules/@nodelib/fs.scandir/out/types/index.d.ts generated vendored
View file

@ -1,20 +0,0 @@
/// <reference types="node" />
import * as fs from 'fs';
export declare type Entry = {
dirent: Dirent;
name: string;
path: string;
stats?: Stats;
};
export declare type Stats = fs.Stats;
export declare type Dirent = {
isBlockDevice(): boolean;
isCharacterDevice(): boolean;
isDirectory(): boolean;
isFIFO(): boolean;
isFile(): boolean;
isSocket(): boolean;
isSymbolicLink(): boolean;
name: string;
};
//# sourceMappingURL=index.d.ts.map

2
node_modules/@nodelib/fs.scandir/out/types/index.js generated vendored
View file

@ -1,2 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

3
node_modules/@nodelib/fs.scandir/out/utils/fs.d.ts generated vendored
View file

@ -1,3 +0,0 @@
import { Dirent, Stats } from '../types';
export declare function createDirentFromStats(name: string, stats: Stats): Dirent;
//# sourceMappingURL=fs.d.ts.map

18
node_modules/@nodelib/fs.scandir/out/utils/fs.js generated vendored
View file

@ -1,18 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
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;

3
node_modules/@nodelib/fs.scandir/out/utils/index.d.ts generated vendored
View file

@ -1,3 +0,0 @@
import * as fs from './fs';
export { fs };
//# sourceMappingURL=index.d.ts.map

4
node_modules/@nodelib/fs.scandir/out/utils/index.js generated vendored
View file

@ -1,4 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("./fs");
exports.fs = fs;

64
node_modules/@nodelib/fs.scandir/package.json generated vendored
View file

@ -1,64 +0,0 @@
{
"_from": "@nodelib/fs.scandir@2.1.3",
"_id": "@nodelib/fs.scandir@2.1.3",
"_inBundle": false,
"_integrity": "sha512-eGmwYQn3gxo4r7jdQnkrrN6bY478C3P+a/y72IJukF8LjB6ZHeB3c+Ehacj3sYeSmUXGlnA67/PmbM9CVwL7Dw==",
"_location": "/@nodelib/fs.scandir",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "@nodelib/fs.scandir@2.1.3",
"name": "@nodelib/fs.scandir",
"escapedName": "@nodelib%2ffs.scandir",
"scope": "@nodelib",
"rawSpec": "2.1.3",
"saveSpec": null,
"fetchSpec": "2.1.3"
},
"_requiredBy": [
"/@nodelib/fs.walk"
],
"_resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz",
"_shasum": "3a582bdb53804c6ba6d146579c46e52130cf4a3b",
"_spec": "@nodelib/fs.scandir@2.1.3",
"_where": "/home/yarmo/dev/keyoxide/doipjs/node_modules/@nodelib/fs.walk",
"bundleDependencies": false,
"dependencies": {
"@nodelib/fs.stat": "2.0.3",
"run-parallel": "^1.1.9"
},
"deprecated": false,
"description": "List files and directories inside the specified directory",
"engines": {
"node": ">= 8"
},
"gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
"keywords": [
"NodeLib",
"fs",
"FileSystem",
"file system",
"scandir",
"readdir",
"dirent"
],
"license": "MIT",
"main": "out/index.js",
"name": "@nodelib/fs.scandir",
"repository": {
"type": "git",
"url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.scandir"
},
"scripts": {
"build": "npm run clean && npm run compile && npm run lint && npm test",
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
"compile": "tsc -b .",
"compile:watch": "tsc -p . --watch --sourceMap",
"lint": "eslint \"src/**/*.ts\" --cache",
"test": "mocha \"out/**/*.spec.js\" -s 0",
"watch": "npm run clean && npm run compile:watch"
},
"typings": "out/index.d.ts",
"version": "2.1.3"
}

21
node_modules/@nodelib/fs.stat/LICENSE generated vendored
View file

@ -1,21 +0,0 @@
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.

126
node_modules/@nodelib/fs.stat/README.md generated vendored
View file

@ -1,126 +0,0 @@
# @nodelib/fs.stat
> Get the status of a file with some features.
## :bulb: Highlights
Wrapper around standard method `fs.lstat` and `fs.stat` with some features.
* :beginner: Normally follows symbolic link.
* :gear: Can safely work with broken symbolic link.
## Install
```console
npm install @nodelib/fs.stat
```
## Usage
```ts
import * as fsStat from '@nodelib/fs.stat';
fsStat.stat('path', (error, stats) => { /* … */ });
```
## API
### .stat(path, [optionsOrSettings], callback)
Returns an instance of `fs.Stats` class for provided path with standard callback-style.
```ts
fsStat.stat('path', (error, stats) => { /* … */ });
fsStat.stat('path', {}, (error, stats) => { /* … */ });
fsStat.stat('path', new fsStat.Settings(), (error, stats) => { /* … */ });
```
### .statSync(path, [optionsOrSettings])
Returns an instance of `fs.Stats` class for provided path.
```ts
const stats = fsStat.stat('path');
const stats = fsStat.stat('path', {});
const stats = fsStat.stat('path', new fsStat.Settings());
```
#### path
* Required: `true`
* Type: `string | Buffer | URL`
A path to a file. If a URL is provided, it must use the `file:` protocol.
#### optionsOrSettings
* Required: `false`
* Type: `Options | Settings`
* Default: An instance of `Settings` class
An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
### Settings([options])
A class of full settings of the package.
```ts
const settings = new fsStat.Settings({ followSymbolicLink: false });
const stats = fsStat.stat('path', settings);
```
## Options
### `followSymbolicLink`
* Type: `boolean`
* Default: `true`
Follow symbolic link or not. Call `fs.stat` on symbolic link if `true`.
### `markSymbolicLink`
* Type: `boolean`
* Default: `false`
Mark symbolic link by setting the return value of `isSymbolicLink` function to always `true` (even after `fs.stat`).
> :book: Can be used if you want to know what is hidden behind a symbolic link, but still continue to know that it is a symbolic link.
### `throwErrorOnBrokenSymbolicLink`
* Type: `boolean`
* Default: `true`
Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
### `fs`
* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
* Default: A default FS methods
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
```ts
interface FileSystemAdapter {
lstat?: typeof fs.lstat;
stat?: typeof fs.stat;
lstatSync?: typeof fs.lstatSync;
statSync?: typeof fs.statSync;
}
const settings = new fsStat.Settings({
fs: { lstat: fakeLstat }
});
```
## Changelog
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
## License
This software is released under the terms of the MIT license.

11
node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts generated vendored
View file

@ -1,11 +0,0 @@
/// <reference types="node" />
import * as fs from 'fs';
export declare type FileSystemAdapter = {
lstat: typeof fs.lstat;
stat: typeof fs.stat;
lstatSync: typeof fs.lstatSync;
statSync: typeof fs.statSync;
};
export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
//# sourceMappingURL=fs.d.ts.map

16
node_modules/@nodelib/fs.stat/out/adapters/fs.js generated vendored
View file

@ -1,16 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs.lstat,
stat: fs.stat,
lstatSync: fs.lstatSync,
statSync: fs.statSync
};
function createFileSystemAdapter(fsMethods) {
if (fsMethods === undefined) {
return exports.FILE_SYSTEM_ADAPTER;
}
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter;

13
node_modules/@nodelib/fs.stat/out/index.d.ts generated vendored
View file

@ -1,13 +0,0 @@
import { FileSystemAdapter } from './adapters/fs';
import * as async from './providers/async';
import Settings, { Options } from './settings';
import { Stats } from './types';
declare type AsyncCallback = async.AsyncCallback;
declare function stat(path: string, callback: AsyncCallback): void;
declare function stat(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
declare namespace stat {
function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Stats>;
}
declare function statSync(path: string, optionsOrSettings?: Options | Settings): Stats;
export { Settings, stat, statSync, AsyncCallback, FileSystemAdapter, Options, Stats };
//# sourceMappingURL=index.d.ts.map

24
node_modules/@nodelib/fs.stat/out/index.js generated vendored
View file

@ -1,24 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async = require("./providers/async");
const sync = require("./providers/sync");
const settings_1 = require("./settings");
exports.Settings = settings_1.default;
function stat(path, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === 'function') {
return async.read(path, getSettings(), optionsOrSettingsOrCallback);
}
async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
}
exports.stat = stat;
function statSync(path, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
return sync.read(path, settings);
}
exports.statSync = statSync;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}

5
node_modules/@nodelib/fs.stat/out/providers/async.d.ts generated vendored
View file

@ -1,5 +0,0 @@
import Settings from '../settings';
import { ErrnoException, Stats } from '../types';
export declare type AsyncCallback = (err: ErrnoException, stats: Stats) => void;
export declare function read(path: string, settings: Settings, callback: AsyncCallback): void;
//# sourceMappingURL=async.d.ts.map

31
node_modules/@nodelib/fs.stat/out/providers/async.js generated vendored
View file

@ -1,31 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function read(path, settings, callback) {
settings.fs.lstat(path, (lstatError, lstat) => {
if (lstatError !== null) {
return callFailureCallback(callback, lstatError);
}
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
return callSuccessCallback(callback, lstat);
}
settings.fs.stat(path, (statError, stat) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
return callFailureCallback(callback, statError);
}
return callSuccessCallback(callback, lstat);
}
if (settings.markSymbolicLink) {
stat.isSymbolicLink = () => true;
}
callSuccessCallback(callback, stat);
});
});
}
exports.read = read;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, result) {
callback(null, result);
}

4
node_modules/@nodelib/fs.stat/out/providers/sync.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import Settings from '../settings';
import { Stats } from '../types';
export declare function read(path: string, settings: Settings): Stats;
//# sourceMappingURL=sync.d.ts.map

22
node_modules/@nodelib/fs.stat/out/providers/sync.js generated vendored
View file

@ -1,22 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function read(path, settings) {
const lstat = settings.fs.lstatSync(path);
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
return lstat;
}
try {
const stat = settings.fs.statSync(path);
if (settings.markSymbolicLink) {
stat.isSymbolicLink = () => true;
}
return stat;
}
catch (error) {
if (!settings.throwErrorOnBrokenSymbolicLink) {
return lstat;
}
throw error;
}
}
exports.read = read;

17
node_modules/@nodelib/fs.stat/out/settings.d.ts generated vendored
View file

@ -1,17 +0,0 @@
import * as fs from './adapters/fs';
export declare type Options = {
followSymbolicLink?: boolean;
fs?: Partial<fs.FileSystemAdapter>;
markSymbolicLink?: boolean;
throwErrorOnBrokenSymbolicLink?: boolean;
};
export default class Settings {
private readonly _options;
readonly followSymbolicLink: boolean;
readonly fs: fs.FileSystemAdapter;
readonly markSymbolicLink: boolean;
readonly throwErrorOnBrokenSymbolicLink: boolean;
constructor(_options?: Options);
private _getValue;
}
//# sourceMappingURL=settings.d.ts.map

16
node_modules/@nodelib/fs.stat/out/settings.js generated vendored
View file

@ -1,16 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("./adapters/fs");
class Settings {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
this.fs = fs.createFileSystemAdapter(this._options.fs);
this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
}
_getValue(option, value) {
return option === undefined ? value : option;
}
}
exports.default = Settings;

5
node_modules/@nodelib/fs.stat/out/types/index.d.ts generated vendored
View file

@ -1,5 +0,0 @@
/// <reference types="node" />
import * as fs from 'fs';
export declare type Stats = fs.Stats;
export declare type ErrnoException = NodeJS.ErrnoException;
//# sourceMappingURL=index.d.ts.map

2
node_modules/@nodelib/fs.stat/out/types/index.js generated vendored
View file

@ -1,2 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

59
node_modules/@nodelib/fs.stat/package.json generated vendored
View file

@ -1,59 +0,0 @@
{
"_from": "@nodelib/fs.stat@^2.0.2",
"_id": "@nodelib/fs.stat@2.0.3",
"_inBundle": false,
"_integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==",
"_location": "/@nodelib/fs.stat",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@nodelib/fs.stat@^2.0.2",
"name": "@nodelib/fs.stat",
"escapedName": "@nodelib%2ffs.stat",
"scope": "@nodelib",
"rawSpec": "^2.0.2",
"saveSpec": null,
"fetchSpec": "^2.0.2"
},
"_requiredBy": [
"/@nodelib/fs.scandir",
"/fast-glob"
],
"_resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
"_shasum": "34dc5f4cabbc720f4e60f75a747e7ecd6c175bd3",
"_spec": "@nodelib/fs.stat@^2.0.2",
"_where": "/home/yarmo/dev/keyoxide/doipjs/node_modules/fast-glob",
"bundleDependencies": false,
"deprecated": false,
"description": "Get the status of a file with some features",
"engines": {
"node": ">= 8"
},
"gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
"keywords": [
"NodeLib",
"fs",
"FileSystem",
"file system",
"stat"
],
"license": "MIT",
"main": "out/index.js",
"name": "@nodelib/fs.stat",
"repository": {
"type": "git",
"url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat"
},
"scripts": {
"build": "npm run clean && npm run compile && npm run lint && npm test",
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
"compile": "tsc -b .",
"compile:watch": "tsc -p . --watch --sourceMap",
"lint": "eslint \"src/**/*.ts\" --cache",
"test": "mocha \"out/**/*.spec.js\" -s 0",
"watch": "npm run clean && npm run compile:watch"
},
"typings": "out/index.d.ts",
"version": "2.0.3"
}

21
node_modules/@nodelib/fs.walk/LICENSE generated vendored
View file

@ -1,21 +0,0 @@
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.

215
node_modules/@nodelib/fs.walk/README.md generated vendored
View file

@ -1,215 +0,0 @@
# @nodelib/fs.walk
> A library for efficiently walking a directory recursively.
## :bulb: Highlights
* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
* :rocket: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type for performance reasons. See [`old` and `modern` mode](https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode).
* :gear: Built-in directories/files and error filtering system.
* :link: Can safely work with broken symbolic links.
## Install
```console
npm install @nodelib/fs.walk
```
## Usage
```ts
import * as fsWalk from '@nodelib/fs.walk';
fsWalk.walk('path', (error, entries) => { /* … */ });
```
## API
### .walk(path, [optionsOrSettings], callback)
Reads the directory recursively and asynchronously. Requires a callback function.
> :book: If you want to use the Promise API, use `util.promisify`.
```ts
fsWalk.walk('path', (error, entries) => { /* … */ });
fsWalk.walk('path', {}, (error, entries) => { /* … */ });
fsWalk.walk('path', new fsWalk.Settings(), (error, entries) => { /* … */ });
```
### .walkStream(path, [optionsOrSettings])
Reads the directory recursively and asynchronously. [Readable Stream](https://nodejs.org/dist/latest-v12.x/docs/api/stream.html#stream_readable_streams) is used as a provider.
```ts
const stream = fsWalk.walkStream('path');
const stream = fsWalk.walkStream('path', {});
const stream = fsWalk.walkStream('path', new fsWalk.Settings());
```
### .walkSync(path, [optionsOrSettings])
Reads the directory recursively and synchronously. Returns an array of entries.
```ts
const entries = fsWalk.walkSync('path');
const entries = fsWalk.walkSync('path', {});
const entries = fsWalk.walkSync('path', new fsWalk.Settings());
```
#### path
* Required: `true`
* Type: `string | Buffer | URL`
A path to a file. If a URL is provided, it must use the `file:` protocol.
#### optionsOrSettings
* Required: `false`
* Type: `Options | Settings`
* Default: An instance of `Settings` class
An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
### Settings([options])
A class of full settings of the package.
```ts
const settings = new fsWalk.Settings({ followSymbolicLinks: true });
const entries = fsWalk.walkSync('path', settings);
```
## Entry
* `name` — The name of the entry (`unknown.txt`).
* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class.
* [`stats`] — An instance of `fs.Stats` class.
## Options
### basePath
* Type: `string`
* Default: `undefined`
By default, all paths are built relative to the root path. You can use this option to set custom root path.
In the example below we read the files from the `root` directory, but in the results the root path will be `custom`.
```ts
fsWalk.walkSync('root'); // → ['root/file.txt']
fsWalk.walkSync('root', { basePath: 'custom' }); // → ['custom/file.txt']
```
### concurrency
* Type: `number`
* Default: `Infinity`
The maximum number of concurrent calls to `fs.readdir`.
> :book: The higher the number, the higher performance and the load on the File System. If you want to read in quiet mode, set the value to `4 * os.cpus().length` (4 is default size of [thread pool work scheduling](http://docs.libuv.org/en/v1.x/threadpool.html#thread-pool-work-scheduling)).
### deepFilter
* Type: [`DeepFilterFunction`](./src/settings.ts)
* Default: `undefined`
A function that indicates whether the directory will be read deep or not.
```ts
// Skip all directories that starts with `node_modules`
const filter: DeepFilterFunction = (entry) => !entry.path.startsWith('node_modules');
```
### entryFilter
* Type: [`EntryFilterFunction`](./src/settings.ts)
* Default: `undefined`
A function that indicates whether the entry will be included to results or not.
```ts
// Exclude all `.js` files from results
const filter: EntryFilterFunction = (entry) => !entry.name.endsWith('.js');
```
### errorFilter
* Type: [`ErrorFilterFunction`](./src/settings.ts)
* Default: `undefined`
A function that allows you to skip errors that occur when reading directories.
For example, you can skip `ENOENT` errors if required:
```ts
// Skip all ENOENT errors
const filter: ErrorFilterFunction = (error) => error.code == 'ENOENT';
```
### stats
* Type: `boolean`
* Default: `false`
Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
> :book: Always use `fs.readdir` with additional `fs.lstat/fs.stat` calls to determine the entry type.
### followSymbolicLinks
* Type: `boolean`
* Default: `false`
Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
### `throwErrorOnBrokenSymbolicLink`
* Type: `boolean`
* Default: `true`
Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
### `pathSegmentSeparator`
* Type: `string`
* Default: `path.sep`
By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
### `fs`
* Type: `FileSystemAdapter`
* Default: A default FS methods
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
```ts
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;
}
const settings = new fsWalk.Settings({
fs: { lstat: fakeLstat }
});
```
## Changelog
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
## License
This software is released under the terms of the MIT license.

15
node_modules/@nodelib/fs.walk/out/index.d.ts generated vendored
View file

@ -1,15 +0,0 @@
/// <reference types="node" />
import { Readable } from 'stream';
import { Dirent, FileSystemAdapter } from '@nodelib/fs.scandir';
import { AsyncCallback } from './providers/async';
import Settings, { DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction, Options } from './settings';
import { Entry } from './types';
declare function walk(directory: string, callback: AsyncCallback): void;
declare function walk(directory: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
declare namespace walk {
function __promisify__(directory: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
}
declare function walkSync(directory: string, optionsOrSettings?: Options | Settings): Entry[];
declare function walkStream(directory: string, optionsOrSettings?: Options | Settings): Readable;
export { walk, walkSync, walkStream, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, Options, DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction };
//# sourceMappingURL=index.d.ts.map

32
node_modules/@nodelib/fs.walk/out/index.js generated vendored
View file

@ -1,32 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async_1 = require("./providers/async");
const stream_1 = require("./providers/stream");
const sync_1 = require("./providers/sync");
const settings_1 = require("./settings");
exports.Settings = settings_1.default;
function walk(directory, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === 'function') {
return new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
}
new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
}
exports.walk = walk;
function walkSync(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new sync_1.default(directory, settings);
return provider.read();
}
exports.walkSync = walkSync;
function walkStream(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new stream_1.default(directory, settings);
return provider.read();
}
exports.walkStream = walkStream;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}

13
node_modules/@nodelib/fs.walk/out/providers/async.d.ts generated vendored
View file

@ -1,13 +0,0 @@
import AsyncReader from '../readers/async';
import Settings from '../settings';
import { Entry, Errno } from '../types';
export declare type AsyncCallback = (err: Errno, entries: Entry[]) => void;
export default class AsyncProvider {
private readonly _root;
private readonly _settings;
protected readonly _reader: AsyncReader;
private readonly _storage;
constructor(_root: string, _settings: Settings);
read(callback: AsyncCallback): void;
}
//# sourceMappingURL=async.d.ts.map

30
node_modules/@nodelib/fs.walk/out/providers/async.js generated vendored
View file

@ -1,30 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async_1 = require("../readers/async");
class AsyncProvider {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1.default(this._root, this._settings);
this._storage = new Set();
}
read(callback) {
this._reader.onError((error) => {
callFailureCallback(callback, error);
});
this._reader.onEntry((entry) => {
this._storage.add(entry);
});
this._reader.onEnd(() => {
callSuccessCallback(callback, [...this._storage]);
});
this._reader.read();
}
}
exports.default = AsyncProvider;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, entries) {
callback(null, entries);
}

5
node_modules/@nodelib/fs.walk/out/providers/index.d.ts generated vendored
View file

@ -1,5 +0,0 @@
import AsyncProvider from './async';
import StreamProvider from './stream';
import SyncProvider from './sync';
export { AsyncProvider, StreamProvider, SyncProvider };
//# sourceMappingURL=index.d.ts.map

8
node_modules/@nodelib/fs.walk/out/providers/index.js generated vendored
View file

@ -1,8 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async_1 = require("./async");
exports.AsyncProvider = async_1.default;
const stream_1 = require("./stream");
exports.StreamProvider = stream_1.default;
const sync_1 = require("./sync");
exports.SyncProvider = sync_1.default;

13
node_modules/@nodelib/fs.walk/out/providers/stream.d.ts generated vendored
View file

@ -1,13 +0,0 @@
/// <reference types="node" />
import { Readable } from 'stream';
import AsyncReader from '../readers/async';
import Settings from '../settings';
export default class StreamProvider {
private readonly _root;
private readonly _settings;
protected readonly _reader: AsyncReader;
protected readonly _stream: Readable;
constructor(_root: string, _settings: Settings);
read(): Readable;
}
//# sourceMappingURL=stream.d.ts.map

30
node_modules/@nodelib/fs.walk/out/providers/stream.js generated vendored
View file

@ -1,30 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1 = require("stream");
const async_1 = require("../readers/async");
class StreamProvider {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1.default(this._root, this._settings);
this._stream = new stream_1.Readable({
objectMode: true,
read: () => { },
destroy: this._reader.destroy.bind(this._reader)
});
}
read() {
this._reader.onError((error) => {
this._stream.emit('error', error);
});
this._reader.onEntry((entry) => {
this._stream.push(entry);
});
this._reader.onEnd(() => {
this._stream.push(null);
});
this._reader.read();
return this._stream;
}
}
exports.default = StreamProvider;

11
node_modules/@nodelib/fs.walk/out/providers/sync.d.ts generated vendored
View file

@ -1,11 +0,0 @@
import SyncReader from '../readers/sync';
import Settings from '../settings';
import { Entry } from '../types';
export default class SyncProvider {
private readonly _root;
private readonly _settings;
protected readonly _reader: SyncReader;
constructor(_root: string, _settings: Settings);
read(): Entry[];
}
//# sourceMappingURL=sync.d.ts.map

14
node_modules/@nodelib/fs.walk/out/providers/sync.js generated vendored
View file

@ -1,14 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const sync_1 = require("../readers/sync");
class SyncProvider {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new sync_1.default(this._root, this._settings);
}
read() {
return this._reader.read();
}
}
exports.default = SyncProvider;

30
node_modules/@nodelib/fs.walk/out/readers/async.d.ts generated vendored
View file

@ -1,30 +0,0 @@
/// <reference types="node" />
import { EventEmitter } from 'events';
import * as fsScandir from '@nodelib/fs.scandir';
import Settings from '../settings';
import { Entry, Errno } from '../types';
import Reader from './reader';
declare type EntryEventCallback = (entry: Entry) => void;
declare type ErrorEventCallback = (error: Errno) => void;
declare type EndEventCallback = () => void;
export default class AsyncReader extends Reader {
protected readonly _settings: Settings;
protected readonly _scandir: typeof fsScandir.scandir;
protected readonly _emitter: EventEmitter;
private readonly _queue;
private _isFatalError;
private _isDestroyed;
constructor(_root: string, _settings: Settings);
read(): EventEmitter;
destroy(): void;
onEntry(callback: EntryEventCallback): void;
onError(callback: ErrorEventCallback): void;
onEnd(callback: EndEventCallback): void;
private _pushToQueue;
private _worker;
private _handleError;
private _handleEntry;
private _emitEntry;
}
export {};
//# sourceMappingURL=async.d.ts.map

93
node_modules/@nodelib/fs.walk/out/readers/async.js generated vendored
View file

@ -1,93 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const fsScandir = require("@nodelib/fs.scandir");
const fastq = require("fastq");
const common = require("./common");
const reader_1 = require("./reader");
class AsyncReader extends reader_1.default {
constructor(_root, _settings) {
super(_root, _settings);
this._settings = _settings;
this._scandir = fsScandir.scandir;
this._emitter = new events_1.EventEmitter();
this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
this._isFatalError = false;
this._isDestroyed = false;
this._queue.drain = () => {
if (!this._isFatalError) {
this._emitter.emit('end');
}
};
}
read() {
this._isFatalError = false;
this._isDestroyed = false;
setImmediate(() => {
this._pushToQueue(this._root, this._settings.basePath);
});
return this._emitter;
}
destroy() {
if (this._isDestroyed) {
throw new Error('The reader is already destroyed');
}
this._isDestroyed = true;
this._queue.killAndDrain();
}
onEntry(callback) {
this._emitter.on('entry', callback);
}
onError(callback) {
this._emitter.once('error', callback);
}
onEnd(callback) {
this._emitter.once('end', callback);
}
_pushToQueue(directory, base) {
const queueItem = { directory, base };
this._queue.push(queueItem, (error) => {
if (error !== null) {
this._handleError(error);
}
});
}
_worker(item, done) {
this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
if (error !== null) {
return done(error, undefined);
}
for (const entry of entries) {
this._handleEntry(entry, item.base);
}
done(null, undefined);
});
}
_handleError(error) {
if (!common.isFatalError(this._settings, error)) {
return;
}
this._isFatalError = true;
this._isDestroyed = true;
this._emitter.emit('error', error);
}
_handleEntry(entry, base) {
if (this._isDestroyed || this._isFatalError) {
return;
}
const fullpath = entry.path;
if (base !== undefined) {
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
}
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
this._emitEntry(entry);
}
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
this._pushToQueue(fullpath, entry.path);
}
}
_emitEntry(entry) {
this._emitter.emit('entry', entry);
}
}
exports.default = AsyncReader;

7
node_modules/@nodelib/fs.walk/out/readers/common.d.ts generated vendored
View file

@ -1,7 +0,0 @@
import Settings, { FilterFunction } from '../settings';
import { Errno } from '../types';
export declare function isFatalError(settings: Settings, error: Errno): boolean;
export declare function isAppliedFilter<T>(filter: FilterFunction<T> | null, value: T): boolean;
export declare function replacePathSegmentSeparator(filepath: string, separator: string): string;
export declare function joinPathSegments(a: string, b: string, separator: string): string;
//# sourceMappingURL=common.d.ts.map

24
node_modules/@nodelib/fs.walk/out/readers/common.js generated vendored
View file

@ -1,24 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function isFatalError(settings, error) {
if (settings.errorFilter === null) {
return true;
}
return !settings.errorFilter(error);
}
exports.isFatalError = isFatalError;
function isAppliedFilter(filter, value) {
return filter === null || filter(value);
}
exports.isAppliedFilter = isAppliedFilter;
function replacePathSegmentSeparator(filepath, separator) {
return filepath.split(/[\\/]/).join(separator);
}
exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
function joinPathSegments(a, b, separator) {
if (a === '') {
return b;
}
return a + separator + b;
}
exports.joinPathSegments = joinPathSegments;

7
node_modules/@nodelib/fs.walk/out/readers/reader.d.ts generated vendored
View file

@ -1,7 +0,0 @@
import Settings from '../settings';
export default class Reader {
protected readonly _root: string;
protected readonly _settings: Settings;
constructor(_root: string, _settings: Settings);
}
//# sourceMappingURL=reader.d.ts.map

11
node_modules/@nodelib/fs.walk/out/readers/reader.js generated vendored
View file

@ -1,11 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const common = require("./common");
class Reader {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
}
}
exports.default = Reader;

16
node_modules/@nodelib/fs.walk/out/readers/sync.d.ts generated vendored
View file

@ -1,16 +0,0 @@
import * as fsScandir from '@nodelib/fs.scandir';
import { Entry } from '../types';
import Reader from './reader';
export default class SyncReader extends Reader {
protected readonly _scandir: typeof fsScandir.scandirSync;
private readonly _storage;
private readonly _queue;
read(): Entry[];
private _pushToQueue;
private _handleQueue;
private _handleDirectory;
private _handleError;
private _handleEntry;
private _pushToStorage;
}
//# sourceMappingURL=sync.d.ts.map

59
node_modules/@nodelib/fs.walk/out/readers/sync.js generated vendored
View file

@ -1,59 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fsScandir = require("@nodelib/fs.scandir");
const common = require("./common");
const reader_1 = require("./reader");
class SyncReader extends reader_1.default {
constructor() {
super(...arguments);
this._scandir = fsScandir.scandirSync;
this._storage = new Set();
this._queue = new Set();
}
read() {
this._pushToQueue(this._root, this._settings.basePath);
this._handleQueue();
return [...this._storage];
}
_pushToQueue(directory, base) {
this._queue.add({ directory, base });
}
_handleQueue() {
for (const item of this._queue.values()) {
this._handleDirectory(item.directory, item.base);
}
}
_handleDirectory(directory, base) {
try {
const entries = this._scandir(directory, this._settings.fsScandirSettings);
for (const entry of entries) {
this._handleEntry(entry, base);
}
}
catch (error) {
this._handleError(error);
}
}
_handleError(error) {
if (!common.isFatalError(this._settings, error)) {
return;
}
throw error;
}
_handleEntry(entry, base) {
const fullpath = entry.path;
if (base !== undefined) {
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
}
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
this._pushToStorage(entry);
}
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
this._pushToQueue(fullpath, entry.path);
}
}
_pushToStorage(entry) {
this._storage.add(entry);
}
}
exports.default = SyncReader;

31
node_modules/@nodelib/fs.walk/out/settings.d.ts generated vendored
View file

@ -1,31 +0,0 @@
import * as fsScandir from '@nodelib/fs.scandir';
import { Entry, Errno } from './types';
export declare type FilterFunction<T> = (value: T) => boolean;
export declare type DeepFilterFunction = FilterFunction<Entry>;
export declare type EntryFilterFunction = FilterFunction<Entry>;
export declare type ErrorFilterFunction = FilterFunction<Errno>;
export declare type Options = {
basePath?: string;
concurrency?: number;
deepFilter?: DeepFilterFunction;
entryFilter?: EntryFilterFunction;
errorFilter?: ErrorFilterFunction;
followSymbolicLinks?: boolean;
fs?: Partial<fsScandir.FileSystemAdapter>;
pathSegmentSeparator?: string;
stats?: boolean;
throwErrorOnBrokenSymbolicLink?: boolean;
};
export default class Settings {
private readonly _options;
readonly basePath?: string;
readonly concurrency: number;
readonly deepFilter: DeepFilterFunction | null;
readonly entryFilter: EntryFilterFunction | null;
readonly errorFilter: ErrorFilterFunction | null;
readonly pathSegmentSeparator: string;
readonly fsScandirSettings: fsScandir.Settings;
constructor(_options?: Options);
private _getValue;
}
//# sourceMappingURL=settings.d.ts.map

26
node_modules/@nodelib/fs.walk/out/settings.js generated vendored
View file

@ -1,26 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fsScandir = require("@nodelib/fs.scandir");
class Settings {
constructor(_options = {}) {
this._options = _options;
this.basePath = this._getValue(this._options.basePath, undefined);
this.concurrency = this._getValue(this._options.concurrency, Infinity);
this.deepFilter = this._getValue(this._options.deepFilter, null);
this.entryFilter = this._getValue(this._options.entryFilter, null);
this.errorFilter = this._getValue(this._options.errorFilter, null);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
this.fsScandirSettings = new fsScandir.Settings({
followSymbolicLinks: this._options.followSymbolicLinks,
fs: this._options.fs,
pathSegmentSeparator: this._options.pathSegmentSeparator,
stats: this._options.stats,
throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option === undefined ? value : option;
}
}
exports.default = Settings;

9
node_modules/@nodelib/fs.walk/out/types/index.d.ts generated vendored
View file

@ -1,9 +0,0 @@
/// <reference types="node" />
import * as scandir from '@nodelib/fs.scandir';
export declare type Entry = scandir.Entry;
export declare type Errno = NodeJS.ErrnoException;
export declare type QueueItem = {
directory: string;
base?: string;
};
//# sourceMappingURL=index.d.ts.map

2
node_modules/@nodelib/fs.walk/out/types/index.js generated vendored
View file

@ -1,2 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

64
node_modules/@nodelib/fs.walk/package.json generated vendored
View file

@ -1,64 +0,0 @@
{
"_from": "@nodelib/fs.walk@^1.2.3",
"_id": "@nodelib/fs.walk@1.2.4",
"_inBundle": false,
"_integrity": "sha512-1V9XOY4rDW0rehzbrcqAmHnz8e7SKvX27gh8Gt2WgB0+pdzdiLV83p72kZPU+jvMbS1qU5mauP2iOvO8rhmurQ==",
"_location": "/@nodelib/fs.walk",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@nodelib/fs.walk@^1.2.3",
"name": "@nodelib/fs.walk",
"escapedName": "@nodelib%2ffs.walk",
"scope": "@nodelib",
"rawSpec": "^1.2.3",
"saveSpec": null,
"fetchSpec": "^1.2.3"
},
"_requiredBy": [
"/fast-glob"
],
"_resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz",
"_shasum": "011b9202a70a6366e436ca5c065844528ab04976",
"_spec": "@nodelib/fs.walk@^1.2.3",
"_where": "/home/yarmo/dev/keyoxide/doipjs/node_modules/fast-glob",
"bundleDependencies": false,
"dependencies": {
"@nodelib/fs.scandir": "2.1.3",
"fastq": "^1.6.0"
},
"deprecated": false,
"description": "A library for efficiently walking a directory recursively",
"engines": {
"node": ">= 8"
},
"gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
"keywords": [
"NodeLib",
"fs",
"FileSystem",
"file system",
"walk",
"scanner",
"crawler"
],
"license": "MIT",
"main": "out/index.js",
"name": "@nodelib/fs.walk",
"repository": {
"type": "git",
"url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.walk"
},
"scripts": {
"build": "npm run clean && npm run compile && npm run lint && npm test",
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
"compile": "tsc -b .",
"compile:watch": "tsc -p . --watch --sourceMap",
"lint": "eslint \"src/**/*.ts\" --cache",
"test": "mocha \"out/**/*.spec.js\" -s 0",
"watch": "npm run clean && npm run compile:watch"
},
"typings": "out/index.d.ts",
"version": "1.2.4"
}

32
node_modules/@sinonjs/commons/CHANGES.md generated vendored
View file

@ -1,32 +0,0 @@
# Changes
## 1.8.1
- [`07b9e7a`](https://github.com/sinonjs/commons/commit/07b9e7a1d784771273a9a58d74945bbc7319b5d4)
Optimize npm package size (Uladzimir Havenchyk)
_Released on 2020-07-17._
## 1.8.0
- [`4282205`](https://github.com/sinonjs/commons/commit/4282205343a4dcde2a35ccf2a8c2094300dad369)
Emit deprecationg warnings in node, and keep console info in browsers (mshaaban0)
_Released on 2020-05-20._
## 1.7.2
- [`76ad9c1`](https://github.com/sinonjs/commons/commit/76ad9c16bad29f72420ed55bdf45b65d076108c8)
Fix generators causing exceptions in function-name (Sebastian Mayr)
_Released on 2020-04-08._
## 1.7.1
- [`0486d25`](https://github.com/sinonjs/commons/commit/0486d250ecec9b5f9aa2210357767e413f4162d3)
Upgrade eslint-config-sinon, add eslint-plugin-jsdoc (Morgan Roderick)
>
> This adds linting of jsdoc
>
_Released on 2020-02-19._

29
node_modules/@sinonjs/commons/LICENSE generated vendored
View file

@ -1,29 +0,0 @@
BSD 3-Clause License
Copyright (c) 2018, Sinon.JS
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

16
node_modules/@sinonjs/commons/README.md generated vendored
View file

@ -1,16 +0,0 @@
# commons
[![CircleCI](https://circleci.com/gh/sinonjs/commons.svg?style=svg)](https://circleci.com/gh/sinonjs/commons)
[![codecov](https://codecov.io/gh/sinonjs/commons/branch/master/graph/badge.svg)](https://codecov.io/gh/sinonjs/commons)
<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
Simple functions shared among the sinon end user libraries
## Rules
* Follows the [Sinon.JS compatibility](https://github.com/sinonjs/sinon/blob/master/CONTRIBUTING.md#compatibility)
* 100% test coverage
* Code formatted using [Prettier](https://prettier.io)
* No side effects welcome! (only pure functions)
* No platform specific functions
* One export per file (any bundler can do tree shaking)

57
node_modules/@sinonjs/commons/lib/called-in-order.js generated vendored
View file

@ -1,57 +0,0 @@
"use strict";
var every = require("./prototypes/array").every;
/**
* @private
*/
function hasCallsLeft(callMap, spy) {
if (callMap[spy.id] === undefined) {
callMap[spy.id] = 0;
}
return callMap[spy.id] < spy.callCount;
}
/**
* @private
*/
function checkAdjacentCalls(callMap, spy, index, spies) {
var calledBeforeNext = true;
if (index !== spies.length - 1) {
calledBeforeNext = spy.calledBefore(spies[index + 1]);
}
if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
callMap[spy.id] += 1;
return true;
}
return false;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} calledBefore - A method that determines if this proxy was called before another one
* @property {string} id - Some id
* @property {number} callCount - Number of times this proxy has been called
*/
/**
* Returns true when the spies have been called in the order they were supplied in
*
* @param {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
* @returns {boolean} true when spies are called in order, false otherwise
*/
function calledInOrder(spies) {
var callMap = {};
// eslint-disable-next-line no-underscore-dangle
var _spies = arguments.length > 1 ? arguments : spies;
return every(_spies, checkAdjacentCalls.bind(null, callMap));
}
module.exports = calledInOrder;

121
node_modules/@sinonjs/commons/lib/called-in-order.test.js generated vendored
View file

@ -1,121 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var calledInOrder = require("./called-in-order");
var sinon = require("@sinonjs/referee-sinon").sinon;
var testObject1 = {
someFunction: function() {
return;
}
};
var testObject2 = {
otherFunction: function() {
return;
}
};
var testObject3 = {
thirdFunction: function() {
return;
}
};
function testMethod() {
testObject1.someFunction();
testObject2.otherFunction();
testObject2.otherFunction();
testObject2.otherFunction();
testObject3.thirdFunction();
}
describe("calledInOrder", function() {
beforeEach(function() {
sinon.stub(testObject1, "someFunction");
sinon.stub(testObject2, "otherFunction");
sinon.stub(testObject3, "thirdFunction");
testMethod();
});
afterEach(function() {
testObject1.someFunction.restore();
testObject2.otherFunction.restore();
testObject3.thirdFunction.restore();
});
describe("given single array argument", function() {
describe("when stubs were called in expected order", function() {
it("returns true", function() {
assert.isTrue(
calledInOrder([
testObject1.someFunction,
testObject2.otherFunction
])
);
assert.isTrue(
calledInOrder([
testObject1.someFunction,
testObject2.otherFunction,
testObject2.otherFunction,
testObject3.thirdFunction
])
);
});
});
describe("when stubs were called in unexpected order", function() {
it("returns false", function() {
assert.isFalse(
calledInOrder([
testObject2.otherFunction,
testObject1.someFunction
])
);
assert.isFalse(
calledInOrder([
testObject2.otherFunction,
testObject1.someFunction,
testObject1.someFunction,
testObject3.thirdFunction
])
);
});
});
});
describe("given multiple arguments", function() {
describe("when stubs were called in expected order", function() {
it("returns true", function() {
assert.isTrue(
calledInOrder(
testObject1.someFunction,
testObject2.otherFunction
)
);
assert.isTrue(
calledInOrder(
testObject1.someFunction,
testObject2.otherFunction,
testObject3.thirdFunction
)
);
});
});
describe("when stubs were called in unexpected order", function() {
it("returns false", function() {
assert.isFalse(
calledInOrder(
testObject2.otherFunction,
testObject1.someFunction
)
);
assert.isFalse(
calledInOrder(
testObject2.otherFunction,
testObject1.someFunction,
testObject3.thirdFunction
)
);
});
});
});
});

27
node_modules/@sinonjs/commons/lib/class-name.js generated vendored
View file

@ -1,27 +0,0 @@
"use strict";
var functionName = require("./function-name");
/**
* Returns a display name for a value from a constructor
*
* @param {object} value A value to examine
* @returns {(string|null)} A string or null
*/
function className(value) {
return (
(value.constructor && value.constructor.name) ||
// The next branch is for IE11 support only:
// Because the name property is not set on the prototype
// of the Function object, we finally try to grab the
// name from its definition. This will never be reached
// in node, so we are not able to test this properly.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
(typeof value.constructor === "function" &&
/* istanbul ignore next */
functionName(value.constructor)) ||
null
);
}
module.exports = className;

37
node_modules/@sinonjs/commons/lib/class-name.test.js generated vendored
View file

@ -1,37 +0,0 @@
"use strict";
/* eslint-disable no-empty-function */
var assert = require("@sinonjs/referee").assert;
var className = require("./class-name");
describe("className", function() {
it("returns the class name of an instance", function() {
// Because eslint-config-sinon disables es6, we can't
// use a class definition here
// https://github.com/sinonjs/eslint-config-sinon/blob/master/index.js
// var instance = new (class TestClass {})();
var instance = new (function TestClass() {})();
var name = className(instance);
assert.equals(name, "TestClass");
});
it("returns 'Object' for {}", function() {
var name = className({});
assert.equals(name, "Object");
});
it("returns null for an object that has no prototype", function() {
var obj = Object.create(null);
var name = className(obj);
assert.equals(name, null);
});
it("returns null for an object whose prototype was mangled", function() {
// This is what Node v6 and v7 do for objects returned by querystring.parse()
function MangledObject() {}
MangledObject.prototype = Object.create(null);
var obj = new MangledObject();
var name = className(obj);
assert.equals(name, null);
});
});

58
node_modules/@sinonjs/commons/lib/deprecated.js generated vendored
View file

@ -1,58 +0,0 @@
/* eslint-disable no-console */
"use strict";
/**
* Returns a function that will invoke the supplied function and print a
* deprecation warning to the console each time it is called.
*
* @param {Function} func
* @param {string} msg
* @returns {Function}
*/
exports.wrap = function(func, msg) {
var wrapped = function() {
exports.printWarning(msg);
return func.apply(this, arguments);
};
if (func.prototype) {
wrapped.prototype = func.prototype;
}
return wrapped;
};
/**
* Returns a string which can be supplied to `wrap()` to notify the user that a
* particular part of the sinon API has been deprecated.
*
* @param {string} packageName
* @param {string} funcName
* @returns {string}
*/
exports.defaultMsg = function(packageName, funcName) {
return (
packageName +
"." +
funcName +
" is deprecated and will be removed from the public API in a future version of " +
packageName +
"."
);
};
/**
* Prints a warning on the console, when it exists
*
* @param {string} msg
* @returns {undefined}
*/
exports.printWarning = function(msg) {
/* istanbul ignore next */
if (typeof process === "object" && process.emitWarning) {
// Emit Warnings in Node
process.emitWarning(msg);
} else if (console.info) {
console.info(msg);
} else {
console.log(msg);
}
};

100
node_modules/@sinonjs/commons/lib/deprecated.test.js generated vendored
View file

@ -1,100 +0,0 @@
/* eslint-disable no-console */
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var sinon = require("@sinonjs/referee-sinon").sinon;
var deprecated = require("./deprecated");
var msg = "test";
describe("deprecated", function() {
describe("defaultMsg", function() {
it("should return a string", function() {
assert.equals(
deprecated.defaultMsg("sinon", "someFunc"),
"sinon.someFunc is deprecated and will be removed from the public API in a future version of sinon."
);
});
});
describe("printWarning", function() {
beforeEach(function() {
sinon.replace(process, "emitWarning", sinon.fake());
});
afterEach(sinon.restore);
describe("when `process.emitWarning` is defined", function() {
it("should call process.emitWarning with a msg", function() {
deprecated.printWarning(msg);
assert.calledOnceWith(process.emitWarning, msg);
});
});
describe("when `process.emitWarning` is undefined", function() {
beforeEach(function() {
sinon.replace(console, "info", sinon.fake());
sinon.replace(console, "log", sinon.fake());
process.emitWarning = undefined;
});
afterEach(sinon.restore);
describe("when `console.info` is defined", function() {
it("should call `console.info` with a message", function() {
deprecated.printWarning(msg);
assert.calledOnceWith(console.info, msg);
});
});
describe("when `console.info` is undefined", function() {
it("should call `console.log` with a message", function() {
console.info = undefined;
deprecated.printWarning(msg);
assert.calledOnceWith(console.log, msg);
});
});
});
});
describe("wrap", function() {
var method = sinon.fake();
var wrapped;
beforeEach(function() {
wrapped = deprecated.wrap(method, msg);
});
it("should return a wrapper function", function() {
assert.match(wrapped, sinon.match.func);
});
it("should assign the prototype of the passed method", function() {
assert.equals(method.prototype, wrapped.prototype);
});
context("when the passed method has falsy prototype", function() {
it("should not be assigned to the wrapped method", function() {
method.prototype = null;
wrapped = deprecated.wrap(method, msg);
assert.match(wrapped.prototype, sinon.match.object);
});
});
context("when invoking the wrapped function", function() {
before(function() {
sinon.replace(deprecated, "printWarning", sinon.fake());
wrapped({});
});
it("should call `printWarning` before invoking", function() {
assert.calledOnceWith(deprecated.printWarning, msg);
});
it("should invoke the passed method with the given arguments", function() {
assert.calledOnceWith(method, {});
});
});
});
});

27
node_modules/@sinonjs/commons/lib/every.js generated vendored
View file

@ -1,27 +0,0 @@
"use strict";
/**
* Returns true when fn returns true for all members of obj.
* This is an every implementation that works for all iterables
*
* @param {object} obj
* @param {Function} fn
* @returns {boolean}
*/
module.exports = function every(obj, fn) {
var pass = true;
try {
/* eslint-disable-next-line local-rules/no-prototype-methods */
obj.forEach(function() {
if (!fn.apply(this, arguments)) {
// Throwing an error is the only way to break `forEach`
throw new Error();
}
});
} catch (e) {
pass = false;
}
return pass;
};

41
node_modules/@sinonjs/commons/lib/every.test.js generated vendored
View file

@ -1,41 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var sinon = require("@sinonjs/referee-sinon").sinon;
var every = require("./every");
describe("util/core/every", function() {
it("returns true when the callback function returns true for every element in an iterable", function() {
var obj = [true, true, true, true];
var allTrue = every(obj, function(val) {
return val;
});
assert(allTrue);
});
it("returns false when the callback function returns false for any element in an iterable", function() {
var obj = [true, true, true, false];
var result = every(obj, function(val) {
return val;
});
assert.isFalse(result);
});
it("calls the given callback once for each item in an iterable until it returns false", function() {
var iterableOne = [true, true, true, true];
var iterableTwo = [true, true, false, true];
var callback = sinon.spy(function(val) {
return val;
});
every(iterableOne, callback);
assert.equals(callback.callCount, 4);
callback.resetHistory();
every(iterableTwo, callback);
assert.equals(callback.callCount, 3);
});
});

29
node_modules/@sinonjs/commons/lib/function-name.js generated vendored
View file

@ -1,29 +0,0 @@
"use strict";
/**
* Returns a display name for a function
*
* @param {Function} func
* @returns {string}
*/
module.exports = function functionName(func) {
if (!func) {
return "";
}
try {
return (
func.displayName ||
func.name ||
// Use function decomposition as a last resort to get function
// name. Does not rely on function decomposition to work - if it
// doesn't debugging will be slightly less informative
// (i.e. toString will say 'spy' rather than 'myFunc').
(String(func).match(/function ([^\s(]+)/) || [])[1]
);
} catch (e) {
// Stringify may fail and we might get an exception, as a last-last
// resort fall back to empty string.
return "";
}
};

76
node_modules/@sinonjs/commons/lib/function-name.test.js generated vendored
View file

@ -1,76 +0,0 @@
"use strict";
var jsc = require("jsverify");
var refute = require("@sinonjs/referee-sinon").refute;
var functionName = require("./function-name");
describe("function-name", function() {
it("should return empty string if func is falsy", function() {
jsc.assertForall("falsy", function(fn) {
return functionName(fn) === "";
});
});
it("should use displayName by default", function() {
jsc.assertForall("nestring", function(displayName) {
var fn = { displayName: displayName };
return functionName(fn) === fn.displayName;
});
});
it("should use name if displayName is not available", function() {
jsc.assertForall("nestring", function(name) {
var fn = { name: name };
return functionName(fn) === fn.name;
});
});
it("should fallback to string parsing", function() {
jsc.assertForall("nat", function(naturalNumber) {
var name = "fn" + naturalNumber;
var fn = {
toString: function() {
return "\nfunction " + name;
}
};
return functionName(fn) === name;
});
});
it("should not fail when a name cannot be found", function() {
refute.exception(function() {
var fn = {
toString: function() {
return "\nfunction (";
}
};
functionName(fn);
});
});
it("should not fail when toString is undefined", function() {
refute.exception(function() {
functionName(Object.create(null));
});
});
it("should not fail when toString throws", function() {
refute.exception(function() {
var fn;
try {
// eslint-disable-next-line no-eval
fn = eval("(function*() {})")().constructor;
} catch (e) {
// env doesn't support generators
return;
}
functionName(fn);
});
});
});

22
node_modules/@sinonjs/commons/lib/global.js generated vendored
View file

@ -1,22 +0,0 @@
"use strict";
/**
* A reference to the global object
*
* @type {object} globalObject
*/
var globalObject;
/* istanbul ignore else */
if (typeof global !== "undefined") {
// Node
globalObject = global;
} else if (typeof window !== "undefined") {
// Browser
globalObject = window;
} else {
// WebWorker
globalObject = self;
}
module.exports = globalObject;

16
node_modules/@sinonjs/commons/lib/global.test.js generated vendored
View file

@ -1,16 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var globalObject = require("./global");
describe("global", function() {
before(function() {
if (typeof global === "undefined") {
this.skip();
}
});
it("is same as global", function() {
assert.same(globalObject, global);
});
});

14
node_modules/@sinonjs/commons/lib/index.js generated vendored
View file

@ -1,14 +0,0 @@
"use strict";
module.exports = {
global: require("./global"),
calledInOrder: require("./called-in-order"),
className: require("./class-name"),
deprecated: require("./deprecated"),
every: require("./every"),
functionName: require("./function-name"),
orderByFirstCall: require("./order-by-first-call"),
prototypes: require("./prototypes"),
typeOf: require("./type-of"),
valueToString: require("./value-to-string")
};

29
node_modules/@sinonjs/commons/lib/index.test.js generated vendored
View file

@ -1,29 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var index = require("./index");
var expectedMethods = [
"calledInOrder",
"className",
"every",
"functionName",
"orderByFirstCall",
"typeOf",
"valueToString"
];
var expectedObjectProperties = ["deprecated", "prototypes"];
describe("package", function() {
expectedMethods.forEach(function(name) {
it("should export a method named " + name, function() {
assert.isFunction(index[name]);
});
});
expectedObjectProperties.forEach(function(name) {
it("should export an object property named " + name, function() {
assert.isObject(index[name]);
});
});
});

36
node_modules/@sinonjs/commons/lib/order-by-first-call.js generated vendored
View file

@ -1,36 +0,0 @@
"use strict";
var sort = require("./prototypes/array").sort;
var slice = require("./prototypes/array").slice;
/**
* @private
*/
function comparator(a, b) {
// uuid, won't ever be equal
var aCall = a.getCall(0);
var bCall = b.getCall(0);
var aId = (aCall && aCall.callId) || -1;
var bId = (bCall && bCall.callId) || -1;
return aId < bId ? -1 : 1;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} getCall - A method that can return the first call
*/
/**
* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
*
* @param {SinonProxy[] | SinonProxy} spies
* @returns {SinonProxy[]}
*/
function orderByFirstCall(spies) {
return sort(slice(spies), comparator);
}
module.exports = orderByFirstCall;

52
node_modules/@sinonjs/commons/lib/order-by-first-call.test.js generated vendored
View file

@ -1,52 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var knuthShuffle = require("knuth-shuffle").knuthShuffle;
var sinon = require("@sinonjs/referee-sinon").sinon;
var orderByFirstCall = require("./order-by-first-call");
describe("orderByFirstCall", function() {
it("should order an Array of spies by the callId of the first call, ascending", function() {
// create an array of spies
var spies = [
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy()
];
// call all the spies
spies.forEach(function(spy) {
spy();
});
// add a few uncalled spies
spies.push(sinon.spy());
spies.push(sinon.spy());
// randomise the order of the spies
knuthShuffle(spies);
var sortedSpies = orderByFirstCall(spies);
assert.equals(sortedSpies.length, spies.length);
var orderedByFirstCall = sortedSpies.every(function(spy, index) {
if (index + 1 === sortedSpies.length) {
return true;
}
var nextSpy = sortedSpies[index + 1];
// uncalled spies should be ordered first
if (!spy.called) {
return true;
}
return spy.calledImmediatelyBefore(nextSpy);
});
assert.isTrue(orderedByFirstCall);
});
});

44
node_modules/@sinonjs/commons/lib/prototypes/README.md generated vendored
View file

@ -1,44 +0,0 @@
# Prototypes
The functions in this folder are to be use for keeping cached references to the built-in prototypes, so that people can't inadvertently break the library by making mistakes in userland.
See https://github.com/sinonjs/sinon/pull/1523
## Without cached references
```js
// in userland, the library user needs to replace the filter method on
// Array.prototype
var array = [1, 2, 3];
sinon.replace(array, "filter", sinon.fake.returns(2));
// in a sinon module, the library author needs to use the filter method
var someArray = ["a", "b", 42, "c"];
var answer = filter(someArray, function(v) {
return v === 42;
});
console.log(answer);
// => 2
```
## With cached references
```js
// in userland, the library user needs to replace the filter method on
// Array.prototype
var array = [1, 2, 3];
sinon.replace(array, "filter", sinon.fake.returns(2));
// in a sinon module, the library author needs to use the filter method
// get a reference to the original Array.prototype.filter
var filter = require("@sinonjs/commons").prototypes.array.filter;
var someArray = ["a", "b", 42, "c"];
var answer = filter(someArray, function(v) {
return v === 42;
});
console.log(answer);
// => 42
```

5
node_modules/@sinonjs/commons/lib/prototypes/array.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype");
module.exports = copyPrototype(Array.prototype);

21
node_modules/@sinonjs/commons/lib/prototypes/copy-prototype.js generated vendored
View file

@ -1,21 +0,0 @@
"use strict";
var call = Function.call;
module.exports = function copyPrototypeMethods(prototype) {
/* eslint-disable local-rules/no-prototype-methods */
return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
// ignore size because it throws from Map
if (
name !== "size" &&
name !== "caller" &&
name !== "callee" &&
name !== "arguments" &&
typeof prototype[name] === "function"
) {
result[name] = call.bind(prototype[name]);
}
return result;
}, Object.create(null));
};

5
node_modules/@sinonjs/commons/lib/prototypes/function.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype");
module.exports = copyPrototype(Function.prototype);

10
node_modules/@sinonjs/commons/lib/prototypes/index.js generated vendored
View file

@ -1,10 +0,0 @@
"use strict";
module.exports = {
array: require("./array"),
function: require("./function"),
map: require("./map"),
object: require("./object"),
set: require("./set"),
string: require("./string")
};

51
node_modules/@sinonjs/commons/lib/prototypes/index.test.js generated vendored
View file

@ -1,51 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var arrayProto = require("./index").array;
var functionProto = require("./index").function;
var mapProto = require("./index").map;
var objectProto = require("./index").object;
var setProto = require("./index").set;
var stringProto = require("./index").string;
describe("prototypes", function() {
describe(".array", function() {
verifyProperties(arrayProto, Array);
});
describe(".function", function() {
verifyProperties(functionProto, Function);
});
describe(".map", function() {
verifyProperties(mapProto, Map);
});
describe(".object", function() {
verifyProperties(objectProto, Object);
});
describe(".set", function() {
verifyProperties(setProto, Set);
});
describe(".string", function() {
verifyProperties(stringProto, String);
});
});
function verifyProperties(p, origin) {
it("should have all the methods of the origin prototype", function() {
var methodNames = Object.getOwnPropertyNames(origin.prototype).filter(
function(name) {
return (
name !== "size" &&
name !== "caller" &&
name !== "callee" &&
name !== "arguments" &&
typeof origin.prototype[name] === "function"
);
}
);
methodNames.forEach(function(name) {
assert.isTrue(Object.prototype.hasOwnProperty.call(p, name), name);
});
});
}

5
node_modules/@sinonjs/commons/lib/prototypes/map.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype");
module.exports = copyPrototype(Map.prototype);

5
node_modules/@sinonjs/commons/lib/prototypes/object.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype");
module.exports = copyPrototype(Object.prototype);

Some files were not shown because too many files have changed in this diff Show more