enable eslint for Storage (#1850)

* storage auto fix

* fix test files

* more storage fixes

* fix more lint issues

* fix metadata.ts

* [AUTOMATED]: Prettier Code Styling

* update param type

* revert accidental change

* use unknown[] for rest param

* Further improve Storage typings (#1860)

* disable unused var check for function params

* remove duplicate imports

* [AUTOMATED]: Prettier Code Styling

* update test command

* fix something

* fix some ts errors

* [AUTOMATED]: Prettier Code Styling

* fix some lint issues

Author: Feiyang1

config/.eslintrc.json

@@ -103,7 +103,7 @@
             "error",
             {
                 "types": {
-                    "Object": "Use object instead.",
+                    "Object": "Use {} or 'object' instead.",
                     "String": "Use 'string' instead.",
                     "Number": "Use 'number' instead.",
                     "Boolean": "Use 'boolean' instead."

packages/storage/.eslintrc.json

@@ -0,0 +1,16 @@
+{
+    "extends": "../../config/.eslintrc.json",
+    "parserOptions": {
+        "project": "tsconfig.json"
+    },
+    "rules": {
+        "no-throw-literal": "off",
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                "varsIgnorePattern": "^_",
+                "args": "none"
+            }
+        ]
+    }
+}

packages/storage/index.ts

@@ -22,8 +22,8 @@ import {
   _FirebaseNamespace
 } from '@firebase/app-types/private';
 import { StringFormat } from './src/implementation/string';
-import { TaskEvent } from './src/implementation/taskenums';
-import { TaskState } from './src/implementation/taskenums';
+import { TaskEvent, TaskState } from './src/implementation/taskenums';
+
 import { XhrIoPool } from './src/implementation/xhriopool';
 import { Reference } from './src/reference';
 import { Service } from './src/service';
@@ -36,20 +36,24 @@ const STORAGE_TYPE = 'storage';
 
 function factory(
   app: FirebaseApp,
-  unused: any,
-  opt_url?: string
+  unused: unknown,
+  url?: string
 ): types.FirebaseStorage {
-  return new Service(app, new XhrIoPool(), opt_url) as any;
+  return (new Service(
+    app,
+    new XhrIoPool(),
+    url
+  ) as unknown) as types.FirebaseStorage;
 }
 
-export function registerStorage(instance: _FirebaseNamespace) {
-  let namespaceExports = {
+export function registerStorage(instance: _FirebaseNamespace): void {
+  const namespaceExports = {
     // no-inline
-    TaskState: TaskState,
-    TaskEvent: TaskEvent,
-    StringFormat: StringFormat,
+    TaskState,
+    TaskEvent,
+    StringFormat,
     Storage: Service,
-    Reference: Reference
+    Reference
   };
   instance.INTERNAL.registerService(
     STORAGE_TYPE,

packages/storage/package.json

@@ -10,9 +10,11 @@
     "dist"
   ],
   "scripts": {
+    "lint": "eslint -c .eslintrc.json '**/*.ts' --ignore-path '../../.gitignore'",
+    "lint:fix": "eslint --fix -c .eslintrc.json '**/*.ts' --ignore-path '../../.gitignore'",
     "build": "rollup -c",
     "dev": "rollup -c -w",
-    "test": "run-p test:browser",
+    "test": "run-p test:browser lint",
     "test:browser": "karma start --single-run",
     "prepare": "yarn build"
   },
@@ -46,7 +48,11 @@
     "source-map-loader": "0.2.4",
     "ts-loader": "5.4.5",
     "typescript": "3.4.5",
-    "webpack": "4.30.0"
+    "webpack": "4.30.0",
+    "eslint": "5.16.0",
+    "@typescript-eslint/parser": "1.10.2",
+    "@typescript-eslint/eslint-plugin": "1.10.2",
+    "@typescript-eslint/eslint-plugin-tslint": "1.10.2"
   },
   "repository": {
     "directory": "packages/storage",

packages/storage/src/implementation/args.ts

@@ -25,16 +25,20 @@ import * as type from './type';
  * @param passed The actual arguments passed to the function.
  * @throws {fbs.Error} If the arguments are invalid.
  */
-export function validate(name: string, specs: ArgSpec[], passed: IArguments) {
+export function validate(
+  name: string,
+  specs: ArgSpec[],
+  passed: IArguments
+): void {
   let minArgs = specs.length;
-  let maxArgs = specs.length;
+  const maxArgs = specs.length;
   for (let i = 0; i < specs.length; i++) {
     if (specs[i].optional) {
       minArgs = i;
       break;
     }
   }
-  let validLength = minArgs <= passed.length && passed.length <= maxArgs;
+  const validLength = minArgs <= passed.length && passed.length <= maxArgs;
   if (!validLength) {
     throw errorsExports.invalidArgumentCount(
       minArgs,
@@ -60,49 +64,52 @@ export function validate(name: string, specs: ArgSpec[], passed: IArguments) {
  * @struct
  */
 export class ArgSpec {
-  validator: (p1: any) => void;
+  validator: (p1: unknown) => void;
   optional: boolean;
 
-  constructor(validator: (p1: any) => void, opt_optional?: boolean) {
-    let self = this;
-    this.validator = function(p: any) {
+  constructor(validator: (p1: unknown) => void, optional?: boolean) {
+    const self = this;
+    this.validator = function(p: unknown) {
       if (self.optional && !type.isJustDef(p)) {
         return;
       }
       validator(p);
     };
-    this.optional = !!opt_optional;
+    this.optional = !!optional;
   }
 }
 
-export function and_(v1: (p1: any) => void, v2: Function): (p1: any) => void {
+export function and_(
+  v1: (p1: unknown) => void,
+  v2: (p1: unknown) => void
+): (p1: unknown) => void {
   return function(p) {
     v1(p);
     v2(p);
   };
 }
 
 export function stringSpec(
-  opt_validator?: (p1: any) => void | null,
-  opt_optional?: boolean
+  validator?: (p1: unknown) => void | null,
+  optional?: boolean
 ): ArgSpec {
-  function stringValidator(p: any) {
+  function stringValidator(p: unknown): void {
     if (!type.isString(p)) {
       throw 'Expected string.';
     }
   }
-  let validator;
-  if (opt_validator) {
-    validator = and_(stringValidator, opt_validator);
+  let chainedValidator;
+  if (validator) {
+    chainedValidator = and_(stringValidator, validator);
   } else {
-    validator = stringValidator;
+    chainedValidator = stringValidator;
   }
-  return new ArgSpec(validator, opt_optional);
+  return new ArgSpec(chainedValidator, optional);
 }
 
 export function uploadDataSpec(): ArgSpec {
-  function validator(p: any) {
-    let valid =
+  function validator(p: unknown): void {
+    const valid =
       p instanceof Uint8Array ||
       p instanceof ArrayBuffer ||
       (type.isNativeBlobDefined() && p instanceof Blob);
@@ -113,17 +120,17 @@ export function uploadDataSpec(): ArgSpec {
   return new ArgSpec(validator);
 }
 
-export function metadataSpec(opt_optional?: boolean): ArgSpec {
-  return new ArgSpec(MetadataUtils.metadataValidator, opt_optional);
+export function metadataSpec(optional?: boolean): ArgSpec {
+  return new ArgSpec(MetadataUtils.metadataValidator, optional);
 }
 
-export function listOptionSpec(opt_optional?: boolean): ArgSpec {
-  return new ArgSpec(ListOptionsUtils.listOptionsValidator, opt_optional);
+export function listOptionSpec(optional?: boolean): ArgSpec {
+  return new ArgSpec(ListOptionsUtils.listOptionsValidator, optional);
 }
 
 export function nonNegativeNumberSpec(): ArgSpec {
-  function validator(p: any) {
-    let valid = type.isNumber(p) && p >= 0;
+  function validator(p: unknown): void {
+    const valid = type.isNumber(p) && p >= 0;
     if (!valid) {
       throw 'Expected a number 0 or greater.';
     }
@@ -132,27 +139,27 @@ export function nonNegativeNumberSpec(): ArgSpec {
 }
 
 export function looseObjectSpec(
-  opt_validator?: ((p1: any) => void) | null,
-  opt_optional?: boolean
+  validator?: ((p1: unknown) => void) | null,
+  optional?: boolean
 ): ArgSpec {
-  function validator(p: any) {
-    let isLooseObject = p === null || (type.isDef(p) && p instanceof Object);
+  function isLooseObjectValidator(p: unknown): void {
+    const isLooseObject = p === null || (type.isDef(p) && p instanceof Object);
     if (!isLooseObject) {
       throw 'Expected an Object.';
     }
-    if (opt_validator !== undefined && opt_validator !== null) {
-      opt_validator(p);
+    if (validator !== undefined && validator !== null) {
+      validator(p);
     }
   }
-  return new ArgSpec(validator, opt_optional);
+  return new ArgSpec(isLooseObjectValidator, optional);
 }
 
-export function nullFunctionSpec(opt_optional?: boolean): ArgSpec {
-  function validator(p: any) {
-    let valid = p === null || type.isFunction(p);
+export function nullFunctionSpec(optional?: boolean): ArgSpec {
+  function validator(p: unknown): void {
+    const valid = p === null || type.isFunction(p);
     if (!valid) {
       throw 'Expected a Function.';
     }
   }
-  return new ArgSpec(validator, opt_optional);
+  return new ArgSpec(validator, optional);
 }

packages/storage/src/implementation/array.ts

@@ -15,20 +15,14 @@
  * limitations under the License.
  */
 
-/**
- * @fileoverview Method for invoking a callback asynchronously.
- */
-import * as promiseimpl from './promise_external';
-
 /**
  * Returns a function that invokes f with its arguments asynchronously as a
  * microtask, i.e. as soon as possible after the current script returns back
  * into browser code.
  */
 export function async(f: Function): Function {
-  return function(...argsToForward: any[]) {
-    promiseimpl.resolve(true).then(function() {
-      f.apply(null, argsToForward);
-    });
+  return (...argsToForward: unknown[]) => {
+    // tslint:disable-next-line:no-floating-promises
+    Promise.resolve().then(() => f(...argsToForward));
   };
 }