feat: Convert to TypeScript

.eslintrc.json

@@ -1,17 +1,8 @@
 {
-  "root": true,
-  "globals": {
-    "atom": true
-  },
-  "extends": "steelbrain",
+  "extends": "eslint-config-atomic/react",
+  "ignorePatterns": ["dist/", "node_modules/"],
   "rules": {
-    "global-require": "off",
-    "no-param-reassign": "off",
-    "no-underscore-dangle": "off",
-    "no-duplicate-imports": "off",
-    "import/prefer-default-export": "off",
-    "import/no-unresolved": ["error", {
-      "ignore": ["atom"]
-    }]
+    "@typescript-eslint/no-inferrable-types": "off",
+    "@typescript-eslint/no-non-null-assertion": "off"
   }
 }

.prettierignore

@@ -0,0 +1,8 @@
+node_modules
+package.json
+package-lock.json
+pnpm-lock.yaml
+changelog.md
+coverage
+build
+dist

lib/commands.js → lib/commands.ts

@@ -1,16 +1,14 @@
-/* @flow */
-
 import { CompositeDisposable, Emitter } from 'atom'
 import type { Disposable } from 'atom'
 
 import * as Helpers from './helpers'
 import type { Linter, UI } from './types'
 import type IndieDelegate from './indie-delegate'
 
-let manifest
+let manifest: {version: number}
 
