flatlint 1.19.0 → 1.21.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2025.01.03, v1.21.0
+
+feature:
+- d13da41 flatlint: add-missing-squire-brace: empty array
+
+2025.01.03, v1.20.0
+
+feature:
+- a6d8bd6 remove-useless-comma: use __args
+
 2025.01.02, v1.19.0
 
 feature:

package/README.md

@@ -151,6 +151,10 @@ it can be only one quote `'__a` - this is valid, since **FlatLint** is tokens ba
 Collects everything that looks like array elements, it can start from squire brace `[__array;`, but that's not important
 to end with it, since it used to fix error patterns.
 
+### `__args`
+
+Collects arguments of function when exists.
+
 ### `__expr`
 
 Collects everything that looks like expression.

package/lib/compare/collect-args.js

@@ -0,0 +1,34 @@
+import {
+    closeRoundBrace,
+    closeSquareBrace,
+    NOT_OK,
+    OK,
+    OpenRoundBrace,
+} from '#types';
+import {equal} from './equal.js';
+
+export const collectArgs = ({currentTokenIndex, tokens, nextTemplateToken = closeRoundBrace}) => {
+    const n = tokens.length;
+    let index = currentTokenIndex;
+    
+    if (equal(tokens[index - 1], OpenRoundBrace) && equal(tokens[index], closeRoundBrace))
+        return [NOT_OK];
+    
+    for (; index < n; index++) {
+        const token = tokens[index];
+        
+        if (equal(token, closeRoundBrace))
+            break;
+        
+        if (equal(token, nextTemplateToken))
+            break;
+        
+        if (equal(token, closeSquareBrace))
+            break;
+    }
+    
+    return [
+        OK,
+        --index,
+    ];
+};

package/lib/compare/collect-array.js

@@ -1,26 +1,34 @@
 import {
-    CloseRoundBrace,
-    Punctuator,
+    closeRoundBrace,
+    closeSquareBrace,
+    semicolon,
+    OK,
+    NOT_OK,
 } from '#types';
 import {equal} from './equal.js';
 
