style: add lint

Author: mapleeit

.editorconfig

@@ -5,7 +5,7 @@ root = true
 [*]
 charset = utf-8
 indent_style = space
-indent_size = 4
+indent_size = 2
 end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true

.eslintrc

@@ -0,0 +1,20 @@
+{
+  "extends": [
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "tsconfig.json"
+  },
+  "plugins": [
+    "@typescript-eslint",
+    "eslint-plugin-import",
+    "eslint-plugin-eslint-comments",
+    "eslint-plugin-jsdoc"
+  ],
+  "env": {
+    "node": true,
+    "jest": true
+  },
+  "rules": {}
+}

.github/workflows/lint-and-test-code.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - master
       - release
+      - 2.0
 
 jobs:
   lint-code:

.prettierrc.yml

@@ -1,4 +1,4 @@
-trailingComma: "all"
-tabWidth: 4
-semi: false
-singleQuote: true
+trailingComma: "none"
+tabWidth: 2
+semi: true
+doubleQuote: true

import-sorter.json

@@ -1,31 +1,27 @@
-// import logger from '../../logger/index'
-import { consoleHack } from '../../runtime/console.hack'
+import { consoleHack } from "../../runtime/console.hack";
 
 // jest.mock('../../logger/index')
 
 beforeAll(() => {
-    consoleHack()
-})
+  consoleHack();
+});
 
-const writeLog = jest.fn((level, info) => {
-    return `${level}: ${info}`
-})
+describe("console hack test", () => {
+  test("ensure console contains all origin functions", () => {
+    expect(typeof console.originDebug).toBe("function");
+    expect(typeof console.originLog).toBe("function");
+    expect(typeof console.originInfo).toBe("function");
+    expect(typeof console.originDir).toBe("function");
+    expect(typeof console.originWarn).toBe("function");
+    expect(typeof console.originError).toBe("function");
+  });
 
-describe('console hack test', () => {
-    test('ensure console contains all origin functions', () => {
-        expect(typeof console.originDebug).toBe('function')
-        expect(typeof console.originLog).toBe('function')
-        expect(typeof console.originInfo).toBe('function')
-        expect(typeof console.originDir).toBe('function')
-        expect(typeof console.originWarn).toBe('function')
-        expect(typeof console.originError).toBe('function')
-    })
-    test('console.debug should be logged by logger', () => {
-        console.debug('test_log')
-        console.log('test_log')
-        console.info('test_log')
-        console.dir('test_log')
-        console.warn('test_log')
-        console.error('test_log')
-    })
-})
+  test("console.debug should be logged by logger", () => {
+    console.debug("test_log");
+    console.log("test_log");
+    console.info("test_log");
+    console.dir("test_log");
+    console.warn("test_log");
+    console.error("test_log");
+  });
+});

lib/core/__test__/add.test.ts

@@ -1,74 +1,74 @@
-import { lookup, promises as dnsPromises } from 'dns'
-import { isIP } from 'net'
+import { lookup } from "dns";
+import { isIP } from "net";
 
-import { eventBus } from '../../bus'
-import { dnsHack } from '../../runtime/dns.hack'
+import { eventBus } from "../../bus";
+import { dnsHack } from "../../runtime/dns.hack";
 
 beforeAll(() => {
-    dnsHack()
-})
+  dnsHack();
+});
 
