FlatLint

Token-based JavaScript linter that fixes Syntax Errors

Install

npm i flatlint

Available fixes

<summary>apply import order</summary>

-import {readFile}, fs from 'node:fs';
+import fs, {readFile} from 'node:fs';

<summary>apply import from</summary>

-import fs form 'node:fs';
+import fs from 'node:fs';

<summary>assignment without parentheses after &&</summary>

-a && b = c;
+a && (b = c);

<summary>convert assert to with</summary>

-import a from 'a' assert {type: 'json'}
+import a from 'a' with {type: 'json'}

<summary>convert comma to semicolon</summary>

-const a = 5,
+const a = 5;

function x() {
-   return m,
+   return m;
}

-import a from 'a',
+import a from 'a';

-const a = 3,
+const a = 3;
module.exports = 2;

<summary>convert colon to semicolon</summary>

-console.log(a, b):
+console.log(a, b);

<summary>convert colon to comma</summary>

export const rules = [
-   ['apply-nesting': applyNesting],
+   ['apply-nesting', applyNesting],
];

<summary>convert colon to as</summary>

-import {simpleImport: _simpleImport} from './simple-import.js';
+import {simpleImport as _simpleImport} from './simple-import.js';

<summary>convert from to require</summary>

-const a = from 'a';
+const a = require('a');

<summary>add missing curly brace</summary>

-function a({b, c) {}
-function a({b, c}) {}

-const {a = b;
+const {a} = b;

<summary>add missing round brace</summary>

-if a > 5 {
+if (a > 5) {
    alert();
}

-if (a.b() {
+if (a.b()) {
}

-a('hello'
+a('hello');

const m = {
-    z: z('hello'
+    z: z('hello')
}

-{hello} = world;
+({hello} = world);

-assign(oldPath, currentPath;
+assign(oldPath, currentPath);

<summary>add missing assign</summary>

-const a 5;
+const a = 5;

-module.exports {};
+module.exports = {};

<summary>add missing comma</summary>

import {
-   a
+   a,
    b,
} from 'c';

t.transform('declare-imports-first', {
-   'declare-imports-first': declareImportsFirst
+   'declare-imports-first': declareImportsFirst,
    'convert-esm-to-commonjs': convertEsmToCommonJs,
});

<summary>add missing arrow '=>'</summary>

-const a = (b, c) {};
+const a = (b, c) => {};

<summary>add const to export</summary>

-export x = 5;
+export const x = 5;

<summary>add missing squire brace</summary>

-const a = ['hello', 'world';
+const a = ['hello', 'world'];

<summary>remove useless round brace</summary>

-const a = 5);
+const a = 5;

-import a from 'a');
+import a from 'a';

if (a) {
-})
+}

<summary>remove useless square brace</summary>

-const a = [1, 2, 3]];
+const a = [1, 2, 3];

<summary>convert semicolon to comma</summary>

const a = {
-    b: 'hello';
+    b: 'hello',
}

const b = [
    1,
-   2;
+   2,
    3,
]

<summary>convert module to namespace</summary>

-module M {
+namespace M {
    var a: string;
}

<summary>remove useless comma</summary>

function x() {
    return m;
-},
+}

-const expected = [],
+const expected = [];
t.equal(expected, []);

<summary>remove useless dot</summary>

-fn([]);
+fn([].);

<summary>remove invalid character</summary>

-const {¬
-····is,¬
-····sArgsStr,¬
-····isTypeParamsStr,¬
-} = require('./is');¬
+const {
+    is,
+    isArgsStr,
+    isTypeParamsStr,
+} = require('./is');

<summary>add missing quote</summary>

-const a = 'hello
+const a = 'hello'

-fn('hello);
+fn('hello');

<summary>Remove useless arrow</summary>

-function parse(source) => {
+function parse(source) {
    return source;
}

<summary>Remove useless assign</summary>

-import {readFile, readdir} = from 'node:fs/promises';
+import {readFile, readdir} from 'node:fs/promises';

<summary>Remove useless coma</summary>

const a = class {
-    b() {},
+    b() {}
}

<summary>add missing semicolon</summary>

-const a = 5
+const a = 5;

<summary>add missing if</summary>

    if (a < 0)
        console.log('hello');
-    else (a > 3)
+    else if (a > 3)
        console.log('world');

<summary>split namespace with specifiers</summary>

-import * as plugin, {CUT} from './plugin.js';
+import * as plugin from './plugin.js';
+const {CUT} = plugin;

Template literals

FlatLint uses language similar to ????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.

`__args`

Collects arguments of function when exists.

`__expr`

Collects everything that looks like expression.

API

import {lint, plugins} from 'flatlint/with-plugins';

const [code] = flatlint(`a && b = c`, {
    plugins,
});

// returns
`
a && (b = c);
`;

Without fix:

import {lint, plugins} from 'flatlint/with-plugins';

const [, places] = flatlint(`a && b = c`, {
    fix: false,
    plugins,
});

// returns
[{
    column: 1,
    line: 1,
    message: `Wrap the assignment in parentheses after '&&'`,
    rule: 'wrap-assignment-in-parens',
}];

When you want to use custom plugins:

import {lint} from 'flatlint';

const [code] = lint(`a && b = c`, {
    startLine: 1,
    plugins: [
        ['wrap-assignment-in-parens', {
            report: () => `Wrap the assignment in parentheses after '&&'`,
            replace: () => ({
                '__a && __b = __c': '__a && (__b = __c)',
            }),
        }],
    ],
});