mirror of
https://gitea.com/Lydanne/issues-helper.git
synced 2025-08-19 18:25:58 +08:00
8908 lines
270 KiB
JavaScript
8908 lines
270 KiB
JavaScript
module.exports =
|
||
/******/ (() => { // webpackBootstrap
|
||
/******/ var __webpack_modules__ = ({
|
||
|
||
/***/ 7351:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
const os = __importStar(__webpack_require__(2087));
|
||
const utils_1 = __webpack_require__(5278);
|
||
/**
|
||
* Commands
|
||
*
|
||
* Command Format:
|
||
* ::name key=value,key=value::message
|
||
*
|
||
* Examples:
|
||
* ::warning::This is the message
|
||
* ::set-env name=MY_VAR::some value
|
||
*/
|
||
function issueCommand(command, properties, message) {
|
||
const cmd = new Command(command, properties, message);
|
||
process.stdout.write(cmd.toString() + os.EOL);
|
||
}
|
||
exports.issueCommand = issueCommand;
|
||
function issue(name, message = '') {
|
||
issueCommand(name, {}, message);
|
||
}
|
||
exports.issue = issue;
|
||
const CMD_STRING = '::';
|
||
class Command {
|
||
constructor(command, properties, message) {
|
||
if (!command) {
|
||
command = 'missing.command';
|
||
}
|
||
this.command = command;
|
||
this.properties = properties;
|
||
this.message = message;
|
||
}
|
||
toString() {
|
||
let cmdStr = CMD_STRING + this.command;
|
||
if (this.properties && Object.keys(this.properties).length > 0) {
|
||
cmdStr += ' ';
|
||
let first = true;
|
||
for (const key in this.properties) {
|
||
if (this.properties.hasOwnProperty(key)) {
|
||
const val = this.properties[key];
|
||
if (val) {
|
||
if (first) {
|
||
first = false;
|
||
}
|
||
else {
|
||
cmdStr += ',';
|
||
}
|
||
cmdStr += `${key}=${escapeProperty(val)}`;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
||
return cmdStr;
|
||
}
|
||
}
|
||
function escapeData(s) {
|
||
return utils_1.toCommandValue(s)
|
||
.replace(/%/g, '%25')
|
||
.replace(/\r/g, '%0D')
|
||
.replace(/\n/g, '%0A');
|
||
}
|
||
function escapeProperty(s) {
|
||
return utils_1.toCommandValue(s)
|
||
.replace(/%/g, '%25')
|
||
.replace(/\r/g, '%0D')
|
||
.replace(/\n/g, '%0A')
|
||
.replace(/:/g, '%3A')
|
||
.replace(/,/g, '%2C');
|
||
}
|
||
//# sourceMappingURL=command.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2186:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
const command_1 = __webpack_require__(7351);
|
||
const file_command_1 = __webpack_require__(717);
|
||
const utils_1 = __webpack_require__(5278);
|
||
const os = __importStar(__webpack_require__(2087));
|
||
const path = __importStar(__webpack_require__(5622));
|
||
/**
|
||
* The code to exit an action
|
||
*/
|
||
var ExitCode;
|
||
(function (ExitCode) {
|
||
/**
|
||
* A code indicating that the action was successful
|
||
*/
|
||
ExitCode[ExitCode["Success"] = 0] = "Success";
|
||
/**
|
||
* A code indicating that the action was a failure
|
||
*/
|
||
ExitCode[ExitCode["Failure"] = 1] = "Failure";
|
||
})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
|
||
//-----------------------------------------------------------------------
|
||
// Variables
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Sets env variable for this action and future actions in the job
|
||
* @param name the name of the variable to set
|
||
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function exportVariable(name, val) {
|
||
const convertedVal = utils_1.toCommandValue(val);
|
||
process.env[name] = convertedVal;
|
||
const filePath = process.env['GITHUB_ENV'] || '';
|
||
if (filePath) {
|
||
const delimiter = '_GitHubActionsFileCommandDelimeter_';
|
||
const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
|
||
file_command_1.issueCommand('ENV', commandValue);
|
||
}
|
||
else {
|
||
command_1.issueCommand('set-env', { name }, convertedVal);
|
||
}
|
||
}
|
||
exports.exportVariable = exportVariable;
|
||
/**
|
||
* Registers a secret which will get masked from logs
|
||
* @param secret value of the secret
|
||
*/
|
||
function setSecret(secret) {
|
||
command_1.issueCommand('add-mask', {}, secret);
|
||
}
|
||
exports.setSecret = setSecret;
|
||
/**
|
||
* Prepends inputPath to the PATH (for this action and future actions)
|
||
* @param inputPath
|
||
*/
|
||
function addPath(inputPath) {
|
||
const filePath = process.env['GITHUB_PATH'] || '';
|
||
if (filePath) {
|
||
file_command_1.issueCommand('PATH', inputPath);
|
||
}
|
||
else {
|
||
command_1.issueCommand('add-path', {}, inputPath);
|
||
}
|
||
process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
|
||
}
|
||
exports.addPath = addPath;
|
||
/**
|
||
* Gets the value of an input. The value is also trimmed.
|
||
*
|
||
* @param name name of the input to get
|
||
* @param options optional. See InputOptions.
|
||
* @returns string
|
||
*/
|
||
function getInput(name, options) {
|
||
const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
|
||
if (options && options.required && !val) {
|
||
throw new Error(`Input required and not supplied: ${name}`);
|
||
}
|
||
return val.trim();
|
||
}
|
||
exports.getInput = getInput;
|
||
/**
|
||
* Sets the value of an output.
|
||
*
|
||
* @param name name of the output to set
|
||
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function setOutput(name, value) {
|
||
command_1.issueCommand('set-output', { name }, value);
|
||
}
|
||
exports.setOutput = setOutput;
|
||
/**
|
||
* Enables or disables the echoing of commands into stdout for the rest of the step.
|
||
* Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
|
||
*
|
||
*/
|
||
function setCommandEcho(enabled) {
|
||
command_1.issue('echo', enabled ? 'on' : 'off');
|
||
}
|
||
exports.setCommandEcho = setCommandEcho;
|
||
//-----------------------------------------------------------------------
|
||
// Results
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Sets the action status to failed.
|
||
* When the action exits it will be with an exit code of 1
|
||
* @param message add error issue message
|
||
*/
|
||
function setFailed(message) {
|
||
process.exitCode = ExitCode.Failure;
|
||
error(message);
|
||
}
|
||
exports.setFailed = setFailed;
|
||
//-----------------------------------------------------------------------
|
||
// Logging Commands
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Gets whether Actions Step Debug is on or not
|
||
*/
|
||
function isDebug() {
|
||
return process.env['RUNNER_DEBUG'] === '1';
|
||
}
|
||
exports.isDebug = isDebug;
|
||
/**
|
||
* Writes debug message to user log
|
||
* @param message debug message
|
||
*/
|
||
function debug(message) {
|
||
command_1.issueCommand('debug', {}, message);
|
||
}
|
||
exports.debug = debug;
|
||
/**
|
||
* Adds an error issue
|
||
* @param message error issue message. Errors will be converted to string via toString()
|
||
*/
|
||
function error(message) {
|
||
command_1.issue('error', message instanceof Error ? message.toString() : message);
|
||
}
|
||
exports.error = error;
|
||
/**
|
||
* Adds an warning issue
|
||
* @param message warning issue message. Errors will be converted to string via toString()
|
||
*/
|
||
function warning(message) {
|
||
command_1.issue('warning', message instanceof Error ? message.toString() : message);
|
||
}
|
||
exports.warning = warning;
|
||
/**
|
||
* Writes info to log with console.log.
|
||
* @param message info message
|
||
*/
|
||
function info(message) {
|
||
process.stdout.write(message + os.EOL);
|
||
}
|
||
exports.info = info;
|
||
/**
|
||
* Begin an output group.
|
||
*
|
||
* Output until the next `groupEnd` will be foldable in this group
|
||
*
|
||
* @param name The name of the output group
|
||
*/
|
||
function startGroup(name) {
|
||
command_1.issue('group', name);
|
||
}
|
||
exports.startGroup = startGroup;
|
||
/**
|
||
* End an output group.
|
||
*/
|
||
function endGroup() {
|
||
command_1.issue('endgroup');
|
||
}
|
||
exports.endGroup = endGroup;
|
||
/**
|
||
* Wrap an asynchronous function call in a group.
|
||
*
|
||
* Returns the same type as the function itself.
|
||
*
|
||
* @param name The name of the group
|
||
* @param fn The function to wrap in the group
|
||
*/
|
||
function group(name, fn) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
startGroup(name);
|
||
let result;
|
||
try {
|
||
result = yield fn();
|
||
}
|
||
finally {
|
||
endGroup();
|
||
}
|
||
return result;
|
||
});
|
||
}
|
||
exports.group = group;
|
||
//-----------------------------------------------------------------------
|
||
// Wrapper action state
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Saves state for current action, the state can only be retrieved by this action's post job execution.
|
||
*
|
||
* @param name name of the state to store
|
||
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function saveState(name, value) {
|
||
command_1.issueCommand('save-state', { name }, value);
|
||
}
|
||
exports.saveState = saveState;
|
||
/**
|
||
* Gets the value of an state set by this action's main execution.
|
||
*
|
||
* @param name name of the state to get
|
||
* @returns string
|
||
*/
|
||
function getState(name) {
|
||
return process.env[`STATE_${name}`] || '';
|
||
}
|
||
exports.getState = getState;
|
||
//# sourceMappingURL=core.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 717:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// For internal use, subject to change.
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
// We use any as a valid input type
|
||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||
const fs = __importStar(__webpack_require__(5747));
|
||
const os = __importStar(__webpack_require__(2087));
|
||
const utils_1 = __webpack_require__(5278);
|
||
function issueCommand(command, message) {
|
||
const filePath = process.env[`GITHUB_${command}`];
|
||
if (!filePath) {
|
||
throw new Error(`Unable to find environment variable for file command ${command}`);
|
||
}
|
||
if (!fs.existsSync(filePath)) {
|
||
throw new Error(`Missing file at path: ${filePath}`);
|
||
}
|
||
fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
|
||
encoding: 'utf8'
|
||
});
|
||
}
|
||
exports.issueCommand = issueCommand;
|
||
//# sourceMappingURL=file-command.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5278:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
// We use any as a valid input type
|
||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
/**
|
||
* Sanitizes an input into a string so it can be passed into issueCommand safely
|
||
* @param input input to sanitize into a string
|
||
*/
|
||
function toCommandValue(input) {
|
||
if (input === null || input === undefined) {
|
||
return '';
|
||
}
|
||
else if (typeof input === 'string' || input instanceof String) {
|
||
return input;
|
||
}
|
||
return JSON.stringify(input);
|
||
}
|
||
exports.toCommandValue = toCommandValue;
|
||
//# sourceMappingURL=utils.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4087:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
exports.Context = void 0;
|
||
const fs_1 = __webpack_require__(5747);
|
||
const os_1 = __webpack_require__(2087);
|
||
class Context {
|
||
/**
|
||
* Hydrate the context from the environment
|
||
*/
|
||
constructor() {
|
||
this.payload = {};
|
||
if (process.env.GITHUB_EVENT_PATH) {
|
||
if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) {
|
||
this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' }));
|
||
}
|
||
else {
|
||
const path = process.env.GITHUB_EVENT_PATH;
|
||
process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`);
|
||
}
|
||
}
|
||
this.eventName = process.env.GITHUB_EVENT_NAME;
|
||
this.sha = process.env.GITHUB_SHA;
|
||
this.ref = process.env.GITHUB_REF;
|
||
this.workflow = process.env.GITHUB_WORKFLOW;
|
||
this.action = process.env.GITHUB_ACTION;
|
||
this.actor = process.env.GITHUB_ACTOR;
|
||
this.job = process.env.GITHUB_JOB;
|
||
this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
|
||
this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
|
||
}
|
||
get issue() {
|
||
const payload = this.payload;
|
||
return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number });
|
||
}
|
||
get repo() {
|
||
if (process.env.GITHUB_REPOSITORY) {
|
||
const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
|
||
return { owner, repo };
|
||
}
|
||
if (this.payload.repository) {
|
||
return {
|
||
owner: this.payload.repository.owner.login,
|
||
repo: this.payload.repository.name
|
||
};
|
||
}
|
||
throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'");
|
||
}
|
||
}
|
||
exports.Context = Context;
|
||
//# sourceMappingURL=context.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5438:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
exports.getOctokit = exports.context = void 0;
|
||
const Context = __importStar(__webpack_require__(4087));
|
||
const utils_1 = __webpack_require__(3030);
|
||
exports.context = new Context.Context();
|
||
/**
|
||
* Returns a hydrated octokit ready to use for GitHub Actions
|
||
*
|
||
* @param token the repo PAT or GITHUB_TOKEN
|
||
* @param options other options to set
|
||
*/
|
||
function getOctokit(token, options) {
|
||
return new utils_1.GitHub(utils_1.getOctokitOptions(token, options));
|
||
}
|
||
exports.getOctokit = getOctokit;
|
||
//# sourceMappingURL=github.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7914:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0;
|
||
const httpClient = __importStar(__webpack_require__(9925));
|
||
function getAuthString(token, options) {
|
||
if (!token && !options.auth) {
|
||
throw new Error('Parameter token or opts.auth is required');
|
||
}
|
||
else if (token && options.auth) {
|
||
throw new Error('Parameters token and opts.auth may not both be specified');
|
||
}
|
||
return typeof options.auth === 'string' ? options.auth : `token ${token}`;
|
||
}
|
||
exports.getAuthString = getAuthString;
|
||
function getProxyAgent(destinationUrl) {
|
||
const hc = new httpClient.HttpClient();
|
||
return hc.getAgent(destinationUrl);
|
||
}
|
||
exports.getProxyAgent = getProxyAgent;
|
||
function getApiBaseUrl() {
|
||
return process.env['GITHUB_API_URL'] || 'https://api.github.com';
|
||
}
|
||
exports.getApiBaseUrl = getApiBaseUrl;
|
||
//# sourceMappingURL=utils.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 3030:
|
||
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
exports.getOctokitOptions = exports.GitHub = exports.context = void 0;
|
||
const Context = __importStar(__webpack_require__(4087));
|
||
const Utils = __importStar(__webpack_require__(7914));
|
||
// octokit + plugins
|
||
const core_1 = __webpack_require__(6762);
|
||
const plugin_rest_endpoint_methods_1 = __webpack_require__(3044);
|
||
const plugin_paginate_rest_1 = __webpack_require__(4193);
|
||
exports.context = new Context.Context();
|
||
const baseUrl = Utils.getApiBaseUrl();
|
||
const defaults = {
|
||
baseUrl,
|
||
request: {
|
||
agent: Utils.getProxyAgent(baseUrl)
|
||
}
|
||
};
|
||
exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults);
|
||
/**
|
||
* Convience function to correctly format Octokit Options to pass into the constructor.
|
||
*
|
||
* @param token the repo PAT or GITHUB_TOKEN
|
||
* @param options other options to set
|
||
*/
|
||
function getOctokitOptions(token, options) {
|
||
const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller
|
||
// Auth
|
||
const auth = Utils.getAuthString(token, opts);
|
||
if (auth) {
|
||
opts.auth = auth;
|
||
}
|
||
return opts;
|
||
}
|
||
exports.getOctokitOptions = getOctokitOptions;
|
||
//# sourceMappingURL=utils.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9925:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
const http = __webpack_require__(8605);
|
||
const https = __webpack_require__(7211);
|
||
const pm = __webpack_require__(6443);
|
||
let tunnel;
|
||
var HttpCodes;
|
||
(function (HttpCodes) {
|
||
HttpCodes[HttpCodes["OK"] = 200] = "OK";
|
||
HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
|
||
HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
|
||
HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
|
||
HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
|
||
HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
|
||
HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
|
||
HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
|
||
HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
||
HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
|
||
HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
|
||
HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
|
||
HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
|
||
HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
|
||
HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
|
||
HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
||
HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
|
||
HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
||
HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
|
||
HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
|
||
HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
|
||
HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
|
||
HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
|
||
HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
|
||
HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
|
||
HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
||
HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
|
||
})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {}));
|
||
var Headers;
|
||
(function (Headers) {
|
||
Headers["Accept"] = "accept";
|
||
Headers["ContentType"] = "content-type";
|
||
})(Headers = exports.Headers || (exports.Headers = {}));
|
||
var MediaTypes;
|
||
(function (MediaTypes) {
|
||
MediaTypes["ApplicationJson"] = "application/json";
|
||
})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {}));
|
||
/**
|
||
* Returns the proxy URL, depending upon the supplied url and proxy environment variables.
|
||
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
||
*/
|
||
function getProxyUrl(serverUrl) {
|
||
let proxyUrl = pm.getProxyUrl(new URL(serverUrl));
|
||
return proxyUrl ? proxyUrl.href : '';
|
||
}
|
||
exports.getProxyUrl = getProxyUrl;
|
||
const HttpRedirectCodes = [
|
||
HttpCodes.MovedPermanently,
|
||
HttpCodes.ResourceMoved,
|
||
HttpCodes.SeeOther,
|
||
HttpCodes.TemporaryRedirect,
|
||
HttpCodes.PermanentRedirect
|
||
];
|
||
const HttpResponseRetryCodes = [
|
||
HttpCodes.BadGateway,
|
||
HttpCodes.ServiceUnavailable,
|
||
HttpCodes.GatewayTimeout
|
||
];
|
||
const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD'];
|
||
const ExponentialBackoffCeiling = 10;
|
||
const ExponentialBackoffTimeSlice = 5;
|
||
class HttpClientError extends Error {
|
||
constructor(message, statusCode) {
|
||
super(message);
|
||
this.name = 'HttpClientError';
|
||
this.statusCode = statusCode;
|
||
Object.setPrototypeOf(this, HttpClientError.prototype);
|
||
}
|
||
}
|
||
exports.HttpClientError = HttpClientError;
|
||
class HttpClientResponse {
|
||
constructor(message) {
|
||
this.message = message;
|
||
}
|
||
readBody() {
|
||
return new Promise(async (resolve, reject) => {
|
||
let output = Buffer.alloc(0);
|
||
this.message.on('data', (chunk) => {
|
||
output = Buffer.concat([output, chunk]);
|
||
});
|
||
this.message.on('end', () => {
|
||
resolve(output.toString());
|
||
});
|
||
});
|
||
}
|
||
}
|
||
exports.HttpClientResponse = HttpClientResponse;
|
||
function isHttps(requestUrl) {
|
||
let parsedUrl = new URL(requestUrl);
|
||
return parsedUrl.protocol === 'https:';
|
||
}
|
||
exports.isHttps = isHttps;
|
||
class HttpClient {
|
||
constructor(userAgent, handlers, requestOptions) {
|
||
this._ignoreSslError = false;
|
||
this._allowRedirects = true;
|
||
this._allowRedirectDowngrade = false;
|
||
this._maxRedirects = 50;
|
||
this._allowRetries = false;
|
||
this._maxRetries = 1;
|
||
this._keepAlive = false;
|
||
this._disposed = false;
|
||
this.userAgent = userAgent;
|
||
this.handlers = handlers || [];
|
||
this.requestOptions = requestOptions;
|
||
if (requestOptions) {
|
||
if (requestOptions.ignoreSslError != null) {
|
||
this._ignoreSslError = requestOptions.ignoreSslError;
|
||
}
|
||
this._socketTimeout = requestOptions.socketTimeout;
|
||
if (requestOptions.allowRedirects != null) {
|
||
this._allowRedirects = requestOptions.allowRedirects;
|
||
}
|
||
if (requestOptions.allowRedirectDowngrade != null) {
|
||
this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
|
||
}
|
||
if (requestOptions.maxRedirects != null) {
|
||
this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
|
||
}
|
||
if (requestOptions.keepAlive != null) {
|
||
this._keepAlive = requestOptions.keepAlive;
|
||
}
|
||
if (requestOptions.allowRetries != null) {
|
||
this._allowRetries = requestOptions.allowRetries;
|
||
}
|
||
if (requestOptions.maxRetries != null) {
|
||
this._maxRetries = requestOptions.maxRetries;
|
||
}
|
||
}
|
||
}
|
||
options(requestUrl, additionalHeaders) {
|
||
return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
|
||
}
|
||
get(requestUrl, additionalHeaders) {
|
||
return this.request('GET', requestUrl, null, additionalHeaders || {});
|
||
}
|
||
del(requestUrl, additionalHeaders) {
|
||
return this.request('DELETE', requestUrl, null, additionalHeaders || {});
|
||
}
|
||
post(requestUrl, data, additionalHeaders) {
|
||
return this.request('POST', requestUrl, data, additionalHeaders || {});
|
||
}
|
||
patch(requestUrl, data, additionalHeaders) {
|
||
return this.request('PATCH', requestUrl, data, additionalHeaders || {});
|
||
}
|
||
put(requestUrl, data, additionalHeaders) {
|
||
return this.request('PUT', requestUrl, data, additionalHeaders || {});
|
||
}
|
||
head(requestUrl, additionalHeaders) {
|
||
return this.request('HEAD', requestUrl, null, additionalHeaders || {});
|
||
}
|
||
sendStream(verb, requestUrl, stream, additionalHeaders) {
|
||
return this.request(verb, requestUrl, stream, additionalHeaders);
|
||
}
|
||
/**
|
||
* Gets a typed object from an endpoint
|
||
* Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise
|
||
*/
|
||
async getJson(requestUrl, additionalHeaders = {}) {
|
||
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
||
let res = await this.get(requestUrl, additionalHeaders);
|
||
return this._processResponse(res, this.requestOptions);
|
||
}
|
||
async postJson(requestUrl, obj, additionalHeaders = {}) {
|
||
let data = JSON.stringify(obj, null, 2);
|
||
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
||
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
||
let res = await this.post(requestUrl, data, additionalHeaders);
|
||
return this._processResponse(res, this.requestOptions);
|
||
}
|
||
async putJson(requestUrl, obj, additionalHeaders = {}) {
|
||
let data = JSON.stringify(obj, null, 2);
|
||
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
||
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
||
let res = await this.put(requestUrl, data, additionalHeaders);
|
||
return this._processResponse(res, this.requestOptions);
|
||
}
|
||
async patchJson(requestUrl, obj, additionalHeaders = {}) {
|
||
let data = JSON.stringify(obj, null, 2);
|
||
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
||
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
||
let res = await this.patch(requestUrl, data, additionalHeaders);
|
||
return this._processResponse(res, this.requestOptions);
|
||
}
|
||
/**
|
||
* Makes a raw http request.
|
||
* All other methods such as get, post, patch, and request ultimately call this.
|
||
* Prefer get, del, post and patch
|
||
*/
|
||
async request(verb, requestUrl, data, headers) {
|
||
if (this._disposed) {
|
||
throw new Error('Client has already been disposed.');
|
||
}
|
||
let parsedUrl = new URL(requestUrl);
|
||
let info = this._prepareRequest(verb, parsedUrl, headers);
|
||
// Only perform retries on reads since writes may not be idempotent.
|
||
let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1
|
||
? this._maxRetries + 1
|
||
: 1;
|
||
let numTries = 0;
|
||
let response;
|
||
while (numTries < maxTries) {
|
||
response = await this.requestRaw(info, data);
|
||
// Check if it's an authentication challenge
|
||
if (response &&
|
||
response.message &&
|
||
response.message.statusCode === HttpCodes.Unauthorized) {
|
||
let authenticationHandler;
|
||
for (let i = 0; i < this.handlers.length; i++) {
|
||
if (this.handlers[i].canHandleAuthentication(response)) {
|
||
authenticationHandler = this.handlers[i];
|
||
break;
|
||
}
|
||
}
|
||
if (authenticationHandler) {
|
||
return authenticationHandler.handleAuthentication(this, info, data);
|
||
}
|
||
else {
|
||
// We have received an unauthorized response but have no handlers to handle it.
|
||
// Let the response return to the caller.
|
||
return response;
|
||
}
|
||
}
|
||
let redirectsRemaining = this._maxRedirects;
|
||
while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 &&
|
||
this._allowRedirects &&
|
||
redirectsRemaining > 0) {
|
||
const redirectUrl = response.message.headers['location'];
|
||
if (!redirectUrl) {
|
||
// if there's no location to redirect to, we won't
|
||
break;
|
||
}
|
||
let parsedRedirectUrl = new URL(redirectUrl);
|
||
if (parsedUrl.protocol == 'https:' &&
|
||
parsedUrl.protocol != parsedRedirectUrl.protocol &&
|
||
!this._allowRedirectDowngrade) {
|
||
throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
|
||
}
|
||
// we need to finish reading the response before reassigning response
|
||
// which will leak the open socket.
|
||
await response.readBody();
|
||
// strip authorization header if redirected to a different hostname
|
||
if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
|
||
for (let header in headers) {
|
||
// header names are case insensitive
|
||
if (header.toLowerCase() === 'authorization') {
|
||
delete headers[header];
|
||
}
|
||
}
|
||
}
|
||
// let's make the request with the new redirectUrl
|
||
info = this._prepareRequest(verb, parsedRedirectUrl, headers);
|
||
response = await this.requestRaw(info, data);
|
||
redirectsRemaining--;
|
||
}
|
||
if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) {
|
||
// If not a retry code, return immediately instead of retrying
|
||
return response;
|
||
}
|
||
numTries += 1;
|
||
if (numTries < maxTries) {
|
||
await response.readBody();
|
||
await this._performExponentialBackoff(numTries);
|
||
}
|
||
}
|
||
return response;
|
||
}
|
||
/**
|
||
* Needs to be called if keepAlive is set to true in request options.
|
||
*/
|
||
dispose() {
|
||
if (this._agent) {
|
||
this._agent.destroy();
|
||
}
|
||
this._disposed = true;
|
||
}
|
||
/**
|
||
* Raw request.
|
||
* @param info
|
||
* @param data
|
||
*/
|
||
requestRaw(info, data) {
|
||
return new Promise((resolve, reject) => {
|
||
let callbackForResult = function (err, res) {
|
||
if (err) {
|
||
reject(err);
|
||
}
|
||
resolve(res);
|
||
};
|
||
this.requestRawWithCallback(info, data, callbackForResult);
|
||
});
|
||
}
|
||
/**
|
||
* Raw request with callback.
|
||
* @param info
|
||
* @param data
|
||
* @param onResult
|
||
*/
|
||
requestRawWithCallback(info, data, onResult) {
|
||
let socket;
|
||
if (typeof data === 'string') {
|
||
info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
|
||
}
|
||
let callbackCalled = false;
|
||
let handleResult = (err, res) => {
|
||
if (!callbackCalled) {
|
||
callbackCalled = true;
|
||
onResult(err, res);
|
||
}
|
||
};
|
||
let req = info.httpModule.request(info.options, (msg) => {
|
||
let res = new HttpClientResponse(msg);
|
||
handleResult(null, res);
|
||
});
|
||
req.on('socket', sock => {
|
||
socket = sock;
|
||
});
|
||
// If we ever get disconnected, we want the socket to timeout eventually
|
||
req.setTimeout(this._socketTimeout || 3 * 60000, () => {
|
||
if (socket) {
|
||
socket.end();
|
||
}
|
||
handleResult(new Error('Request timeout: ' + info.options.path), null);
|
||
});
|
||
req.on('error', function (err) {
|
||
// err has statusCode property
|
||
// res should have headers
|
||
handleResult(err, null);
|
||
});
|
||
if (data && typeof data === 'string') {
|
||
req.write(data, 'utf8');
|
||
}
|
||
if (data && typeof data !== 'string') {
|
||
data.on('close', function () {
|
||
req.end();
|
||
});
|
||
data.pipe(req);
|
||
}
|
||
else {
|
||
req.end();
|
||
}
|
||
}
|
||
/**
|
||
* Gets an http agent. This function is useful when you need an http agent that handles
|
||
* routing through a proxy server - depending upon the url and proxy environment variables.
|
||
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
||
*/
|
||
getAgent(serverUrl) {
|
||
let parsedUrl = new URL(serverUrl);
|
||
return this._getAgent(parsedUrl);
|
||
}
|
||
_prepareRequest(method, requestUrl, headers) {
|
||
const info = {};
|
||
info.parsedUrl = requestUrl;
|
||
const usingSsl = info.parsedUrl.protocol === 'https:';
|
||
info.httpModule = usingSsl ? https : http;
|
||
const defaultPort = usingSsl ? 443 : 80;
|
||
info.options = {};
|
||
info.options.host = info.parsedUrl.hostname;
|
||
info.options.port = info.parsedUrl.port
|
||
? parseInt(info.parsedUrl.port)
|
||
: defaultPort;
|
||
info.options.path =
|
||
(info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
|
||
info.options.method = method;
|
||
info.options.headers = this._mergeHeaders(headers);
|
||
if (this.userAgent != null) {
|
||
info.options.headers['user-agent'] = this.userAgent;
|
||
}
|
||
info.options.agent = this._getAgent(info.parsedUrl);
|
||
// gives handlers an opportunity to participate
|
||
if (this.handlers) {
|
||
this.handlers.forEach(handler => {
|
||
handler.prepareRequest(info.options);
|
||
});
|
||
}
|
||
return info;
|
||
}
|
||
_mergeHeaders(headers) {
|
||
const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
|
||
if (this.requestOptions && this.requestOptions.headers) {
|
||
return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers));
|
||
}
|
||
return lowercaseKeys(headers || {});
|
||
}
|
||
_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
|
||
const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
|
||
let clientHeader;
|
||
if (this.requestOptions && this.requestOptions.headers) {
|
||
clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
|
||
}
|
||
return additionalHeaders[header] || clientHeader || _default;
|
||
}
|
||
_getAgent(parsedUrl) {
|
||
let agent;
|
||
let proxyUrl = pm.getProxyUrl(parsedUrl);
|
||
let useProxy = proxyUrl && proxyUrl.hostname;
|
||
if (this._keepAlive && useProxy) {
|
||
agent = this._proxyAgent;
|
||
}
|
||
if (this._keepAlive && !useProxy) {
|
||
agent = this._agent;
|
||
}
|
||
// if agent is already assigned use that agent.
|
||
if (!!agent) {
|
||
return agent;
|
||
}
|
||
const usingSsl = parsedUrl.protocol === 'https:';
|
||
let maxSockets = 100;
|
||
if (!!this.requestOptions) {
|
||
maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
|
||
}
|
||
if (useProxy) {
|
||
// If using proxy, need tunnel
|
||
if (!tunnel) {
|
||
tunnel = __webpack_require__(4294);
|
||
}
|
||
const agentOptions = {
|
||
maxSockets: maxSockets,
|
||
keepAlive: this._keepAlive,
|
||
proxy: {
|
||
proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`,
|
||
host: proxyUrl.hostname,
|
||
port: proxyUrl.port
|
||
}
|
||
};
|
||
let tunnelAgent;
|
||
const overHttps = proxyUrl.protocol === 'https:';
|
||
if (usingSsl) {
|
||
tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
|
||
}
|
||
else {
|
||
tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
|
||
}
|
||
agent = tunnelAgent(agentOptions);
|
||
this._proxyAgent = agent;
|
||
}
|
||
// if reusing agent across request and tunneling agent isn't assigned create a new agent
|
||
if (this._keepAlive && !agent) {
|
||
const options = { keepAlive: this._keepAlive, maxSockets: maxSockets };
|
||
agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
|
||
this._agent = agent;
|
||
}
|
||
// if not using private agent and tunnel agent isn't setup then use global agent
|
||
if (!agent) {
|
||
agent = usingSsl ? https.globalAgent : http.globalAgent;
|
||
}
|
||
if (usingSsl && this._ignoreSslError) {
|
||
// we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
|
||
// http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
|
||
// we have to cast it to any and change it directly
|
||
agent.options = Object.assign(agent.options || {}, {
|
||
rejectUnauthorized: false
|
||
});
|
||
}
|
||
return agent;
|
||
}
|
||
_performExponentialBackoff(retryNumber) {
|
||
retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
|
||
const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
|
||
return new Promise(resolve => setTimeout(() => resolve(), ms));
|
||
}
|
||
static dateTimeDeserializer(key, value) {
|
||
if (typeof value === 'string') {
|
||
let a = new Date(value);
|
||
if (!isNaN(a.valueOf())) {
|
||
return a;
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
async _processResponse(res, options) {
|
||
return new Promise(async (resolve, reject) => {
|
||
const statusCode = res.message.statusCode;
|
||
const response = {
|
||
statusCode: statusCode,
|
||
result: null,
|
||
headers: {}
|
||
};
|
||
// not found leads to null obj returned
|
||
if (statusCode == HttpCodes.NotFound) {
|
||
resolve(response);
|
||
}
|
||
let obj;
|
||
let contents;
|
||
// get the result from the body
|
||
try {
|
||
contents = await res.readBody();
|
||
if (contents && contents.length > 0) {
|
||
if (options && options.deserializeDates) {
|
||
obj = JSON.parse(contents, HttpClient.dateTimeDeserializer);
|
||
}
|
||
else {
|
||
obj = JSON.parse(contents);
|
||
}
|
||
response.result = obj;
|
||
}
|
||
response.headers = res.message.headers;
|
||
}
|
||
catch (err) {
|
||
// Invalid resource (contents not json); leaving result obj null
|
||
}
|
||
// note that 3xx redirects are handled by the http layer.
|
||
if (statusCode > 299) {
|
||
let msg;
|
||
// if exception/error in body, attempt to get better error
|
||
if (obj && obj.message) {
|
||
msg = obj.message;
|
||
}
|
||
else if (contents && contents.length > 0) {
|
||
// it may be the case that the exception is in the body message as string
|
||
msg = contents;
|
||
}
|
||
else {
|
||
msg = 'Failed request: (' + statusCode + ')';
|
||
}
|
||
let err = new HttpClientError(msg, statusCode);
|
||
err.result = response.result;
|
||
reject(err);
|
||
}
|
||
else {
|
||
resolve(response);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
exports.HttpClient = HttpClient;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6443:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
function getProxyUrl(reqUrl) {
|
||
let usingSsl = reqUrl.protocol === 'https:';
|
||
let proxyUrl;
|
||
if (checkBypass(reqUrl)) {
|
||
return proxyUrl;
|
||
}
|
||
let proxyVar;
|
||
if (usingSsl) {
|
||
proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY'];
|
||
}
|
||
else {
|
||
proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY'];
|
||
}
|
||
if (proxyVar) {
|
||
proxyUrl = new URL(proxyVar);
|
||
}
|
||
return proxyUrl;
|
||
}
|
||
exports.getProxyUrl = getProxyUrl;
|
||
function checkBypass(reqUrl) {
|
||
if (!reqUrl.hostname) {
|
||
return false;
|
||
}
|
||
let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
|
||
if (!noProxy) {
|
||
return false;
|
||
}
|
||
// Determine the request port
|
||
let reqPort;
|
||
if (reqUrl.port) {
|
||
reqPort = Number(reqUrl.port);
|
||
}
|
||
else if (reqUrl.protocol === 'http:') {
|
||
reqPort = 80;
|
||
}
|
||
else if (reqUrl.protocol === 'https:') {
|
||
reqPort = 443;
|
||
}
|
||
// Format the request hostname and hostname with port
|
||
let upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
||
if (typeof reqPort === 'number') {
|
||
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
||
}
|
||
// Compare request host against noproxy
|
||
for (let upperNoProxyItem of noProxy
|
||
.split(',')
|
||
.map(x => x.trim().toUpperCase())
|
||
.filter(x => x)) {
|
||
if (upperReqHosts.some(x => x === upperNoProxyItem)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
exports.checkBypass = checkBypass;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 334:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
async function auth(token) {
|
||
const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth";
|
||
return {
|
||
type: "token",
|
||
token: token,
|
||
tokenType
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Prefix token for usage in the Authorization header
|
||
*
|
||
* @param token OAuth token or JSON Web Token
|
||
*/
|
||
function withAuthorizationPrefix(token) {
|
||
if (token.split(/\./).length === 3) {
|
||
return `bearer ${token}`;
|
||
}
|
||
|
||
return `token ${token}`;
|
||
}
|
||
|
||
async function hook(token, request, route, parameters) {
|
||
const endpoint = request.endpoint.merge(route, parameters);
|
||
endpoint.headers.authorization = withAuthorizationPrefix(token);
|
||
return request(endpoint);
|
||
}
|
||
|
||
const createTokenAuth = function createTokenAuth(token) {
|
||
if (!token) {
|
||
throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
|
||
}
|
||
|
||
if (typeof token !== "string") {
|
||
throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
|
||
}
|
||
|
||
token = token.replace(/^(token|bearer) +/i, "");
|
||
return Object.assign(auth.bind(null, token), {
|
||
hook: hook.bind(null, token)
|
||
});
|
||
};
|
||
|
||
exports.createTokenAuth = createTokenAuth;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6762:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
var universalUserAgent = __webpack_require__(5030);
|
||
var beforeAfterHook = __webpack_require__(3682);
|
||
var request = __webpack_require__(6234);
|
||
var graphql = __webpack_require__(8467);
|
||
var authToken = __webpack_require__(334);
|
||
|
||
function _objectWithoutPropertiesLoose(source, excluded) {
|
||
if (source == null) return {};
|
||
var target = {};
|
||
var sourceKeys = Object.keys(source);
|
||
var key, i;
|
||
|
||
for (i = 0; i < sourceKeys.length; i++) {
|
||
key = sourceKeys[i];
|
||
if (excluded.indexOf(key) >= 0) continue;
|
||
target[key] = source[key];
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
function _objectWithoutProperties(source, excluded) {
|
||
if (source == null) return {};
|
||
|
||
var target = _objectWithoutPropertiesLoose(source, excluded);
|
||
|
||
var key, i;
|
||
|
||
if (Object.getOwnPropertySymbols) {
|
||
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
||
|
||
for (i = 0; i < sourceSymbolKeys.length; i++) {
|
||
key = sourceSymbolKeys[i];
|
||
if (excluded.indexOf(key) >= 0) continue;
|
||
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
const VERSION = "3.2.4";
|
||
|
||
class Octokit {
|
||
constructor(options = {}) {
|
||
const hook = new beforeAfterHook.Collection();
|
||
const requestDefaults = {
|
||
baseUrl: request.request.endpoint.DEFAULTS.baseUrl,
|
||
headers: {},
|
||
request: Object.assign({}, options.request, {
|
||
hook: hook.bind(null, "request")
|
||
}),
|
||
mediaType: {
|
||
previews: [],
|
||
format: ""
|
||
}
|
||
}; // prepend default user agent with `options.userAgent` if set
|
||
|
||
requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" ");
|
||
|
||
if (options.baseUrl) {
|
||
requestDefaults.baseUrl = options.baseUrl;
|
||
}
|
||
|
||
if (options.previews) {
|
||
requestDefaults.mediaType.previews = options.previews;
|
||
}
|
||
|
||
if (options.timeZone) {
|
||
requestDefaults.headers["time-zone"] = options.timeZone;
|
||
}
|
||
|
||
this.request = request.request.defaults(requestDefaults);
|
||
this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults);
|
||
this.log = Object.assign({
|
||
debug: () => {},
|
||
info: () => {},
|
||
warn: console.warn.bind(console),
|
||
error: console.error.bind(console)
|
||
}, options.log);
|
||
this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
|
||
// is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered.
|
||
// (2) If only `options.auth` is set, use the default token authentication strategy.
|
||
// (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
|
||
// TODO: type `options.auth` based on `options.authStrategy`.
|
||
|
||
if (!options.authStrategy) {
|
||
if (!options.auth) {
|
||
// (1)
|
||
this.auth = async () => ({
|
||
type: "unauthenticated"
|
||
});
|
||
} else {
|
||
// (2)
|
||
const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯
|
||
|
||
hook.wrap("request", auth.hook);
|
||
this.auth = auth;
|
||
}
|
||
} else {
|
||
const {
|
||
authStrategy
|
||
} = options,
|
||
otherOptions = _objectWithoutProperties(options, ["authStrategy"]);
|
||
|
||
const auth = authStrategy(Object.assign({
|
||
request: this.request,
|
||
log: this.log,
|
||
// we pass the current octokit instance as well as its constructor options
|
||
// to allow for authentication strategies that return a new octokit instance
|
||
// that shares the same internal state as the current one. The original
|
||
// requirement for this was the "event-octokit" authentication strategy
|
||
// of https://github.com/probot/octokit-auth-probot.
|
||
octokit: this,
|
||
octokitOptions: otherOptions
|
||
}, options.auth)); // @ts-ignore ¯\_(ツ)_/¯
|
||
|
||
hook.wrap("request", auth.hook);
|
||
this.auth = auth;
|
||
} // apply plugins
|
||
// https://stackoverflow.com/a/16345172
|
||
|
||
|
||
const classConstructor = this.constructor;
|
||
classConstructor.plugins.forEach(plugin => {
|
||
Object.assign(this, plugin(this, options));
|
||
});
|
||
}
|
||
|
||
static defaults(defaults) {
|
||
const OctokitWithDefaults = class extends this {
|
||
constructor(...args) {
|
||
const options = args[0] || {};
|
||
|
||
if (typeof defaults === "function") {
|
||
super(defaults(options));
|
||
return;
|
||
}
|
||
|
||
super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
|
||
userAgent: `${options.userAgent} ${defaults.userAgent}`
|
||
} : null));
|
||
}
|
||
|
||
};
|
||
return OctokitWithDefaults;
|
||
}
|
||
/**
|
||
* Attach a plugin (or many) to your Octokit instance.
|
||
*
|
||
* @example
|
||
* const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
|
||
*/
|
||
|
||
|
||
static plugin(...newPlugins) {
|
||
var _a;
|
||
|
||
const currentPlugins = this.plugins;
|
||
const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a);
|
||
return NewOctokit;
|
||
}
|
||
|
||
}
|
||
Octokit.VERSION = VERSION;
|
||
Octokit.plugins = [];
|
||
|
||
exports.Octokit = Octokit;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9440:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
var isPlainObject = __webpack_require__(558);
|
||
var universalUserAgent = __webpack_require__(5030);
|
||
|
||
function lowercaseKeys(object) {
|
||
if (!object) {
|
||
return {};
|
||
}
|
||
|
||
return Object.keys(object).reduce((newObj, key) => {
|
||
newObj[key.toLowerCase()] = object[key];
|
||
return newObj;
|
||
}, {});
|
||
}
|
||
|
||
function mergeDeep(defaults, options) {
|
||
const result = Object.assign({}, defaults);
|
||
Object.keys(options).forEach(key => {
|
||
if (isPlainObject.isPlainObject(options[key])) {
|
||
if (!(key in defaults)) Object.assign(result, {
|
||
[key]: options[key]
|
||
});else result[key] = mergeDeep(defaults[key], options[key]);
|
||
} else {
|
||
Object.assign(result, {
|
||
[key]: options[key]
|
||
});
|
||
}
|
||
});
|
||
return result;
|
||
}
|
||
|
||
function removeUndefinedProperties(obj) {
|
||
for (const key in obj) {
|
||
if (obj[key] === undefined) {
|
||
delete obj[key];
|
||
}
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
function merge(defaults, route, options) {
|
||
if (typeof route === "string") {
|
||
let [method, url] = route.split(" ");
|
||
options = Object.assign(url ? {
|
||
method,
|
||
url
|
||
} : {
|
||
url: method
|
||
}, options);
|
||
} else {
|
||
options = Object.assign({}, route);
|
||
} // lowercase header names before merging with defaults to avoid duplicates
|
||
|
||
|
||
options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging
|
||
|
||
removeUndefinedProperties(options);
|
||
removeUndefinedProperties(options.headers);
|
||
const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten
|
||
|
||
if (defaults && defaults.mediaType.previews.length) {
|
||
mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
|
||
}
|
||
|
||
mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, ""));
|
||
return mergedOptions;
|
||
}
|
||
|
||
function addQueryParameters(url, parameters) {
|
||
const separator = /\?/.test(url) ? "&" : "?";
|
||
const names = Object.keys(parameters);
|
||
|
||
if (names.length === 0) {
|
||
return url;
|
||
}
|
||
|
||
return url + separator + names.map(name => {
|
||
if (name === "q") {
|
||
return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
|
||
}
|
||
|
||
return `${name}=${encodeURIComponent(parameters[name])}`;
|
||
}).join("&");
|
||
}
|
||
|
||
const urlVariableRegex = /\{[^}]+\}/g;
|
||
|
||
function removeNonChars(variableName) {
|
||
return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
|
||
}
|
||
|
||
function extractUrlVariableNames(url) {
|
||
const matches = url.match(urlVariableRegex);
|
||
|
||
if (!matches) {
|
||
return [];
|
||
}
|
||
|
||
return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
|
||
}
|
||
|
||
function omit(object, keysToOmit) {
|
||
return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => {
|
||
obj[key] = object[key];
|
||
return obj;
|
||
}, {});
|
||
}
|
||
|
||
// Based on https://github.com/bramstein/url-template, licensed under BSD
|
||
// TODO: create separate package.
|
||
//
|
||
// Copyright (c) 2012-2014, Bram Stein
|
||
// All rights reserved.
|
||
// Redistribution and use in source and binary forms, with or without
|
||
// modification, are permitted provided that the following conditions
|
||
// are met:
|
||
// 1. Redistributions of source code must retain the above copyright
|
||
// notice, this list of conditions and the following disclaimer.
|
||
// 2. Redistributions in binary form must reproduce the above copyright
|
||
// notice, this list of conditions and the following disclaimer in the
|
||
// documentation and/or other materials provided with the distribution.
|
||
// 3. The name of the author may not be used to endorse or promote products
|
||
// derived from this software without specific prior written permission.
|
||
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
|
||
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||
// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
||
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
||
/* istanbul ignore file */
|
||
function encodeReserved(str) {
|
||
return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
|
||
if (!/%[0-9A-Fa-f]/.test(part)) {
|
||
part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
|
||
}
|
||
|
||
return part;
|
||
}).join("");
|
||
}
|
||
|
||
function encodeUnreserved(str) {
|
||
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
|
||
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
|
||
});
|
||
}
|
||
|
||
function encodeValue(operator, value, key) {
|
||
value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
|
||
|
||
if (key) {
|
||
return encodeUnreserved(key) + "=" + value;
|
||
} else {
|
||
return value;
|
||
}
|
||
}
|
||
|
||
function isDefined(value) {
|
||
return value !== undefined && value !== null;
|
||
}
|
||
|
||
function isKeyOperator(operator) {
|
||
return operator === ";" || operator === "&" || operator === "?";
|
||
}
|
||
|
||
function getValues(context, operator, key, modifier) {
|
||
var value = context[key],
|
||
result = [];
|
||
|
||
if (isDefined(value) && value !== "") {
|
||
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
|
||
value = value.toString();
|
||
|
||
if (modifier && modifier !== "*") {
|
||
value = value.substring(0, parseInt(modifier, 10));
|
||
}
|
||
|
||
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
|
||
} else {
|
||
if (modifier === "*") {
|
||
if (Array.isArray(value)) {
|
||
value.filter(isDefined).forEach(function (value) {
|
||
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
|
||
});
|
||
} else {
|
||
Object.keys(value).forEach(function (k) {
|
||
if (isDefined(value[k])) {
|
||
result.push(encodeValue(operator, value[k], k));
|
||
}
|
||
});
|
||
}
|
||
} else {
|
||
const tmp = [];
|
||
|
||
if (Array.isArray(value)) {
|
||
value.filter(isDefined).forEach(function (value) {
|
||
tmp.push(encodeValue(operator, value));
|
||
});
|
||
} else {
|
||
Object.keys(value).forEach(function (k) {
|
||
if (isDefined(value[k])) {
|
||
tmp.push(encodeUnreserved(k));
|
||
tmp.push(encodeValue(operator, value[k].toString()));
|
||
}
|
||
});
|
||
}
|
||
|
||
if (isKeyOperator(operator)) {
|
||
result.push(encodeUnreserved(key) + "=" + tmp.join(","));
|
||
} else if (tmp.length !== 0) {
|
||
result.push(tmp.join(","));
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if (operator === ";") {
|
||
if (isDefined(value)) {
|
||
result.push(encodeUnreserved(key));
|
||
}
|
||
} else if (value === "" && (operator === "&" || operator === "?")) {
|
||
result.push(encodeUnreserved(key) + "=");
|
||
} else if (value === "") {
|
||
result.push("");
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
function parseUrl(template) {
|
||
return {
|
||
expand: expand.bind(null, template)
|
||
};
|
||
}
|
||
|
||
function expand(template, context) {
|
||
var operators = ["+", "#", ".", "/", ";", "?", "&"];
|
||
return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
|
||
if (expression) {
|
||
let operator = "";
|
||
const values = [];
|
||
|
||
if (operators.indexOf(expression.charAt(0)) !== -1) {
|
||
operator = expression.charAt(0);
|
||
expression = expression.substr(1);
|
||
}
|
||
|
||
expression.split(/,/g).forEach(function (variable) {
|
||
var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
|
||
values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
|
||
});
|
||
|
||
if (operator && operator !== "+") {
|
||
var separator = ",";
|
||
|
||
if (operator === "?") {
|
||
separator = "&";
|
||
} else if (operator !== "#") {
|
||
separator = operator;
|
||
}
|
||
|
||
return (values.length !== 0 ? operator : "") + values.join(separator);
|
||
} else {
|
||
return values.join(",");
|
||
}
|
||
} else {
|
||
return encodeReserved(literal);
|
||
}
|
||
});
|
||
}
|
||
|
||
function parse(options) {
|
||
// https://fetch.spec.whatwg.org/#methods
|
||
let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible
|
||
|
||
let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
|
||
let headers = Object.assign({}, options.headers);
|
||
let body;
|
||
let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later
|
||
|
||
const urlVariableNames = extractUrlVariableNames(url);
|
||
url = parseUrl(url).expand(parameters);
|
||
|
||
if (!/^http/.test(url)) {
|
||
url = options.baseUrl + url;
|
||
}
|
||
|
||
const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl");
|
||
const remainingParameters = omit(parameters, omittedParameters);
|
||
const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
|
||
|
||
if (!isBinaryRequest) {
|
||
if (options.mediaType.format) {
|
||
// e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
|
||
headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
|
||
}
|
||
|
||
if (options.mediaType.previews.length) {
|
||
const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
|
||
headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => {
|
||
const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
|
||
return `application/vnd.github.${preview}-preview${format}`;
|
||
}).join(",");
|
||
}
|
||
} // for GET/HEAD requests, set URL query parameters from remaining parameters
|
||
// for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
|
||
|
||
|
||
if (["GET", "HEAD"].includes(method)) {
|
||
url = addQueryParameters(url, remainingParameters);
|
||
} else {
|
||
if ("data" in remainingParameters) {
|
||
body = remainingParameters.data;
|
||
} else {
|
||
if (Object.keys(remainingParameters).length) {
|
||
body = remainingParameters;
|
||
} else {
|
||
headers["content-length"] = 0;
|
||
}
|
||
}
|
||
} // default content-type for JSON if body is set
|
||
|
||
|
||
if (!headers["content-type"] && typeof body !== "undefined") {
|
||
headers["content-type"] = "application/json; charset=utf-8";
|
||
} // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
|
||
// fetch does not allow to set `content-length` header, but we can set body to an empty string
|
||
|
||
|
||
if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
|
||
body = "";
|
||
} // Only return body/request keys if present
|
||
|
||
|
||
return Object.assign({
|
||
method,
|
||
url,
|
||
headers
|
||
}, typeof body !== "undefined" ? {
|
||
body
|
||
} : null, options.request ? {
|
||
request: options.request
|
||
} : null);
|
||
}
|
||
|
||
function endpointWithDefaults(defaults, route, options) {
|
||
return parse(merge(defaults, route, options));
|
||
}
|
||
|
||
function withDefaults(oldDefaults, newDefaults) {
|
||
const DEFAULTS = merge(oldDefaults, newDefaults);
|
||
const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
|
||
return Object.assign(endpoint, {
|
||
DEFAULTS,
|
||
defaults: withDefaults.bind(null, DEFAULTS),
|
||
merge: merge.bind(null, DEFAULTS),
|
||
parse
|
||
});
|
||
}
|
||
|
||
const VERSION = "6.0.10";
|
||
|
||
const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url.
|
||
// So we use RequestParameters and add method as additional required property.
|
||
|
||
const DEFAULTS = {
|
||
method: "GET",
|
||
baseUrl: "https://api.github.com",
|
||
headers: {
|
||
accept: "application/vnd.github.v3+json",
|
||
"user-agent": userAgent
|
||
},
|
||
mediaType: {
|
||
format: "",
|
||
previews: []
|
||
}
|
||
};
|
||
|
||
const endpoint = withDefaults(null, DEFAULTS);
|
||
|
||
exports.endpoint = endpoint;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 558:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
/*!
|
||
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
|
||
*
|
||
* Copyright (c) 2014-2017, Jon Schlinkert.
|
||
* Released under the MIT License.
|
||
*/
|
||
|
||
function isObject(o) {
|
||
return Object.prototype.toString.call(o) === '[object Object]';
|
||
}
|
||
|
||
function isPlainObject(o) {
|
||
var ctor,prot;
|
||
|
||
if (isObject(o) === false) return false;
|
||
|
||
// If has modified constructor
|
||
ctor = o.constructor;
|
||
if (ctor === undefined) return true;
|
||
|
||
// If has modified prototype
|
||
prot = ctor.prototype;
|
||
if (isObject(prot) === false) return false;
|
||
|
||
// If constructor does not have an Object-specific method
|
||
if (prot.hasOwnProperty('isPrototypeOf') === false) {
|
||
return false;
|
||
}
|
||
|
||
// Most likely a plain Object
|
||
return true;
|
||
}
|
||
|
||
exports.isPlainObject = isPlainObject;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8467:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
var request = __webpack_require__(6234);
|
||
var universalUserAgent = __webpack_require__(5030);
|
||
|
||
const VERSION = "4.5.8";
|
||
|
||
class GraphqlError extends Error {
|
||
constructor(request, response) {
|
||
const message = response.data.errors[0].message;
|
||
super(message);
|
||
Object.assign(this, response.data);
|
||
Object.assign(this, {
|
||
headers: response.headers
|
||
});
|
||
this.name = "GraphqlError";
|
||
this.request = request; // Maintains proper stack trace (only available on V8)
|
||
|
||
/* istanbul ignore next */
|
||
|
||
if (Error.captureStackTrace) {
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"];
|
||
const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
|
||
function graphql(request, query, options) {
|
||
if (typeof query === "string" && options && "query" in options) {
|
||
return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
|
||
}
|
||
|
||
const parsedOptions = typeof query === "string" ? Object.assign({
|
||
query
|
||
}, options) : query;
|
||
const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
|
||
if (NON_VARIABLE_OPTIONS.includes(key)) {
|
||
result[key] = parsedOptions[key];
|
||
return result;
|
||
}
|
||
|
||
if (!result.variables) {
|
||
result.variables = {};
|
||
}
|
||
|
||
result.variables[key] = parsedOptions[key];
|
||
return result;
|
||
}, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix
|
||
// https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451
|
||
|
||
const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl;
|
||
|
||
if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
|
||
requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
|
||
}
|
||
|
||
return request(requestOptions).then(response => {
|
||
if (response.data.errors) {
|
||
const headers = {};
|
||
|
||
for (const key of Object.keys(response.headers)) {
|
||
headers[key] = response.headers[key];
|
||
}
|
||
|
||
throw new GraphqlError(requestOptions, {
|
||
headers,
|
||
data: response.data
|
||
});
|
||
}
|
||
|
||
return response.data.data;
|
||
});
|
||
}
|
||
|
||
function withDefaults(request$1, newDefaults) {
|
||
const newRequest = request$1.defaults(newDefaults);
|
||
|
||
const newApi = (query, options) => {
|
||
return graphql(newRequest, query, options);
|
||
};
|
||
|
||
return Object.assign(newApi, {
|
||
defaults: withDefaults.bind(null, newRequest),
|
||
endpoint: request.request.endpoint
|
||
});
|
||
}
|
||
|
||
const graphql$1 = withDefaults(request.request, {
|
||
headers: {
|
||
"user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}`
|
||
},
|
||
method: "POST",
|
||
url: "/graphql"
|
||
});
|
||
function withCustomRequest(customRequest) {
|
||
return withDefaults(customRequest, {
|
||
method: "POST",
|
||
url: "/graphql"
|
||
});
|
||
}
|
||
|
||
exports.graphql = graphql$1;
|
||
exports.withCustomRequest = withCustomRequest;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4193:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
const VERSION = "2.6.2";
|
||
|
||
/**
|
||
* Some “list” response that can be paginated have a different response structure
|
||
*
|
||
* They have a `total_count` key in the response (search also has `incomplete_results`,
|
||
* /installation/repositories also has `repository_selection`), as well as a key with
|
||
* the list of the items which name varies from endpoint to endpoint.
|
||
*
|
||
* Octokit normalizes these responses so that paginated results are always returned following
|
||
* the same structure. One challenge is that if the list response has only one page, no Link
|
||
* header is provided, so this header alone is not sufficient to check wether a response is
|
||
* paginated or not.
|
||
*
|
||
* We check if a "total_count" key is present in the response data, but also make sure that
|
||
* a "url" property is not, as the "Get the combined status for a specific ref" endpoint would
|
||
* otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
|
||
*/
|
||
function normalizePaginatedListResponse(response) {
|
||
const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
|
||
if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way
|
||
// to retrieve the same information.
|
||
|
||
const incompleteResults = response.data.incomplete_results;
|
||
const repositorySelection = response.data.repository_selection;
|
||
const totalCount = response.data.total_count;
|
||
delete response.data.incomplete_results;
|
||
delete response.data.repository_selection;
|
||
delete response.data.total_count;
|
||
const namespaceKey = Object.keys(response.data)[0];
|
||
const data = response.data[namespaceKey];
|
||
response.data = data;
|
||
|
||
if (typeof incompleteResults !== "undefined") {
|
||
response.data.incomplete_results = incompleteResults;
|
||
}
|
||
|
||
if (typeof repositorySelection !== "undefined") {
|
||
response.data.repository_selection = repositorySelection;
|
||
}
|
||
|
||
response.data.total_count = totalCount;
|
||
return response;
|
||
}
|
||
|
||
function iterator(octokit, route, parameters) {
|
||
const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
|
||
const requestMethod = typeof route === "function" ? route : octokit.request;
|
||
const method = options.method;
|
||
const headers = options.headers;
|
||
let url = options.url;
|
||
return {
|
||
[Symbol.asyncIterator]: () => ({
|
||
async next() {
|
||
if (!url) return {
|
||
done: true
|
||
};
|
||
const response = await requestMethod({
|
||
method,
|
||
url,
|
||
headers
|
||
});
|
||
const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format:
|
||
// '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
|
||
// sets `url` to undefined if "next" URL is not present or `link` header is not set
|
||
|
||
url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
|
||
return {
|
||
value: normalizedResponse
|
||
};
|
||
}
|
||
|
||
})
|
||
};
|
||
}
|
||
|
||
function paginate(octokit, route, parameters, mapFn) {
|
||
if (typeof parameters === "function") {
|
||
mapFn = parameters;
|
||
parameters = undefined;
|
||
}
|
||
|
||
return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
|
||
}
|
||
|
||
function gather(octokit, results, iterator, mapFn) {
|
||
return iterator.next().then(result => {
|
||
if (result.done) {
|
||
return results;
|
||
}
|
||
|
||
let earlyExit = false;
|
||
|
||
function done() {
|
||
earlyExit = true;
|
||
}
|
||
|
||
results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
|
||
|
||
if (earlyExit) {
|
||
return results;
|
||
}
|
||
|
||
return gather(octokit, results, iterator, mapFn);
|
||
});
|
||
}
|
||
|
||
const composePaginateRest = Object.assign(paginate, {
|
||
iterator
|
||
});
|
||
|
||
/**
|
||
* @param octokit Octokit instance
|
||
* @param options Options passed to Octokit constructor
|
||
*/
|
||
|
||
function paginateRest(octokit) {
|
||
return {
|
||
paginate: Object.assign(paginate.bind(null, octokit), {
|
||
iterator: iterator.bind(null, octokit)
|
||
})
|
||
};
|
||
}
|
||
paginateRest.VERSION = VERSION;
|
||
|
||
exports.composePaginateRest = composePaginateRest;
|
||
exports.paginateRest = paginateRest;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8883:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
const VERSION = "1.0.2";
|
||
|
||
/**
|
||
* @param octokit Octokit instance
|
||
* @param options Options passed to Octokit constructor
|
||
*/
|
||
|
||
function requestLog(octokit) {
|
||
octokit.hook.wrap("request", (request, options) => {
|
||
octokit.log.debug("request", options);
|
||
const start = Date.now();
|
||
const requestOptions = octokit.request.endpoint.parse(options);
|
||
const path = requestOptions.url.replace(options.baseUrl, "");
|
||
return request(options).then(response => {
|
||
octokit.log.info(`${requestOptions.method} ${path} - ${response.status} in ${Date.now() - start}ms`);
|
||
return response;
|
||
}).catch(error => {
|
||
octokit.log.info(`${requestOptions.method} ${path} - ${error.status} in ${Date.now() - start}ms`);
|
||
throw error;
|
||
});
|
||
});
|
||
}
|
||
requestLog.VERSION = VERSION;
|
||
|
||
exports.requestLog = requestLog;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 3044:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
const Endpoints = {
|
||
actions: {
|
||
addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
|
||
cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],
|
||
createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
|
||
createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
|
||
createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"],
|
||
createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"],
|
||
createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
|
||
createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"],
|
||
createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"],
|
||
deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
|
||
deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
|
||
deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
|
||
deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"],
|
||
deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],
|
||
deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
|
||
deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
|
||
disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"],
|
||
disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"],
|
||
downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],
|
||
downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],
|
||
downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
|
||
enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"],
|
||
enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"],
|
||
getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"],
|
||
getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"],
|
||
getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
|
||
getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"],
|
||
getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"],
|
||
getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
|
||
getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
|
||
getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
|
||
getRepoPermissions: ["GET /repos/{owner}/{repo}/actions/permissions", {}, {
|
||
renamed: ["actions", "getGithubActionsPermissionsRepository"]
|
||
}],
|
||
getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
|
||
getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
|
||
getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
|
||
getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],
|
||
getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
|
||
getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
|
||
getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],
|
||
getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],
|
||
listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
|
||
listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],
|
||
listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
|
||
listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
|
||
listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
|
||
listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
|
||
listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"],
|
||
listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],
|
||
listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"],
|
||
listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
|
||
listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
|
||
listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],
|
||
listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],
|
||
listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
|
||
reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
|
||
removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
|
||
setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"],
|
||
setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"],
|
||
setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"],
|
||
setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"],
|
||
setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"],
|
||
setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"]
|
||
},
|
||
activity: {
|
||
checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
|
||
deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
|
||
deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"],
|
||
getFeeds: ["GET /feeds"],
|
||
getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
|
||
getThread: ["GET /notifications/threads/{thread_id}"],
|
||
getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"],
|
||
listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
|
||
listNotificationsForAuthenticatedUser: ["GET /notifications"],
|
||
listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"],
|
||
listPublicEvents: ["GET /events"],
|
||
listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
|
||
listPublicEventsForUser: ["GET /users/{username}/events/public"],
|
||
listPublicOrgEvents: ["GET /orgs/{org}/events"],
|
||
listReceivedEventsForUser: ["GET /users/{username}/received_events"],
|
||
listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"],
|
||
listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
|
||
listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"],
|
||
listReposStarredByAuthenticatedUser: ["GET /user/starred"],
|
||
listReposStarredByUser: ["GET /users/{username}/starred"],
|
||
listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
|
||
listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
|
||
listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
|
||
listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
|
||
markNotificationsAsRead: ["PUT /notifications"],
|
||
markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
|
||
markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
|
||
setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
|
||
setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"],
|
||
starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
|
||
unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
|
||
},
|
||
apps: {
|
||
addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"],
|
||
checkToken: ["POST /applications/{client_id}/token"],
|
||
createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", {
|
||
mediaType: {
|
||
previews: ["corsair"]
|
||
}
|
||
}],
|
||
createFromManifest: ["POST /app-manifests/{code}/conversions"],
|
||
createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"],
|
||
deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
|
||
deleteInstallation: ["DELETE /app/installations/{installation_id}"],
|
||
deleteToken: ["DELETE /applications/{client_id}/token"],
|
||
getAuthenticated: ["GET /app"],
|
||
getBySlug: ["GET /apps/{app_slug}"],
|
||
getInstallation: ["GET /app/installations/{installation_id}"],
|
||
getOrgInstallation: ["GET /orgs/{org}/installation"],
|
||
getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"],
|
||
getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"],
|
||
getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"],
|
||
getUserInstallation: ["GET /users/{username}/installation"],
|
||
getWebhookConfigForApp: ["GET /app/hook/config"],
|
||
listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
|
||
listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],
|
||
listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"],
|
||
listInstallations: ["GET /app/installations"],
|
||
listInstallationsForAuthenticatedUser: ["GET /user/installations"],
|
||
listPlans: ["GET /marketplace_listing/plans"],
|
||
listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
|
||
listReposAccessibleToInstallation: ["GET /installation/repositories"],
|
||
listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
|
||
listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"],
|
||
removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"],
|
||
resetToken: ["PATCH /applications/{client_id}/token"],
|
||
revokeInstallationAccessToken: ["DELETE /installation/token"],
|
||
suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
|
||
unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"],
|
||
updateWebhookConfigForApp: ["PATCH /app/hook/config"]
|
||
},
|
||
billing: {
|
||
getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"],
|
||
getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"],
|
||
getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"],
|
||
getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"],
|
||
getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"],
|
||
getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"]
|
||
},
|
||
checks: {
|
||
create: ["POST /repos/{owner}/{repo}/check-runs"],
|
||
createSuite: ["POST /repos/{owner}/{repo}/check-suites"],
|
||
get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],
|
||
getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],
|
||
listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"],
|
||
listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],
|
||
listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"],
|
||
listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],
|
||
rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"],
|
||
setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"],
|
||
update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]
|
||
},
|
||
codeScanning: {
|
||
getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, {
|
||
renamedParameters: {
|
||
alert_id: "alert_number"
|
||
}
|
||
}],
|
||
listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
|
||
listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"],
|
||
updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"],
|
||
uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"]
|
||
},
|
||
codesOfConduct: {
|
||
getAllCodesOfConduct: ["GET /codes_of_conduct", {
|
||
mediaType: {
|
||
previews: ["scarlet-witch"]
|
||
}
|
||
}],
|
||
getConductCode: ["GET /codes_of_conduct/{key}", {
|
||
mediaType: {
|
||
previews: ["scarlet-witch"]
|
||
}
|
||
}],
|
||
getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", {
|
||
mediaType: {
|
||
previews: ["scarlet-witch"]
|
||
}
|
||
}]
|
||
},
|
||
emojis: {
|
||
get: ["GET /emojis"]
|
||
},
|
||
enterpriseAdmin: {
|
||
disableSelectedOrganizationGithubActionsEnterprise: ["DELETE /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"],
|
||
enableSelectedOrganizationGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"],
|
||
getAllowedActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/selected-actions"],
|
||
getGithubActionsPermissionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions"],
|
||
listSelectedOrganizationsEnabledGithubActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/organizations"],
|
||
setAllowedActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/selected-actions"],
|
||
setGithubActionsPermissionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions"],
|
||
setSelectedOrganizationsEnabledGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations"]
|
||
},
|
||
gists: {
|
||
checkIsStarred: ["GET /gists/{gist_id}/star"],
|
||
create: ["POST /gists"],
|
||
createComment: ["POST /gists/{gist_id}/comments"],
|
||
delete: ["DELETE /gists/{gist_id}"],
|
||
deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
|
||
fork: ["POST /gists/{gist_id}/forks"],
|
||
get: ["GET /gists/{gist_id}"],
|
||
getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
|
||
getRevision: ["GET /gists/{gist_id}/{sha}"],
|
||
list: ["GET /gists"],
|
||
listComments: ["GET /gists/{gist_id}/comments"],
|
||
listCommits: ["GET /gists/{gist_id}/commits"],
|
||
listForUser: ["GET /users/{username}/gists"],
|
||
listForks: ["GET /gists/{gist_id}/forks"],
|
||
listPublic: ["GET /gists/public"],
|
||
listStarred: ["GET /gists/starred"],
|
||
star: ["PUT /gists/{gist_id}/star"],
|
||
unstar: ["DELETE /gists/{gist_id}/star"],
|
||
update: ["PATCH /gists/{gist_id}"],
|
||
updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
|
||
},
|
||
git: {
|
||
createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
|
||
createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
|
||
createRef: ["POST /repos/{owner}/{repo}/git/refs"],
|
||
createTag: ["POST /repos/{owner}/{repo}/git/tags"],
|
||
createTree: ["POST /repos/{owner}/{repo}/git/trees"],
|
||
deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
|
||
getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
|
||
getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
|
||
getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
|
||
getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
|
||
getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
|
||
listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
|
||
updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
|
||
},
|
||
gitignore: {
|
||
getAllTemplates: ["GET /gitignore/templates"],
|
||
getTemplate: ["GET /gitignore/templates/{name}"]
|
||
},
|
||
interactions: {
|
||
getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
|
||
getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
|
||
getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits"],
|
||
removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
|
||
removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"],
|
||
removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits"],
|
||
setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
|
||
setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
|
||
setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits"]
|
||
},
|
||
issues: {
|
||
addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
|
||
addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
||
checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
|
||
create: ["POST /repos/{owner}/{repo}/issues"],
|
||
createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],
|
||
createLabel: ["POST /repos/{owner}/{repo}/labels"],
|
||
createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
|
||
deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],
|
||
deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
|
||
deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],
|
||
get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
|
||
getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
|
||
getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
|
||
getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
|
||
getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
|
||
list: ["GET /issues"],
|
||
listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
|
||
listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
|
||
listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
|
||
listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
|
||
listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
|
||
listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", {
|
||
mediaType: {
|
||
previews: ["mockingbird"]
|
||
}
|
||
}],
|
||
listForAuthenticatedUser: ["GET /user/issues"],
|
||
listForOrg: ["GET /orgs/{org}/issues"],
|
||
listForRepo: ["GET /repos/{owner}/{repo}/issues"],
|
||
listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],
|
||
listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
|
||
listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
||
listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
|
||
lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
|
||
removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
||
removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
|
||
removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],
|
||
setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
||
unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
|
||
update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
|
||
updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
|
||
updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
|
||
updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]
|
||
},
|
||
licenses: {
|
||
get: ["GET /licenses/{license}"],
|
||
getAllCommonlyUsed: ["GET /licenses"],
|
||
getForRepo: ["GET /repos/{owner}/{repo}/license"]
|
||
},
|
||
markdown: {
|
||
render: ["POST /markdown"],
|
||
renderRaw: ["POST /markdown/raw", {
|
||
headers: {
|
||
"content-type": "text/plain; charset=utf-8"
|
||
}
|
||
}]
|
||
},
|
||
meta: {
|
||
get: ["GET /meta"],
|
||
getOctocat: ["GET /octocat"],
|
||
getZen: ["GET /zen"],
|
||
root: ["GET /"]
|
||
},
|
||
migrations: {
|
||
cancelImport: ["DELETE /repos/{owner}/{repo}/import"],
|
||
deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"],
|
||
getImportStatus: ["GET /repos/{owner}/{repo}/import"],
|
||
getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"],
|
||
getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
listForAuthenticatedUser: ["GET /user/migrations", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
listForOrg: ["GET /orgs/{org}/migrations", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
listReposForUser: ["GET /user/migrations/{migration_id}/repositories", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"],
|
||
setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"],
|
||
startForAuthenticatedUser: ["POST /user/migrations"],
|
||
startForOrg: ["POST /orgs/{org}/migrations"],
|
||
startImport: ["PUT /repos/{owner}/{repo}/import"],
|
||
unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", {
|
||
mediaType: {
|
||
previews: ["wyandotte"]
|
||
}
|
||
}],
|
||
updateImport: ["PATCH /repos/{owner}/{repo}/import"]
|
||
},
|
||
orgs: {
|
||
blockUser: ["PUT /orgs/{org}/blocks/{username}"],
|
||
checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
|
||
checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
|
||
checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
|
||
convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"],
|
||
createInvitation: ["POST /orgs/{org}/invitations"],
|
||
createWebhook: ["POST /orgs/{org}/hooks"],
|
||
deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
|
||
get: ["GET /orgs/{org}"],
|
||
getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
|
||
getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
|
||
getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
|
||
getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"],
|
||
list: ["GET /organizations"],
|
||
listAppInstallations: ["GET /orgs/{org}/installations"],
|
||
listBlockedUsers: ["GET /orgs/{org}/blocks"],
|
||
listForAuthenticatedUser: ["GET /user/orgs"],
|
||
listForUser: ["GET /users/{username}/orgs"],
|
||
listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
|
||
listMembers: ["GET /orgs/{org}/members"],
|
||
listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
|
||
listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
|
||
listPendingInvitations: ["GET /orgs/{org}/invitations"],
|
||
listPublicMembers: ["GET /orgs/{org}/public_members"],
|
||
listWebhooks: ["GET /orgs/{org}/hooks"],
|
||
pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
|
||
removeMember: ["DELETE /orgs/{org}/members/{username}"],
|
||
removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
|
||
removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"],
|
||
removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"],
|
||
setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
|
||
setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"],
|
||
unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
|
||
update: ["PATCH /orgs/{org}"],
|
||
updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"],
|
||
updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"],
|
||
updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"]
|
||
},
|
||
projects: {
|
||
addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
createCard: ["POST /projects/columns/{column_id}/cards", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
createColumn: ["POST /projects/{project_id}/columns", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
createForAuthenticatedUser: ["POST /user/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
createForOrg: ["POST /orgs/{org}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
createForRepo: ["POST /repos/{owner}/{repo}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
delete: ["DELETE /projects/{project_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
deleteCard: ["DELETE /projects/columns/cards/{card_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
deleteColumn: ["DELETE /projects/columns/{column_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
get: ["GET /projects/{project_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
getCard: ["GET /projects/columns/cards/{card_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
getColumn: ["GET /projects/columns/{column_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listCards: ["GET /projects/columns/{column_id}/cards", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listCollaborators: ["GET /projects/{project_id}/collaborators", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listColumns: ["GET /projects/{project_id}/columns", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listForOrg: ["GET /orgs/{org}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listForRepo: ["GET /repos/{owner}/{repo}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listForUser: ["GET /users/{username}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
moveCard: ["POST /projects/columns/cards/{card_id}/moves", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
moveColumn: ["POST /projects/columns/{column_id}/moves", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
update: ["PATCH /projects/{project_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
updateCard: ["PATCH /projects/columns/cards/{card_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
updateColumn: ["PATCH /projects/columns/{column_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}]
|
||
},
|
||
pulls: {
|
||
checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
|
||
create: ["POST /repos/{owner}/{repo}/pulls"],
|
||
createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],
|
||
createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
|
||
createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
|
||
deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
|
||
deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
|
||
dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],
|
||
get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
|
||
getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
|
||
getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
|
||
list: ["GET /repos/{owner}/{repo}/pulls"],
|
||
listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],
|
||
listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
|
||
listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
|
||
listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
|
||
listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
|
||
listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
|
||
listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
|
||
merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
|
||
removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
|
||
requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
|
||
submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],
|
||
update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
|
||
updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", {
|
||
mediaType: {
|
||
previews: ["lydian"]
|
||
}
|
||
}],
|
||
updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
|
||
updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]
|
||
},
|
||
rateLimit: {
|
||
get: ["GET /rate_limit"]
|
||
},
|
||
reactions: {
|
||
createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
deleteLegacy: ["DELETE /reactions/{reaction_id}", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}, {
|
||
deprecated: "octokit.reactions.deleteLegacy() is deprecated, see https://docs.github.com/v3/reactions/#delete-a-reaction-legacy"
|
||
}],
|
||
listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}],
|
||
listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
|
||
mediaType: {
|
||
previews: ["squirrel-girl"]
|
||
}
|
||
}]
|
||
},
|
||
repos: {
|
||
acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"],
|
||
addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
|
||
mapToData: "apps"
|
||
}],
|
||
addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
|
||
addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
|
||
mapToData: "contexts"
|
||
}],
|
||
addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
|
||
mapToData: "teams"
|
||
}],
|
||
addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
|
||
mapToData: "users"
|
||
}],
|
||
checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
|
||
checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", {
|
||
mediaType: {
|
||
previews: ["dorian"]
|
||
}
|
||
}],
|
||
compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
|
||
createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
|
||
createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
|
||
mediaType: {
|
||
previews: ["zzzax"]
|
||
}
|
||
}],
|
||
createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
|
||
createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
|
||
createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
|
||
createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
|
||
createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
|
||
createForAuthenticatedUser: ["POST /user/repos"],
|
||
createFork: ["POST /repos/{owner}/{repo}/forks"],
|
||
createInOrg: ["POST /orgs/{org}/repos"],
|
||
createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
|
||
createPagesSite: ["POST /repos/{owner}/{repo}/pages", {
|
||
mediaType: {
|
||
previews: ["switcheroo"]
|
||
}
|
||
}],
|
||
createRelease: ["POST /repos/{owner}/{repo}/releases"],
|
||
createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", {
|
||
mediaType: {
|
||
previews: ["baptiste"]
|
||
}
|
||
}],
|
||
createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
|
||
declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"],
|
||
delete: ["DELETE /repos/{owner}/{repo}"],
|
||
deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
|
||
deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
|
||
deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],
|
||
deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
|
||
deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
|
||
mediaType: {
|
||
previews: ["zzzax"]
|
||
}
|
||
}],
|
||
deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
|
||
deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],
|
||
deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
|
||
deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],
|
||
deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages", {
|
||
mediaType: {
|
||
previews: ["switcheroo"]
|
||
}
|
||
}],
|
||
deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
|
||
deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
|
||
deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],
|
||
deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
|
||
disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", {
|
||
mediaType: {
|
||
previews: ["london"]
|
||
}
|
||
}],
|
||
disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", {
|
||
mediaType: {
|
||
previews: ["dorian"]
|
||
}
|
||
}],
|
||
downloadArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}", {}, {
|
||
renamed: ["repos", "downloadZipballArchive"]
|
||
}],
|
||
downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"],
|
||
downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"],
|
||
enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes", {
|
||
mediaType: {
|
||
previews: ["london"]
|
||
}
|
||
}],
|
||
enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", {
|
||
mediaType: {
|
||
previews: ["dorian"]
|
||
}
|
||
}],
|
||
get: ["GET /repos/{owner}/{repo}"],
|
||
getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
|
||
getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
|
||
getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],
|
||
getAllTopics: ["GET /repos/{owner}/{repo}/topics", {
|
||
mediaType: {
|
||
previews: ["mercy"]
|
||
}
|
||
}],
|
||
getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],
|
||
getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
|
||
getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"],
|
||
getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
|
||
getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
|
||
getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],
|
||
getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
|
||
getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
|
||
getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
|
||
getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
|
||
getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
|
||
mediaType: {
|
||
previews: ["zzzax"]
|
||
}
|
||
}],
|
||
getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
|
||
getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
|
||
getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
|
||
getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
|
||
getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
|
||
getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],
|
||
getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
|
||
getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
|
||
getPages: ["GET /repos/{owner}/{repo}/pages"],
|
||
getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
|
||
getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
|
||
getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
|
||
getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
|
||
getReadme: ["GET /repos/{owner}/{repo}/readme"],
|
||
getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
|
||
getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
|
||
getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
|
||
getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
|
||
getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],
|
||
getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
|
||
getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
|
||
getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],
|
||
getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
|
||
getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
|
||
getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"],
|
||
listBranches: ["GET /repos/{owner}/{repo}/branches"],
|
||
listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", {
|
||
mediaType: {
|
||
previews: ["groot"]
|
||
}
|
||
}],
|
||
listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
|
||
listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
|
||
listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
|
||
listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],
|
||
listCommits: ["GET /repos/{owner}/{repo}/commits"],
|
||
listContributors: ["GET /repos/{owner}/{repo}/contributors"],
|
||
listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
|
||
listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
|
||
listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
|
||
listForAuthenticatedUser: ["GET /user/repos"],
|
||
listForOrg: ["GET /orgs/{org}/repos"],
|
||
listForUser: ["GET /users/{username}/repos"],
|
||
listForks: ["GET /repos/{owner}/{repo}/forks"],
|
||
listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
|
||
listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
|
||
listLanguages: ["GET /repos/{owner}/{repo}/languages"],
|
||
listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
|
||
listPublic: ["GET /repositories"],
|
||
listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", {
|
||
mediaType: {
|
||
previews: ["groot"]
|
||
}
|
||
}],
|
||
listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],
|
||
listReleases: ["GET /repos/{owner}/{repo}/releases"],
|
||
listTags: ["GET /repos/{owner}/{repo}/tags"],
|
||
listTeams: ["GET /repos/{owner}/{repo}/teams"],
|
||
listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
|
||
merge: ["POST /repos/{owner}/{repo}/merges"],
|
||
pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
|
||
removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
|
||
mapToData: "apps"
|
||
}],
|
||
removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"],
|
||
removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
|
||
mapToData: "contexts"
|
||
}],
|
||
removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
|
||
removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
|
||
mapToData: "teams"
|
||
}],
|
||
removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
|
||
mapToData: "users"
|
||
}],
|
||
replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics", {
|
||
mediaType: {
|
||
previews: ["mercy"]
|
||
}
|
||
}],
|
||
requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
|
||
setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
|
||
setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
|
||
mapToData: "apps"
|
||
}],
|
||
setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
|
||
mapToData: "contexts"
|
||
}],
|
||
setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
|
||
mapToData: "teams"
|
||
}],
|
||
setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
|
||
mapToData: "users"
|
||
}],
|
||
testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
|
||
transfer: ["POST /repos/{owner}/{repo}/transfer"],
|
||
update: ["PATCH /repos/{owner}/{repo}"],
|
||
updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],
|
||
updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
|
||
updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
|
||
updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],
|
||
updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
|
||
updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
|
||
updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],
|
||
updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, {
|
||
renamed: ["repos", "updateStatusCheckProtection"]
|
||
}],
|
||
updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
|
||
updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
|
||
updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"],
|
||
uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", {
|
||
baseUrl: "https://uploads.github.com"
|
||
}]
|
||
},
|
||
search: {
|
||
code: ["GET /search/code"],
|
||
commits: ["GET /search/commits", {
|
||
mediaType: {
|
||
previews: ["cloak"]
|
||
}
|
||
}],
|
||
issuesAndPullRequests: ["GET /search/issues"],
|
||
labels: ["GET /search/labels"],
|
||
repos: ["GET /search/repositories"],
|
||
topics: ["GET /search/topics", {
|
||
mediaType: {
|
||
previews: ["mercy"]
|
||
}
|
||
}],
|
||
users: ["GET /search/users"]
|
||
},
|
||
secretScanning: {
|
||
getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],
|
||
listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"],
|
||
updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"]
|
||
},
|
||
teams: {
|
||
addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],
|
||
addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
|
||
checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
|
||
create: ["POST /orgs/{org}/teams"],
|
||
createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
|
||
createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
|
||
deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
|
||
deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
|
||
deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
|
||
getByName: ["GET /orgs/{org}/teams/{team_slug}"],
|
||
getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
|
||
getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
|
||
getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],
|
||
list: ["GET /orgs/{org}/teams"],
|
||
listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
|
||
listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
|
||
listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
|
||
listForAuthenticatedUser: ["GET /user/teams"],
|
||
listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
|
||
listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"],
|
||
listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", {
|
||
mediaType: {
|
||
previews: ["inertia"]
|
||
}
|
||
}],
|
||
listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
|
||
removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],
|
||
removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"],
|
||
removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
|
||
updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
|
||
updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
|
||
updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
|
||
},
|
||
users: {
|
||
addEmailForAuthenticated: ["POST /user/emails"],
|
||
block: ["PUT /user/blocks/{username}"],
|
||
checkBlocked: ["GET /user/blocks/{username}"],
|
||
checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
|
||
checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
|
||
createGpgKeyForAuthenticated: ["POST /user/gpg_keys"],
|
||
createPublicSshKeyForAuthenticated: ["POST /user/keys"],
|
||
deleteEmailForAuthenticated: ["DELETE /user/emails"],
|
||
deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"],
|
||
deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}"],
|
||
follow: ["PUT /user/following/{username}"],
|
||
getAuthenticated: ["GET /user"],
|
||
getByUsername: ["GET /users/{username}"],
|
||
getContextForUser: ["GET /users/{username}/hovercard"],
|
||
getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}"],
|
||
getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"],
|
||
list: ["GET /users"],
|
||
listBlockedByAuthenticated: ["GET /user/blocks"],
|
||
listEmailsForAuthenticated: ["GET /user/emails"],
|
||
listFollowedByAuthenticated: ["GET /user/following"],
|
||
listFollowersForAuthenticatedUser: ["GET /user/followers"],
|
||
listFollowersForUser: ["GET /users/{username}/followers"],
|
||
listFollowingForUser: ["GET /users/{username}/following"],
|
||
listGpgKeysForAuthenticated: ["GET /user/gpg_keys"],
|
||
listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
|
||
listPublicEmailsForAuthenticated: ["GET /user/public_emails"],
|
||
listPublicKeysForUser: ["GET /users/{username}/keys"],
|
||
listPublicSshKeysForAuthenticated: ["GET /user/keys"],
|
||
setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"],
|
||
unblock: ["DELETE /user/blocks/{username}"],
|
||
unfollow: ["DELETE /user/following/{username}"],
|
||
updateAuthenticated: ["PATCH /user"]
|
||
}
|
||
};
|
||
|
||
const VERSION = "4.4.1";
|
||
|
||
function endpointsToMethods(octokit, endpointsMap) {
|
||
const newMethods = {};
|
||
|
||
for (const [scope, endpoints] of Object.entries(endpointsMap)) {
|
||
for (const [methodName, endpoint] of Object.entries(endpoints)) {
|
||
const [route, defaults, decorations] = endpoint;
|
||
const [method, url] = route.split(/ /);
|
||
const endpointDefaults = Object.assign({
|
||
method,
|
||
url
|
||
}, defaults);
|
||
|
||
if (!newMethods[scope]) {
|
||
newMethods[scope] = {};
|
||
}
|
||
|
||
const scopeMethods = newMethods[scope];
|
||
|
||
if (decorations) {
|
||
scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations);
|
||
continue;
|
||
}
|
||
|
||
scopeMethods[methodName] = octokit.request.defaults(endpointDefaults);
|
||
}
|
||
}
|
||
|
||
return newMethods;
|
||
}
|
||
|
||
function decorate(octokit, scope, methodName, defaults, decorations) {
|
||
const requestWithDefaults = octokit.request.defaults(defaults);
|
||
/* istanbul ignore next */
|
||
|
||
function withDecorations(...args) {
|
||
// @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
|
||
let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData`
|
||
|
||
if (decorations.mapToData) {
|
||
options = Object.assign({}, options, {
|
||
data: options[decorations.mapToData],
|
||
[decorations.mapToData]: undefined
|
||
});
|
||
return requestWithDefaults(options);
|
||
}
|
||
|
||
if (decorations.renamed) {
|
||
const [newScope, newMethodName] = decorations.renamed;
|
||
octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`);
|
||
}
|
||
|
||
if (decorations.deprecated) {
|
||
octokit.log.warn(decorations.deprecated);
|
||
}
|
||
|
||
if (decorations.renamedParameters) {
|
||
// @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
|
||
const options = requestWithDefaults.endpoint.merge(...args);
|
||
|
||
for (const [name, alias] of Object.entries(decorations.renamedParameters)) {
|
||
if (name in options) {
|
||
octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`);
|
||
|
||
if (!(alias in options)) {
|
||
options[alias] = options[name];
|
||
}
|
||
|
||
delete options[name];
|
||
}
|
||
}
|
||
|
||
return requestWithDefaults(options);
|
||
} // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
|
||
|
||
|
||
return requestWithDefaults(...args);
|
||
}
|
||
|
||
return Object.assign(withDecorations, requestWithDefaults);
|
||
}
|
||
|
||
/**
|
||
* This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary
|
||
* goal is to rebuild @octokit/rest on top of @octokit/core. Once that is
|
||
* done, we will remove the registerEndpoints methods and return the methods
|
||
* directly as with the other plugins. At that point we will also remove the
|
||
* legacy workarounds and deprecations.
|
||
*
|
||
* See the plan at
|
||
* https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1
|
||
*/
|
||
|
||
function restEndpointMethods(octokit) {
|
||
return endpointsToMethods(octokit, Endpoints);
|
||
}
|
||
restEndpointMethods.VERSION = VERSION;
|
||
|
||
exports.restEndpointMethods = restEndpointMethods;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 537:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
||
|
||
var deprecation = __webpack_require__(8932);
|
||
var once = _interopDefault(__webpack_require__(1223));
|
||
|
||
const logOnce = once(deprecation => console.warn(deprecation));
|
||
/**
|
||
* Error with extra properties to help with debugging
|
||
*/
|
||
|
||
class RequestError extends Error {
|
||
constructor(message, statusCode, options) {
|
||
super(message); // Maintains proper stack trace (only available on V8)
|
||
|
||
/* istanbul ignore next */
|
||
|
||
if (Error.captureStackTrace) {
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
this.name = "HttpError";
|
||
this.status = statusCode;
|
||
Object.defineProperty(this, "code", {
|
||
get() {
|
||
logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
|
||
return statusCode;
|
||
}
|
||
|
||
});
|
||
this.headers = options.headers || {}; // redact request credentials without mutating original request options
|
||
|
||
const requestCopy = Object.assign({}, options.request);
|
||
|
||
if (options.request.headers.authorization) {
|
||
requestCopy.headers = Object.assign({}, options.request.headers, {
|
||
authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
|
||
});
|
||
}
|
||
|
||
requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit
|
||
// see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
|
||
.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended
|
||
// see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
|
||
.replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
|
||
this.request = requestCopy;
|
||
}
|
||
|
||
}
|
||
|
||
exports.RequestError = RequestError;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6234:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
||
|
||
var endpoint = __webpack_require__(9440);
|
||
var universalUserAgent = __webpack_require__(5030);
|
||
var isPlainObject = __webpack_require__(9062);
|
||
var nodeFetch = _interopDefault(__webpack_require__(467));
|
||
var requestError = __webpack_require__(537);
|
||
|
||
const VERSION = "5.4.12";
|
||
|
||
function getBufferResponse(response) {
|
||
return response.arrayBuffer();
|
||
}
|
||
|
||
function fetchWrapper(requestOptions) {
|
||
if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) {
|
||
requestOptions.body = JSON.stringify(requestOptions.body);
|
||
}
|
||
|
||
let headers = {};
|
||
let status;
|
||
let url;
|
||
const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch;
|
||
return fetch(requestOptions.url, Object.assign({
|
||
method: requestOptions.method,
|
||
body: requestOptions.body,
|
||
headers: requestOptions.headers,
|
||
redirect: requestOptions.redirect
|
||
}, requestOptions.request)).then(response => {
|
||
url = response.url;
|
||
status = response.status;
|
||
|
||
for (const keyAndValue of response.headers) {
|
||
headers[keyAndValue[0]] = keyAndValue[1];
|
||
}
|
||
|
||
if (status === 204 || status === 205) {
|
||
return;
|
||
} // GitHub API returns 200 for HEAD requests
|
||
|
||
|
||
if (requestOptions.method === "HEAD") {
|
||
if (status < 400) {
|
||
return;
|
||
}
|
||
|
||
throw new requestError.RequestError(response.statusText, status, {
|
||
headers,
|
||
request: requestOptions
|
||
});
|
||
}
|
||
|
||
if (status === 304) {
|
||
throw new requestError.RequestError("Not modified", status, {
|
||
headers,
|
||
request: requestOptions
|
||
});
|
||
}
|
||
|
||
if (status >= 400) {
|
||
return response.text().then(message => {
|
||
const error = new requestError.RequestError(message, status, {
|
||
headers,
|
||
request: requestOptions
|
||
});
|
||
|
||
try {
|
||
let responseBody = JSON.parse(error.message);
|
||
Object.assign(error, responseBody);
|
||
let errors = responseBody.errors; // Assumption `errors` would always be in Array format
|
||
|
||
error.message = error.message + ": " + errors.map(JSON.stringify).join(", ");
|
||
} catch (e) {// ignore, see octokit/rest.js#684
|
||
}
|
||
|
||
throw error;
|
||
});
|
||
}
|
||
|
||
const contentType = response.headers.get("content-type");
|
||
|
||
if (/application\/json/.test(contentType)) {
|
||
return response.json();
|
||
}
|
||
|
||
if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
|
||
return response.text();
|
||
}
|
||
|
||
return getBufferResponse(response);
|
||
}).then(data => {
|
||
return {
|
||
status,
|
||
url,
|
||
headers,
|
||
data
|
||
};
|
||
}).catch(error => {
|
||
if (error instanceof requestError.RequestError) {
|
||
throw error;
|
||
}
|
||
|
||
throw new requestError.RequestError(error.message, 500, {
|
||
headers,
|
||
request: requestOptions
|
||
});
|
||
});
|
||
}
|
||
|
||
function withDefaults(oldEndpoint, newDefaults) {
|
||
const endpoint = oldEndpoint.defaults(newDefaults);
|
||
|
||
const newApi = function (route, parameters) {
|
||
const endpointOptions = endpoint.merge(route, parameters);
|
||
|
||
if (!endpointOptions.request || !endpointOptions.request.hook) {
|
||
return fetchWrapper(endpoint.parse(endpointOptions));
|
||
}
|
||
|
||
const request = (route, parameters) => {
|
||
return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters)));
|
||
};
|
||
|
||
Object.assign(request, {
|
||
endpoint,
|
||
defaults: withDefaults.bind(null, endpoint)
|
||
});
|
||
return endpointOptions.request.hook(request, endpointOptions);
|
||
};
|
||
|
||
return Object.assign(newApi, {
|
||
endpoint,
|
||
defaults: withDefaults.bind(null, endpoint)
|
||
});
|
||
}
|
||
|
||
const request = withDefaults(endpoint.endpoint, {
|
||
headers: {
|
||
"user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}`
|
||
}
|
||
});
|
||
|
||
exports.request = request;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9062:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
/*!
|
||
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
|
||
*
|
||
* Copyright (c) 2014-2017, Jon Schlinkert.
|
||
* Released under the MIT License.
|
||
*/
|
||
|
||
function isObject(o) {
|
||
return Object.prototype.toString.call(o) === '[object Object]';
|
||
}
|
||
|
||
function isPlainObject(o) {
|
||
var ctor,prot;
|
||
|
||
if (isObject(o) === false) return false;
|
||
|
||
// If has modified constructor
|
||
ctor = o.constructor;
|
||
if (ctor === undefined) return true;
|
||
|
||
// If has modified prototype
|
||
prot = ctor.prototype;
|
||
if (isObject(prot) === false) return false;
|
||
|
||
// If constructor does not have an Object-specific method
|
||
if (prot.hasOwnProperty('isPrototypeOf') === false) {
|
||
return false;
|
||
}
|
||
|
||
// Most likely a plain Object
|
||
return true;
|
||
}
|
||
|
||
exports.isPlainObject = isPlainObject;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5375:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
var core = __webpack_require__(6762);
|
||
var pluginRequestLog = __webpack_require__(8883);
|
||
var pluginPaginateRest = __webpack_require__(4193);
|
||
var pluginRestEndpointMethods = __webpack_require__(3044);
|
||
|
||
const VERSION = "18.0.12";
|
||
|
||
const Octokit = core.Octokit.plugin(pluginRequestLog.requestLog, pluginRestEndpointMethods.restEndpointMethods, pluginPaginateRest.paginateRest).defaults({
|
||
userAgent: `octokit-rest.js/${VERSION}`
|
||
});
|
||
|
||
exports.Octokit = Octokit;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 3682:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var register = __webpack_require__(4670)
|
||
var addHook = __webpack_require__(5549)
|
||
var removeHook = __webpack_require__(6819)
|
||
|
||
// bind with array of arguments: https://stackoverflow.com/a/21792913
|
||
var bind = Function.bind
|
||
var bindable = bind.bind(bind)
|
||
|
||
function bindApi (hook, state, name) {
|
||
var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state])
|
||
hook.api = { remove: removeHookRef }
|
||
hook.remove = removeHookRef
|
||
|
||
;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
|
||
var args = name ? [state, kind, name] : [state, kind]
|
||
hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args)
|
||
})
|
||
}
|
||
|
||
function HookSingular () {
|
||
var singularHookName = 'h'
|
||
var singularHookState = {
|
||
registry: {}
|
||
}
|
||
var singularHook = register.bind(null, singularHookState, singularHookName)
|
||
bindApi(singularHook, singularHookState, singularHookName)
|
||
return singularHook
|
||
}
|
||
|
||
function HookCollection () {
|
||
var state = {
|
||
registry: {}
|
||
}
|
||
|
||
var hook = register.bind(null, state)
|
||
bindApi(hook, state)
|
||
|
||
return hook
|
||
}
|
||
|
||
var collectionHookDeprecationMessageDisplayed = false
|
||
function Hook () {
|
||
if (!collectionHookDeprecationMessageDisplayed) {
|
||
console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4')
|
||
collectionHookDeprecationMessageDisplayed = true
|
||
}
|
||
return HookCollection()
|
||
}
|
||
|
||
Hook.Singular = HookSingular.bind()
|
||
Hook.Collection = HookCollection.bind()
|
||
|
||
module.exports = Hook
|
||
// expose constructors as a named property for TypeScript
|
||
module.exports.Hook = Hook
|
||
module.exports.Singular = Hook.Singular
|
||
module.exports.Collection = Hook.Collection
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5549:
|
||
/***/ ((module) => {
|
||
|
||
module.exports = addHook
|
||
|
||
function addHook (state, kind, name, hook) {
|
||
var orig = hook
|
||
if (!state.registry[name]) {
|
||
state.registry[name] = []
|
||
}
|
||
|
||
if (kind === 'before') {
|
||
hook = function (method, options) {
|
||
return Promise.resolve()
|
||
.then(orig.bind(null, options))
|
||
.then(method.bind(null, options))
|
||
}
|
||
}
|
||
|
||
if (kind === 'after') {
|
||
hook = function (method, options) {
|
||
var result
|
||
return Promise.resolve()
|
||
.then(method.bind(null, options))
|
||
.then(function (result_) {
|
||
result = result_
|
||
return orig(result, options)
|
||
})
|
||
.then(function () {
|
||
return result
|
||
})
|
||
}
|
||
}
|
||
|
||
if (kind === 'error') {
|
||
hook = function (method, options) {
|
||
return Promise.resolve()
|
||
.then(method.bind(null, options))
|
||
.catch(function (error) {
|
||
return orig(error, options)
|
||
})
|
||
}
|
||
}
|
||
|
||
state.registry[name].push({
|
||
hook: hook,
|
||
orig: orig
|
||
})
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4670:
|
||
/***/ ((module) => {
|
||
|
||
module.exports = register
|
||
|
||
function register (state, name, method, options) {
|
||
if (typeof method !== 'function') {
|
||
throw new Error('method for before hook must be a function')
|
||
}
|
||
|
||
if (!options) {
|
||
options = {}
|
||
}
|
||
|
||
if (Array.isArray(name)) {
|
||
return name.reverse().reduce(function (callback, name) {
|
||
return register.bind(null, state, name, callback, options)
|
||
}, method)()
|
||
}
|
||
|
||
return Promise.resolve()
|
||
.then(function () {
|
||
if (!state.registry[name]) {
|
||
return method(options)
|
||
}
|
||
|
||
return (state.registry[name]).reduce(function (method, registered) {
|
||
return registered.hook.bind(null, method, options)
|
||
}, method)()
|
||
})
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6819:
|
||
/***/ ((module) => {
|
||
|
||
module.exports = removeHook
|
||
|
||
function removeHook (state, name, method) {
|
||
if (!state.registry[name]) {
|
||
return
|
||
}
|
||
|
||
var index = state.registry[name]
|
||
.map(function (registered) { return registered.orig })
|
||
.indexOf(method)
|
||
|
||
if (index === -1) {
|
||
return
|
||
}
|
||
|
||
state.registry[name].splice(index, 1)
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7401:
|
||
/***/ (function(module) {
|
||
|
||
!function(t,e){ true?module.exports=e():0}(this,function(){"use strict";var t="millisecond",e="second",n="minute",r="hour",i="day",s="week",u="month",a="quarter",o="year",f="date",h=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[^0-9]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?.?(\d+)?$/,c=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,d={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_")},$=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},l={s:$,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+$(r,2,"0")+":"+$(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,u),s=n-i<0,a=e.clone().add(r+(s?-1:1),u);return+(-(r+(n-i)/(s?i-a:a-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(h){return{M:u,y:o,w:s,d:i,D:f,h:r,m:n,s:e,ms:t,Q:a}[h]||String(h||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},y="en",M={};M[y]=d;var m=function(t){return t instanceof S},D=function(t,e,n){var r;if(!t)return y;if("string"==typeof t)M[t]&&(r=t),e&&(M[t]=e,r=t);else{var i=t.name;M[i]=t,r=i}return!n&&r&&(y=r),r||!n&&y},v=function(t,e){if(m(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new S(n)},g=l;g.l=D,g.i=m,g.w=function(t,e){return v(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var S=function(){function d(t){this.$L=D(t.locale,null,!0),this.parse(t)}var $=d.prototype;return $.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(g.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(h);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init()},$.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},$.$utils=function(){return g},$.isValid=function(){return!("Invalid Date"===this.$d.toString())},$.isSame=function(t,e){var n=v(t);return this.startOf(e)<=n&&n<=this.endOf(e)},$.isAfter=function(t,e){return v(t)<this.startOf(e)},$.isBefore=function(t,e){return this.endOf(e)<v(t)},$.$g=function(t,e,n){return g.u(t)?this[e]:this.set(n,t)},$.unix=function(){return Math.floor(this.valueOf()/1e3)},$.valueOf=function(){return this.$d.getTime()},$.startOf=function(t,a){var h=this,c=!!g.u(a)||a,d=g.p(t),$=function(t,e){var n=g.w(h.$u?Date.UTC(h.$y,e,t):new Date(h.$y,e,t),h);return c?n:n.endOf(i)},l=function(t,e){return g.w(h.toDate()[t].apply(h.toDate("s"),(c?[0,0,0,0]:[23,59,59,999]).slice(e)),h)},y=this.$W,M=this.$M,m=this.$D,D="set"+(this.$u?"UTC":"");switch(d){case o:return c?$(1,0):$(31,11);case u:return c?$(1,M):$(0,M+1);case s:var v=this.$locale().weekStart||0,S=(y<v?y+7:y)-v;return $(c?m-S:m+(6-S),M);case i:case f:return l(D+"Hours",0);case r:return l(D+"Minutes",1);case n:return l(D+"Seconds",2);case e:return l(D+"Milliseconds",3);default:return this.clone()}},$.endOf=function(t){return this.startOf(t,!1)},$.$set=function(s,a){var h,c=g.p(s),d="set"+(this.$u?"UTC":""),$=(h={},h[i]=d+"Date",h[f]=d+"Date",h[u]=d+"Month",h[o]=d+"FullYear",h[r]=d+"Hours",h[n]=d+"Minutes",h[e]=d+"Seconds",h[t]=d+"Milliseconds",h)[c],l=c===i?this.$D+(a-this.$W):a;if(c===u||c===o){var y=this.clone().set(f,1);y.$d[$](l),y.init(),this.$d=y.set(f,Math.min(this.$D,y.daysInMonth())).$d}else $&&this.$d[$](l);return this.init(),this},$.set=function(t,e){return this.clone().$set(t,e)},$.get=function(t){return this[g.p(t)]()},$.add=function(t,a){var f,h=this;t=Number(t);var c=g.p(a),d=function(e){var n=v(h);return g.w(n.date(n.date()+Math.round(e*t)),h)};if(c===u)return this.set(u,this.$M+t);if(c===o)return this.set(o,this.$y+t);if(c===i)return d(1);if(c===s)return d(7);var $=(f={},f[n]=6e4,f[r]=36e5,f[e]=1e3,f)[c]||1,l=this.$d.getTime()+t*$;return g.w(l,this)},$.subtract=function(t,e){return this.add(-1*t,e)},$.format=function(t){var e=this;if(!this.isValid())return"Invalid Date";var n=t||"YYYY-MM-DDTHH:mm:ssZ",r=g.z(this),i=this.$locale(),s=this.$H,u=this.$m,a=this.$M,o=i.weekdays,f=i.months,h=function(t,r,i,s){return t&&(t[r]||t(e,n))||i[r].substr(0,s)},d=function(t){return g.s(s%12||12,t,"0")},$=i.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:g.s(a+1,2,"0"),MMM:h(i.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:g.s(this.$D,2,"0"),d:String(this.$W),dd:h(i.weekdaysMin,this.$W,o,2),ddd:h(i.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:g.s(s,2,"0"),h:d(1),hh:d(2),a:$(s,u,!0),A:$(s,u,!1),m:String(u),mm:g.s(u,2,"0"),s:String(this.$s),ss:g.s(this.$s,2,"0"),SSS:g.s(this.$ms,3,"0"),Z:r};return n.replace(c,function(t,e){return e||l[t]||r.replace(":","")})},$.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},$.diff=function(t,f,h){var c,d=g.p(f),$=v(t),l=6e4*($.utcOffset()-this.utcOffset()),y=this-$,M=g.m(this,$);return M=(c={},c[o]=M/12,c[u]=M,c[a]=M/3,c[s]=(y-l)/6048e5,c[i]=(y-l)/864e5,c[r]=y/36e5,c[n]=y/6e4,c[e]=y/1e3,c)[d]||y,h?M:g.a(M)},$.daysInMonth=function(){return this.endOf(u).$D},$.$locale=function(){return M[this.$L]},$.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=D(t,e,!0);return r&&(n.$L=r),n},$.clone=function(){return g.w(this.$d,this)},$.toDate=function(){return new Date(this.valueOf())},$.toJSON=function(){return this.isValid()?this.toISOString():null},$.toISOString=function(){return this.$d.toISOString()},$.toString=function(){return this.$d.toUTCString()},d}(),p=S.prototype;return v.prototype=p,[["$ms",t],["$s",e],["$m",n],["$H",r],["$W",i],["$M",u],["$y",o],["$D",f]].forEach(function(t){p[t[1]]=function(e){return this.$g(e,t[0],t[1])}}),v.extend=function(t,e){return t.$i||(t(e,S,v),t.$i=!0),v},v.locale=D,v.isDayjs=m,v.unix=function(t){return v(1e3*t)},v.en=M[y],v.Ls=M,v.p={},v});
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9517:
|
||
/***/ (function(module) {
|
||
|
||
!function(e,t){ true?module.exports=t():0}(this,function(){"use strict";return function(e,t){t.prototype.isSameOrBefore=function(e,t){return this.isSame(e,t)||this.isBefore(e,t)}}});
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4359:
|
||
/***/ (function(module) {
|
||
|
||
!function(t,i){ true?module.exports=i():0}(this,function(){"use strict";return function(t,i,e){var s=i.prototype;e.utc=function(t){return new i({date:t,utc:!0,args:arguments})},s.utc=function(t){var i=e(this.toDate(),{locale:this.$L,utc:!0});return t?i.add(this.utcOffset(),"minute"):i},s.local=function(){return e(this.toDate(),{locale:this.$L,utc:!1})};var f=s.parse;s.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),f.call(this,t)};var n=s.init;s.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else n.call(this)};var u=s.utcOffset;s.utcOffset=function(t,i){var e=this.$utils().u;if(e(t))return this.$u?0:e(this.$offset)?u.call(this):this.$offset;var s=Math.abs(t)<=16?60*t:t,f=this;if(i)return f.$offset=s,f.$u=0===t,f;if(0!==t){var n=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(f=this.local().add(s+n,"minute")).$offset=s,f.$x.$localOffset=n}else f=this.utc();return f};var o=s.format;s.format=function(t){var i=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return o.call(this,i)},s.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||(new Date).getTimezoneOffset());return this.$d.valueOf()-6e4*t},s.isUTC=function(){return!!this.$u},s.toISOString=function(){return this.toDate().toISOString()},s.toString=function(){return this.toDate().toUTCString()};var r=s.toDate;s.toDate=function(t){return"s"===t&&this.$offset?e(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():r.call(this)};var a=s.diff;s.diff=function(t,i,s){if(t&&this.$u===t.$u)return a.call(this,t,i,s);var f=this.local(),n=e(t).local();return a.call(f,n,i,s)}}});
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8932:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
class Deprecation extends Error {
|
||
constructor(message) {
|
||
super(message); // Maintains proper stack trace (only available on V8)
|
||
|
||
/* istanbul ignore next */
|
||
|
||
if (Error.captureStackTrace) {
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
this.name = 'Deprecation';
|
||
}
|
||
|
||
}
|
||
|
||
exports.Deprecation = Deprecation;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2437:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
/* @flow */
|
||
/*::
|
||
|
||
type DotenvParseOptions = {
|
||
debug?: boolean
|
||
}
|
||
|
||
// keys and values from src
|
||
type DotenvParseOutput = { [string]: string }
|
||
|
||
type DotenvConfigOptions = {
|
||
path?: string, // path to .env file
|
||
encoding?: string, // encoding of .env file
|
||
debug?: string // turn on logging for debugging purposes
|
||
}
|
||
|
||
type DotenvConfigOutput = {
|
||
parsed?: DotenvParseOutput,
|
||
error?: Error
|
||
}
|
||
|
||
*/
|
||
|
||
const fs = __webpack_require__(5747)
|
||
const path = __webpack_require__(5622)
|
||
|
||
function log (message /*: string */) {
|
||
console.log(`[dotenv][DEBUG] ${message}`)
|
||
}
|
||
|
||
const NEWLINE = '\n'
|
||
const RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/
|
||
const RE_NEWLINES = /\\n/g
|
||
const NEWLINES_MATCH = /\n|\r|\r\n/
|
||
|
||
// Parses src into an Object
|
||
function parse (src /*: string | Buffer */, options /*: ?DotenvParseOptions */) /*: DotenvParseOutput */ {
|
||
const debug = Boolean(options && options.debug)
|
||
const obj = {}
|
||
|
||
// convert Buffers before splitting into lines and processing
|
||
src.toString().split(NEWLINES_MATCH).forEach(function (line, idx) {
|
||
// matching "KEY' and 'VAL' in 'KEY=VAL'
|
||
const keyValueArr = line.match(RE_INI_KEY_VAL)
|
||
// matched?
|
||
if (keyValueArr != null) {
|
||
const key = keyValueArr[1]
|
||
// default undefined or missing values to empty string
|
||
let val = (keyValueArr[2] || '')
|
||
const end = val.length - 1
|
||
const isDoubleQuoted = val[0] === '"' && val[end] === '"'
|
||
const isSingleQuoted = val[0] === "'" && val[end] === "'"
|
||
|
||
// if single or double quoted, remove quotes
|
||
if (isSingleQuoted || isDoubleQuoted) {
|
||
val = val.substring(1, end)
|
||
|
||
// if double quoted, expand newlines
|
||
if (isDoubleQuoted) {
|
||
val = val.replace(RE_NEWLINES, NEWLINE)
|
||
}
|
||
} else {
|
||
// remove surrounding whitespace
|
||
val = val.trim()
|
||
}
|
||
|
||
obj[key] = val
|
||
} else if (debug) {
|
||
log(`did not match key and value when parsing line ${idx + 1}: ${line}`)
|
||
}
|
||
})
|
||
|
||
return obj
|
||
}
|
||
|
||
// Populates process.env from .env file
|
||
function config (options /*: ?DotenvConfigOptions */) /*: DotenvConfigOutput */ {
|
||
let dotenvPath = path.resolve(process.cwd(), '.env')
|
||
let encoding /*: string */ = 'utf8'
|
||
let debug = false
|
||
|
||
if (options) {
|
||
if (options.path != null) {
|
||
dotenvPath = options.path
|
||
}
|
||
if (options.encoding != null) {
|
||
encoding = options.encoding
|
||
}
|
||
if (options.debug != null) {
|
||
debug = true
|
||
}
|
||
}
|
||
|
||
try {
|
||
// specifying an encoding returns a string instead of a buffer
|
||
const parsed = parse(fs.readFileSync(dotenvPath, { encoding }), { debug })
|
||
|
||
Object.keys(parsed).forEach(function (key) {
|
||
if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
|
||
process.env[key] = parsed[key]
|
||
} else if (debug) {
|
||
log(`"${key}" is already defined in \`process.env\` and will not be overwritten`)
|
||
}
|
||
})
|
||
|
||
return { parsed }
|
||
} catch (e) {
|
||
return { error: e }
|
||
}
|
||
}
|
||
|
||
module.exports.config = config
|
||
module.exports.parse = parse
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9213:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var root = __webpack_require__(9882);
|
||
|
||
/** Built-in value references. */
|
||
var Symbol = root.Symbol;
|
||
|
||
module.exports = Symbol;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2237:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseTimes = __webpack_require__(7765),
|
||
isArguments = __webpack_require__(8495),
|
||
isArray = __webpack_require__(4869),
|
||
isBuffer = __webpack_require__(4190),
|
||
isIndex = __webpack_require__(2936),
|
||
isTypedArray = __webpack_require__(2496);
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Creates an array of the enumerable property names of the array-like `value`.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to query.
|
||
* @param {boolean} inherited Specify returning inherited property names.
|
||
* @returns {Array} Returns the array of property names.
|
||
*/
|
||
function arrayLikeKeys(value, inherited) {
|
||
var isArr = isArray(value),
|
||
isArg = !isArr && isArguments(value),
|
||
isBuff = !isArr && !isArg && isBuffer(value),
|
||
isType = !isArr && !isArg && !isBuff && isTypedArray(value),
|
||
skipIndexes = isArr || isArg || isBuff || isType,
|
||
result = skipIndexes ? baseTimes(value.length, String) : [],
|
||
length = result.length;
|
||
|
||
for (var key in value) {
|
||
if ((inherited || hasOwnProperty.call(value, key)) &&
|
||
!(skipIndexes && (
|
||
// Safari 9 has enumerable `arguments.length` in strict mode.
|
||
key == 'length' ||
|
||
// Node.js 0.10 has enumerable non-index properties on buffers.
|
||
(isBuff && (key == 'offset' || key == 'parent')) ||
|
||
// PhantomJS 2 has enumerable non-index properties on typed arrays.
|
||
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
|
||
// Skip index properties.
|
||
isIndex(key, length)
|
||
))) {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = arrayLikeKeys;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4356:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* A specialized version of `_.map` for arrays without support for iteratee
|
||
* shorthands.
|
||
*
|
||
* @private
|
||
* @param {Array} [array] The array to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array} Returns the new mapped array.
|
||
*/
|
||
function arrayMap(array, iteratee) {
|
||
var index = -1,
|
||
length = array == null ? 0 : array.length,
|
||
result = Array(length);
|
||
|
||
while (++index < length) {
|
||
result[index] = iteratee(array[index], index, array);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = arrayMap;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 585:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseClamp = __webpack_require__(768),
|
||
copyArray = __webpack_require__(5157),
|
||
shuffleSelf = __webpack_require__(5436);
|
||
|
||
/**
|
||
* A specialized version of `_.sampleSize` for arrays.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to sample.
|
||
* @param {number} n The number of elements to sample.
|
||
* @returns {Array} Returns the random elements.
|
||
*/
|
||
function arraySampleSize(array, n) {
|
||
return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
|
||
}
|
||
|
||
module.exports = arraySampleSize;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 768:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* The base implementation of `_.clamp` which doesn't coerce arguments.
|
||
*
|
||
* @private
|
||
* @param {number} number The number to clamp.
|
||
* @param {number} [lower] The lower bound.
|
||
* @param {number} upper The upper bound.
|
||
* @returns {number} Returns the clamped number.
|
||
*/
|
||
function baseClamp(number, lower, upper) {
|
||
if (number === number) {
|
||
if (upper !== undefined) {
|
||
number = number <= upper ? number : upper;
|
||
}
|
||
if (lower !== undefined) {
|
||
number = number >= lower ? number : lower;
|
||
}
|
||
}
|
||
return number;
|
||
}
|
||
|
||
module.exports = baseClamp;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7497:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var Symbol = __webpack_require__(9213),
|
||
getRawTag = __webpack_require__(923),
|
||
objectToString = __webpack_require__(4200);
|
||
|
||
/** `Object#toString` result references. */
|
||
var nullTag = '[object Null]',
|
||
undefinedTag = '[object Undefined]';
|
||
|
||
/** Built-in value references. */
|
||
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
||
|
||
/**
|
||
* The base implementation of `getTag` without fallbacks for buggy environments.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to query.
|
||
* @returns {string} Returns the `toStringTag`.
|
||
*/
|
||
function baseGetTag(value) {
|
||
if (value == null) {
|
||
return value === undefined ? undefinedTag : nullTag;
|
||
}
|
||
return (symToStringTag && symToStringTag in Object(value))
|
||
? getRawTag(value)
|
||
: objectToString(value);
|
||
}
|
||
|
||
module.exports = baseGetTag;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2177:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseGetTag = __webpack_require__(7497),
|
||
isObjectLike = __webpack_require__(5926);
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]';
|
||
|
||
/**
|
||
* The base implementation of `_.isArguments`.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
|
||
*/
|
||
function baseIsArguments(value) {
|
||
return isObjectLike(value) && baseGetTag(value) == argsTag;
|
||
}
|
||
|
||
module.exports = baseIsArguments;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1528:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseGetTag = __webpack_require__(7497),
|
||
isLength = __webpack_require__(4530),
|
||
isObjectLike = __webpack_require__(5926);
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]',
|
||
arrayTag = '[object Array]',
|
||
boolTag = '[object Boolean]',
|
||
dateTag = '[object Date]',
|
||
errorTag = '[object Error]',
|
||
funcTag = '[object Function]',
|
||
mapTag = '[object Map]',
|
||
numberTag = '[object Number]',
|
||
objectTag = '[object Object]',
|
||
regexpTag = '[object RegExp]',
|
||
setTag = '[object Set]',
|
||
stringTag = '[object String]',
|
||
weakMapTag = '[object WeakMap]';
|
||
|
||
var arrayBufferTag = '[object ArrayBuffer]',
|
||
dataViewTag = '[object DataView]',
|
||
float32Tag = '[object Float32Array]',
|
||
float64Tag = '[object Float64Array]',
|
||
int8Tag = '[object Int8Array]',
|
||
int16Tag = '[object Int16Array]',
|
||
int32Tag = '[object Int32Array]',
|
||
uint8Tag = '[object Uint8Array]',
|
||
uint8ClampedTag = '[object Uint8ClampedArray]',
|
||
uint16Tag = '[object Uint16Array]',
|
||
uint32Tag = '[object Uint32Array]';
|
||
|
||
/** Used to identify `toStringTag` values of typed arrays. */
|
||
var typedArrayTags = {};
|
||
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
||
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
||
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
||
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
||
typedArrayTags[uint32Tag] = true;
|
||
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
||
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
||
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
|
||
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
|
||
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
|
||
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
|
||
typedArrayTags[setTag] = typedArrayTags[stringTag] =
|
||
typedArrayTags[weakMapTag] = false;
|
||
|
||
/**
|
||
* The base implementation of `_.isTypedArray` without Node.js optimizations.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
|
||
*/
|
||
function baseIsTypedArray(value) {
|
||
return isObjectLike(value) &&
|
||
isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
||
}
|
||
|
||
module.exports = baseIsTypedArray;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7164:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var isPrototype = __webpack_require__(10),
|
||
nativeKeys = __webpack_require__(5778);
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
*/
|
||
function baseKeys(object) {
|
||
if (!isPrototype(object)) {
|
||
return nativeKeys(object);
|
||
}
|
||
var result = [];
|
||
for (var key in Object(object)) {
|
||
if (hasOwnProperty.call(object, key) && key != 'constructor') {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseKeys;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2183:
|
||
/***/ ((module) => {
|
||
|
||
/* Built-in method references for those with the same name as other `lodash` methods. */
|
||
var nativeFloor = Math.floor,
|
||
nativeRandom = Math.random;
|
||
|
||
/**
|
||
* The base implementation of `_.random` without support for returning
|
||
* floating-point numbers.
|
||
*
|
||
* @private
|
||
* @param {number} lower The lower bound.
|
||
* @param {number} upper The upper bound.
|
||
* @returns {number} Returns the random number.
|
||
*/
|
||
function baseRandom(lower, upper) {
|
||
return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
|
||
}
|
||
|
||
module.exports = baseRandom;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8686:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseClamp = __webpack_require__(768),
|
||
shuffleSelf = __webpack_require__(5436),
|
||
values = __webpack_require__(5736);
|
||
|
||
/**
|
||
* The base implementation of `_.sampleSize` without param guards.
|
||
*
|
||
* @private
|
||
* @param {Array|Object} collection The collection to sample.
|
||
* @param {number} n The number of elements to sample.
|
||
* @returns {Array} Returns the random elements.
|
||
*/
|
||
function baseSampleSize(collection, n) {
|
||
var array = values(collection);
|
||
return shuffleSelf(array, baseClamp(n, 0, array.length));
|
||
}
|
||
|
||
module.exports = baseSampleSize;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7765:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* The base implementation of `_.times` without support for iteratee shorthands
|
||
* or max array length checks.
|
||
*
|
||
* @private
|
||
* @param {number} n The number of times to invoke `iteratee`.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array} Returns the array of results.
|
||
*/
|
||
function baseTimes(n, iteratee) {
|
||
var index = -1,
|
||
result = Array(n);
|
||
|
||
while (++index < n) {
|
||
result[index] = iteratee(index);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseTimes;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9258:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* The base implementation of `_.unary` without support for storing metadata.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to cap arguments for.
|
||
* @returns {Function} Returns the new capped function.
|
||
*/
|
||
function baseUnary(func) {
|
||
return function(value) {
|
||
return func(value);
|
||
};
|
||
}
|
||
|
||
module.exports = baseUnary;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5159:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var arrayMap = __webpack_require__(4356);
|
||
|
||
/**
|
||
* The base implementation of `_.values` and `_.valuesIn` which creates an
|
||
* array of `object` property values corresponding to the property names
|
||
* of `props`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @param {Array} props The property names to get values for.
|
||
* @returns {Object} Returns the array of property values.
|
||
*/
|
||
function baseValues(object, props) {
|
||
return arrayMap(props, function(key) {
|
||
return object[key];
|
||
});
|
||
}
|
||
|
||
module.exports = baseValues;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5157:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Copies the values of `source` to `array`.
|
||
*
|
||
* @private
|
||
* @param {Array} source The array to copy values from.
|
||
* @param {Array} [array=[]] The array to copy values to.
|
||
* @returns {Array} Returns `array`.
|
||
*/
|
||
function copyArray(source, array) {
|
||
var index = -1,
|
||
length = source.length;
|
||
|
||
array || (array = Array(length));
|
||
while (++index < length) {
|
||
array[index] = source[index];
|
||
}
|
||
return array;
|
||
}
|
||
|
||
module.exports = copyArray;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2085:
|
||
/***/ ((module) => {
|
||
|
||
/** Detect free variable `global` from Node.js. */
|
||
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
|
||
|
||
module.exports = freeGlobal;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 923:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var Symbol = __webpack_require__(9213);
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Used to resolve the
|
||
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var nativeObjectToString = objectProto.toString;
|
||
|
||
/** Built-in value references. */
|
||
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
||
|
||
/**
|
||
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to query.
|
||
* @returns {string} Returns the raw `toStringTag`.
|
||
*/
|
||
function getRawTag(value) {
|
||
var isOwn = hasOwnProperty.call(value, symToStringTag),
|
||
tag = value[symToStringTag];
|
||
|
||
try {
|
||
value[symToStringTag] = undefined;
|
||
var unmasked = true;
|
||
} catch (e) {}
|
||
|
||
var result = nativeObjectToString.call(value);
|
||
if (unmasked) {
|
||
if (isOwn) {
|
||
value[symToStringTag] = tag;
|
||
} else {
|
||
delete value[symToStringTag];
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = getRawTag;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2936:
|
||
/***/ ((module) => {
|
||
|
||
/** Used as references for various `Number` constants. */
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/** Used to detect unsigned integer values. */
|
||
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like index.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
||
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
||
*/
|
||
function isIndex(value, length) {
|
||
var type = typeof value;
|
||
length = length == null ? MAX_SAFE_INTEGER : length;
|
||
|
||
return !!length &&
|
||
(type == 'number' ||
|
||
(type != 'symbol' && reIsUint.test(value))) &&
|
||
(value > -1 && value % 1 == 0 && value < length);
|
||
}
|
||
|
||
module.exports = isIndex;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8494:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var eq = __webpack_require__(1901),
|
||
isArrayLike = __webpack_require__(8017),
|
||
isIndex = __webpack_require__(2936),
|
||
isObject = __webpack_require__(3334);
|
||
|
||
/**
|
||
* Checks if the given arguments are from an iteratee call.
|
||
*
|
||
* @private
|
||
* @param {*} value The potential iteratee value argument.
|
||
* @param {*} index The potential iteratee index or key argument.
|
||
* @param {*} object The potential iteratee object argument.
|
||
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
|
||
* else `false`.
|
||
*/
|
||
function isIterateeCall(value, index, object) {
|
||
if (!isObject(object)) {
|
||
return false;
|
||
}
|
||
var type = typeof index;
|
||
if (type == 'number'
|
||
? (isArrayLike(object) && isIndex(index, object.length))
|
||
: (type == 'string' && index in object)
|
||
) {
|
||
return eq(object[index], value);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = isIterateeCall;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 10:
|
||
/***/ ((module) => {
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Checks if `value` is likely a prototype object.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
|
||
*/
|
||
function isPrototype(value) {
|
||
var Ctor = value && value.constructor,
|
||
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
|
||
|
||
return value === proto;
|
||
}
|
||
|
||
module.exports = isPrototype;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5778:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var overArg = __webpack_require__(6320);
|
||
|
||
/* Built-in method references for those with the same name as other `lodash` methods. */
|
||
var nativeKeys = overArg(Object.keys, Object);
|
||
|
||
module.exports = nativeKeys;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4643:
|
||
/***/ ((module, exports, __webpack_require__) => {
|
||
|
||
/* module decorator */ module = __webpack_require__.nmd(module);
|
||
var freeGlobal = __webpack_require__(2085);
|
||
|
||
/** Detect free variable `exports`. */
|
||
var freeExports = true && exports && !exports.nodeType && exports;
|
||
|
||
/** Detect free variable `module`. */
|
||
var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
|
||
|
||
/** Detect the popular CommonJS extension `module.exports`. */
|
||
var moduleExports = freeModule && freeModule.exports === freeExports;
|
||
|
||
/** Detect free variable `process` from Node.js. */
|
||
var freeProcess = moduleExports && freeGlobal.process;
|
||
|
||
/** Used to access faster Node.js helpers. */
|
||
var nodeUtil = (function() {
|
||
try {
|
||
// Use `util.types` for Node.js 10+.
|
||
var types = freeModule && freeModule.require && freeModule.require('util').types;
|
||
|
||
if (types) {
|
||
return types;
|
||
}
|
||
|
||
// Legacy `process.binding('util')` for Node.js < 10.
|
||
return freeProcess && freeProcess.binding && freeProcess.binding('util');
|
||
} catch (e) {}
|
||
}());
|
||
|
||
module.exports = nodeUtil;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4200:
|
||
/***/ ((module) => {
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the
|
||
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var nativeObjectToString = objectProto.toString;
|
||
|
||
/**
|
||
* Converts `value` to a string using `Object.prototype.toString`.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to convert.
|
||
* @returns {string} Returns the converted string.
|
||
*/
|
||
function objectToString(value) {
|
||
return nativeObjectToString.call(value);
|
||
}
|
||
|
||
module.exports = objectToString;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6320:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Creates a unary function that invokes `func` with its argument transformed.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to wrap.
|
||
* @param {Function} transform The argument transform.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function overArg(func, transform) {
|
||
return function(arg) {
|
||
return func(transform(arg));
|
||
};
|
||
}
|
||
|
||
module.exports = overArg;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9882:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var freeGlobal = __webpack_require__(2085);
|
||
|
||
/** Detect free variable `self`. */
|
||
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
|
||
|
||
/** Used as a reference to the global object. */
|
||
var root = freeGlobal || freeSelf || Function('return this')();
|
||
|
||
module.exports = root;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5436:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseRandom = __webpack_require__(2183);
|
||
|
||
/**
|
||
* A specialized version of `_.shuffle` which mutates and sets the size of `array`.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to shuffle.
|
||
* @param {number} [size=array.length] The size of `array`.
|
||
* @returns {Array} Returns `array`.
|
||
*/
|
||
function shuffleSelf(array, size) {
|
||
var index = -1,
|
||
length = array.length,
|
||
lastIndex = length - 1;
|
||
|
||
size = size === undefined ? length : size;
|
||
while (++index < size) {
|
||
var rand = baseRandom(index, lastIndex),
|
||
value = array[rand];
|
||
|
||
array[rand] = array[index];
|
||
array[index] = value;
|
||
}
|
||
array.length = size;
|
||
return array;
|
||
}
|
||
|
||
module.exports = shuffleSelf;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1901:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Performs a
|
||
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
||
* comparison between two values to determine if they are equivalent.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to compare.
|
||
* @param {*} other The other value to compare.
|
||
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
||
* @example
|
||
*
|
||
* var object = { 'a': 1 };
|
||
* var other = { 'a': 1 };
|
||
*
|
||
* _.eq(object, object);
|
||
* // => true
|
||
*
|
||
* _.eq(object, other);
|
||
* // => false
|
||
*
|
||
* _.eq('a', 'a');
|
||
* // => true
|
||
*
|
||
* _.eq('a', Object('a'));
|
||
* // => false
|
||
*
|
||
* _.eq(NaN, NaN);
|
||
* // => true
|
||
*/
|
||
function eq(value, other) {
|
||
return value === other || (value !== value && other !== other);
|
||
}
|
||
|
||
module.exports = eq;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8495:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseIsArguments = __webpack_require__(2177),
|
||
isObjectLike = __webpack_require__(5926);
|
||
|
||
/** Used for built-in method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/** Built-in value references. */
|
||
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
||
|
||
/**
|
||
* Checks if `value` is likely an `arguments` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 0.1.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
|
||
* else `false`.
|
||
* @example
|
||
*
|
||
* _.isArguments(function() { return arguments; }());
|
||
* // => true
|
||
*
|
||
* _.isArguments([1, 2, 3]);
|
||
* // => false
|
||
*/
|
||
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
|
||
return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
|
||
!propertyIsEnumerable.call(value, 'callee');
|
||
};
|
||
|
||
module.exports = isArguments;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4869:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Checks if `value` is classified as an `Array` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 0.1.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArray([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isArray(document.body.children);
|
||
* // => false
|
||
*
|
||
* _.isArray('abc');
|
||
* // => false
|
||
*
|
||
* _.isArray(_.noop);
|
||
* // => false
|
||
*/
|
||
var isArray = Array.isArray;
|
||
|
||
module.exports = isArray;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8017:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var isFunction = __webpack_require__(7799),
|
||
isLength = __webpack_require__(4530);
|
||
|
||
/**
|
||
* Checks if `value` is array-like. A value is considered array-like if it's
|
||
* not a function and has a `value.length` that's an integer greater than or
|
||
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArrayLike([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isArrayLike(document.body.children);
|
||
* // => true
|
||
*
|
||
* _.isArrayLike('abc');
|
||
* // => true
|
||
*
|
||
* _.isArrayLike(_.noop);
|
||
* // => false
|
||
*/
|
||
function isArrayLike(value) {
|
||
return value != null && isLength(value.length) && !isFunction(value);
|
||
}
|
||
|
||
module.exports = isArrayLike;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4190:
|
||
/***/ ((module, exports, __webpack_require__) => {
|
||
|
||
/* module decorator */ module = __webpack_require__.nmd(module);
|
||
var root = __webpack_require__(9882),
|
||
stubFalse = __webpack_require__(7744);
|
||
|
||
/** Detect free variable `exports`. */
|
||
var freeExports = true && exports && !exports.nodeType && exports;
|
||
|
||
/** Detect free variable `module`. */
|
||
var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
|
||
|
||
/** Detect the popular CommonJS extension `module.exports`. */
|
||
var moduleExports = freeModule && freeModule.exports === freeExports;
|
||
|
||
/** Built-in value references. */
|
||
var Buffer = moduleExports ? root.Buffer : undefined;
|
||
|
||
/* Built-in method references for those with the same name as other `lodash` methods. */
|
||
var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
|
||
|
||
/**
|
||
* Checks if `value` is a buffer.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.3.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
|
||
* @example
|
||
*
|
||
* _.isBuffer(new Buffer(2));
|
||
* // => true
|
||
*
|
||
* _.isBuffer(new Uint8Array(2));
|
||
* // => false
|
||
*/
|
||
var isBuffer = nativeIsBuffer || stubFalse;
|
||
|
||
module.exports = isBuffer;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7799:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseGetTag = __webpack_require__(7497),
|
||
isObject = __webpack_require__(3334);
|
||
|
||
/** `Object#toString` result references. */
|
||
var asyncTag = '[object AsyncFunction]',
|
||
funcTag = '[object Function]',
|
||
genTag = '[object GeneratorFunction]',
|
||
proxyTag = '[object Proxy]';
|
||
|
||
/**
|
||
* Checks if `value` is classified as a `Function` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 0.1.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
|
||
* @example
|
||
*
|
||
* _.isFunction(_);
|
||
* // => true
|
||
*
|
||
* _.isFunction(/abc/);
|
||
* // => false
|
||
*/
|
||
function isFunction(value) {
|
||
if (!isObject(value)) {
|
||
return false;
|
||
}
|
||
// The use of `Object#toString` avoids issues with the `typeof` operator
|
||
// in Safari 9 which returns 'object' for typed arrays and other constructors.
|
||
var tag = baseGetTag(value);
|
||
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
||
}
|
||
|
||
module.exports = isFunction;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4530:
|
||
/***/ ((module) => {
|
||
|
||
/** Used as references for various `Number` constants. */
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like length.
|
||
*
|
||
* **Note:** This method is loosely based on
|
||
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
||
* @example
|
||
*
|
||
* _.isLength(3);
|
||
* // => true
|
||
*
|
||
* _.isLength(Number.MIN_VALUE);
|
||
* // => false
|
||
*
|
||
* _.isLength(Infinity);
|
||
* // => false
|
||
*
|
||
* _.isLength('3');
|
||
* // => false
|
||
*/
|
||
function isLength(value) {
|
||
return typeof value == 'number' &&
|
||
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
module.exports = isLength;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 3334:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Checks if `value` is the
|
||
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
|
||
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 0.1.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
||
* @example
|
||
*
|
||
* _.isObject({});
|
||
* // => true
|
||
*
|
||
* _.isObject([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isObject(_.noop);
|
||
* // => true
|
||
*
|
||
* _.isObject(null);
|
||
* // => false
|
||
*/
|
||
function isObject(value) {
|
||
var type = typeof value;
|
||
return value != null && (type == 'object' || type == 'function');
|
||
}
|
||
|
||
module.exports = isObject;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5926:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* Checks if `value` is object-like. A value is object-like if it's not `null`
|
||
* and has a `typeof` result of "object".
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
||
* @example
|
||
*
|
||
* _.isObjectLike({});
|
||
* // => true
|
||
*
|
||
* _.isObjectLike([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isObjectLike(_.noop);
|
||
* // => false
|
||
*
|
||
* _.isObjectLike(null);
|
||
* // => false
|
||
*/
|
||
function isObjectLike(value) {
|
||
return value != null && typeof value == 'object';
|
||
}
|
||
|
||
module.exports = isObjectLike;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6403:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseGetTag = __webpack_require__(7497),
|
||
isObjectLike = __webpack_require__(5926);
|
||
|
||
/** `Object#toString` result references. */
|
||
var symbolTag = '[object Symbol]';
|
||
|
||
/**
|
||
* Checks if `value` is classified as a `Symbol` primitive or object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
|
||
* @example
|
||
*
|
||
* _.isSymbol(Symbol.iterator);
|
||
* // => true
|
||
*
|
||
* _.isSymbol('abc');
|
||
* // => false
|
||
*/
|
||
function isSymbol(value) {
|
||
return typeof value == 'symbol' ||
|
||
(isObjectLike(value) && baseGetTag(value) == symbolTag);
|
||
}
|
||
|
||
module.exports = isSymbol;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2496:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseIsTypedArray = __webpack_require__(1528),
|
||
baseUnary = __webpack_require__(9258),
|
||
nodeUtil = __webpack_require__(4643);
|
||
|
||
/* Node.js helper references. */
|
||
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a typed array.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
|
||
* @example
|
||
*
|
||
* _.isTypedArray(new Uint8Array);
|
||
* // => true
|
||
*
|
||
* _.isTypedArray([]);
|
||
* // => false
|
||
*/
|
||
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
||
|
||
module.exports = isTypedArray;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7645:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var arrayLikeKeys = __webpack_require__(2237),
|
||
baseKeys = __webpack_require__(7164),
|
||
isArrayLike = __webpack_require__(8017);
|
||
|
||
/**
|
||
* Creates an array of the own enumerable property names of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects. See the
|
||
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
|
||
* for more details.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.keys(new Foo);
|
||
* // => ['a', 'b'] (iteration order is not guaranteed)
|
||
*
|
||
* _.keys('hi');
|
||
* // => ['0', '1']
|
||
*/
|
||
function keys(object) {
|
||
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
||
}
|
||
|
||
module.exports = keys;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2199:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var arraySampleSize = __webpack_require__(585),
|
||
baseSampleSize = __webpack_require__(8686),
|
||
isArray = __webpack_require__(4869),
|
||
isIterateeCall = __webpack_require__(8494),
|
||
toInteger = __webpack_require__(2722);
|
||
|
||
/**
|
||
* Gets `n` random elements at unique keys from `collection` up to the
|
||
* size of `collection`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Collection
|
||
* @param {Array|Object} collection The collection to sample.
|
||
* @param {number} [n=1] The number of elements to sample.
|
||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
* @returns {Array} Returns the random elements.
|
||
* @example
|
||
*
|
||
* _.sampleSize([1, 2, 3], 2);
|
||
* // => [3, 1]
|
||
*
|
||
* _.sampleSize([1, 2, 3], 4);
|
||
* // => [2, 3, 1]
|
||
*/
|
||
function sampleSize(collection, n, guard) {
|
||
if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
|
||
n = 1;
|
||
} else {
|
||
n = toInteger(n);
|
||
}
|
||
var func = isArray(collection) ? arraySampleSize : baseSampleSize;
|
||
return func(collection, n);
|
||
}
|
||
|
||
module.exports = sampleSize;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7744:
|
||
/***/ ((module) => {
|
||
|
||
/**
|
||
* This method returns `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {boolean} Returns `false`.
|
||
* @example
|
||
*
|
||
* _.times(2, _.stubFalse);
|
||
* // => [false, false]
|
||
*/
|
||
function stubFalse() {
|
||
return false;
|
||
}
|
||
|
||
module.exports = stubFalse;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9323:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var toNumber = __webpack_require__(1235);
|
||
|
||
/** Used as references for various `Number` constants. */
|
||
var INFINITY = 1 / 0,
|
||
MAX_INTEGER = 1.7976931348623157e+308;
|
||
|
||
/**
|
||
* Converts `value` to a finite number.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.12.0
|
||
* @category Lang
|
||
* @param {*} value The value to convert.
|
||
* @returns {number} Returns the converted number.
|
||
* @example
|
||
*
|
||
* _.toFinite(3.2);
|
||
* // => 3.2
|
||
*
|
||
* _.toFinite(Number.MIN_VALUE);
|
||
* // => 5e-324
|
||
*
|
||
* _.toFinite(Infinity);
|
||
* // => 1.7976931348623157e+308
|
||
*
|
||
* _.toFinite('3.2');
|
||
* // => 3.2
|
||
*/
|
||
function toFinite(value) {
|
||
if (!value) {
|
||
return value === 0 ? value : 0;
|
||
}
|
||
value = toNumber(value);
|
||
if (value === INFINITY || value === -INFINITY) {
|
||
var sign = (value < 0 ? -1 : 1);
|
||
return sign * MAX_INTEGER;
|
||
}
|
||
return value === value ? value : 0;
|
||
}
|
||
|
||
module.exports = toFinite;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2722:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var toFinite = __webpack_require__(9323);
|
||
|
||
/**
|
||
* Converts `value` to an integer.
|
||
*
|
||
* **Note:** This method is loosely based on
|
||
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to convert.
|
||
* @returns {number} Returns the converted integer.
|
||
* @example
|
||
*
|
||
* _.toInteger(3.2);
|
||
* // => 3
|
||
*
|
||
* _.toInteger(Number.MIN_VALUE);
|
||
* // => 0
|
||
*
|
||
* _.toInteger(Infinity);
|
||
* // => 1.7976931348623157e+308
|
||
*
|
||
* _.toInteger('3.2');
|
||
* // => 3
|
||
*/
|
||
function toInteger(value) {
|
||
var result = toFinite(value),
|
||
remainder = result % 1;
|
||
|
||
return result === result ? (remainder ? result - remainder : result) : 0;
|
||
}
|
||
|
||
module.exports = toInteger;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1235:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var isObject = __webpack_require__(3334),
|
||
isSymbol = __webpack_require__(6403);
|
||
|
||
/** Used as references for various `Number` constants. */
|
||
var NAN = 0 / 0;
|
||
|
||
/** Used to match leading and trailing whitespace. */
|
||
var reTrim = /^\s+|\s+$/g;
|
||
|
||
/** Used to detect bad signed hexadecimal string values. */
|
||
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
||
|
||
/** Used to detect binary string values. */
|
||
var reIsBinary = /^0b[01]+$/i;
|
||
|
||
/** Used to detect octal string values. */
|
||
var reIsOctal = /^0o[0-7]+$/i;
|
||
|
||
/** Built-in method references without a dependency on `root`. */
|
||
var freeParseInt = parseInt;
|
||
|
||
/**
|
||
* Converts `value` to a number.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Lang
|
||
* @param {*} value The value to process.
|
||
* @returns {number} Returns the number.
|
||
* @example
|
||
*
|
||
* _.toNumber(3.2);
|
||
* // => 3.2
|
||
*
|
||
* _.toNumber(Number.MIN_VALUE);
|
||
* // => 5e-324
|
||
*
|
||
* _.toNumber(Infinity);
|
||
* // => Infinity
|
||
*
|
||
* _.toNumber('3.2');
|
||
* // => 3.2
|
||
*/
|
||
function toNumber(value) {
|
||
if (typeof value == 'number') {
|
||
return value;
|
||
}
|
||
if (isSymbol(value)) {
|
||
return NAN;
|
||
}
|
||
if (isObject(value)) {
|
||
var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
|
||
value = isObject(other) ? (other + '') : other;
|
||
}
|
||
if (typeof value != 'string') {
|
||
return value === 0 ? value : +value;
|
||
}
|
||
value = value.replace(reTrim, '');
|
||
var isBinary = reIsBinary.test(value);
|
||
return (isBinary || reIsOctal.test(value))
|
||
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
|
||
: (reIsBadHex.test(value) ? NAN : +value);
|
||
}
|
||
|
||
module.exports = toNumber;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5736:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var baseValues = __webpack_require__(5159),
|
||
keys = __webpack_require__(7645);
|
||
|
||
/**
|
||
* Creates an array of the own enumerable string keyed property values of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property values.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.values(new Foo);
|
||
* // => [1, 2] (iteration order is not guaranteed)
|
||
*
|
||
* _.values('hi');
|
||
* // => ['h', 'i']
|
||
*/
|
||
function values(object) {
|
||
return object == null ? [] : baseValues(object, keys(object));
|
||
}
|
||
|
||
module.exports = values;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 467:
|
||
/***/ ((module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
||
|
||
var Stream = _interopDefault(__webpack_require__(2413));
|
||
var http = _interopDefault(__webpack_require__(8605));
|
||
var Url = _interopDefault(__webpack_require__(8835));
|
||
var https = _interopDefault(__webpack_require__(7211));
|
||
var zlib = _interopDefault(__webpack_require__(8761));
|
||
|
||
// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
|
||
|
||
// fix for "Readable" isn't a named export issue
|
||
const Readable = Stream.Readable;
|
||
|
||
const BUFFER = Symbol('buffer');
|
||
const TYPE = Symbol('type');
|
||
|
||
class Blob {
|
||
constructor() {
|
||
this[TYPE] = '';
|
||
|
||
const blobParts = arguments[0];
|
||
const options = arguments[1];
|
||
|
||
const buffers = [];
|
||
let size = 0;
|
||
|
||
if (blobParts) {
|
||
const a = blobParts;
|
||
const length = Number(a.length);
|
||
for (let i = 0; i < length; i++) {
|
||
const element = a[i];
|
||
let buffer;
|
||
if (element instanceof Buffer) {
|
||
buffer = element;
|
||
} else if (ArrayBuffer.isView(element)) {
|
||
buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
|
||
} else if (element instanceof ArrayBuffer) {
|
||
buffer = Buffer.from(element);
|
||
} else if (element instanceof Blob) {
|
||
buffer = element[BUFFER];
|
||
} else {
|
||
buffer = Buffer.from(typeof element === 'string' ? element : String(element));
|
||
}
|
||
size += buffer.length;
|
||
buffers.push(buffer);
|
||
}
|
||
}
|
||
|
||
this[BUFFER] = Buffer.concat(buffers);
|
||
|
||
let type = options && options.type !== undefined && String(options.type).toLowerCase();
|
||
if (type && !/[^\u0020-\u007E]/.test(type)) {
|
||
this[TYPE] = type;
|
||
}
|
||
}
|
||
get size() {
|
||
return this[BUFFER].length;
|
||
}
|
||
get type() {
|
||
return this[TYPE];
|
||
}
|
||
text() {
|
||
return Promise.resolve(this[BUFFER].toString());
|
||
}
|
||
arrayBuffer() {
|
||
const buf = this[BUFFER];
|
||
const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
||
return Promise.resolve(ab);
|
||
}
|
||
stream() {
|
||
const readable = new Readable();
|
||
readable._read = function () {};
|
||
readable.push(this[BUFFER]);
|
||
readable.push(null);
|
||
return readable;
|
||
}
|
||
toString() {
|
||
return '[object Blob]';
|
||
}
|
||
slice() {
|
||
const size = this.size;
|
||
|
||
const start = arguments[0];
|
||
const end = arguments[1];
|
||
let relativeStart, relativeEnd;
|
||
if (start === undefined) {
|
||
relativeStart = 0;
|
||
} else if (start < 0) {
|
||
relativeStart = Math.max(size + start, 0);
|
||
} else {
|
||
relativeStart = Math.min(start, size);
|
||
}
|
||
if (end === undefined) {
|
||
relativeEnd = size;
|
||
} else if (end < 0) {
|
||
relativeEnd = Math.max(size + end, 0);
|
||
} else {
|
||
relativeEnd = Math.min(end, size);
|
||
}
|
||
const span = Math.max(relativeEnd - relativeStart, 0);
|
||
|
||
const buffer = this[BUFFER];
|
||
const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
|
||
const blob = new Blob([], { type: arguments[2] });
|
||
blob[BUFFER] = slicedBuffer;
|
||
return blob;
|
||
}
|
||
}
|
||
|
||
Object.defineProperties(Blob.prototype, {
|
||
size: { enumerable: true },
|
||
type: { enumerable: true },
|
||
slice: { enumerable: true }
|
||
});
|
||
|
||
Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
|
||
value: 'Blob',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
/**
|
||
* fetch-error.js
|
||
*
|
||
* FetchError interface for operational errors
|
||
*/
|
||
|
||
/**
|
||
* Create FetchError instance
|
||
*
|
||
* @param String message Error message for human
|
||
* @param String type Error type for machine
|
||
* @param String systemError For Node.js system error
|
||
* @return FetchError
|
||
*/
|
||
function FetchError(message, type, systemError) {
|
||
Error.call(this, message);
|
||
|
||
this.message = message;
|
||
this.type = type;
|
||
|
||
// when err.type is `system`, err.code contains system error code
|
||
if (systemError) {
|
||
this.code = this.errno = systemError.code;
|
||
}
|
||
|
||
// hide custom error implementation details from end-users
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
FetchError.prototype = Object.create(Error.prototype);
|
||
FetchError.prototype.constructor = FetchError;
|
||
FetchError.prototype.name = 'FetchError';
|
||
|
||
let convert;
|
||
try {
|
||
convert = __webpack_require__(2877).convert;
|
||
} catch (e) {}
|
||
|
||
const INTERNALS = Symbol('Body internals');
|
||
|
||
// fix an issue where "PassThrough" isn't a named export for node <10
|
||
const PassThrough = Stream.PassThrough;
|
||
|
||
/**
|
||
* Body mixin
|
||
*
|
||
* Ref: https://fetch.spec.whatwg.org/#body
|
||
*
|
||
* @param Stream body Readable stream
|
||
* @param Object opts Response options
|
||
* @return Void
|
||
*/
|
||
function Body(body) {
|
||
var _this = this;
|
||
|
||
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
||
_ref$size = _ref.size;
|
||
|
||
let size = _ref$size === undefined ? 0 : _ref$size;
|
||
var _ref$timeout = _ref.timeout;
|
||
let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
|
||
|
||
if (body == null) {
|
||
// body is undefined or null
|
||
body = null;
|
||
} else if (isURLSearchParams(body)) {
|
||
// body is a URLSearchParams
|
||
body = Buffer.from(body.toString());
|
||
} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
|
||
// body is ArrayBuffer
|
||
body = Buffer.from(body);
|
||
} else if (ArrayBuffer.isView(body)) {
|
||
// body is ArrayBufferView
|
||
body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
|
||
} else if (body instanceof Stream) ; else {
|
||
// none of the above
|
||
// coerce to string then buffer
|
||
body = Buffer.from(String(body));
|
||
}
|
||
this[INTERNALS] = {
|
||
body,
|
||
disturbed: false,
|
||
error: null
|
||
};
|
||
this.size = size;
|
||
this.timeout = timeout;
|
||
|
||
if (body instanceof Stream) {
|
||
body.on('error', function (err) {
|
||
const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
|
||
_this[INTERNALS].error = error;
|
||
});
|
||
}
|
||
}
|
||
|
||
Body.prototype = {
|
||
get body() {
|
||
return this[INTERNALS].body;
|
||
},
|
||
|
||
get bodyUsed() {
|
||
return this[INTERNALS].disturbed;
|
||
},
|
||
|
||
/**
|
||
* Decode response as ArrayBuffer
|
||
*
|
||
* @return Promise
|
||
*/
|
||
arrayBuffer() {
|
||
return consumeBody.call(this).then(function (buf) {
|
||
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Return raw response as Blob
|
||
*
|
||
* @return Promise
|
||
*/
|
||
blob() {
|
||
let ct = this.headers && this.headers.get('content-type') || '';
|
||
return consumeBody.call(this).then(function (buf) {
|
||
return Object.assign(
|
||
// Prevent copying
|
||
new Blob([], {
|
||
type: ct.toLowerCase()
|
||
}), {
|
||
[BUFFER]: buf
|
||
});
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as json
|
||
*
|
||
* @return Promise
|
||
*/
|
||
json() {
|
||
var _this2 = this;
|
||
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
try {
|
||
return JSON.parse(buffer.toString());
|
||
} catch (err) {
|
||
return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
|
||
}
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as text
|
||
*
|
||
* @return Promise
|
||
*/
|
||
text() {
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
return buffer.toString();
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as buffer (non-spec api)
|
||
*
|
||
* @return Promise
|
||
*/
|
||
buffer() {
|
||
return consumeBody.call(this);
|
||
},
|
||
|
||
/**
|
||
* Decode response as text, while automatically detecting the encoding and
|
||
* trying to decode to UTF-8 (non-spec api)
|
||
*
|
||
* @return Promise
|
||
*/
|
||
textConverted() {
|
||
var _this3 = this;
|
||
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
return convertBody(buffer, _this3.headers);
|
||
});
|
||
}
|
||
};
|
||
|
||
// In browsers, all properties are enumerable.
|
||
Object.defineProperties(Body.prototype, {
|
||
body: { enumerable: true },
|
||
bodyUsed: { enumerable: true },
|
||
arrayBuffer: { enumerable: true },
|
||
blob: { enumerable: true },
|
||
json: { enumerable: true },
|
||
text: { enumerable: true }
|
||
});
|
||
|
||
Body.mixIn = function (proto) {
|
||
for (const name of Object.getOwnPropertyNames(Body.prototype)) {
|
||
// istanbul ignore else: future proof
|
||
if (!(name in proto)) {
|
||
const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
|
||
Object.defineProperty(proto, name, desc);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Consume and convert an entire Body to a Buffer.
|
||
*
|
||
* Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
|
||
*
|
||
* @return Promise
|
||
*/
|
||
function consumeBody() {
|
||
var _this4 = this;
|
||
|
||
if (this[INTERNALS].disturbed) {
|
||
return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
|
||
}
|
||
|
||
this[INTERNALS].disturbed = true;
|
||
|
||
if (this[INTERNALS].error) {
|
||
return Body.Promise.reject(this[INTERNALS].error);
|
||
}
|
||
|
||
let body = this.body;
|
||
|
||
// body is null
|
||
if (body === null) {
|
||
return Body.Promise.resolve(Buffer.alloc(0));
|
||
}
|
||
|
||
// body is blob
|
||
if (isBlob(body)) {
|
||
body = body.stream();
|
||
}
|
||
|
||
// body is buffer
|
||
if (Buffer.isBuffer(body)) {
|
||
return Body.Promise.resolve(body);
|
||
}
|
||
|
||
// istanbul ignore if: should never happen
|
||
if (!(body instanceof Stream)) {
|
||
return Body.Promise.resolve(Buffer.alloc(0));
|
||
}
|
||
|
||
// body is stream
|
||
// get ready to actually consume the body
|
||
let accum = [];
|
||
let accumBytes = 0;
|
||
let abort = false;
|
||
|
||
return new Body.Promise(function (resolve, reject) {
|
||
let resTimeout;
|
||
|
||
// allow timeout on slow response body
|
||
if (_this4.timeout) {
|
||
resTimeout = setTimeout(function () {
|
||
abort = true;
|
||
reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
|
||
}, _this4.timeout);
|
||
}
|
||
|
||
// handle stream errors
|
||
body.on('error', function (err) {
|
||
if (err.name === 'AbortError') {
|
||
// if the request was aborted, reject with this Error
|
||
abort = true;
|
||
reject(err);
|
||
} else {
|
||
// other errors, such as incorrect content-encoding
|
||
reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
|
||
}
|
||
});
|
||
|
||
body.on('data', function (chunk) {
|
||
if (abort || chunk === null) {
|
||
return;
|
||
}
|
||
|
||
if (_this4.size && accumBytes + chunk.length > _this4.size) {
|
||
abort = true;
|
||
reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
|
||
return;
|
||
}
|
||
|
||
accumBytes += chunk.length;
|
||
accum.push(chunk);
|
||
});
|
||
|
||
body.on('end', function () {
|
||
if (abort) {
|
||
return;
|
||
}
|
||
|
||
clearTimeout(resTimeout);
|
||
|
||
try {
|
||
resolve(Buffer.concat(accum, accumBytes));
|
||
} catch (err) {
|
||
// handle streams that have accumulated too much data (issue #414)
|
||
reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Detect buffer encoding and convert to target encoding
|
||
* ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
|
||
*
|
||
* @param Buffer buffer Incoming buffer
|
||
* @param String encoding Target encoding
|
||
* @return String
|
||
*/
|
||
function convertBody(buffer, headers) {
|
||
if (typeof convert !== 'function') {
|
||
throw new Error('The package `encoding` must be installed to use the textConverted() function');
|
||
}
|
||
|
||
const ct = headers.get('content-type');
|
||
let charset = 'utf-8';
|
||
let res, str;
|
||
|
||
// header
|
||
if (ct) {
|
||
res = /charset=([^;]*)/i.exec(ct);
|
||
}
|
||
|
||
// no charset in content type, peek at response body for at most 1024 bytes
|
||
str = buffer.slice(0, 1024).toString();
|
||
|
||
// html5
|
||
if (!res && str) {
|
||
res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
|
||
}
|
||
|
||
// html4
|
||
if (!res && str) {
|
||
res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
|
||
if (!res) {
|
||
res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
|
||
if (res) {
|
||
res.pop(); // drop last quote
|
||
}
|
||
}
|
||
|
||
if (res) {
|
||
res = /charset=(.*)/i.exec(res.pop());
|
||
}
|
||
}
|
||
|
||
// xml
|
||
if (!res && str) {
|
||
res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
|
||
}
|
||
|
||
// found charset
|
||
if (res) {
|
||
charset = res.pop();
|
||
|
||
// prevent decode issues when sites use incorrect encoding
|
||
// ref: https://hsivonen.fi/encoding-menu/
|
||
if (charset === 'gb2312' || charset === 'gbk') {
|
||
charset = 'gb18030';
|
||
}
|
||
}
|
||
|
||
// turn raw buffers into a single utf-8 buffer
|
||
return convert(buffer, 'UTF-8', charset).toString();
|
||
}
|
||
|
||
/**
|
||
* Detect a URLSearchParams object
|
||
* ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
|
||
*
|
||
* @param Object obj Object to detect by type or brand
|
||
* @return String
|
||
*/
|
||
function isURLSearchParams(obj) {
|
||
// Duck-typing as a necessary condition.
|
||
if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
|
||
return false;
|
||
}
|
||
|
||
// Brand-checking and more duck-typing as optional condition.
|
||
return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
|
||
}
|
||
|
||
/**
|
||
* Check if `obj` is a W3C `Blob` object (which `File` inherits from)
|
||
* @param {*} obj
|
||
* @return {boolean}
|
||
*/
|
||
function isBlob(obj) {
|
||
return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
|
||
}
|
||
|
||
/**
|
||
* Clone body given Res/Req instance
|
||
*
|
||
* @param Mixed instance Response or Request instance
|
||
* @return Mixed
|
||
*/
|
||
function clone(instance) {
|
||
let p1, p2;
|
||
let body = instance.body;
|
||
|
||
// don't allow cloning a used body
|
||
if (instance.bodyUsed) {
|
||
throw new Error('cannot clone body after it is used');
|
||
}
|
||
|
||
// check that body is a stream and not form-data object
|
||
// note: we can't clone the form-data object without having it as a dependency
|
||
if (body instanceof Stream && typeof body.getBoundary !== 'function') {
|
||
// tee instance body
|
||
p1 = new PassThrough();
|
||
p2 = new PassThrough();
|
||
body.pipe(p1);
|
||
body.pipe(p2);
|
||
// set instance body to teed body and return the other teed body
|
||
instance[INTERNALS].body = p1;
|
||
body = p2;
|
||
}
|
||
|
||
return body;
|
||
}
|
||
|
||
/**
|
||
* Performs the operation "extract a `Content-Type` value from |object|" as
|
||
* specified in the specification:
|
||
* https://fetch.spec.whatwg.org/#concept-bodyinit-extract
|
||
*
|
||
* This function assumes that instance.body is present.
|
||
*
|
||
* @param Mixed instance Any options.body input
|
||
*/
|
||
function extractContentType(body) {
|
||
if (body === null) {
|
||
// body is null
|
||
return null;
|
||
} else if (typeof body === 'string') {
|
||
// body is string
|
||
return 'text/plain;charset=UTF-8';
|
||
} else if (isURLSearchParams(body)) {
|
||
// body is a URLSearchParams
|
||
return 'application/x-www-form-urlencoded;charset=UTF-8';
|
||
} else if (isBlob(body)) {
|
||
// body is blob
|
||
return body.type || null;
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
return null;
|
||
} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
|
||
// body is ArrayBuffer
|
||
return null;
|
||
} else if (ArrayBuffer.isView(body)) {
|
||
// body is ArrayBufferView
|
||
return null;
|
||
} else if (typeof body.getBoundary === 'function') {
|
||
// detect form data input from form-data module
|
||
return `multipart/form-data;boundary=${body.getBoundary()}`;
|
||
} else if (body instanceof Stream) {
|
||
// body is stream
|
||
// can't really do much about this
|
||
return null;
|
||
} else {
|
||
// Body constructor defaults other things to string
|
||
return 'text/plain;charset=UTF-8';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The Fetch Standard treats this as if "total bytes" is a property on the body.
|
||
* For us, we have to explicitly get it with a function.
|
||
*
|
||
* ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
|
||
*
|
||
* @param Body instance Instance of Body
|
||
* @return Number? Number of bytes, or null if not possible
|
||
*/
|
||
function getTotalBytes(instance) {
|
||
const body = instance.body;
|
||
|
||
|
||
if (body === null) {
|
||
// body is null
|
||
return 0;
|
||
} else if (isBlob(body)) {
|
||
return body.size;
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
return body.length;
|
||
} else if (body && typeof body.getLengthSync === 'function') {
|
||
// detect form data input from form-data module
|
||
if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
|
||
body.hasKnownLength && body.hasKnownLength()) {
|
||
// 2.x
|
||
return body.getLengthSync();
|
||
}
|
||
return null;
|
||
} else {
|
||
// body is stream
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Write a Body to a Node.js WritableStream (e.g. http.Request) object.
|
||
*
|
||
* @param Body instance Instance of Body
|
||
* @return Void
|
||
*/
|
||
function writeToStream(dest, instance) {
|
||
const body = instance.body;
|
||
|
||
|
||
if (body === null) {
|
||
// body is null
|
||
dest.end();
|
||
} else if (isBlob(body)) {
|
||
body.stream().pipe(dest);
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
dest.write(body);
|
||
dest.end();
|
||
} else {
|
||
// body is stream
|
||
body.pipe(dest);
|
||
}
|
||
}
|
||
|
||
// expose Promise
|
||
Body.Promise = global.Promise;
|
||
|
||
/**
|
||
* headers.js
|
||
*
|
||
* Headers class offers convenient helpers
|
||
*/
|
||
|
||
const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
|
||
const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
|
||
|
||
function validateName(name) {
|
||
name = `${name}`;
|
||
if (invalidTokenRegex.test(name) || name === '') {
|
||
throw new TypeError(`${name} is not a legal HTTP header name`);
|
||
}
|
||
}
|
||
|
||
function validateValue(value) {
|
||
value = `${value}`;
|
||
if (invalidHeaderCharRegex.test(value)) {
|
||
throw new TypeError(`${value} is not a legal HTTP header value`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Find the key in the map object given a header name.
|
||
*
|
||
* Returns undefined if not found.
|
||
*
|
||
* @param String name Header name
|
||
* @return String|Undefined
|
||
*/
|
||
function find(map, name) {
|
||
name = name.toLowerCase();
|
||
for (const key in map) {
|
||
if (key.toLowerCase() === name) {
|
||
return key;
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
const MAP = Symbol('map');
|
||
class Headers {
|
||
/**
|
||
* Headers class
|
||
*
|
||
* @param Object headers Response headers
|
||
* @return Void
|
||
*/
|
||
constructor() {
|
||
let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
|
||
|
||
this[MAP] = Object.create(null);
|
||
|
||
if (init instanceof Headers) {
|
||
const rawHeaders = init.raw();
|
||
const headerNames = Object.keys(rawHeaders);
|
||
|
||
for (const headerName of headerNames) {
|
||
for (const value of rawHeaders[headerName]) {
|
||
this.append(headerName, value);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
// We don't worry about converting prop to ByteString here as append()
|
||
// will handle it.
|
||
if (init == null) ; else if (typeof init === 'object') {
|
||
const method = init[Symbol.iterator];
|
||
if (method != null) {
|
||
if (typeof method !== 'function') {
|
||
throw new TypeError('Header pairs must be iterable');
|
||
}
|
||
|
||
// sequence<sequence<ByteString>>
|
||
// Note: per spec we have to first exhaust the lists then process them
|
||
const pairs = [];
|
||
for (const pair of init) {
|
||
if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
|
||
throw new TypeError('Each header pair must be iterable');
|
||
}
|
||
pairs.push(Array.from(pair));
|
||
}
|
||
|
||
for (const pair of pairs) {
|
||
if (pair.length !== 2) {
|
||
throw new TypeError('Each header pair must be a name/value tuple');
|
||
}
|
||
this.append(pair[0], pair[1]);
|
||
}
|
||
} else {
|
||
// record<ByteString, ByteString>
|
||
for (const key of Object.keys(init)) {
|
||
const value = init[key];
|
||
this.append(key, value);
|
||
}
|
||
}
|
||
} else {
|
||
throw new TypeError('Provided initializer must be an object');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Return combined header value given name
|
||
*
|
||
* @param String name Header name
|
||
* @return Mixed
|
||
*/
|
||
get(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
const key = find(this[MAP], name);
|
||
if (key === undefined) {
|
||
return null;
|
||
}
|
||
|
||
return this[MAP][key].join(', ');
|
||
}
|
||
|
||
/**
|
||
* Iterate over all headers
|
||
*
|
||
* @param Function callback Executed for each item with parameters (value, name, thisArg)
|
||
* @param Boolean thisArg `this` context for callback function
|
||
* @return Void
|
||
*/
|
||
forEach(callback) {
|
||
let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
|
||
|
||
let pairs = getHeaders(this);
|
||
let i = 0;
|
||
while (i < pairs.length) {
|
||
var _pairs$i = pairs[i];
|
||
const name = _pairs$i[0],
|
||
value = _pairs$i[1];
|
||
|
||
callback.call(thisArg, value, name, this);
|
||
pairs = getHeaders(this);
|
||
i++;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Overwrite header values given name
|
||
*
|
||
* @param String name Header name
|
||
* @param String value Header value
|
||
* @return Void
|
||
*/
|
||
set(name, value) {
|
||
name = `${name}`;
|
||
value = `${value}`;
|
||
validateName(name);
|
||
validateValue(value);
|
||
const key = find(this[MAP], name);
|
||
this[MAP][key !== undefined ? key : name] = [value];
|
||
}
|
||
|
||
/**
|
||
* Append a value onto existing header
|
||
*
|
||
* @param String name Header name
|
||
* @param String value Header value
|
||
* @return Void
|
||
*/
|
||
append(name, value) {
|
||
name = `${name}`;
|
||
value = `${value}`;
|
||
validateName(name);
|
||
validateValue(value);
|
||
const key = find(this[MAP], name);
|
||
if (key !== undefined) {
|
||
this[MAP][key].push(value);
|
||
} else {
|
||
this[MAP][name] = [value];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check for header name existence
|
||
*
|
||
* @param String name Header name
|
||
* @return Boolean
|
||
*/
|
||
has(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
return find(this[MAP], name) !== undefined;
|
||
}
|
||
|
||
/**
|
||
* Delete all header values given name
|
||
*
|
||
* @param String name Header name
|
||
* @return Void
|
||
*/
|
||
delete(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
const key = find(this[MAP], name);
|
||
if (key !== undefined) {
|
||
delete this[MAP][key];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Return raw headers (non-spec api)
|
||
*
|
||
* @return Object
|
||
*/
|
||
raw() {
|
||
return this[MAP];
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on keys.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
keys() {
|
||
return createHeadersIterator(this, 'key');
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on values.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
values() {
|
||
return createHeadersIterator(this, 'value');
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on entries.
|
||
*
|
||
* This is the default iterator of the Headers object.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
[Symbol.iterator]() {
|
||
return createHeadersIterator(this, 'key+value');
|
||
}
|
||
}
|
||
Headers.prototype.entries = Headers.prototype[Symbol.iterator];
|
||
|
||
Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
|
||
value: 'Headers',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
Object.defineProperties(Headers.prototype, {
|
||
get: { enumerable: true },
|
||
forEach: { enumerable: true },
|
||
set: { enumerable: true },
|
||
append: { enumerable: true },
|
||
has: { enumerable: true },
|
||
delete: { enumerable: true },
|
||
keys: { enumerable: true },
|
||
values: { enumerable: true },
|
||
entries: { enumerable: true }
|
||
});
|
||
|
||
function getHeaders(headers) {
|
||
let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
|
||
|
||
const keys = Object.keys(headers[MAP]).sort();
|
||
return keys.map(kind === 'key' ? function (k) {
|
||
return k.toLowerCase();
|
||
} : kind === 'value' ? function (k) {
|
||
return headers[MAP][k].join(', ');
|
||
} : function (k) {
|
||
return [k.toLowerCase(), headers[MAP][k].join(', ')];
|
||
});
|
||
}
|
||
|
||
const INTERNAL = Symbol('internal');
|
||
|
||
function createHeadersIterator(target, kind) {
|
||
const iterator = Object.create(HeadersIteratorPrototype);
|
||
iterator[INTERNAL] = {
|
||
target,
|
||
kind,
|
||
index: 0
|
||
};
|
||
return iterator;
|
||
}
|
||
|
||
const HeadersIteratorPrototype = Object.setPrototypeOf({
|
||
next() {
|
||
// istanbul ignore if
|
||
if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
|
||
throw new TypeError('Value of `this` is not a HeadersIterator');
|
||
}
|
||
|
||
var _INTERNAL = this[INTERNAL];
|
||
const target = _INTERNAL.target,
|
||
kind = _INTERNAL.kind,
|
||
index = _INTERNAL.index;
|
||
|
||
const values = getHeaders(target, kind);
|
||
const len = values.length;
|
||
if (index >= len) {
|
||
return {
|
||
value: undefined,
|
||
done: true
|
||
};
|
||
}
|
||
|
||
this[INTERNAL].index = index + 1;
|
||
|
||
return {
|
||
value: values[index],
|
||
done: false
|
||
};
|
||
}
|
||
}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
|
||
|
||
Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
|
||
value: 'HeadersIterator',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
/**
|
||
* Export the Headers object in a form that Node.js can consume.
|
||
*
|
||
* @param Headers headers
|
||
* @return Object
|
||
*/
|
||
function exportNodeCompatibleHeaders(headers) {
|
||
const obj = Object.assign({ __proto__: null }, headers[MAP]);
|
||
|
||
// http.request() only supports string as Host header. This hack makes
|
||
// specifying custom Host header possible.
|
||
const hostHeaderKey = find(headers[MAP], 'Host');
|
||
if (hostHeaderKey !== undefined) {
|
||
obj[hostHeaderKey] = obj[hostHeaderKey][0];
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Create a Headers object from an object of headers, ignoring those that do
|
||
* not conform to HTTP grammar productions.
|
||
*
|
||
* @param Object obj Object of headers
|
||
* @return Headers
|
||
*/
|
||
function createHeadersLenient(obj) {
|
||
const headers = new Headers();
|
||
for (const name of Object.keys(obj)) {
|
||
if (invalidTokenRegex.test(name)) {
|
||
continue;
|
||
}
|
||
if (Array.isArray(obj[name])) {
|
||
for (const val of obj[name]) {
|
||
if (invalidHeaderCharRegex.test(val)) {
|
||
continue;
|
||
}
|
||
if (headers[MAP][name] === undefined) {
|
||
headers[MAP][name] = [val];
|
||
} else {
|
||
headers[MAP][name].push(val);
|
||
}
|
||
}
|
||
} else if (!invalidHeaderCharRegex.test(obj[name])) {
|
||
headers[MAP][name] = [obj[name]];
|
||
}
|
||
}
|
||
return headers;
|
||
}
|
||
|
||
const INTERNALS$1 = Symbol('Response internals');
|
||
|
||
// fix an issue where "STATUS_CODES" aren't a named export for node <10
|
||
const STATUS_CODES = http.STATUS_CODES;
|
||
|
||
/**
|
||
* Response class
|
||
*
|
||
* @param Stream body Readable stream
|
||
* @param Object opts Response options
|
||
* @return Void
|
||
*/
|
||
class Response {
|
||
constructor() {
|
||
let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
||
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
Body.call(this, body, opts);
|
||
|
||
const status = opts.status || 200;
|
||
const headers = new Headers(opts.headers);
|
||
|
||
if (body != null && !headers.has('Content-Type')) {
|
||
const contentType = extractContentType(body);
|
||
if (contentType) {
|
||
headers.append('Content-Type', contentType);
|
||
}
|
||
}
|
||
|
||
this[INTERNALS$1] = {
|
||
url: opts.url,
|
||
status,
|
||
statusText: opts.statusText || STATUS_CODES[status],
|
||
headers,
|
||
counter: opts.counter
|
||
};
|
||
}
|
||
|
||
get url() {
|
||
return this[INTERNALS$1].url || '';
|
||
}
|
||
|
||
get status() {
|
||
return this[INTERNALS$1].status;
|
||
}
|
||
|
||
/**
|
||
* Convenience property representing if the request ended normally
|
||
*/
|
||
get ok() {
|
||
return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
|
||
}
|
||
|
||
get redirected() {
|
||
return this[INTERNALS$1].counter > 0;
|
||
}
|
||
|
||
get statusText() {
|
||
return this[INTERNALS$1].statusText;
|
||
}
|
||
|
||
get headers() {
|
||
return this[INTERNALS$1].headers;
|
||
}
|
||
|
||
/**
|
||
* Clone this response
|
||
*
|
||
* @return Response
|
||
*/
|
||
clone() {
|
||
return new Response(clone(this), {
|
||
url: this.url,
|
||
status: this.status,
|
||
statusText: this.statusText,
|
||
headers: this.headers,
|
||
ok: this.ok,
|
||
redirected: this.redirected
|
||
});
|
||
}
|
||
}
|
||
|
||
Body.mixIn(Response.prototype);
|
||
|
||
Object.defineProperties(Response.prototype, {
|
||
url: { enumerable: true },
|
||
status: { enumerable: true },
|
||
ok: { enumerable: true },
|
||
redirected: { enumerable: true },
|
||
statusText: { enumerable: true },
|
||
headers: { enumerable: true },
|
||
clone: { enumerable: true }
|
||
});
|
||
|
||
Object.defineProperty(Response.prototype, Symbol.toStringTag, {
|
||
value: 'Response',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
const INTERNALS$2 = Symbol('Request internals');
|
||
|
||
// fix an issue where "format", "parse" aren't a named export for node <10
|
||
const parse_url = Url.parse;
|
||
const format_url = Url.format;
|
||
|
||
const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
|
||
|
||
/**
|
||
* Check if a value is an instance of Request.
|
||
*
|
||
* @param Mixed input
|
||
* @return Boolean
|
||
*/
|
||
function isRequest(input) {
|
||
return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
|
||
}
|
||
|
||
function isAbortSignal(signal) {
|
||
const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
|
||
return !!(proto && proto.constructor.name === 'AbortSignal');
|
||
}
|
||
|
||
/**
|
||
* Request class
|
||
*
|
||
* @param Mixed input Url or Request instance
|
||
* @param Object init Custom options
|
||
* @return Void
|
||
*/
|
||
class Request {
|
||
constructor(input) {
|
||
let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
let parsedURL;
|
||
|
||
// normalize input
|
||
if (!isRequest(input)) {
|
||
if (input && input.href) {
|
||
// in order to support Node.js' Url objects; though WHATWG's URL objects
|
||
// will fall into this branch also (since their `toString()` will return
|
||
// `href` property anyway)
|
||
parsedURL = parse_url(input.href);
|
||
} else {
|
||
// coerce input to a string before attempting to parse
|
||
parsedURL = parse_url(`${input}`);
|
||
}
|
||
input = {};
|
||
} else {
|
||
parsedURL = parse_url(input.url);
|
||
}
|
||
|
||
let method = init.method || input.method || 'GET';
|
||
method = method.toUpperCase();
|
||
|
||
if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
|
||
throw new TypeError('Request with GET/HEAD method cannot have body');
|
||
}
|
||
|
||
let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
|
||
|
||
Body.call(this, inputBody, {
|
||
timeout: init.timeout || input.timeout || 0,
|
||
size: init.size || input.size || 0
|
||
});
|
||
|
||
const headers = new Headers(init.headers || input.headers || {});
|
||
|
||
if (inputBody != null && !headers.has('Content-Type')) {
|
||
const contentType = extractContentType(inputBody);
|
||
if (contentType) {
|
||
headers.append('Content-Type', contentType);
|
||
}
|
||
}
|
||
|
||
let signal = isRequest(input) ? input.signal : null;
|
||
if ('signal' in init) signal = init.signal;
|
||
|
||
if (signal != null && !isAbortSignal(signal)) {
|
||
throw new TypeError('Expected signal to be an instanceof AbortSignal');
|
||
}
|
||
|
||
this[INTERNALS$2] = {
|
||
method,
|
||
redirect: init.redirect || input.redirect || 'follow',
|
||
headers,
|
||
parsedURL,
|
||
signal
|
||
};
|
||
|
||
// node-fetch-only options
|
||
this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
|
||
this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
|
||
this.counter = init.counter || input.counter || 0;
|
||
this.agent = init.agent || input.agent;
|
||
}
|
||
|
||
get method() {
|
||
return this[INTERNALS$2].method;
|
||
}
|
||
|
||
get url() {
|
||
return format_url(this[INTERNALS$2].parsedURL);
|
||
}
|
||
|
||
get headers() {
|
||
return this[INTERNALS$2].headers;
|
||
}
|
||
|
||
get redirect() {
|
||
return this[INTERNALS$2].redirect;
|
||
}
|
||
|
||
get signal() {
|
||
return this[INTERNALS$2].signal;
|
||
}
|
||
|
||
/**
|
||
* Clone this request
|
||
*
|
||
* @return Request
|
||
*/
|
||
clone() {
|
||
return new Request(this);
|
||
}
|
||
}
|
||
|
||
Body.mixIn(Request.prototype);
|
||
|
||
Object.defineProperty(Request.prototype, Symbol.toStringTag, {
|
||
value: 'Request',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
Object.defineProperties(Request.prototype, {
|
||
method: { enumerable: true },
|
||
url: { enumerable: true },
|
||
headers: { enumerable: true },
|
||
redirect: { enumerable: true },
|
||
clone: { enumerable: true },
|
||
signal: { enumerable: true }
|
||
});
|
||
|
||
/**
|
||
* Convert a Request to Node.js http request options.
|
||
*
|
||
* @param Request A Request instance
|
||
* @return Object The options object to be passed to http.request
|
||
*/
|
||
function getNodeRequestOptions(request) {
|
||
const parsedURL = request[INTERNALS$2].parsedURL;
|
||
const headers = new Headers(request[INTERNALS$2].headers);
|
||
|
||
// fetch step 1.3
|
||
if (!headers.has('Accept')) {
|
||
headers.set('Accept', '*/*');
|
||
}
|
||
|
||
// Basic fetch
|
||
if (!parsedURL.protocol || !parsedURL.hostname) {
|
||
throw new TypeError('Only absolute URLs are supported');
|
||
}
|
||
|
||
if (!/^https?:$/.test(parsedURL.protocol)) {
|
||
throw new TypeError('Only HTTP(S) protocols are supported');
|
||
}
|
||
|
||
if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
|
||
throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch steps 2.4-2.7
|
||
let contentLengthValue = null;
|
||
if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
|
||
contentLengthValue = '0';
|
||
}
|
||
if (request.body != null) {
|
||
const totalBytes = getTotalBytes(request);
|
||
if (typeof totalBytes === 'number') {
|
||
contentLengthValue = String(totalBytes);
|
||
}
|
||
}
|
||
if (contentLengthValue) {
|
||
headers.set('Content-Length', contentLengthValue);
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch step 2.11
|
||
if (!headers.has('User-Agent')) {
|
||
headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch step 2.15
|
||
if (request.compress && !headers.has('Accept-Encoding')) {
|
||
headers.set('Accept-Encoding', 'gzip,deflate');
|
||
}
|
||
|
||
let agent = request.agent;
|
||
if (typeof agent === 'function') {
|
||
agent = agent(parsedURL);
|
||
}
|
||
|
||
if (!headers.has('Connection') && !agent) {
|
||
headers.set('Connection', 'close');
|
||
}
|
||
|
||
// HTTP-network fetch step 4.2
|
||
// chunked encoding is handled by Node.js
|
||
|
||
return Object.assign({}, parsedURL, {
|
||
method: request.method,
|
||
headers: exportNodeCompatibleHeaders(headers),
|
||
agent
|
||
});
|
||
}
|
||
|
||
/**
|
||
* abort-error.js
|
||
*
|
||
* AbortError interface for cancelled requests
|
||
*/
|
||
|
||
/**
|
||
* Create AbortError instance
|
||
*
|
||
* @param String message Error message for human
|
||
* @return AbortError
|
||
*/
|
||
function AbortError(message) {
|
||
Error.call(this, message);
|
||
|
||
this.type = 'aborted';
|
||
this.message = message;
|
||
|
||
// hide custom error implementation details from end-users
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
AbortError.prototype = Object.create(Error.prototype);
|
||
AbortError.prototype.constructor = AbortError;
|
||
AbortError.prototype.name = 'AbortError';
|
||
|
||
// fix an issue where "PassThrough", "resolve" aren't a named export for node <10
|
||
const PassThrough$1 = Stream.PassThrough;
|
||
const resolve_url = Url.resolve;
|
||
|
||
/**
|
||
* Fetch function
|
||
*
|
||
* @param Mixed url Absolute url or Request instance
|
||
* @param Object opts Fetch options
|
||
* @return Promise
|
||
*/
|
||
function fetch(url, opts) {
|
||
|
||
// allow custom promise
|
||
if (!fetch.Promise) {
|
||
throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
|
||
}
|
||
|
||
Body.Promise = fetch.Promise;
|
||
|
||
// wrap http.request into fetch
|
||
return new fetch.Promise(function (resolve, reject) {
|
||
// build request object
|
||
const request = new Request(url, opts);
|
||
const options = getNodeRequestOptions(request);
|
||
|
||
const send = (options.protocol === 'https:' ? https : http).request;
|
||
const signal = request.signal;
|
||
|
||
let response = null;
|
||
|
||
const abort = function abort() {
|
||
let error = new AbortError('The user aborted a request.');
|
||
reject(error);
|
||
if (request.body && request.body instanceof Stream.Readable) {
|
||
request.body.destroy(error);
|
||
}
|
||
if (!response || !response.body) return;
|
||
response.body.emit('error', error);
|
||
};
|
||
|
||
if (signal && signal.aborted) {
|
||
abort();
|
||
return;
|
||
}
|
||
|
||
const abortAndFinalize = function abortAndFinalize() {
|
||
abort();
|
||
finalize();
|
||
};
|
||
|
||
// send request
|
||
const req = send(options);
|
||
let reqTimeout;
|
||
|
||
if (signal) {
|
||
signal.addEventListener('abort', abortAndFinalize);
|
||
}
|
||
|
||
function finalize() {
|
||
req.abort();
|
||
if (signal) signal.removeEventListener('abort', abortAndFinalize);
|
||
clearTimeout(reqTimeout);
|
||
}
|
||
|
||
if (request.timeout) {
|
||
req.once('socket', function (socket) {
|
||
reqTimeout = setTimeout(function () {
|
||
reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
|
||
finalize();
|
||
}, request.timeout);
|
||
});
|
||
}
|
||
|
||
req.on('error', function (err) {
|
||
reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
|
||
finalize();
|
||
});
|
||
|
||
req.on('response', function (res) {
|
||
clearTimeout(reqTimeout);
|
||
|
||
const headers = createHeadersLenient(res.headers);
|
||
|
||
// HTTP fetch step 5
|
||
if (fetch.isRedirect(res.statusCode)) {
|
||
// HTTP fetch step 5.2
|
||
const location = headers.get('Location');
|
||
|
||
// HTTP fetch step 5.3
|
||
const locationURL = location === null ? null : resolve_url(request.url, location);
|
||
|
||
// HTTP fetch step 5.5
|
||
switch (request.redirect) {
|
||
case 'error':
|
||
reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
|
||
finalize();
|
||
return;
|
||
case 'manual':
|
||
// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
|
||
if (locationURL !== null) {
|
||
// handle corrupted header
|
||
try {
|
||
headers.set('Location', locationURL);
|
||
} catch (err) {
|
||
// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
|
||
reject(err);
|
||
}
|
||
}
|
||
break;
|
||
case 'follow':
|
||
// HTTP-redirect fetch step 2
|
||
if (locationURL === null) {
|
||
break;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 5
|
||
if (request.counter >= request.follow) {
|
||
reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
|
||
finalize();
|
||
return;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 6 (counter increment)
|
||
// Create a new Request object.
|
||
const requestOpts = {
|
||
headers: new Headers(request.headers),
|
||
follow: request.follow,
|
||
counter: request.counter + 1,
|
||
agent: request.agent,
|
||
compress: request.compress,
|
||
method: request.method,
|
||
body: request.body,
|
||
signal: request.signal,
|
||
timeout: request.timeout,
|
||
size: request.size
|
||
};
|
||
|
||
// HTTP-redirect fetch step 9
|
||
if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
|
||
reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
|
||
finalize();
|
||
return;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 11
|
||
if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
|
||
requestOpts.method = 'GET';
|
||
requestOpts.body = undefined;
|
||
requestOpts.headers.delete('content-length');
|
||
}
|
||
|
||
// HTTP-redirect fetch step 15
|
||
resolve(fetch(new Request(locationURL, requestOpts)));
|
||
finalize();
|
||
return;
|
||
}
|
||
}
|
||
|
||
// prepare response
|
||
res.once('end', function () {
|
||
if (signal) signal.removeEventListener('abort', abortAndFinalize);
|
||
});
|
||
let body = res.pipe(new PassThrough$1());
|
||
|
||
const response_options = {
|
||
url: request.url,
|
||
status: res.statusCode,
|
||
statusText: res.statusMessage,
|
||
headers: headers,
|
||
size: request.size,
|
||
timeout: request.timeout,
|
||
counter: request.counter
|
||
};
|
||
|
||
// HTTP-network fetch step 12.1.1.3
|
||
const codings = headers.get('Content-Encoding');
|
||
|
||
// HTTP-network fetch step 12.1.1.4: handle content codings
|
||
|
||
// in following scenarios we ignore compression support
|
||
// 1. compression support is disabled
|
||
// 2. HEAD request
|
||
// 3. no Content-Encoding header
|
||
// 4. no content response (204)
|
||
// 5. content not modified response (304)
|
||
if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// For Node v6+
|
||
// Be less strict when decoding compressed responses, since sometimes
|
||
// servers send slightly invalid responses that are still accepted
|
||
// by common browsers.
|
||
// Always using Z_SYNC_FLUSH is what cURL does.
|
||
const zlibOptions = {
|
||
flush: zlib.Z_SYNC_FLUSH,
|
||
finishFlush: zlib.Z_SYNC_FLUSH
|
||
};
|
||
|
||
// for gzip
|
||
if (codings == 'gzip' || codings == 'x-gzip') {
|
||
body = body.pipe(zlib.createGunzip(zlibOptions));
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// for deflate
|
||
if (codings == 'deflate' || codings == 'x-deflate') {
|
||
// handle the infamous raw deflate response from old servers
|
||
// a hack for old IIS and Apache servers
|
||
const raw = res.pipe(new PassThrough$1());
|
||
raw.once('data', function (chunk) {
|
||
// see http://stackoverflow.com/questions/37519828
|
||
if ((chunk[0] & 0x0F) === 0x08) {
|
||
body = body.pipe(zlib.createInflate());
|
||
} else {
|
||
body = body.pipe(zlib.createInflateRaw());
|
||
}
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
});
|
||
return;
|
||
}
|
||
|
||
// for br
|
||
if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
|
||
body = body.pipe(zlib.createBrotliDecompress());
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// otherwise, use response as-is
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
});
|
||
|
||
writeToStream(req, request);
|
||
});
|
||
}
|
||
/**
|
||
* Redirect code matching
|
||
*
|
||
* @param Number code Status code
|
||
* @return Boolean
|
||
*/
|
||
fetch.isRedirect = function (code) {
|
||
return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
|
||
};
|
||
|
||
// expose Promise
|
||
fetch.Promise = global.Promise;
|
||
|
||
module.exports = exports = fetch;
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
exports.default = exports;
|
||
exports.Headers = Headers;
|
||
exports.Request = Request;
|
||
exports.Response = Response;
|
||
exports.FetchError = FetchError;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1223:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
var wrappy = __webpack_require__(2940)
|
||
module.exports = wrappy(once)
|
||
module.exports.strict = wrappy(onceStrict)
|
||
|
||
once.proto = once(function () {
|
||
Object.defineProperty(Function.prototype, 'once', {
|
||
value: function () {
|
||
return once(this)
|
||
},
|
||
configurable: true
|
||
})
|
||
|
||
Object.defineProperty(Function.prototype, 'onceStrict', {
|
||
value: function () {
|
||
return onceStrict(this)
|
||
},
|
||
configurable: true
|
||
})
|
||
})
|
||
|
||
function once (fn) {
|
||
var f = function () {
|
||
if (f.called) return f.value
|
||
f.called = true
|
||
return f.value = fn.apply(this, arguments)
|
||
}
|
||
f.called = false
|
||
return f
|
||
}
|
||
|
||
function onceStrict (fn) {
|
||
var f = function () {
|
||
if (f.called)
|
||
throw new Error(f.onceError)
|
||
f.called = true
|
||
return f.value = fn.apply(this, arguments)
|
||
}
|
||
var name = fn.name || 'Function wrapped with `once`'
|
||
f.onceError = name + " shouldn't be called more than once"
|
||
f.called = false
|
||
return f
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4294:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
module.exports = __webpack_require__(4219);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4219:
|
||
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
var net = __webpack_require__(1631);
|
||
var tls = __webpack_require__(4016);
|
||
var http = __webpack_require__(8605);
|
||
var https = __webpack_require__(7211);
|
||
var events = __webpack_require__(8614);
|
||
var assert = __webpack_require__(2357);
|
||
var util = __webpack_require__(1669);
|
||
|
||
|
||
exports.httpOverHttp = httpOverHttp;
|
||
exports.httpsOverHttp = httpsOverHttp;
|
||
exports.httpOverHttps = httpOverHttps;
|
||
exports.httpsOverHttps = httpsOverHttps;
|
||
|
||
|
||
function httpOverHttp(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = http.request;
|
||
return agent;
|
||
}
|
||
|
||
function httpsOverHttp(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = http.request;
|
||
agent.createSocket = createSecureSocket;
|
||
agent.defaultPort = 443;
|
||
return agent;
|
||
}
|
||
|
||
function httpOverHttps(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = https.request;
|
||
return agent;
|
||
}
|
||
|
||
function httpsOverHttps(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = https.request;
|
||
agent.createSocket = createSecureSocket;
|
||
agent.defaultPort = 443;
|
||
return agent;
|
||
}
|
||
|
||
|
||
function TunnelingAgent(options) {
|
||
var self = this;
|
||
self.options = options || {};
|
||
self.proxyOptions = self.options.proxy || {};
|
||
self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
|
||
self.requests = [];
|
||
self.sockets = [];
|
||
|
||
self.on('free', function onFree(socket, host, port, localAddress) {
|
||
var options = toOptions(host, port, localAddress);
|
||
for (var i = 0, len = self.requests.length; i < len; ++i) {
|
||
var pending = self.requests[i];
|
||
if (pending.host === options.host && pending.port === options.port) {
|
||
// Detect the request to connect same origin server,
|
||
// reuse the connection.
|
||
self.requests.splice(i, 1);
|
||
pending.request.onSocket(socket);
|
||
return;
|
||
}
|
||
}
|
||
socket.destroy();
|
||
self.removeSocket(socket);
|
||
});
|
||
}
|
||
util.inherits(TunnelingAgent, events.EventEmitter);
|
||
|
||
TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
|
||
var self = this;
|
||
var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
|
||
|
||
if (self.sockets.length >= this.maxSockets) {
|
||
// We are over limit so we'll add it to the queue.
|
||
self.requests.push(options);
|
||
return;
|
||
}
|
||
|
||
// If we are under maxSockets create a new one.
|
||
self.createSocket(options, function(socket) {
|
||
socket.on('free', onFree);
|
||
socket.on('close', onCloseOrRemove);
|
||
socket.on('agentRemove', onCloseOrRemove);
|
||
req.onSocket(socket);
|
||
|
||
function onFree() {
|
||
self.emit('free', socket, options);
|
||
}
|
||
|
||
function onCloseOrRemove(err) {
|
||
self.removeSocket(socket);
|
||
socket.removeListener('free', onFree);
|
||
socket.removeListener('close', onCloseOrRemove);
|
||
socket.removeListener('agentRemove', onCloseOrRemove);
|
||
}
|
||
});
|
||
};
|
||
|
||
TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
|
||
var self = this;
|
||
var placeholder = {};
|
||
self.sockets.push(placeholder);
|
||
|
||
var connectOptions = mergeOptions({}, self.proxyOptions, {
|
||
method: 'CONNECT',
|
||
path: options.host + ':' + options.port,
|
||
agent: false,
|
||
headers: {
|
||
host: options.host + ':' + options.port
|
||
}
|
||
});
|
||
if (options.localAddress) {
|
||
connectOptions.localAddress = options.localAddress;
|
||
}
|
||
if (connectOptions.proxyAuth) {
|
||
connectOptions.headers = connectOptions.headers || {};
|
||
connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
|
||
new Buffer(connectOptions.proxyAuth).toString('base64');
|
||
}
|
||
|
||
debug('making CONNECT request');
|
||
var connectReq = self.request(connectOptions);
|
||
connectReq.useChunkedEncodingByDefault = false; // for v0.6
|
||
connectReq.once('response', onResponse); // for v0.6
|
||
connectReq.once('upgrade', onUpgrade); // for v0.6
|
||
connectReq.once('connect', onConnect); // for v0.7 or later
|
||
connectReq.once('error', onError);
|
||
connectReq.end();
|
||
|
||
function onResponse(res) {
|
||
// Very hacky. This is necessary to avoid http-parser leaks.
|
||
res.upgrade = true;
|
||
}
|
||
|
||
function onUpgrade(res, socket, head) {
|
||
// Hacky.
|
||
process.nextTick(function() {
|
||
onConnect(res, socket, head);
|
||
});
|
||
}
|
||
|
||
function onConnect(res, socket, head) {
|
||
connectReq.removeAllListeners();
|
||
socket.removeAllListeners();
|
||
|
||
if (res.statusCode !== 200) {
|
||
debug('tunneling socket could not be established, statusCode=%d',
|
||
res.statusCode);
|
||
socket.destroy();
|
||
var error = new Error('tunneling socket could not be established, ' +
|
||
'statusCode=' + res.statusCode);
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
return;
|
||
}
|
||
if (head.length > 0) {
|
||
debug('got illegal response body from proxy');
|
||
socket.destroy();
|
||
var error = new Error('got illegal response body from proxy');
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
return;
|
||
}
|
||
debug('tunneling connection has established');
|
||
self.sockets[self.sockets.indexOf(placeholder)] = socket;
|
||
return cb(socket);
|
||
}
|
||
|
||
function onError(cause) {
|
||
connectReq.removeAllListeners();
|
||
|
||
debug('tunneling socket could not be established, cause=%s\n',
|
||
cause.message, cause.stack);
|
||
var error = new Error('tunneling socket could not be established, ' +
|
||
'cause=' + cause.message);
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
}
|
||
};
|
||
|
||
TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
|
||
var pos = this.sockets.indexOf(socket)
|
||
if (pos === -1) {
|
||
return;
|
||
}
|
||
this.sockets.splice(pos, 1);
|
||
|
||
var pending = this.requests.shift();
|
||
if (pending) {
|
||
// If we have pending requests and a socket gets closed a new one
|
||
// needs to be created to take over in the pool for the one that closed.
|
||
this.createSocket(pending, function(socket) {
|
||
pending.request.onSocket(socket);
|
||
});
|
||
}
|
||
};
|
||
|
||
function createSecureSocket(options, cb) {
|
||
var self = this;
|
||
TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
|
||
var hostHeader = options.request.getHeader('host');
|
||
var tlsOptions = mergeOptions({}, self.options, {
|
||
socket: socket,
|
||
servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
|
||
});
|
||
|
||
// 0 is dummy port for v0.6
|
||
var secureSocket = tls.connect(0, tlsOptions);
|
||
self.sockets[self.sockets.indexOf(socket)] = secureSocket;
|
||
cb(secureSocket);
|
||
});
|
||
}
|
||
|
||
|
||
function toOptions(host, port, localAddress) {
|
||
if (typeof host === 'string') { // since v0.10
|
||
return {
|
||
host: host,
|
||
port: port,
|
||
localAddress: localAddress
|
||
};
|
||
}
|
||
return host; // for v0.11 or later
|
||
}
|
||
|
||
function mergeOptions(target) {
|
||
for (var i = 1, len = arguments.length; i < len; ++i) {
|
||
var overrides = arguments[i];
|
||
if (typeof overrides === 'object') {
|
||
var keys = Object.keys(overrides);
|
||
for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
|
||
var k = keys[j];
|
||
if (overrides[k] !== undefined) {
|
||
target[k] = overrides[k];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
|
||
|
||
var debug;
|
||
if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
|
||
debug = function() {
|
||
var args = Array.prototype.slice.call(arguments);
|
||
if (typeof args[0] === 'string') {
|
||
args[0] = 'TUNNEL: ' + args[0];
|
||
} else {
|
||
args.unshift('TUNNEL:');
|
||
}
|
||
console.error.apply(console, args);
|
||
}
|
||
} else {
|
||
debug = function() {};
|
||
}
|
||
exports.debug = debug; // for test
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5030:
|
||
/***/ ((__unused_webpack_module, exports) => {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
||
|
||
function getUserAgent() {
|
||
if (typeof navigator === "object" && "userAgent" in navigator) {
|
||
return navigator.userAgent;
|
||
}
|
||
|
||
if (typeof process === "object" && "version" in process) {
|
||
return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
|
||
}
|
||
|
||
return "<environment undetectable>";
|
||
}
|
||
|
||
exports.getUserAgent = getUserAgent;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2940:
|
||
/***/ ((module) => {
|
||
|
||
// Returns a wrapper function that returns a wrapped callback
|
||
// The wrapper function should do some stuff, and return a
|
||
// presumably different callback function.
|
||
// This makes sure that own properties are retained, so that
|
||
// decorations and such are not lost along the way.
|
||
module.exports = wrappy
|
||
function wrappy (fn, cb) {
|
||
if (fn && cb) return wrappy(fn)(cb)
|
||
|
||
if (typeof fn !== 'function')
|
||
throw new TypeError('need wrapper function')
|
||
|
||
Object.keys(fn).forEach(function (k) {
|
||
wrapper[k] = fn[k]
|
||
})
|
||
|
||
return wrapper
|
||
|
||
function wrapper() {
|
||
var args = new Array(arguments.length)
|
||
for (var i = 0; i < args.length; i++) {
|
||
args[i] = arguments[i]
|
||
}
|
||
var ret = fn.apply(this, args)
|
||
var cb = args[args.length-1]
|
||
if (typeof ret === 'function' && ret !== cb) {
|
||
Object.keys(cb).forEach(function (k) {
|
||
ret[k] = cb[k]
|
||
})
|
||
}
|
||
return ret
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9319:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
__webpack_require__(2437).config();
|
||
const core = __webpack_require__(2186);
|
||
const { Octokit } = __webpack_require__(5375);
|
||
|
||
const {
|
||
doAddLabels,
|
||
doCreateComment,
|
||
doCloseIssue,
|
||
doLockIssue,
|
||
doCreateIssue,
|
||
} = __webpack_require__(9932);
|
||
|
||
const { doQueryIssues, getIssuesInMonth, getCreatedMonth } = __webpack_require__(197);
|
||
|
||
const { dealStringToArr, matchKeyword, getPreMonth } = __webpack_require__(6254);
|
||
|
||
// **************************************************************************
|
||
var dayjs = __webpack_require__(7401);
|
||
var utc = __webpack_require__(4359);
|
||
dayjs.extend(utc);
|
||
|
||
// **************************************************************************
|
||
const token = core.getInput('token');
|
||
const octokit = new Octokit({ auth: `token ${token}` });
|
||
|
||
let direction = core.getInput('direction');
|
||
direction = direction === 'desc' ? 'desc' : 'asc';
|
||
const commentAuth = core.getInput('comment-auth');
|
||
const bodyIncludes = core.getInput('body-includes');
|
||
const titleIncludes = core.getInput('title-includes');
|
||
const assigneeIncludes = core.getInput('assignee-includes');
|
||
|
||
let issueState = core.getInput('issue-state') || 'open';
|
||
if (issueState != 'all' && issueState != 'closed') {
|
||
issueState = 'open';
|
||
}
|
||
|
||
const inactiveLabel = core.getInput('inactive-label') || 'inactive';
|
||
|
||
// **************************************************************************
|
||
async function doCheckInactive(owner, repo, labels) {
|
||
const issues = await doQueryIssues(owner, repo, labels, issueState);
|
||
|
||
if (issues.length) {
|
||
for (let i = 0; i < issues.length; i++) {
|
||
let arr = [];
|
||
issues[i].labels.forEach(it => {
|
||
arr.push(it.name);
|
||
});
|
||
if (!arr.includes(inactiveLabel)) {
|
||
await doAddLabels(owner, repo, issues[i].number, inactiveLabel);
|
||
if (core.getInput('body')) {
|
||
await doCreateComment(owner, repo, issues[i].number, core.getInput('body'));
|
||
}
|
||
} else {
|
||
core.info(`Actions: [add-inactive] issue ${issues[i].number} has label!`);
|
||
}
|
||
}
|
||
} else {
|
||
core.info(`Actions: [query-issues] empty!`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查 issue 是否满足条件，满足返回 true
|
||
* 当前 issue 的指定人是否有一个满足 assigneeIncludes 里的某个
|
||
* 关键字匹配，是否包含前一个某个+后一个某个 '官网,网站/挂了,无法访问'
|
||
*/
|
||
async function doCheckIssue(owner, repo, issueNumber) {
|
||
var checkResult = true;
|
||
const issue = await octokit.issues.get({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
|
||
if (!!checkResult && assigneeIncludes) {
|
||
let assigneesCheck = dealStringToArr(assigneeIncludes);
|
||
let checkAssignee = false;
|
||
issue.data.assignees.forEach(it => {
|
||
if (checkResult && !checkAssignee && assigneesCheck.includes(it.login)) {
|
||
checkResult = true;
|
||
checkAssignee = true;
|
||
}
|
||
});
|
||
!checkAssignee ? (checkResult = false) : null;
|
||
}
|
||
|
||
if (!!checkResult && titleIncludes) {
|
||
const titleArr = titleIncludes.split('/');
|
||
const keyword1 = dealStringToArr(titleArr[0]);
|
||
const keyword2 = dealStringToArr(titleArr[1]);
|
||
checkResult = keyword2.length
|
||
? matchKeyword(issue.data.title, keyword1) && matchKeyword(issue.data.title, keyword2)
|
||
: matchKeyword(issue.data.title, keyword1);
|
||
}
|
||
|
||
if (!!checkResult && bodyIncludes) {
|
||
const bodyArr = bodyIncludes.split('/');
|
||
const keyword1 = dealStringToArr(bodyArr[0]);
|
||
const keyword2 = dealStringToArr(bodyArr[1]);
|
||
checkResult = keyword2.length
|
||
? matchKeyword(issue.data.body, keyword1) && matchKeyword(issue.data.body, keyword2)
|
||
: matchKeyword(issue.data.body, keyword1);
|
||
}
|
||
core.info(`Actions: [check-issue][${!!checkResult}] success!`);
|
||
core.setOutput('check-result', !!checkResult);
|
||
}
|
||
|
||
async function doCloseIssues(owner, repo, labels) {
|
||
const issues = await doQueryIssues(owner, repo, labels, 'open');
|
||
|
||
if (issues.length) {
|
||
for (let i = 0; i < issues.length; i++) {
|
||
await doCloseIssue(owner, repo, issues[i].number);
|
||
if (core.getInput('body')) {
|
||
await doCreateComment(owner, repo, issues[i].number, core.getInput('body'));
|
||
}
|
||
}
|
||
} else {
|
||
core.info(`Actions: [query-issues] empty!`);
|
||
}
|
||
}
|
||
|
||
async function doFindComments(owner, repo, issueNumber) {
|
||
const res = await octokit.issues.listComments({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
core.info(`Actions: [find-comments][${issueNumber}] success!`);
|
||
let comments = [];
|
||
res.data.forEach(item => {
|
||
const a = commentAuth ? item.user.login === commentAuth : true;
|
||
const b = bodyIncludes ? item.body.includes(bodyIncludes) : true;
|
||
if (a && b) {
|
||
comments.push({
|
||
id: item.id,
|
||
auth: item.user.login,
|
||
body: item.body,
|
||
created: item.created_at,
|
||
updated: item.updated_at,
|
||
});
|
||
if (direction === 'desc') {
|
||
comments.reverse();
|
||
}
|
||
}
|
||
});
|
||
core.setOutput('comments', comments);
|
||
}
|
||
|
||
async function doLockIssues(owner, repo, labels) {
|
||
const issues = await doQueryIssues(owner, repo, labels, issueState);
|
||
|
||
if (issues.length) {
|
||
for (let i = 0; i < issues.length; i++) {
|
||
await doLockIssue(owner, repo, issues[i].number);
|
||
if (core.getInput('body')) {
|
||
await doCreateComment(owner, repo, issues[i].number, core.getInput('body'));
|
||
}
|
||
}
|
||
} else {
|
||
core.info(`Actions: [query-issues] empty!`);
|
||
}
|
||
}
|
||
|
||
async function doMonthStatistics(owner, repo, labels, assignees) {
|
||
const countLables = core.getInput('count-lables');
|
||
const countComments = core.getInput('count-comments');
|
||
|
||
const thisMonth = dayjs.utc().month() + 1;
|
||
const year = thisMonth == 1 ? dayjs.utc().year() - 1 : dayjs.utc().year();
|
||
|
||
const month = getPreMonth(thisMonth);
|
||
const showMonth = month < 10 ? `0${month}` : month;
|
||
|
||
let issues = await getIssuesInMonth(owner, repo, thisMonth);
|
||
if (issues.length == 0) {
|
||
core.info(`Actions: [query-issues-${month}] empty!`);
|
||
return false;
|
||
}
|
||
issues = issues.filter(i => {
|
||
return getCreatedMonth(i.created_at) == month;
|
||
});
|
||
let total = issues.length;
|
||
let totalIssues = [...issues];
|
||
let openTotal = 0;
|
||
let openIssuesNumber = [];
|
||
let closeTotal = 0;
|
||
let closeIssuesNumber = [];
|
||
let labelsTotals = [];
|
||
const title = `[${owner}/${repo}] Month Statistics: ${year}-${showMonth}`;
|
||
for (let i = 0; i < issues.length; i++) {
|
||
if (issues[i].state == 'closed') {
|
||
closeTotal += 1;
|
||
closeIssuesNumber.push(issues[i].number);
|
||
} else if (issues[i].state == 'open') {
|
||
openTotal += 1;
|
||
openIssuesNumber.push(issues[i].number);
|
||
}
|
||
if (countLables && issues[i].labels) {
|
||
issues[i].labels.forEach(l => {
|
||
if (l.name in labelsTotals) {
|
||
labelsTotals[l.name] += 1;
|
||
} else {
|
||
labelsTotals[l.name] = 1;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
let now = dayjs()
|
||
.utc()
|
||
.format('YYYY-MM-DD HH:mm:ss');
|
||
let body = `
|
||
- Created time: ${now}
|
||
|
||
- Time base: UTC +0
|
||
`;
|
||
let totalShow = `
|
||
### Count
|
||
|
||
| Total | Open | Closed |
|
||
| -- | -- | -- |
|
||
| ${total} | ${openTotal} | ${closeTotal} |
|
||
|
||
`;
|
||
|
||
body += totalShow;
|
||
|
||
if (countLables == 'true') {
|
||
let labelsArr = [];
|
||
for (var lab in labelsTotals) {
|
||
labelsArr.push({
|
||
labelName: lab,
|
||
number: labelsTotals[lab],
|
||
});
|
||
}
|
||
labelsArr.sort((a, b) => b.number - a.number);
|
||
let labelsTitle = `
|
||
### Labels statistics
|
||
|
||
<table>
|
||
<tr>
|
||
<th>Name</th>
|
||
<th>Number</th>
|
||
</tr>`;
|
||
let labelsBody = '';
|
||
labelsArr.forEach(it => {
|
||
labelsBody += `<tr><td>${it.labelName}</td><td>${it.number}</td></tr>`;
|
||
});
|
||
body =
|
||
body +
|
||
labelsTitle +
|
||
labelsBody +
|
||
`</table>
|
||
|
||
`;
|
||
}
|
||
|
||
if (countComments == 'true') {
|
||
totalIssues.sort((a, b) => b.comments - a.comments);
|
||
const maxComments = totalIssues.slice(0, 3);
|
||
let commentTitle = `
|
||
### Most comments
|
||
|
||
<table>
|
||
<tr>
|
||
<th>#</th>
|
||
<th>Issue</th>
|
||
<th>Title</th>
|
||
<th>Number</th>
|
||
<th>State</th>
|
||
</tr>
|
||
`;
|
||
let commentBody = '';
|
||
maxComments.forEach((it, ind) => {
|
||
commentBody += `<tr>
|
||
<td>${ind + 1}</td>
|
||
<td>${it.number}</td>
|
||
<td>${it.title}</td>
|
||
<td>${it.comments}</td>
|
||
<td>${it.state}</td></tr>`;
|
||
});
|
||
body = body + commentTitle + commentBody + '</table>';
|
||
}
|
||
|
||
await doCreateIssue(owner, repo, title, body, labels, assignees);
|
||
}
|
||
|
||
// **************************************************************************
|
||
module.exports = {
|
||
doCheckInactive,
|
||
doCheckIssue,
|
||
doCloseIssues,
|
||
doFindComments,
|
||
doLockIssues,
|
||
doMonthStatistics,
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9932:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
__webpack_require__(2437).config();
|
||
const core = __webpack_require__(2186);
|
||
const github = __webpack_require__(5438);
|
||
const { Octokit } = __webpack_require__(5375);
|
||
|
||
// **************************************************************************
|
||
const ALLREACTIONS = ['+1', '-1', 'laugh', 'confused', 'heart', 'hooray', 'rocket', 'eyes'];
|
||
|
||
const { doQueryIssues } = __webpack_require__(197);
|
||
|
||
const {
|
||
dealStringToArr,
|
||
dealRandomAssignees,
|
||
testDuplicate,
|
||
checkPermission,
|
||
} = __webpack_require__(6254);
|
||
|
||
// **************************************************************************
|
||
const token = core.getInput('token');
|
||
const octokit = new Octokit({ auth: `token ${token}` });
|
||
const context = github.context;
|
||
|
||
const contents = core.getInput('contents');
|
||
|
||
const randomTo = core.getInput('random-to');
|
||
|
||
// **************************************************************************
|
||
async function doAddAssignees(owner, repo, issueNumber, assignees) {
|
||
const arr = dealRandomAssignees(assignees, randomTo);
|
||
await octokit.issues.addAssignees({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
assignees: arr,
|
||
});
|
||
core.info(`Actions: [add-assignees][${arr}] success!`);
|
||
}
|
||
|
||
async function doAddLabels(owner, repo, issueNumber, labels) {
|
||
await octokit.issues.addLabels({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
labels: dealStringToArr(labels),
|
||
});
|
||
core.info(`Actions: [add-labels][${labels}] success!`);
|
||
}
|
||
|
||
async function doCloseIssue(owner, repo, issueNumber) {
|
||
await octokit.issues.update({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
state: 'closed',
|
||
});
|
||
core.info(`Actions: [close-issue][${issueNumber}] success!`);
|
||
}
|
||
|
||
async function doCreateComment(owner, repo, issueNumber, body) {
|
||
const { data } = await octokit.issues.createComment({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
body,
|
||
});
|
||
core.info(`Actions: [create-comment][${body}] success!`);
|
||
core.setOutput('comment-id', data.id);
|
||
|
||
if (contents) {
|
||
await doCreateCommentContent(owner, repo, data.id, dealStringToArr(contents));
|
||
}
|
||
}
|
||
|
||
async function doCreateCommentContent(owner, repo, commentId, contents) {
|
||
if (contents.length) {
|
||
contents.forEach(async item => {
|
||
if (testContent(item)) {
|
||
await octokit.reactions.createForIssueComment({
|
||
owner,
|
||
repo,
|
||
comment_id: commentId,
|
||
content: item,
|
||
});
|
||
core.info(`Actions: [create-reactions][${item}] success!`);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
async function doCreateIssue(owner, repo, title, body, labels, assignees) {
|
||
let params = {
|
||
owner,
|
||
repo,
|
||
title,
|
||
body,
|
||
labels: dealStringToArr(labels),
|
||
assignees: dealRandomAssignees(assignees, randomTo),
|
||
};
|
||
|
||
const { data } = await octokit.issues.create(params);
|
||
core.info(`Actions: [create-issue][${title}] success!`);
|
||
core.setOutput('issue-number', data.number);
|
||
|
||
if (contents) {
|
||
await doCreateIssueContent(owner, repo, data.number, dealStringToArr(contents));
|
||
}
|
||
}
|
||
|
||
async function doCreateIssueContent(owner, repo, issueNumber, contents) {
|
||
if (contents.length) {
|
||
contents.forEach(async item => {
|
||
if (testContent(item)) {
|
||
await octokit.reactions.createForIssue({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
content: item,
|
||
});
|
||
core.info(`Actions: [create-reactions][${item}] success!`);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
async function doDeleteComment(owner, repo, commentId) {
|
||
await octokit.issues.deleteComment({
|
||
owner,
|
||
repo,
|
||
comment_id: commentId,
|
||
});
|
||
core.info(`Actions: [delete-comment][${commentId}] success!`);
|
||
}
|
||
|
||
async function doLockIssue(owner, repo, issueNumber) {
|
||
const lockReason = core.getInput('lock-reason');
|
||
let params = {
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
};
|
||
const reasons = ['off-topic', 'too heated', 'resolved', 'spam'];
|
||
if (lockReason && reasons.includes(lockReason)) {
|
||
params.lock_reason = lockReason;
|
||
}
|
||
await octokit.issues.lock(params);
|
||
core.info(`Actions: [lock-issue][${issueNumber}] success!`);
|
||
}
|
||
|
||
async function doMarkDuplicate(owner, repo, labels) {
|
||
if (context.eventName != 'issue_comment') {
|
||
core.info(`This actions only support on 'issue_comment'!`);
|
||
return false;
|
||
}
|
||
|
||
if (context.payload.action == 'created' || context.payload.action == 'edited') {
|
||
const duplicateCommand = core.getInput('duplicate-command');
|
||
const duplicateLabels = core.getInput('duplicate-labels');
|
||
const removeLables = core.getInput('remove-labels');
|
||
const closeIssue = core.getInput('close-issue');
|
||
const requirePermission = core.getInput('require-permission');
|
||
|
||
const commentId = context.payload.comment.id;
|
||
const commentBody = context.payload.comment.body;
|
||
const commentUser = context.payload.comment.user.login;
|
||
const issueNumber = context.payload.issue.number;
|
||
|
||
const ifCommandInput = !!duplicateCommand;
|
||
|
||
if (requirePermission) {
|
||
const res = await octokit.repos.getCollaboratorPermissionLevel({
|
||
owner,
|
||
repo,
|
||
username: commentUser,
|
||
});
|
||
const { permission } = res.data;
|
||
if (!checkPermission(requirePermission, permission)) {
|
||
core.info(`The user ${commentUser} is not allow!`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (
|
||
!commentBody.includes('?') &&
|
||
((ifCommandInput &&
|
||
commentBody.startsWith(duplicateCommand) &&
|
||
commentBody.split(' ')[0] == duplicateCommand) ||
|
||
testDuplicate(commentBody))
|
||
) {
|
||
if (ifCommandInput) {
|
||
const nextBody = commentBody.replace(duplicateCommand, 'Duplicate of');
|
||
await doUpdateComment(owner, repo, commentId, nextBody, 'replace', true);
|
||
} else if (contents) {
|
||
await doCreateCommentContent(owner, repo, commentId, dealStringToArr(contents));
|
||
}
|
||
|
||
const issue = await octokit.issues.get({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
let newLabels = [];
|
||
if (issue.data.labels.length > 0) {
|
||
newLabels = issue.data.labels
|
||
.map(({ name }) => name)
|
||
.filter(name => !dealStringToArr(removeLables).includes(name));
|
||
}
|
||
if (duplicateLabels) {
|
||
newLabels = [...newLabels, ...dealStringToArr(duplicateLabels)];
|
||
}
|
||
if (labels) {
|
||
newLabels = dealStringToArr(labels);
|
||
}
|
||
if (newLabels.length > 0) {
|
||
await doSetLabels(owner, repo, issueNumber, newLabels.toString());
|
||
core.info(`Actions: [mark-duplicate-labels][${newLabels}] success!`);
|
||
}
|
||
|
||
if (closeIssue == 'true') {
|
||
await doCloseIssue(owner, repo, issueNumber);
|
||
}
|
||
} else {
|
||
core.info(
|
||
`This comment body should start whith 'duplicate-command' or 'Duplicate of' and not include '?'`,
|
||
);
|
||
}
|
||
} else {
|
||
core.info(`This actions only support on 'issue_comment' created or edited!`);
|
||
}
|
||
}
|
||
|
||
async function doOpenIssue(owner, repo, issueNumber) {
|
||
await octokit.issues.update({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
state: 'open',
|
||
});
|
||
core.info(`Actions: [open-issue][${issueNumber}] success!`);
|
||
}
|
||
|
||
async function doRemoveAssignees(owner, repo, issueNumber, assignees) {
|
||
await octokit.issues.removeAssignees({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
assignees: dealStringToArr(assignees),
|
||
});
|
||
core.info(`Actions: [remove-assignees][${assignees}] success!`);
|
||
}
|
||
|
||
async function doRemoveLabels(owner, repo, issueNumber, labels) {
|
||
const dealLabels = dealStringToArr(labels);
|
||
for (label of dealLabels) {
|
||
await octokit.issues.removeLabel({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
name: label,
|
||
});
|
||
core.info(`Actions: [remove-labels-foreach][${label}] success!`);
|
||
}
|
||
core.info(`Actions: [remove-labels][${labels}] success!`);
|
||
}
|
||
|
||
async function doSetLabels(owner, repo, issueNumber, labels) {
|
||
// 概率性出现问题：https://github.com/octokit/rest.js/issues/1982，规避 setLabels
|
||
if (labels) {
|
||
// await octokit.issues.setLabels({
|
||
// owner,
|
||
// repo,
|
||
// issue_number: issueNumber,
|
||
// labels: dealStringToArr(labels)
|
||
// });
|
||
const issue = await octokit.issues.get({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
const baseLabels = issue.data.labels.map(({ name }) => name);
|
||
const removeLabels = baseLabels.filter(name => !dealStringToArr(labels).includes(name));
|
||
const addLabels = dealStringToArr(labels).filter(name => !baseLabels.includes(name));
|
||
|
||
if (removeLabels.length > 0) {
|
||
await doRemoveLabels(owner, repo, issueNumber, removeLabels.toString());
|
||
core.info(`Actions: [set-labels-remove][${removeLabels}] success!`);
|
||
}
|
||
|
||
if (addLabels.length > 0) {
|
||
await doAddLabels(owner, repo, issueNumber, addLabels.toString());
|
||
core.info(`Actions: [set-labels-add][${addLabels}] success!`);
|
||
}
|
||
|
||
core.info(`Actions: [set-labels][${labels}] success!`);
|
||
}
|
||
}
|
||
|
||
async function doUnlockIssue(owner, repo, issueNumber) {
|
||
await octokit.issues.unlock({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
core.info(`Actions: [unlock-issue][${issueNumber}] success!`);
|
||
}
|
||
|
||
async function doUpdateComment(owner, repo, commentId, body, updateMode, ifUpdateBody) {
|
||
const comment = await octokit.issues.getComment({
|
||
owner,
|
||
repo,
|
||
comment_id: commentId,
|
||
});
|
||
const comment_body = comment.data.body;
|
||
|
||
let params = {
|
||
owner,
|
||
repo,
|
||
comment_id: commentId,
|
||
};
|
||
|
||
if (core.getInput('body') || ifUpdateBody) {
|
||
if (updateMode === 'append') {
|
||
params.body = `${comment_body}\n${body}`;
|
||
} else {
|
||
params.body = body;
|
||
}
|
||
|
||
await octokit.issues.updateComment(params);
|
||
core.info(`Actions: [update-comment][${commentId}] success!`);
|
||
}
|
||
|
||
if (contents) {
|
||
await doCreateCommentContent(owner, repo, commentId, dealStringToArr(contents));
|
||
}
|
||
}
|
||
|
||
async function doUpdateIssue(
|
||
owner,
|
||
repo,
|
||
issueNumber,
|
||
state,
|
||
title,
|
||
body,
|
||
updateMode,
|
||
assignees,
|
||
labels,
|
||
) {
|
||
const issue = await octokit.issues.get({
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
});
|
||
const issue_body = issue.data.body;
|
||
const issue_title = issue.data.title;
|
||
|
||
let issue_labels = [];
|
||
if (issue.data.labels.length > 0) {
|
||
issue.data.labels.forEach(it => {
|
||
issue_labels.push(it.name);
|
||
});
|
||
}
|
||
|
||
let issue_assignees = [];
|
||
if (issue.data.assignees.length > 0) {
|
||
issue.data.assignees.forEach(it => {
|
||
issue_assignees.push(it.login);
|
||
});
|
||
}
|
||
|
||
let params = {
|
||
owner,
|
||
repo,
|
||
issue_number: issueNumber,
|
||
state,
|
||
};
|
||
|
||
params.title = core.getInput('title') ? title : issue_title;
|
||
|
||
let next_body;
|
||
if (core.getInput('body')) {
|
||
if (updateMode === 'append') {
|
||
next_body = `${issue_body}\n${body}`;
|
||
} else {
|
||
next_body = body;
|
||
}
|
||
} else {
|
||
next_body = issue_body;
|
||
}
|
||
params.body = next_body;
|
||
|
||
params.labels = labels ? dealStringToArr(labels) : issue_labels;
|
||
params.assignees = assignees ? dealStringToArr(assignees) : issue_assignees;
|
||
|
||
await octokit.issues.update(params);
|
||
core.info(`Actions: [update-issue][${issueNumber}] success!`);
|
||
|
||
if (contents) {
|
||
await doCreateIssueContent(owner, repo, issueNumber, contents);
|
||
}
|
||
}
|
||
|
||
async function doWelcome(owner, repo, assignees, labels, body) {
|
||
const context = github.context;
|
||
const isIssue = !!context.payload.issue;
|
||
const issueContents = core.getInput('issue-contents');
|
||
if (!isIssue) {
|
||
core.setFailed('The event that triggered this action must be a issue. Error!');
|
||
} else {
|
||
const auth = context.payload.sender.login;
|
||
core.info(`Actions: [welcome: auth=][${auth}]`);
|
||
const issueNumber = context.issue.number;
|
||
const issues = await doQueryIssues(owner, repo, false, 'all', auth);
|
||
if (issues.length == 0 || (issues.length == 1 && issues[0].number == issueNumber)) {
|
||
if (core.getInput('body')) {
|
||
await doCreateComment(owner, repo, issueNumber, body);
|
||
} else {
|
||
core.info(`Actions: [welcome] no body!`);
|
||
}
|
||
|
||
if (assignees) {
|
||
await doAddAssignees(owner, repo, issueNumber, assignees);
|
||
}
|
||
|
||
if (labels) {
|
||
await doAddLabels(owner, repo, issueNumber, labels);
|
||
}
|
||
|
||
if (issueContents) {
|
||
await doCreateIssueContent(owner, repo, issueNumber, dealStringToArr(issueContents));
|
||
}
|
||
} else {
|
||
core.info(`Actions: [welcome][${auth}] is not first time!`);
|
||
}
|
||
}
|
||
}
|
||
|
||
// **************************************************************************
|
||
function testContent(con) {
|
||
if (ALLREACTIONS.includes(con)) {
|
||
return true;
|
||
} else {
|
||
core.setFailed('This actions not supported!');
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// **************************************************************************
|
||
module.exports = {
|
||
doAddAssignees,
|
||
doAddLabels,
|
||
doCloseIssue,
|
||
doCreateComment,
|
||
doCreateCommentContent,
|
||
doCreateIssue,
|
||
doCreateIssueContent,
|
||
doDeleteComment,
|
||
doMarkDuplicate,
|
||
doLockIssue,
|
||
doOpenIssue,
|
||
doRemoveAssignees,
|
||
doRemoveLabels,
|
||
doSetLabels,
|
||
doUnlockIssue,
|
||
doUpdateComment,
|
||
doUpdateIssue,
|
||
doWelcome,
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1713:
|
||
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
const core = __webpack_require__(2186);
|
||
const github = __webpack_require__(5438);
|
||
|
||
// **************************************************************************
|
||
const {
|
||
doAddAssignees,
|
||
doAddLabels,
|
||
doCloseIssue,
|
||
doCreateComment,
|
||
doCreateIssue,
|
||
doDeleteComment,
|
||
doMarkDuplicate,
|
||
doLockIssue,
|
||
doOpenIssue,
|
||
doRemoveAssignees,
|
||
doRemoveLabels,
|
||
doSetLabels,
|
||
doUnlockIssue,
|
||
doUpdateComment,
|
||
doUpdateIssue,
|
||
doWelcome,
|
||
} = __webpack_require__(9932);
|
||
|
||
const {
|
||
doCheckInactive,
|
||
doCheckIssue,
|
||
doCloseIssues,
|
||
doFindComments,
|
||
doLockIssues,
|
||
doMonthStatistics,
|
||
} = __webpack_require__(9319);
|
||
|
||
// **************************************************************************
|
||
const ALLACTIONS = [
|
||
// base
|
||
'add-assignees',
|
||
'add-labels',
|
||
'close-issue',
|
||
'create-comment',
|
||
'create-issue',
|
||
'delete-comment',
|
||
'lock-issue',
|
||
'mark-duplicate',
|
||
'open-issue',
|
||
'remove-assignees',
|
||
'remove-labels',
|
||
'set-labels',
|
||
'unlock-issue',
|
||
'update-comment',
|
||
'update-issue',
|
||
'welcome',
|
||
|
||
// advanced
|
||
'check-inactive',
|
||
'check-issue',
|
||
'close-issues',
|
||
'find-comments',
|
||
'lock-issues',
|
||
'month-statistics',
|
||
];
|
||
|
||
// **************************************************************************
|
||
async function main() {
|
||
try {
|
||
const owner = github.context.repo.owner;
|
||
const repo = github.context.repo.repo;
|
||
|
||
const issueNumber = core.getInput('issue-number');
|
||
const commentId = core.getInput('comment-id');
|
||
|
||
const defaultBody = `Currently at ${owner}/${repo}. And this is default comment.`;
|
||
const body = core.getInput('body') || defaultBody;
|
||
|
||
const defaultTitle = `Default Title`;
|
||
const title = core.getInput('title') || defaultTitle;
|
||
|
||
const assignees = core.getInput('assignees');
|
||
|
||
const labels = core.getInput('labels');
|
||
const state = core.getInput('state') || 'open';
|
||
|
||
let updateMode = core.getInput('update-mode');
|
||
if (updateMode !== 'append') {
|
||
updateMode = 'replace';
|
||
}
|
||
|
||
// actions
|
||
const actions = core.getInput('actions', { required: true });
|
||
|
||
const actionsArr = actions.split(',');
|
||
actionsArr.forEach(item => {
|
||
testActions(item.trim());
|
||
});
|
||
|
||
function testActions(action) {
|
||
if (ALLACTIONS.includes(action)) {
|
||
choseActions(action);
|
||
} else {
|
||
core.setFailed('This actions not supported!');
|
||
}
|
||
}
|
||
|
||
async function choseActions(action) {
|
||
switch (action) {
|
||
// base
|
||
case 'add-assignees':
|
||
await doAddAssignees(owner, repo, issueNumber, assignees);
|
||
break;
|
||
case 'add-labels':
|
||
await doAddLabels(owner, repo, issueNumber, labels);
|
||
break;
|
||
case 'close-issue':
|
||
await doCloseIssue(owner, repo, issueNumber);
|
||
break;
|
||
case 'create-comment':
|
||
await doCreateComment(owner, repo, issueNumber, body);
|
||
break;
|
||
case 'create-issue':
|
||
await doCreateIssue(owner, repo, title, body, labels, assignees);
|
||
break;
|
||
case 'delete-comment':
|
||
await doDeleteComment(owner, repo, commentId);
|
||
break;
|
||
case 'lock-issue':
|
||
await doLockIssue(owner, repo, issueNumber);
|
||
break;
|
||
case 'mark-duplicate':
|
||
await doMarkDuplicate(owner, repo, labels);
|
||
break;
|
||
case 'open-issue':
|
||
await doOpenIssue(owner, repo, issueNumber);
|
||
break;
|
||
case 'remove-assignees':
|
||
await doRemoveAssignees(owner, repo, issueNumber, assignees);
|
||
break;
|
||
case 'remove-labels':
|
||
await doRemoveLabels(owner, repo, issueNumber, labels);
|
||
break;
|
||
case 'set-labels':
|
||
await doSetLabels(owner, repo, issueNumber, labels);
|
||
break;
|
||
case 'unlock-issue':
|
||
await doUnlockIssue(owner, repo, issueNumber);
|
||
break;
|
||
case 'update-comment':
|
||
await doUpdateComment(owner, repo, commentId, body, updateMode);
|
||
break;
|
||
case 'update-issue':
|
||
await doUpdateIssue(
|
||
owner,
|
||
repo,
|
||
issueNumber,
|
||
state,
|
||
title,
|
||
body,
|
||
updateMode,
|
||
assignees,
|
||
labels,
|
||
);
|
||
break;
|
||
case 'welcome':
|
||
await doWelcome(owner, repo, assignees, labels, body);
|
||
break;
|
||
|
||
// advanced
|
||
case 'check-inactive':
|
||
await doCheckInactive(owner, repo, labels);
|
||
break;
|
||
case 'check-issue':
|
||
await doCheckIssue(owner, repo, issueNumber);
|
||
break;
|
||
case 'close-issues':
|
||
await doCloseIssues(owner, repo, labels);
|
||
break;
|
||
case 'find-comments':
|
||
await doFindComments(owner, repo, issueNumber);
|
||
break;
|
||
case 'lock-issues':
|
||
await doLockIssues(owner, repo, labels);
|
||
break;
|
||
case 'month-statistics':
|
||
await doMonthStatistics(owner, repo, labels, assignees);
|
||
break;
|
||
// default
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
core.setFailed(error.message);
|
||
}
|
||
}
|
||
|
||
// **************************************************************************
|
||
main();
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 197:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
__webpack_require__(2437).config();
|
||
const core = __webpack_require__(2186);
|
||
const { Octokit } = __webpack_require__(5375);
|
||
|
||
const { getPreMonth } = __webpack_require__(6254);
|
||
|
||
// **************************************************************************
|
||
var dayjs = __webpack_require__(7401);
|
||
var utc = __webpack_require__(4359);
|
||
dayjs.extend(utc);
|
||
var isSameOrBefore = __webpack_require__(9517);
|
||
dayjs.extend(isSameOrBefore);
|
||
|
||
// **************************************************************************
|
||
const token = core.getInput('token');
|
||
const octokit = new Octokit({ auth: `token ${token}` });
|
||
|
||
const perPage = 100;
|
||
|
||
const issueCreator = core.getInput('issue-creator');
|
||
const issueAssignee = core.getInput('issue-assignee');
|
||
const issueMentioned = core.getInput('issue-mentioned');
|
||
|
||
const bodyIncludes = core.getInput('body-includes');
|
||
const titleIncludes = core.getInput('title-includes');
|
||
|
||
const inactiveDay = core.getInput('inactive-day');
|
||
|
||
// **************************************************************************
|
||
async function doQueryIssues(owner, repo, labels, state, creator) {
|
||
let params = {
|
||
owner,
|
||
repo,
|
||
state,
|
||
};
|
||
|
||
issueCreator ? (params.creator = issueCreator) : null;
|
||
issueAssignee ? (params.assignee = issueAssignee) : null;
|
||
issueMentioned ? (params.mentioned = issueMentioned) : null;
|
||
|
||
if (labels) {
|
||
params.labels = labels;
|
||
}
|
||
|
||
if (creator) {
|
||
params.creator = creator;
|
||
}
|
||
|
||
const res = await getIssues(params);
|
||
let issues = [];
|
||
let issueNumbers = [];
|
||
if (res.length) {
|
||
res.forEach(iss => {
|
||
const a = bodyIncludes ? iss.body.includes(bodyIncludes) : true;
|
||
const b = titleIncludes ? iss.title.includes(titleIncludes) : true;
|
||
/**
|
||
* Note: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request.
|
||
* For this reason, "Issues" endpoints may return both issues and pull requests in the response.
|
||
* You can identify pull requests by the pull_request key.
|
||
*/
|
||
if (a && b && iss.pull_request === undefined) {
|
||
if (inactiveDay) {
|
||
let lastTime = dayjs.utc().subtract(Number(inactiveDay), 'day');
|
||
let updateTime = dayjs.utc(iss.updated_at);
|
||
if (updateTime.isSameOrBefore(lastTime)) {
|
||
issues.push(iss);
|
||
issueNumbers.push(iss.number);
|
||
}
|
||
} else {
|
||
issues.push(iss);
|
||
issueNumbers.push(iss.number);
|
||
}
|
||
}
|
||
});
|
||
core.info(`Actions: [query-issues]: [${JSON.stringify(issueNumbers)}]!`);
|
||
}
|
||
|
||
return issues;
|
||
}
|
||
|
||
async function getIssues(params, page = 1) {
|
||
let { data: issues } = await octokit.issues.listForRepo({
|
||
...params,
|
||
per_page: perPage,
|
||
page,
|
||
});
|
||
if (issues.length >= perPage) {
|
||
issues = issues.concat(await getIssues(params, page + 1));
|
||
}
|
||
return issues;
|
||
}
|
||
|
||
async function getIssuesInMonth(owner, repo, thisMonth, page = 1) {
|
||
const month = getPreMonth(thisMonth);
|
||
let { data: issues } = await octokit.issues.listForRepo({
|
||
owner,
|
||
repo,
|
||
state: 'all',
|
||
per_page: perPage,
|
||
page,
|
||
});
|
||
issues = issues.filter(i => {
|
||
return i.pull_request === undefined;
|
||
});
|
||
if (issues.length && getCreatedMonth(issues[issues.length - 1].created_at) >= month) {
|
||
issues = issues.concat(await getIssuesInMonth(owner, repo, thisMonth, page + 1));
|
||
}
|
||
return issues;
|
||
}
|
||
|
||
// **************************************************************************
|
||
function getCreatedMonth(d) {
|
||
return (
|
||
dayjs(d)
|
||
.utc()
|
||
.month() + 1
|
||
);
|
||
}
|
||
|
||
// **************************************************************************
|
||
module.exports = {
|
||
doQueryIssues,
|
||
getIssues,
|
||
getIssuesInMonth,
|
||
getCreatedMonth,
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6254:
|
||
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
||
|
||
const sampleSize = __webpack_require__(2199);
|
||
|
||
function dealStringToArr(para) {
|
||
/**
|
||
* in 'x1,x2,x3'
|
||
* out ['x1','x2','x3']
|
||
*/
|
||
let arr = [];
|
||
if (para) {
|
||
const paraArr = para.split(',');
|
||
paraArr.forEach(it => {
|
||
if (it.trim()) {
|
||
arr.push(it.trim());
|
||
}
|
||
});
|
||
}
|
||
return arr;
|
||
}
|
||
|
||
function dealRandomAssignees(assignees, randomTo) {
|
||
let arr = dealStringToArr(assignees);
|
||
if (randomTo && Number(randomTo) > 0 && Number(randomTo) < arr.length) {
|
||
arr = sampleSize(arr, randomTo);
|
||
}
|
||
return arr;
|
||
}
|
||
|
||
function matchKeyword(content, keywords) {
|
||
return keywords.find(item => content.toLowerCase().includes(item));
|
||
}
|
||
|
||
function testDuplicate(body) {
|
||
if (!body || !body.startsWith('Duplicate of')) {
|
||
return false;
|
||
}
|
||
|
||
let arr = body.split(' ');
|
||
if (arr[0] == 'Duplicate' && arr[1] == 'of') {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function getPreMonth(m) {
|
||
return m == 1 ? 12 : m - 1;
|
||
}
|
||
|
||
function checkPermission(require, permission) {
|
||
/**
|
||
* 有权限返回 true
|
||
*/
|
||
const permissions = ['none', 'read', 'write', 'admin'];
|
||
const requireNo = permissions.indexOf(require);
|
||
const permissionNo = permissions.indexOf(permission);
|
||
|
||
return requireNo <= permissionNo;
|
||
}
|
||
|
||
// **********************************************************
|
||
module.exports = {
|
||
dealStringToArr,
|
||
dealRandomAssignees,
|
||
getPreMonth,
|
||
matchKeyword,
|
||
testDuplicate,
|
||
checkPermission,
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2877:
|
||
/***/ ((module) => {
|
||
|
||
module.exports = eval("require")("encoding");
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2357:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("assert");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8614:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("events");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5747:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("fs");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8605:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("http");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7211:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("https");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1631:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("net");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2087:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("os");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5622:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("path");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 2413:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("stream");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 4016:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("tls");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8835:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("url");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 1669:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("util");;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8761:
|
||
/***/ ((module) => {
|
||
|
||
"use strict";
|
||
module.exports = require("zlib");;
|
||
|
||
/***/ })
|
||
|
||
/******/ });
|
||
/************************************************************************/
|
||
/******/ // The module cache
|
||
/******/ var __webpack_module_cache__ = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/ // Check if module is in cache
|
||
/******/ if(__webpack_module_cache__[moduleId]) {
|
||
/******/ return __webpack_module_cache__[moduleId].exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = __webpack_module_cache__[moduleId] = {
|
||
/******/ id: moduleId,
|
||
/******/ loaded: false,
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ var threw = true;
|
||
/******/ try {
|
||
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/ threw = false;
|
||
/******/ } finally {
|
||
/******/ if(threw) delete __webpack_module_cache__[moduleId];
|
||
/******/ }
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.loaded = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/************************************************************************/
|
||
/******/ /* webpack/runtime/node module decorator */
|
||
/******/ (() => {
|
||
/******/ __webpack_require__.nmd = (module) => {
|
||
/******/ module.paths = [];
|
||
/******/ if (!module.children) module.children = [];
|
||
/******/ return module;
|
||
/******/ };
|
||
/******/ })();
|
||
/******/
|
||
/******/ /* webpack/runtime/compat */
|
||
/******/
|
||
/******/ __webpack_require__.ab = __dirname + "/";/************************************************************************/
|
||
/******/ // module exports must be returned from runtime so entry inlining is disabled
|
||
/******/ // startup
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(1713);
|
||
/******/ })()
|
||
; |