@yvhitxcel/opencode-remote 0.15.0

package/dist/weixin/node_modules/qiniu/qiniu/httpc/endpointsRetryPolicy.js

@@ -0,0 +1,76 @@
+const {
+    RetryPolicy
+} = require('../retry');
+const {
+    StaticEndpointsProvider
+} = require('./endpointsProvider');
+
+/**
+ * @typedef {RetryPolicyContext} EndpointsRetryPolicyContext
+ * @property {Endpoint} endpoint
+ * @property {Endpoint[]} alternativeEndpoints
+ */
+
+/**
+ * @class
+ * @extends RetryPolicy
+ * @param {boolean} [options.skipInitContext]
+ * @param {Endpoint[]} [options.endpoints]
+ * @param {EndpointsProvider} [options.endpointsProvider]
+ * @constructor
+ */
+function EndpointsRetryPolicy (options) {
+    this.skipInitContext = options.skipInitContext || false;
+    this.endpoints = options.endpoints || [];
+    this.endpointsProvider = options.endpointsProvider || new StaticEndpointsProvider([]);
+}
+
+EndpointsRetryPolicy.prototype = Object.create(RetryPolicy.prototype);
+EndpointsRetryPolicy.prototype.constructor = EndpointsRetryPolicy;
+
+/**
+ * @param {EndpointsRetryPolicyContext} context
+ * @returns {Promise<void>}
+ */
+EndpointsRetryPolicy.prototype.initContext = function (context) {
+    if (this.skipInitContext) {
+        return Promise.resolve();
+    }
+    if (this.endpoints.length > 0) {
+        [context.endpoint, ...context.alternativeEndpoints] = this.endpoints.slice();
+        return Promise.resolve();
+    }
+    return this.endpointsProvider.getEndpoints()
+        .then(endpoints => {
+            if (endpoints.length < 0) {
+                return Promise.reject(
+                    new Error('There isn\'t available endpoint')
+                );
+            }
+            [context.endpoint, ...context.alternativeEndpoints] = endpoints.slice();
+        });
+};
+
+/**
+ * @param {EndpointsRetryPolicyContext} context
+ * @returns {boolean}
+ */
+EndpointsRetryPolicy.prototype.shouldRetry = function (context) {
+    return context.alternativeEndpoints.length > 0;
+};
+
+/**
+ * @param {EndpointsRetryPolicyContext} context
+ * @returns {Promise<void>}
+ */
+EndpointsRetryPolicy.prototype.prepareRetry = function (context) {
+    context.endpoint = context.alternativeEndpoints.shift();
+    if (!context.endpoint) {
+        return Promise.reject(
+            new Error('There isn\'t available endpoint for next try')
+        );
+    }
+    return Promise.resolve();
+};
+
+exports.EndpointsRetryPolicy = EndpointsRetryPolicy;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/middleware/base.js

@@ -0,0 +1,31 @@
+/**
+ * Middleware could be an interface if migrate to typescript
+ * @class
+ * @constructor
+ */
+function Middleware () {
+}
+
+/**
+ * @memberOf Middleware
+ * @param _request
+ * @param _next
+ */
+Middleware.prototype.send = function (_request, _next) {
+    throw new Error('The Middleware NOT be Implemented');
+};
+
+exports.Middleware = Middleware;
+
+/**
+ * @param {Middleware[]} middlewares
+ * @param {function(ReqOpts):Promise<ResponseWrapper>} handler
+ * @returns {function(ReqOpts):Promise<ResponseWrapper>}
+ */
+exports.composeMiddlewares = function (middlewares, handler) {
+    return middlewares.reverse()
+        .reduce(
+            (h, mw) => request => mw.send(request, h),
+            handler
+        );
+};

package/dist/weixin/node_modules/qiniu/qiniu/httpc/middleware/index.js

@@ -0,0 +1,9 @@
+const base = require('./base');
+
+module.exports = {
+    composeMiddlewares: base.composeMiddlewares,
+    Middleware: base.Middleware,
+    RetryDomainsMiddleware: require('./retryDomains').RetryDomainsMiddleware,
+    UserAgentMiddleware: require('./ua').UserAgentMiddleware,
+    QiniuAuthMiddleware: require('./qiniuAuth').QiniuAuthMiddleware
+};

package/dist/weixin/node_modules/qiniu/qiniu/httpc/middleware/qiniuAuth.js

