ko-lints 2.0.0 → 3.1.0

package/index.d.ts

@@ -4,6 +4,8 @@ export type IOpts = {
   write: boolean;
   configPath: string;
   patterns: Pattern[];
+  concurrency?: boolean;
+  concurrentNumber?: number;
 };
 
 export type IKeys = 'eslint' | 'prettier' | 'stylelint';
@@ -13,7 +15,7 @@ declare class Lints {
   private opts;
   state: 0 | 1;
   constructor(opts: IOpts);
-  run(key: IKeys): Promise<true | string[]>;
+  run(key: IKeys): Promise<string[]>;
 }
 
 export default Lints;

package/lib/eslint/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = __importDefault(require("./parser"));
+const runner_1 = __importDefault(require("../factory/runner"));
+class ESLintRunner extends runner_1.default {
+    constructor(opts) {
+        const { configPath, write } = opts;
+        const parser = new parser_1.default({
+            configPath,
+            write,
+            name: ESLintRunner.NAME,
+        });
+        const childOpts = {
+            parser,
+            name: ESLintRunner.NAME,
+            ignoreFiles: ESLintRunner.IGNORE_FILES,
+        };
+        super(opts, childOpts);
+    }
+}
+ESLintRunner.IGNORE_FILES = ['.eslintignore'];
+ESLintRunner.NAME = 'eslint';
+exports.default = ESLintRunner;

package/lib/eslint/parser.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ko_lint_config_1 = require("ko-lint-config");
+const parser_1 = __importDefault(require("../factory/parser"));
+class ESLintParser extends parser_1.default {
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.generateConfig();
+        this.initInstance();
+    }
+    initInstance() {
+        const { write } = this.opts;
+        this.eslintInstance = new ko_lint_config_1.eslint.ESLint({
+            fix: write,
+            overrideConfig: this.config,
+            useEslintrc: false,
+            extensions: ESLintParser.EXTENSIONS,
+        });
+    }
+    async format(file) {
+        const formatter = await this.eslintInstance.loadFormatter();
+        let resultText = '';
+        try {
+            const result = await this.eslintInstance.lintFiles(file);
+            if (result[0].errorCount) {
+                resultText = formatter.format(result);
+            }
+            return resultText;
+        }
+        catch (ex) {
+            console.log(ex);
+            process.exit(1);
+        }
+    }
+    generateConfig() {
+        if (this.opts.configPath) {
+            this.config = this.getConfigFromFile(this.opts.configPath);
+        }
+        else {
+            const localConfigPath = this.detectLocalRunnerConfig(this.opts.name);
+            if (localConfigPath) {
+                this.config = this.getConfigFromFile(localConfigPath);
+            }
+        }
+    }
+}
+ESLintParser.EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+exports.default = ESLintParser;

package/lib/factory/parser.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const assert_1 = __importDefault(require("assert"));
+class LintParserFactory {
+    constructor() {
+        this.cwd = process.cwd();
+    }
+    getConfigFromFile(filepath) {
+        (0, assert_1.default)((0, path_1.isAbsolute)(filepath), 'only accept absolute config filepath');
+        return require(filepath);
+    }
+    detectLocalRunnerConfig(name) {
+        const files = (0, fs_1.readdirSync)(this.cwd).filter(path => !(0, fs_1.statSync)(path).isDirectory());
+        let ret = '';
+        for (let file of files) {
+            if (file.includes(name) && !file.includes('ignore')) {
+                ret = file;
+                break;
+            }
+        }
+        return ret ? (0, path_1.join)(this.cwd, ret) : ret;
+    }
+}
+exports.default = LintParserFactory;

