@vssue/api-github-v3 - npm Package Compare versions

Comparing version 0.2.0 to 0.3.0

lib/index.js

 import * as tslib_1 from "tslib";
 import axios from 'axios';
 import { buildURL, getCleanURL, parseQuery, } from '@vssue/utils';
-import { normalizeUser, normalizeIssue, normalizeComment, mapReactionName, } from './utils';
+import { normalizeUser, normalizeIssue, normalizeComment, normalizeReactions, mapReactionName, } from './utils';
 /**
- * Github API v3
+ * Github REST API v3
  *
- * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/
- * @see https://developer.github.com/v3/issues/
- * @see https://developer.github.com/v3/issues/comments/
- * @see https://developer.github.com/v3/reactions/
+ * @see https://developer.github.com/v3/
+ * @see https://developer.github.com/apps/building-oauth-apps/
  */
@@ -56,2 +54,4 @@ var GithubV3 = /** @class */ (function () {
      * Redirect to the authorization page of platform.
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#1-request-a-users-github-identity
      */
@@ -69,6 +69,8 @@ GithubV3.prototype.redirectAuth = function () {
      *
+     * @return A string for access token, `null` for no authorization code
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/
+     *
      * @remarks
      * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.
-     *
-     * @return A string for access token, `null` for no authorization code
      */
@@ -106,2 +108,4 @@ GithubV3.prototype.handleAuth = function () {
      * @return User access token
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github
      */
@@ -136,2 +140,4 @@ GithubV3.prototype.getAccessToken = function (_a) {
      * @return The user
+     *
+     * @see https://developer.github.com/v3/users/#get-the-authenticated-user
      */
@@ -162,2 +168,6 @@ GithubV3.prototype.getUser = function (_a) {
      * @return The raw response of issue
+     *
+     * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository
+     * @see https://developer.github.com/v3/issues/#get-a-single-issue
+     * @see https://developer.github.com/v3/#pagination
      */
@@ -218,2 +228,33 @@ GithubV3.prototype.getIssue = function (_a) {
     /**
+     * Create a new issue
+     *
+     * @param options.accessToken - User access token
+     * @param options.title - The title of issue
+     * @param options.content - The content of issue
+     *
+     * @return The created issue
+     *
+     * @see https://developer.github.com/v3/issues/#create-an-issue
+     */
+    GithubV3.prototype.postIssue = function (_a) {
+        var accessToken = _a.accessToken, title = _a.title, content = _a.content;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.$http.post("repos/" + this.owner + "/" + this.repo + "/issues", {
+                            title: title,
+                            body: content,
+                            labels: this.labels.split(','),
+                        }, {
+                            headers: { 'Authorization': "token " + accessToken },
+                        })];
+                    case 1:
+                        data = (_b.sent()).data;
+                        return [2 /*return*/, normalizeIssue(data)];
+                }
+            });
+        });
+    };
+    /**
      * Get comments of this page according to the issue id or the issue title
@@ -226,2 +267,9 @@ *
      * @return The comments
+     *
+     * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
+     * @see https://developer.github.com/v3/#pagination
+     *
+     * @reamrks
+     * Github V3 does not support sort for issue comments now.
+     * Github V3 have to request the parent issue to get the count of comments.
      */
@@ -291,31 +339,2 @@ GithubV3.prototype.getComments = function (_a) {
     /**
-     * Create a new issue
-     *
-     * @param options.accessToken - User access token
-     * @param options.title - The title of issue
-     * @param options.content - The content of issue
-     *
-     * @return The created issue
-     */
-    GithubV3.prototype.createIssue = function (_a) {
-        var accessToken = _a.accessToken, title = _a.title, content = _a.content;
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var data;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.$http.post("repos/" + this.owner + "/" + this.repo + "/issues", {
-                            title: title,
-                            body: content,
-                            labels: this.labels.split(','),
-                        }, {
-                            headers: { 'Authorization': "token " + accessToken },
-                        })];
-                    case 1:
-                        data = (_b.sent()).data;
-                        return [2 /*return*/, normalizeIssue(data)];
-                }
-            });
-        });
-    };
-    /**
      * Create a new comment
@@ -328,4 +347,6 @@ *
      * @return The created comment
+     *
+     * @see https://developer.github.com/v3/issues/comments/#create-a-comment
      */
-    GithubV3.prototype.createComment = function (_a) {
+    GithubV3.prototype.postComment = function (_a) {
         var accessToken = _a.accessToken, issueId = _a.issueId, content = _a.content;
@@ -356,24 +377,23 @@ return tslib_1.__awaiter(this, void 0, void 0, function () {
     /**
-     * Create a new reaction of issue
+     * Delete a comment
      *
      * @param options.accessToken - User access token
-     * @param options.issueId - The id of issue
-     * @param options.reaction - The reaction
+     * @param options.commentId - The id of comment
      *
-     * @return `true` if succeed, `false` if already token
+     * @return `true` if succeed, `false` if failed
+     *
+     * @see https://developer.github.com/v3/issues/comments/#delete-a-comment
      */
-    GithubV3.prototype.createIssueReaction = function (_a) {
-        var accessToken = _a.accessToken, issueId = _a.issueId, reaction = _a.reaction;
+    GithubV3.prototype.deleteComment = function (_a) {
+        var accessToken = _a.accessToken, commentId = _a.commentId;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var response;
+            var status;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.$http.post("repos/" + this.owner + "/" + this.repo + "/issues/" + issueId + "/reactions", {
-                            content: mapReactionName(reaction),
-                        }, {
+                    case 0: return [4 /*yield*/, this.$http.delete("repos/" + this.owner + "/" + this.repo + "/issues/comments/" + commentId, {
                             headers: { 'Authorization': "token " + accessToken },
                         })];
                     case 1:
-                        response = _b.sent();
-                        return [2 /*return*/, response.status === 201];
+                        status = (_b.sent()).status;
+                        return [2 /*return*/, status === 204];
                 }
@@ -384,13 +404,48 @@ });
     /**
-     * Create a new reaction of comment
+     * Get reactions of a comment
      *
      * @param options.accessToken - User access token
-     * @param options.issueId - The id of issue
      * @param options.commentId - The id of comment
+     *
+     * @return The comments
+     *
+     * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment
+     * @see https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment
+     *
+     * @remarks
+     * The `List reactions for an issue comment` API also returns author of each reaction.
+     * As we only need the count, use the `Get a single comment` API is much simpler.
+     */
+    GithubV3.prototype.getCommentReactions = function (_a) {
+        var accessToken = _a.accessToken, commentId = _a.commentId;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.$http.get("repos/" + this.owner + "/" + this.repo + "/issues/comments/" + commentId, {
+                            headers: {
+                                'Authorization': "token " + accessToken,
+                                'Accept': 'application/vnd.github.squirrel-girl-preview',
+                            },
+                        })];
+                    case 1:
+                        data = (_b.sent()).data;
+                        return [2 /*return*/, normalizeReactions(data.reactions)];
+                }
+            });
+        });
+    };
+    /**
+     * Create a new reaction of a comment
+     *
+     * @param options.accessToken - User access token
+     * @param options.commentId - The id of comment
      * @param options.reaction - The reaction
      *
      * @return `true` if succeed, `false` if already token
+     *
+     * @see https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment
      */