-function formatItem(item) {
-  let itemName
+function formatItem(item: {name: string} | string) {
+  let itemName: string
   if (item && typeof item === 'object' && typeof item.name === 'string') {
     itemName = item.name
   } else if (typeof item === 'string') {
@@ -20,7 +18,7 @@ function formatItem(item) {
   }
   return `  - ${itemName}`
 }
-function sortByName(item1, item2) {
+function sortByName(item1: {name: string}, item2: {name: string}) {
   return item1.name.localeCompare(item2.name)
 }
 
@@ -84,10 +82,7 @@ export default class Commands {
 
     const ignoreGlob = atom.config.get('linter.ignoreGlob')
     const ignoreVCSIgnoredPaths = atom.config.get('core.excludeVcsIgnoredPaths')
-    const disabledLinters = atom.config
-      .get('linter.disabledProviders')
-      .map(formatItem)
-      .join('\n')
+    const disabledLinters = atom.config.get('linter.disabledProviders').map(formatItem).join('\n')
     const filePathIgnored = Helpers.isPathIgnored(textEditor.getPath(), ignoreGlob, ignoreVCSIgnoredPaths)
 
     atom.notifications.addInfo('Linter Debug Info', {
@@ -108,16 +103,16 @@ export default class Commands {
       dismissable: true,
     })
   }
-  onShouldLint(callback: Function): Disposable {
+  onShouldLint(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('should-lint', callback)
   }
-  onShouldDebug(callback: Function): Disposable {
+  onShouldDebug(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('should-debug', callback)
   }
-  onShouldToggleActiveEditor(callback: Function): Disposable {
+  onShouldToggleActiveEditor(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('should-toggle-active-editor', callback)
   }
-  onShouldToggleLinter(callback: Function): Disposable {
+  onShouldToggleLinter(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('should-toggle-linter', callback)
   }
   dispose() {

lib/editor-linter.js → lib/editor-linter.ts

@@ -1,9 +1,6 @@
-/* @flow */
-
 import { Emitter, CompositeDisposable, Disposable } from 'atom'
 import debounce from 'lodash/debounce'
 import type { TextEditor } from 'atom'
-import { subscriptiveObserve } from './helpers'
 
 export default class EditorLinter {
   editor: TextEditor
@@ -36,7 +33,7 @@ export default class EditorLinter {
     // NOTE: TextEditor::onDidChange immediately invokes the callback if the text editor was *just* created
     // Using TextBuffer::onDidChange doesn't have the same behavior so using it instead.
     this.subscriptions.add(
-      subscriptiveObserve(atom.config, 'linter.lintOnChangeInterval', interval =>
+      this.subscriptiveObserve(atom.config, 'linter.lintOnChangeInterval', interval =>
         editorBuffer.onDidChange(
           debounce(() => {
             this.emitter.emit('should-lint', true)
@@ -51,15 +48,38 @@ export default class EditorLinter {
   lint(onChange: boolean = false) {
     this.emitter.emit('should-lint', onChange)
   }
-  onShouldLint(callback: Function): Disposable {
+  onShouldLint(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('should-lint', callback)
   }
-  onDidDestroy(callback: Function): Disposable {
+  onDidDestroy(callback: (...args: Array<any>) => any): Disposable {
     return this.emitter.on('did-destroy', callback)
   }
   dispose() {
     this.emitter.emit('did-destroy')
     this.subscriptions.dispose()
     this.emitter.dispose()
   }
+
+
+  subscriptiveObserve(
+    object: Record<string, any>,
+    eventName: string,
+    callback: (...args: Array<any>) => any,
+  ): Disposable {
+    let subscription: Disposable | null = null
+    const eventSubscription = object.observe(eventName, (props: Record<string, any>) => {
+      if (subscription) {
+        subscription.dispose()
+      }
+      // TODO what is this?!
+      subscription = callback.call(this, props)
+    })
+
+    return new Disposable(function () {
+      eventSubscription.dispose()
+      if (subscription) {
+        subscription.dispose()
+      }
+    })
+  }
 }

lib/editor-registry.js → lib/editor-registry.ts

@@ -1,5 +1,3 @@
-/* @flow */
-
 import { Emitter, CompositeDisposable } from 'atom'
 import type { Disposable, TextEditor } from 'atom'
 import EditorLinter from './editor-linter'
@@ -29,7 +27,7 @@ class EditorRegistry {
       }),
     )
   }
-  get(textEditor: TextEditor): ?EditorLinter {
+  get(textEditor: TextEditor): EditorLinter | null | undefined {
     return this.editorLinters.get(textEditor)
   }
   createFromTextEditor(textEditor: TextEditor): EditorLinter {

lib/helpers.js → lib/helpers.ts

@@ -1,7 +1,5 @@
-/* @flow */
-
 import arrayUnique from 'lodash/uniq'
-import { Disposable, Range, Point } from 'atom'
+import { Range, Point } from 'atom'
 import type { TextEditor } from 'atom'
 import type { Linter, Message } from './types'
 
@@ -14,7 +12,7 @@ export function shouldTriggerLinter(linter: Linter, wasTriggeredOnChange: boolea
   if (wasTriggeredOnChange && !linter.lintsOnChange) {
     return false
   }
-  return scopes.some(function(scope) {
+  return scopes.some(function (scope) {
     return linter.grammarScopes.includes(scope)
   })
 }
@@ -25,8 +23,8 @@ export function getEditorCursorScopes(textEditor: TextEditor): Array<string> {
   )
 }
 
-let minimatch
-export function isPathIgnored(filePath: ?string, ignoredGlob: string, ignoredVCS: boolean): boolean {
+let minimatch: typeof import('minimatch')
+export function isPathIgnored(filePath: string | null | undefined, ignoredGlob: string, ignoredVCS: boolean): boolean {
   if (!filePath) {
     return true
   }
@@ -52,30 +50,12 @@ export function isPathIgnored(filePath: ?string, ignoredGlob: string, ignoredVCS
   return minimatch(normalizedFilePath, ignoredGlob)
 }
 
-export function subscriptiveObserve(object: Object, eventName: string, callback: Function): Disposable {
-  let subscription = null
-  const eventSubscription = object.observe(eventName, function(props) {
-    if (subscription) {
-      subscription.dispose()
-    }
-    subscription = callback.call(this, props)
-  })
-
-  return new Disposable(function() {
-    eventSubscription.dispose()
-    if (subscription) {
-      subscription.dispose()
-    }
-  })
-}
 
 export function updateMessageKey(message: Message) {
   const { reference, location } = message
   message.key = [
     `$LINTER:${message.linterName}`,
-    `$LOCATION:${location.file}$${location.position.start.row}$${location.position.start.column}$${
-      location.position.end.row
-    }$${location.position.end.column}`,
+    `$LOCATION:${location.file}$${location.position.start.row}$${location.position.start.column}$${location.position.end.row}$${location.position.end.column}`,
     reference
       ? `$REFERENCE:${reference.file}$${reference.position ? `${reference.position.row}$${reference.position.column}` : ''}`
       : '$REFERENCE:null',
@@ -98,7 +78,7 @@ export function normalizeMessages(linterName: string, messages: Array<Message>)
       reference.position = Point.fromObject(reference.position)
     }
     if (message.solutions && message.solutions.length) {
-      for (let j = 0, _length = message.solutions.length, solution; j < _length; j++) {
+      for (let j = 0, _length = message.solutions.length, solution: Message['solutions'][0]; j < _length; j++) {
         solution = message.solutions[j]
         if (Array.isArray(solution.position)) {
           solution.position = Range.fromObject(solution.position)
@@ -131,9 +111,9 @@ export function createKeyMessageMap(messages: Array<Message>): Map<string, Messa
 }
 
 interface FlaggedMessages {
-  oldKept: Array<Message>;
-  oldRemoved: Array<Message>;
-  newAdded: Array<Message>;
+  oldKept: Array<Message>
+  oldRemoved: Array<Message>
+  newAdded: Array<Message>
 }
 
 // This fast function returns the new messages and old messages by comparing their key against the cache.
@@ -181,7 +161,7 @@ export function flagMessages(inputs: Array<Message>, oldMessages: Array<Message>
 
   const oldRemovedKeys = cacheKeys.filter(x => !oldKeptKeys.includes(x))
 
-  const oldRemoved = new Set()
+  const oldRemoved: Set<Message> = new Set()
   for (let iRemoved = 0, RemovedKeysLen = oldRemovedKeys.length; iRemoved < RemovedKeysLen; iRemoved++) {
     oldRemoved.add(cache.get(oldRemovedKeys[iRemoved]))
   }

lib/index.js → lib/index.ts

@@ -1,9 +1,7 @@
-/* @flow */
-
 import { CompositeDisposable, Disposable } from 'atom'
 
 import Linter from './main'
-import type { UI, Linter as LinterProvider } from './types'
+import type { UI, Linter as LinterProvider, Indie } from './types'
 
 // Internal variables
 let instance: Linter
@@ -16,7 +14,7 @@ export function activate() {
   subscriptions.add(instance)
 
   subscriptions.add(
-    atom.packages.onDidActivateInitialPackages(function() {
+    atom.packages.onDidActivateInitialPackages(function () {
       if (!atom.inSpecMode()) {
         require('atom-package-deps').install('linter', true)
       }
@@ -45,8 +43,8 @@ export function consumeUI(ui: UI): Disposable {
     }
   })
 }
-export function provideIndie(): Object {
-  return indie => instance.addIndie(indie)
+export function provideIndie() {
+  return (indie: Indie) => instance.addIndie(indie)
 }
 export function deactivate() {
   subscriptions.dispose()