flatlint 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# TKLint
+
+Token-based JavaScript linter that fixes Syntax Errors
+
+## Install
+
+```
+npm i tklint
+```
+
+## API
+
+```js
+import {lint, plugins} from 'tklint/with-plugins';
+
+const [code] = tklint(`a && b = c`, {
+    plugins,
+});
+
+// returns
+`
+a && (b = c);
+`;
+```
+
+Without `fix`:
+
+```js
+import {lint, plugins} from 'tklint/with-plugins';
+
+const [, places] = tklint(`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:
+
+```js
+import {lint} from 'tklint';
+
+const [code] = lint(`a && b = c`, {
+    plugins: [
+        ['wrap-assignment-in-parens', {
+            report: () => `Wrap the assignment in parentheses after '&&'`,
+            replace: () => ({
+                '__a && __b = __c': '__a && (__b = __c)',
+            }),
+        }],
+    ],
+});
+```
+
+## License
+
+MIT

package/example/1.js

@@ -0,0 +1 @@
+

package/lib/compare/compare.js

@@ -0,0 +1,99 @@
+import {prepare} from '../tokenizer/index.js';
+import {
+    isId,
+    isIdentifier,
+    isNewLine,
+    isPunctuator,
+    isWhiteSpace,
+} 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;
+    let start = 0;
+    let end = 0;
+    
+    for (let index = 0; index < n; index++) {
+        let tokenDelta = 0;
+        let templateDelta = 0;
+        
+        for (let templateIndex = 0; templateIndex < templateTokensLength; templateIndex++) {
+            const currentTokenIndex = index + templateIndex - tokenDelta;
+            
+            if (currentTokenIndex === n + 1)
+                break;
+            
+            const templateToken = templateTokens[templateIndex - templateDelta];
+            const currentToken = tokens[currentTokenIndex];
+            
+            if (isWhiteSpace(currentToken)) {
+                ++templateDelta;
+                continue;
+            }
+            
+            if (isWhiteSpace(templateToken)) {
+                ++tokenDelta;
+                continue;
+            }
+            
+            if (isNewLine(currentToken))
+                continue;
+            
+            if (!compareAll(currentToken, templateToken)) {
+                isEqual = false;
+                break;
+            }
+            
+            isEqual = true;
+            start = index;
+            end = currentTokenIndex + tokenDelta + templateDelta;
+        }
+        
+        if (isEqual)
+            return [true, start, ++end];
+    }
+    
+    return [false];
+};
+
+const comparators = [
+    equal,
+    equalId,
+    equalAny,
+];
+
+function compareAll(a, b) {
+    for (const currentCompare of comparators) {
+        if (currentCompare(a, b))
+            return true;
+    }
+    
+    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 equalId(a, b) {
+    if (!isIdentifier(b))
+        return false;
+    
+    if (isPunctuator(a))
+        return false;
+    
+    return isId(b.value);
+}

package/lib/compare/types.js

@@ -0,0 +1,31 @@
+const isString = (a) => typeof a === 'string';
+
+export const isWhiteSpace = ({type}) => type === 'WhiteSpace';
+export const isIdentifier = ({type}) => type === 'IdentifierName';
+export const isNumericLiteral = ({type}) => type === 'NumericLiteral';
+export const isNewLine = ({type}) => type === 'LineTerminatorSequence';
+export const notWhiteSpace = (a) => !isWhiteSpace(a);
+export const isPunctuator = ({type}) => type === 'Punctuator';
+
+export const is = (str, array = ALL) => {
+    for (const item of array) {
+        if (check(str, item))
+            return true;
+    }
+    
+    return false;
+};
+
+const LINKED_NODE = /^__[a-z]$/;
+const ANY = '__';
+
+const ALL = [ANY, LINKED_NODE];
+
+function check(str, item) {
+    if (isString(item))
+        return str === item;
+    
+    return item.test(str);
+}
+
+export const isId = (a) => LINKED_NODE.test(a);

package/lib/plugins/wrap-assignment-in-parens/index.js

@@ -0,0 +1,9 @@
+export function replace() {
+    return {
+        '__a && __b = __c': '__a && (__b = __c)',
+    };
+}
+
+export function report() {
+    return `Wrap the assignment in parentheses after '&&'`;
+}

package/lib/plugins.js

@@ -0,0 +1,5 @@
+import * as wrapAssignmentInParens from './plugins/wrap-assignment-in-parens/index.js';
+
+export const plugins = [
+    ['wrap-assignment-in-parens', wrapAssignmentInParens],
+];

package/lib/runner/replacer.js

@@ -0,0 +1,88 @@
+import {compare} from '../compare/compare.js';
+import {traverse} from '../traverser/traverser.js';
+import {is} from '../compare/types.js';
+import {prepare} from '../tokenizer/index.js';
+
+const {entries} = Object;
+
+export const replace = (tokens, {fix, rule, plugin}) => {
+    const places = [];
+    
+    for (const [from, to] of entries(plugin.replace())) {
+        const [ok, start, end] = compare(tokens, from);
+        
+        if (!ok)
+            continue;
+        
+        if (fix) {
+            runReplace(tokens, {
+                from,
+                to,
+                start,
+                end,
+            });
+            continue;
+        }
+        
+        const {line, column} = tokens[start];
+        const message = plugin.report();
+        
+        places.push({
+            rule,
+            message,
+            line,
+            column,
+        });
+    }
+    
+    return places;
+};
+
+function runReplace(tokens, {from, to, start, end}) {
+    const current = tokens.slice(start, end);
+    
+    to = prepare(to);
+    from = prepare(from);
+    
+    const waysFrom = findVarsWays(from);
+    const values = getValues(current, waysFrom);
+    
+    const waysTo = findVarsWays(to);
+    
+    setValues({
+        values,
+        waysTo,
+        to,
+    });
+    
+    tokens.splice(start, end - start, ...to);
+}
+
+function findVarsWays(tokens) {
+    const ways = {};
+    
+    traverse(tokens, {
+        Identifier({value, index}) {
+            if (is(value))
+                ways[value] = index;
+        },
+    });
+    
+    return ways;
+}
+
+function getValues(tokens, waysFrom) {
+    const values = {};
+    
+    for (const [name, index] of entries(waysFrom)) {
+        values[name] = tokens[index];
+    }
+    
+    return values;
+}
+
+function setValues({to, waysTo, values}) {
+    for (const [name, index] of entries(waysTo)) {
+        to[index] = values[name];
+    }
+}

package/lib/runner/runner.js

@@ -0,0 +1,15 @@
+import {replace} from './replacer.js';
+
+export const run = (tokens, {fix, plugins}) => {
+    const places = [];
+    
+    for (const {rule, plugin} of plugins) {
+        places.push(...replace(tokens, {
+            fix,
+            rule,
+            plugin,
+        }));
+    }
+    
+    return [places];
+};

package/lib/tklint.js

@@ -0,0 +1,31 @@
+import {loadPlugins} from '@putout/engine-loader';
+import {run} from './runner/runner.js';
+import {parse} from './tokenizer/index.js';
+
+export function lint(source, overrides = {}) {
+    const {fix = true, plugins: pluginNames = []} = overrides;
+    const plugins = loadPlugins({
+        pluginNames,
+    });
+    
+    const tokens = parse(source);
+    
+    const [places] = run(tokens, {
+        plugins,
+        fix,
+    });
+    
+    if (!fix)
+        return [source, places];
+    
+    return [
+        print(tokens),
+        places,
+    ];
+}
+
+function print(tokens) {
+    return tokens
+        .map((token) => token.value)
+        .join('');
+}

package/lib/tokenizer/index.js

@@ -0,0 +1,38 @@
+import tokenize from 'js-tokens';
+import {isNewLine} from '../compare/types.js';
+
+const isString = (a) => typeof a === 'string';
+
+export const prepare = (a) => {
+    if (isString(a))
+        return Array.from(tokenize(a));
+    
+    return a;
+};
+
+export const parse = (source) => {
+    return getTokensWithLocation(prepare(source));
+};
+
+function getTokensWithLocation(tokens) {
+    let line = 1;
+    let column = 1;
+    const result = [];
+    
+    for (const token of tokens) {
+        if (isNewLine(token)) {
+            ++line;
+            continue;
+        }
+        
+        result.push({
+            ...token,
+            line,
+            column,
+        });
+        
+        column += token.value.length;
+    }
+    
+    return result;
+}

package/lib/traverser/traverser.js

@@ -0,0 +1,13 @@
+import {isIdentifier} 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))
+            maybeCall(visitors.Identifier, {
+                ...token,
+                index,
+            });
+    }
+};

