ng-easycommerce 0.0.691 → 0.1.0

package/lib/ec-component/account-ec/order-ec/order-ec.component.d.ts

@@ -25,9 +25,24 @@ export declare class OrderEcComponent extends ComponentHelper implements OnInit
     hideDiscounts: boolean;
     hideTaxes: boolean;
     enableFieldNotesInArticleFile: boolean;
+    showPriceWithTaxesWhileBrowsing: boolean;
     constructor(ordersService: OrdersService, activedRoute: ActivatedRoute, router: Router, consts: Constants, cartService: CartService, channelConfigService: ChannelConfigService);
     ngOnInit(): void;
     toDate: (date: any, format: any) => string;
+    private getLinePricing;
+    private getHistoricalPricingKey;
+    getOrderLineValue: (item: any, section: "subtotal" | "discount" | "unit") => number;
+    hasOrderLineValue: (item: any, section: "subtotal" | "discount" | "unit") => boolean;
+    private getTotalsPricing;
+    private getSelectedTotalsPricing;
+    private hasHistoricalLinePricing;
+    getHistoricalProductsSubtotal: () => number;
+    getHistoricalOrderDiscount: () => number;
+    getHistoricalCouponDiscount: () => number;
+    getHistoricalShipping: () => number;
+    getHistoricalTaxes: () => number;
+    hasHistoricalTaxes: () => boolean;
+    getHistoricalTotal: () => number;
     callError: () => void;
     volver: () => Promise<boolean>;
     repeatOrder(): void;

package/lib/ec-component/cart-ec/cart-ec.component.d.ts