-describe('dns hack test', () => {
-    test('dns could work normally', async () => {
-        await new Promise((resolve, reject) => {
-            lookup('qq.com', (err, address, family) => {
-                expect(err).toBeNull()
-                expect(isIP(address)).toBeTruthy()
-                expect(family).toBeTruthy()
-                resolve()
-            })
-        })
-    })
+describe("dns hack test", () => {
+  test("dns could work normally", async () => {
+    await new Promise((resolve) => {
+      lookup("qq.com", (err, address, family) => {
+        expect(err).toBeNull();
+        expect(isIP(address)).toBeTruthy();
+        expect(family).toBeTruthy();
+        resolve();
+      });
+    });
+  });
 
-    test('eventBus was informed', async () => {
-        await new Promise((resolve, reject) => {
-            eventBus.on('DNS_LOOKUP_SUCCESS', data => {
-                resolve(data)
-            })
+  test("eventBus was informed", async () => {
+    await new Promise((resolve, reject) => {
+      eventBus.on("DNS_LOOKUP_SUCCESS", data => {
+        resolve(data);
+      });
 
-            eventBus.on('DNS_LOOKUP_ERROR', err => {
-                reject(err)
-            })
+      eventBus.on("DNS_LOOKUP_ERROR", err => {
+        reject(err);
+      });
 
-            lookup('qq.com', () => {
-                // nothing
-            })
-        })
-    })
+      lookup("qq.com", () => {
+        // nothing
+      });
+    });
+  });
 
-    test('ipv4 should return immediately', async () => {
-        await new Promise((resolve, reject) => {
-            const ip = '1.2.3.4'
-            lookup(ip, (err, address, family) => {
-                expect(err).toBeNull()
-                expect(address).toEqual(ip)
-                expect(family).toBeTruthy()
-                resolve()
-            })
-        })
-    })
+  test("ipv4 should return immediately", async () => {
+    await new Promise((resolve) => {
+      const ip = "1.2.3.4";
+      lookup(ip, (err, address, family) => {
+        expect(err).toBeNull();
+        expect(address).toEqual(ip);
+        expect(family).toBeTruthy();
+        resolve();
+      });
+    });
+  });
 
-    test('ipv6 should return immediately', async () => {
-        await new Promise((resolve, reject) => {
-            const ip = '::ffff:192.0.2.128'
-            lookup(ip, (err, address, family) => {
-                expect(err).toBeNull()
-                expect(address).toEqual(ip)
-                expect(family).toBeTruthy()
-                resolve()
-            })
-        })
-    })
+  test("ipv6 should return immediately", async () => {
+    await new Promise((resolve) => {
+      const ip = "::ffff:192.0.2.128";
+      lookup(ip, (err, address, family) => {
+        expect(err).toBeNull();
+        expect(address).toEqual(ip);
+        expect(family).toBeTruthy();
+        resolve();
+      });
+    });
+  });
 
-    test('a wrong domain should fail', async () => {
-        await new Promise((resolve, reject) => {
-            const nullDomain = 'this.is.not.a.domain'
-            lookup(nullDomain, (err, address, family) => {
-                // error could be "Dns Lookup Timeout"
-                // or "getaddrinfo ENOTFOUND this.is.not.a.domain"
-                expect(err).toBeTruthy()
-                resolve()
-            })
-        })
-    })
-})
+  test("a wrong domain should fail", async () => {
+    await new Promise((resolve) => {
+      const nullDomain = "this.is.not.a.domain";
+      lookup(nullDomain, (err) => {
+        // error could be "Dns Lookup Timeout"
+        // or "getaddrinfo ENOTFOUND this.is.not.a.domain"
+        expect(err).toBeTruthy();
+        resolve();
+      });
+    });
+  });
+});

lib/core/__test__/runtime/console.hack.test.ts

@@ -1,18 +1,18 @@
-import { EventEmitter } from 'events'
+import { EventEmitter } from "events";
 
 export enum EVENT_LIST {
-    DNS_LOOKUP_SUCCESS = 'DNS_LOOKUP_SUCCESS',
-    DNS_LOOKUP_ERROR = 'DNS_LOOKUP_ERROR',
+  DNS_LOOKUP_SUCCESS = "DNS_LOOKUP_SUCCESS",
+  DNS_LOOKUP_ERROR = "DNS_LOOKUP_ERROR"
 }
 
-export interface IEventPayload {
-    error: Error | null
-    code: number
-    msg: string
-    success: boolean
-    data: any | null
+export interface EventPayload {
+  error: Error | null;
+  code: number;
+  msg: string;
+  success: boolean;
+  data: any | null;
 }
 
-let bus: EventEmitter
+let bus: EventEmitter | undefined;
 
-export const eventBus = bus ? bus : (bus = new EventEmitter())
+export const eventBus = bus ? bus : (bus = new EventEmitter());

lib/core/__test__/runtime/dns.hack.test.ts

@@ -1,5 +1,5 @@
 export const config = {
-    timeout: {
-        dns: 3000,
-    },
-}
+  timeout: {
+    dns: 3000
+  }
+};

lib/core/add.ts

@@ -1,17 +1,20 @@
 class Logger {
-    writeLog(level: any, info: any) {}
-    debug(str: string) {
-        console.debug(str)
-    }
-    error(str: string) {
-        console.error(str)
-    }
+  writeLog(level: any, info: any) {
+    // do nothing
+  }
+  debug(str: string) {
+    console.debug(str);
+  }
+
+  error(str: string) {
+    console.error(str);
+  }
 }
 
-let logger
+let logger: Logger;
 
 if (!logger) {
-    logger = new Logger()
+  logger = new Logger();
 }
 
-export default logger
+export default logger;