immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/eslint/lib/rules/no-multiple-empty-lines.js

@@ -70,7 +70,7 @@ module.exports = {
         const sourceCode = context.sourceCode;
 
         // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
-        const allLines = sourceCode.lines[sourceCode.lines.length - 1] === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
+        const allLines = sourceCode.lines.at(-1) === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
         const templateLiteralLines = new Set();
 
         //--------------------------------------------------------------------------

data/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js

@@ -22,7 +22,7 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with global non-constructor functions",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
         },
 

data/node_modules/eslint/lib/rules/no-new-symbol.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to disallow use of the new operator with the `Symbol` object
  * @author Alberto Rodríguez
+ * @deprecated in ESLint v9.0.0
  */
 
 "use strict";
@@ -16,10 +17,16 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with the `Symbol` object",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-new-symbol"
         },
 
+        deprecated: true,
+
+        replacedBy: [
+            "no-new-native-nonconstructor"
+        ],
+
         schema: [],
 
         messages: {

data/node_modules/eslint/lib/rules/no-restricted-globals.js

@@ -97,7 +97,7 @@ module.exports = {
          * @private
          */
         function isRestricted(name) {
-            return Object.prototype.hasOwnProperty.call(restrictedGlobalMessages, name);
+            return Object.hasOwn(restrictedGlobalMessages, name);
         }
 
         return {

data/node_modules/eslint/lib/rules/no-restricted-imports.js

@@ -34,10 +34,17 @@ const arrayOfStringsOrObjects = {
                         items: {
                             type: "string"
                         }
+                    },
+                    allowImportNames: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        }
                     }
                 },
                 additionalProperties: false,
-                required: ["name"]
+                required: ["name"],
+                not: { required: ["importNames", "allowImportNames"] }
             }
         ]
     },
@@ -66,6 +73,14 @@ const arrayOfStringsOrObjectPatterns = {
                         minItems: 1,
                         uniqueItems: true
                     },
