@dineroregnskab/eslint-plugin-custom-rules 2.0.6 → 2.0.7

package/node_modules/@nodelib/fs.walk/README.md

@@ -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.

package/node_modules/@nodelib/fs.walk/out/index.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-import type { Readable } from 'stream';
-import type { Dirent, FileSystemAdapter } from '@nodelib/fs.scandir';
-import { AsyncCallback } from './providers/async';
-import Settings, { DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction, Options } from './settings';
-import type { 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 };

package/node_modules/@nodelib/fs.walk/out/index.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0;
-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') {
-        new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
-        return;
-    }
-    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);
-}

package/node_modules/@nodelib/fs.walk/out/providers/async.d.ts

@@ -1,12 +0,0 @@
-import AsyncReader from '../readers/async';
-import type Settings from '../settings';
-import type { Entry, Errno } from '../types';
-export declare type AsyncCallback = (error: 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;
-}

package/node_modules/@nodelib/fs.walk/out/providers/async.js

@@ -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 = [];
-    }
-    read(callback) {
-        this._reader.onError((error) => {
-            callFailureCallback(callback, error);
-        });
-        this._reader.onEntry((entry) => {
-            this._storage.push(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);
-}

package/node_modules/@nodelib/fs.walk/out/providers/index.d.ts

@@ -1,4 +0,0 @@
-import AsyncProvider from './async';
-import StreamProvider from './stream';
-import SyncProvider from './sync';
-export { AsyncProvider, StreamProvider, SyncProvider };

package/node_modules/@nodelib/fs.walk/out/providers/index.js

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

package/node_modules/@nodelib/fs.walk/out/providers/stream.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import AsyncReader from '../readers/async';
-import type 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;
-}

package/node_modules/@nodelib/fs.walk/out/providers/stream.js

@@ -1,34 +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: () => {
-                if (!this._reader.isDestroyed) {
-                    this._reader.destroy();
-                }
-            }
-        });
-    }
-    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;

package/node_modules/@nodelib/fs.walk/out/providers/sync.d.ts

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

package/node_modules/@nodelib/fs.walk/out/providers/sync.js

@@ -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;

package/node_modules/@nodelib/fs.walk/out/readers/async.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import * as fsScandir from '@nodelib/fs.scandir';
-import type Settings from '../settings';
-import type { 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;
-    get isDestroyed(): boolean;
-    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 {};

package/node_modules/@nodelib/fs.walk/out/readers/async.js

@@ -1,97 +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;
-    }
-    get isDestroyed() {
-        return this._isDestroyed;
-    }
-    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) {
-                done(error, undefined);
-                return;
-            }
-            for (const entry of entries) {
-                this._handleEntry(entry, item.base);
-            }
-            done(null, undefined);
-        });
-    }
-    _handleError(error) {
-        if (this._isDestroyed || !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, base === undefined ? undefined : entry.path);
-        }
-    }
-    _emitEntry(entry) {
-        this._emitter.emit('entry', entry);
-    }
-}
-exports.default = AsyncReader;

package/node_modules/@nodelib/fs.walk/out/readers/common.d.ts

@@ -1,7 +0,0 @@
-import type { FilterFunction } from '../settings';
-import type Settings from '../settings';
-import type { 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;

package/node_modules/@nodelib/fs.walk/out/readers/common.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0;
-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;
-    }
-    /**
-     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
-     */
-    if (a.endsWith(separator)) {
-        return a + b;
-    }
-    return a + separator + b;
-}
-exports.joinPathSegments = joinPathSegments;

package/node_modules/@nodelib/fs.walk/out/readers/reader.d.ts

@@ -1,6 +0,0 @@
-import type Settings from '../settings';
-export default class Reader {
-    protected readonly _root: string;
-    protected readonly _settings: Settings;
-    constructor(_root: string, _settings: Settings);
-}

package/node_modules/@nodelib/fs.walk/out/readers/reader.js

@@ -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;

package/node_modules/@nodelib/fs.walk/out/readers/sync.d.ts

@@ -1,15 +0,0 @@
-import * as fsScandir from '@nodelib/fs.scandir';
-import type { 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;
-}

package/node_modules/@nodelib/fs.walk/out/readers/sync.js

@@ -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 = [];
-        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, base === undefined ? undefined : entry.path);
-        }
-    }
-    _pushToStorage(entry) {
-        this._storage.push(entry);
-    }
-}
-exports.default = SyncReader;