@adtrackify/at-service-common 4.0.2 → 4.0.3

package/dist/cjs/utils/custom-measure-formula-utils.js

@@ -1,210 +1,210 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateFormula = exports.evaluateFormulaAst = exports.collectFormulaMeasures = exports.parseFormula = exports.tokenizeFormula = void 0;
-const at_tracking_event_types_1 = require("@adtrackify/at-tracking-event-types");
-const NUMBER_PATTERN = /^[0-9]+(\.[0-9]+)?$/;
-const MEASURE_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+)+$/;
-const ALLOWED_CHARS_PATTERN = /[^a-z0-9_.+\-*/()\s]/;
-const tokenizeFormula = (formula) => {
-    if (!formula || formula.trim().length === 0) {
-        throw new Error('Formula is empty');
-    }
-    const invalidChar = formula.match(ALLOWED_CHARS_PATTERN);
-    if (invalidChar) {
-        throw new Error(`Invalid character in formula: '${invalidChar[0]}'`);
-    }
-    const tokens = [];
-    let i = 0;
-    while (i < formula.length) {
-        const char = formula[i];
-        if (/\s/.test(char)) {
-            i += 1;
-            continue;
-        }
-        if (char === '(' || char === ')') {
-            tokens.push({ type: char === '(' ? at_tracking_event_types_1.FORMULA_TOKEN_TYPE.LPAREN : at_tracking_event_types_1.FORMULA_TOKEN_TYPE.RPAREN, value: char });
-            i += 1;
-            continue;
-        }
-        if (char === '+' || char === '-' || char === '*' || char === '/') {
-            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR, value: char });
-            i += 1;
-            continue;
-        }
-        if (char >= '0' && char <= '9') {
-            let value = '';
-            while (i < formula.length && /[0-9.]/.test(formula[i])) {
-                value += formula[i];
-                i += 1;
-            }
-            if (!NUMBER_PATTERN.test(value)) {
-                throw new Error(`Invalid number in formula: '${value}'`);
-            }
-            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.NUMBER, value });
-            continue;
-        }
-        if (char >= 'a' && char <= 'z') {
-            let value = '';
-            while (i < formula.length && /[a-z0-9_.]/.test(formula[i])) {
-                value += formula[i];
-                i += 1;
-            }
-            if (!MEASURE_PATTERN.test(value)) {
-                throw new Error(`Invalid measure reference in formula: '${value}'`);
-            }
-            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.MEASURE, value });
-            continue;
-        }
-        throw new Error(`Invalid character in formula: '${char}'`);
-    }
-    return tokens;
-};
-exports.tokenizeFormula = tokenizeFormula;
-const parseFormula = (formula) => {
-    const tokens = (0, exports.tokenizeFormula)(formula);
-    let pos = 0;
-    const peek = () => tokens[pos];
-    const parseExpression = () => {
-        let left = parseTerm();
-        while (peek()?.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && (peek()?.value === '+' || peek()?.value === '-')) {
-            const operator = tokens[pos].value;
-            pos += 1;
-            const right = parseTerm();
-            left = { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY, operator, left, right };
-        }
-        return left;
-    };
-    const parseTerm = () => {
-        let left = parseFactor();
-        while (peek()?.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && (peek()?.value === '*' || peek()?.value === '/')) {
-            const operator = tokens[pos].value;
-            pos += 1;
-            const right = parseFactor();
-            left = { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY, operator, left, right };
-        }
-        return left;
-    };
-    const parseFactor = () => {
-        const token = peek();
-        if (!token) {
-            throw new Error('Unexpected end of formula');
-        }
-        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && token.value === '-') {
-            pos += 1;
-            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY, operator: at_tracking_event_types_1.FORMULA_OPERATOR.SUBTRACT, operand: parseFactor() };
-        }
-        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.NUMBER) {
-            pos += 1;
-            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.NUMBER, value: Number(token.value) };
-        }
-        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.MEASURE) {
-            pos += 1;
-            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE, measure: token.value };
-        }
-        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.LPAREN) {
-            pos += 1;
-            const expression = parseExpression();
-            if (peek()?.type !== at_tracking_event_types_1.FORMULA_TOKEN_TYPE.RPAREN) {
-                throw new Error('Unbalanced parentheses in formula');
-            }
-            pos += 1;
-            return expression;
-        }
-        throw new Error(`Unexpected token in formula: '${token.value}'`);
-    };
-    const ast = parseExpression();
-    if (pos !== tokens.length) {
-        throw new Error(`Unexpected token in formula: '${tokens[pos].value}'`);
-    }
-    return ast;
-};
-exports.parseFormula = parseFormula;
-const collectFormulaMeasures = (ast) => {
-    const measures = [];
-    const walk = (node) => {
-        switch (node.type) {
-            case at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE:
-                if (!measures.includes(node.measure)) {
-                    measures.push(node.measure);
-                }
-                break;
-            case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
-                walk(node.operand);
-                break;
-            case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY:
-                walk(node.left);
-                walk(node.right);
-                break;
-        }
-    };
-    walk(ast);
-    return measures;
-};
-exports.collectFormulaMeasures = collectFormulaMeasures;
-const evaluateFormulaAst = (ast, operandValues) => {
-    switch (ast.type) {
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.NUMBER:
-            return ast.value;
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE: {
-            const value = Number(operandValues.get(ast.measure));
-            return Number.isFinite(value) ? value : 0;
-        }
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
-            return -(0, exports.evaluateFormulaAst)(ast.operand, operandValues);
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY: {
-            const left = (0, exports.evaluateFormulaAst)(ast.left, operandValues);
-            const right = (0, exports.evaluateFormulaAst)(ast.right, operandValues);
-            switch (ast.operator) {
-                case at_tracking_event_types_1.FORMULA_OPERATOR.ADD:
-                    return left + right;
-                case at_tracking_event_types_1.FORMULA_OPERATOR.SUBTRACT:
-                    return left - right;
-                case at_tracking_event_types_1.FORMULA_OPERATOR.MULTIPLY:
-                    return left * right;
-                case at_tracking_event_types_1.FORMULA_OPERATOR.DIVIDE:
-                    return right === 0 ? 0 : left / right;
-            }
-        }
-    }
-};
-exports.evaluateFormulaAst = evaluateFormulaAst;
-const hasConstantZeroDivisor = (ast) => {
-    switch (ast.type) {
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
-            return hasConstantZeroDivisor(ast.operand);
-        case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY: {
-            const divisorIsConstantZero = ast.operator === at_tracking_event_types_1.FORMULA_OPERATOR.DIVIDE &&
-                (0, exports.collectFormulaMeasures)(ast.right).length === 0 &&
-                (0, exports.evaluateFormulaAst)(ast.right, EMPTY_OPERAND_VALUES) === 0;
-            return divisorIsConstantZero || hasConstantZeroDivisor(ast.left) || hasConstantZeroDivisor(ast.right);
-        }
-        default:
-            return false;
-    }
-};
-const EMPTY_OPERAND_VALUES = new Map();
-const validateFormula = (formula, options) => {
-    let ast;
-    try {
-        ast = (0, exports.parseFormula)(formula);
-    }
-    catch (error) {
-        return { valid: false, errors: [error.message] };
-    }
-    const errors = [];
-    const measures = (0, exports.collectFormulaMeasures)(ast);
-    if (measures.length === 0) {
-        errors.push('Formula must reference at least one measure');
-    }
-    measures.forEach((measure) => {
-        if (options?.knownOperands && !options.knownOperands.has(measure)) {
-            errors.push(`Unknown or unsupported measure: '${measure}'`);
-        }
-    });
-    if (hasConstantZeroDivisor(ast)) {
-        errors.push('Division by zero is not allowed');
-    }
-    return errors.length > 0 ? { valid: false, errors } : { valid: true, errors: [], ast };
-};
-exports.validateFormula = validateFormula;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFormula = exports.evaluateFormulaAst = exports.collectFormulaMeasures = exports.parseFormula = exports.tokenizeFormula = void 0;
+const at_tracking_event_types_1 = require("@adtrackify/at-tracking-event-types");
+const NUMBER_PATTERN = /^[0-9]+(\.[0-9]+)?$/;
+const MEASURE_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+)+$/;
+const ALLOWED_CHARS_PATTERN = /[^a-z0-9_.+\-*/()\s]/;
+const tokenizeFormula = (formula) => {
+    if (!formula || formula.trim().length === 0) {
+        throw new Error('Formula is empty');
+    }
+    const invalidChar = formula.match(ALLOWED_CHARS_PATTERN);
+    if (invalidChar) {
+        throw new Error(`Invalid character in formula: '${invalidChar[0]}'`);
+    }
+    const tokens = [];
+    let i = 0;
+    while (i < formula.length) {
+        const char = formula[i];
+        if (/\s/.test(char)) {
+            i += 1;
+            continue;
+        }
+        if (char === '(' || char === ')') {
+            tokens.push({ type: char === '(' ? at_tracking_event_types_1.FORMULA_TOKEN_TYPE.LPAREN : at_tracking_event_types_1.FORMULA_TOKEN_TYPE.RPAREN, value: char });
+            i += 1;
+            continue;
+        }
+        if (char === '+' || char === '-' || char === '*' || char === '/') {
+            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR, value: char });
+            i += 1;
+            continue;
+        }
+        if (char >= '0' && char <= '9') {
+            let value = '';
+            while (i < formula.length && /[0-9.]/.test(formula[i])) {
+                value += formula[i];
+                i += 1;
+            }
+            if (!NUMBER_PATTERN.test(value)) {
+                throw new Error(`Invalid number in formula: '${value}'`);
+            }
+            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.NUMBER, value });
+            continue;
+        }
+        if (char >= 'a' && char <= 'z') {
+            let value = '';
+            while (i < formula.length && /[a-z0-9_.]/.test(formula[i])) {
+                value += formula[i];
+                i += 1;
+            }
+            if (!MEASURE_PATTERN.test(value)) {
+                throw new Error(`Invalid measure reference in formula: '${value}'`);
+            }
+            tokens.push({ type: at_tracking_event_types_1.FORMULA_TOKEN_TYPE.MEASURE, value });
+            continue;
+        }
+        throw new Error(`Invalid character in formula: '${char}'`);
+    }
+    return tokens;
+};
+exports.tokenizeFormula = tokenizeFormula;
+const parseFormula = (formula) => {
+    const tokens = (0, exports.tokenizeFormula)(formula);
+    let pos = 0;
+    const peek = () => tokens[pos];
+    const parseExpression = () => {
+        let left = parseTerm();
+        while (peek()?.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && (peek()?.value === '+' || peek()?.value === '-')) {
+            const operator = tokens[pos].value;
+            pos += 1;
+            const right = parseTerm();
+            left = { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY, operator, left, right };
+        }
+        return left;
+    };
+    const parseTerm = () => {
+        let left = parseFactor();
+        while (peek()?.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && (peek()?.value === '*' || peek()?.value === '/')) {
+            const operator = tokens[pos].value;
+            pos += 1;
+            const right = parseFactor();
+            left = { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY, operator, left, right };
+        }
+        return left;
+    };
+    const parseFactor = () => {
+        const token = peek();
+        if (!token) {
+            throw new Error('Unexpected end of formula');
+        }
+        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.OPERATOR && token.value === '-') {
+            pos += 1;
+            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY, operator: at_tracking_event_types_1.FORMULA_OPERATOR.SUBTRACT, operand: parseFactor() };
+        }
+        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.NUMBER) {
+            pos += 1;
+            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.NUMBER, value: Number(token.value) };
+        }
+        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.MEASURE) {
+            pos += 1;
+            return { type: at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE, measure: token.value };
+        }
+        if (token.type === at_tracking_event_types_1.FORMULA_TOKEN_TYPE.LPAREN) {
+            pos += 1;
+            const expression = parseExpression();
+            if (peek()?.type !== at_tracking_event_types_1.FORMULA_TOKEN_TYPE.RPAREN) {
+                throw new Error('Unbalanced parentheses in formula');
+            }
+            pos += 1;
+            return expression;
+        }
+        throw new Error(`Unexpected token in formula: '${token.value}'`);
+    };
+    const ast = parseExpression();
+    if (pos !== tokens.length) {
+        throw new Error(`Unexpected token in formula: '${tokens[pos].value}'`);
+    }
+    return ast;
+};
+exports.parseFormula = parseFormula;
+const collectFormulaMeasures = (ast) => {
+    const measures = [];
+    const walk = (node) => {
+        switch (node.type) {
+            case at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE:
+                if (!measures.includes(node.measure)) {
+                    measures.push(node.measure);
+                }
+                break;
+            case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
+                walk(node.operand);
+                break;
+            case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY:
+                walk(node.left);
+                walk(node.right);
+                break;
+        }
+    };
+    walk(ast);
+    return measures;
+};
+exports.collectFormulaMeasures = collectFormulaMeasures;
+const evaluateFormulaAst = (ast, operandValues) => {
+    switch (ast.type) {
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.NUMBER:
+            return ast.value;
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.MEASURE: {
+            const value = Number(operandValues.get(ast.measure));
+            return Number.isFinite(value) ? value : 0;
+        }
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
+            return -(0, exports.evaluateFormulaAst)(ast.operand, operandValues);
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY: {
+            const left = (0, exports.evaluateFormulaAst)(ast.left, operandValues);
+            const right = (0, exports.evaluateFormulaAst)(ast.right, operandValues);
+            switch (ast.operator) {
+                case at_tracking_event_types_1.FORMULA_OPERATOR.ADD:
+                    return left + right;
+                case at_tracking_event_types_1.FORMULA_OPERATOR.SUBTRACT:
+                    return left - right;
+                case at_tracking_event_types_1.FORMULA_OPERATOR.MULTIPLY:
+                    return left * right;
+                case at_tracking_event_types_1.FORMULA_OPERATOR.DIVIDE:
+                    return right === 0 ? 0 : left / right;
+            }
+        }
+    }
+};
+exports.evaluateFormulaAst = evaluateFormulaAst;
+const hasConstantZeroDivisor = (ast) => {
+    switch (ast.type) {
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.UNARY:
+            return hasConstantZeroDivisor(ast.operand);
+        case at_tracking_event_types_1.FORMULA_NODE_TYPE.BINARY: {
+            const divisorIsConstantZero = ast.operator === at_tracking_event_types_1.FORMULA_OPERATOR.DIVIDE &&
+                (0, exports.collectFormulaMeasures)(ast.right).length === 0 &&
+                (0, exports.evaluateFormulaAst)(ast.right, EMPTY_OPERAND_VALUES) === 0;
+            return divisorIsConstantZero || hasConstantZeroDivisor(ast.left) || hasConstantZeroDivisor(ast.right);
+        }
+        default:
+            return false;
+    }
+};
+const EMPTY_OPERAND_VALUES = new Map();
+const validateFormula = (formula, options) => {
+    let ast;
+    try {
+        ast = (0, exports.parseFormula)(formula);
+    }
+    catch (error) {
+        return { valid: false, errors: [error.message] };
+    }
+    const errors = [];
+    const measures = (0, exports.collectFormulaMeasures)(ast);
+    if (measures.length === 0) {
+        errors.push('Formula must reference at least one measure');
+    }
+    measures.forEach((measure) => {
+        if (options?.knownOperands && !options.knownOperands.has(measure)) {
+            errors.push(`Unknown or unsupported measure: '${measure}'`);
+        }
+    });
+    if (hasConstantZeroDivisor(ast)) {
+        errors.push('Division by zero is not allowed');
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true, errors: [], ast };
+};
+exports.validateFormula = validateFormula;
 //# sourceMappingURL=custom-measure-formula-utils.js.map

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