@@ -81,10 +81,17 @@ export declare class CartEcComponent extends ComponentHelper implements OnInit {
      * ```
      */
     getItemEffectiveDiscount: (item: any) => number;
-    /** @param item Ítem del carrito. @returns Subtotal actual del renglón según backend. */
+    /**
+     * Subtotal actual del renglón.
+     *
+     * El backend nuevo informa `item.subtotal` sin impuestos ni descuentos
+     * generales de orden. Las respuestas legacy continúan usando `item.total`.
+     */
     getDisplayedItemTotal: (item: any) => number;
     /** @param item Ítem del carrito. @returns `true` si el backend informó promociones unitarias. */
     hasUnitPromotions: (item: any) => boolean;
+    /** @param items Ítems del carrito. @returns `true` si al menos un ítem tiene promociones unitarias. */
+    hasAnyUnitPromotions: (items?: any[]) => boolean;
     /** @param item Ítem del carrito. @returns `true` si el resumen activo pertenece a ese ítem. */
     isUnitPromotionSummaryOpen: (item: any) => boolean;
     /**

package/lib/ec-component/checkout-ec/checkout-ec.component.d.ts

@@ -97,7 +97,7 @@ export declare class CheckoutEcComponent extends ComponentHelper implements OnIn
     goToNextSection: (stepName: string) => void;
     goToNextFromAddress: () => void;
     isSectionOpen: (stepName: string) => boolean;
-    getSummaryLabel: (type: import("../../interfaces/checkout-data").CheckoutDataType) => "total" | "subtotal" | "shipment" | "coupon" | "discount" | "taxes" | "clientTaxes" | "national-taxes";
+    getSummaryLabel: (type: import("../../interfaces/checkout-data").CheckoutDataType, item?: CheckoutData) => "total" | "subtotal" | "shipment" | "coupon" | "discount" | "taxes" | "clientTaxes" | "products-before-discounts" | "line-discounts" | "taxes-included-in-total" | "national-taxes";
     getSummaryData: (data: CheckoutData[]) => CheckoutData[];
     getSummaryAmountView: (item: CheckoutData) => import("../../utils/shipping-price-display.service").ShippingPriceViewModel;
     getTotalAmount: (data: CheckoutData[]) => number;

package/lib/ec-component/checkout-ec/detail-checkout-block-ec/detail-checkout-block-ec.component.d.ts

@@ -24,8 +24,8 @@ export declare class DetailCheckoutBlockEcComponent extends ComponentHelper impl
     calcularTotales(): void;
     getIcon: (data_item: CheckoutData) => "fas fa-ticket-alt fa-2x" | "fas fa-tags fa-2x" | "fas fa-shipping-fast fa-2x" | "fas fa-boxes fa-2x" | "fas fa-file-invoice-dollar fa-2x" | "fas fa-shopping-basket fa-2x";
     getIcon2: (data_type: any) => "fas fa-ticket-alt fa-2x" | "fas fa-tags fa-2x" | "fas fa-percent fa-2x";
-    getTypeLabel(type: string): string;
-    shouldShowItem(type: string): boolean;
+    getTypeLabel(type: string, item?: CheckoutData): string;
+    shouldShowItem(type: string, item?: CheckoutData): boolean;
     shouldHideSubtotal(item: any): boolean;
     getAmountView(item: CheckoutData): import("../../../utils/shipping-price-display.service").ShippingPriceViewModel;
     private getShipmentOriginalAmount;

package/lib/interfaces/cart-item.d.ts

@@ -14,14 +14,27 @@ export interface CartItemPromotion {
     /** Nombre legible de la promoción o descuento. */
     name: string;
 }
+/** Valor fiscal explícito de una parte de la línea del carrito. */
+export interface CartLinePricingValue {
+    net: number;
+    tax: number;
+    gross: number;
+}
+/** Contrato aditivo de precios de línea informado por el backend. */
+export interface CartLinePricing {
+    unit: CartLinePricingValue;
+    discount: CartLinePricingValue;
+    subtotal: CartLinePricingValue;
+}
 /**
  * Precios del ítem normalizados por el core para evitar duplicar lógica en cada frontend.
  *
  * @remarks
  * Esta estructura separa tres conceptos distintos:
- * - `basePrice`: precio unitario histórico de la tabla (`saleprice` si existe, si no `price`)
+ * - `basePrice`: precio unitario explícito del carrito cuando el backend lo informa;
+ *   en respuestas legacy, `saleprice` si existe, si no `price`
  * - `strikePrice`: precio tachado de la lógica legacy `price/saleprice`
- * - `finalPrice`: precio unitario neto luego de aplicar `unitPromotions`
+ * - `finalPrice`: precio unitario neto luego de aplicar descuentos propios de la línea
  */
 export interface CartItemPricing {
     /** Precio unitario base que ya usaba el frontend antes de soportar promociones unitarias. */
@@ -55,8 +68,20 @@ export interface CartItem {
     quantity: number;
     variant_id: number;
     total: number;
+    /** Precio unitario explícito del carrito, sin impuestos, cuando lo informa el backend. */
+    unitPrice?: number;
+    /** Descuento total propio de la línea, sin descuentos generales de orden. */
+    discount?: number;
+    /** Subtotal explícito de la línea, sin impuestos ni descuentos generales de orden. */
+    subtotal?: number;
+    /** Impuesto total de la línea, cuando lo informa el backend. */
+    taxTotal?: number;
     /** Promociones unitarias crudas devueltas por backend. */
     unitPromotions?: CartItemPromotion[];
+    /** Valores netos, fiscales y brutos explícitos de la línea del carrito. */
+    linePricing?: CartLinePricing;
+    /** Nombre real serializado por JMS; se normaliza una sola vez en CartService. */
+    line_pricing?: CartLinePricing;
     /** Precios derivados listos para usar en la UI. */
     pricing?: CartItemPricing;
 }

package/lib/interfaces/cart-totals.d.ts

@@ -0,0 +1,19 @@
+/** Valor fiscal explícito utilizado por los totales del carrito. */
+export interface CartTotalPricingValue {
+    net: number;
+    tax: number;
+    gross: number;
+}
+/**
+ * Contratos aditivos serializados por el backend con nombres snake_case.
+ * Las variantes camelCase permiten consumir respuestas ya normalizadas por
+ * integraciones legacy sin crear una segunda transformación global.
+ */
+export interface CartTotalsPricing {
+    order_discount_pricing?: CartTotalPricingValue;
+    coupon_discount_pricing?: CartTotalPricingValue;
+    shipping_pricing?: CartTotalPricingValue;
+    orderDiscountPricing?: CartTotalPricingValue;
+    couponDiscountPricing?: CartTotalPricingValue;
+    shippingPricing?: CartTotalPricingValue;
+}

package/lib/interfaces/channel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configuración de canal utilizada por el core.
+ *
+ * Las propiedades son opcionales para conservar compatibilidad con respuestas
+ * legacy y se mantiene una extensión abierta para el resto de la configuración.
+ */
+export interface Channel {
+    code?: string;
+    type?: string;
+    showPriceWithTaxesWhileBrowsing?: boolean;
+    showTaxLegend?: boolean;
+    hideTaxes?: boolean;
+    hideDiscounts?: boolean;
+    [key: string]: any;
+}

package/lib/interfaces/checkout-data.d.ts

@@ -1,6 +1,7 @@
-export declare type CheckoutDataType = 'total' | 'subtotal' | 'shipment' | 'coupon' | 'discount' | 'taxes' | 'clientTaxes';
+export declare type CheckoutDataType = 'total' | 'subtotal' | 'productsBeforeDiscounts' | 'shipment' | 'coupon' | 'discount' | 'lineDiscount' | 'taxes' | 'clientTaxes';
 export interface CheckoutData {
     type: CheckoutDataType;
     amount: number;
     name: string;
+    taxesIncludedInTotal?: boolean;
 }

package/lib/interfaces/product.d.ts

@@ -1,6 +1,53 @@
 export declare type ProductColor = 'white' | 'black' | 'red' | 'green' | 'purple' | 'yellow' | 'blue' | 'gray' | 'orange' | 'pink';
 export declare type ProductSize = 'M' | 'L' | 'XL';
 export declare type ProductTags = 'nike' | 'puma' | 'lifestyle' | 'caprese';
+/** Valores fiscales explícitos de un precio de producto/variante. */
+export interface ProductPricingValue {
+    net: number;
+    tax: number;
+    gross: number;
+}
+/** Metadatos fiscales del precio informado por el backend. */
+export interface ProductPricingTax {
+    hasTax: boolean;
+    rate: number | null;
+    includedInPrice: boolean | null;
+}
+/** Contrato aditivo de pricing de ProductVariantView. */
+export interface ProductVariantPricing {
+    current: ProductPricingValue;
+    previous: ProductPricingValue | null;
+    tax: ProductPricingTax;
+}
+/** Variante de producto, conservando los campos legacy consumidos por el core. */
+export interface ProductVariant {
+    code?: any;
+    price?: any;
+    saleprice?: any;
+    priceWithoutTaxes?: any;
+    taxes?: any;
+    taxRate?: any;
+    taxIncluded?: any;
+    taxLegendInfo?: any;
+    cartAndSidebarPrices?: any;
+    final_consumer_price?: any;
+    original_final_consumer_price?: any;
+    discount?: any;
+    options?: any[];
+    images?: any[];
+    properties?: any;
+    stock?: number;
+    multipleQuantity?: number;
+    minimumItemsQuantity?: number;
+    maximumItemsQuantity?: number;
+    maximumAmount?: number;
+    minimumAmount?: number;
+    dateCreate?: any;
+    dateExpired?: any;
+    uniqueExternalCode?: any;
+    pricing?: ProductVariantPricing;
+    [key: string]: any;
+}
 export interface Product {
     id?: number;
     category?: string;
@@ -16,7 +63,7 @@ export interface Product {
     tag?: any[];
     rating?: number | string;
     special_mark?: any[];
-    variants?: any[];
+    variants?: ProductVariant[];
     productToCartItem?: ProductToCartItem;
     currentOption?: CurrentOption;
     productWithUniqueVariant?: Product[];

package/lib/services/account/orders.service.d.ts

@@ -20,6 +20,11 @@ export declare class OrdersService {
     constructor(connection: ConnectionService, cartService: CartService, router: Router, consts: Constants);
     updateOrders: () => void;
     mapOrdersAndAddInfo: (orders: any) => any;
+    /**
+     * Normaliza únicamente los aliases de los contratos históricos nuevos.
+     * La respuesta original se conserva para no afectar otros consumidores.
+     */
+    private normalizeOrderPricing;
     setSelectedOrder(order: any): void;
     findOrder: (order_number: any) => any;
     getOrderByNumber: (order_number: any) => any;

package/lib/services/cart.service.d.ts

@@ -11,6 +11,8 @@ import { CartAffordable } from '../interfaces/cart/cart-affordable';
 import { ChannelConfigService } from './channel-config.service';
 import { AnalyticsService } from '../../public-api';
 import { Router } from '@angular/router';
+import { Channel } from '../interfaces/channel';
+import { CartItemPricePresentation, CartSummaryPricePresentation, PricePresentationService } from '../utils/price-presentation.service';
 export declare class CartService {
     private connection;
     private toastrService;
@@ -20,6 +22,7 @@ export declare class CartService {
     private analyticsService;
     private channelConfigService;
     private router;
+    private pricePresentationService;
     private cartItemsSubject;
     private couponSubject;
     private cartSubject;
@@ -63,7 +66,7 @@ export declare class CartService {
     creditAmount$: Observable<number>;
     showMax$: Observable<boolean>;
     showPrice$: Observable<boolean>;
-    constructor(connection: ConnectionService, toastrService: ToastService, consts: Constants, authService: AuthService, orderUtils: OrderUtilityService, analyticsService: AnalyticsService, channelConfigService: ChannelConfigService, router: Router);
+    constructor(connection: ConnectionService, toastrService: ToastService, consts: Constants, authService: AuthService, orderUtils: OrderUtilityService, analyticsService: AnalyticsService, channelConfigService: ChannelConfigService, router: Router, pricePresentationService: PricePresentationService);
     getCart2(): CartItem[];
     getAddressBook: () => Promise<any>;
     getTaxes: () => Promise<import("rxjs").Subscription>;
@@ -138,9 +141,13 @@ export declare class CartService {
     getCartToken: () => any;
     getLocale: () => string;
     getTotalAmount: () => Observable<number>;
+    /** Total para carrito/sidebar, sin envío persistido ni recargos de checkout. */
+    getCartTotalAmount: () => Observable<number>;
     getCountCartItems: () => Observable<number>;
     getTaxesAmount: () => Observable<number>;
     getSubTotalAmount: () => Observable<number>;
+    getCartTaxesAmount: () => Observable<number>;
+    getCartClientTaxesAmount: () => Observable<number>;
     /**
      * Devuelve el descuento que debe mostrarse en el resumen de compra.
      *
@@ -152,10 +159,13 @@ export declare class CartService {
      * ```
      *
      * @remarks
-     * Si el backend nuevo informa `totals.promotionBreakdown.orderPromotions`, se usa ese valor.
-     * Si todavía no existe, el método hace fallback a `totals.promotion` para mantener compatibilidad.
+     * Si el backend nuevo informa `totals.orderDiscount`, se usa ese valor.
+     * En su ausencia, prioriza `totals.promotionBreakdown.orderPromotions` y
+     * luego hace fallback a `totals.promotion` para mantener compatibilidad.
      */
     getSummaryPromotionAmount: () => Observable<number>;
+    /** Descuento específico del cupón, si el backend lo informa por separado. */
+    getCouponPromotionAmount: () => Observable<number>;
     /**
      * Indica si existe un cupón aplicado en el carrito actual.
      *
@@ -182,6 +192,17 @@ export declare class CartService {
      * ```
      */
     getItemPricing: (item: CartItem) => CartItemPricing;
+    /** Resuelve la presentación nueva de una línea y conserva el fallback legacy. */
+    getCartItemPricePresentation: (item: CartItem, channel?: Channel) => CartItemPricePresentation;
+    /** Resuelve el resumen visible usando linePricing sin convertir importes fiscales. */
+    getCartSummaryPricePresentation: (cart?: any, channel?: Channel, includeShipping?: boolean) => CartSummaryPricePresentation;
+    /** Normaliza sólo el alias serializado del contrato de línea. */
+    private normalizeCartItemPricing;
+    /**
+     * Lee el contrato nuevo sin confundir un objeto válido con fallback legacy,
+     * incluso cuando todos sus importes son cero.
+     */
+    private getTotalsPricing;
     addCoupon: (code: any) => Promise<any>;
     removeCoupon: () => Promise<boolean>;
     formatCoupon: (cart: any) => void;
@@ -214,8 +235,8 @@ export declare class CartService {
      * @example
      * ```ts
      * const pricing = this.buildCartItemPricing(item);
-     * // pricing.basePrice => saleprice si existe, si no price
-     * // pricing.finalPrice => basePrice + unitPromotionTotal
+     * // pricing.basePrice => unitPrice del backend nuevo o fallback legacy
+     * // pricing.finalPrice => unitPrice del backend nuevo o cálculo legacy
      * // pricing.effectiveDiscountPercent => % total contra el precio de referencia
      * ```
      */

package/lib/utils/order-util.service.d.ts

@@ -46,6 +46,28 @@ export declare class OrderUtilityService {
      * Con backends viejos hace fallback a `totals.promotion` o `totals.discount`.
      */
     getSummaryPromotionAmount: (cart: any) => number;
+    /** Descuento de orden separado de cupones y descuentos de envío. */
+    getOrderPromotionAmount: (cart: any) => number;
+    /**
+     * Obtiene únicamente el descuento aplicado por el cupón.
+     *
+     * Devuelve `null` cuando la respuesta no permite identificar su importe,
+     * para que el frontend pueda mostrar solamente el código.
+     */
+    getCouponPromotionAmount: (cart: any) => number;
+    /**
+     * Obtiene el subtotal compatible con backends nuevos y legacy.
+     *
+     * @param cart Carrito u orden con `totals`.
+     * @returns `totals.subtotal` cuando existe; en backends legacy usa `totals.items`.
+     */
+    getSummarySubtotalAmount: (cart: any) => number;
+    /** Total que debe mostrar el carrito/sidebar, excluyendo envío persistido. */
+    getCartTotalAmount: (cart: any) => number;
+    /** Impuestos de productos para carrito/sidebar, con fallback legacy. */
+    getCartTaxesAmount: (cart: any) => number;
+    /** Impuestos específicos del cliente para carrito/sidebar, con fallback legacy. */
+    getCartClientTaxesAmount: (cart: any) => number;
     /**
      * Indica si el backend ya informa el desglose nuevo de promociones.
      *

package/lib/utils/price-presentation.service.d.ts

@@ -0,0 +1,56 @@
+import { Channel } from '../interfaces/channel';
+import { ProductVariant } from '../interfaces/product';
+import { CartItem, CartItemPricing } from '../interfaces/cart-item';
+export declare type PricePresentationValue = number | string;
+export interface PricePresentation {
+    primary: PricePresentationValue;
+    previous: PricePresentationValue | null;
+    secondary: number | null;
+    hasTax: boolean;
+    tax: number;
+    taxRate: number | null;
+    includedInPrice: boolean | null;
+    source: 'pricing' | 'legacy';
+}
+export interface CartItemPricePresentation {
+    unitPrice: number;
+    discount: number;
+    subtotal: number;
+    previous: number | null;
+    secondary: number | null;
+    hasTax: boolean;
+    tax: number;
+    taxRate: number | null;
+    includedInPrice: boolean | null;
+    source: 'linePricing' | 'legacy';
+}
+export interface CartSummaryPricePresentation {
+    productsBeforeDiscounts: number;
+    lineDiscounts: number;
+    subtotal: number;
+    orderDiscount: number;
+    couponDiscount: number | null;
+    taxes: number;
+    clientTaxes: number;
+    shipping: number | null;
+    total: number;
+    taxesIncludedInTotal: boolean;
+    source: 'linePricing' | 'legacy';
+}
+export declare class PricePresentationService {
+    /** Resuelve únicamente qué valor presentar; no calcula impuestos. */
+    getProductPricePresentation(variant: ProductVariant | any, channel?: Channel | any): PricePresentation;
+    /**
+     * Resuelve los importes visibles de una línea sin convertir ni recalcular
+     * valores fiscales. `legacyPricing` debe ser el resultado ya normalizado
+     * por CartService para conservar exactamente el fallback histórico.
+     */
+    getCartItemPricePresentation(item: CartItem | any, channel?: Channel | any, legacyPricing?: CartItemPricing): CartItemPricePresentation;
+    private fromPricing;
+    private fromLegacy;
+    private legacyValue;
+    private isPricingContract;
+    private isValue;
+    private isFiniteNumber;
+    private isCartLinePricing;
+}