-    GithubV3.prototype.createCommentReaction = function (_a) {
-        var accessToken = _a.accessToken, issueId = _a.issueId, commentId = _a.commentId, reaction = _a.reaction;
+    GithubV3.prototype.postCommentReaction = function (_a) {
+        var accessToken = _a.accessToken, commentId = _a.commentId, reaction = _a.reaction;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -418,2 +473,2 @@ var response;
 export default GithubV3;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAKA,OAAO,KAGN,MAAM,OAAO,CAAA;AAEd,OAAO,EACL,QAAQ,EACR,WAAW,EACX,UAAU,GACX,MAAM,cAAc,CAAA;AAErB,OAAO,EACL,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,eAAe,GAChB,MAAM,SAAS,CAAA;AAEhB;;;;;;;GAOG;AACH;IAUE,kBAAa,EAQK;YAPhB,eAAkC,EAAlC,uDAAkC,EAClC,gBAAK,EACL,cAAI,EACJ,kBAAM,EACN,sBAAQ,EACR,8BAAY,EACZ,gBAAK;QAEL,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAE9B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC;YACxB,OAAO,SAAA;YACP,OAAO,EAAE;gBACP,QAAQ,EAAE,gCAAgC;aAC3C;SACF,CAAC,CAAA;QAEF,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,QAAQ;YACrD,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE;gBACvB,OAAO,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;aACvD;YACD,OAAO,QAAQ,CAAA;QACjB,CAAC,CAAC,CAAA;IACJ,CAAC;IAKD,sBAAI,8BAAQ;QAHZ;;WAEG;aACH;YACE,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,oBAAoB;gBAC1B,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE;oBACJ,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,KAAK;iBAChB;aACF,CAAA;QACH,CAAC;;;OAAA;IAED;;OAEG;IACH,+BAAY,GAAZ;QACE,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,0CAA0C,EAAE;YAC1E,SAAS,EAAE,IAAI,CAAC,QAAQ;YACxB,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI;YAClC,KAAK,EAAE,aAAa;YACpB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;OAOG;IACG,6BAAU,GAAhB;;;;;;wBACQ,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;6BAC5C,KAAK,CAAC,IAAI,EAAV,wBAAU;wBACZ,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE;4BAC9B,sBAAO,IAAI,EAAA;yBACZ;wBACK,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;wBACvB,OAAO,KAAK,CAAC,IAAI,CAAA;wBACjB,OAAO,KAAK,CAAC,KAAK,CAAA;wBACZ,UAAU,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA;wBAC5F,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,UAAU,CAAC,CAAA;wBAC7B,qBAAM,IAAI,CAAC,cAAc,CAAC,EAAE,IAAI,MAAA,EAAE,CAAC,EAAA;;wBAAjD,WAAW,GAAG,SAAmC;wBACvD,sBAAO,WAAW,EAAA;4BAEpB,sBAAO,IAAI,EAAA;;;;KACZ;IAED;;;;;;OAMG;IACG,iCAAc,GAApB,UAAsB,EAA0B;YAAxB,cAAI;;;;;4BAKT,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,yCAAuC,6CAA+C,EAAE;4BAC7H,SAAS,EAAE,IAAI,CAAC,QAAQ;4BACxB,aAAa,EAAE,IAAI,CAAC,YAAY;4BAChC,IAAI,MAAA;yBAOL,EAAE;4BACD,OAAO,EAAE;gCACP,QAAQ,EAAE,kBAAkB;6BAC7B;yBACF,CAAC,EAAA;;wBAdM,IAAI,GAAK,CAAA,SAcf,CAAA,KAdU;wBAeZ,sBAAO,IAAI,CAAC,YAAY,EAAA;;;;KACzB;IAED;;;;;;OAMG;IACG,0BAAO,GAAb,UAAe,EAAe;YAAb,4BAAW;;;;;4BACT,qBAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;4BAC7C,OAAO,EAAE,EAAE,eAAe,EAAE,WAAS,WAAa,EAAE;yBACrD,CAAC,EAAA;;wBAFM,IAAI,GAAK,CAAA,SAEf,CAAA,KAFU;wBAGZ,sBAAO,aAAa,CAAC,IAAI,CAAC,EAAA;;;;KAC3B;IAED;;;;;;;;OAQG;IACG,2BAAQ,GAAd,UAAgB,EAIf;YAHC,4BAAW,EACX,oBAAO,EACP,0BAAU;;;;;;wBAEJ,OAAO,GAAuB,EAAE,CAAA;wBAEtC,IAAI,WAAW,EAAE;4BACf,OAAO,CAAC,OAAO,GAAG;gCAChB,eAAe,EAAE,WAAS,WAAa;6BACxC,CAAA;yBACF;6BAEG,OAAO,EAAP,wBAAO;;;;wBAEP,OAAO,CAAC,MAAM,GAAG;4BACf,mBAAmB;4BACnB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;yBACtB,CAAA;wBACgB,qBAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,gBAAW,OAAS,EAAE,OAAO,CAAC,EAAA;;wBAA5F,IAAI,GAAK,CAAA,SAAmF,CAAA,KAAxF;wBACZ,sBAAO,cAAc,CAAC,IAAI,CAAC,EAAA;;;wBAE3B,IAAI,GAAC,CAAC,QAAQ,IAAI,GAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE;4BAC3C,sBAAO,IAAI,EAAA;yBACZ;6BAAM;4BACL,MAAM,GAAC,CAAA;yBACR;;;;wBAGH,OAAO,CAAC,MAAM,GAAG;4BACf,MAAM,EAAE,IAAI,CAAC,MAAM;4BACnB,IAAI,EAAE,SAAS;4BACf,SAAS,EAAE,KAAK;4BAChB,mBAAmB;4BACnB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;yBACtB,CAAA;wBACgB,qBAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,YAAS,EAAE,OAAO,CAAC,EAAA;;wBAAjF,IAAI,GAAK,CAAA,SAAwE,CAAA,KAA7E;wBACN,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,KAAK,KAAK,UAAU,EAAzB,CAAyB,CAAC,CAAA;wBAC9E,sBAAO,KAAK,IAAI,IAAI,EAAA;;;;;KAEvB;IAED;;;;;;;;OAQG;IACG,8BAAW,GAAjB,UAAmB,EAQlB;YAPC,4BAAW,EACX,oBAAO,EACP,aAIM,EAJN,4BAIM,EAHJ,YAAQ,EAAR,6BAAQ,EACR,eAAY,EAAZ,iCAAY,EACZ,YAAa,EAAb,kCAAa;;;;;;wBAGT,YAAY,GAAuB;4BACvC,MAAM,EAAE;gCACN,mBAAmB;gCACnB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;6BACtB;yBACF,CAAA;wBACK,eAAe,GAAuB;4BAC1C,MAAM,EAAE;gCACN,aAAa;gCACb,MAAM,EAAE,IAAI;gCACZ,UAAU,EAAE,OAAO;gCACnB;;;mCAGG;gCACH,qBAAqB;gCACrB,qBAAqB;gCACrB,mBAAmB;gCACnB,WAAW,EAAE,IAAI,CAAC,GAAG,EAAE;6BACxB;4BACD,OAAO,EAAE;gCACP,QAAQ,EAAE;oCACR,oCAAoC;oCACpC,qCAAqC;oCACrC,8CAA8C;iCAC/C;6BACF;yBACF,CAAA;wBACD,IAAI,WAAW,EAAE;4BACf,YAAY,CAAC,OAAO,GAAG;gCACrB,eAAe,EAAE,WAAS,WAAa;6BACxC,CAAA;4BACD,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,GAAG,WAAS,WAAa,CAAA;yBAClE;wBAG+B,qBAAM,OAAO,CAAC,GAAG,CAAC;gCAChD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,gBAAW,OAAS,EAAE,YAAY,CAAC;gCAClF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,gBAAW,OAAO,cAAW,EAAE,eAAe,CAAC;6BAC/F,CAAC;4BAEF,8EAA8E;0BAF5E;;wBAHI,KAAA,8BAA0B,SAG9B;4BAEF,8EAA8E;iCAF5E,EAHK,QAAQ,QAAA,EAAE,WAAW,QAAA;wBAMtB,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAA;wBAEtD,sBAAO;gCACL,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;gCACrC,IAAI,EAAE,IAAI;gCACV,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO;gCACxF,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC;6BAC7C,EAAA;;;;KACF;IAED;;;;;;;;OAQG;IACG,8BAAW,GAAjB,UAAmB,EAIlB;YAHC,4BAAW,EACX,gBAAK,EACL,oBAAO;;;;;4BAEU,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,YAAS,EAAE;4BAChF,KAAK,OAAA;4BACL,IAAI,EAAE,OAAO;4BACb,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;yBAC/B,EAAE;4BACD,OAAO,EAAE,EAAE,eAAe,EAAE,WAAS,WAAa,EAAE;yBACrD,CAAC,EAAA;;wBANM,IAAI,GAAK,CAAA,SAMf,CAAA,KANU;wBAOZ,sBAAO,cAAc,CAAC,IAAI,CAAC,EAAA;;;;KAC5B;IAED;;;;;;;;OAQG;IACG,gCAAa,GAAnB,UAAqB,EAIpB;YAHC,4BAAW,EACX,oBAAO,EACP,oBAAO;;;;;4BAEU,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,gBAAW,OAAO,cAAW,EAAE;4BACpG,IAAI,EAAE,OAAO;yBACd,EAAE;4BACD,OAAO,EAAE;gCACP,eAAe,EAAE,WAAS,WAAa;gCACvC,QAAQ,EAAE;oCACR,oCAAoC;oCACpC,qCAAqC;oCACrC,8CAA8C;iCAC/C;6BACF;yBACF,CAAC,EAAA;;wBAXM,IAAI,GAAK,CAAA,SAWf,CAAA,KAXU;wBAYZ,sBAAO,gBAAgB,CAAC,IAAI,CAAC,EAAA;;;;KAC9B;IAED;;;;;;;;OAQG;IACG,sCAAmB,GAAzB,UAA2B,EAI1B;YAHC,4BAAW,EACX,oBAAO,EACP,sBAAQ;;;;;4BAES,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,gBAAW,OAAO,eAAY,EAAE;4BACrG,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC;yBACnC,EAAE;4BACD,OAAO,EAAE,EAAE,eAAe,EAAE,WAAS,WAAa,EAAE;yBACrD,CAAC,EAAA;;wBAJI,QAAQ,GAAG,SAIf;wBACF,sBAAO,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAA;;;;KAC/B;IAED;;;;;;;;;OASG;IACG,wCAAqB,GAA3B,UAA6B,EAK5B;YAJC,4BAAW,EACX,oBAAO,EACP,wBAAS,EACT,sBAAQ;;;;;4BAES,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAS,IAAI,CAAC,KAAK,SAAI,IAAI,CAAC,IAAI,yBAAoB,SAAS,eAAY,EAAE;4BAChH,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC;yBACnC,EAAE;4BACD,OAAO,EAAE;gCACP,eAAe,EAAE,WAAS,WAAa;gCACvC,QAAQ,EAAE,8CAA8C;6BACzD;yBACF,CAAC,EAAA;;wBAPI,QAAQ,GAAG,SAOf;wBACF,sBAAO,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAA;;;;KAC/B;IACH,eAAC;AAAD,CAAC,AAzWD,IAyWC","sourcesContent":["import {\n  VssueAPI,\n  VssueAPIOptions,\n} from 'vssue'\n\nimport axios, {\n  AxiosInstance,\n  AxiosRequestConfig,\n} from 'axios'\n\nimport {\n  buildURL,\n  getCleanURL,\n  parseQuery,\n} from '@vssue/utils'\n\nimport {\n  normalizeUser,\n  normalizeIssue,\n  normalizeComment,\n  mapReactionName,\n} from './utils'\n\n/**\n * Github API v3\n *\n * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/\n * @see https://developer.github.com/v3/issues/\n * @see https://developer.github.com/v3/issues/comments/\n * @see https://developer.github.com/v3/reactions/\n */\nexport default class GithubV3 implements VssueAPI.Instance {\n  baseURL: string\n  owner: string\n  repo: string\n  labels: string\n  clientId: string\n  clientSecret: string\n  state: string\n  $http: AxiosInstance\n\n  constructor ({\n    baseURL = 'https://api.github.com',\n    owner,\n    repo,\n    labels,\n    clientId,\n    clientSecret,\n    state,\n  }: VssueAPIOptions) {\n    this.baseURL = baseURL\n    this.owner = owner\n    this.repo = repo\n    this.labels = labels.join(',')\n\n    this.clientId = clientId\n    this.clientSecret = clientSecret\n    this.state = state\n\n    this.$http = axios.create({\n      baseURL,\n      headers: {\n        'Accept': 'application/vnd.github.v3+json',\n      },\n    })\n\n    this.$http.interceptors.response.use(function (response) {\n      if (response.data.error) {\n        return Promise.reject(response.data.error_description)\n      }\n      return response\n    })\n  }\n\n  /**\n   * The platform api info\n   */\n  get platform (): VssueAPI.Platform {\n    return {\n      name: 'GitHub',\n      link: 'https://github.com',\n      version: 'v3',\n      meta: {\n        reactable: true,\n        sortable: false,\n      },\n    }\n  }\n\n  /**\n   * Redirect to the authorization page of platform.\n   */\n  redirectAuth (): void {\n    window.location.href = buildURL('https://github.com/login/oauth/authorize', {\n      client_id: this.clientId,\n      redirect_uri: window.location.href,\n      scope: 'public_repo',\n      state: this.state,\n    })\n  }\n\n  /**\n   * Handle authorization.\n   *\n   * @remarks\n   * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.\n   *\n   * @return A string for access token, `null` for no authorization code\n   */\n  async handleAuth (): Promise<string | null> {\n    const query = parseQuery(window.location.search)\n    if (query.code) {\n      if (query.state !== this.state) {\n        return null\n      }\n      const code = query.code\n      delete query.code\n      delete query.state\n      const replaceURL = buildURL(getCleanURL(window.location.href), query) + window.location.hash\n      window.history.replaceState(null, '', replaceURL)\n      const accessToken = await this.getAccessToken({ code })\n      return accessToken\n    }\n    return null\n  }\n\n  /**\n   * Get user access token via `code`\n   *\n   * @param options.code - The code from the query\n   *\n   * @return User access token\n   */\n  async getAccessToken ({ code }: { code: string }): Promise<string> {\n    /**\n     * access_token api does not support cors\n     * @see https://github.com/isaacs/github/issues/330\n     */\n    const { data } = await this.$http.post(`https://cors-anywhere.herokuapp.com/${'https://github.com/login/oauth/access_token'}`, {\n      client_id: this.clientId,\n      client_secret: this.clientSecret,\n      code,\n      /**\n       * useless but mentioned in docs\n       * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github\n       */\n      // redirect_uri: window.location.href,\n      // state: this.state,\n    }, {\n      headers: {\n        'Accept': 'application/json',\n      },\n    })\n    return data.access_token\n  }\n\n  /**\n   * Get the logined user with access token.\n   *\n   * @param options.accessToken - User access token\n   *\n   * @return The user\n   */\n  async getUser ({ accessToken }): Promise<VssueAPI.User> {\n    const { data } = await this.$http.get('/user', {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return normalizeUser(data)\n  }\n\n  /**\n   * Get issue of this page according to the issue id or the issue title\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.issueTitle - The title of issue\n   *\n   * @return The raw response of issue\n   */\n  async getIssue ({\n    accessToken,\n    issueId,\n    issueTitle,\n  }): Promise<VssueAPI.Issue | null> {\n    const options: AxiosRequestConfig = {}\n\n    if (accessToken) {\n      options.headers = {\n        'Authorization': `token ${accessToken}`,\n      }\n    }\n\n    if (issueId) {\n      try {\n        options.params = {\n          // to avoid caching\n          timestamp: Date.now(),\n        }\n        const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, options)\n        return normalizeIssue(data)\n      } catch (e) {\n        if (e.response && e.response.status === 404) {\n          return null\n        } else {\n          throw e\n        }\n      }\n    } else {\n      options.params = {\n        labels: this.labels,\n        sort: 'created',\n        direction: 'asc',\n        // to avoid caching\n        timestamp: Date.now(),\n      }\n      const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues`, options)\n      const issue = data.map(normalizeIssue).find(item => item.title === issueTitle)\n      return issue || null\n    }\n  }\n\n  /**\n   * Get comments of this page according to the issue id or the issue title\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.query - The query parameters\n   *\n   * @return The comments\n   */\n  async getComments ({\n    accessToken,\n    issueId,\n    query: {\n      page = 1,\n      perPage = 10,\n      sort = 'desc',\n    } = {},\n  }): Promise<VssueAPI.Comments> {\n    const issueOptions: AxiosRequestConfig = {\n      params: {\n        // to avoid caching\n        timestamp: Date.now(),\n      },\n    }\n    const commentsOptions: AxiosRequestConfig = {\n      params: {\n        // pagination\n        'page': page,\n        'per_page': perPage,\n        /**\n         * github v3 api does not support sort for issue comments\n         * have sent feedback to github support\n         */\n        // 'sort': 'created',\n        // 'direction': sort,\n        // to avoid caching\n        'timestamp': Date.now(),\n      },\n      headers: {\n        'Accept': [\n          'application/vnd.github.v3.raw+json',\n          'application/vnd.github.v3.html+json',\n          'application/vnd.github.squirrel-girl-preview',\n        ],\n      },\n    }\n    if (accessToken) {\n      issueOptions.headers = {\n        'Authorization': `token ${accessToken}`,\n      }\n      commentsOptions.headers['Authorization'] = `token ${accessToken}`\n    }\n\n    // github v3 have to get the total count of comments by requesting the issue\n    const [issueRes, commentsRes] = await Promise.all([\n      this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, issueOptions),\n      this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, commentsOptions),\n    ])\n\n    // it's annoying that have to get the page and per_page from the `Link` header\n    const linkHeader = commentsRes.headers['link'] || null\n\n    return {\n      count: Number(issueRes.data.comments),\n      page: page,\n      perPage: linkHeader ? Number(linkHeader.replace(/^.*per_page=(\\d*).*$/, '$1')) : perPage,\n      data: commentsRes.data.map(normalizeComment),\n    }\n  }\n\n  /**\n   * Create a new issue\n   *\n   * @param options.accessToken - User access token\n   * @param options.title - The title of issue\n   * @param options.content - The content of issue\n   *\n   * @return The created issue\n   */\n  async createIssue ({\n    accessToken,\n    title,\n    content,\n  }): Promise<VssueAPI.Issue> {\n    const { data } = await this.$http.post(`repos/${this.owner}/${this.repo}/issues`, {\n      title,\n      body: content,\n      labels: this.labels.split(','),\n    }, {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return normalizeIssue(data)\n  }\n\n  /**\n   * Create a new comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.content - The content of comment\n   *\n   * @return The created comment\n   */\n  async createComment ({\n    accessToken,\n    issueId,\n    content,\n  }): Promise<VssueAPI.Comment> {\n    const { data } = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {\n      body: content,\n    }, {\n      headers: {\n        'Authorization': `token ${accessToken}`,\n        'Accept': [\n          'application/vnd.github.v3.raw+json',\n          'application/vnd.github.v3.html+json',\n          'application/vnd.github.squirrel-girl-preview',\n        ],\n      },\n    })\n    return normalizeComment(data)\n  }\n\n  /**\n   * Create a new reaction of issue\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.reaction - The reaction\n   *\n   * @return `true` if succeed, `false` if already token\n   */\n  async createIssueReaction ({\n    accessToken,\n    issueId,\n    reaction,\n  }): Promise<boolean> {\n    const response = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/${issueId}/reactions`, {\n      content: mapReactionName(reaction),\n    }, {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return response.status === 201\n  }\n\n  /**\n   * Create a new reaction of comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.commentId - The id of comment\n   * @param options.reaction - The reaction\n   *\n   * @return `true` if succeed, `false` if already token\n   */\n  async createCommentReaction ({\n    accessToken,\n    issueId,\n    commentId,\n    reaction,\n  }): Promise<boolean> {\n    const response = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}/reactions`, {\n      content: mapReactionName(reaction),\n    }, {\n      headers: {\n        'Authorization': `token ${accessToken}`,\n        'Accept': 'application/vnd.github.squirrel-girl-preview',\n      },\n    })\n    return response.status === 201\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { VssueAPI } from '../../../vssue/types'\n\nimport axios, {\n  AxiosInstance,\n  AxiosRequestConfig,\n} from 'axios'\n\nimport {\n  buildURL,\n  getCleanURL,\n  parseQuery,\n} from '@vssue/utils'\n\nimport {\n  normalizeUser,\n  normalizeIssue,\n  normalizeComment,\n  normalizeReactions,\n  mapReactionName,\n} from './utils'\n\n/**\n * Github REST API v3\n *\n * @see https://developer.github.com/v3/\n * @see https://developer.github.com/apps/building-oauth-apps/\n */\nexport default class GithubV3 implements VssueAPI.Instance {\n  baseURL: string\n  owner: string\n  repo: string\n  labels: string\n  clientId: string\n  clientSecret: string\n  state: string\n  $http: AxiosInstance\n\n  constructor ({\n    baseURL = 'https://api.github.com',\n    owner,\n    repo,\n    labels,\n    clientId,\n    clientSecret,\n    state,\n  }: VssueAPI.Options) {\n    this.baseURL = baseURL\n    this.owner = owner\n    this.repo = repo\n    this.labels = labels.join(',')\n\n    this.clientId = clientId\n    this.clientSecret = clientSecret\n    this.state = state\n\n    this.$http = axios.create({\n      baseURL,\n      headers: {\n        'Accept': 'application/vnd.github.v3+json',\n      },\n    })\n\n    this.$http.interceptors.response.use(function (response) {\n      if (response.data.error) {\n        return Promise.reject(response.data.error_description)\n      }\n      return response\n    })\n  }\n\n  /**\n   * The platform api info\n   */\n  get platform (): VssueAPI.Platform {\n    return {\n      name: 'GitHub',\n      link: 'https://github.com',\n      version: 'v3',\n      meta: {\n        reactable: true,\n        sortable: false,\n      },\n    }\n  }\n\n  /**\n   * Redirect to the authorization page of platform.\n   *\n   * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#1-request-a-users-github-identity\n   */\n  redirectAuth (): void {\n    window.location.href = buildURL('https://github.com/login/oauth/authorize', {\n      client_id: this.clientId,\n      redirect_uri: window.location.href,\n      scope: 'public_repo',\n      state: this.state,\n    })\n  }\n\n  /**\n   * Handle authorization.\n   *\n   * @return A string for access token, `null` for no authorization code\n   *\n   * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/\n   *\n   * @remarks\n   * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.\n   */\n  async handleAuth (): Promise<VssueAPI.AccessToken> {\n    const query = parseQuery(window.location.search)\n    if (query.code) {\n      if (query.state !== this.state) {\n        return null\n      }\n      const code = query.code\n      delete query.code\n      delete query.state\n      const replaceURL = buildURL(getCleanURL(window.location.href), query) + window.location.hash\n      window.history.replaceState(null, '', replaceURL)\n      const accessToken = await this.getAccessToken({ code })\n      return accessToken\n    }\n    return null\n  }\n\n  /**\n   * Get user access token via `code`\n   *\n   * @param options.code - The code from the query\n   *\n   * @return User access token\n   *\n   * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github\n   */\n  async getAccessToken ({\n    code,\n  }: {\n    code: string\n  }): Promise<string> {\n    /**\n     * access_token api does not support cors\n     * @see https://github.com/isaacs/github/issues/330\n     */\n    const { data } = await this.$http.post(`https://cors-anywhere.herokuapp.com/${'https://github.com/login/oauth/access_token'}`, {\n      client_id: this.clientId,\n      client_secret: this.clientSecret,\n      code,\n      /**\n       * useless but mentioned in docs\n       */\n      // redirect_uri: window.location.href,\n      // state: this.state,\n    }, {\n      headers: {\n        'Accept': 'application/json',\n      },\n    })\n    return data.access_token\n  }\n\n  /**\n   * Get the logined user with access token.\n   *\n   * @param options.accessToken - User access token\n   *\n   * @return The user\n   *\n   * @see https://developer.github.com/v3/users/#get-the-authenticated-user\n   */\n  async getUser ({\n    accessToken,\n  }: {\n    accessToken: VssueAPI.AccessToken\n  }): Promise<VssueAPI.User> {\n    const { data } = await this.$http.get('/user', {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return normalizeUser(data)\n  }\n\n  /**\n   * Get issue of this page according to the issue id or the issue title\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.issueTitle - The title of issue\n   *\n   * @return The raw response of issue\n   *\n   * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n   * @see https://developer.github.com/v3/issues/#get-a-single-issue\n   * @see https://developer.github.com/v3/#pagination\n   */\n  async getIssue ({\n    accessToken,\n    issueId,\n    issueTitle,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId?: string | number\n    issueTitle?: string\n  }): Promise<VssueAPI.Issue | null> {\n    const options: AxiosRequestConfig = {}\n\n    if (accessToken) {\n      options.headers = {\n        'Authorization': `token ${accessToken}`,\n      }\n    }\n\n    if (issueId) {\n      try {\n        options.params = {\n          // to avoid caching\n          timestamp: Date.now(),\n        }\n        const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, options)\n        return normalizeIssue(data)\n      } catch (e) {\n        if (e.response && e.response.status === 404) {\n          return null\n        } else {\n          throw e\n        }\n      }\n    } else {\n      options.params = {\n        labels: this.labels,\n        sort: 'created',\n        direction: 'asc',\n        // to avoid caching\n        timestamp: Date.now(),\n      }\n      const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues`, options)\n      const issue = data.map(normalizeIssue).find(item => item.title === issueTitle)\n      return issue || null\n    }\n  }\n\n  /**\n   * Create a new issue\n   *\n   * @param options.accessToken - User access token\n   * @param options.title - The title of issue\n   * @param options.content - The content of issue\n   *\n   * @return The created issue\n   *\n   * @see https://developer.github.com/v3/issues/#create-an-issue\n   */\n  async postIssue ({\n    accessToken,\n    title,\n    content,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    title: string\n    content: string\n  }): Promise<VssueAPI.Issue> {\n    const { data } = await this.$http.post(`repos/${this.owner}/${this.repo}/issues`, {\n      title,\n      body: content,\n      labels: this.labels.split(','),\n    }, {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return normalizeIssue(data)\n  }\n\n  /**\n   * Get comments of this page according to the issue id or the issue title\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.query - The query parameters\n   *\n   * @return The comments\n   *\n   * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n   * @see https://developer.github.com/v3/#pagination\n   *\n   * @reamrks\n   * Github V3 does not support sort for issue comments now.\n   * Github V3 have to request the parent issue to get the count of comments.\n   */\n  async getComments ({\n    accessToken,\n    issueId,\n    query: {\n      page = 1,\n      perPage = 10,\n      sort = 'desc',\n    } = {},\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId: string | number\n    query?: Partial<VssueAPI.Query>\n  }): Promise<VssueAPI.Comments> {\n    const issueOptions: AxiosRequestConfig = {\n      params: {\n        // to avoid caching\n        timestamp: Date.now(),\n      },\n    }\n    const commentsOptions: AxiosRequestConfig = {\n      params: {\n        // pagination\n        'page': page,\n        'per_page': perPage,\n        /**\n         * github v3 api does not support sort for issue comments\n         * have sent feedback to github support\n         */\n        // 'sort': 'created',\n        // 'direction': sort,\n        // to avoid caching\n        'timestamp': Date.now(),\n      },\n      headers: {\n        'Accept': [\n          'application/vnd.github.v3.raw+json',\n          'application/vnd.github.v3.html+json',\n          'application/vnd.github.squirrel-girl-preview',\n        ],\n      },\n    }\n    if (accessToken) {\n      issueOptions.headers = {\n        'Authorization': `token ${accessToken}`,\n      }\n      commentsOptions.headers['Authorization'] = `token ${accessToken}`\n    }\n\n    // github v3 have to get the total count of comments by requesting the issue\n    const [issueRes, commentsRes] = await Promise.all([\n      this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, issueOptions),\n      this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, commentsOptions),\n    ])\n\n    // it's annoying that have to get the page and per_page from the `Link` header\n    const linkHeader = commentsRes.headers['link'] || null\n\n    return {\n      count: Number(issueRes.data.comments),\n      page: page,\n      perPage: linkHeader ? Number(linkHeader.replace(/^.*per_page=(\\d*).*$/, '$1')) : perPage,\n      data: commentsRes.data.map(normalizeComment),\n    }\n  }\n\n  /**\n   * Create a new comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.issueId - The id of issue\n   * @param options.content - The content of comment\n   *\n   * @return The created comment\n   *\n   * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n   */\n  async postComment ({\n    accessToken,\n    issueId,\n    content,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId: string | number\n    content: string\n  }): Promise<VssueAPI.Comment> {\n    const { data } = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {\n      body: content,\n    }, {\n      headers: {\n        'Authorization': `token ${accessToken}`,\n        'Accept': [\n          'application/vnd.github.v3.raw+json',\n          'application/vnd.github.v3.html+json',\n          'application/vnd.github.squirrel-girl-preview',\n        ],\n      },\n    })\n    return normalizeComment(data)\n  }\n\n  /**\n   * Delete a comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.commentId - The id of comment\n   *\n   * @return `true` if succeed, `false` if failed\n   *\n   * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n   */\n  async deleteComment ({\n    accessToken,\n    commentId,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId: string | number\n    commentId: string | number\n  }): Promise<boolean> {\n    const { status } = await this.$http.delete(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {\n      headers: { 'Authorization': `token ${accessToken}` },\n    })\n    return status === 204\n  }\n\n  /**\n   * Get reactions of a comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.commentId - The id of comment\n   *\n   * @return The comments\n   *\n   * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n   * @see https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment\n   *\n   * @remarks\n   * The `List reactions for an issue comment` API also returns author of each reaction.\n   * As we only need the count, use the `Get a single comment` API is much simpler.\n   */\n  async getCommentReactions ({\n    accessToken,\n    commentId,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId: string | number\n    commentId: string | number\n  }): Promise<VssueAPI.Reactions> {\n    const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {\n      headers: {\n        'Authorization': `token ${accessToken}`,\n        'Accept': 'application/vnd.github.squirrel-girl-preview',\n      },\n    })\n    return normalizeReactions(data.reactions)\n  }\n\n  /**\n   * Create a new reaction of a comment\n   *\n   * @param options.accessToken - User access token\n   * @param options.commentId - The id of comment\n   * @param options.reaction - The reaction\n   *\n   * @return `true` if succeed, `false` if already token\n   *\n   * @see https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment\n   */\n  async postCommentReaction ({\n    accessToken,\n    commentId,\n    reaction,\n  }: {\n    accessToken: VssueAPI.AccessToken\n    issueId: string | number\n    commentId: string | number\n    reaction: keyof VssueAPI.Reactions\n  }): Promise<boolean> {\n    const response = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}/reactions`, {\n      content: mapReactionName(reaction),\n    }, {\n      headers: {\n        'Authorization': `token ${accessToken}`,\n        'Accept': 'application/vnd.github.squirrel-girl-preview',\n      },\n    })\n    return response.status === 201\n  }\n}\n"]}

package.json

 {
   "name": "@vssue/api-github-v3",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Vssue api for github v3",
@@ -29,9 +29,9 @@ "license": "MIT",
   "dependencies": {
-    "@vssue/utils": "^0.2.0",
+    "@vssue/utils": "^0.3.0",
     "axios": "^0.18.0"
   },
   "peerDependencies": {
-    "vssue": "^0.1.0"
+    "vssue": "^0.3.0"
   },
-  "gitHead": "b766459604ded3b56082a642a88e211433c7dbc2"
+  "gitHead": "3f37354a2ba2477e39dbaa2d9bd773d174837a24"
 }

types/index.d.ts

@@ -1,10 +0,8 @@
-import { VssueAPI, VssueAPIOptions } from 'vssue';
+import { VssueAPI } from '../../../vssue/types';
 import { AxiosInstance } from 'axios';
 /**
- * Github API v3
+ * Github REST API v3
  *
- * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/
- * @see https://developer.github.com/v3/issues/
- * @see https://developer.github.com/v3/issues/comments/
- * @see https://developer.github.com/v3/reactions/
+ * @see https://developer.github.com/v3/
+ * @see https://developer.github.com/apps/building-oauth-apps/
  */
@@ -20,3 +18,3 @@ export default class GithubV3 implements VssueAPI.Instance {
     $http: AxiosInstance;
-    constructor({ baseURL, owner, repo, labels, clientId, clientSecret, state, }: VssueAPIOptions);
+    constructor({ baseURL, owner, repo, labels, clientId, clientSecret, state, }: VssueAPI.Options);
     /**
@@ -28,2 +26,4 @@ * The platform api info
      * Redirect to the authorization page of platform.
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#1-request-a-users-github-identity
      */
@@ -34,8 +34,10 @@ redirectAuth(): void;
      *
+     * @return A string for access token, `null` for no authorization code
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/
+     *
      * @remarks
      * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.
-     *
-     * @return A string for access token, `null` for no authorization code
      */
-    handleAuth(): Promise<string | null>;
+    handleAuth(): Promise<VssueAPI.AccessToken>;
     /**
@@ -47,4 +49,6 @@ * Get user access token via `code`
      * @return User access token
+     *
+     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github
      */
-    getAccessToken({ code }: {
+    getAccessToken({ code, }: {
         code: string;
@@ -58,5 +62,7 @@ }): Promise<string>;
      * @return The user
+     *
+     * @see https://developer.github.com/v3/users/#get-the-authenticated-user
      */
-    getUser({ accessToken }: {
-        accessToken: any;
+    getUser({ accessToken, }: {
+        accessToken: VssueAPI.AccessToken;
     }): Promise<VssueAPI.User>;
@@ -71,9 +77,29 @@ /**
      * @return The raw response of issue
+     *
+     * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository
+     * @see https://developer.github.com/v3/issues/#get-a-single-issue
+     * @see https://developer.github.com/v3/#pagination
      */
     getIssue({ accessToken, issueId, issueTitle, }: {
-        accessToken: any;
-        issueId: any;
-        issueTitle: any;
+        accessToken: VssueAPI.AccessToken;
+        issueId?: string | number;
+        issueTitle?: string;
     }): Promise<VssueAPI.Issue | null>;
     /**
+     * Create a new issue
+     *
+     * @param options.accessToken - User access token
+     * @param options.title - The title of issue
+     * @param options.content - The content of issue
+     *
+     * @return The created issue
+     *
+     * @see https://developer.github.com/v3/issues/#create-an-issue
+     */
+    postIssue({ accessToken, title, content, }: {
+        accessToken: VssueAPI.AccessToken;
+        title: string;
+        content: string;
+    }): Promise<VssueAPI.Issue>;
+    /**
      * Get comments of this page according to the issue id or the issue title
@@ -86,27 +112,16 @@ *
      * @return The comments
+     *
+     * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
+     * @see https://developer.github.com/v3/#pagination
+     *
+     * @reamrks
+     * Github V3 does not support sort for issue comments now.
+     * Github V3 have to request the parent issue to get the count of comments.
      */
     getComments({ accessToken, issueId, query: { page, perPage, sort, }, }: {
-        accessToken: any;
-        issueId: any;
-        query?: {
-            page?: number | undefined;
-            perPage?: number | undefined;
-            sort?: string | undefined;
-        } | undefined;
+        accessToken: VssueAPI.AccessToken;
+        issueId: string | number;
+        query?: Partial<VssueAPI.Query>;
     }): Promise<VssueAPI.Comments>;
     /**
-     * Create a new issue
-     *
-     * @param options.accessToken - User access token
-     * @param options.title - The title of issue
-     * @param options.content - The content of issue
-     *
-     * @return The created issue
-     */
-    createIssue({ accessToken, title, content, }: {
-        accessToken: any;
-        title: any;
-        content: any;
-    }): Promise<VssueAPI.Issue>;
-    /**
      * Create a new comment
@@ -119,38 +134,62 @@ *
      * @return The created comment
+     *
+     * @see https://developer.github.com/v3/issues/comments/#create-a-comment
      */
-    createComment({ accessToken, issueId, content, }: {
-        accessToken: any;
-        issueId: any;
-        content: any;
+    postComment({ accessToken, issueId, content, }: {
+        accessToken: VssueAPI.AccessToken;
+        issueId: string | number;
+        content: string;
     }): Promise<VssueAPI.Comment>;
     /**
-     * Create a new reaction of issue
+     * Delete a comment
      *
      * @param options.accessToken - User access token
-     * @param options.issueId - The id of issue
-     * @param options.reaction - The reaction
+     * @param options.commentId - The id of comment
      *
-     * @return `true` if succeed, `false` if already token
+     * @return `true` if succeed, `false` if failed
+     *
+     * @see https://developer.github.com/v3/issues/comments/#delete-a-comment
      */
-    createIssueReaction({ accessToken, issueId, reaction, }: {
-        accessToken: any;
-        issueId: any;
-        reaction: any;
+    deleteComment({ accessToken, commentId, }: {
+        accessToken: VssueAPI.AccessToken;
+        issueId: string | number;
+        commentId: string | number;
     }): Promise<boolean>;
     /**
-     * Create a new reaction of comment
+     * Get reactions of a comment
      *
      * @param options.accessToken - User access token
-     * @param options.issueId - The id of issue
      * @param options.commentId - The id of comment
+     *
+     * @return The comments
+     *
+     * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment
+     * @see https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment
+     *
+     * @remarks
+     * The `List reactions for an issue comment` API also returns author of each reaction.
+     * As we only need the count, use the `Get a single comment` API is much simpler.
+     */
+    getCommentReactions({ accessToken, commentId, }: {
+        accessToken: VssueAPI.AccessToken;
+        issueId: string | number;
+        commentId: string | number;
+    }): Promise<VssueAPI.Reactions>;
+    /**
+     * Create a new reaction of a comment
+     *
+     * @param options.accessToken - User access token
+     * @param options.commentId - The id of comment
      * @param options.reaction - The reaction
      *
      * @return `true` if succeed, `false` if already token
+     *
+     * @see https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment
      */
-    createCommentReaction({ accessToken, issueId, commentId, reaction, }: {
-        accessToken: any;
-        issueId: any;
-        commentId: any;
-        reaction: any;
+    postCommentReaction({ accessToken, commentId, reaction, }: {
+        accessToken: VssueAPI.AccessToken;
+        issueId: string | number;
+        commentId: string | number;
+        reaction: keyof VssueAPI.Reactions;
     }): Promise<boolean>;
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

61664

increased by15.87%

Lines of code

709

increased by15.28%

Number of medium supply chain risk alerts

0

decreased by-100%

Dependency changes

• + Added@vssue/api-bitbucket-v2@0.3.1(transitive)

• + Added@vssue/api-github-v3@0.3.1(transitive)

• + Added@vssue/api-gitlab-v4@0.3.1(transitive)

• + Added@vssue/utils@0.3.1(transitive)

• + Addedvssue@0.3.1(transitive)

• - Removed@vssue/api-bitbucket-v2@0.1.9(transitive)

• - Removed@vssue/api-github-v3@0.1.9(transitive)

• - Removed@vssue/api-gitlab-v4@0.1.9(transitive)

• - Removed@vssue/utils@0.1.20.2.0(transitive)

• - Removedvssue@0.1.9(transitive)

• Updated@vssue/utils@^0.3.0