@@ -1,4 +1,4 @@
-export * from './size.js';
-export * from './compression.js';
-export * from './retry-envelope.js';
-export * from './custom-measure-formula-utils.js';
+export * from './size.js';
+export * from './compression.js';
+export * from './retry-envelope.js';
+export * from './custom-measure-formula-utils.js';

package/dist/cjs/utils/index.js

@@ -1,21 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./size.js"), exports);
-__exportStar(require("./compression.js"), exports);
-__exportStar(require("./retry-envelope.js"), exports);
-__exportStar(require("./custom-measure-formula-utils.js"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./size.js"), exports);
+__exportStar(require("./compression.js"), exports);
+__exportStar(require("./retry-envelope.js"), exports);
+__exportStar(require("./custom-measure-formula-utils.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/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/cjs/utils/retry-envelope.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRetryEnvelope = exports.unwrapItem = exports.isRetryEnvelope = void 0;
-function isRetryEnvelope(payload) {
-    return (typeof payload === 'object' &&
-        payload !== null &&
-        'item' in payload &&
-        'retryCount' in payload &&
-        typeof payload.retryCount === 'number');
-}
-exports.isRetryEnvelope = isRetryEnvelope;
-function unwrapItem(payload) {
-    if (isRetryEnvelope(payload)) {
-        return { item: payload.item, retryCount: payload.retryCount };
-    }
-    return { item: payload, retryCount: 0 };
-}
-exports.unwrapItem = unwrapItem;
-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,
-    };
-}
-exports.createRetryEnvelope = createRetryEnvelope;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRetryEnvelope = exports.unwrapItem = exports.isRetryEnvelope = void 0;
+function isRetryEnvelope(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        'item' in payload &&
+        'retryCount' in payload &&
+        typeof payload.retryCount === 'number');
+}
+exports.isRetryEnvelope = isRetryEnvelope;
+function unwrapItem(payload) {
+    if (isRetryEnvelope(payload)) {
+        return { item: payload.item, retryCount: payload.retryCount };
+    }
+    return { item: payload, retryCount: 0 };
+}
+exports.unwrapItem = unwrapItem;
+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,
+    };
+}
+exports.createRetryEnvelope = createRetryEnvelope;
 //# sourceMappingURL=retry-envelope.js.map

package/dist/cjs/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[][];