npm - @alexlit/lint-kit - Versions diffs - 173.2.2 → 173.3.0 - Mend

@alexlit/lint-kit 173.2.2 → 173.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (417) hide show

package/packages/config-stylelint/node_modules/globby/readme.md DELETED Viewed

@@ -1,388 +0,0 @@
-# globby
-> User-friendly glob matching
-Based on [`fast-glob`](https://github.com/mrmlnc/fast-glob) but adds a bunch of useful features.
-## Features
-- Promise API
-- Multiple patterns
-- Negated patterns: `['foo*', '!foobar']`
-- Negation-only patterns: `['!foobar']` → matches all files except `foobar`
-- Expands directories: `foo` → `foo/**/*`
-- Supports `.gitignore` and similar ignore config files
-- Supports `URL` as `cwd`
-## Install
-```sh
-npm install globby
-```
-## Usage
-```
-├── unicorn
-├── cake
-└── rainbow
-```
-```js
-import {globby} from 'globby';
-const paths = await globby(['*', '!cake']);
-console.log(paths);
-//=> ['unicorn', 'rainbow']
-```
-## API
-Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
-**Windows:** Patterns with backslashes will silently fail. Use `path.posix.join()` or [`convertPathToPattern()`](#convertpathtopatternpath).
-### globby(patterns, options?)
-Returns a `Promise<string[]>` of matching paths.
-#### patterns
-Type: `string | string[]`
-See supported `minimatch` [patterns](https://github.com/isaacs/minimatch#usage).
-#### options
-Type: `object`
-See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones below.
-##### expandDirectories
-Type: `boolean | string[] | object`\
-Default: `true`
-If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `object` with `files` and `extensions` like below:
-```js
-import {globby} from 'globby';
-const paths = await globby('images', {
-	expandDirectories: {
-		files: ['cat', 'unicorn', '*.jpg'],
-		extensions: ['png']
-	}
-});
-console.log(paths);
-//=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
-```
-Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
-##### gitignore
-Type: `boolean`\
-Default: `false`
-Respect ignore patterns in `.gitignore` files that apply to the globbed files.
-When enabled, globby searches for `.gitignore` files from the current working directory downward, and if a Git repository is detected (by finding a `.git` directory), it also respects `.gitignore` files in parent directories up to the repository root. This matches Git's actual behavior where patterns from parent `.gitignore` files apply to subdirectories.
-Gitignore patterns take priority over user patterns, matching Git's behavior. To include gitignored files, set this to `false`.
-**Performance:** Globby reads `.gitignore` files before globbing. When there are no negation patterns (like `!important.log`) and no parent `.gitignore` files are found, it passes ignore patterns to fast-glob to skip traversing ignored directories entirely, which significantly improves performance for large `node_modules` or build directories. When negation patterns or parent `.gitignore` files are present, all filtering is done after traversal to ensure correct Git-compatible behavior. For optimal performance, prefer specific `.gitignore` patterns without negations, or use `ignoreFiles: '.gitignore'` to target only the root ignore file.
-##### ignoreFiles
-Type: `string | string[]`\
-Default: `undefined`
-Glob patterns to look for ignore files, which are then used to ignore globbed files.
-This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
-**Performance tip:** Using a specific path like `'.gitignore'` is much faster than recursive patterns.
-##### expandNegationOnlyPatterns
-Type: `boolean`\
-Default: `true`
-When only negation patterns are provided (e.g., `['!*.json']`), automatically prepend a catch-all pattern (`**/*`) to match all files before applying negations.
-Set to `false` to return an empty array when only negation patterns are provided. This can be useful when patterns are user-controlled, to avoid unexpectedly matching all files.
-```js
-import {globby} from 'globby';
-// Default behavior: matches all files except .json
-await globby(['!*.json']);
-//=> ['file.txt', 'image.png', ...]
-// Disable expansion: returns empty array
-await globby(['!*.json'], {expandNegationOnlyPatterns: false});
-//=> []
-```
-##### fs
-Type: [`FileSystemAdapter`](https://github.com/mrmlnc/fast-glob#fs)\
-Default: `undefined`
-Custom file system implementation (useful for testing or virtual file systems).
-**Note:** When using `gitignore` or `ignoreFiles`, the custom fs must also provide `readFile`/`readFileSync` methods.
-### globbySync(patterns, options?)
-Returns `string[]` of matching paths.
-### globbyStream(patterns, options?)
-Returns a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_readable_streams) of matching paths.
-For example, loop over glob matches in a [`for await...of` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) like this:
-```js
-import {globbyStream} from 'globby';
-for await (const path of globbyStream('*.tmp')) {
-	console.log(path);
-}
-```
-### convertPathToPattern(path)
-Converts a path to a pattern by escaping special glob characters like `()`, `[]`, `{}`. On Windows, also converts backslashes to forward slashes.
-Use this when your literal paths contain characters with special meaning in globs.
-```js
-import {globby, convertPathToPattern} from 'globby';
-// ❌ Fails - parentheses are glob syntax
-await globby('C:/Program Files (x86)/*.txt');
-//=> []
-// ✅ Works
-const base = convertPathToPattern('C:/Program Files (x86)');
-await globby(`${base}/*.txt`);
-//=> ['C:/Program Files (x86)/file.txt']
-```
-[Learn more.](https://github.com/mrmlnc/fast-glob#convertpathtopatternpath)
-### generateGlobTasks(patterns, options?)
-Returns an `Promise<object[]>` in the format `{patterns: string[], options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
-Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
-### generateGlobTasksSync(patterns, options?)
-Returns an `object[]` in the format `{patterns: string[], options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
-Takes the same arguments as `generateGlobTasks`.
-### isDynamicPattern(patterns, options?)
-Returns a `boolean` of whether there are any special glob characters in the `patterns`.
-Note that the options affect the results.
-This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).
-### isGitIgnored(options?)
-Returns a `Promise<(path: URL | string) => boolean>` indicating whether a given path is ignored via a `.gitignore` file.
-#### options
-Type: `object`
-##### cwd
-Type: `URL | string`\
-Default: `process.cwd()`
-The current working directory in which to search.
-##### suppressErrors
-Type: `boolean`\
-Default: `false`
-Suppress errors when encountering directories or files without read permissions.
-##### deep
-Type: `number`\
-Default: `Infinity`
-Maximum depth to search for `.gitignore` files.
-- `0` - Only search in the start directory
-- `1` - Search in the start directory and one level of subdirectories
-- `2` - Search in the start directory and two levels of subdirectories
-##### ignore
-Type: `string | string[]`\
-Default: `[]`
-Glob patterns to exclude from `.gitignore` file search.
-##### followSymbolicLinks
-Type: `boolean`\
-Default: `true`
-Indicates whether to traverse descendants of symbolic link directories.
-##### concurrency
-Type: `number`\
-Default: `os.cpus().length`
-Specifies the maximum number of concurrent requests from a reader to read directories.
-##### throwErrorOnBrokenSymbolicLink
-Type: `boolean`\
-Default: `false`
-Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
-##### fs
-Type: [`FileSystemAdapter`](https://github.com/mrmlnc/fast-glob#fs)\
-Default: `undefined`
-Custom file system implementation (useful for testing or virtual file systems).
-**Note:** The custom fs must provide `readFile`/`readFileSync` methods for reading `.gitignore` files.
-```js
-import {isGitIgnored} from 'globby';
-const isIgnored = await isGitIgnored();
-console.log(isIgnored('some/file'));
-```
-```js
-// Suppress errors when encountering unreadable directories
-const isIgnored = await isGitIgnored({suppressErrors: true});
-```
-```js
-// Limit search depth and exclude certain directories
-const isIgnored = await isGitIgnored({
-	deep: 2,
-	ignore: ['**/node_modules/**', '**/dist/**']
-});
-```
-### isGitIgnoredSync(options?)
-Returns a `(path: URL | string) => boolean` indicating whether a given path is ignored via a `.gitignore` file.
-See [`isGitIgnored`](#isgitignoredoptions) for options.
-### isIgnoredByIgnoreFiles(patterns, options?)
-Returns a `Promise<(path: URL | string) => boolean>` indicating whether a given path is ignored via the ignore files.
-This is a more generic form of the `isGitIgnored` function, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
-#### patterns
-Type: `string | string[]`
-Glob patterns to look for ignore files.
-#### options
-Type: `object`
-See [`isGitIgnored` options](#isgitignoredoptions) for all available options.
-```js
-import {isIgnoredByIgnoreFiles} from 'globby';
-const isIgnored = await isIgnoredByIgnoreFiles("**/.gitignore");
-console.log(isIgnored('some/file'));
-```
-```js
-// Suppress errors when encountering unreadable directories
-const isIgnored = await isIgnoredByIgnoreFiles("**/.eslintignore", {suppressErrors: true});
-```
-```js
-// Limit search depth and concurrency
-const isIgnored = await isIgnoredByIgnoreFiles("**/.prettierignore", {
-	deep: 3,
-	concurrency: 4
-});
-```
-### isIgnoredByIgnoreFilesSync(patterns, options?)
-Returns a `(path: URL | string) => boolean` indicating whether a given path is ignored via the ignore files.
-This is a more generic form of the `isGitIgnoredSync` function, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
-See [`isIgnoredByIgnoreFiles`](#isignoredbyignorefilespatterns-options) for patterns and options.
-```js
-import {isIgnoredByIgnoreFilesSync} from 'globby';
-const isIgnored = isIgnoredByIgnoreFilesSync("**/.gitignore");
-console.log(isIgnored('some/file'));
-```
-## Globbing patterns
-Just a quick overview.
-- `*` matches any number of characters, but not `/`
-- `?` matches a single character, but not `/`
-- `**` matches any number of characters, including `/`, as long as it's the only thing in a path part
-- `{}` allows for a comma-separated list of "or" expressions
-- `!` at the beginning of a pattern will negate the match
-### Negation patterns
-Globby supports negation patterns to exclude files. There are two ways to use them:
-**With positive patterns:**
-```js
-await globby(['src/**/*.js', '!src/**/*.test.js']);
-// Matches all .js files except test files
-```
-**Negation-only patterns:**
-```js
-await globby(['!*.json', '!*.xml'], {cwd: 'config'});
-// Matches all files in config/ except .json and .xml files
-```
-When using only negation patterns, globby implicitly prepends `**/*` to match all files, then applies the negations. This means `['!*.json', '!*.xml']` is equivalent to `['**/*', '!*.json', '!*.xml']`.
-**Note:** The prepended `**/*` pattern respects the `dot` option. By default, dotfiles (files starting with `.`) are not matched unless you set `dot: true`.
-[Various patterns and expected matches.](https://github.com/sindresorhus/multimatch/blob/main/test/test.js)
-## Related
-- [multimatch](https://github.com/sindresorhus/multimatch) - Match against a list instead of the filesystem
-- [matcher](https://github.com/sindresorhus/matcher) - Simple wildcard matching
-- [del](https://github.com/sindresorhus/del) - Delete files and directories
-- [make-dir](https://github.com/sindresorhus/make-dir) - Make a directory and its parents if needed

package/packages/config-stylelint/node_modules/globby/utilities.js DELETED Viewed

@@ -1,299 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import {promisify} from 'node:util';
-import isPathInside from 'is-path-inside';
-export const isNegativePattern = pattern => pattern[0] === '!';
-/**
-Normalize an absolute pattern to be relative.
-On Unix, patterns starting with `/` are interpreted as absolute paths from the filesystem root. This causes inconsistent behavior across platforms since Windows uses different path roots (like `C:\`).
-This function strips leading `/` to make patterns relative to cwd, ensuring consistent cross-platform behavior.
-@param {string} pattern - The pattern to normalize.
-*/
-export const normalizeAbsolutePatternToRelative = pattern => pattern.startsWith('/') ? pattern.slice(1) : pattern;
-export const bindFsMethod = (object, methodName) => {
-	const method = object?.[methodName];
-	return typeof method === 'function' ? method.bind(object) : undefined;
-};
-// Only used as a fallback for legacy fs implementations
-export const promisifyFsMethod = (object, methodName) => {
-	const method = object?.[methodName];
-	if (typeof method !== 'function') {
-		return undefined;
-	}
-	return promisify(method.bind(object));
-};
-export const normalizeDirectoryPatternForFastGlob = pattern => {
-	if (!pattern.endsWith('/')) {
-		return pattern;
-	}
-	const trimmedPattern = pattern.replace(/\/+$/u, '');
-	if (!trimmedPattern) {
-		return '/**';
-	}
-	// Special case for '**/' to avoid producing '**/**/**'
-	if (trimmedPattern === '**') {
-		return '**/**';
-	}
-	const hasLeadingSlash = trimmedPattern.startsWith('/');
-	const patternBody = hasLeadingSlash ? trimmedPattern.slice(1) : trimmedPattern;
-	const hasInnerSlash = patternBody.includes('/');
-	const needsRecursivePrefix = !hasLeadingSlash && !hasInnerSlash && !trimmedPattern.startsWith('**/');
-	const recursivePrefix = needsRecursivePrefix ? '**/' : '';
-	return `${recursivePrefix}${trimmedPattern}/**`;
-};
-/**
-Extract the parent directory prefix from a pattern (e.g., '../' or '../../').
-Note: Patterns should have trailing slash after '..' (e.g., '../foo' not '..foo'). The directoryToGlob function ensures this in the normal pipeline.
-@param {string} pattern - The pattern to analyze.
-@returns {string} The parent directory prefix, or empty string if none.
-*/
-export const getParentDirectoryPrefix = pattern => {
-	const normalizedPattern = isNegativePattern(pattern) ? pattern.slice(1) : pattern;
-	const match = normalizedPattern.match(/^(\.\.\/)+/);
-	return match ? match[0] : '';
-};
-/**
-Adjust ignore patterns to match the relative base of the main patterns.
-When patterns reference parent directories, ignore patterns starting with globstars need to be adjusted to match from the same base directory. This ensures intuitive behavior where ignore patterns work correctly with parent directory patterns.
-This is analogous to how node-glob normalizes path prefixes (see node-glob issue #309) and how Rust ignore crate strips path prefixes before matching.
-@param {string[]} patterns - The main glob patterns.
-@param {string[]} ignorePatterns - The ignore patterns to adjust.
-@returns {string[]} Adjusted ignore patterns.
-*/
-export const adjustIgnorePatternsForParentDirectories = (patterns, ignorePatterns) => {
-	// Early exit for empty arrays
-	if (patterns.length === 0 || ignorePatterns.length === 0) {
-		return ignorePatterns;
-	}
-	// Get parent directory prefixes for all patterns (empty string if no prefix)
-	const parentPrefixes = patterns.map(pattern => getParentDirectoryPrefix(pattern));
-	// Check if all patterns have the same parent prefix
-	const firstPrefix = parentPrefixes[0];
-	if (!firstPrefix) {
-		return ignorePatterns; // No parent directories in any pattern
-	}
-	const allSamePrefix = parentPrefixes.every(prefix => prefix === firstPrefix);
-	if (!allSamePrefix) {
-		return ignorePatterns; // Mixed bases - don't adjust
-	}
-	// Adjust ignore patterns that start with **/
-	return ignorePatterns.map(pattern => {
-		// Only adjust patterns starting with **/ that don't already have a parent reference
-		if (pattern.startsWith('**/') && !pattern.startsWith('../')) {
-			return firstPrefix + pattern;
-		}
-		return pattern;
-	});
-};
-/**
-Find the git root directory by searching upward for a .git directory.
-@param {string} cwd - The directory to start searching from.
-@param {Object} [fsImplementation] - Optional fs implementation.
-@returns {string|undefined} The git root directory path, or undefined if not found.
-*/
-const getAsyncStatMethod = fsImplementation =>
-	bindFsMethod(fsImplementation?.promises, 'stat')
-	?? bindFsMethod(fs.promises, 'stat');
-const getStatSyncMethod = fsImplementation => {
-	if (fsImplementation) {
-		return bindFsMethod(fsImplementation, 'statSync');
-	}
-	return bindFsMethod(fs, 'statSync');
-};
-const pathHasGitDirectory = stats => Boolean(stats?.isDirectory?.() || stats?.isFile?.());
-const buildPathChain = (startPath, rootPath) => {
-	const chain = [];
-	let currentPath = startPath;
-	chain.push(currentPath);
-	while (currentPath !== rootPath) {
-		const parentPath = path.dirname(currentPath);
-		if (parentPath === currentPath) {
-			break;
-		}
-		currentPath = parentPath;
-		chain.push(currentPath);
-	}
-	return chain;
-};
-const findGitRootInChain = async (paths, statMethod) => {
-	for (const directory of paths) {
-		const gitPath = path.join(directory, '.git');
-		try {
-			const stats = await statMethod(gitPath); // eslint-disable-line no-await-in-loop
-			if (pathHasGitDirectory(stats)) {
-				return directory;
-			}
-		} catch {
-			// Ignore errors and continue searching
-		}
-	}
-	return undefined;
-};
-const findGitRootSyncUncached = (cwd, fsImplementation) => {
-	const statSyncMethod = getStatSyncMethod(fsImplementation);
-	if (!statSyncMethod) {
-		return undefined;
-	}
-	const currentPath = path.resolve(cwd);
-	const {root} = path.parse(currentPath);
-	const chain = buildPathChain(currentPath, root);
-	for (const directory of chain) {
-		const gitPath = path.join(directory, '.git');
-		try {
-			const stats = statSyncMethod(gitPath);
-			if (pathHasGitDirectory(stats)) {
-				return directory;
-			}
-		} catch {
-			// Ignore errors and continue searching
-		}
-	}
-	return undefined;
-};
-export const findGitRootSync = (cwd, fsImplementation) => {
-	if (typeof cwd !== 'string') {
-		throw new TypeError('cwd must be a string');
-	}
-	return findGitRootSyncUncached(cwd, fsImplementation);
-};
-const findGitRootAsyncUncached = async (cwd, fsImplementation) => {
-	const statMethod = getAsyncStatMethod(fsImplementation);
-	if (!statMethod) {
-		return findGitRootSync(cwd, fsImplementation);
-	}
-	const currentPath = path.resolve(cwd);
-	const {root} = path.parse(currentPath);
-	const chain = buildPathChain(currentPath, root);
-	return findGitRootInChain(chain, statMethod);
-};
-export const findGitRoot = async (cwd, fsImplementation) => {
-	if (typeof cwd !== 'string') {
-		throw new TypeError('cwd must be a string');
-	}
-	return findGitRootAsyncUncached(cwd, fsImplementation);
-};
-/**
-Get paths to all .gitignore files from git root to cwd (inclusive).
-@param {string} gitRoot - The git root directory.
-@param {string} cwd - The current working directory.
-@returns {string[]} Array of .gitignore file paths to search for.
-*/
-const isWithinGitRoot = (gitRoot, cwd) => {
-	const resolvedGitRoot = path.resolve(gitRoot);
-	const resolvedCwd = path.resolve(cwd);
-	return resolvedCwd === resolvedGitRoot || isPathInside(resolvedCwd, resolvedGitRoot);
-};
-export const getParentGitignorePaths = (gitRoot, cwd) => {
-	if (gitRoot && typeof gitRoot !== 'string') {
-		throw new TypeError('gitRoot must be a string or undefined');
-	}
-	if (typeof cwd !== 'string') {
-		throw new TypeError('cwd must be a string');
-	}
-	// If no gitRoot provided, return empty array
-	if (!gitRoot) {
-		return [];
-	}
-	if (!isWithinGitRoot(gitRoot, cwd)) {
-		return [];
-	}
-	const chain = buildPathChain(path.resolve(cwd), path.resolve(gitRoot));
-	return [...chain]
-		.reverse()
-		.map(directory => path.join(directory, '.gitignore'));
-};
-/**
-Convert ignore patterns to fast-glob compatible format.
-Returns empty array if patterns should be handled by predicate only.
-@param {string[]} patterns - Ignore patterns from .gitignore files
-@param {boolean} usingGitRoot - Whether patterns are relative to git root
-@param {Function} normalizeDirectoryPatternForFastGlob - Function to normalize directory patterns
-@returns {string[]} Patterns safe to pass to fast-glob, or empty array
-*/
-export const convertPatternsForFastGlob = (patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob) => {
-	// Determine which patterns are safe to pass to fast-glob
-	// If there are negation patterns, we can't pass file patterns to fast-glob
-	// because fast-glob doesn't understand negations and would filter out files
-	// that should be re-included by negation patterns.
-	// If we're using git root, patterns are relative to git root not cwd,
-	// so we can't pass them to fast-glob which expects cwd-relative patterns.
-	// We only pass patterns to fast-glob if there are NO negations AND we're not using git root.
-	if (usingGitRoot) {
-		return []; // Patterns are relative to git root, not cwd
-	}
-	const result = [];
-	let hasNegations = false;
-	// Single pass to check for negations and collect positive patterns
-	for (const pattern of patterns) {
-		if (isNegativePattern(pattern)) {
-			hasNegations = true;
-			break; // Early exit on first negation
-		}
-		result.push(normalizeDirectoryPatternForFastGlob(pattern));
-	}
-	return hasNegations ? [] : result;
-};