package/lib/factory/runner.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const perf_hooks_1 = require("perf_hooks");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const threads_1 = __importDefault(require("../threads"));
+class LintRunnerFactory {
+    constructor(opts, childOpts) {
+        this.cwd = process.cwd();
+        this.opts = opts;
+        this.childOpts = childOpts;
+        this.parser = childOpts.parser;
+    }
+    async getEntries(patterns, ignoreFiles) {
+        return (0, fast_glob_1.default)(patterns, {
+            dot: true,
+            ignore: this.getIgnorePatterns(...ignoreFiles),
+        });
+    }
+    getIgnorePatterns(...ignoreFiles) {
+        return ['.gitignore', ...ignoreFiles]
+            .map(fileName => {
+            const filePath = (0, path_1.join)(this.cwd, fileName);
+            if ((0, fs_1.existsSync)(filePath)) {
+                return (0, fs_1.readFileSync)(filePath, 'utf-8')
+                    .split('\n')
+                    .filter(str => str && !str.startsWith('#'));
+            }
+            return [];
+        })
+            .reduce((acc, current) => {
+            current.forEach(p => {
+                if (!acc.includes(p)) {
+                    acc.push(p);
+                }
+            });
+            return acc;
+        }, []);
+    }
+    getConcurrentNumber(num) {
+        return num ? num : (0, os_1.cpus)().length;
+    }
+    async run(entries) {
+        let ret;
+        const { concurrency } = this.opts;
+        if (concurrency) {
+            ret = await this.runInConcurrencyMode(entries);
+        }
+        else {
+            ret = await this.runInNormalMode(entries);
+        }
+        return ret;
+    }
+    async runInConcurrencyMode(entries) {
+        const { concurrentNumber, write, configPath } = this.opts;
+        const threads = new threads_1.default({
+            entries,
+            concurrentNumber: this.getConcurrentNumber(concurrentNumber),
+            write,
+            configPath,
+            name: this.childOpts.name,
+        });
+        return threads.batch();
+    }
+    async runInNormalMode(entries) {
+        const pList = entries.map(async (file) => await this.parser.format(file));
+        const result = await Promise.all(pList);
+        return result.filter(Boolean);
+    }
+    async start() {
+        const { patterns } = this.opts;
+        const { ignoreFiles, name } = this.childOpts;
+        const entries = await this.getEntries(patterns, ignoreFiles);
+        const totalCount = entries.length;
+        if (entries.length === 0) {
+            console.log(`No files matched with pattern:${patterns} via ${name}`);
+            process.exit(0);
+        }
+        const startTime = perf_hooks_1.performance.now();
+        const ret = await this.run(entries);
+        const endTime = perf_hooks_1.performance.now();
+        console.log(`exec ${name} with ${totalCount} files cost ${((endTime - startTime) /
+            1000).toFixed(2)}s`);
+        return ret;
+    }
+}
+exports.default = LintRunnerFactory;

package/lib/index.js

@@ -22,7 +22,6 @@ class Lints {
                 this.runner = new stylelint_1.default(this.opts);
                 break;
         }
-        this.runner.generateConfig();
         const result = await this.runner.start();
         return result;
     }

package/lib/prettier/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runner_1 = __importDefault(require("../factory/runner"));
+const parser_1 = __importDefault(require("./parser"));
+class PrettierRunner extends runner_1.default {
+    constructor(opts) {
+        const { configPath, write } = opts;
+        const parser = new parser_1.default({
+            configPath,
+            write,
+            name: PrettierRunner.NAME,
+        });
+        const childOpts = {
+            parser,
+            name: PrettierRunner.NAME,
+            ignoreFiles: PrettierRunner.IGNORE_FILES,
+        };
+        super(opts, childOpts);
+    }
+}
+PrettierRunner.IGNORE_FILES = ['.prettierignore'];
+PrettierRunner.NAME = 'prettier';
+exports.default = PrettierRunner;

package/lib/prettier/parser.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const ko_lint_config_1 = require("ko-lint-config");
+const parser_1 = __importDefault(require("../factory/parser"));
+const { format, check } = ko_lint_config_1.prettier;
+class PrettierParser extends parser_1.default {
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.generateConfig();
+    }
+    generateConfig() {
+        if (this.opts.configPath) {
+            this.config = this.getConfigFromFile(this.opts.configPath);
+        }
+        else {
+            const localConfigPath = this.detectLocalRunnerConfig(this.opts.name);
+            if (localConfigPath) {
+                this.config = this.getConfigFromFile(localConfigPath);
+            }
+        }
+    }
+    async format(file) {
+        const opts = { ...this.config, filepath: file };
+        let resultText = '';
+        try {
+            const source = await (0, promises_1.readFile)(file, 'utf-8');
+            if (this.opts.write) {
+                const formatContent = format(source, opts);
+                await (0, promises_1.writeFile)(file, formatContent, 'utf-8');
+            }
+            else {
+                if (!check(source, opts)) {
+                    resultText = `file ${opts.filepath} doesn't match ${this.opts.name} config`;
+                }
+            }
+            return resultText;
+        }
+        catch (ex) {
+            console.log(ex);
+            process.exit(1);
+        }
+    }
+}
+exports.default = PrettierParser;

