@adtrackify/at-service-common 3.18.11 → 3.18.13

package/dist/esm/types/shopify-rest-types.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=shopify-rest-types.js.map

package/dist/esm/utils/compression.d.ts

@@ -1,36 +1,36 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { CompressionAlgorithm } from '../clients/generic/sqs-bundled-client.types.js';
-export declare function getZstdUncompressedSize(buffer: Buffer): number | undefined;
-export declare function getGzipUncompressedSize(buffer: Buffer): number | undefined;
-export declare enum CompressionOperation {
-    COMPRESS = "compress",
-    DECOMPRESS = "decompress"
-}
-export declare function compress(data: Buffer, algorithm: CompressionAlgorithm, level?: number): Promise<Buffer>;
-export declare function decompress(data: Buffer, algorithm: CompressionAlgorithm): Promise<Buffer>;
-export declare function compressToBase64(data: unknown, algorithm: CompressionAlgorithm, level?: number): Promise<{
-    base64: string;
-    originalSize: number;
-    compressedSize: number;
-}>;
-export declare const DECOMPRESSION_LIMITS: {
-    readonly MAX_DECOMPRESSED_SIZE_BYTES: number;
-    readonly MAX_COMPRESSION_RATIO: 100;
-    readonly DEFAULT_TIMEOUT_MS: 30000;
-};
-export declare class DecompressionBombError extends Error {
-    readonly compressedSize: number;
-    readonly decompressedSize: number;
-    readonly limit: number;
-    constructor(compressedSize: number, decompressedSize: number, limit: number);
-}
-export declare class CompressionTimeoutError extends Error {
-    readonly operation: CompressionOperation;
-    readonly timeoutMs: number;
-    constructor(operation: CompressionOperation, timeoutMs: number);
-}
-export declare function decompressFromBase64<T>(base64: string, algorithm: CompressionAlgorithm, options?: {
-    maxDecompressedSizeBytes?: number;
-    timeoutMs?: number;
-}): Promise<T>;
+/// <reference types="node" />
+/// <reference types="node" />
+import { CompressionAlgorithm } from '../clients/generic/sqs-bundled-client.types.js';
+export declare function getZstdUncompressedSize(buffer: Buffer): number | undefined;
+export declare function getGzipUncompressedSize(buffer: Buffer): number | undefined;
+export declare enum CompressionOperation {
+    COMPRESS = "compress",
+    DECOMPRESS = "decompress"
+}
+export declare function compress(data: Buffer, algorithm: CompressionAlgorithm, level?: number): Promise<Buffer>;
+export declare function decompress(data: Buffer, algorithm: CompressionAlgorithm): Promise<Buffer>;
+export declare function compressToBase64(data: unknown, algorithm: CompressionAlgorithm, level?: number): Promise<{
+    base64: string;
+    originalSize: number;
+    compressedSize: number;
+}>;
+export declare const DECOMPRESSION_LIMITS: {
+    readonly MAX_DECOMPRESSED_SIZE_BYTES: number;
+    readonly MAX_COMPRESSION_RATIO: 100;
+    readonly DEFAULT_TIMEOUT_MS: 30000;
+};
+export declare class DecompressionBombError extends Error {
+    readonly compressedSize: number;
+    readonly decompressedSize: number;
+    readonly limit: number;
+    constructor(compressedSize: number, decompressedSize: number, limit: number);
+}
+export declare class CompressionTimeoutError extends Error {
+    readonly operation: CompressionOperation;
+    readonly timeoutMs: number;
+    constructor(operation: CompressionOperation, timeoutMs: number);
+}
+export declare function decompressFromBase64<T>(base64: string, algorithm: CompressionAlgorithm, options?: {
+    maxDecompressedSizeBytes?: number;
+    timeoutMs?: number;
+}): Promise<T>;

package/dist/esm/utils/compression.js

