refactor: refactoring for ES modules

Author: jarrodek

.eslintignore

@@ -0,0 +1 @@
+test/

.eslintrc.js

@@ -0,0 +1,18 @@
+// module.exports = {
+//     "env": {
+//         "browser": true,
+//         "es6": true,
+//         "node": true
+//     },
+//     "extends": "google",
+//     "parserOptions": {
+//         "ecmaVersion": 2018,
+//         "sourceType": "module"
+//     },
+//     "rules": {
+//
+//     }
+// };
+module.exports = {
+  extends: ['@advanced-rest-client/eslint-config'].map(require.resolve),
+};

.npmignore

@@ -0,0 +1,8 @@
+coverage/
+test/
+.travis.yml
+husky.*
+commitlint.*
+.*
+*.config.*
+prettier.config.js

commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+};

husky.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  hooks: {
+    'pre-commit': 'lint-staged',
+    'commit-msg': 'commitlint -E HUSKY_GIT_PARAMS',
+  },
+};

index.js

@@ -0,0 +1,2 @@
+require = require('esm')(module);
+module.exports = require('./main.js');

lib/GithubCache.d.ts

@@ -0,0 +1,30 @@
+// tslint:disable:variable-name Describing an API that's defined elsewhere.
+// tslint:disable:no-any describes the API as best we are able today
+
+export {GithubCache};
+
+/**
+ * A class responsible for caching and restoring cached GitHub responses
+ * results.
+ *
+ * Unauthenticated requests to GitHub has 60 requests per hour limit.
+ * This class helps to cache the results so it's a lower risk of receiving
+ * `403 Forbidden` error.
+ *
+ * This class works with the resolver class.
+ *
+ * The class stores data in user's home data folder in
+ * `api-console/cache/github-http-cache.json` folder.
+ */
+declare class GithubCache {
+  constructor(logger: Object);
+  locateAppDir(platform?: String): String;
+  loadCache(): Promise<Object>;
+  lastEtag(url: String): Promise<String|undefined>;
+  getCachedResult(url: String): Promise<String|undefined>;
+  storeResponse(url: String, etag: String, response: Object): Promise<void>;
+  _findEtag(data: Object, url: String): String|undefined;
+  _findResponse(data: Object, url: String): String|undefined;
+  _addCacheEntry(data: Object, url: String, etag: String, response: Object): Promise<void>;
+  _store(): Promise<void>;
+}

lib/github-cache.js renamed to lib/GithubCache.js

@@ -1,5 +1,5 @@
-const path = require('path');
-const fs = require('fs-extra');
+import path from 'path';
+import fs from 'fs-extra';
 /**
  * A class responsible for caching and restoring cached GitHub responses
  * results.
@@ -13,7 +13,7 @@ const fs = require('fs-extra');
  * The class stores data in user's home data folder in
  * `api-console/cache/github-http-cache.json` folder.
  */