@@ -0,0 +1,53 @@
+const middleware = require('./base');
+const util = require('../../util');
+
+/**
+ * @class
+ * @extends middleware.Middleware
+ * @param {Object} qiniuAuthOptions
+ * @param {Mac} qiniuAuthOptions.mac
+ * @constructor
+ */
+function QiniuAuthMiddleware (qiniuAuthOptions) {
+    this.mac = qiniuAuthOptions.mac;
+}
+
+QiniuAuthMiddleware.prototype = Object.create(middleware.Middleware.prototype);
+QiniuAuthMiddleware.prototype.constructor = QiniuAuthMiddleware;
+
+/**
+ * @memberOf QiniuAuthMiddleware
+ * @param {ReqOpts} reqOpts
+ * @param {function(ReqOpts):Promise<ResponseWrapper>} next
+ * @returns {Promise<ResponseWrapper>}
+ */
+QiniuAuthMiddleware.prototype.send = function (reqOpts, next) {
+    const headers = reqOpts.urllibOptions.headers;
+    if (this._shouldSignTime()) {
+        headers['X-Qiniu-Date'] = util.formatDateUTC(new Date(), 'YYYYMMDDTHHmmssZ');
+    }
+
+    if (this.mac.accessKey) {
+        headers.Authorization = util.generateAccessTokenV2(
+            this.mac,
+            reqOpts.url,
+            reqOpts.urllibOptions.method,
+            reqOpts.urllibOptions.contentType,
+            reqOpts.urllibOptions.content,
+            headers
+        );
+    }
+
+    return next(reqOpts);
+};
+
+QiniuAuthMiddleware.prototype._shouldSignTime = function () {
+    let shouldDisable = this.mac.options.disableQiniuTimestampSignature;
+    if (shouldDisable === null) {
+        const envDisable = process.env.DISABLE_QINIU_TIMESTAMP_SIGNATURE || '';
+        shouldDisable = envDisable.toLowerCase() === 'true';
+    }
+    return !shouldDisable;
+};
+
+exports.QiniuAuthMiddleware = QiniuAuthMiddleware;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/middleware/retryDomains.js

@@ -0,0 +1,101 @@
+const middleware = require('./base');
+
+const URL = require('url').URL;
+
+/**
+ * @class
+ * @extends middleware.Middleware
+ * @param {Object} retryDomainsOptions
+ * @param {string[]} retryDomainsOptions.backupDomains
+ * @param {number} [retryDomainsOptions.maxRetryTimes]
+ * @param {function(Error || null, ResponseWrapper || null, ReqOpts):boolean} [retryDomainsOptions.retryCondition]
+ * @constructor
+ */
+function RetryDomainsMiddleware (retryDomainsOptions) {
+    this.backupDomains = retryDomainsOptions.backupDomains;
+    this.maxRetryTimes = retryDomainsOptions.maxRetryTimes || 2;
+    this.retryCondition = retryDomainsOptions.retryCondition;
+
+    this._retriedTimes = 0;
+}
+
+RetryDomainsMiddleware.prototype = Object.create(middleware.Middleware.prototype);
+RetryDomainsMiddleware.prototype.constructor = RetryDomainsMiddleware;
+
+/**
+ * @memberOf RetryDomainsMiddleware
+ * @param {Error || null} err
+ * @param {ResponseWrapper || null} respWrapper
+ * @param {ReqOpts} reqOpts
+ * @returns {boolean}
+ * @private
+ */
+RetryDomainsMiddleware.prototype._shouldRetry = function (err, respWrapper, reqOpts) {
+    if (typeof this.retryCondition === 'function') {
+        return this.retryCondition(err, respWrapper, reqOpts);
+    }
+
+    return !respWrapper || respWrapper.needRetry();
+};
+
+/**
+ * @memberOf RetryDomainsMiddleware
+ * @param {ReqOpts} reqOpts
+ * @param {function(ReqOpts):Promise<ResponseWrapper>} next
+ * @returns {Promise<ResponseWrapper>}
+ */
+RetryDomainsMiddleware.prototype.send = function (reqOpts, next) {
+    const url = new URL(reqOpts.url);
+    const domains = this.backupDomains.slice(); // copy for late pop
+
+    const couldRetry = () => {
+        // the reason `this.maxRetryTimes - 1` is request send first then add retriedTimes
+        // and `this.maxRetryTimes` means max request times per domain
+        if (this._retriedTimes < this.maxRetryTimes - 1) {
+            this._retriedTimes += 1;
+            return true;
+        }
+
+        if (domains.length) {
+            this._retriedTimes = 0;
+            const domain = domains.shift();
+            const [hostname, port] = domain.split(':');
+            url.hostname = hostname;
+            url.port = port || url.port;
+            reqOpts.url = url.toString();
+            return true;
+        }
+
+        return false;
+    };
+
+    const tryNext = () => {
+        return next(reqOpts)
+            .then(respWrapper => {
+                if (!this._shouldRetry(null, respWrapper, reqOpts)) {
+                    return respWrapper;
+                }
+
+                if (couldRetry()) {
+                    return tryNext();
+                }
+
+                return respWrapper;
+            })
+            .catch(err => {
+                if (!this._shouldRetry(err, null, reqOpts)) {
+                    return Promise.reject(err);
+                }
+
+                if (couldRetry()) {
+                    return tryNext();
+                }
+
+                return Promise.reject(err);
+            });
+    };
+
+    return tryNext();
+};
+
+exports.RetryDomainsMiddleware = RetryDomainsMiddleware;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/middleware/ua.js