@@ -1,188 +1,188 @@
-import { promisify } from 'node:util';
-import { zstdCompress as zstdCompressCallback, zstdDecompress as zstdDecompressCallback, gunzip as gunzipCallback, constants, } from 'node:zlib';
-import { CompressionAlgorithm } from '../clients/generic/sqs-bundled-client.types.js';
-const zstdCompressNative = promisify(zstdCompressCallback);
-const zstdDecompressNative = promisify(zstdDecompressCallback);
-const gunzipNative = promisify(gunzipCallback);
-const ZSTD_MAGIC = 0xfd2fb528;
-const GZIP_MAGIC_BYTE_0 = 0x1f;
-const GZIP_MAGIC_BYTE_1 = 0x8b;
-const GZIP_MIN_SIZE = 18;
-export function getZstdUncompressedSize(buffer) {
-    if (buffer.length < 5) {
-        return undefined;
-    }
-    const magic = buffer.readUInt32LE(0);
-    if (magic !== ZSTD_MAGIC) {
-        return undefined;
-    }
-    const frameHeaderDescriptor = buffer[4];
-    if (frameHeaderDescriptor === undefined) {
-        return undefined;
-    }
-    const singleSegmentFlag = (frameHeaderDescriptor >> 5) & 0x01;
-    const contentSizeFlag = (frameHeaderDescriptor >> 6) & 0x03;
-    const dictionaryIdFlag = frameHeaderDescriptor & 0x03;
-    const dictIdSizes = [0, 1, 2, 4];
-    const dictIdSize = dictIdSizes[dictionaryIdFlag];
-    let fcsSize;
-    if (contentSizeFlag === 0) {
-        fcsSize = singleSegmentFlag === 1 ? 1 : 0;
-    }
-    else if (contentSizeFlag === 1) {
-        fcsSize = 2;
-    }
-    else if (contentSizeFlag === 2) {
-        fcsSize = 4;
-    }
-    else {
-        fcsSize = 8;
-    }
-    if (fcsSize === 0) {
-        return undefined;
-    }
-    const windowDescriptorSize = singleSegmentFlag === 1 ? 0 : 1;
-    const fcsOffset = 5 + windowDescriptorSize + dictIdSize;
-    if (buffer.length < fcsOffset + fcsSize) {
-        return undefined;
-    }
-    if (fcsSize === 1) {
-        return buffer.readUInt8(fcsOffset);
-    }
-    else if (fcsSize === 2) {
-        return buffer.readUInt16LE(fcsOffset) + 256;
-    }
-    else if (fcsSize === 4) {
-        return buffer.readUInt32LE(fcsOffset);
-    }
-    else {
-        const bigValue = buffer.readBigUInt64LE(fcsOffset);
-        if (bigValue > BigInt(Number.MAX_SAFE_INTEGER)) {
-            return Number.MAX_SAFE_INTEGER;
-        }
-        return Number(bigValue);
-    }
-}
-export function getGzipUncompressedSize(buffer) {
-    if (buffer.length < GZIP_MIN_SIZE) {
-        return undefined;
-    }
-    if (buffer[0] !== GZIP_MAGIC_BYTE_0 || buffer[1] !== GZIP_MAGIC_BYTE_1) {
-        return undefined;
-    }
-    return buffer.readUInt32LE(buffer.length - 4);
-}
-export var CompressionOperation;
-(function (CompressionOperation) {
-    CompressionOperation["COMPRESS"] = "compress";
-    CompressionOperation["DECOMPRESS"] = "decompress";
-})(CompressionOperation || (CompressionOperation = {}));
-export async function compress(data, algorithm, level = 3) {
-    switch (algorithm) {
-        case CompressionAlgorithm.NONE:
-            return data;
-        case CompressionAlgorithm.ZSTD:
-            return await zstdCompressNative(data, {
-                params: {
-                    [constants.ZSTD_c_compressionLevel]: level,
-                },
-            });
-        default:
-            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
-    }
-}
-export async function decompress(data, algorithm) {
-    switch (algorithm) {
-        case CompressionAlgorithm.NONE:
-            return data;
-        case CompressionAlgorithm.ZSTD:
-            return await zstdDecompressNative(data);
-        case CompressionAlgorithm.GZIP:
-            return await gunzipNative(data);
-        default:
-            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
-    }
-}
-export async function compressToBase64(data, algorithm, level = 3) {
-    const json = JSON.stringify(data);
-    const originalSize = Buffer.byteLength(json, 'utf8');
-    if (algorithm === CompressionAlgorithm.NONE) {
-        return { base64: '', originalSize, compressedSize: originalSize };
-    }
-    const compressed = await compress(Buffer.from(json, 'utf8'), algorithm, level);
-    const base64 = compressed.toString('base64');
-    return {
-        base64,
-        originalSize,
-        compressedSize: Buffer.byteLength(base64, 'utf8'),
-    };
-}
-export const DECOMPRESSION_LIMITS = {
-    MAX_DECOMPRESSED_SIZE_BYTES: 10 * 1024 * 1024,
-    MAX_COMPRESSION_RATIO: 100,
-    DEFAULT_TIMEOUT_MS: 30000,
-};
-export class DecompressionBombError extends Error {
-    compressedSize;
-    decompressedSize;
-    limit;
-    constructor(compressedSize, decompressedSize, limit) {
-        super(`Decompression bomb detected: ${decompressedSize} bytes exceeds limit of ${limit} bytes ` +
-            `(compression ratio: ${(decompressedSize / compressedSize).toFixed(1)}x)`);
-        this.compressedSize = compressedSize;
-        this.decompressedSize = decompressedSize;
-        this.limit = limit;
-        this.name = 'DecompressionBombError';
-    }
-}
-export class CompressionTimeoutError extends Error {
-    operation;
-    timeoutMs;
-    constructor(operation, timeoutMs) {
-        super(`${operation} operation timed out after ${timeoutMs}ms`);
-        this.operation = operation;
-        this.timeoutMs = timeoutMs;
-        this.name = 'CompressionTimeoutError';
-    }
-}
-async function withTimeout(operation, timeoutMs, operationName) {
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-            reject(new CompressionTimeoutError(operationName, timeoutMs));
-        }, timeoutMs);
-    });
-    try {
-        return await Promise.race([operation, timeoutPromise]);
-    }
-    finally {
-        if (timeoutId)
-            clearTimeout(timeoutId);
-    }
-}
-export async function decompressFromBase64(base64, algorithm, options) {
-    if (algorithm === CompressionAlgorithm.NONE) {
-        throw new Error('Cannot decompress NONE algorithm from base64');
-    }
-    const maxSize = options?.maxDecompressedSizeBytes ?? DECOMPRESSION_LIMITS.MAX_DECOMPRESSED_SIZE_BYTES;
-    const timeoutMs = options?.timeoutMs ?? DECOMPRESSION_LIMITS.DEFAULT_TIMEOUT_MS;
-    const compressed = Buffer.from(base64, 'base64');
-    if (algorithm === CompressionAlgorithm.ZSTD) {
-        const headerSize = getZstdUncompressedSize(compressed);
-        if (headerSize !== undefined && headerSize > maxSize) {
-            throw new DecompressionBombError(compressed.length, headerSize, maxSize);
-        }
-    }
-    if (algorithm === CompressionAlgorithm.GZIP) {
-        const headerSize = getGzipUncompressedSize(compressed);
-        if (headerSize !== undefined && headerSize > maxSize) {
-            throw new DecompressionBombError(compressed.length, headerSize, maxSize);
-        }
-    }
-    const decompressed = await withTimeout(decompress(compressed, algorithm), timeoutMs, CompressionOperation.DECOMPRESS);
-    if (decompressed.length > maxSize) {
-        throw new DecompressionBombError(compressed.length, decompressed.length, maxSize);
-    }
-    return JSON.parse(decompressed.toString('utf8'));
-}
+import { promisify } from 'node:util';
+import { zstdCompress as zstdCompressCallback, zstdDecompress as zstdDecompressCallback, gunzip as gunzipCallback, constants, } from 'node:zlib';
+import { CompressionAlgorithm } from '../clients/generic/sqs-bundled-client.types.js';
+const zstdCompressNative = promisify(zstdCompressCallback);
+const zstdDecompressNative = promisify(zstdDecompressCallback);
+const gunzipNative = promisify(gunzipCallback);
+const ZSTD_MAGIC = 0xfd2fb528;
+const GZIP_MAGIC_BYTE_0 = 0x1f;
+const GZIP_MAGIC_BYTE_1 = 0x8b;
+const GZIP_MIN_SIZE = 18;
+export function getZstdUncompressedSize(buffer) {
+    if (buffer.length < 5) {
+        return undefined;
+    }
+    const magic = buffer.readUInt32LE(0);
+    if (magic !== ZSTD_MAGIC) {
+        return undefined;
+    }
+    const frameHeaderDescriptor = buffer[4];
+    if (frameHeaderDescriptor === undefined) {
+        return undefined;
+    }
+    const singleSegmentFlag = (frameHeaderDescriptor >> 5) & 0x01;
+    const contentSizeFlag = (frameHeaderDescriptor >> 6) & 0x03;
+    const dictionaryIdFlag = frameHeaderDescriptor & 0x03;
+    const dictIdSizes = [0, 1, 2, 4];
+    const dictIdSize = dictIdSizes[dictionaryIdFlag];
+    let fcsSize;
+    if (contentSizeFlag === 0) {
+        fcsSize = singleSegmentFlag === 1 ? 1 : 0;
+    }
+    else if (contentSizeFlag === 1) {
+        fcsSize = 2;
+    }
+    else if (contentSizeFlag === 2) {
+        fcsSize = 4;
+    }
+    else {
+        fcsSize = 8;
+    }
+    if (fcsSize === 0) {
+        return undefined;
+    }
+    const windowDescriptorSize = singleSegmentFlag === 1 ? 0 : 1;
+    const fcsOffset = 5 + windowDescriptorSize + dictIdSize;
+    if (buffer.length < fcsOffset + fcsSize) {
+        return undefined;
+    }
+    if (fcsSize === 1) {
+        return buffer.readUInt8(fcsOffset);
+    }
+    else if (fcsSize === 2) {
+        return buffer.readUInt16LE(fcsOffset) + 256;
+    }
+    else if (fcsSize === 4) {
+        return buffer.readUInt32LE(fcsOffset);
+    }
+    else {
+        const bigValue = buffer.readBigUInt64LE(fcsOffset);
+        if (bigValue > BigInt(Number.MAX_SAFE_INTEGER)) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        return Number(bigValue);
+    }
+}
+export function getGzipUncompressedSize(buffer) {
+    if (buffer.length < GZIP_MIN_SIZE) {
+        return undefined;
+    }
+    if (buffer[0] !== GZIP_MAGIC_BYTE_0 || buffer[1] !== GZIP_MAGIC_BYTE_1) {
+        return undefined;
+    }
+    return buffer.readUInt32LE(buffer.length - 4);
+}
+export var CompressionOperation;
+(function (CompressionOperation) {
+    CompressionOperation["COMPRESS"] = "compress";
+    CompressionOperation["DECOMPRESS"] = "decompress";
+})(CompressionOperation || (CompressionOperation = {}));
+export async function compress(data, algorithm, level = 3) {
+    switch (algorithm) {
+        case CompressionAlgorithm.NONE:
+            return data;
+        case CompressionAlgorithm.ZSTD:
+            return await zstdCompressNative(data, {
+                params: {
+                    [constants.ZSTD_c_compressionLevel]: level,
+                },
+            });
+        default:
+            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+    }
+}
+export async function decompress(data, algorithm) {
+    switch (algorithm) {
+        case CompressionAlgorithm.NONE:
+            return data;
+        case CompressionAlgorithm.ZSTD:
+            return await zstdDecompressNative(data);
+        case CompressionAlgorithm.GZIP:
+            return await gunzipNative(data);
+        default:
+            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+    }
+}
+export async function compressToBase64(data, algorithm, level = 3) {
+    const json = JSON.stringify(data);
+    const originalSize = Buffer.byteLength(json, 'utf8');
+    if (algorithm === CompressionAlgorithm.NONE) {
+        return { base64: '', originalSize, compressedSize: originalSize };
+    }
+    const compressed = await compress(Buffer.from(json, 'utf8'), algorithm, level);
+    const base64 = compressed.toString('base64');
+    return {
+        base64,
+        originalSize,
+        compressedSize: Buffer.byteLength(base64, 'utf8'),
+    };
+}
+export const DECOMPRESSION_LIMITS = {
+    MAX_DECOMPRESSED_SIZE_BYTES: 10 * 1024 * 1024,
+    MAX_COMPRESSION_RATIO: 100,
+    DEFAULT_TIMEOUT_MS: 30000,
+};
+export class DecompressionBombError extends Error {
+    compressedSize;
+    decompressedSize;
+    limit;
+    constructor(compressedSize, decompressedSize, limit) {
+        super(`Decompression bomb detected: ${decompressedSize} bytes exceeds limit of ${limit} bytes ` +
+            `(compression ratio: ${(decompressedSize / compressedSize).toFixed(1)}x)`);
+        this.compressedSize = compressedSize;
+        this.decompressedSize = decompressedSize;
+        this.limit = limit;
+        this.name = 'DecompressionBombError';
+    }
+}
+export class CompressionTimeoutError extends Error {
+    operation;
+    timeoutMs;
+    constructor(operation, timeoutMs) {
+        super(`${operation} operation timed out after ${timeoutMs}ms`);
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+        this.name = 'CompressionTimeoutError';
+    }
+}
+async function withTimeout(operation, timeoutMs, operationName) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new CompressionTimeoutError(operationName, timeoutMs));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([operation, timeoutPromise]);
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+}
+export async function decompressFromBase64(base64, algorithm, options) {
+    if (algorithm === CompressionAlgorithm.NONE) {
+        throw new Error('Cannot decompress NONE algorithm from base64');
+    }
+    const maxSize = options?.maxDecompressedSizeBytes ?? DECOMPRESSION_LIMITS.MAX_DECOMPRESSED_SIZE_BYTES;
+    const timeoutMs = options?.timeoutMs ?? DECOMPRESSION_LIMITS.DEFAULT_TIMEOUT_MS;
+    const compressed = Buffer.from(base64, 'base64');
+    if (algorithm === CompressionAlgorithm.ZSTD) {
+        const headerSize = getZstdUncompressedSize(compressed);
+        if (headerSize !== undefined && headerSize > maxSize) {
+            throw new DecompressionBombError(compressed.length, headerSize, maxSize);
+        }
+    }
+    if (algorithm === CompressionAlgorithm.GZIP) {
+        const headerSize = getGzipUncompressedSize(compressed);
+        if (headerSize !== undefined && headerSize > maxSize) {
+            throw new DecompressionBombError(compressed.length, headerSize, maxSize);
+        }
+    }
+    const decompressed = await withTimeout(decompress(compressed, algorithm), timeoutMs, CompressionOperation.DECOMPRESS);
+    if (decompressed.length > maxSize) {
+        throw new DecompressionBombError(compressed.length, decompressed.length, maxSize);
+    }
+    return JSON.parse(decompressed.toString('utf8'));
+}
 //# sourceMappingURL=compression.js.map

