flatlint 1.25.0 → 1.27.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2025.01.08, v1.27.0
+
+feature:
+- a6b1991 flatlint: multiple fixes in one source
+
+2025.01.07, v1.26.0
+
+feature:
+- 0ba6115 flatlint: add-missing-quote: round brace before quote
+- 0aca502 flatlint: add-missing-round-brace: improve
+
 2025.01.06, v1.25.0
 
 feature:

package/README.md

@@ -47,6 +47,11 @@ npm i flatlint
 
 -a('hello'
 +a('hello');
+
+const m = {
+-    z: z('hello'
++    z: z('hello')
+}
 ```
 
  </details>

package/lib/compare/collect-args.js

@@ -1,5 +1,6 @@
 import {
     closeRoundBrace,
+    isNewLine,
     NOT_OK,
     OK,
 } from '#types';
@@ -17,6 +18,9 @@ export const collectArgs = ({currentTokenIndex, tokens}) => {
         
         if (equal(token, closeRoundBrace))
             break;
+        
+        if (isNewLine(token))
+            break;
     }
     
     return [

package/lib/compare/compare.js

@@ -15,7 +15,7 @@ import {
     equalStr,
 } from './equal.js';
 
-export const compare = (source, template) => {
+export const compare = (source, template, {index = 0} = {}) => {
     const templateTokens = prepare(template);
     const tokens = prepare(source);
     
@@ -27,7 +27,7 @@ export const compare = (source, template) => {
     let delta = 0;
     let skip = 0;
     
-    for (let index = 0; index < n; index++) {
+    for (; index < n; index++) {
         for (let templateIndex = 0; templateIndex < templateTokensLength; templateIndex++) {
             let currentTokenIndex = index + templateIndex - skip;
             

package/lib/flatlint.js

@@ -1,9 +1,7 @@
 import {loadPlugins} from '@putout/engine-loader';
 import {parse} from '#parser';
 import {run} from '#runner';
-
-const getValue = (token) => token.value;
-const print = (tokens) => tokens.map(getValue).join('');
+import {print} from '#printer';
 
 export function lint(source, overrides = {}) {
     const {fix = true, plugins: pluginNames = []} = overrides;

package/lib/parser/string-literal.js

@@ -1,4 +1,10 @@
-import {Punctuator, StringLiteral} from '#types';
+import {
+    closeRoundBrace,
+    comma,
+    Punctuator,
+    semicolon,
+    StringLiteral,
+} from '#types';
 
 export function parseStringLiteral({i, token, tokens}) {
     const {closed} = token;
@@ -17,15 +23,19 @@ export function parseStringLiteral({i, token, tokens}) {
         let count = 0;
         
         if (value.endsWith(';')) {
-            const semicolon = Punctuator(';');
-            
             value = value.slice(0, -1);
             newTokens.push(semicolon);
             ++count;
         }
         
+        if (value.endsWith(',')) {
+            value = value.slice(0, -1);
+            newTokens.push(comma);
+            ++count;
+        }
+        
         if (value.endsWith(')')) {
-            const brace = Punctuator(')');
+            const brace = closeRoundBrace;
             
             value = value.slice(0, -1);
             const {length} = newTokens;

package/lib/plugins/add-missing-quote/index.js

@@ -1,6 +1,11 @@
 export const report = () => 'Add missing quote';
 
+export const match = () => ({
+    '__a("__b': (vars, path) => !path.isNextPunctuator(vars.quote),
+});
+
 export const replace = () => ({
     'const __a = "__b;': 'const __a = "__b";',
     '__a("__b)': '__a("__b")',
+    '__a("__b': '__a("__b")',
 });

package/lib/plugins/add-missing-semicolon/index.js

@@ -20,6 +20,9 @@ function check(vars, path) {
     if (path.isEndsWithPunctuator(comma))
         return false;
     
+    if (path.isPrevIdentifier('function'))
+        return false;
+    
     for (const token of path.getAllNext()) {
         if (isPunctuator(token, semicolon))
             return false;

package/lib/printer/printer.js

@@ -0,0 +1,11 @@
+const isString = (a) => typeof a === 'string';
+const getValue = (token) => token.value;
+
+export const print = (tokens) => {
+    if (isString(tokens))
+        return tokens;
+    
+    return tokens
+        .map(getValue)
+        .join('');
+};

package/lib/runner/path.js

@@ -1,4 +1,8 @@
-import {isNewLine, isPunctuator} from '#types';
+import {
+    isIdentifier,
+    isNewLine,
+    isPunctuator,
+} from '#types';
 
 export const createPath = ({tokens, start, end}) => ({
     getAllPrev: createGetAllPrev({
@@ -13,12 +17,26 @@ export const createPath = ({tokens, start, end}) => ({
         tokens,
         end,
     }),
-    isEndsWithPunctuator: createIsEndsWithPunctuator({
+    isPrevIdentifier: createIsPrevIdentifier({
+        tokens,
+        start,
+    }),
+    isEndsWithPunctuator: createIsCurrentPunctuator({
+        tokens,
+        end,
+    }),
+    isCurrentPunctuator: createIsCurrentPunctuator({
         tokens,
         end,
     }),
 });
 
+const createIsCurrentPunctuator = ({tokens, end}) => (punctuator) => {
+    const current = tokens[end - 1];
+    
+    return isPunctuator(current, punctuator);
+};
+
 const createIsNextPunctuator = ({tokens, end}) => (punctuator) => {
     const current = tokens[end];
     
@@ -28,9 +46,15 @@ const createIsNextPunctuator = ({tokens, end}) => (punctuator) => {
     return isPunctuator(current, punctuator);
 };
 
-const createIsEndsWithPunctuator = ({tokens, end}) => (punctuator) => {
-    const current = tokens[end - 1];
-    return isPunctuator(current, punctuator);
+const createIsPrevIdentifier = ({tokens, start}) => (value) => {
+    const SPACE = 1;
+    const FUNCTION = 1;
+    const current = tokens[start - (FUNCTION + SPACE)];
+    
+    if (!current)
+        return false;
+    
+    return isIdentifier(current, value);
 };
 
 const createGetAllPrev = ({tokens, start}) => function*() {

package/lib/runner/replacer.js

@@ -1,3 +1,4 @@
+import debug from 'debug';
 import {compare} from '#compare';
 import {prepare} from '#parser';
 import {traverse} from '#traverser';
@@ -14,62 +15,78 @@ import {collectArgs} from '../compare/collect-args.js';
 
 const returns = (a) => () => a;
 const {entries} = Object;
+const log = debug('flatlint');
 
 export const replace = (tokens, {fix, rule, plugin}) => {
     const places = [];
     let isFixed = false;
     const match = plugin.match?.() ?? returns({});
     
-    for (let [from, to] of entries(plugin.replace())) {
-        const [ok, start, end] = compare(tokens, from);
+    for (const [from, to] of entries(plugin.replace())) {
+        let index = 0;
         
-        if (!ok)
-            continue;
-        
-        const values = getCurrentValues({
-            from,
-            start,
-            end,
-            tokens,
-        });
-        
-        const matchFn = match[from];
-        
-        if (matchFn) {
-            const is = matchFn(values, createPath({
-                tokens,
+        while (index < tokens.length - 1) {
+            const [ok, start, end] = compare(tokens, from, {
+                index,
+            });
+            
+            if (!ok)
+                break;
+            
+            const values = getCurrentValues({
+                from,
                 start,
                 end,
-            }));
+                tokens,
+            });
+            
+            const matchFn = match[from];
+            
+            if (matchFn) {
+                const is = matchFn(values, createPath({
+                    tokens,
+                    start,
+                    end,
+                }));
+                
+                if (!is) {
+                    index = end;
+                    continue;
+                }
+            }
             
-            if (!is)
+            if (fix) {
+                log(`${rule}: ${from} -> ${to}`);
+                
+                const preparedTo = prepare(to);
+                const waysTo = findVarsWays(preparedTo);
+                
+                setValues({
+                    values,
+                    waysTo,
+                    to: preparedTo,
+                });
+                
+                tokens.splice(start, end - start, ...preparedTo);
+                isFixed = true;
+                index = end;
+                
                 continue;
-        }
-        
-        if (fix) {
-            to = prepare(to);
-            const waysTo = findVarsWays(to);
+            }
             
-            setValues({
-                values,
-                waysTo,
-                to,
+            const {line, column} = tokens[start];
+            const message = plugin.report();
+            
+            places.push({
+                rule,
+                message,
+                line,
+                column,
             });
             
-            tokens.splice(start, end - start, ...to);
-            isFixed = true;
-            continue;
+            index = end;
+            isFixed = false;
         }
-        
-        const {line, column} = tokens[start];
-        const message = plugin.report();
-        
-        places.push({
-            rule,
-            message,
-            line,
-            column,
-        });
     }
     
     return [isFixed, places];

package/lib/traverser/traverser.js

@@ -1,7 +1,7 @@
 import {
     isIdentifier,
     isStringLiteral,
-} from '../types/types.js';
+} from '#types';
 
 const maybeCall = (fn, a) => fn?.(a);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatlint",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "JavaScript tokens-based linter",
   "main": "lib/flatlint.js",
   "type": "module",
@@ -17,6 +17,9 @@
     "#parser": {
       "default": "./lib/parser/parser.js"
     },
+    "#printer": {
+      "default": "./lib/printer/printer.js"
+    },
     "#traverser": {
       "default": "./lib/traverser/traverser.js"
     },
@@ -76,6 +79,7 @@
   },
   "dependencies": {
     "@putout/engine-loader": "^15.0.1",
+    "debug": "^4.4.0",
     "js-tokens": "^9.0.1",
     "putout": "^37.0.0"
   },