flatlint 1.11.0 → 1.13.0

package/ChangeLog

@@ -1,3 +1,14 @@
+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:
+- dedb945 flatlint: add-missing-quote: improve
+
 2024.12.31, v1.11.0
 
 feature:

package/README.md

@@ -28,6 +28,15 @@ npm i flatlint
 
 </details>
 
+<details><summary>Convert <code>from</code> to <code>require</code></summary>
+
+```diff
+-const a = from 'a';
++const a = require('a');
+```
+
+</details>
+
 <details><summary>add missing round braces in if statement</summary>
 
 ```diff
@@ -81,6 +90,24 @@ 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.
+
 ## API
 
 ```js

package/lib/compare/collect-array.js

@@ -0,0 +1,21 @@
+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/compare.js

@@ -1,11 +1,13 @@
 import {prepare} from '#parser';
+import {isTemplateArrayToken} from '#types';
+import {collectArray} from './collect-array.js';
 import {
-    isId,
-    isIdentifier,
-    isPunctuator,
-    isQuote,
-    isStringLiteral,
-} from '#types';
+    equal,
+    equalAny,
+    equalId,
+    equalQuote,
+    equalStr,
+} from './equal.js';
 
 export const compare = (source, template) => {
     const templateTokens = prepare(template);
@@ -16,26 +18,31 @@ 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 (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 +69,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-quote/index.js

@@ -1,10 +1,6 @@
-export function report() {
-    return 'Add missing quote';
-}
+export const report = () => 'Add missing quote';
 
-export function replace() {
-    return {
-        'const __a = "__b': 'const __a = "__b"',
-        '__a("__b)': '__a("__b")',
-    };
-}
+export const replace = () => ({
+    'const __a = "__b;': 'const __a = "__b";',
+    '__a("__b)': '__a("__b")',
+});

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/convert-from-to-require/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Use 'require' instead of 'from'`;
+
+export const replace = () => ({
+    '= from "__a"': '= require("__a")',
+});

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

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

package/lib/plugins.js

@@ -3,13 +3,17 @@ import * as addMissingRoundBraces from './plugins/add-missing-round-braces/index
 import * as addMissingSquireBrace from './plugins/add-missing-square-brace/index.js';
 import * as addMissingQuote from './plugins/add-missing-quote/index.js';
 import * as convertCommaToSemicolon from './plugins/convert-comma-to-semicolon/index.js';
+import * as convertFromToRequire from './plugins/convert-from-to-require/index.js';
 import * as removeUselessRoundBrace from './plugins/remove-useless-round-brace/index.js';
+import * as addConstToExport from './plugins/add-const-to-export/index.js';
 
 export const plugins = [
     ['wrap-assignment-in-parens', wrapAssignmentInParens],
     ['add-missing-round-braces', addMissingRoundBraces],
     ['add-missing-squire-brace', addMissingSquireBrace],
     ['add-missing-quote', addMissingQuote],
+    ['add-const-to-export', addConstToExport],
     ['convert-comma-to-semicolon', convertCommaToSemicolon],
+    ['convert-from-to-require', convertFromToRequire],
     ['remove-useless-round-brace', removeUselessRoundBrace],
 ];

package/lib/runner/replacer.js

@@ -1,8 +1,14 @@
-import {is} from '#types';
+import {
+    is,
+    isTemplateArray,
+    Punctuator,
+} from '#types';
 import {prepare} from '#parser';
 import {compare} from '#compare';
 import {traverse} from '#traverser';
+import {collectArray} from '../compare/collect-array.js';
 
+const {isArray} = Array;
 const {entries} = Object;
 
 export const replace = (tokens, {fix, rule, plugin}) => {
@@ -79,6 +85,23 @@ function getValues(tokens, waysFrom) {
     const values = {};
     
     for (const [name, index] of entries(waysFrom)) {
+        if (isTemplateArray(name)) {
+            debugger;
+            const endOfArray = collectArray({
+                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 +110,14 @@ 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

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

package/lib/types/types.js

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

package/package.json

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