package/dist/esm/utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from './size.js';
-export * from './compression.js';
-export * from './retry-envelope.js';
+export * from './size.js';
+export * from './compression.js';
+export * from './retry-envelope.js';

package/dist/esm/utils/index.js

@@ -1,4 +1,4 @@
-export * from './size.js';
-export * from './compression.js';
-export * from './retry-envelope.js';
+export * from './size.js';
+export * from './compression.js';
+export * from './retry-envelope.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/utils/retry-envelope.d.ts

@@ -1,12 +1,12 @@
-export interface RetryEnvelope<T> {
-    item: T;
-    retryCount: number;
-    firstFailedAt: string;
-    lastError: string;
-}
-export declare function isRetryEnvelope<T>(payload: unknown): payload is RetryEnvelope<T>;
-export declare function unwrapItem<T>(payload: T | RetryEnvelope<T>): {
-    item: T;
-    retryCount: number;
-};
-export declare function createRetryEnvelope<T>(item: T, currentRetryCount: number, originalPayload: T | RetryEnvelope<T>, error: unknown): RetryEnvelope<T>;
+export interface RetryEnvelope<T> {
+    item: T;
+    retryCount: number;
+    firstFailedAt: string;
+    lastError: string;
+}
+export declare function isRetryEnvelope<T>(payload: unknown): payload is RetryEnvelope<T>;
+export declare function unwrapItem<T>(payload: T | RetryEnvelope<T>): {
+    item: T;
+    retryCount: number;
+};
+export declare function createRetryEnvelope<T>(item: T, currentRetryCount: number, originalPayload: T | RetryEnvelope<T>, error: unknown): RetryEnvelope<T>;