package/lib/with-plugins.js

@@ -0,0 +1,7 @@
+import {lint} from './tklint.js';
+import {plugins} from './plugins.js';
+
+export {
+    lint,
+    plugins,
+};

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "flatlint",
+  "version": "1.0.0",
+  "description": "JavaScript tokens-based linter",
+  "main": "lib/flatlint.js",
+  "type": "module",
+  "exports": {
+    "./with-plugins": "./lib/with-plugins.js"
+  },
+  "imports": {
+    "#test": {
+      "default": "./lib/test/test.js"
+    },
+    "#flatlint": {
+      "default": "./lib/flatlint.js"
+    }
+  },
+  "scripts": {
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "watch:tape": "madrun watch:tape",
+    "watch:lint": "madrun watch:lint",
+    "watcher": "madrun watcher",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/flatlint.git"
+  },
+  "keywords": [
+    "flatlint",
+    "scripts",
+    "package",
+    "npm",
+    "npm run",
+    "npm-scripts",
+    "tool",
+    "cli",
+    "command",
+    "task",
+    "parallel",
+    "serial",
+    "run",
+    "tool",
+    "commandline",
+    "command"
+  ],
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (http://coderaiser.github.io/)",
+  "bugs": {
+    "url": "https://github.com/coderaiser/flatlint/issues"
+  },
+  "homepage": "https://github.com/coderaiser/flatlint",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@putout/engine-loader": "^15.0.1",
+    "@putout/formatter-dump": "^5.0.0",
+    "all-object-keys": "^2.0.0",
+    "enquirer": "^2.3.6",
+    "find-up": "^7.0.0",
+    "jessy": "^3.0.0",
+    "js-tokens": "^9.0.1",
+    "mapsome": "^1.0.0",
+    "montag": "^1.0.0",
+    "once": "^1.4.0",
+    "putout": "^37.0.0",
+    "try-catch": "^3.0.0",
+    "try-to-catch": "^3.0.0",
+    "yargs-parser": "^21.0.0"
+  },
+  "devDependencies": {
+    "@putout/formatter-json": "^2.0.0",
+    "@putout/test": "^11.1.0",
+    "c8": "^10.1.2",
+    "escover": "^4.0.0",
+    "eslint": "^9.7.0",
+    "eslint-plugin-putout": "^23.1.0",
+    "madrun": "^10.2.2",
+    "mock-import": "^4.0.2",
+    "mock-require": "^3.0.3",
+    "nodemon": "^3.0.1",
+    "runsome": "^1.0.0",
+    "supertape": "^10.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}