+                    allowImportNames: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        },
+                        minItems: 1,
+                        uniqueItems: true
+                    },
                     group: {
                         type: "array",
                         items: {
@@ -77,6 +92,9 @@ const arrayOfStringsOrObjectPatterns = {
                     importNamePattern: {
                         type: "string"
                     },
+                    allowImportNamePattern: {
+                        type: "string"
+                    },
                     message: {
                         type: "string",
                         minLength: 1
@@ -86,7 +104,16 @@ const arrayOfStringsOrObjectPatterns = {
                     }
                 },
                 additionalProperties: false,
-                required: ["group"]
+                required: ["group"],
+                not: {
+                    anyOf: [
+                        { required: ["importNames", "allowImportNames"] },
+                        { required: ["importNamePattern", "allowImportNamePattern"] },
+                        { required: ["importNames", "allowImportNamePattern"] },
+                        { required: ["importNamePattern", "allowImportNames"] },
+                        { required: ["allowImportNames", "allowImportNamePattern"] }
+                    ]
+                }
             },
             uniqueItems: true
         }
@@ -131,7 +158,23 @@ module.exports = {
 
             importName: "'{{importName}}' import from '{{importSource}}' is restricted.",
             // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-            importNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}"
+            importNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}",
+
+            allowedImportName: "'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            allowedImportNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed. {{customMessage}}",
+
+            everythingWithAllowImportNames: "* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            everythingWithAllowImportNamesAndCustomMessage: "* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed. {{customMessage}}",
+
+            allowedImportNamePattern: "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            allowedImportNamePatternWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'. {{customMessage}}",
+
+            everythingWithAllowedImportNamePattern: "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            everythingWithAllowedImportNamePatternWithCustomMessage: "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed. {{customMessage}}"
         },
 
         schema: {
@@ -158,20 +201,29 @@ module.exports = {
         const options = Array.isArray(context.options) ? context.options : [];
         const isPathAndPatternsObject =
             typeof options[0] === "object" &&
-            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+            (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
-        const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {
+        const groupedRestrictedPaths = restrictedPaths.reduce((memo, importSource) => {
+            const path = typeof importSource === "string"
+                ? importSource
+                : importSource.name;
+
+            if (!memo[path]) {
+                memo[path] = [];
+            }
+
             if (typeof importSource === "string") {
-                memo[importSource] = { message: null };
+                memo[path].push({});
             } else {
-                memo[importSource.name] = {
+                memo[path].push({
                     message: importSource.message,
-                    importNames: importSource.importNames
-                };
+                    importNames: importSource.importNames,
+                    allowImportNames: importSource.allowImportNames
+                });
             }
             return memo;
-        }, {});
+        }, Object.create(null));
 
         // Handle patterns too, either as strings or groups
         let restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
@@ -182,12 +234,18 @@ module.exports = {
         }
 
         // relative paths are supported for this rule
-        const restrictedPatternGroups = restrictedPatterns.map(({ group, message, caseSensitive, importNames, importNamePattern }) => ({
-            matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group),
-            customMessage: message,
-            importNames,
-            importNamePattern
-        }));
+        const restrictedPatternGroups = restrictedPatterns.map(
+            ({ group, message, caseSensitive, importNames, importNamePattern, allowImportNames, allowImportNamePattern }) => (
+                {
+                    matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group),
+                    customMessage: message,
+                    importNames,
+                    importNamePattern,
+                    allowImportNames,
+                    allowImportNamePattern
+                }
+            )
+        );
 
         // if no imports are restricted we don't need to check
         if (Object.keys(restrictedPaths).length === 0 && restrictedPatternGroups.length === 0) {
@@ -203,33 +261,60 @@ module.exports = {
          * @private
          */
         function checkRestrictedPathAndReport(importSource, importNames, node) {
-            if (!Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource)) {
+            if (!Object.hasOwn(groupedRestrictedPaths, importSource)) {
                 return;
             }
 
-            const customMessage = restrictedPathMessages[importSource].message;
-            const restrictedImportNames = restrictedPathMessages[importSource].importNames;
-
-            if (restrictedImportNames) {
-                if (importNames.has("*")) {
-                    const specifierData = importNames.get("*")[0];
+            groupedRestrictedPaths[importSource].forEach(restrictedPathEntry => {
+                const customMessage = restrictedPathEntry.message;
+                const restrictedImportNames = restrictedPathEntry.importNames;
+                const allowedImportNames = restrictedPathEntry.allowImportNames;
 
+                if (!restrictedImportNames && !allowedImportNames) {
                     context.report({
                         node,
-                        messageId: customMessage ? "everythingWithCustomMessage" : "everything",
-                        loc: specifierData.loc,
+                        messageId: customMessage ? "pathWithCustomMessage" : "path",
                         data: {
                             importSource,
-                            importNames: restrictedImportNames,
                             customMessage
                         }
                     });
+
+                    return;
                 }
 
-                restrictedImportNames.forEach(importName => {
-                    if (importNames.has(importName)) {
-                        const specifiers = importNames.get(importName);
+                importNames.forEach((specifiers, importName) => {
+                    if (importName === "*") {
+                        const [specifier] = specifiers;
 
+                        if (restrictedImportNames) {
+                            context.report({
+                                node,
+                                messageId: customMessage ? "everythingWithCustomMessage" : "everything",
+                                loc: specifier.loc,
+                                data: {
+                                    importSource,
+                                    importNames: restrictedImportNames,
+                                    customMessage
+                                }
+                            });
+                        } else if (allowedImportNames) {
+                            context.report({
+                                node,
+                                messageId: customMessage ? "everythingWithAllowImportNamesAndCustomMessage" : "everythingWithAllowImportNames",
+                                loc: specifier.loc,
+                                data: {
+                                    importSource,
+                                    allowedImportNames,
+                                    customMessage
+                                }
+                            });
+                        }
+
+                        return;
+                    }
+
+                    if (restrictedImportNames && restrictedImportNames.includes(importName)) {
                         specifiers.forEach(specifier => {
                             context.report({
                                 node,
@@ -243,17 +328,24 @@ module.exports = {
                             });
                         });
                     }
-                });
-            } else {
-                context.report({
-                    node,
-                    messageId: customMessage ? "pathWithCustomMessage" : "path",
-                    data: {
-                        importSource,
-                        customMessage
+
+                    if (allowedImportNames && !allowedImportNames.includes(importName)) {
+                        specifiers.forEach(specifier => {
+                            context.report({
+                                node,
+                                loc: specifier.loc,
+                                messageId: customMessage ? "allowedImportNameWithCustomMessage" : "allowedImportName",
+                                data: {
+                                    importSource,
+                                    customMessage,
+                                    importName,
+                                    allowedImportNames
+                                }
+                            });
+                        });
                     }
                 });
-            }
+            });
         }
 
         /**
@@ -271,12 +363,14 @@ module.exports = {
             const customMessage = group.customMessage;
             const restrictedImportNames = group.importNames;
             const restrictedImportNamePattern = group.importNamePattern ? new RegExp(group.importNamePattern, "u") : null;
+            const allowedImportNames = group.allowImportNames;
+            const allowedImportNamePattern = group.allowImportNamePattern ? new RegExp(group.allowImportNamePattern, "u") : null;
 
-            /*
+            /**
              * If we are not restricting to any specific import names and just the pattern itself,
              * report the error and move on
              */
-            if (!restrictedImportNames && !restrictedImportNamePattern) {
+            if (!restrictedImportNames && !allowedImportNames && !restrictedImportNamePattern && !allowedImportNamePattern) {
                 context.report({
                     node,
                     messageId: customMessage ? "patternWithCustomMessage" : "patterns",
@@ -303,6 +397,28 @@ module.exports = {
                                 customMessage
                             }
                         });
+                    } else if (allowedImportNames) {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithAllowImportNamesAndCustomMessage" : "everythingWithAllowImportNames",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                allowedImportNames,
+                                customMessage
+                            }
+                        });
+                    } else if (allowedImportNamePattern) {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithAllowedImportNamePatternWithCustomMessage" : "everythingWithAllowedImportNamePattern",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                allowedImportNamePattern,
+                                customMessage
+                            }
+                        });
                     } else {
                         context.report({
                             node,
@@ -336,6 +452,36 @@ module.exports = {
                         });
                     });
                 }
+
+                if (allowedImportNames && !allowedImportNames.includes(importName)) {
+                    specifiers.forEach(specifier => {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "allowedImportNameWithCustomMessage" : "allowedImportName",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                customMessage,
+                                importName,
+                                allowedImportNames
+                            }
+                        });
+                    });
+                } else if (allowedImportNamePattern && !allowedImportNamePattern.test(importName)) {
+                    specifiers.forEach(specifier => {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "allowedImportNamePatternWithCustomMessage" : "allowedImportNamePattern",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                customMessage,
+                                importName,
+                                allowedImportNamePattern
+                            }
+                        });
+                    });
+                }
             });
         }
 