-class GithubCache {
+export class GithubCache {
   /**
    * @param {Object} logger A logger object to use to log messages.
    */
@@ -54,35 +54,33 @@ class GithubCache {
    * Loads cache data into memory and returns the data.
    * @return {Promise} Promise resolved to cache file contents.
    */
-  loadCache() {
+  async loadCache() {
     if (this._data) {
-      return Promise.resolve(this._data);
+      return this._data;
     }
     if (this.logger) {
       this.logger.debug('[GithubCache] Loading cache from ' + this.cacheLocation);
     }
-    return fs.ensureFile(this.cacheLocation)
-    .then(() => fs.readJson(this.cacheLocation, {throws: false}))
-    .then((data) => {
-      if (data === null) {
-        data = undefined;
-        if (this.logger) {
-          this.logger.debug('[GithubCache] Cache file does not exists.');
-        }
+    await fs.ensureFile(this.cacheLocation);
+    let data = await fs.readJson(this.cacheLocation, { throws: false });
+    if (data === null) {
+      data = undefined;
+      if (this.logger) {
+        this.logger.debug('[GithubCache] Cache file does not exists.');
       }
-      this._data = data;
-      return data;
-    });
+    }
+    this._data = data;
+    return data;
   }
   /**
    * Restores latest `etag`
    *
    * @param {String} url The full URL used to cache the results.
    * @return {Promise}
    */
-  lastEtag(url) {
-    return this.loadCache()
-    .then((data) => this._findEtag(data, url));
+  async lastEtag(url) {
+    const data = await this.loadCache();
+    return await this._findEtag(data, url);
   }
   /**
    * Finds etag in cached data.
@@ -111,9 +109,9 @@ class GithubCache {
    * @param {String} url The full URL used to cache the results.
    * @return {Promise}
    */
-  getCachedResult(url) {
-    return this.loadCache()
-    .then((data) => this._findResponse(data, url));
+  async getCachedResult(url) {
+    const data = await this.loadCache();
+    return await this._findResponse(data, url);
   }
   /**
    * Finds response in cached data.
@@ -148,20 +146,20 @@ class GithubCache {
    * @param {Object} response Response data to cache
    * @return {Promise}
    */
-  storeResponse(url, etag, response) {
-    return this.loadCache()
-    .then((data) => this._addCacheEntry(data, url, etag, response));
+  async storeResponse(url, etag, response) {
+    const data = await this.loadCache();
+    return await this._addCacheEntry(data, url, etag, response);
   }
   /**
    * Appends response data to the cache.
    *
-   * @param {Obect} data Responses cache object
+   * @param {Object} data Responses cache object
    * @param {String} url Request URL
    * @param {String} etag Response etag
    * @param {Object} response GitHub response.
    * @return {Promise}
    */
-  _addCacheEntry(data, url, etag, response) {
+  async _addCacheEntry(data, url, etag, response) {
     if (this.logger) {
       this.logger.debug('[GithubCache] Adding cache entry for ' + url);
     }
@@ -173,18 +171,17 @@ class GithubCache {
       response
     };
     this._data = data;
-    return this._store();
+    await this._store();
   }
   /**
    * Stores current data to the cache file.
    * @return {Promise}
    */
-  _store() {
+  async _store() {
     const data = this._data || {};
     if (this.logger) {
       this.logger.debug('[GithubCache] Storing cache data to ' + this.cacheLocation);
     }
-    return fs.writeJson(this.cacheLocation, data);
+    await fs.writeJson(this.cacheLocation, data);
   }
 }
-exports.GithubCache = GithubCache;

lib/GithubResolver.d.ts

@@ -0,0 +1,29 @@
+// tslint:disable:variable-name Describing an API that's defined elsewhere.
+// tslint:disable:no-any describes the API as best we are able today
+
+export {GithubResolver};
+
+import { GithubResolverOptions } from './GithubResolverOptions.js';
+
+/**
+ * A GitGub transport class.
+ * The transport is based on the HTTPS protocol.
+ */
+declare class GithubResolver {
+  constructor(opts?: GithubResolverOptions);
+  getLatestInfo(): Promise<Object>;
+  getReleasesList(): Promise<Array<Object>>;
+  getTagInfo(): Promise<Object>;
+  _setupLogger(opts?: GithubResolverOptions): Object;
+  _computeHeaders(): Object;
+  _getResetTime(): number;
+  _assertCanMakeRequest(): void;
+  _makeRequest(url: String, headers?: Object): Promise<Object|Buffer>;
+  _handleResponseHeaders(): void;
+  _filterSupportedTags(json: Array<Object>): Array<Object>;
+  _sortTags(a: string, b: string): number;
+  _getTagInfo(tag: string): Object;
+  _throwTag404Error(tag: string): void;
+  _getReleasesListErrorMessage(tag: string, releases: Array<Object>): string;
+  _assertTag(tag: string): void;
+}