package/dist/esm/utils/retry-envelope.js

@@ -1,23 +1,23 @@
-export function isRetryEnvelope(payload) {
-    return (typeof payload === 'object' &&
-        payload !== null &&
-        'item' in payload &&
-        'retryCount' in payload &&
-        typeof payload.retryCount === 'number');
-}
-export function unwrapItem(payload) {
-    if (isRetryEnvelope(payload)) {
-        return { item: payload.item, retryCount: payload.retryCount };
-    }
-    return { item: payload, retryCount: 0 };
-}
-export function createRetryEnvelope(item, currentRetryCount, originalPayload, error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-        item,
-        retryCount: currentRetryCount + 1,
-        firstFailedAt: isRetryEnvelope(originalPayload) ? originalPayload.firstFailedAt : new Date().toISOString(),
-        lastError: errorMessage,
-    };
-}
+export function isRetryEnvelope(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        'item' in payload &&
+        'retryCount' in payload &&
+        typeof payload.retryCount === 'number');
+}
+export function unwrapItem(payload) {
+    if (isRetryEnvelope(payload)) {
+        return { item: payload.item, retryCount: payload.retryCount };
+    }
+    return { item: payload, retryCount: 0 };
+}
+export function createRetryEnvelope(item, currentRetryCount, originalPayload, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+        item,
+        retryCount: currentRetryCount + 1,
+        firstFailedAt: isRetryEnvelope(originalPayload) ? originalPayload.firstFailedAt : new Date().toISOString(),
+        lastError: errorMessage,
+    };
+}
 //# sourceMappingURL=retry-envelope.js.map