@@ -0,0 +1,36 @@
+const os = require('os');
+
+const middleware = require('./base');
+
+/**
+ * @class
+ * @extends middleware.Middleware
+ * @param {string} sdkVersion
+ * @constructor
+ */
+function UserAgentMiddleware (sdkVersion) {
+    this.userAgent = 'QiniuNodejs/' + sdkVersion +
+        ' (' +
+        os.type() + '; ' +
+        os.platform() + '; ' +
+        os.arch() + '; ' +
+        'Node.js ' + process.version + '; )';
+}
+UserAgentMiddleware.prototype = Object.create(middleware.Middleware.prototype);
+UserAgentMiddleware.prototype.constructor = UserAgentMiddleware;
+
+/**
+ * @memberOf UserAgentMiddleware
+ * @param {ReqOpts} reqOpts
+ * @param {function(ReqOpts):Promise<ResponseWrapper>} next
+ * @returns {Promise<ResponseWrapper>}
+ */
+UserAgentMiddleware.prototype.send = function (reqOpts, next) {
+    if (!reqOpts.urllibOptions.headers) {
+        reqOpts.urllibOptions.headers = {};
+    }
+    reqOpts.urllibOptions.headers['User-Agent'] = this.userAgent;
+    return next(reqOpts);
+};
+
+exports.UserAgentMiddleware = UserAgentMiddleware;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/region.js

