xo 0.46.0 → 0.46.4

package/index.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import {ESLint} from 'eslint';
 import {globby, isGitIgnoredSync} from 'globby';
-import {isEqual, groupBy} from 'lodash-es';
+import {isEqual} from 'lodash-es';
 import micromatch from 'micromatch';
 import arrify from 'arrify';
 import slash from 'slash';
@@ -9,6 +9,7 @@ import {
 	parseOptions,
 	getIgnores,
 	mergeWithFileConfig,
+	getOptionGroups,
 } from './lib/options-manager.js';
 import {mergeReports, processReport, getIgnoredReport} from './lib/report.js';
 
@@ -34,8 +35,8 @@ const getConfig = async options => {
 };
 
 const lintText = async (string, options) => {
-	options = await parseOptions(options);
-	const {filePath, warnIgnored, eslintOptions, isQuiet} = options;
+	const [[options_]] = Object.values(await getOptionGroups([options && options.filePath], options));
+	const {filePath, warnIgnored, eslintOptions, isQuiet} = options_;
 	const {cwd, baseConfig: {ignorePatterns}} = eslintOptions;
 
 	if (typeof filePath !== 'string' && !isEqual(getIgnores({}), ignorePatterns)) {
@@ -65,13 +66,7 @@ const lintText = async (string, options) => {
 const lintFiles = async (patterns, options) => {
 	const files = await globFiles(patterns, options);
 
-	const allOptions = await Promise.all(
-		files.map(filePath => parseOptions({...options, filePath})),
-	);
-
-	// Files with same `xoConfigPath` can lint together
-	// https://github.com/xojs/xo/issues/599
-	const groups = groupBy(allOptions, 'eslintConfigId');
+	const groups = await getOptionGroups(files, options);
 
 	const reports = await Promise.all(
 		Object.values(groups)

package/lib/options-manager.js

@@ -11,11 +11,10 @@ import semver from 'semver';
 import {cosmiconfig, defaultLoaders} from 'cosmiconfig';
 import micromatch from 'micromatch';
 import JSON5 from 'json5';
-import toAbsoluteGlob from 'to-absolute-glob';
 import stringify from 'json-stable-stringify-without-jsonify';
-import murmur from 'imurmurhash';
 import {Legacy} from '@eslint/eslintrc';
 import createEsmUtils from 'esm-utils';
+import MurmurHash3 from 'imurmurhash';
 import {
 	DEFAULT_IGNORES,
 	DEFAULT_EXTENSION,
@@ -42,7 +41,6 @@ resolveFrom.silent = (moduleId, fromDirectory) => {
 
 const resolveLocalConfig = name => resolveModule(normalizePackageName(name, 'eslint-config'), import.meta.url);
 
-const nodeVersion = process && process.version;
 const cacheLocation = cwd => findCacheDir({name: CACHE_DIR_NAME, cwd}) || path.join(os.homedir() || os.tmpdir(), '.xo-cache/');
 
 const DEFAULT_CONFIG = {
@@ -109,93 +107,92 @@ const mergeWithFileConfig = async options => {
 	}
 
 	const searchPath = options.filePath || options.cwd;
-
 	const {config: xoOptions, filepath: xoConfigPath} = (await configExplorer.search(searchPath)) || {};
 	const {config: enginesOptions} = (await pkgConfigExplorer.search(searchPath)) || {};
 
-	options = mergeOptions(options, xoOptions, enginesOptions);
+	options = normalizeOptions({
+		...xoOptions,
+		...(enginesOptions && enginesOptions.node && semver.validRange(enginesOptions.node) ? {nodeVersion: enginesOptions.node} : {}),
+		...options,
+	});
+	options.extensions = [...DEFAULT_EXTENSION, ...(options.extensions || [])];
+	options.ignores = getIgnores(options);
 	options.cwd = xoConfigPath && path.dirname(xoConfigPath) !== options.cwd ? path.resolve(options.cwd, path.dirname(xoConfigPath)) : options.cwd;
 
-	// Very simple way to ensure eslint is ran minimal times across
-	// all linted files, once for each unique configuration - xo config path + override hash + tsconfig path
-	let eslintConfigId = xoConfigPath;
+	// Ensure eslint is ran minimal times across all linted files, once for each unique configuration
+	// incremental hash of: xo config path + override hash + tsconfig path
+	// ensures unique configurations
+	options.eslintConfigId = new MurmurHash3(xoConfigPath);
 	if (options.filePath) {
 		const overrides = applyOverrides(options.filePath, options);
 		options = overrides.options;
 
 		if (overrides.hash) {
-			eslintConfigId += overrides.hash;
+			options.eslintConfigId = options.eslintConfigId.hash(`${overrides.hash}`);
 		}
 	}
 
 	const prettierOptions = options.prettier ? await prettier.resolveConfig(searchPath, {editorconfig: true}) || {} : {};
 
 	if (options.filePath && isTypescript(options.filePath)) {
-		// We can skip looking up the tsconfig if we have it defined
-		// in our parser options already. Otherwise we can look it up and create it as normal
-		const {project: tsConfigProjectPath, tsconfigRootDir} = options.parserOptions || {};
-
-		let tsConfig;
-		let tsConfigPath;
-		if (tsConfigProjectPath) {
-			tsConfigPath = path.resolve(options.cwd, tsConfigProjectPath);
-			tsConfig = await json.load(tsConfigPath);
-		} else {
-			const tsConfigExplorer = cosmiconfig([], {
-				searchPlaces: ['tsconfig.json'],
-				loaders: {'.json': (_, content) => JSON5.parse(content)},
-				stopDir: tsconfigRootDir,
-			});
-			const searchResults = (await tsConfigExplorer.search(options.filePath)) || {};
-			tsConfigPath = searchResults.filepath;
-			tsConfig = searchResults.config;
-		}
-
-		if (tsConfigPath) {
-			options.tsConfigPath = tsConfigPath;
-			eslintConfigId += tsConfigPath;
-		} else {
-			const {path: tsConfigCachePath, hash: tsConfigHash} = await getTsConfigCachePath([eslintConfigId], tsConfigPath, options.cwd);
-			eslintConfigId += tsConfigHash;
-			options.tsConfigPath = tsConfigCachePath;
-			const config = makeTSConfig(tsConfig, tsConfigPath, [options.filePath]);
-			await fs.mkdir(path.dirname(options.tsConfigPath), {recursive: true});
-			await fs.writeFile(options.tsConfigPath, JSON.stringify(config));
-		}
-
-		options.ts = true;
+		options = await handleTSConfig(options);
 	}
 
-	return {options, prettierOptions, eslintConfigId};
-};
+	// Ensure this field ends up as a string
+	options.eslintConfigId = options.eslintConfigId.result();
 
-/**
-Generate a unique and consistent path for the temporary `tsconfig.json`.
-Hashing based on https://github.com/eslint/eslint/blob/cf38d0d939b62f3670cdd59f0143fd896fccd771/lib/cli-engine/lint-result-cache.js#L30
-*/
-const getTsConfigCachePath = async (files, tsConfigPath, cwd) => {
-	const {version} = await json.load('../package.json');
-	const tsConfigHash = murmur(`${version}_${nodeVersion}_${stringify({files: files.sort(), tsConfigPath})}`).result().toString(36);
-	return {
-		path: path.join(
-			cacheLocation(cwd),
-			`tsconfig.${tsConfigHash}.json`,
-		),
-		hash: tsConfigHash,
-	};
+	return {options, prettierOptions};
 };
 
-const makeTSConfig = (tsConfig, tsConfigPath, files) => {
-	const config = {files: files.filter(file => isTypescript(file))};
-
-	if (tsConfig) {
-		config.extends = tsConfigPath;
-		config.include = arrify(tsConfig.include).map(pattern => toAbsoluteGlob(pattern, {cwd: path.dirname(tsConfigPath)}));
+/**
+ * Find the tsconfig or create a default config
+ * If a config is found but it doesn't cover the file as needed by parserOptions.project
+ * we create a temp config for that file that extends the found config. If no config is found
+ * for a file we apply a default config.
+ */
+const handleTSConfig = async options => {
+	// We can skip looking up the tsconfig if we have it defined
+	// in our parser options already. Otherwise we can look it up and create it as normal
+	options.ts = true;
+	options.tsConfig = {};
+	options.tsConfigPath = '';
+
+	const {project: tsConfigProjectPath, tsconfigRootDir} = options.parserOptions || {};
+
+	if (tsConfigProjectPath) {
+		options.tsConfigPath = path.resolve(options.cwd, tsConfigProjectPath);
+		options.tsConfig = await json.load(options.tsConfigPath);
 	} else {
-		Object.assign(config, TSCONFIG_DEFAULTS);
+		const tsConfigExplorer = cosmiconfig([], {
+			searchPlaces: ['tsconfig.json'],
+			loaders: {'.json': (_, content) => JSON5.parse(content)},
+			stopDir: tsconfigRootDir,
+		});
+		const searchResults = (await tsConfigExplorer.search(options.filePath)) || {};
+		options.tsConfigPath = searchResults.filepath;
+		options.tsConfig = searchResults.config;
 	}
 
-	return config;
+	// If there is no files of include property - ts uses **/* as default so all TS files are matched
+	// TODO: Improve this matching - however, even if we get it wrong, it should still lint correctly as it will just extend the nearest tsconfig
+	const hasMatch = options.tsConfig && !options.tsConfig.include && !options.tsConfig.files ? true : micromatch.contains(options.filePath, [
+		...(options.tsConfig && Array.isArray(options.tsConfig.include) ? options.tsConfig.include : []),
+		...(options.tsConfig && Array.isArray(options.tsConfig.files) ? options.tsConfig.files : []),
+	]);
+
+	if (!hasMatch) {
+		// Only use our default tsconfig if no other tsconfig is found - otherwise extend the found config for linting
+		options.tsConfig = options.tsConfigPath ? {extends: options.tsConfigPath} : TSCONFIG_DEFAULTS;
+		options.tsConfigHash = new MurmurHash3(stringify(options.tsConfig)).result();
+		options.tsConfigPath = path.join(
+			cacheLocation(options.cwd),
+			`tsconfig.${options.tsConfigHash}.json`,
+		);
+	}
+
+	options.eslintConfigId = options.eslintConfigId.hash(options.tsConfigPath);
+
+	return options;
 };
 
 const normalizeOptions = options => {
@@ -235,22 +232,6 @@ const normalizeOptions = options => {
 
 const normalizeSpaces = options => typeof options.space === 'number' ? options.space : 2;
 
-/**
-Merge option passed via CLI/API via options found in config files.
-*/
-const mergeOptions = (options, xoOptions = {}, enginesOptions = {}) => {
-	const mergedOptions = normalizeOptions({
-		...xoOptions,
-		...(enginesOptions && enginesOptions.node && semver.validRange(enginesOptions.node) ? {nodeVersion: enginesOptions.node} : {}),
-		...options,
-	});
-
-	mergedOptions.extensions = [...DEFAULT_EXTENSION, ...(mergedOptions.extensions || [])];
-	mergedOptions.ignores = getIgnores(mergedOptions);
-
-	return mergedOptions;
-};
-
 /**
 Transform an XO options into ESLint compatible options:
 - Apply rules based on XO options (e.g `spaces` => `indent` rules or `semicolon` => `semi` rule).
@@ -487,9 +468,6 @@ const buildTSConfig = options => config => {
 					? options.parserOptions.projectFolderIgnoreList
 					: [new RegExp(`/node_modules/(?!.*\\.cache/${CACHE_DIR_NAME})`)],
 		};
-
-		delete config.tsConfigPath;
-		delete config.ts;
 	}
 
 	return config;
@@ -576,7 +554,8 @@ const gatherImportResolvers = options => {
 
 const parseOptions = async options => {
 	options = normalizeOptions(options);
-	const {options: foundOptions, prettierOptions, eslintConfigId} = await mergeWithFileConfig(options);
+	const {options: foundOptions, prettierOptions} = await mergeWithFileConfig(options);
+	const {eslintConfigId, tsConfigHash, tsConfig, tsConfigPath} = foundOptions;
 	const {filePath, warnIgnored, ...eslintOptions} = buildConfig(foundOptions, prettierOptions);
 	return {
 		filePath,
@@ -584,9 +563,50 @@ const parseOptions = async options => {
 		isQuiet: options.quiet,
 		eslintOptions,
 		eslintConfigId,
+		tsConfigHash,
+		tsConfigPath,
+		tsConfig,
 	};
 };
 
+const getOptionGroups = async (files, options) => {
+	const allOptions = await Promise.all(
+		arrify(files).map(filePath => parseOptions({...options, filePath})),
+	);
+
+	const tsGroups = {};
+	const optionGroups = {};
+	for (const options of allOptions) {
+		if (Array.isArray(optionGroups[options.eslintConfigId])) {
+			optionGroups[options.eslintConfigId].push(options);
+		} else {
+			optionGroups[options.eslintConfigId] = [options];
+		}
+
+		if (options.tsConfigHash) {
+			if (Array.isArray(tsGroups[options.tsConfigHash])) {
+				tsGroups[options.tsConfigHash].push(options);
+			} else {
+				tsGroups[options.tsConfigHash] = [options];
+			}
+		}
+	}
+
+	await Promise.all(Object.values(tsGroups).map(async tsGroup => {
+		await fs.mkdir(path.dirname(tsGroup[0].tsConfigPath), {recursive: true});
+		await fs.writeFile(tsGroup[0].tsConfigPath, JSON.stringify({
+			...tsGroup[0].tsConfig,
+			files: tsGroup.map(o => o.filePath),
+			include: [],
+			exclude: [],
+		}));
+	}));
+
+	// Files with same `xoConfigPath` can lint together
+	// https://github.com/xojs/xo/issues/599
+	return optionGroups;
+};
+
 export {
 	parseOptions,
 	getIgnores,
@@ -598,4 +618,6 @@ export {
 	mergeWithPrettierConfig,
 	normalizeOptions,
 	buildConfig,
+	getOptionGroups,
+	handleTSConfig,
 };

package/node_modules/@nodelib/fs.scandir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

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

package/node_modules/@nodelib/fs.scandir/out/adapters/fs.d.ts

@@ -0,0 +1,20 @@
+import type * as fsStat from '@nodelib/fs.stat';
+import type { Dirent, ErrnoException } from '../types';
+export interface ReaddirAsynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
+    (filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
+}
+export interface ReaddirSynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }): Dirent[];
+    (filepath: string): string[];
+}
+export declare type FileSystemAdapter = fsStat.FileSystemAdapter & {
+    readdir: ReaddirAsynchronousMethod;
+    readdirSync: ReaddirSynchronousMethod;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;

package/node_modules/@nodelib/fs.scandir/out/adapters/fs.js

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

package/node_modules/@nodelib/fs.scandir/out/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;

package/node_modules/@nodelib/fs.scandir/out/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+}
+const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = Number.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;

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

@@ -0,0 +1,12 @@
+import type { FileSystemAdapter, ReaddirAsynchronousMethod, ReaddirSynchronousMethod } from './adapters/fs';
+import * as async from './providers/async';
+import Settings, { Options } from './settings';
+import type { 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, ReaddirAsynchronousMethod, ReaddirSynchronousMethod, Options };

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = exports.scandirSync = exports.scandir = void 0;
+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') {
+        async.read(path, getSettings(), optionsOrSettingsOrCallback);
+        return;
+    }
+    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);
+}

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

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