package/lib/stylelint/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = __importDefault(require("./parser"));
+const runner_1 = __importDefault(require("../factory/runner"));
+class StyleLintRunner extends runner_1.default {
+    constructor(opts) {
+        const { configPath, write } = opts;
+        const parser = new parser_1.default({
+            configPath,
+            write,
+            name: StyleLintRunner.NAME,
+        });
+        const childOpts = {
+            parser,
+            name: StyleLintRunner.NAME,
+            ignoreFiles: StyleLintRunner.IGNORE_FILES,
+        };
+        super(opts, childOpts);
+    }
+}
+StyleLintRunner.IGNORE_FILES = ['.stylelintignore'];
+StyleLintRunner.NAME = 'stylelint';
+exports.default = StyleLintRunner;

package/lib/{stylelint.js → stylelint/parser.js}

@@ -4,12 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ko_lint_config_1 = require("ko-lint-config");
-const factory_1 = __importDefault(require("./factory"));
+const parser_1 = __importDefault(require("../factory/parser"));
 const { lint, formatters } = ko_lint_config_1.stylelint;
-class StyleLintRunner extends factory_1.default {
+class StyleLintParser extends parser_1.default {
     constructor(opts) {
         super();
-        this.stdout = [];
         this.opts = opts;
         this.generateConfig();
     }
@@ -18,34 +17,25 @@ class StyleLintRunner extends factory_1.default {
             this.config = this.getConfigFromFile(this.opts.configPath);
         }
         else {
-            const localConfigPath = this.detectLocalRunnerConfig(StyleLintRunner.NAME);
+            const localConfigPath = this.detectLocalRunnerConfig(this.opts.name);
             if (localConfigPath) {
                 this.config = this.getConfigFromFile(localConfigPath);
             }
         }
     }
-    async start() {
-        const { write, patterns } = this.opts;
-        const entries = await this.getEntries(patterns, [
-            ...StyleLintRunner.IGNORE_FILES,
-        ]);
-        if (entries.length === 0) {
-            console.log(`No files matched with pattern:${patterns} via ${StyleLintRunner.NAME}`);
-            process.exit(0);
-        }
+    async format(file) {
+        const { write } = this.opts;
+        let resultText = '';
         try {
             const result = await lint({
                 fix: write,
                 config: this.config,
-                files: entries,
+                files: file,
             });
             if (result.errored) {
-                this.stdout = [formatters.string(result.results)];
-                return this.stdout;
-            }
-            else {
-                return true;
+                resultText = formatters.string(result.results);
             }
+            return resultText;
         }
         catch (ex) {
             console.error(ex);
@@ -53,7 +43,4 @@ class StyleLintRunner extends factory_1.default {
         }
     }
 }
-StyleLintRunner.EXTENSIONS = ['css', 'less', 'sass', 'scss'];
-StyleLintRunner.IGNORE_FILES = ['.stylelintignore'];
-StyleLintRunner.NAME = 'stylelint';
-exports.default = StyleLintRunner;
+exports.default = StyleLintParser;

package/lib/threads/Pool.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const worker_threads_1 = require("worker_threads");
+class ThreadPool {
+    constructor(opts) {
+        this.workers = [];
+        this.workerPList = [];
+        this.stdout = [];
+        console.log('Using Multithreading...');
+        this.opts = opts;
+        this.queue = this.opts.entries;
+        this.format();
+    }
+    format() {
+        const { concurrentNumber, configPath, write, name } = this.opts;
+        if (this.workers.length < concurrentNumber) {
+            this.workerPList.push(this.createWorker({
+                configPath,
+                write,
+                name,
+            }));
+            this.format();
+        }
+    }
+    createWorker(opts) {
+        const worker = new worker_threads_1.Worker((0, path_1.join)(__dirname, './Worker.js'), {
+            workerData: {
+                opts,
+            },
+        });
+        return new Promise(resolve => {
+            worker.postMessage(this.queue.shift());
+            worker.on('message', (result) => {
+                this.stdout.push(result);
+                if (this.queue.length === 0) {
+                    resolve(true);
+                }
+                else {
+                    const next = this.queue.shift();
+                    worker.postMessage(next);
+                }
+            });
+            worker.on('error', err => {
+                console.log(err);
+                process.exit(1);
+            });
+            this.workers.push(worker);
+        });
+    }
+    async exec() {
+        return Promise.all(this.workerPList).then(() => {
+            return this.stdout;
+        });
+    }
+}
+exports.default = ThreadPool;

package/lib/threads/Worker.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+let parser;
+switch (worker_threads_1.workerData.opts.name) {
+    case 'eslint':
+        const ESLintParser = require('../eslint/parser').default;
+        parser = new ESLintParser(worker_threads_1.workerData.opts);
+        break;
+    case 'prettier':
+        const PrettierParser = require('../prettier/parser').default;
+        parser = new PrettierParser(worker_threads_1.workerData.opts);
+        break;
+    case 'stylelint':
+        const StyleParser = require('../stylelint/parser').default;
+        parser = new StyleParser(worker_threads_1.workerData.opts);
+        break;
+}
+worker_threads_1.parentPort?.on('message', async (file) => {
+    const result = await parser.format(file);
+    worker_threads_1.parentPort?.postMessage(result);
+});

package/lib/threads/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Pool_1 = __importDefault(require("./Pool"));
+class MultiThreading {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async batch() {
+        const pool = new Pool_1.default(this.opts);
+        return await pool.exec();
+    }
+}
+exports.default = MultiThreading;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ko-lints",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "lint tools used by ko",
   "keywords": [
     "ko",
@@ -29,15 +29,15 @@
     "fast-glob": "^3.2.11"
   },
   "peerDependencies": {
-    "ko-lint-config": "1.0.0"
+    "ko-lint-config": "2.1.0"
   },
   "devDependencies": {
     "typescript": "^4.6.4",
-    "ko-lint-config": "1.0.0"
+    "ko-lint-config": "2.1.0"
   },
   "scripts": {
     "build": "tsc",
-    "debug": "tsc --sourcemap -w"
+    "debug": "rm -rf lib && tsc --sourcemap -w"
   },
   "readme": "# ko-lint\n\nThis package is used by [ko](https://github.com/DTStack/ko)\n"
 }

package/lib/eslint.js

@@ -1,70 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ko_lint_config_1 = require("ko-lint-config");
-const factory_1 = __importDefault(require("./factory"));
-const { ESLint } = ko_lint_config_1.eslint;
-class ESlintRunner extends factory_1.default {
-    constructor(opts) {
-        super();
-        this.stdout = [];
-        this.opts = opts;
-        this.generateConfig();
-    }
-    generateConfig() {
-        if (this.opts.configPath) {
-            this.config = this.getConfigFromFile(this.opts.configPath);
-        }
-        else {
-            const localConfigPath = this.detectLocalRunnerConfig('eslint');
-            if (localConfigPath) {
-                this.config = this.getConfigFromFile(localConfigPath);
-            }
-        }
-    }
-    async start() {
-        const { write, patterns } = this.opts;
-        const entries = await this.getEntries(patterns, [
-            ...ESlintRunner.IGNORE_FILES,
-        ]);
-        if (entries.length === 0) {
-            console.log(`No files matched with pattern:${patterns} via ${ESlintRunner.NAME}`);
-            process.exit(0);
-        }
-        const eslintInstance = new ESLint({
-            fix: write,
-            overrideConfig: this.config,
-            useEslintrc: false,
-            extensions: ESlintRunner.EXTENSIONS,
-        });
-        try {
-            const formatter = await eslintInstance.loadFormatter();
-            const eslintFilesPromises = entries.map(async (file) => {
-                const result = await eslintInstance.lintFiles(file);
-                if (result[0].errorCount) {
-                    const resultText = formatter.format(result);
-                    this.stdout.push(resultText);
-                    return false;
-                }
-                return true;
-            });
-            const result = await Promise.all(eslintFilesPromises);
-            if (result.includes(false)) {
-                return this.stdout;
-            }
-            else {
-                return true;
-            }
-        }
-        catch (ex) {
-            console.error(ex);
-            process.exit(1);
-        }
-    }
-}
-ESlintRunner.EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
-ESlintRunner.IGNORE_FILES = ['.eslintignore'];
-ESlintRunner.NAME = 'eslint';
-exports.default = ESlintRunner;

package/lib/factory.js

@@ -1,57 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const fs_1 = require("fs");
-const assert_1 = __importDefault(require("assert"));
-const fast_glob_1 = __importDefault(require("fast-glob"));
-class LintRunnerFactory {
-    constructor() {
-        this.cwd = process.cwd();
-    }
-    async getEntries(patterns, ignoreFiles) {
-        return (0, fast_glob_1.default)(patterns, {
-            dot: true,
-            ignore: this.getIgnorePatterns(...ignoreFiles),
-        });
-    }
-    getIgnorePatterns(...ignoreFiles) {
-        return ['.gitignore', ...ignoreFiles]
-            .map(fileName => {
-            const filePath = (0, path_1.join)(this.cwd, fileName);
-            if ((0, fs_1.existsSync)(filePath)) {
-                return (0, fs_1.readFileSync)(filePath, 'utf-8')
-                    .split('\n')
-                    .filter(str => str && !str.startsWith('#'));
-            }
-            return [];
-        })
-            .reduce((acc, current) => {
-            current.forEach(p => {
-                if (!acc.includes(p)) {
-                    acc.push(p);
-                }
-            });
-            return acc;
-        }, []);
-    }
-    getConfigFromFile(filepath) {
-        (0, assert_1.default)((0, path_1.isAbsolute)(filepath), 'only accept absolute config filepath');
-        return require(filepath);
-    }
-    detectLocalRunnerConfig(name) {
-        const cwd = process.cwd();
-        const files = (0, fs_1.readdirSync)(cwd).filter(path => !(0, fs_1.statSync)(path).isDirectory());
-        let ret = '';
-        for (let file of files) {
-            if (file.includes(name) && !file.includes('ignore')) {
-                ret = file;
-                break;
-            }
-        }
-        return ret ? (0, path_1.join)(cwd, ret) : ret;
-    }
-}
-exports.default = LintRunnerFactory;

package/lib/prettier.js

@@ -1,73 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const promises_1 = require("fs/promises");
-const ko_lint_config_1 = require("ko-lint-config");
-const factory_1 = __importDefault(require("./factory"));
-const { format, check } = ko_lint_config_1.prettier;
-class PrettierRunner extends factory_1.default {
-    constructor(opts) {
-        super();
-        this.stdout = [];
-        this.opts = opts;
-        this.generateConfig();
-    }
-    generateConfig() {
-        if (this.opts.configPath) {
-            this.config = this.getConfigFromFile(this.opts.configPath);
-        }
-        else {
-            const localConfigPath = this.detectLocalRunnerConfig('prettier');
-            if (localConfigPath) {
-                this.config = this.getConfigFromFile(localConfigPath);
-            }
-        }
-    }
-    async start() {
-        const { write, patterns } = this.opts;
-        const entries = await this.getEntries(patterns, [
-            ...PrettierRunner.IGNORE_FILES,
-        ]);
-        if (entries.length === 0) {
-            console.log(`No files matched with pattern:${patterns} via ${PrettierRunner.NAME}`);
-            process.exit(0);
-        }
-        try {
-            const formatFilesPromises = entries.map(async (file) => {
-                const source = await (0, promises_1.readFile)(file, 'utf-8');
-                const opts = { ...this.config, filepath: file };
-                if (write) {
-                    const formatContent = format(source, opts);
-                    await (0, promises_1.writeFile)(file, formatContent, 'utf-8');
-                    return true;
-                }
-                else {
-                    if (check(source, opts)) {
-                        return true;
-                    }
-                    else {
-                        this.stdout.push(`file ${opts.filepath} doesn't match prettier config`);
-                        return false;
-                    }
-                }
-            });
-            const result = await Promise.all(formatFilesPromises);
-            if (result.includes(false)) {
-                return this.stdout;
-            }
-            else {
-                return true;
-            }
-        }
-        catch (ex) {
-            console.error(ex);
-            process.exit(1);
-        }
-    }
-}
-PrettierRunner.EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'json'];
-PrettierRunner.IGNORE_FILES = ['.prettierignore'];
-PrettierRunner.NAME = 'prettier';
-exports.default = PrettierRunner;