package/dist/esm/utils/size.d.ts

@@ -1,2 +1,2 @@
-export declare function sizeInBytes(obj: unknown): number;
-export declare function chunkArrayBySize<T>(array: T[], maxChunkSizeBytes: number, maxItemsPerChunk?: number): T[][];
+export declare function sizeInBytes(obj: unknown): number;
+export declare function chunkArrayBySize<T>(array: T[], maxChunkSizeBytes: number, maxItemsPerChunk?: number): T[][];

package/dist/esm/utils/size.js

@@ -1,45 +1,45 @@
-import { Logger } from '../helpers/logging-helper.js';
-export function sizeInBytes(obj) {
-    try {
-        return new TextEncoder().encode(JSON.stringify(obj)).length;
-    }
-    catch (error) {
-        Logger.warn('sizeInBytes: failed to stringify object, returning fallback size', {
-            error,
-            objectType: typeof obj,
-        });
-        return 1024 * 1024;
-    }
-}
-export function chunkArrayBySize(array, maxChunkSizeBytes, maxItemsPerChunk) {
-    const chunks = [];
-    let currentChunk = [];
-    let currentChunkSize = 0;
-    for (const item of array) {
-        const itemSize = sizeInBytes(item);
-        const arrayOverhead = 2 + Math.max(0, currentChunk.length);
-        const wouldExceedSize = currentChunkSize + itemSize + arrayOverhead > maxChunkSizeBytes;
-        const wouldExceedCount = maxItemsPerChunk !== undefined && currentChunk.length >= maxItemsPerChunk;
-        if ((wouldExceedSize || wouldExceedCount) && currentChunk.length > 0) {
-            chunks.push(currentChunk);
-            currentChunk = [];
-            currentChunkSize = 0;
-        }
-        if (itemSize > maxChunkSizeBytes) {
-            if (currentChunk.length > 0) {
-                chunks.push(currentChunk);
-                currentChunk = [];
-                currentChunkSize = 0;
-            }
-            chunks.push([item]);
-            continue;
-        }
-        currentChunk.push(item);
-        currentChunkSize += itemSize;
-    }
-    if (currentChunk.length > 0) {
-        chunks.push(currentChunk);
-    }
-    return chunks;
-}
+import { Logger } from '../helpers/logging-helper.js';
+export function sizeInBytes(obj) {
+    try {
+        return new TextEncoder().encode(JSON.stringify(obj)).length;
+    }
+    catch (error) {
+        Logger.warn('sizeInBytes: failed to stringify object, returning fallback size', {
+            error,
+            objectType: typeof obj,
+        });
+        return 1024 * 1024;
+    }
+}
+export function chunkArrayBySize(array, maxChunkSizeBytes, maxItemsPerChunk) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentChunkSize = 0;
+    for (const item of array) {
+        const itemSize = sizeInBytes(item);
+        const arrayOverhead = 2 + Math.max(0, currentChunk.length);
+        const wouldExceedSize = currentChunkSize + itemSize + arrayOverhead > maxChunkSizeBytes;
+        const wouldExceedCount = maxItemsPerChunk !== undefined && currentChunk.length >= maxItemsPerChunk;
+        if ((wouldExceedSize || wouldExceedCount) && currentChunk.length > 0) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkSize = 0;
+        }
+        if (itemSize > maxChunkSizeBytes) {
+            if (currentChunk.length > 0) {
+                chunks.push(currentChunk);
+                currentChunk = [];
+                currentChunkSize = 0;
+            }
+            chunks.push([item]);
+            continue;
+        }
+        currentChunk.push(item);
+        currentChunkSize += itemSize;
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
 //# sourceMappingURL=size.js.map