immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/eslint/lib/eslint/eslint-helpers.js

@@ -15,7 +15,6 @@ const fsp = fs.promises;
 const isGlob = require("is-glob");
 const hash = require("../cli-engine/hash");
 const minimatch = require("minimatch");
-const util = require("util");
 const fswalk = require("@nodelib/fs.walk");
 const globParent = require("glob-parent");
 const isPathInside = require("is-path-inside");
@@ -24,7 +23,6 @@ const isPathInside = require("is-path-inside");
 // Fixup references
 //-----------------------------------------------------------------------------
 
-const doFsWalk = util.promisify(fswalk.walk);
 const Minimatch = minimatch.Minimatch;
 const MINIMATCH_OPTIONS = { dot: true };
 
@@ -105,20 +103,30 @@ class AllFilesIgnoredError extends Error {
 
 /**
  * Check if a given value is a non-empty string or not.
- * @param {any} x The value to check.
- * @returns {boolean} `true` if `x` is a non-empty string.
+ * @param {any} value The value to check.
+ * @returns {boolean} `true` if `value` is a non-empty string.
  */
-function isNonEmptyString(x) {
-    return typeof x === "string" && x.trim() !== "";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "";
 }
 
 /**
  * Check if a given value is an array of non-empty strings or not.
- * @param {any} x The value to check.
- * @returns {boolean} `true` if `x` is an array of non-empty strings.
+ * @param {any} value The value to check.
+ * @returns {boolean} `true` if `value` is an array of non-empty strings.
+ */
+function isArrayOfNonEmptyString(value) {
+    return Array.isArray(value) && value.length && value.every(isNonEmptyString);
+}
+
+/**
+ * Check if a given value is an empty array or an array of non-empty strings.
+ * @param {any} value The value to check.
+ * @returns {boolean} `true` if `value` is an empty array or an array of non-empty
+ *      strings.
  */
-function isArrayOfNonEmptyString(x) {
-    return Array.isArray(x) && x.every(isNonEmptyString);
+function isEmptyArrayOrArrayOfNonEmptyString(value) {
+    return Array.isArray(value) && value.every(isNonEmptyString);
 }
 
 //-----------------------------------------------------------------------------
@@ -270,56 +278,92 @@ async function globSearch({
      */
     const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
 
-    const filePaths = (await doFsWalk(basePath, {
-
-        deepFilter(entry) {
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
-            const matchesPattern = matchers.some(matcher => matcher.match(relativePath, true));
+    const filePaths = (await new Promise((resolve, reject) => {
 
-            return matchesPattern && !configs.isDirectoryIgnored(entry.path);
-        },
-        entryFilter(entry) {
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+        let promiseRejected = false;
 
-            // entries may be directories or files so filter out directories
-            if (entry.dirent.isDirectory()) {
+        /**
+         * Wraps a boolean-returning filter function. The wrapped function will reject the promise if an error occurs.
+         * @param {Function} filter A filter function to wrap.
+         * @returns {Function} A function similar to the wrapped filter that rejects the promise if an error occurs.
+         */
+        function wrapFilter(filter) {
+            return (...args) => {
+
+                // No need to run the filter if an error has been thrown.
+                if (!promiseRejected) {
+                    try {
+                        return filter(...args);
+                    } catch (error) {
+                        promiseRejected = true;
+                        reject(error);
+                    }
+                }
                 return false;
-            }
+            };
+        }
 
-            /*
-             * Optimization: We need to track when patterns are left unmatched
-             * and so we use `unmatchedPatterns` to do that. There is a bit of
-             * complexity here because the same file can be matched by more than
-             * one pattern. So, when we start, we actually need to test every
-             * pattern against every file. Once we know there are no remaining
-             * unmatched patterns, then we can switch to just looking for the
-             * first matching pattern for improved speed.
-             */
-            const matchesPattern = unmatchedPatterns.size > 0
-                ? matchers.reduce((previousValue, matcher) => {
-                    const pathMatches = matcher.match(relativePath);
+        fswalk.walk(
+            basePath,
+            {
+                deepFilter: wrapFilter(entry => {
+                    const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+                    const matchesPattern = matchers.some(matcher => matcher.match(relativePath, true));
+
+                    return matchesPattern && !configs.isDirectoryIgnored(entry.path);
+                }),
+                entryFilter: wrapFilter(entry => {
+                    const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+                    // entries may be directories or files so filter out directories
+                    if (entry.dirent.isDirectory()) {
+                        return false;
+                    }
 
                     /*
-                     * We updated the unmatched patterns set only if the path
-                     * matches and the file isn't ignored. If the file is
-                     * ignored, that means there wasn't a match for the
-                     * pattern so it should not be removed.
-                     *
-                     * Performance note: isFileIgnored() aggressively caches
-                     * results so there is no performance penalty for calling
-                     * it twice with the same argument.
+                     * Optimization: We need to track when patterns are left unmatched
+                     * and so we use `unmatchedPatterns` to do that. There is a bit of
+                     * complexity here because the same file can be matched by more than
+                     * one pattern. So, when we start, we actually need to test every
+                     * pattern against every file. Once we know there are no remaining
+                     * unmatched patterns, then we can switch to just looking for the
+                     * first matching pattern for improved speed.
                      */
-                    if (pathMatches && !configs.isFileIgnored(entry.path)) {
-                        unmatchedPatterns.delete(matcher.pattern);
-                    }
-
-                    return pathMatches || previousValue;
-                }, false)
-                : matchers.some(matcher => matcher.match(relativePath));
-
-            return matchesPattern && !configs.isFileIgnored(entry.path);
-        }
-
+                    const matchesPattern = unmatchedPatterns.size > 0
+                        ? matchers.reduce((previousValue, matcher) => {
+                            const pathMatches = matcher.match(relativePath);
+
+                            /*
+                             * We updated the unmatched patterns set only if the path
+                             * matches and the file isn't ignored. If the file is
+                             * ignored, that means there wasn't a match for the
+                             * pattern so it should not be removed.
+                             *
+                             * Performance note: isFileIgnored() aggressively caches
+                             * results so there is no performance penalty for calling
+                             * it twice with the same argument.
+                             */
+                            if (pathMatches && !configs.isFileIgnored(entry.path)) {
+                                unmatchedPatterns.delete(matcher.pattern);
+                            }
+
+                            return pathMatches || previousValue;
+                        }, false)
+                        : matchers.some(matcher => matcher.match(relativePath));
+
+                    return matchesPattern && !configs.isFileIgnored(entry.path);
+                })
+            },
+            (error, entries) => {
+
+                // If the promise is already rejected, calling `resolve` or `reject` will do nothing.
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(entries);
+                }
+            }
+        );
     })).map(entry => entry.path);
 
     // now check to see if we have any unmatched patterns
@@ -655,9 +699,9 @@ class ESLintInvalidOptionsError extends Error {
 
 /**
  * Validates and normalizes options for the wrapped CLIEngine instance.
- * @param {FlatESLintOptions} options The options to process.
+ * @param {ESLintOptions} options The options to process.
  * @throws {ESLintInvalidOptionsError} If of any of a variety of type errors.
- * @returns {FlatESLintOptions} The normalized options.
+ * @returns {ESLintOptions} The normalized options.
  */
 function processOptions({
     allowInlineConfig = true, // ← we cannot use `overrideConfig.noInlineConfig` instead because `allowInlineConfig` has side-effect that suppress warnings that show inline configs are ignored.
@@ -675,7 +719,10 @@ function processOptions({
     overrideConfig = null,
     overrideConfigFile = null,
     plugins = {},
+    stats = false,
     warnIgnored = true,
+    passOnNoPatterns = false,
+    ruleFilter = () => true,
     ...unknownOptions
 }) {
     const errors = [];
@@ -759,7 +806,7 @@ function processOptions({
     if (typeof ignore !== "boolean") {
         errors.push("'ignore' must be a boolean.");
     }
-    if (!isArrayOfNonEmptyString(ignorePatterns) && ignorePatterns !== null) {
+    if (!isEmptyArrayOrArrayOfNonEmptyString(ignorePatterns) && ignorePatterns !== null) {
         errors.push("'ignorePatterns' must be an array of non-empty strings or null.");
     }
     if (typeof overrideConfig !== "object") {
@@ -768,6 +815,9 @@ function processOptions({
     if (!isNonEmptyString(overrideConfigFile) && overrideConfigFile !== null && overrideConfigFile !== true) {
         errors.push("'overrideConfigFile' must be a non-empty string, null, or true.");
     }
+    if (typeof passOnNoPatterns !== "boolean") {
+        errors.push("'passOnNoPatterns' must be a boolean.");
+    }
     if (typeof plugins !== "object") {
         errors.push("'plugins' must be an object or null.");
     } else if (plugins !== null && Object.keys(plugins).includes("")) {
@@ -776,9 +826,15 @@ function processOptions({
     if (Array.isArray(plugins)) {
         errors.push("'plugins' doesn't add plugins to configuration to load. Please use the 'overrideConfig.plugins' option instead.");
     }
+    if (typeof stats !== "boolean") {
+        errors.push("'stats' must be a boolean.");
+    }
     if (typeof warnIgnored !== "boolean") {
         errors.push("'warnIgnored' must be a boolean.");
     }
+    if (typeof ruleFilter !== "function") {
+        errors.push("'ruleFilter' must be a function.");
+    }
     if (errors.length > 0) {
         throw new ESLintInvalidOptionsError(errors);
     }
@@ -800,7 +856,10 @@ function processOptions({
         globInputPaths,
         ignore,
         ignorePatterns,
-        warnIgnored
+        stats,
+        passOnNoPatterns,
+        warnIgnored,
+        ruleFilter
     };
 }
 
@@ -887,7 +946,6 @@ function getCacheFile(cacheFile, cwd) {
 //-----------------------------------------------------------------------------
 
 module.exports = {
-    isGlobPattern,
     findFiles,
 
     isNonEmptyString,