@adtrackify/at-service-common 4.0.4 → 4.0.5

package/dist/esm/services/cost/cost-currency-service.d.ts

@@ -1,6 +1,6 @@
-import { type CostConfigsBundle } from './cost-calculation-types.js';
-export type ExchangeRatesMap = Record<string, Record<string, number>>;
-export declare const CostCurrencyService: {
-    extractCurrenciesFromConfigs: (configs: CostConfigsBundle, orderCurrency: string) => string[];
-    convertAmount: (amount: number, fromCurrency: string, toCurrency: string, exchangeRatesMap: ExchangeRatesMap) => number;
-};
+import { type CostConfigsBundle } from './cost-calculation-types.js';
+export type ExchangeRatesMap = Record<string, Record<string, number>>;
+export declare const CostCurrencyService: {
+    extractCurrenciesFromConfigs: (configs: CostConfigsBundle, orderCurrency: string) => string[];
+    convertAmount: (amount: number, fromCurrency: string, toCurrency: string, exchangeRatesMap: ExchangeRatesMap) => number;
+};

package/dist/esm/services/cost/cost-currency-service.js

@@ -1,85 +1,85 @@
-import { Logger } from '../../helpers/logging-helper.js';
-import { convertAmountBetweenCurrencies } from '../../libs/currency.js';
-export const CostCurrencyService = {
-    extractCurrenciesFromConfigs: (configs, orderCurrency) => {
-        try {
-            const currencies = new Set();
-            const normalizedOrderCurrency = orderCurrency.toUpperCase();
-            if (configs.globalProductOverride?.currency) {
-                const c = configs.globalProductOverride.currency.toUpperCase();
-                if (c !== normalizedOrderCurrency)
-                    currencies.add(c);
-            }
-            if (configs.order?.entries) {
-                for (const entry of configs.order.entries) {
-                    if (entry.currency) {
-                        const c = entry.currency.toUpperCase();
-                        if (c !== normalizedOrderCurrency)
-                            currencies.add(c);
-                    }
-                }
-            }
-            if (configs.gateway?.entries) {
-                for (const entry of configs.gateway.entries) {
-                    if (entry.currency) {
-                        const c = entry.currency.toUpperCase();
-                        if (c !== normalizedOrderCurrency)
-                            currencies.add(c);
-                    }
-                }
-            }
-            if (configs.shipping?.currency) {
-                const c = configs.shipping.currency.toUpperCase();
-                if (c !== normalizedOrderCurrency)
-                    currencies.add(c);
-            }
-            if (configs.shipping?.profiles) {
-                for (const profile of configs.shipping.profiles) {
-                    if (profile.currency) {
-                        const c = profile.currency.toUpperCase();
-                        if (c !== normalizedOrderCurrency)
-                            currencies.add(c);
-                    }
-                }
-            }
-            return Array.from(currencies);
-        }
-        catch (error) {
-            Logger.error('CostCurrencyService.extractCurrenciesFromConfigs: failed', { error, orderCurrency });
-            return [];
-        }
-    },
-    convertAmount: (amount, fromCurrency, toCurrency, exchangeRatesMap) => {
-        try {
-            if (!amount)
-                return amount;
-            const normalizedFrom = fromCurrency.toUpperCase();
-            const normalizedTo = toCurrency.toUpperCase();
-            if (normalizedFrom === normalizedTo)
-                return amount;
-            const rates = exchangeRatesMap[normalizedFrom];
-            if (!rates) {
-                Logger.warn('CostCurrencyService.convertAmount: no rates found', {
-                    fromCurrency: normalizedFrom,
-                    toCurrency: normalizedTo,
-                });
-                return amount;
-            }
-            const rate = rates[normalizedTo];
-            if (!rate) {
-                Logger.warn('CostCurrencyService.convertAmount: no rate for target currency', {
-                    fromCurrency: normalizedFrom,
-                    toCurrency: normalizedTo,
-                });
-                return amount;
-            }
-            const converted = convertAmountBetweenCurrencies(normalizedFrom, normalizedTo, amount, rate);
-            return converted ?? amount;
-        }
-        catch (error) {
-            Logger.error('CostCurrencyService.convertAmount: failed', { error, amount, fromCurrency, toCurrency });
-            return amount;
-        }
-    },
-};
+import { Logger } from '../../helpers/logging-helper.js';
+import { convertAmountBetweenCurrencies } from '../../libs/currency.js';
+export const CostCurrencyService = {
+    extractCurrenciesFromConfigs: (configs, orderCurrency) => {
+        try {
+            const currencies = new Set();
+            const normalizedOrderCurrency = orderCurrency.toUpperCase();
+            if (configs.globalProductOverride?.currency) {
+                const c = configs.globalProductOverride.currency.toUpperCase();
+                if (c !== normalizedOrderCurrency)
+                    currencies.add(c);
+            }
+            if (configs.order?.entries) {
+                for (const entry of configs.order.entries) {
+                    if (entry.currency) {
+                        const c = entry.currency.toUpperCase();
+                        if (c !== normalizedOrderCurrency)
+                            currencies.add(c);
+                    }
+                }
+            }
+            if (configs.gateway?.entries) {
+                for (const entry of configs.gateway.entries) {
+                    if (entry.currency) {
+                        const c = entry.currency.toUpperCase();
+                        if (c !== normalizedOrderCurrency)
+                            currencies.add(c);
+                    }
+                }
+            }
+            if (configs.shipping?.currency) {
+                const c = configs.shipping.currency.toUpperCase();
+                if (c !== normalizedOrderCurrency)
+                    currencies.add(c);
+            }
+            if (configs.shipping?.profiles) {
+                for (const profile of configs.shipping.profiles) {
+                    if (profile.currency) {
+                        const c = profile.currency.toUpperCase();
+                        if (c !== normalizedOrderCurrency)
+                            currencies.add(c);
+                    }
+                }
+            }
+            return Array.from(currencies);
+        }
+        catch (error) {
+            Logger.error('CostCurrencyService.extractCurrenciesFromConfigs: failed', { error, orderCurrency });
+            return [];
+        }
+    },
+    convertAmount: (amount, fromCurrency, toCurrency, exchangeRatesMap) => {
+        try {
+            if (!amount)
+                return amount;
+            const normalizedFrom = fromCurrency.toUpperCase();
+            const normalizedTo = toCurrency.toUpperCase();
+            if (normalizedFrom === normalizedTo)
+                return amount;
+            const rates = exchangeRatesMap[normalizedFrom];
+            if (!rates) {
+                Logger.warn('CostCurrencyService.convertAmount: no rates found', {
+                    fromCurrency: normalizedFrom,
+                    toCurrency: normalizedTo,
+                });
+                return amount;
+            }
+            const rate = rates[normalizedTo];
+            if (!rate) {
+                Logger.warn('CostCurrencyService.convertAmount: no rate for target currency', {
+                    fromCurrency: normalizedFrom,
+                    toCurrency: normalizedTo,
+                });
+                return amount;
+            }
+            const converted = convertAmountBetweenCurrencies(normalizedFrom, normalizedTo, amount, rate);
+            return converted ?? amount;
+        }
+        catch (error) {
+            Logger.error('CostCurrencyService.convertAmount: failed', { error, amount, fromCurrency, toCurrency });
+            return amount;
+        }
+    },
+};
 //# sourceMappingURL=cost-currency-service.js.map