data/node_modules/eslint/lib/rules/no-restricted-modules.js

@@ -90,7 +90,7 @@ module.exports = {
         const options = Array.isArray(context.options) ? context.options : [];
         const isPathAndPatternsObject =
             typeof options[0] === "object" &&
-            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+            (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
         const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
@@ -178,7 +178,7 @@ module.exports = {
          * @private
          */
         function isRestrictedPath(name) {
-            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);
+            return Object.hasOwn(restrictedPathMessages, name);
         }
 
         return {

data/node_modules/eslint/lib/rules/no-return-await.js

@@ -118,7 +118,7 @@ module.exports = {
             if (node.parent.type === "LogicalExpression" && node === node.parent.right) {
                 return isInTailCallPosition(node.parent);
             }
-            if (node.parent.type === "SequenceExpression" && node === node.parent.expressions[node.parent.expressions.length - 1]) {
+            if (node.parent.type === "SequenceExpression" && node === node.parent.expressions.at(-1)) {
                 return isInTailCallPosition(node.parent);
             }
             return false;

data/node_modules/eslint/lib/rules/no-sequences.js

@@ -35,6 +35,7 @@ module.exports = {
         },
 
         schema: [{
+            type: "object",
             properties: {
                 allowInParentheses: {
                     type: "boolean",

data/node_modules/eslint/lib/rules/no-this-before-super.js

@@ -30,6 +30,29 @@ function isConstructorFunction(node) {
     );
 }
 
+/*
+ * Information for each code path segment.
+ * - superCalled:  The flag which shows `super()` called in all code paths.
+ * - invalidNodes: The array of invalid ThisExpression and Super nodes.
+ */
+/**
+ *
+ */
+class SegmentInfo {
+
+    /**
+     * Indicates whether `super()` is called in all code paths.
+     * @type {boolean}
+     */
+    superCalled = false;
+
+    /**
+     * The array of invalid ThisExpression and Super nodes.
+     * @type {ASTNode[]}
+     */
+    invalidNodes = [];
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -64,13 +87,7 @@ module.exports = {
          */
         let funcInfo = null;
 
-        /*
-         * Information for each code path segment.
-         * Each key is the id of a code path segment.
-         * Each value is an object:
-         * - superCalled:  The flag which shows `super()` called in all code paths.
-         * - invalidNodes: The array of invalid ThisExpression and Super nodes.
-         */
+        /** @type {Record<string, SegmentInfo>} */
         let segInfoMap = Object.create(null);
 
         /**
@@ -79,7 +96,7 @@ module.exports = {
          * @returns {boolean} `true` if `super()` is called.
          */
         function isCalled(segment) {
-            return !segment.reachable || segInfoMap[segment.id].superCalled;
+            return !segment.reachable || segInfoMap[segment.id]?.superCalled;
         }
 
         /**
@@ -197,11 +214,26 @@ module.exports = {
                     return;
                 }
 
+                /**
+                 * A collection of nodes to avoid duplicate reports.
+                 * @type {Set<ASTNode>}
+                 */
+                const reported = new Set();
+
                 codePath.traverseSegments((segment, controller) => {
                     const info = segInfoMap[segment.id];
+                    const invalidNodes = info.invalidNodes
+                        .filter(
 
-                    for (let i = 0; i < info.invalidNodes.length; ++i) {
-                        const invalidNode = info.invalidNodes[i];
+                            /*
+                             * Avoid duplicate reports.
+                             * When there is a `finally`, invalidNodes may contain already reported node.
+                             */
+                            node => !reported.has(node)
+                        );
+
+                    for (const invalidNode of invalidNodes) {
+                        reported.add(invalidNode);
 
                         context.report({
                             messageId: "noBeforeSuper",
@@ -270,18 +302,18 @@ module.exports = {
                 funcInfo.codePath.traverseSegments(
                     { first: toSegment, last: fromSegment },
                     (segment, controller) => {
-                        const info = segInfoMap[segment.id];
+                        const info = segInfoMap[segment.id] ?? new SegmentInfo();
 
                         if (info.superCalled) {
-                            info.invalidNodes = [];
                             controller.skip();
                         } else if (
                             segment.prevSegments.length > 0 &&
                             segment.prevSegments.every(isCalled)
                         ) {
                             info.superCalled = true;
-                            info.invalidNodes = [];
                         }
+
+                        segInfoMap[segment.id] = info;
                     }
                 );
             },

data/node_modules/eslint/lib/rules/no-trailing-spaces.js

@@ -129,8 +129,7 @@ module.exports = {
                     comments = sourceCode.getAllComments(),
                     commentLineNumbers = getCommentLineNumbers(comments);
 
-                let totalLength = 0,
-                    fixRange = [];
+                let totalLength = 0;
 
                 for (let i = 0, ii = lines.length; i < ii; i++) {
                     const lineNumber = i + 1;
@@ -177,7 +176,7 @@ module.exports = {
                             continue;
                         }
 
-                        fixRange = [rangeStart, rangeEnd];
+                        const fixRange = [rangeStart, rangeEnd];
 
                         if (!ignoreComments || !commentLineNumbers.has(lineNumber)) {
                             report(node, location, fixRange);

data/node_modules/eslint/lib/rules/no-unneeded-ternary.js

@@ -76,7 +76,7 @@ module.exports = {
          * @returns {string} A string representing an inverted expression
          */
         function invertExpression(node) {
-            if (node.type === "BinaryExpression" && Object.prototype.hasOwnProperty.call(OPERATOR_INVERSES, node.operator)) {
+            if (node.type === "BinaryExpression" && Object.hasOwn(OPERATOR_INVERSES, node.operator)) {
                 const operatorToken = sourceCode.getFirstTokenBetween(
                     node.left,
                     node.right,

data/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js

@@ -94,7 +94,7 @@ module.exports = {
                     break;
                 case "SequenceExpression":
                     checkUndefinedShortCircuit(
-                        node.expressions[node.expressions.length - 1],
+                        node.expressions.at(-1),
                         reportFunc
                     );
                     break;

data/node_modules/eslint/lib/rules/no-unused-private-class-members.js

@@ -16,7 +16,7 @@ module.exports = {
 
         docs: {
             description: "Disallow unused private class members",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
         },