Eslint fixes returning types and variables types (forcedotcom#214)

* Set eslint configuration, delete tslint configs, first pass at fixing eslint errors and warnings

* temporarily remove pre push and pre commit tasks

* Lint lsp common, still work to do here

* Fixed some eslint problems

* Delete package-lock.json

* Not used variables, and duplicated imports

* Remove package-lock

* Deleted unused functions, and minor eslint fixes

* Moved code for used after declaration, and some minor eslint fixes

* Not infereable types fixed

* Exporting ternerror

* Deleted import ternError and copied function

* No inferreable fixed, and interfaces that were starting with I prefix, removed

* Moved check if file outside of promise

* Changed logger to use args instead of arguments, for eslint rules

* Deleted functions that code will never run

* Rever changes for yarn.lock

* Missing await async function

* Yarn.lock re-added, so the circle ci can run, as its running with freeze lock files

* Added returning types to some functions

* Eslint retrun types, and types of variables

Co-authored-by: Luis Campos <[email protected]>

.eslintrc.json

@@ -43,6 +43,7 @@
     ], // non-complete list of globals that are easy to access unintentionally
     "no-var": "error",
     "jsdoc/no-types": "warn",
-    "@typescript-eslint/semi": "warn"
+    "@typescript-eslint/semi": "warn",
+    "@typescript-eslint/no-explicit-any": "off"
   }
 }

packages/aura-language-server/src/__tests__/package-dependencies.test.ts

@@ -9,7 +9,7 @@ import glob from 'glob';
 
 const checkedPackagePatterns: RegExp[] = [/^@salesforce/i, /^@lwc/i];
 