package/dist/esm/services/cost/cost-filter-service.d.ts

@@ -1,10 +1,10 @@
-import { type CostFilter, type CostFilters } from '@adtrackify/at-tracking-event-types';
-import { type OrderFilterContext, type LineItemFilterContext } from './cost-calculation-types.js';
-export declare const CostFilterService: {
-    matchSingleFilter: (filter: CostFilter, value: string | undefined) => boolean;
-    matchArrayFilter: (filter: CostFilter, values: string[] | undefined) => boolean;
-    matchProductFilter: (filter: CostFilter, productId: string, variantId: string) => boolean;
-    hasProductFilters: (filters?: CostFilters) => boolean;
-    matchLineItemFilters: (filters: CostFilters, lineItem: LineItemFilterContext) => boolean;
-    matchesFilters: (filters: CostFilters | undefined, order: OrderFilterContext, lineItem: LineItemFilterContext | null, lineItems?: LineItemFilterContext[]) => boolean;
-};
+import { type CostFilter, type CostFilters } from '@adtrackify/at-tracking-event-types';
+import { type OrderFilterContext, type LineItemFilterContext } from './cost-calculation-types.js';
+export declare const CostFilterService: {
+    matchSingleFilter: (filter: CostFilter, value: string | undefined) => boolean;
+    matchArrayFilter: (filter: CostFilter, values: string[] | undefined) => boolean;
+    matchProductFilter: (filter: CostFilter, productId: string, variantId: string) => boolean;
+    hasProductFilters: (filters?: CostFilters) => boolean;
+    matchLineItemFilters: (filters: CostFilters, lineItem: LineItemFilterContext) => boolean;
+    matchesFilters: (filters: CostFilters | undefined, order: OrderFilterContext, lineItem: LineItemFilterContext | null, lineItems?: LineItemFilterContext[]) => boolean;
+};