-export const collectArray = ({currentTokenIndex, tokens, nextTemplateToken = Punctuator(';')}) => {
+export const collectArray = ({currentTokenIndex, tokens, nextTemplateToken = semicolon}) => {
     const n = tokens.length;
-    const brace = Punctuator(']');
     let index = currentTokenIndex;
     
+    if (equal(tokens[index], closeSquareBrace))
+        return [NOT_OK];
+    
     for (; index < n; index++) {
         const token = tokens[index];
         
-        if (equal(token, CloseRoundBrace))
+        if (equal(token, closeRoundBrace))
             break;
         
         if (equal(token, nextTemplateToken))
             break;
         
-        if (equal(token, brace))
+        if (equal(token, closeSquareBrace))
             break;
     }
     
-    return --index;
+    return [
+        OK,
+        --index,
+    ];
 };

package/lib/compare/compare.js

@@ -1,10 +1,12 @@
 import {prepare} from '#parser';
 import {
+    isTemplateArgsToken,
     isTemplateArrayToken,
     isTemplateExpressionToken,
 } from '#types';
 import {collectArray} from './collect-array.js';
 import {collectExpression} from './collect-expression.js';
+import {collectArgs} from './collect-args.js';
 import {
     equal,
     equalAny,
@@ -23,10 +25,11 @@ export const compare = (source, template) => {
     let start = 0;
     let end = 0;
     let delta = 0;
+    let skip = 0;
     
     for (let index = 0; index < n; index++) {
         for (let templateIndex = 0; templateIndex < templateTokensLength; templateIndex++) {
-            const currentTokenIndex = index + templateIndex;
+            const currentTokenIndex = index + templateIndex - skip;
             
             if (currentTokenIndex > n) {
                 isEqual = false;
@@ -36,7 +39,21 @@ export const compare = (source, template) => {
             const templateToken = templateTokens[templateIndex];
             const currentToken = tokens[currentTokenIndex];
             
-            if (isTemplateExpressionToken(templateToken)) {
+            if (isTemplateArgsToken(templateToken)) {
+                const [ok, end] = collectArgs({
+                    currentTokenIndex,
+                    tokens,
+                    templateToken,
+                    nextTemplateToken: templateTokens[templateIndex + 1],
+                });
+                
+                if (!ok) {
+                    ++skip;
+                } else {
+                    delta = end - currentTokenIndex;
+                    index = end - templateIndex;
+                }
+            } else if (isTemplateExpressionToken(templateToken)) {
                 const indexOfExpressionEnd = collectExpression({
                     currentTokenIndex,
                     tokens,
@@ -47,15 +64,19 @@ export const compare = (source, template) => {
                 delta = indexOfExpressionEnd - currentTokenIndex;
                 index = indexOfExpressionEnd - templateIndex;
             } else if (isTemplateArrayToken(templateToken)) {
-                const indexOfArrayEnd = collectArray({
+                const [ok, indexOfArrayEnd] = collectArray({
                     currentTokenIndex,
                     tokens,
                     templateToken,
                     nextTemplateToken: templateTokens[templateIndex + 1],
                 });
                 
-                delta = indexOfArrayEnd - currentTokenIndex;
-                index = indexOfArrayEnd - templateIndex;
+                if (!ok) {
+                    ++skip;
+                } else {
+                    delta = indexOfArrayEnd - currentTokenIndex;
+                    index = indexOfArrayEnd - templateIndex;
+                }
             } else if (!compareAll(currentToken, templateToken)) {
                 isEqual = false;
                 break;

package/lib/flatlint.js

@@ -10,7 +10,7 @@ export function lint(source, overrides = {}) {
     
     const tokens = parse(source);
     
-    const [places] = run(tokens, {
+    const places = run(tokens, {
         plugins,
         fix,
     });

package/lib/plugins/remove-useless-coma/index.js

@@ -3,7 +3,7 @@ import {isIdentifier} from '#types';
 export const report = () => 'Remove useless coma';
 
 export const match = () => ({
-    '__a() {},': (vars, path) => {
+    '__a(__args) {},': (vars, path) => {
         for (const token of path.getPrev()) {
             if (isIdentifier(token, 'class'))
                 return true;
@@ -14,5 +14,5 @@ export const match = () => ({
 });
 
 export const replace = () => ({
-    '__a() {},': '__a() {}',
+    '__a(__args) {},': '__a(__args) {}',
 });

package/lib/runner/path.js

@@ -1,8 +1,9 @@
-export const createPath = ({tokens, start, end}) => {
-    return {
-        getPrev: createGetPrev({tokens, start}),
-    };
-};
+export const createPath = ({tokens, start}) => ({
+    getPrev: createGetPrev({
+        tokens,
+        start,
+    }),
+});
 
 function createGetPrev({tokens, start}) {
     return function*() {

package/lib/runner/replacer.js

@@ -3,42 +3,42 @@ import {prepare} from '#parser';
 import {traverse} from '#traverser';
 import {
     is,
+    isTemplateArgs,
     isTemplateArray,
     isTemplateExpression,
 } from '#types';
 import {collectArray} from '../compare/collect-array.js';
 import {collectExpression} from '../compare/collect-expression.js';
 import {createPath} from './path.js';
+import {collectArgs} from '../compare/collect-args.js';
 
 const returns = (a) => () => a;
 const {entries} = Object;
 
 export const match = (tokens, {plugin}) => {
     const match = plugin.match ?? returns([]);
+    let result = true;
     
     for (const [from, fn] of entries(match())) {
-        const [ok, start, end] = compare(tokens, from);
-        
-        if (!ok)
-            continue;
-        
+        const [, start, end] = compare(tokens, from);
         const current = tokens.slice(start, end);
         
         const waysFrom = findVarsWays(prepare(from));
         const values = getValues(current, waysFrom);
         
-        return fn(values, createPath({
+        result = fn(values, createPath({
             tokens,
             start,
             end,
         }));
     }
     
-    return true;
+    return result;
 };
 
 export const replace = (tokens, {fix, rule, plugin}) => {
     const places = [];
+    let isFixed = false;
     
     for (const [from, to] of entries(plugin.replace())) {
         const [ok, start, end] = compare(tokens, from);
@@ -53,6 +53,7 @@ export const replace = (tokens, {fix, rule, plugin}) => {
                 start,
                 end,
             });
+            isFixed = true;
             continue;
         }
         
@@ -67,7 +68,7 @@ export const replace = (tokens, {fix, rule, plugin}) => {
         });
     }
     
-    return places;
+    return [isFixed, places];
 };
 
 function runReplace(tokens, {from, to, start, end}) {
@@ -112,9 +113,10 @@ function getValues(tokens, waysFrom) {
     
     for (const [name, index] of entries(waysFrom)) {
         let end = index;
+        let ok = true;
         
         if (isTemplateArray(name))
-            end = collectArray({
+            [ok, end] = collectArray({
                 currentTokenIndex: index,
                 tokens,
             });
@@ -123,6 +125,16 @@ function getValues(tokens, waysFrom) {
                 currentTokenIndex: index,
                 tokens,
             });
+        else if (isTemplateArgs(name))
+            [ok, end] = collectArgs({
+                currentTokenIndex: index,
+                tokens,
+            });
+        
+        if (!ok) {
+            values[name] = [];
+            continue;
+        }
         
         values[name] = tokens.slice(index, end + 1);
     }

package/lib/runner/runner.js

@@ -1,23 +1,27 @@
 import {match, replace} from './replacer.js';
 
-export const run = (tokens, {fix, fixCount = 10, plugins}) => {
+export const run = (tokens, {fix, fixCount = fix ? 10 : 1, plugins}) => {
     const places = [];
     
     while (--fixCount >= 0) {
+        const fixed = [];
+        
         for (const {rule, plugin} of plugins) {
-            if (match(tokens, {plugin}))
-                places.push(...replace(tokens, {
+            if (match(tokens, {plugin})) {
+                const [isFixed, newPlaces] = replace(tokens, {
                     fix,
                     rule,
                     plugin,
-                }));
-            
-            if (!fix) {
-                fixCount = 0;
-                break;
+                });
+                
+                fixed.push(isFixed);
+                places.push(...newPlaces);
             }
         }
+        
+        if (!fixed.filter(Boolean).length)
+            break;
     }
     
-    return [places];
+    return places;
 };

package/lib/types/types.js

@@ -41,11 +41,13 @@ const ANY = '__';
 const QUOTE = /^['"]$/;
 const ARRAY = '__array';
 const EXPR = '__expr';
+const ARGS = '__args';
 
 const ALL = [
     ANY,
     LINKED_NODE,
     ARRAY,
+    ARGS,
     EXPR,
 ];
 
@@ -60,8 +62,15 @@ export const isId = (a) => LINKED_NODE.test(a);
 export const isQuote = (a) => QUOTE.test(a);
 export const isTemplateArray = (a) => a === ARRAY;
 export const isTemplateExpression = (a) => a === EXPR;
+export const isTemplateArgs = (a) => a === ARGS;
 export const isTemplateArrayToken = (a) => isIdentifier(a) && isTemplateArray(a.value);
 export const isTemplateExpressionToken = (a) => isIdentifier(a) && isTemplateExpression(a.value);
+export const isTemplateArgsToken = (a) => isIdentifier(a) && isTemplateArgs(a.value);
 
 export const OpenRoundBrace = Punctuator('(');
-export const CloseRoundBrace = Punctuator(')');
+export const closeRoundBrace = Punctuator(')');
+export const closeSquareBrace = Punctuator(']');
+export const semicolon = Punctuator(';');
+
+export const OK = true;
+export const NOT_OK = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatlint",
-  "version": "1.19.0",
+  "version": "1.21.0",
   "description": "JavaScript tokens-based linter",
   "main": "lib/flatlint.js",
   "type": "module",