-function readJsonFile(jsonFilePath: string) {
+function readJsonFile(jsonFilePath: string): any {
     try {
         return JSON.parse(fs.readFileSync(jsonFilePath, 'utf8'));
     } catch (e) {

packages/aura-language-server/src/aura-indexer/__tests__/indexer.spec.ts

@@ -3,7 +3,7 @@ import AuraIndexer from '../indexer';
 import * as path from 'path';
 import URI from 'vscode-uri';
 
-function normalize(start: string, p: string) {
+function normalize(start: string, p: string): string {
     // Fix relative paths on windows
     if (start.indexOf('\\') !== -1) {
         start = start.replace(/\\/g, '/');

packages/aura-language-server/src/aura-indexer/indexer.ts

@@ -24,7 +24,7 @@ export default class AuraIndexer implements Indexer {
         this.context.addIndexingProvider({ name: 'aura', indexer: this });
     }
 
-    public async configureAndIndex() {
+    public async configureAndIndex(): Promise<any> {
         const indexingTasks: Promise<void>[] = [];
 
         indexingTasks.push(this.loadStandardComponents());
@@ -35,11 +35,11 @@ export default class AuraIndexer implements Indexer {
         return this.indexingTasks;
     }
 
-    public async waitForIndexing() {
+    public async waitForIndexing(): Promise<void> {
         return this.indexingTasks;
     }
 
-    public resetIndex() {
+    public resetIndex(): void {
         this.eventEmitter.emit('clear');
         this.AURA_TAGS.clear();
         this.AURA_EVENTS.clear();
@@ -57,7 +57,7 @@ export default class AuraIndexer implements Indexer {
         return this.getAuraTags().get(tag);
     }
 
-    public clearTagsforDirectory(directory: string, sfdxProject: boolean) {
+    public clearTagsforDirectory(directory: string, sfdxProject: boolean): void {
         const name = componentUtil.componentFromDirectory(directory, sfdxProject);
         this.deleteCustomTag(name);
     }
@@ -121,7 +121,7 @@ export default class AuraIndexer implements Indexer {
         return tagInfo;
     }
 
-    private async indexCustomComponents() {
+    private async indexCustomComponents(): Promise<void> {
         const startTime = process.hrtime();
         const markupfiles = await this.context.findAllAuraMarkup();
 
@@ -135,31 +135,31 @@ export default class AuraIndexer implements Indexer {
         console.info(`Indexed ${markupfiles.length} files in ${utils.elapsedMillis(startTime)} ms`);
     }
 
-    private clearTagsforFile(file: string, sfdxProject: boolean) {
+    private clearTagsforFile(file: string, sfdxProject: boolean): void {
         const name = componentUtil.componentFromFile(file, sfdxProject);
         this.deleteCustomTag(name);
     }
 
-    private deleteCustomTag(tag: string) {
+    private deleteCustomTag(tag: string): void {
         this.AURA_TAGS.delete(tag);
         this.AURA_EVENTS.delete(tag);
 
         this.eventEmitter.emit('delete', tag);
     }
-    private setAuraNamespaceTag(namespace: string) {
+    private setAuraNamespaceTag(namespace: string): void {
         if (!this.AURA_NAMESPACES.has(namespace)) {
             this.AURA_NAMESPACES.add(namespace);
             this.eventEmitter.emit('set-namespace', namespace);
         }
     }
 
-    private setCustomEventTag(info: TagInfo) {
+    private setCustomEventTag(info: TagInfo): void {
         this.setAuraNamespaceTag(info.namespace);
         this.AURA_EVENTS.set(info.name, info);
         this.eventEmitter.emit('set', info);
     }
 
-    private setCustomTag(info: TagInfo) {
+    private setCustomTag(info: TagInfo): void {
         this.setAuraNamespaceTag(info.namespace);
         this.AURA_TAGS.set(info.name, info);
         this.eventEmitter.emit('set', info);
@@ -229,7 +229,7 @@ export default class AuraIndexer implements Indexer {
         return results;
     }
 
-    private trimQuotes(str: string) {
+    private trimQuotes(str: string): string {
         if (!str) {
             return '';
         }

packages/aura-language-server/src/aura-utils.ts

@@ -13,10 +13,10 @@ export function isAuraMarkup(textDocument: TextDocument): boolean {
     return AURA_EXTENSIONS.includes(fileExt);
 }
 
-export function getAuraStandardResourcePath() {
+export function getAuraStandardResourcePath(): string {
     return join(__dirname, RESOURCES_DIR, AURA_STANDARD);
 }
 
-export function getAuraSystemResourcePath() {
+export function getAuraSystemResourcePath(): string {
     return join(__dirname, RESOURCES_DIR, AURA_SYSTEM);
 }

packages/aura-language-server/src/markup/auraTags.ts

@@ -16,18 +16,18 @@ function getAuraByTag(tag: string): TagInfo {
     return undefined;
 }
 
-export function setIndexer(idx: AuraIndexer) {
+export function setIndexer(idx: AuraIndexer): void {
     indexer = idx;
 }
 
 export function getAuraTagProvider(): IHTMLTagProvider {
-    function addTags(collector: (tag: string, label: string, info: TagInfo) => void) {
+    function addTags(collector: (tag: string, label: string, info: TagInfo) => void): void {
         for (const [tag, tagInfo] of getAuraTags()) {
             collector(tag, tagInfo.getHover(), tagInfo);
         }
     }
 
-    function addAttributes(tag: string, collector: (attribute: string, info: AttributeInfo, type?: string) => void) {
+    function addAttributes(tag: string, collector: (attribute: string, info: AttributeInfo, type?: string) => void): void {
         const cTag = getAuraByTag(tag);
         if (cTag) {
             for (const info of cTag.attributes) {
@@ -36,7 +36,7 @@ export function getAuraTagProvider(): IHTMLTagProvider {
         }
     }
 
-    function addExpressions(templateTag: string, collector: (attribute: string, info: AttributeInfo, type: string) => void) {
+    function addExpressions(templateTag: string, collector: (attribute: string, info: AttributeInfo, type: string) => void): void {
         const cTag = getAuraByTag(templateTag);
         if (cTag) {
             cTag.attributes.forEach(attribute => {
@@ -49,25 +49,25 @@ export function getAuraTagProvider(): IHTMLTagProvider {
     }
 
     return {
-        getId: () => 'aura',
-        isApplicable: languageId => languageId === 'html',
-        collectTags: (collector: (tag: string, label: string, info: TagInfo) => void) => {
+        getId: (): string => 'aura',
+        isApplicable: (languageId): boolean => languageId === 'html',
+        collectTags: (collector: (tag: string, label: string, info: TagInfo) => void): void => {
             addTags(collector);
         },
-        collectAttributes: (tag: string, collector: (attribute: string, info: AttributeInfo, type?: string) => void) => {
+        collectAttributes: (tag: string, collector: (attribute: string, info: AttributeInfo, type?: string) => void): void => {
             if (tag) {
                 addAttributes(tag, collector);
             }
         },
-        collectValues: (/*tag: string, attribute: string, collector: (value: string) => void*/) => {
+        collectValues: (/*tag: string, attribute: string, collector: (value: string) => void*/): void => {
             // TODO provide suggestions by consulting shapeService
         },
 
         // TODO move this to ICompletionParticipant
         collectExpressionValues: (templateTag: string, collector: (value: string) => void): void => {
             addExpressions(templateTag, collector);
         },
-        getTagInfo: (tag: string) => getAuraByTag(tag),
-        getGlobalAttributes: () => [],
+        getTagInfo: (tag: string): TagInfo => getAuraByTag(tag),
+        getGlobalAttributes: (): [] => [],
     };
 }

packages/aura-language-server/src/server.ts

@@ -48,7 +48,7 @@ documents.listen(connection);
 let htmlLS: LanguageService;
 let context: WorkspaceContext;
 
-function startIndexing() {
+function startIndexing(): void {
     setTimeout(async () => {
         const indexer = context.getIndexingProvider('aura') as AuraIndexer;
         connection.sendNotification('salesforce/indexingStarted');
@@ -282,6 +282,7 @@ connection.onRequest('salesforce/listNamespaces', () => {
     return result;
 });
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 connection.onRequest((method: string, ...params: any[]) => {
     // debugger
     console.log(method);

packages/aura-language-server/src/tern-server/string-util.ts

@@ -1,4 +1,4 @@
-function isAlphaNumberic(code: number) {
+function isAlphaNumberic(code: number): boolean {
     if (code > 47 && code < 58) {
         // numeric
         return true;
@@ -14,7 +14,7 @@ function isAlphaNumberic(code: number) {
     return false;
 }
 
-export function findWord(str: string, offset: number) {
+export function findWord(str: string, offset: number): { start: number; end: number } {
     let start = -1;
     let end = -1;
 
@@ -56,7 +56,7 @@ export function findWord(str: string, offset: number) {
         };
     }
 }
-export function countPreviousCommas(str: string, offset: number) {
+export function countPreviousCommas(str: string, offset: number): number {
     let commas = 0;
     let pos: number = offset;
     let c: number;
@@ -73,7 +73,7 @@ export function countPreviousCommas(str: string, offset: number) {
     }
     return commas;
 }
-export function findPreviousLeftParan(str: string, offset: number) {
+export function findPreviousLeftParan(str: string, offset: number): number {
     let start = -1;
     let pos: number = offset;
     let c: number;
@@ -91,7 +91,7 @@ export function findPreviousLeftParan(str: string, offset: number) {
     return start;
 }
 
-export function findPreviousWord(str: string, offset: number) {
+export function findPreviousWord(str: string, offset: number): { start: number; end: number } {
     let start = -1;
     let end = -1;