@@ -0,0 +1,349 @@
+const { Endpoint } = require('./endpoint');
+
+/**
+ * @interface RegionsProvider
+ */
+
+/**
+ * @function
+ * @name RegionsProvider#getRegions
+ * @returns {Promise<Region[]>}
+ */
+
+/**
+ * @interface MutableRegionsProvider
+ * @extends RegionsProvider
+ */
+
+/**
+ * @function
+ * @name MutableRegionsProvider#setRegions
+ * @param {Region[]} regions
+ * @returns {Promise<void>}
+ */
+
+// --- could split to files if migrate to typescript --- //
+
+/**
+ * @readonly
+ * @enum {string}
+ */
+const SERVICE_NAME = {
+    UC: 'uc',
+    UP: 'up',
+    UP_ACC: 'up_acc',
+    IO: 'io',
+    RS: 'rs',
+    RSF: 'rsf',
+    API: 'api',
+    S3: 's3'
+};
+
+// --- could split to files if migrate to typescript --- //
+
+/**
+ * @typedef {SERVICE_NAME | string} ServiceKey
+ */
+
+/**
+ * @class
+ * @implements RegionsProvider
+ * @param {Object} options
+ * @param {string} [options.regionId]
+ * @param {string} [options.s3RegionId]
+ * @param {Object.<ServiceKey, Endpoint[]>} [options.services]
+ * @param {number} [options.ttl] seconds. default 1 day.
+ * @param {Date} [options.createTime]
+ * @constructor
+ */
+function Region (options) {
+    this.regionId = options.regionId;
+    this.s3RegionId = options.s3RegionId || options.regionId;
+
+    this.services = options.services || {};
+    // use Object.values when min version of Node.js update to ≥ v7.5.0
+    Object.keys(SERVICE_NAME).map(k => {
+        const v = SERVICE_NAME[k];
+        if (!Array.isArray(this.services[v])) {
+            this.services[v] = [];
+        }
+    });
+
+    this.ttl = options.ttl || 86400;
+    this.createTime = options.createTime || new Date();
+}
+
+/**
+ * This is used to be compatible with Zone.
+ * So this function will be removed after remove Zone.
+ * NOTE: The Region instance obtained using this method
+ *  can only be used for the following services: up, io, rs, rsf, api.
+ *  Because the Zone not support other services.
+ * @param {conf.Zone} zone
+ * @param {Object} [options]
+ * @param {string} [options.regionId]
+ * @param {string} [options.s3RegionId]
+ * @param {number} [options.ttl]
+ * @param {boolean} [options.isPreferCdnHost]
+ * @param {string} [options.preferredScheme]
+ */
+Region.fromZone = function (zone, options) {
+    options = options || {};
+    options.ttl = options.ttl || -1;
+
+    const upHosts = options.isPreferCdnHost
+        ? zone.cdnUpHosts.concat(zone.srcUpHosts)
+        : zone.srcUpHosts.concat(zone.cdnUpHosts);
+
+    const endpointOptions = {};
+    if (options.preferredScheme) {
+        endpointOptions.defaultScheme = options.preferredScheme;
+    }
+
+    const services = {
+        // use array destructure if migrate to typescript
+        [SERVICE_NAME.UP]: upHosts.map(
+            h => new Endpoint(h, endpointOptions)
+        ),
+        [SERVICE_NAME.IO]: [
+            new Endpoint(zone.ioHost, endpointOptions)
+        ],
+        [SERVICE_NAME.RS]: [
+            new Endpoint(zone.rsHost, endpointOptions)
+        ],
+        [SERVICE_NAME.RSF]: [
+            new Endpoint(zone.rsfHost, endpointOptions)
+        ],
+        [SERVICE_NAME.API]: [
+            new Endpoint(zone.apiHost, endpointOptions)
+        ]
+    };
+
+    return new Region({
+        regionId: options.regionId,
+        s3RegionId: options.s3RegionId || options.regionId,
+        services: services,
+        ttl: options.ttl
+    });
+};
+
+/**
+ * @param {string} regionId
+ * @param {Object} [options]
+ * @param {string} [options.s3RegionId]
+ * @param {number} [options.ttl]
+ * @param {Date} [options.createTime]
+ * @param {string} [options.preferredScheme]
+ * @param {boolean} [options.isPreferCdnUpHost]
+ * @param {Object.<ServiceKey, Endpoint[]>} [options.extendedServices]
+ * @returns {Region}
+ */
+Region.fromRegionId = function (regionId, options) {
+    options = options || {};
+
+    const s3RegionId = options.s3RegionId || regionId;
+    const ttl = options.ttl;
+    const createTime = options.createTime;
+    const isPreferCdnUpHost = typeof options.isPreferCdnUpHost === 'boolean'
+        ? options.isPreferCdnUpHost
+        : true;
+
+    const endpointOptions = {};
+    if (options.preferredScheme) {
+        endpointOptions.defaultScheme = options.preferredScheme;
+    }
+
+    const isZ0 = regionId === 'z0';
+    let upCdnEndpoints;
+    let upSourceEndpoints;
+    if (isZ0) {
+        upCdnEndpoints = [
+            new Endpoint(
+                'upload.qiniup.com',
+                endpointOptions
+            )
+        ];
+        upSourceEndpoints = [
+            new Endpoint(
+                'up.qiniup.com',
+                endpointOptions
+            ),
+            new Endpoint(
+                'up.qbox.me',
+                endpointOptions
+            )
+        ];
+    } else {
+        upCdnEndpoints = [
+            new Endpoint(
+                'upload-' + regionId + '.qiniup.com',
+                endpointOptions
+            )
+        ];
+        upSourceEndpoints = [
+            new Endpoint(
+                'up-' + regionId + '.qiniup.com',
+                endpointOptions
+            ),
+            new Endpoint(
+                'up-' + regionId + '.qbox.me',
+                endpointOptions
+            )
+        ];
+    }
+
+    /**
+     * @type {Object.<ServiceKey, Endpoint[]>}
+     */
+    let services = {
+        [SERVICE_NAME.UC]: [
+            new Endpoint(
+                'uc.qiniuapi.com',
+                endpointOptions
+            )
+        ],
+        [SERVICE_NAME.UP]: isPreferCdnUpHost
+            ? upCdnEndpoints.concat(upSourceEndpoints)
+            : upSourceEndpoints.concat(upCdnEndpoints),
+        [SERVICE_NAME.IO]: isZ0
+            ? [
+                new Endpoint(
+                    'iovip.qiniuio.com',
+                    endpointOptions
+                ),
+                new Endpoint(
+                    'iovip.qbox.me',
+                    endpointOptions
+                )
+            ]
+            : [
+                new Endpoint(
+                    'iovip-' + regionId + '.qiniuio.com',
+                    endpointOptions
+                ),
+                new Endpoint(
+                    'iovip-' + regionId + '.qbox.me',
+                    endpointOptions
+                )
+            ],
+        [SERVICE_NAME.RS]: [
+            new Endpoint(
+                'rs-' + regionId + '.qiniuapi.com',
+                endpointOptions
+            ),
+            new Endpoint(
+                'rs-' + regionId + '.qbox.me',
+                endpointOptions
+            )
+        ],
+        [SERVICE_NAME.RSF]: [
+            new Endpoint(
+                'rsf-' + regionId + '.qiniuapi.com',
+                endpointOptions
+            ),
+            new Endpoint(
+                'rsf-' + regionId + '.qbox.me',
+                endpointOptions
+            )
+        ],
+        [SERVICE_NAME.API]: [
+            new Endpoint(
+                'api-' + regionId + '.qiniuapi.com',
+                endpointOptions
+            ),
+            new Endpoint(
+                'api-' + regionId + '.qbox.me',
+                endpointOptions
+            )
+        ],
+        [SERVICE_NAME.S3]: [
+            new Endpoint(
+                's3.' + s3RegionId + '.qiniucs.com',
+                endpointOptions
+            )
+        ]
+    };
+
+    services = Object.assign(services, options.extendedServices || {});
+
+    return new Region({
+        regionId: regionId,
+        s3RegionId: s3RegionId,
+        services: services,
+        ttl: ttl,
+        createTime: createTime
+    });
+};
+
+/**
+ * @param {Region} regions
+ * @returns {Region}
+ */
+Region.merge = function (...regions) {
+    const [source, ...rest] = regions;
+    const target = source.clone();
+    rest.forEach(s => {
+    // use Object.values when min version of Node.js update to ≥ v7.5.0
+        Object.keys(s.services).forEach(n => {
+            if (!target.services[n]) {
+                target.services[n] = s.services[n].map(endpoint => endpoint.clone());
+                return;
+            }
+            s.services[n].forEach(endpoint => {
+                if (!target.services[n].some(existsEndpoint => existsEndpoint.getValue() === endpoint.getValue())) {
+                    target.services[n].push(endpoint.clone());
+                }
+            });
+        });
+    });
+    return target;
+};
+
+/**
+ * @returns {Promise<Region[]>}
+ */
+Region.prototype.getRegions = function () {
+    return Promise.resolve([this]);
+};
+
+Region.prototype.clone = function () {
+    // use Object.entries when min version of Node.js update to ≥ v7.5.0
+    const services = Object.keys(this.services).reduce((s, n) => {
+        s[n] = this.services[n].map(endpoint => endpoint.clone());
+        return s;
+    }, {});
+    return new Region({
+        regionId: this.regionId,
+        s3RegionId: this.s3RegionId,
+        services: services,
+        ttl: this.ttl,
+        createTime: this.createTime
+    });
+};
+
+/**
+ * @param {Region} regions
+ * @returns {Region}
+ */
+Region.prototype.merge = function (...regions) {
+    return Region.merge(this, ...regions);
+};
+
+Object.defineProperty(Region.prototype, 'isLive', {
+    /**
+     * @returns {boolean}
+     */
+    get: function () {
+        if (this.ttl < 0) {
+            return true;
+        }
+        // convert ms to s
+        const liveTime = Math.round((Date.now() - this.createTime) / 1000);
+        return liveTime < this.ttl;
+    },
+    enumerable: false,
+    configurable: true
+});
+
+exports.SERVICE_NAME = SERVICE_NAME;
+exports.Region = Region;