apify-client 2.23.5-beta.25 → 2.23.5-beta.27

package/dist/bundle.js

@@ -13221,13 +13221,13 @@ function ensureHeadersPrototype(config) {
         return typeof value === 'function' ? value.toString() : value;
     });
 }
-async function maybeGzipRequest(config) {
+async function maybeCompressRequest(config) {
     if (config.headers?.['content-encoding']) return config;
-    const maybeZippedData = await (0,_utils__rspack_import_2.maybeGzipValue)(config.data);
-    if (maybeZippedData) {
+    const maybeCompressed = await (0,_utils__rspack_import_2.maybeCompressValue)(config.data);
+    if (maybeCompressed) {
         config.headers ??= {};
-        config.headers['content-encoding'] = 'gzip';
-        config.data = maybeZippedData;
+        config.headers['content-encoding'] = maybeCompressed.encoding;
+        config.data = maybeCompressed.data;
     }
     return config;
 }
@@ -13253,7 +13253,7 @@ function parseResponseData(response) {
     return response;
 }
 const requestInterceptors = [
-    maybeGzipRequest,
+    maybeCompressRequest,
     serializeRequest,
     ensureHeadersPrototype
 ];
@@ -13514,7 +13514,7 @@ __webpack_require__.r(__webpack_exports__);
      *                         (e.g., `'latest'` or `'1.2.345'`). If not provided, uses the default build.
      * @param options.contentType - Content type of the input. If specified, input must be a string or Buffer.
      * @returns `true` if the input is valid. Invalid input causes the underlying API call to throw an `ApifyApiError`.
-     * @see https://docs.apify.com/api/v2/act-input-validate-post
+     * @see https://docs.apify.com/api/v2/act-validate-input-post
      *
      * @example
      * ```javascript
@@ -17961,7 +17961,7 @@ let _computedKey;
 const NOT_FOUND_STATUS_CODE = 404;
 const RECORD_NOT_FOUND_TYPE = 'record-not-found';
 const RECORD_OR_TOKEN_NOT_FOUND_TYPE = 'record-or-token-not-found';
-const MIN_GZIP_BYTES = 1024;
+const MIN_COMPRESS_BYTES = 1024;
 /**
  * Returns object's 'data' property or throws if parameter is not an object,
  * or an object without a 'data' property.
@@ -18031,23 +18031,61 @@ const MIN_GZIP_BYTES = 1024;
 }
 let gzipPromisified;
 /**
- * Gzip provided value, otherwise returns undefined.
- */ async function maybeGzipValue(value) {
-    if (!isNode()) return;
-    if (typeof value !== 'string' && !Buffer.isBuffer(value)) return;
-    // Request compression is not that important so let's
-    // skip it instead of throwing for unsupported types.
-    const areDataLargeEnough = Buffer.byteLength(value) >= MIN_GZIP_BYTES;
-    if (areDataLargeEnough) {
-        if (!gzipPromisified) {
-            const { promisify } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 6029, 23));
-            const { gzip } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 1134, 23));
-            gzipPromisified = promisify(gzip);
+ * Gzip-compress the provided value.
+ */ async function gzipValue(value) {
+    if (!gzipPromisified) {
+        const { promisify } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 6029, 23));
+        const { gzip } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 1134, 23));
+        gzipPromisified = promisify(gzip);
+    }
+    return gzipPromisified(value);
+}
+// null = confirmed unavailable; undefined = not yet checked
+let brotliCompressPromisified;
+/**
+ * Brotli-compress the provided value, or return undefined if brotli is unavailable
+ * (Node.js < v10.16.0), this is a strict defensive guard.
+ */ async function maybeBrotliValue(value) {
+    if (brotliCompressPromisified === undefined) {
+        const { promisify } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 6029, 23));
+        const { brotliCompress, constants } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 1134, 23));
+        if (typeof brotliCompress === 'function') {
+            const compress = promisify(brotliCompress);
+            brotliCompressPromisified = async (value)=>compress(value, {
+                    params: {
+                        [constants.BROTLI_PARAM_QUALITY]: 6
+                    }
+                });
+        } else {
+            brotliCompressPromisified = null;
         }
-        return gzipPromisified(value);
+    }
+    if (brotliCompressPromisified !== null) {
+        return brotliCompressPromisified(value);
     }
     return undefined;
 }
+/**
+ * Compress the passed value using brotli if available or using gzip as a fallback. Returns undefined
+ * if the data is too small / wrong type.
+ */ async function maybeCompressValue(value) {
+    if (!isNode()) return undefined;
+    // Request compression is not that important so let's
+    // skip it instead of throwing for unsupported types.
+    if (typeof value !== 'string' && !Buffer.isBuffer(value)) return undefined;
+    const areDataLargeEnough = Buffer.byteLength(value) >= MIN_COMPRESS_BYTES;
+    if (!areDataLargeEnough) return undefined;
+    const brotli = await maybeBrotliValue(value);
+    if (brotli) return {
+        data: brotli,
+        encoding: 'br'
+    };
+    const gzipped = await gzipValue(value);
+    return {
+        data: gzipped,
+        encoding: 'gzip'
+    };
+}
 /**
  * Helper function slice the items from array to fit the max byte length.
  */ function sliceArrayByByteLength(array, maxByteLength, startIndex) {
@@ -18084,7 +18122,7 @@ function isStream(value) {
 function getVersionData() {
     if (true) {
         return {
-            version: "2.23.5-beta.25"
+            version: "2.23.5-beta.27"
         };
     }
     // eslint-disable-next-line
@@ -18179,7 +18217,7 @@ __webpack_require__.d(__webpack_exports__, {
   isBuffer: () => (isBuffer),
   isNode: () => (isNode),
   isStream: () => (isStream),
-  maybeGzipValue: () => (maybeGzipValue),
+  maybeCompressValue: () => (maybeCompressValue),
   parseDateFields: () => (parseDateFields),
   pluckData: () => (pluckData),
   sliceArrayByByteLength: () => (sliceArrayByByteLength),