apify-client 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/utils.js

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import { NotFoundError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
+import { runtime } from '#runtime';
 import { ResponseValidationError } from './response_validation_error.js';
 // @ts-ignore if we enable `resolveJsonModule`, we end up with a `src` folder in `dist`
 import packageJson from '../package.json' with { type: 'json' };
 const MIN_COMPRESS_BYTES = 1024;
+const textEncoder = new TextEncoder();
+// Only the version, so a bundler can drop the rest of the manifest.
+export const { version } = packageJson;
 /** Media type prefixes whose payloads carry their own compression, so compressing the request body is wasted work. */
 const ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES = ['audio/', 'image/', 'video/'];
 /** Exact media types whose payloads carry their own compression. */
@@ -126,39 +130,45 @@ export function catchNotFoundForResourceOrThrow(err, resourceId) {
 export function stringifyWebhooksToBase64(webhooks) {
     if (!webhooks)
         return;
-    const webhooksJson = JSON.stringify(webhooks);
-    if (isNode()) {
-        return Buffer.from(webhooksJson, 'utf8').toString('base64');
-    }
-    const encoder = new TextEncoder();
-    const uint8Array = encoder.encode(webhooksJson);
-    return btoa(String.fromCharCode(...uint8Array));
+    return bytesToBase64(textEncoder.encode(JSON.stringify(webhooks)));
 }
-let brotliCompressPromisified;
 /**
- * Brotli-compress the provided value.
+ * Encodes bytes as base64. `btoa()` takes a binary string, and the bytes are turned into one in slices,
+ * because spreading them all into a single `String.fromCharCode()` call overflows the argument limit on
+ * inputs of a few tens of kilobytes.
  */
-async function brotliValue(value) {
-    if (!brotliCompressPromisified) {
-        const { promisify } = await import('node:util');
-        const { brotliCompress, constants } = await import('node:zlib');
-        const compress = promisify(brotliCompress);
-        const options = { params: { [constants.BROTLI_PARAM_QUALITY]: 6 } };
-        brotliCompressPromisified = async (input) => compress(input, options);
+export function bytesToBase64(bytes) {
+    const SLICE_LENGTH = 0x8000;
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += SLICE_LENGTH) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + SLICE_LENGTH));
     }
-    return brotliCompressPromisified(value);
+    return btoa(binary);
 }
-let gzipPromisified;
 /**
- * Gzip-compress the provided value.
+ * Concatenates byte chunks into one array.
  */
-async function gzipValue(value) {
-    if (!gzipPromisified) {
-        const { promisify } = await import('node:util');
-        const { gzip } = await import('node:zlib');
-        gzipPromisified = promisify(gzip);
+export function concatBytes(chunks) {
+    const result = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
     }
-    return gzipPromisified(value);
+    return result;
+}
+/**
+ * Views a request body as bytes: a string is UTF-8 encoded, binary values are viewed in place. Anything else
+ * - a stream, a `Blob`, form data - is `undefined`.
+ */
+function toBytes(value) {
+    if (typeof value === 'string')
+        return textEncoder.encode(value);
+    if (!isBuffer(value))
+        return undefined;
+    return ArrayBuffer.isView(value)
+        ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+        : new Uint8Array(value);
 }
 /**
  * Decides whether a request body with the given content type is worth compressing.
@@ -183,40 +193,28 @@ export function isCompressibleContentType(contentType) {
     return !ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES.some((prefix) => mediaType.startsWith(prefix));
 }
 /**
- * Compress the passed value using brotli, falling back to gzip. Returns undefined if the data is
- * too small / wrong type, or if neither algorithm is available.
+ * Compresses the passed value with the runtime's best available algorithm. Returns `undefined` if the data
+ * is too small, is not a string or binary value, or if the runtime does not offer compression.
  */
 export 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)
+    const bytes = toBytes(value);
+    if (!bytes || bytes.byteLength < MIN_COMPRESS_BYTES)
         return undefined;
-    try {
-        return { data: await brotliValue(value), encoding: 'br' };
-    }
-    catch {
-        // Runtimes that only provide a partial `node:zlib` (bundler polyfills, edge runtimes with
-        // Node compatibility shims) may not implement brotli, but usually do implement gzip.
-    }
-    try {
-        return { data: await gzipValue(value), encoding: 'gzip' };
-    }
-    catch {
-        // Same reasoning as above: compression is a best-effort optimization, so skip it instead
-        // of failing the request.
-        return undefined;
-    }
+    return runtime.compress(bytes);
+}
+/**
+ * Reads an environment variable, on runtimes that have them.
+ */
+export function getEnv(name) {
+    return typeof process !== 'undefined' ? process.env?.[name] : undefined;
 }
 /**
  * Returns the UTF-8 byte length of a string.
  */
 export function utf8ByteLength(value) {
-    return isNode() ? Buffer.byteLength(value) : new Blob([value]).size;
+    return textEncoder.encode(value).byteLength;
 }
 /**
  * Splits JSON-serialized items into consecutive batches of at most `maxCount` items, each of which fits into a JSON
@@ -243,11 +241,6 @@ export function splitIntoJsonArrayBatches(items, { maxCount, maxByteLength }) {
         batches.push(batch);
     return batches;
 }
-export function isNode() {
-    if (typeof BROWSER_BUILD !== 'undefined')
-        return false;
-    return !!(typeof process !== 'undefined' && process.versions && process.versions.node);
-}
 export function isBuffer(value) {
     // Tag checks rather than `instanceof`, to also match buffers from another realm. `isView()`
     // additionally covers `DataView`, which is not raw binary content.
@@ -264,12 +257,6 @@ export function isStream(value) {
     const { on, pipe } = value;
     return typeof on === 'function' && typeof pipe === 'function';
 }
-export function getVersionData() {
-    if (typeof BROWSER_BUILD !== 'undefined') {
-        return { version: VERSION };
-    }
-    return packageJson;
-}
 /**
  * Helper class to create async iterators from paginated list endpoints.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.20",
+  "version": "3.0.0-beta.22",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.0.0"
@@ -10,6 +10,12 @@
   "types": "dist/index.d.ts",
   "browser": "dist/bundle.js",
   "unpkg": "dist/bundle.js",
+  "imports": {
+    "#runtime": {
+      "node": "./dist/runtime/node.js",
+      "default": "./dist/runtime/web.js"
+    }
+  },
   "exports": {
     "./package.json": "./package.json",
     "./browser": "./dist/bundle.js",