package/dist/esm/services/cost/cost-filter-service.js

@@ -1,119 +1,119 @@
-import { Logger } from '../../helpers/logging-helper.js';
-import { COST_FILTER_MODE } from '@adtrackify/at-tracking-event-types';
-export const CostFilterService = {
-    matchSingleFilter: (filter, value) => {
-        try {
-            if (filter.mode === COST_FILTER_MODE.ALL)
-                return true;
-            if (!value || !filter.values?.length) {
-                return filter.mode === COST_FILTER_MODE.EXCLUDE;
-            }
-            const normalizedValue = value.toLowerCase();
-            const hasMatch = filter.values.some((v) => v.toLowerCase() === normalizedValue);
-            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
-        }
-        catch (error) {
-            Logger.error('CostFilterService.matchSingleFilter: failed', { error, filter, value });
-            return false;
-        }
-    },
-    matchArrayFilter: (filter, values) => {
-        try {
-            if (filter.mode === COST_FILTER_MODE.ALL)
-                return true;
-            if (!values?.length || !filter.values?.length) {
-                return filter.mode === COST_FILTER_MODE.EXCLUDE;
-            }
-            const normalizedValues = values.map((v) => v.toLowerCase());
-            const normalizedFilterValues = filter.values.map((v) => v.toLowerCase());
-            const hasMatch = normalizedValues.some((v) => normalizedFilterValues.includes(v));
-            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
-        }
-        catch (error) {
-            Logger.error('CostFilterService.matchArrayFilter: failed', { error, filter, values });
-            return false;
-        }
-    },
-    matchProductFilter: (filter, productId, variantId) => {
-        try {
-            if (filter.mode === COST_FILTER_MODE.ALL)
-                return true;
-            if (!productId || !filter.values?.length) {
-                return filter.mode === COST_FILTER_MODE.EXCLUDE;
-            }
-            const hasMatch = filter.values.some((v) => {
-                if (v.includes('_')) {
-                    return v === `${productId}_${variantId}`;
-                }
-                return v === productId;
-            });
-            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
-        }
-        catch (error) {
-            Logger.error('CostFilterService.matchProductFilter: failed', { error, filter, productId, variantId });
-            return false;
-        }
-    },
-    hasProductFilters: (filters) => {
-        if (!filters)
-            return false;
-        return !!(filters.productVendors || filters.productTypes || filters.productTags || filters.productCategories || filters.products);
-    },
-    matchLineItemFilters: (filters, lineItem) => {
-        try {
-            if (filters.productVendors && !CostFilterService.matchSingleFilter(filters.productVendors, lineItem.vendor)) {
-                return false;
-            }
-            if (filters.productTypes && !CostFilterService.matchSingleFilter(filters.productTypes, lineItem.productType)) {
-                return false;
-            }
-            if (filters.productTags && !CostFilterService.matchArrayFilter(filters.productTags, lineItem.tags)) {
-                return false;
-            }
-            if (filters.productCategories && !CostFilterService.matchSingleFilter(filters.productCategories, lineItem.category)) {
-                return false;
-            }
-            if (filters.products && !CostFilterService.matchProductFilter(filters.products, lineItem.productId, lineItem.variantId)) {
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            Logger.error('CostFilterService.matchLineItemFilters: failed', { error, filters });
-            return false;
-        }
-    },
-    matchesFilters: (filters, order, lineItem, lineItems) => {
-        try {
-            if (!filters)
-                return true;
-            if (filters.orderTags && !CostFilterService.matchArrayFilter(filters.orderTags, order.tags)) {
-                return false;
-            }
-            if (filters.orderSourceNames && !CostFilterService.matchSingleFilter(filters.orderSourceNames, order.sourceName)) {
-                return false;
-            }
-            if (filters.orderPaymentGateways && !CostFilterService.matchArrayFilter(filters.orderPaymentGateways, order.paymentGateways)) {
-                return false;
-            }
-            if (filters.orderShippingTitles && !CostFilterService.matchArrayFilter(filters.orderShippingTitles, order.shippingTitles)) {
-                return false;
-            }
-            if (filters.countries && !CostFilterService.matchSingleFilter(filters.countries, order.shipCountryCode)) {
-                return false;
-            }
-            if (lineItem) {
-                return CostFilterService.matchLineItemFilters(filters, lineItem);
-            }
-            if (CostFilterService.hasProductFilters(filters) && lineItems?.length) {
-                return lineItems.some(li => CostFilterService.matchLineItemFilters(filters, li));
-            }
-            return true;
-        }
-        catch (error) {
-            Logger.error('CostFilterService.matchesFilters: failed', { error, filters });
-            return false;
-        }
-    },
-};
+import { Logger } from '../../helpers/logging-helper.js';
+import { COST_FILTER_MODE } from '@adtrackify/at-tracking-event-types';
+export const CostFilterService = {
+    matchSingleFilter: (filter, value) => {
+        try {
+            if (filter.mode === COST_FILTER_MODE.ALL)
+                return true;
+            if (!value || !filter.values?.length) {
+                return filter.mode === COST_FILTER_MODE.EXCLUDE;
+            }
+            const normalizedValue = value.toLowerCase();
+            const hasMatch = filter.values.some((v) => v.toLowerCase() === normalizedValue);
+            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
+        }
+        catch (error) {
+            Logger.error('CostFilterService.matchSingleFilter: failed', { error, filter, value });
+            return false;
+        }
+    },
+    matchArrayFilter: (filter, values) => {
+        try {
+            if (filter.mode === COST_FILTER_MODE.ALL)
+                return true;
+            if (!values?.length || !filter.values?.length) {
+                return filter.mode === COST_FILTER_MODE.EXCLUDE;
+            }
+            const normalizedValues = values.map((v) => v.toLowerCase());
+            const normalizedFilterValues = filter.values.map((v) => v.toLowerCase());
+            const hasMatch = normalizedValues.some((v) => normalizedFilterValues.includes(v));
+            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
+        }
+        catch (error) {
+            Logger.error('CostFilterService.matchArrayFilter: failed', { error, filter, values });
+            return false;
+        }
+    },
+    matchProductFilter: (filter, productId, variantId) => {
+        try {
+            if (filter.mode === COST_FILTER_MODE.ALL)
+                return true;
+            if (!productId || !filter.values?.length) {
+                return filter.mode === COST_FILTER_MODE.EXCLUDE;
+            }
+            const hasMatch = filter.values.some((v) => {
+                if (v.includes('_')) {
+                    return v === `${productId}_${variantId}`;
+                }
+                return v === productId;
+            });
+            return filter.mode === COST_FILTER_MODE.INCLUDE ? hasMatch : !hasMatch;
+        }
+        catch (error) {
+            Logger.error('CostFilterService.matchProductFilter: failed', { error, filter, productId, variantId });
+            return false;
+        }
+    },
+    hasProductFilters: (filters) => {
+        if (!filters)
+            return false;
+        return !!(filters.productVendors || filters.productTypes || filters.productTags || filters.productCategories || filters.products);
+    },
+    matchLineItemFilters: (filters, lineItem) => {
+        try {
+            if (filters.productVendors && !CostFilterService.matchSingleFilter(filters.productVendors, lineItem.vendor)) {
+                return false;
+            }
+            if (filters.productTypes && !CostFilterService.matchSingleFilter(filters.productTypes, lineItem.productType)) {
+                return false;
+            }
+            if (filters.productTags && !CostFilterService.matchArrayFilter(filters.productTags, lineItem.tags)) {
+                return false;
+            }
+            if (filters.productCategories && !CostFilterService.matchSingleFilter(filters.productCategories, lineItem.category)) {
+                return false;
+            }
+            if (filters.products && !CostFilterService.matchProductFilter(filters.products, lineItem.productId, lineItem.variantId)) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            Logger.error('CostFilterService.matchLineItemFilters: failed', { error, filters });
+            return false;
+        }
+    },
+    matchesFilters: (filters, order, lineItem, lineItems) => {
+        try {
+            if (!filters)
+                return true;
+            if (filters.orderTags && !CostFilterService.matchArrayFilter(filters.orderTags, order.tags)) {
+                return false;
+            }
+            if (filters.orderSourceNames && !CostFilterService.matchSingleFilter(filters.orderSourceNames, order.sourceName)) {
+                return false;
+            }
+            if (filters.orderPaymentGateways && !CostFilterService.matchArrayFilter(filters.orderPaymentGateways, order.paymentGateways)) {
+                return false;
+            }
+            if (filters.orderShippingTitles && !CostFilterService.matchArrayFilter(filters.orderShippingTitles, order.shippingTitles)) {
+                return false;
+            }
+            if (filters.countries && !CostFilterService.matchSingleFilter(filters.countries, order.shipCountryCode)) {
+                return false;
+            }
+            if (lineItem) {
+                return CostFilterService.matchLineItemFilters(filters, lineItem);
+            }
+            if (CostFilterService.hasProductFilters(filters) && lineItems?.length) {
+                return lineItems.some(li => CostFilterService.matchLineItemFilters(filters, li));
+            }
+            return true;
+        }
+        catch (error) {
+            Logger.error('CostFilterService.matchesFilters: failed', { error, filters });
+            return false;
+        }
+    },
+};
 //# sourceMappingURL=cost-filter-service.js.map

package/dist/esm/services/cost/index.d.ts

@@ -1,5 +1,5 @@
-export * from './cost-calculation-types.js';
-export * from './cost-filter-service.js';
-export * from './cost-currency-service.js';
-export * from './cost-calculator-service.js';
-export * from './order-cost/index.js';
+export * from './cost-calculation-types.js';
+export * from './cost-filter-service.js';
+export * from './cost-currency-service.js';
+export * from './cost-calculator-service.js';
+export * from './order-cost/index.js';

package/dist/esm/services/cost/index.js

@@ -1,6 +1,6 @@
-export * from './cost-calculation-types.js';
-export * from './cost-filter-service.js';
-export * from './cost-currency-service.js';
-export * from './cost-calculator-service.js';
-export * from './order-cost/index.js';
+export * from './cost-calculation-types.js';
+export * from './cost-filter-service.js';
+export * from './cost-currency-service.js';
+export * from './cost-calculator-service.js';
+export * from './order-cost/index.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/services/cost/order-cost/index.d.ts

@@ -1,2 +1,2 @@
-export * from './order-cost-resolution-types.js';
-export * from './order-cost-resolution-service.js';
+export * from './order-cost-resolution-types.js';
+export * from './order-cost-resolution-service.js';

package/dist/esm/services/cost/order-cost/index.js

@@ -1,3 +1,3 @@
-export * from './order-cost-resolution-types.js';
-export * from './order-cost-resolution-service.js';
+export * from './order-cost-resolution-types.js';
+export * from './order-cost-resolution-service.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/services/cost/order-cost/order-cost-resolution-service.d.ts

@@ -1,23 +1,23 @@
-import { type CostHistoryEntry, type ProductVariantRecord } from '@adtrackify/at-tracking-event-types';
-import { ShopifyRest } from '../../../types/index.js';
-import { type CostConfigsByPixelId, type OrderCostContext, type OrderCostResult } from '../cost-calculation-types.js';
-import { type BuildOrderCostContextParams, type ComputeOrderCostResultParams, type LineItemsRefundInfo } from './order-cost-resolution-types.js';
-export declare const OrderCostResolutionService: {
-    selectCostHistoryRecordForOrderDate: (costHistory: CostHistoryEntry[], orderCreatedAt: string) => CostHistoryEntry | null;
-    isValidCost: (cost: number) => boolean;
-    resolveOrderLineItemUnitCosts: (lineItems: Array<{
-        id: number | string;
-        product_id?: number | null;
-        variant_id?: number | null;
-        price?: string;
-        quantity?: number;
-    }>, pixelId: string, orderCreatedAt: string, variantRecords: Record<string, ProductVariantRecord>, costConfigsByPixelId: CostConfigsByPixelId) => Record<string, number>;
-    getOrderCreatedAt: (order: ShopifyRest.IOrder, useProcessedAtForNonWebOrders?: boolean) => string | undefined;
-    getGrossSalePrice: (order: ShopifyRest.IOrder) => number | undefined;
-    getTotalRefundsFromOrder: (order: ShopifyRest.IOrder) => number;
-    getNetSalePrice: (order: ShopifyRest.IOrder) => number | undefined;
-    getTotalProductCost: (order: ShopifyRest.IOrder, lineItemUnitCosts: Record<string, number>) => number | undefined;
-    getLineItemsRefundInfo: (order: ShopifyRest.IOrder) => LineItemsRefundInfo;
-    buildOrderCostContext: (params: BuildOrderCostContextParams) => OrderCostContext;
-    computeOrderCostResult: (params: ComputeOrderCostResultParams) => OrderCostResult;
-};
+import { type CostHistoryEntry, type ProductVariantRecord } from '@adtrackify/at-tracking-event-types';
+import { ShopifyRest } from '../../../types/index.js';
+import { type CostConfigsByPixelId, type OrderCostContext, type OrderCostResult } from '../cost-calculation-types.js';
+import { type BuildOrderCostContextParams, type ComputeOrderCostResultParams, type LineItemsRefundInfo } from './order-cost-resolution-types.js';
+export declare const OrderCostResolutionService: {
+    selectCostHistoryRecordForOrderDate: (costHistory: CostHistoryEntry[], orderCreatedAt: string) => CostHistoryEntry | null;
+    isValidCost: (cost: number) => boolean;
+    resolveOrderLineItemUnitCosts: (lineItems: Array<{
+        id: number | string;
+        product_id?: number | null;
+        variant_id?: number | null;
+        price?: string;
+        quantity?: number;
+    }>, pixelId: string, orderCreatedAt: string, variantRecords: Record<string, ProductVariantRecord>, costConfigsByPixelId: CostConfigsByPixelId) => Record<string, number>;
+    getOrderCreatedAt: (order: ShopifyRest.IOrder, useProcessedAtForNonWebOrders?: boolean) => string | undefined;
+    getGrossSalePrice: (order: ShopifyRest.IOrder) => number | undefined;
+    getTotalRefundsFromOrder: (order: ShopifyRest.IOrder) => number;
+    getNetSalePrice: (order: ShopifyRest.IOrder) => number | undefined;
+    getTotalProductCost: (order: ShopifyRest.IOrder, lineItemUnitCosts: Record<string, number>) => number | undefined;
+    getLineItemsRefundInfo: (order: ShopifyRest.IOrder) => LineItemsRefundInfo;
+    buildOrderCostContext: (params: BuildOrderCostContextParams) => OrderCostContext;
+    computeOrderCostResult: (params: ComputeOrderCostResultParams) => OrderCostResult;
+};