chore: migrate to ESLint and upgrade tools

Author: felixfbecker

.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@sourcegraph/eslint-config",
+  "parserOptions": {
+    "project": "tsconfig.json"
+  }
+}

.prettierignore

@@ -1,3 +1,4 @@
+.nyc_output/
 package.json
 package-lock.json
 dist/

.travis.yml

@@ -11,7 +11,7 @@ jobs:
     - stage: test
       script:
         - yarn run prettier-check
-        - yarn run tslint
+        - yarn run eslint
         - yarn run build
         - yarn test
         - nyc report --reporter json

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

.vscode/tasks.json

@@ -0,0 +1,24 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "eslint",
+      "problemMatcher": ["$eslint-stylish"],
+      "label": "npm: eslint",
+      "detail": "eslint './src/*.ts?(x)'"
+    },
+    {
+      "type": "npm",
+      "script": "watch",
+      "problemMatcher": ["$tsc-watch"],
+      "group": "build",
+      "label": "npm: watch",
+      "detail": "tsc -p . -w",
+      "isBackground": true,
+      "runOptions": {
+        "runOn": "folderOpen"
+      }
+    }
+  ]
+}

package.json

@@ -17,7 +17,7 @@
     "semantic-release": "semantic-release",
     "prettier": "prettier '**/{*.{js?(on),ts?(x),scss},.*.js?(on)}' --write --list-different",
     "prettier-check": "npm run prettier -- --write=false",
-    "tslint": "tslint -c tslint.json -p tsconfig.json './src/*.ts?(x)' './*.ts?(x)'",
+    "eslint": "eslint './src/*.ts?(x)'",
     "build": "tsc -p .",
     "watch": "tsc -p . -w"
   },
