flatlint 1.12.0 → 1.14.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2025.01.01, v1.14.0
+
+feature:
+- 2361298 flatlint: __expr
+
+2025.01.01, v1.13.0
+
+feature:
+- f24e4d3 flatlint: add support of __array
+- 0b2d275 flatlint: compare: __array: add support
+
 2024.12.31, v1.12.0
 
 feature:

package/README.md

@@ -90,6 +90,29 @@ npm i flatlint
 
  </details>
 
+## Template literals
+
+**FlatLint** uses language similar to 🐊[**PutoutScript**](https://github.com/coderaiser/putout/blob/master/docs/putout-script.md#-putoutscript).
+
+It can look similar, but has a couple differences:
+
+- ✅it may not be valid **JavaScript**, it can be couple tokens that can be fixed;
+- ✅it counts each symbol as a token;
+
+### `__a`
+
+From `__a` to `__z` is usually identifiers, but can also be strings if used with quotes `'__a'` they can be single or double,
+it can be only one quote `'__a` - this is valid, since **FlatLint** is tokens based.
+
+### `__array`
+
+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.
+
+### `__expr`
+
+Collects everything that looks like expression.
+
 ## API
 
 ```js

package/lib/compare/collect-array.js

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

package/lib/compare/collect-expression.js

@@ -0,0 +1,28 @@
+import {Punctuator} from '#types';
+import {equal} from './equal.js';
+
+export const collectExpression = ({currentTokenIndex, tokens, nextTemplateToken}) => {
+    const n = tokens.length;
+    const closeBrace = Punctuator(')');
+    const openBrace = Punctuator('(');
+    const semicolon = Punctuator(';');
+    let index = currentTokenIndex;
+    
+    for (; index < n; index++) {
+        const token = tokens[index];
+        
+        if (equal(token, semicolon))
+            break;
+        
+        if (equal(token, nextTemplateToken))
+            break;
+        
+        if (equal(token, openBrace))
+            break;
+        
+        if (equal(token, closeBrace))
+            break;
+    }
+    
+    return --index;
+};

package/lib/compare/compare.js

@@ -1,11 +1,17 @@
 import {prepare} from '#parser';
 import {
-    isId,
-    isIdentifier,
-    isPunctuator,
-    isQuote,
-    isStringLiteral,
+    isTemplateArrayToken,
+    isTemplateExpressionToken,
 } from '#types';
+import {collectArray} from './collect-array.js';
+import {collectExpression} from './collect-expression.js';
+import {
+    equal,
+    equalAny,
+    equalId,
+    equalQuote,
+    equalStr,
+} from './equal.js';
 
 export const compare = (source, template) => {
     const templateTokens = prepare(template);
@@ -16,26 +22,41 @@ export const compare = (source, template) => {
     let isEqual = false;
     let start = 0;
     let end = 0;
+    let delta = 0;
     
     for (let index = 0; index < n; index++) {
         for (let templateIndex = 0; templateIndex < templateTokensLength; templateIndex++) {
             const currentTokenIndex = index + templateIndex;
-            
-            if (currentTokenIndex > n) {
-                isEqual = false;
-                break;
-            }
-            
             const templateToken = templateTokens[templateIndex];
             const currentToken = tokens[currentTokenIndex];
             
-            if (!compareAll(currentToken, templateToken)) {
+            if (isTemplateExpressionToken(templateToken)) {
+                const indexOfExpressionEnd = collectExpression({
+                    currentTokenIndex,
+                    tokens,
+                    templateToken,
+                    nextTemplateToken: templateTokens[templateIndex + 1],
+                });
+                
+                delta = indexOfExpressionEnd - currentTokenIndex;
+                index = indexOfExpressionEnd - templateIndex;
+            } else if (isTemplateArrayToken(templateToken)) {
+                const indexOfArrayEnd = collectArray({
+                    currentTokenIndex,
+                    tokens,
+                    templateToken,
+                    nextTemplateToken: templateTokens[templateIndex + 1],
+                });
+                
+                delta = indexOfArrayEnd - currentTokenIndex;
+                index = indexOfArrayEnd - templateIndex;
+            } else if (!compareAll(currentToken, templateToken)) {
                 isEqual = false;
                 break;
             }
             
             isEqual = true;
-            start = index;
+            start = index - delta;
             end = currentTokenIndex;
         }
         
@@ -62,41 +83,3 @@ function compareAll(a, b) {
     
     return false;
 }
-
-function equal(a, b) {
-    return a.type === b.type && a.value === b.value;
-}
-
-function equalAny(a, b) {
-    if (!isIdentifier(b))
-        return false;
-    
-    if (isPunctuator(a))
-        return false;
-    
-    return b.value === '__';
-}
-
-function equalQuote(a, b) {
-    if (!isPunctuator(a))
-        return false;
-    
-    return isQuote(b.value);
-}
-
-function equalStr(a, b) {
-    if (!isStringLiteral(a))
-        return false;
-    
-    return isId(b.value);
-}
-
-function equalId(a, b) {
-    if (!isIdentifier(b))
-        return false;
-    
-    if (isPunctuator(a))
-        return false;
-    
-    return isId(b.value);
-}

package/lib/compare/equal.js

@@ -0,0 +1,45 @@
+import {
+    isId,
+    isIdentifier,
+    isPunctuator,
+    isQuote,
+    isStringLiteral,
+} from '#types';
+
+export function equal(a, b) {
+    return a.type === b.type && a.value === b.value;
+}
+
+export function equalAny(a, b) {
+    if (!isIdentifier(b))
+        return false;
+    
+    if (isPunctuator(a))
+        return false;
+    
+    return b.value === '__';
+}
+
+export function equalQuote(a, b) {
+    if (!isPunctuator(a))
+        return false;
+    
+    return isQuote(b.value);
+}
+
+export function equalStr(a, b) {
+    if (!isStringLiteral(a))
+        return false;
+    
+    return isId(b.value);
+}
+
+export function equalId(a, b) {
+    if (!isIdentifier(b))
+        return false;
+    
+    if (isPunctuator(a))
+        return false;
+    
+    return isId(b.value);
+}

package/lib/plugins/add-missing-square-brace/index.js

@@ -4,9 +4,6 @@ export function report() {
 
 export function replace() {
     return {
-        '["__a";': '["__a"];',
-        '[__a;': '[__a];',
-        '["__a", "__b";': '["__a", "__b"];',
-        '[__a, __b;': '[__a, __b];',
+        '[__array;': '[__array];',
     };
 }

package/lib/plugins/remove-useless-round-brace/index.js

@@ -1,7 +1,6 @@
 export const report = () => 'Remove useless round brace';
 
 export const replace = () => ({
-    'const __a = __b)': 'const __a = __b',
-    'const __a = "__b")': 'const __a = "__b"',
+    'const __a = __expr);': 'const __a = __expr;',
     'from "__b")': 'from "__b"',
 });

package/lib/runner/replacer.js

@@ -1,8 +1,16 @@
-import {is} from '#types';
-import {prepare} from '#parser';
 import {compare} from '#compare';
+import {prepare} from '#parser';
 import {traverse} from '#traverser';
+import {
+    is,
+    isTemplateArray,
+    isTemplateExpression,
+    Punctuator,
+} from '#types';
+import {collectArray} from '../compare/collect-array.js';
+import {collectExpression} from '../compare/collect-expression.js';
 
+const {isArray} = Array;
 const {entries} = Object;
 
 export const replace = (tokens, {fix, rule, plugin}) => {
@@ -79,6 +87,38 @@ function getValues(tokens, waysFrom) {
     const values = {};
     
     for (const [name, index] of entries(waysFrom)) {
+        if (isTemplateArray(name)) {
+            const endOfArray = collectArray({
+                currentTokenIndex: index,
+                tokens,
+                nextTemplateToken: Punctuator(';'),
+            });
+            
+            if (index === endOfArray) {
+                values[name] = tokens[index];
+                continue;
+            }
+            
+            values[name] = tokens.slice(index, endOfArray + 1);
+            continue;
+        }
+        
+        if (isTemplateExpression(name)) {
+            const endOfArray = collectExpression({
+                currentTokenIndex: index,
+                tokens,
+                nextTemplateToken: Punctuator(';'),
+            });
+            
+            if (index === endOfArray) {
+                values[name] = tokens[index];
+                continue;
+            }
+            
+            values[name] = tokens.slice(index, endOfArray + 1);
+            continue;
+        }
+        
         values[name] = tokens[index];
     }
     
@@ -87,6 +127,13 @@ function getValues(tokens, waysFrom) {
 
 function setValues({to, waysTo, values}) {
     for (const [name, index] of entries(waysTo)) {
-        to[index] = values[name];
+        const current = values[name];
+        
+        if (!isArray(current)) {
+            to[index] = values[name];
+            continue;
+        }
+        
+        to.splice(index, 1, ...values[name]);
     }
 }

package/lib/runner/runner.js

@@ -3,7 +3,7 @@ import {replace} from './replacer.js';
 export const run = (tokens, {fix, fixCount = 10, plugins}) => {
     const places = [];
     
-    while (--fixCount) {
+    while (--fixCount >= 0) {
         for (const {rule, plugin} of plugins) {
             places.push(...replace(tokens, {
                 fix,
@@ -11,8 +11,10 @@ export const run = (tokens, {fix, fixCount = 10, plugins}) => {
                 plugin,
             }));
             
-            if (places.length)
-                return [places];
+            if (!fix) {
+                fixCount = 0;
+                break;
+            }
         }
     }
     

package/lib/types/types.js

@@ -30,8 +30,15 @@ export const is = (str, array = ALL) => {
 const LINKED_NODE = /^__[a-z]$/;
 const ANY = '__';
 const QUOTE = /^['"]$/;
+const ARRAY = '__array';
+const EXPR = '__expr';
 
-const ALL = [ANY, LINKED_NODE];
+const ALL = [
+    ANY,
+    LINKED_NODE,
+    ARRAY,
+    EXPR,
+];
 
 function check(str, item) {
     if (isString(item))
@@ -42,3 +49,7 @@ function check(str, item) {
 
 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 isTemplateArrayToken = (a) => isIdentifier(a) && isTemplateArray(a.value);
+export const isTemplateExpressionToken = (a) => isIdentifier(a) && isTemplateExpression(a.value);

package/package.json

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