flatlint 1.3.0 → 1.4.0

package/ChangeLog

@@ -1,3 +1,8 @@
+2024.12.29, v1.4.0
+
+feature:
+- bb670ef flatlint: add-missing-quote: add
+
 2024.12.29, v1.3.0
 
 feature:

package/README.md

@@ -48,6 +48,15 @@ npm i flatlint
 
  </details>
 
+<details><summary>add missing quote</summary>
+
+```diff
+-const a = 'hello
++const a = 'hello'
+```
+
+ </details>
+
 ## API
 
 ```js

package/lib/compare/compare.js

@@ -3,11 +3,14 @@ import {
     isId,
     isIdentifier,
     isPunctuator,
+    isQuote,
+    isStringLiteral,
 } from './types.js';
 
 export const compare = (source, template) => {
     const templateTokens = prepare(template);
     const tokens = prepare(source);
+    
     const n = tokens.length - 1;
     const templateTokensLength = templateTokens.length;
     let isEqual = false;
@@ -17,6 +20,12 @@ export const compare = (source, template) => {
     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];
             
@@ -40,7 +49,9 @@ export const compare = (source, template) => {
 const comparators = [
     equal,
     equalId,
+    equalStr,
     equalAny,
+    equalQuote,
 ];
 
 function compareAll(a, b) {
@@ -66,6 +77,20 @@ function equalAny(a, b) {
     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;

package/lib/compare/types.js

@@ -2,6 +2,7 @@ const isString = (a) => typeof a === 'string';
 
 export const isWhiteSpace = ({type}) => type === 'WhiteSpace';
 export const isIdentifier = ({type}) => type === 'IdentifierName';
+export const isStringLiteral = ({type}) => type === 'StringLiteral';
 export const isNumericLiteral = ({type}) => type === 'NumericLiteral';
 export const isNewLine = ({type}) => type === 'LineTerminatorSequence';
 export const notWhiteSpace = (a) => !isWhiteSpace(a);
@@ -18,6 +19,7 @@ export const is = (str, array = ALL) => {
 
 const LINKED_NODE = /^__[a-z]$/;
 const ANY = '__';
+const QUOTE = /^['"]$/;
 
 const ALL = [ANY, LINKED_NODE];
 
@@ -29,3 +31,4 @@ function check(str, item) {
 }
 
 export const isId = (a) => LINKED_NODE.test(a);
+export const isQuote = (a) => QUOTE.test(a);

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

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

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

@@ -5,5 +5,6 @@ export function report() {
 export function replace() {
     return {
         'const __a = __b)': 'const __a = __b',
+        'const __a = "__b")': 'const __a = "__b"',
     };
 }

package/lib/plugins.js

@@ -1,11 +1,13 @@
 import * as wrapAssignmentInParens from './plugins/wrap-assignment-in-parens/index.js';
 import * as addMissingRoundBraces from './plugins/add-missing-round-braces/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 removeUselessRoundBrace from './plugins/remove-useless-round-brace/index.js';
 
 export const plugins = [
     ['wrap-assignment-in-parens', wrapAssignmentInParens],
     ['add-missing-round-braces', addMissingRoundBraces],
+    ['add-missing-quote', addMissingQuote],
     ['convert-comma-to-semicolon', convertCommaToSemicolon],
     ['remove-useless-round-brace', removeUselessRoundBrace],
 ];

package/lib/runner/replacer.js

@@ -66,6 +66,10 @@ function findVarsWays(tokens) {
             if (is(value))
                 ways[value] = index;
         },
+        StringLiteral({value, index}) {
+            if (is(value))
+                ways[value] = index;
+        },
     });
     
     return ways;

package/lib/tokenizer/index.js

@@ -1,13 +1,57 @@
 import tokenize from 'js-tokens';
-import {isNewLine} from '../compare/types.js';
+import {
+    isNewLine,
+    isStringLiteral,
+} from '../compare/types.js';
 
 const isString = (a) => typeof a === 'string';
 
+const closeQuotes = (tokens) => {
+    const n = tokens.length;
+    
+    for (let i = 0; i < n; i++) {
+        const token = tokens[i];
+        
+        if (isStringLiteral(token)) {
+            const {closed, value} = token;
+            
+            const quote = {
+                type: 'Punctuator',
+                value: value.at(0),
+            };
+            
+            const newTokens = [];
+            
+            if (closed) {
+                const literal = {
+                    value: value.slice(1, -1),
+                    type: 'StringLiteral',
+                };
+                
+                newTokens.push(quote, literal, quote);
+            } else {
+                const literal = {
+                    value: value.slice(1),
+                    type: 'StringLiteral',
+                };
+                
+                newTokens.push(quote, literal);
+            }
+            
+            tokens.splice(i, 1, ...newTokens);
+            ++i;
+        }
+    }
+};
+
 export const prepare = (a) => {
-    if (isString(a))
-        return Array.from(tokenize(a));
+    if (!isString(a))
+        return a;
+    
+    const array = Array.from(tokenize(a));
+    closeQuotes(array);
     
-    return a;
+    return array;
 };
 
 export const parse = (source) => {

package/lib/traverser/traverser.js

@@ -1,13 +1,26 @@
-import {isIdentifier} from '../compare/types.js';
+import {
+    isIdentifier,
+    isStringLiteral,
+} from '../compare/types.js';
 
 const maybeCall = (fn, a) => fn?.(a);
 
 export const traverse = (tokens, visitors = {}) => {
     for (const [index, token] of tokens.entries()) {
-        if (isIdentifier(token))
+        if (isIdentifier(token)) {
             maybeCall(visitors.Identifier, {
                 ...token,
                 index,
             });
+            continue;
+        }
+        
+        if (isStringLiteral(token)) {
+            maybeCall(visitors.StringLiteral, {
+                ...token,
+                index,
+            });
+            continue;
+        }
     }
 };

package/package.json

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