@qqbrowser/openclaw-qbot 0.10.17 → 0.10.19

package/node_modules/@slack/web-api/dist/WebClient.js

@@ -32,6 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -182,60 +191,62 @@ class WebClient extends methods_1.Methods {
      * @param method - the Web API method to call {@link https://docs.slack.dev/reference/methods}
      * @param options - options
      */
-    async apiCall(method, options = {}) {
-        this.logger.debug(`apiCall('${method}') start`);
-        warnDeprecations(method, this.logger);
-        warnIfFallbackIsMissing(method, this.logger, options);
-        warnIfThreadTsIsNotString(method, this.logger, options);
-        if (typeof options === 'string' || typeof options === 'number' || typeof options === 'boolean') {
-            throw new TypeError(`Expected an options argument but instead received a ${typeof options}`);
-        }
-        (0, file_upload_1.warnIfNotUsingFilesUploadV2)(method, this.logger);
-        // @ts-expect-error insufficient overlap between Record and FilesUploadV2Arguments
-        if (method === 'files.uploadV2')
-            return this.filesUploadV2(options);
-        const headers = {};
-        if (options.token)
-            headers.Authorization = `Bearer ${options.token}`;
-        const url = this.deriveRequestUrl(method);
-        const response = await this.makeRequest(url, Object.assign({ team_id: this.teamId }, options), headers);
-        const result = await this.buildResult(response);
-        this.logger.debug(`http request result: ${JSON.stringify(result)}`);
-        // log warnings in response metadata
-        if (result.response_metadata !== undefined && result.response_metadata.warnings !== undefined) {
-            result.response_metadata.warnings.forEach(this.logger.warn.bind(this.logger));
-        }
-        // log warnings and errors in response metadata messages
-        // related to https://docs.slack.dev/changelog/2016/09/28/response-metadata-is-on-the-way
-        if (result.response_metadata !== undefined && result.response_metadata.messages !== undefined) {
-            for (const msg of result.response_metadata.messages) {
-                const errReg = /\[ERROR\](.*)/;
-                const warnReg = /\[WARN\](.*)/;
-                if (errReg.test(msg)) {
-                    const errMatch = msg.match(errReg);
-                    if (errMatch != null) {
-                        this.logger.error(errMatch[1].trim());
+    apiCall(method_1) {
+        return __awaiter(this, arguments, void 0, function* (method, options = {}) {
+            this.logger.debug(`apiCall('${method}') start`);
+            warnDeprecations(method, this.logger);
+            warnIfFallbackIsMissing(method, this.logger, options);
+            warnIfThreadTsIsNotString(method, this.logger, options);
+            if (typeof options === 'string' || typeof options === 'number' || typeof options === 'boolean') {
+                throw new TypeError(`Expected an options argument but instead received a ${typeof options}`);
+            }
+            (0, file_upload_1.warnIfNotUsingFilesUploadV2)(method, this.logger);
+            // @ts-expect-error insufficient overlap between Record and FilesUploadV2Arguments
+            if (method === 'files.uploadV2')
+                return this.filesUploadV2(options);
+            const headers = {};
+            if (options.token)
+                headers.Authorization = `Bearer ${options.token}`;
+            const url = this.deriveRequestUrl(method);
+            const response = yield this.makeRequest(url, Object.assign({ team_id: this.teamId }, options), headers);
+            const result = yield this.buildResult(response);
+            this.logger.debug(`http request result: ${JSON.stringify(result)}`);
+            // log warnings in response metadata
+            if (result.response_metadata !== undefined && result.response_metadata.warnings !== undefined) {
+                result.response_metadata.warnings.forEach(this.logger.warn.bind(this.logger));
+            }
+            // log warnings and errors in response metadata messages
+            // related to https://docs.slack.dev/changelog/2016/09/28/response-metadata-is-on-the-way
+            if (result.response_metadata !== undefined && result.response_metadata.messages !== undefined) {
+                for (const msg of result.response_metadata.messages) {
+                    const errReg = /\[ERROR\](.*)/;
+                    const warnReg = /\[WARN\](.*)/;
+                    if (errReg.test(msg)) {
+                        const errMatch = msg.match(errReg);
+                        if (errMatch != null) {
+                            this.logger.error(errMatch[1].trim());
+                        }
                     }
-                }
-                else if (warnReg.test(msg)) {
-                    const warnMatch = msg.match(warnReg);
-                    if (warnMatch != null) {
-                        this.logger.warn(warnMatch[1].trim());
+                    else if (warnReg.test(msg)) {
+                        const warnMatch = msg.match(warnReg);
+                        if (warnMatch != null) {
+                            this.logger.warn(warnMatch[1].trim());
+                        }
                     }
                 }
             }
-        }
-        // If result's content is gzip, "ok" property is not returned with successful response
-        // TODO: look into simplifying this code block to only check for the second condition
-        // if an { ok: false } body applies for all API errors
-        if (!result.ok && response.headers['content-type'] !== 'application/gzip') {
-            throw (0, errors_1.platformErrorFromResult)(result);
-        }
-        if ('ok' in result && result.ok === false) {
-            throw (0, errors_1.platformErrorFromResult)(result);
-        }
-        this.logger.debug(`apiCall('${method}') end`);
-        return result;
+            // If result's content is gzip, "ok" property is not returned with successful response
+            // TODO: look into simplifying this code block to only check for the second condition
+            // if an { ok: false } body applies for all API errors
+            if (!result.ok && response.headers['content-type'] !== 'application/gzip') {
+                throw (0, errors_1.platformErrorFromResult)(result);
+            }
+            if ('ok' in result && result.ok === false) {
+                throw (0, errors_1.platformErrorFromResult)(result);
+            }
+            this.logger.debug(`apiCall('${method}') end`);
+            return result;
+        });
     }
     paginate(method, options, shouldStop, reduce) {
         const pageSize = (() => {
@@ -270,14 +281,14 @@ class WebClient extends methods_1.Methods {
         }
         const pageReducer = reduce !== undefined ? reduce : noopPageReducer;
         let index = 0;
-        return (async () => {
+        return (() => __awaiter(this, void 0, void 0, function* () {
             // Unroll the first iteration of the iterator
             // This is done primarily because in order to satisfy the type system, we need a variable that is typed as A
             // (shown as accumulator before), but before the first iteration all we have is a variable typed A | undefined.
             // Unrolling the first iteration allows us to deal with undefined as a special case.
             var _a, e_1, _b, _c;
             const pageIterator = generatePages.call(this);
-            const firstIteratorResult = await pageIterator.next(undefined);
+            const firstIteratorResult = yield pageIterator.next(undefined);
             // Assumption: there will always be at least one result in a paginated API request
             // if (firstIteratorResult.done) { return; }
             const firstPage = firstIteratorResult.value;
@@ -288,7 +299,7 @@ class WebClient extends methods_1.Methods {
             }
             try {
                 // Continue iteration
-                for (var _d = true, pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = await pageIterator_1.next(), _a = pageIterator_1_1.done, !_a; _d = true) {
+                for (var _d = true, pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = yield pageIterator_1.next(), _a = pageIterator_1_1.done, !_a; _d = true) {
                     _c = pageIterator_1_1.value;
                     _d = false;
                     const page = _c;
@@ -302,12 +313,12 @@ class WebClient extends methods_1.Methods {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = pageIterator_1.return)) await _b.call(pageIterator_1);
+                    if (!_d && !_a && (_b = pageIterator_1.return)) yield _b.call(pageIterator_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
             return accumulator;
-        })();
+        }))();
     }
     /**
      * Stream markdown text into a conversation.
@@ -355,21 +366,23 @@ class WebClient extends methods_1.Methods {
      * **#3**: Complete uploads {@link https://docs.slack.dev/reference/methods/files.completeuploadexternal files.completeUploadExternal}
      * @param options
      */
-    async filesUploadV2(options) {
-        this.logger.debug('files.uploadV2() start');
-        // 1
-        const fileUploads = await this.getAllFileUploads(options);
-        const fileUploadsURLRes = await this.fetchAllUploadURLExternal(fileUploads);
-        // set the upload_url and file_id returned from Slack
-        fileUploadsURLRes.forEach((res, idx) => {
-            fileUploads[idx].upload_url = res.upload_url;
-            fileUploads[idx].file_id = res.file_id;
+    filesUploadV2(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug('files.uploadV2() start');
+            // 1
+            const fileUploads = yield this.getAllFileUploads(options);
+            const fileUploadsURLRes = yield this.fetchAllUploadURLExternal(fileUploads);
+            // set the upload_url and file_id returned from Slack
+            fileUploadsURLRes.forEach((res, idx) => {
+                fileUploads[idx].upload_url = res.upload_url;
+                fileUploads[idx].file_id = res.file_id;
+            });
+            // 2
+            yield this.postFileUploadsToExternalURL(fileUploads, options);
+            // 3
+            const completion = yield this.completeFileUploads(fileUploads);
+            return { ok: true, files: completion };
         });
-        // 2
-        await this.postFileUploadsToExternalURL(fileUploads, options);
-        // 3
-        const completion = await this.completeFileUploads(fileUploads);
-        return { ok: true, files: completion };
     }
     /**
      * For each file submitted with this method, submits filenames
@@ -377,148 +390,158 @@ class WebClient extends methods_1.Methods {
      * which to send the file data to and an id for the file
      * @param fileUploads
      */
-    async fetchAllUploadURLExternal(fileUploads) {
-        return Promise.all(fileUploads.map((upload) => {
-            const options = {
-                filename: upload.filename,
-                length: upload.length,
-                alt_text: upload.alt_text,
-                snippet_type: upload.snippet_type,
-            };
-            if ('token' in upload) {
-                options.token = upload.token;
-            }
-            return this.files.getUploadURLExternal(options);
-        }));
+    fetchAllUploadURLExternal(fileUploads) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(fileUploads.map((upload) => {
+                const options = {
+                    filename: upload.filename,
+                    length: upload.length,
+                    alt_text: upload.alt_text,
+                    snippet_type: upload.snippet_type,
+                };
+                if ('token' in upload) {
+                    options.token = upload.token;
+                }
+                return this.files.getUploadURLExternal(options);
+            }));
+        });
     }
     /**
      * Complete uploads.
      * @param fileUploads
      * @returns
      */
-    async completeFileUploads(fileUploads) {
-        const toComplete = Object.values((0, file_upload_1.getAllFileUploadsToComplete)(fileUploads));
-        return Promise.all(toComplete.map((job) => this.files.completeUploadExternal(job)));
+    completeFileUploads(fileUploads) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toComplete = Object.values((0, file_upload_1.getAllFileUploadsToComplete)(fileUploads));
+            return Promise.all(toComplete.map((job) => this.files.completeUploadExternal(job)));
+        });
     }
     /**
      * for each returned file upload URL, upload corresponding file
      * @param fileUploads
      * @returns
      */
-    async postFileUploadsToExternalURL(fileUploads, options) {
-        return Promise.all(fileUploads.map(async (upload) => {
-            const { upload_url, file_id, filename, data } = upload;
-            // either file or content will be defined
-            const body = data;
-            // try to post to external url
-            if (upload_url) {
-                const headers = {};
-                if (options.token)
-                    headers.Authorization = `Bearer ${options.token}`;
-                const uploadRes = await this.makeRequest(upload_url, {
-                    body,
-                }, headers);
-                if (uploadRes.status !== 200) {
-                    return Promise.reject(Error(`Failed to upload file (id:${file_id}, filename: ${filename})`));
+    postFileUploadsToExternalURL(fileUploads, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(fileUploads.map((upload) => __awaiter(this, void 0, void 0, function* () {
+                const { upload_url, file_id, filename, data } = upload;
+                // either file or content will be defined
+                const body = data;
+                // try to post to external url
+                if (upload_url) {
+                    const headers = {};
+                    if (options.token)
+                        headers.Authorization = `Bearer ${options.token}`;
+                    const uploadRes = yield this.makeRequest(upload_url, {
+                        body,
+                    }, headers);
+                    if (uploadRes.status !== 200) {
+                        return Promise.reject(Error(`Failed to upload file (id:${file_id}, filename: ${filename})`));
+                    }
+                    const returnData = { ok: true, body: uploadRes.data };
+                    return Promise.resolve(returnData);
                 }
-                const returnData = { ok: true, body: uploadRes.data };
-                return Promise.resolve(returnData);
-            }
-            return Promise.reject(Error(`No upload url found for file (id: ${file_id}, filename: ${filename}`));
-        }));
+                return Promise.reject(Error(`No upload url found for file (id: ${file_id}, filename: ${filename}`));
+            })));
+        });
     }
     /**
      * @param options All file uploads arguments
      * @returns An array of file upload entries
      */
-    async getAllFileUploads(options) {
-        let fileUploads = [];
-        // add single file data to uploads if file or content exists at the top level
-        if ('file' in options || 'content' in options) {
-            fileUploads.push(await (0, file_upload_1.getFileUploadJob)(options, this.logger));
-        }
-        // add multiple files data when file_uploads is supplied
-        if ('file_uploads' in options) {
-            fileUploads = fileUploads.concat(await (0, file_upload_1.getMultipleFileUploadJobs)(options, this.logger));
-        }
-        return fileUploads;
+    getAllFileUploads(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let fileUploads = [];
+            // add single file data to uploads if file or content exists at the top level
+            if ('file' in options || 'content' in options) {
+                fileUploads.push(yield (0, file_upload_1.getFileUploadJob)(options, this.logger));
+            }
+            // add multiple files data when file_uploads is supplied
+            if ('file_uploads' in options) {
+                fileUploads = fileUploads.concat(yield (0, file_upload_1.getMultipleFileUploadJobs)(options, this.logger));
+            }
+            return fileUploads;
+        });
     }
     /**
      * Low-level function to make a single API request. handles queuing, retries, and http-level errors
      */
-    async makeRequest(url, body, headers = {}) {
-        // TODO: better input types - remove any
-        const task = () => this.requestQueue.add(async () => {
-            try {
-                // biome-ignore lint/suspicious/noExplicitAny: TODO: type this
-                const config = Object.assign({ headers }, this.tlsConfig);
-                // admin.analytics.getFile returns a binary response
-                // To be able to parse it, it should be read as an ArrayBuffer
-                if (url.endsWith('admin.analytics.getFile')) {
-                    config.responseType = 'arraybuffer';
-                }
-                // apps.event.authorizations.list will reject HTTP requests that send token in the body
-                // TODO: consider applying this change to all methods - though that will require thorough integration testing
-                if (url.endsWith('apps.event.authorizations.list')) {
-                    body.token = undefined;
-                }
-                this.logger.debug(`http request url: ${url}`);
-                this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
-                // compile all headers - some set by default under the hood by axios - that will be sent along
-                let allHeaders = Object.keys(this.axios.defaults.headers).reduce((acc, cur) => {
-                    if (!axiosHeaderPropsToIgnore.includes(cur)) {
-                        acc[cur] = this.axios.defaults.headers[cur];
+    makeRequest(url_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (url, body, headers = {}) {
+            // TODO: better input types - remove any
+            const task = () => this.requestQueue.add(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // biome-ignore lint/suspicious/noExplicitAny: TODO: type this
+                    const config = Object.assign({ headers }, this.tlsConfig);
+                    // admin.analytics.getFile returns a binary response
+                    // To be able to parse it, it should be read as an ArrayBuffer
+                    if (url.endsWith('admin.analytics.getFile')) {
+                        config.responseType = 'arraybuffer';
                     }
-                    return acc;
-                }, {});
-                allHeaders = Object.assign(Object.assign(Object.assign({}, this.axios.defaults.headers.common), allHeaders), headers);
-                this.logger.debug(`http request headers: ${JSON.stringify(redact(allHeaders))}`);
-                const response = await this.axios.post(url, body, config);
-                this.logger.debug('http response received');
-                if (response.status === 429) {
-                    const retrySec = parseRetryHeaders(response);
-                    if (retrySec !== undefined) {
-                        this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
-                        if (this.rejectRateLimitedCalls) {
-                            throw new p_retry_1.AbortError((0, errors_1.rateLimitedErrorWithDelay)(retrySec));
+                    // apps.event.authorizations.list will reject HTTP requests that send token in the body
+                    // TODO: consider applying this change to all methods - though that will require thorough integration testing
+                    if (url.endsWith('apps.event.authorizations.list')) {
+                        body.token = undefined;
+                    }
+                    this.logger.debug(`http request url: ${url}`);
+                    this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
+                    // compile all headers - some set by default under the hood by axios - that will be sent along
+                    let allHeaders = Object.keys(this.axios.defaults.headers).reduce((acc, cur) => {
+                        if (!axiosHeaderPropsToIgnore.includes(cur)) {
+                            acc[cur] = this.axios.defaults.headers[cur];
+                        }
+                        return acc;
+                    }, {});
+                    allHeaders = Object.assign(Object.assign(Object.assign({}, this.axios.defaults.headers.common), allHeaders), headers);
+                    this.logger.debug(`http request headers: ${JSON.stringify(redact(allHeaders))}`);
+                    const response = yield this.axios.post(url, body, config);
+                    this.logger.debug('http response received');
+                    if (response.status === 429) {
+                        const retrySec = parseRetryHeaders(response);
+                        if (retrySec !== undefined) {
+                            this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
+                            if (this.rejectRateLimitedCalls) {
+                                throw new p_retry_1.AbortError((0, errors_1.rateLimitedErrorWithDelay)(retrySec));
+                            }
+                            this.logger.info(`API Call failed due to rate limiting. Will retry in ${retrySec} seconds.`);
+                            // pause the request queue and then delay the rejection by the amount of time in the retry header
+                            this.requestQueue.pause();
+                            // NOTE: if there was a way to introspect the current RetryOperation and know what the next timeout
+                            // would be, then we could subtract that time from the following delay, knowing that it the next
+                            // attempt still wouldn't occur until after the rate-limit header has specified. an even better
+                            // solution would be to subtract the time from only the timeout of this next attempt of the
+                            // RetryOperation. this would result in the staying paused for the entire duration specified in the
+                            // header, yet this operation not having to pay the timeout cost in addition to that.
+                            yield (0, helpers_1.default)(retrySec * 1000);
+                            // resume the request queue and throw a non-abort error to signal a retry
+                            this.requestQueue.start();
+                            // TODO: We may want to have more detailed info such as team_id, params except tokens, and so on.
+                            throw new Error(`A rate limit was exceeded (url: ${url}, retry-after: ${retrySec})`);
                         }
-                        this.logger.info(`API Call failed due to rate limiting. Will retry in ${retrySec} seconds.`);
-                        // pause the request queue and then delay the rejection by the amount of time in the retry header
-                        this.requestQueue.pause();
-                        // NOTE: if there was a way to introspect the current RetryOperation and know what the next timeout
-                        // would be, then we could subtract that time from the following delay, knowing that it the next
-                        // attempt still wouldn't occur until after the rate-limit header has specified. an even better
-                        // solution would be to subtract the time from only the timeout of this next attempt of the
-                        // RetryOperation. this would result in the staying paused for the entire duration specified in the
-                        // header, yet this operation not having to pay the timeout cost in addition to that.
-                        await (0, helpers_1.default)(retrySec * 1000);
-                        // resume the request queue and throw a non-abort error to signal a retry
-                        this.requestQueue.start();
-                        // TODO: We may want to have more detailed info such as team_id, params except tokens, and so on.
-                        throw new Error(`A rate limit was exceeded (url: ${url}, retry-after: ${retrySec})`);
+                        // TODO: turn this into some CodedError
+                        throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers['retry-after']})`));
                     }
-                    // TODO: turn this into some CodedError
-                    throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers['retry-after']})`));
-                }
-                // Slack's Web API doesn't use meaningful status codes besides 429 and 200
-                if (response.status !== 200) {
-                    throw (0, errors_1.httpErrorFromResponse)(response);
+                    // Slack's Web API doesn't use meaningful status codes besides 429 and 200
+                    if (response.status !== 200) {
+                        throw (0, errors_1.httpErrorFromResponse)(response);
+                    }
+                    return response;
                 }
-                return response;
-            }
-            catch (error) {
-                // To make this compatible with tsd, casting here instead of `catch (error: any)`
-                // biome-ignore lint/suspicious/noExplicitAny: errors can be anything
-                const e = error;
-                this.logger.warn('http request failed', e.message);
-                if (e.request) {
-                    throw (0, errors_1.requestErrorWithOriginal)(e, this.attachOriginalToWebAPIRequestError);
+                catch (error) {
+                    // To make this compatible with tsd, casting here instead of `catch (error: any)`
+                    // biome-ignore lint/suspicious/noExplicitAny: errors can be anything
+                    const e = error;
+                    this.logger.warn('http request failed', e.message);
+                    if (e.request) {
+                        throw (0, errors_1.requestErrorWithOriginal)(e, this.attachOriginalToWebAPIRequestError);
+                    }
+                    throw error;
                 }
-                throw error;
-            }
+            }));
+            // biome-ignore lint/suspicious/noExplicitAny: http responses can be anything
+            return (0, p_retry_1.default)(task, this.retryConfig);
         });
-        // biome-ignore lint/suspicious/noExplicitAny: http responses can be anything
-        return (0, p_retry_1.default)(task, this.retryConfig);
     }
     /**
      * Get the complete request URL for the provided URL.
@@ -617,72 +640,74 @@ class WebClient extends methods_1.Methods {
      * HTTP headers into the object.
      * @param response - an http response
      */
-    async buildResult(response) {
-        let { data } = response;
-        const isGzipResponse = response.headers['content-type'] === 'application/gzip';
-        // Check for GZIP response - if so, it is a successful response from admin.analytics.getFile
-        if (isGzipResponse) {
-            // admin.analytics.getFile will return a Buffer that can be unzipped
-            try {
-                const unzippedData = await new Promise((resolve, reject) => {
-                    node_zlib_1.default.unzip(data, (err, buf) => {
-                        if (err) {
-                            return reject(err);
-                        }
-                        return resolve(buf.toString().split('\n'));
+    buildResult(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { data } = response;
+            const isGzipResponse = response.headers['content-type'] === 'application/gzip';
+            // Check for GZIP response - if so, it is a successful response from admin.analytics.getFile
+            if (isGzipResponse) {
+                // admin.analytics.getFile will return a Buffer that can be unzipped
+                try {
+                    const unzippedData = yield new Promise((resolve, reject) => {
+                        node_zlib_1.default.unzip(data, (err, buf) => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            return resolve(buf.toString().split('\n'));
+                        });
+                    })
+                        .then((res) => res)
+                        .catch((err) => {
+                        throw err;
                     });
-                })
-                    .then((res) => res)
-                    .catch((err) => {
-                    throw err;
-                });
-                const fileData = [];
-                if (Array.isArray(unzippedData)) {
-                    for (const dataset of unzippedData) {
-                        if (dataset && dataset.length > 0) {
-                            fileData.push(JSON.parse(dataset));
+                    const fileData = [];
+                    if (Array.isArray(unzippedData)) {
+                        for (const dataset of unzippedData) {
+                            if (dataset && dataset.length > 0) {
+                                fileData.push(JSON.parse(dataset));
+                            }
                         }
                     }
+                    data = { file_data: fileData };
+                }
+                catch (err) {
+                    data = { ok: false, error: err };
                 }
-                data = { file_data: fileData };
             }
-            catch (err) {
-                data = { ok: false, error: err };
+            else if (!isGzipResponse && response.request.path === '/api/admin.analytics.getFile') {
+                // if it isn't a Gzip response but is from the admin.analytics.getFile request,
+                // decode the ArrayBuffer to JSON read the error
+                data = JSON.parse(new node_util_1.TextDecoder().decode(data));
             }
-        }
-        else if (!isGzipResponse && response.request.path === '/api/admin.analytics.getFile') {
-            // if it isn't a Gzip response but is from the admin.analytics.getFile request,
-            // decode the ArrayBuffer to JSON read the error
-            data = JSON.parse(new node_util_1.TextDecoder().decode(data));
-        }
-        if (typeof data === 'string') {
-            // response.data can be a string, not an object for some reason
-            try {
-                data = JSON.parse(data);
+            if (typeof data === 'string') {
+                // response.data can be a string, not an object for some reason
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (_) {
+                    // failed to parse the string value as JSON data
+                    data = { ok: false, error: data };
+                }
             }
-            catch (_) {
-                // failed to parse the string value as JSON data
-                data = { ok: false, error: data };
+            if (data.response_metadata === undefined) {
+                data.response_metadata = {};
             }
-        }
-        if (data.response_metadata === undefined) {
-            data.response_metadata = {};
-        }
-        // add scopes metadata from headers
-        if (response.headers['x-oauth-scopes'] !== undefined) {
-            data.response_metadata.scopes = response.headers['x-oauth-scopes'].trim().split(/\s*,\s*/);
-        }
-        if (response.headers['x-accepted-oauth-scopes'] !== undefined) {
-            data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes']
-                .trim()
-                .split(/\s*,\s*/);
-        }
-        // add retry metadata from headers
-        const retrySec = parseRetryHeaders(response);
-        if (retrySec !== undefined) {
-            data.response_metadata.retryAfter = retrySec;
-        }
-        return data;
+            // add scopes metadata from headers
+            if (response.headers['x-oauth-scopes'] !== undefined) {
+                data.response_metadata.scopes = response.headers['x-oauth-scopes'].trim().split(/\s*,\s*/);
+            }
+            if (response.headers['x-accepted-oauth-scopes'] !== undefined) {
+                data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes']
+                    .trim()
+                    .split(/\s*,\s*/);
+            }
+            // add retry metadata from headers
+            const retrySec = parseRetryHeaders(response);
+            if (retrySec !== undefined) {
+                data.response_metadata.retryAfter = retrySec;
+            }
+            return data;
+        });
     }
 }
 exports.WebClient = WebClient;