@@ -49,19 +49,19 @@
   "devDependencies": {
     "@commitlint/cli": "^9.0.1",
     "@commitlint/config-conventional": "^9.0.1",
+    "@sourcegraph/eslint-config": "^0.19.15",
     "@sourcegraph/prettierrc": "^2.2.0",
     "@sourcegraph/tsconfig": "^4.0.1",
-    "@sourcegraph/tslint-config": "^13.4.0",
     "@types/mocha": "7.0.2",
+    "eslint": "^7.4.0",
     "husky": "^2.1.0",
     "mocha": "^6.1.4",
     "nyc": "^14.1.0",
-    "prettier": "^1.19.1",
+    "prettier": "^2.0.5",
     "semantic-release": "^15.13.3",
     "sourcegraph": "^24.6.0",
     "ts-node": "^8.1.0",
-    "tslint": "^6.1.2",
-    "typescript": "^3.4.5"
+    "typescript": "^3.9.6"
   },
   "husky": {
     "hooks": {

src/enums.ts

@@ -1,5 +1,4 @@
 /* istanbul ignore file */
-// tslint:disable: no-object-literal-type-assertion https://github.com/palantir/tslint/issues/4628
 
 import * as sourcegraph from 'sourcegraph'
 

src/location.ts

@@ -4,7 +4,7 @@ import { Range } from './range'
 import { isURL } from './url'
 
 export class Location implements sourcegraph.Location {
-    public static isLocation(thing: any): thing is sourcegraph.Location {
+    public static isLocation(thing: unknown): thing is sourcegraph.Location {
         if (thing instanceof Location) {
             return true
         }
@@ -24,7 +24,7 @@ export class Location implements sourcegraph.Location {
         } else if (rangeOrPosition instanceof Position) {
             this.range = new Range(rangeOrPosition, rangeOrPosition)
         } else {
-            throw new Error('Illegal argument')
+            throw new TypeError('Illegal argument')
         }
     }
 

src/position.test.ts

@@ -7,114 +7,114 @@ suite('Position', () => {
         assert.throws(() => new Position(-1, 0))
         assert.throws(() => new Position(0, -1))
 
-        const pos = new Position(0, 0)
-        assert.throws(() => ((pos as any).line = -1))
-        assert.throws(() => ((pos as any).character = -1))
-        assert.throws(() => ((pos as any).line = 12))
+        const position = new Position(0, 0)
+        assert.throws(() => ((position as any).line = -1))
+        assert.throws(() => ((position as any).character = -1))
+        assert.throws(() => ((position as any).line = 12))
 
-        const { line, character } = pos.toJSON()
+        const { line, character } = position.toJSON()
         assert.strictEqual(line, 0)
         assert.strictEqual(character, 0)
     })
 
     test('toJSON', () => {
-        const pos = new Position(4, 2)
-        assertToJSON(pos, { line: 4, character: 2 })
+        const position = new Position(4, 2)
+        assertToJSON(position, { line: 4, character: 2 })
     })
 
     test('isBefore(OrEqual)?', () => {
-        const p1 = new Position(1, 3)
-        const p2 = new Position(1, 2)
-        const p3 = new Position(0, 4)
-
-        assert(p1.isBeforeOrEqual(p1))
-        assert(!p1.isBefore(p1))
-        assert(p2.isBefore(p1))
-        assert(p3.isBefore(p2))
+        const position1 = new Position(1, 3)
+        const position2 = new Position(1, 2)
+        const position3 = new Position(0, 4)
+
+        assert(position1.isBeforeOrEqual(position1))
+        assert(!position1.isBefore(position1))
+        assert(position2.isBefore(position1))
+        assert(position3.isBefore(position2))
     })
 
     test('isAfter(OrEqual)?', () => {
-        const p1 = new Position(1, 3)
-        const p2 = new Position(1, 2)
-        const p3 = new Position(0, 4)
-
-        assert(p1.isAfterOrEqual(p1))
-        assert(!p1.isAfter(p1))
-        assert(p1.isAfter(p2))
-        assert(p2.isAfter(p3))
-        assert(p1.isAfter(p3))
+        const position1 = new Position(1, 3)
+        const position2 = new Position(1, 2)
+        const position3 = new Position(0, 4)
+
+        assert(position1.isAfterOrEqual(position1))
+        assert(!position1.isAfter(position1))
+        assert(position1.isAfter(position2))
+        assert(position2.isAfter(position3))
+        assert(position1.isAfter(position3))
     })
 
     test('compareTo', () => {
-        const p1 = new Position(1, 3)
-        const p2 = new Position(1, 2)
-        const p3 = new Position(0, 4)
-
-        assert.strictEqual(p1.compareTo(p1), 0)
-        assert.strictEqual(p2.compareTo(p1), -1)
-        assert.strictEqual(p1.compareTo(p2), 1)
-        assert.strictEqual(p2.compareTo(p3), 1)
-        assert.strictEqual(p1.compareTo(p3), 1)
+        const position1 = new Position(1, 3)
+        const position2 = new Position(1, 2)
+        const position3 = new Position(0, 4)
+
+        assert.strictEqual(position1.compareTo(position1), 0)
+        assert.strictEqual(position2.compareTo(position1), -1)
+        assert.strictEqual(position1.compareTo(position2), 1)
+        assert.strictEqual(position2.compareTo(position3), 1)
+        assert.strictEqual(position1.compareTo(position3), 1)
     })
 
     test('translate', () => {
-        const p1 = new Position(1, 3)
-
-        assert(p1.translate() === p1)
-        assert(p1.translate({}) === p1)
-        assert(p1.translate(0, 0) === p1)
-        assert(p1.translate(0) === p1)
-        assert(p1.translate(undefined, 0) === p1)
-        assert(p1.translate(undefined) === p1)
-
-        let res = p1.translate(-1)
-        assert.strictEqual(res.line, 0)
-        assert.strictEqual(res.character, 3)
-
-        res = p1.translate({ lineDelta: -1 })
-        assert.strictEqual(res.line, 0)
-        assert.strictEqual(res.character, 3)
-
-        res = p1.translate(undefined, -1)
-        assert.strictEqual(res.line, 1)
-        assert.strictEqual(res.character, 2)
-
-        res = p1.translate({ characterDelta: -1 })
-        assert.strictEqual(res.line, 1)
-        assert.strictEqual(res.character, 2)
-
-        res = p1.translate(11)
-        assert.strictEqual(res.line, 12)
-        assert.strictEqual(res.character, 3)
-
-        assert.throws(() => p1.translate(null as any))
-        assert.throws(() => p1.translate(null as any, null as any))
-        assert.throws(() => p1.translate(-2))
-        assert.throws(() => p1.translate({ lineDelta: -2 }))
-        assert.throws(() => p1.translate(-2, null as any))
-        assert.throws(() => p1.translate(0, -4))
+        const position1 = new Position(1, 3)
+
+        assert(position1.translate() === position1)
+        assert(position1.translate({}) === position1)
+        assert(position1.translate(0, 0) === position1)
+        assert(position1.translate(0) === position1)
+        assert(position1.translate(undefined, 0) === position1)
+        assert(position1.translate(undefined) === position1)
+
+        let translated = position1.translate(-1)
+        assert.strictEqual(translated.line, 0)
+        assert.strictEqual(translated.character, 3)
+
+        translated = position1.translate({ lineDelta: -1 })
+        assert.strictEqual(translated.line, 0)
+        assert.strictEqual(translated.character, 3)
+
+        translated = position1.translate(undefined, -1)
+        assert.strictEqual(translated.line, 1)
+        assert.strictEqual(translated.character, 2)
+
+        translated = position1.translate({ characterDelta: -1 })
+        assert.strictEqual(translated.line, 1)
+        assert.strictEqual(translated.character, 2)
+
+        translated = position1.translate(11)
+        assert.strictEqual(translated.line, 12)
+        assert.strictEqual(translated.character, 3)
+
+        assert.throws(() => position1.translate(null as any))
+        assert.throws(() => position1.translate(null as any, null as any))
+        assert.throws(() => position1.translate(-2))
+        assert.throws(() => position1.translate({ lineDelta: -2 }))
+        assert.throws(() => position1.translate(-2, null as any))
+        assert.throws(() => position1.translate(0, -4))
     })
 
     test('with', () => {
-        const p1 = new Position(1, 3)
-
-        assert(p1.with() === p1)
-        assert(p1.with(1) === p1)
-        assert(p1.with(undefined, 3) === p1)
-        assert(p1.with(1, 3) === p1)
-        assert(p1.with(undefined) === p1)
-        assert(p1.with({ line: 1 }) === p1)
-        assert(p1.with({ character: 3 }) === p1)
-        assert(p1.with({ line: 1, character: 3 }) === p1)
-
-        const p2 = p1.with({ line: 0, character: 11 })
-        assert.strictEqual(p2.line, 0)
-        assert.strictEqual(p2.character, 11)
-
-        assert.throws(() => p1.with(null as any))
-        assert.throws(() => p1.with(-9))
-        assert.throws(() => p1.with(0, -9))
-        assert.throws(() => p1.with({ line: -1 }))
-        assert.throws(() => p1.with({ character: -1 }))
+        const position1 = new Position(1, 3)
+
+        assert(position1.with() === position1)
+        assert(position1.with(1) === position1)
+        assert(position1.with(undefined, 3) === position1)
+        assert(position1.with(1, 3) === position1)
+        assert(position1.with(undefined) === position1)
+        assert(position1.with({ line: 1 }) === position1)
+        assert(position1.with({ character: 3 }) === position1)
+        assert(position1.with({ line: 1, character: 3 }) === position1)
+
+        const position2 = position1.with({ line: 0, character: 11 })
+        assert.strictEqual(position2.line, 0)
+        assert.strictEqual(position2.character, 11)
+
+        assert.throws(() => position1.with(null as any))
+        assert.throws(() => position1.with(-9))
+        assert.throws(() => position1.with(0, -9))
+        assert.throws(() => position1.with({ line: -1 }))
+        assert.throws(() => position1.with({ character: -1 }))
     })
 })

src/position.ts

@@ -9,9 +9,9 @@ export class Position implements sourcegraph.Position {
         if (result === undefined) {
             return undefined
         }
-        for (const p of positions) {
-            if (p.isBefore(result)) {
-                result = p
+        for (const position of positions) {
+            if (position.isBefore(result)) {
+                result = position
             }
         }
         return result
@@ -24,9 +24,9 @@ export class Position implements sourcegraph.Position {
         if (result === undefined) {
             return undefined
         }
-        for (const p of positions) {
-            if (p.isAfter(result)) {
-                result = p
+        for (const position of positions) {
+            if (position.isAfter(result)) {
+                result = position
             }
         }
         return result