ng-easycommerce-v18 0.3.19-beta.1 → 0.3.20-beta.1

package/lib/classes/filters/attributes-filter.d.ts

@@ -1,14 +1,38 @@
 import { FilterElement, FilterType } from "../../interfaces";
 import { Filter } from "./filter";
+import { Params } from "@angular/router";
+/**
+ * AttributesFilter
+ * - Gestiona el filtro de atributos (estructura de padres/children).
+ * - Soporta hidratación desde query params y aplicación de códigos seleccionados.
+ */
 export declare class AttributesFilter extends Filter {
     private _optionsService;
     data: FilterElement[];
     multi: boolean;
+    private _codesFromQuery;
     constructor(initialValue?: any, options?: any);
     type(): FilterType;
     setContent(options: any, initialValue?: any): void;
     getContent(): FilterElement[];
+    /**
+     * ADDED: toUrlParams construye la porción de query string que representa las selecciones de atributos.
+     */
     toUrlParams(actual_url?: string, sublist?: any, already?: any): string;
     cleanResult(text: string): string;
+    /**
+     * ADDED: createElement transforma cada nodo original en FilterElement y marca selección inicial si corresponde.
+     */
     createElement(filter: any, original: any, initialValue?: any): any;
+    /** hidratar desde la URL */
+    hydrateFromQuery(params: Params): void;
+    /**
+     * ADDED: applyCodes recorre la estructura y marca selected=true en los children cuyo código está en 'codes'.
+     * Además marca el parent como seleccionado si alguno de sus hijos lo está.
+     */
+    private applyCodes;
+    /**
+     * ADDED: clearSelection desmarca todos los parents y children (restablece el filtro).
+     */
+    private clearSelection;
 }

package/lib/classes/filters/category-filter.d.ts

@@ -1,14 +1,41 @@
 import { FilterElement, FilterType } from "../../interfaces";
 import { Filter } from "./filter";
+/**
+ * CategoryFilter
+ * - Gestiona el filtro de categorías.
+ * - Mantiene la estructura de categorías (parents/children) y permite:
+ *   * Inicializar desde OptionsService.
+ *   * Marcar elementos según slug o query param.
+ *   * Generar porción de query string (&category=...).
+ */
 export declare class CategoryFilter extends Filter {
-    private initialValues?;
     private _optionsService;
+    private _filtersService;
     data: FilterElement[];
     multi: boolean;
-    constructor(initialValues?: any);
+    constructor(initialValue?: any);
     type(): FilterType;
     setContent(options: any, initialValue?: any): void;
     getContent(): FilterElement[];
-    toUrlParams(actual_url?: string, sublist?: any): string;
+    /**
+     * toUrlParams
+     * - Recorre la estructura y devuelve la porción de query string para la categoría seleccionada.
+     * - Prioriza el primer selected encontrado (solo una categoría se envía).
+     */
+    toUrlParams(): string;
     createElement(filter: any, original: any, initialValue?: any): any;
+    /**
+     * setFromSlug
+     * - Marca como selected los nodos cuyo slug/path/name coincide con el slug proporcionado.
+     * - Utiliza removeAccents para comparar sin tildes y en minúsculas.
+     * - No retorna valor, solo modifica this.data.
+     */
+    setFromSlug(slug: string): void;
+    /**
+     * hydrateFromQuery
+     * - Marca la categoría según el parámetro de query 'category' si existe.
+     * - Busca el code exacto en la estructura y marca el nodo correspondiente.
+     * - Loggea si se encontró o no la categoría.
+     */
+    hydrateFromQuery(query: any): void;
 }

package/lib/constants/api.constants.service.d.ts

@@ -7,6 +7,7 @@ import * as i0 from "@angular/core";
 export declare class ApiConstantsService {
     private _localStorage;
     private _translate;
+    private _runtimeConfig;
     /**
      * Contiene los datos provisto por el frontend en el archivo environment.ts
      */

package/lib/constants/core.constants.service.d.ts

@@ -27,6 +27,11 @@ export declare class CoreConstantsService {
      * Guarda la variable window del web browser.
      */
     private window?;
+    /**
+     * Tipo de ruta actual (ej: 'categories', 'attributes', etc).
+     * Lo usamos para que PaginationService sepa qué filtro esperar.
+     */
+    currentRouteType: string | null;
     constructor();
     /**
      * Path usado en las colecciones de productos.
@@ -144,6 +149,8 @@ export declare class CoreConstantsService {
     getParamsProductsWithUniqueVariant: () => ParamsProductsWithUniqueVariant;
     getChannel(): string;
     form_sender: boolean;
+    setCurrentRouteType(type: string | null): void;
+    getCurrentRouteType(): string | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreConstantsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CoreConstantsService>;
 }

package/lib/ec-components/abstractions-components/menu-ec.component.d.ts

@@ -75,6 +75,18 @@ export declare class MenuEcComponent {
    * @returns true si la categoría es visible, false en caso contrario
    */
     hasVisibleProperty(category: Category): boolean;
+    private filterVisibleTree;
+    categoriesVisible$: Observable<Category[]>;
+    sectionsVisible$: Observable<Section[]>;
+    attributesVisible$: Observable<Attribute[]>;
+    getVisibleChildren<T extends {
+        isVisible?: boolean;
+        children?: T[];
+    }>(node?: T): T[];
+    hasVisibleChildren<T extends {
+        isVisible?: boolean;
+        children?: T[];
+    }>(node?: T): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuEcComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MenuEcComponent, "lib-footer-ec", never, {}, {}, never, never, true, never>;
 }

package/lib/ec-components/auth-ec/login-form-ec/login-form-ec.component.d.ts

@@ -2,10 +2,12 @@ import { EventEmitter } from '@angular/core';
 import { UserRoleType } from '../../../interfaces';
 import * as i0 from "@angular/core";
 export declare class LoginFormEcComponent {
+    private platformId;
     private _authService;
     private _formBuilder;
     private _toastService;
     private _router;
+    constructor(platformId: Object);
     showPassword: boolean;
     /**
      * Parametro para indicar si tras loguear

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

@@ -16,8 +16,8 @@ export declare class CartItemEcComponent implements OnInit {
     isQuantityUpdating: boolean;
     ngOnInit(): void;
     updateQuantity(stock: number): void;
-    plus(stock: number, value?: number): void;
     less(stock: number, value?: number): void;
+    plus(stock: number, value?: number): void;
     deleteCartItem(): void;
     getVariants(product: any): any;
     createDiscountMessage(saleprice: number, price: number): string;

package/lib/ec-components/collection-ec/collection-ec.component.d.ts

@@ -1,4 +1,4 @@
-import { OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { DefaultFilter, FilterType, Product } from '../../interfaces';
 import { AuthService, OptionsService, ProductsService } from '../../ec-services';
 import { ActivatedRoute } from '@angular/router';
@@ -6,10 +6,11 @@ import { CoreConstantsService } from '../../constants';
 import { Observable } from 'rxjs';
 import { Filter } from '../../classes';
 import * as i0 from "@angular/core";
-export declare class CollectionEcComponent implements OnInit {
+export declare class CollectionEcComponent implements OnInit, OnDestroy {
     protected _productsService: ProductsService;
     protected _activeRoute: ActivatedRoute;
     protected _optionsService: OptionsService;
+    private _filtersService;
     params$: Observable<import("@angular/router").Params>;
     queryParams$: Observable<import("@angular/router").Params>;
     products$: Observable<Product[]>;
@@ -22,17 +23,17 @@ export declare class CollectionEcComponent implements OnInit {
     private loaded;
     optionsFilters: FilterType[];
     filters_sort: Filter[];
-    private _filtersService;
     filters$: Observable<Filter[]>;
     ready$: Observable<boolean>;
     private window?;
     isList: boolean;
+    private destroy$;
     setAsList: (value: boolean) => boolean;
     ngOnInit(): void;
     private total;
     private platformId;
     constructor();
-    getProducts(): void;
+    ngOnDestroy(): void;
     onScroll(): void;
     productHasStock(product: Product): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CollectionEcComponent, never>;

package/lib/ec-components/filters-ec/filters-ec.component.d.ts

@@ -15,6 +15,7 @@ export declare class FiltersEcComponent {
     injector: Injector;
     isAuthenticated$: boolean;
     hidePrices: boolean;
+    private route;
     setSelect: any;
     ngOnInit(): void;
     constructor();
@@ -23,6 +24,18 @@ export declare class FiltersEcComponent {
     /** 2) Para cualquier otro FilterType, devuelvo Filter */
     getSpecificFilter(type: FilterType): Filter | null;
     onSelect(event: any, filter: FilterElement[] | null): void;
+    /**
+     * Maneja el click sobre un elemento de filtro (categoría, atributo, etc.).
+     *
+     * - Para categorías: navega a la URL de la categoría.
+     * - Para atributos: actualiza la query string de la URL con `attributeCodes`.
+     * - Para otros filtros: delega en FiltersService para marcar seleccionado.
+     *
+     * La idea es que **la URL siempre represente los filtros aplicados**,
+     * de modo que:
+     *   - al hacer F5 no se pierdan los filtros,
+     *   - los links sean compartibles (deep linking).
+     */
     setSelected(filter: Filter | null, selected: FilterElement | null): void;
     uniqueSelection(filter: {
         data: any[];
@@ -31,11 +44,19 @@ export declare class FiltersEcComponent {
     scrollUp: () => boolean;
     hasAppliedFilters(): boolean;
     /**
-       * Verifica si una categoría tiene la propiedad isVisible y está marcada como visible
-       * @param category - La categoría a verificar
-       * @returns true si la categoría es visible, false en caso contrario
-       */
+     * Verifica si una categoría tiene la propiedad isVisible y está marcada como visible
+     * @param category - La categoría a verificar
+     * @returns true si la categoría es visible, false en caso contrario
+     */
     hasVisibleProperty(category: FilterElement): boolean;
+    /** Lista visible (filtra recursivo por isVisible) */
+    getVisibleData(filter: Filter | null): FilterElement[];
+    /** Children visibles de un nodo */
+    getVisibleChildren(node?: FilterElement): FilterElement[];
+    /** Tiene hijos visibles? */
+    hasVisibleChildren(node?: FilterElement): boolean;
+    /** Utilidad recursiva */
+    private filterVisibleTree;
     static ɵfac: i0.ɵɵFactoryDeclaration<FiltersEcComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FiltersEcComponent, "lib-filters-ec", never, { "setSelect": { "alias": "setSelect"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/ec-components/price-range-filter/price-range-filter.component.d.ts

@@ -3,6 +3,8 @@ import { PriceRangeFilter } from '../../classes/filters/price_range-filter';
 import * as i0 from "@angular/core";
 export declare class PriceRangeFilterComponent {
     private _filtersService;
+    private router;
+    private route;
     priceGap: number;
     roundStep: number;
     filter: PriceRangeFilter;

package/lib/ec-components/product-ec/product-ec.component.d.ts

@@ -50,10 +50,6 @@ export declare class ProductEcComponent implements OnInit {
     plus(stock?: number, multipleQuantity?: number): void;
     less(multipleQuantity?: number): void;
     addToCart(): void;
-    /**
-     * Valida las restricciones de cantidad del producto
-     */
-    private validateQuantity;
     checkStock(stock: number): void;
     onQuantityChange(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductEcComponent, never>;

package/lib/ec-services/analytics/gtm.service.d.ts

@@ -23,6 +23,7 @@ export declare class GTMService {
     private window?;
     private rendererFactory;
     private document;
+    private platformId;
     /**
      * Servicio de ruteo de angular.
      */
@@ -31,7 +32,6 @@ export declare class GTMService {
      * Configuración de Google Tag Manager.
      */
     private config;
-    private platformId;
     constructor();
     /**
      * Obtiene el dataLayer del objecto window

package/lib/ec-services/base-api.service.d.ts

@@ -0,0 +1,64 @@
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { RuntimeConfigService } from './runtime-config.service';
+import * as i0 from "@angular/core";
+export interface ApiRequestOptions {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    params?: HttpParams | {
+        [param: string]: string | string[];
+    };
+    withCredentials?: boolean;
+}
+/**
+ * Servicio base para realizar peticiones HTTP usando configuración dinámica
+ * Todos los servicios de la aplicación deben extender este servicio o usar sus métodos
+ */
+export declare class BaseApiService {
+    protected http: HttpClient;
+    protected runtimeConfigService: RuntimeConfigService;
+    constructor(http: HttpClient, runtimeConfigService: RuntimeConfigService);
+    /**
+     * Construye una URL completa usando la API_URL del runtime
+     */
+    protected buildApiUrl(endpoint: string): string;
+    /**
+     * Obtiene headers comunes que incluyen información del runtime
+     */
+    protected getCommonHeaders(): HttpHeaders;
+    /**
+     * Método GET genérico
+     */
+    get<T>(endpoint: string, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método POST genérico
+     */
+    post<T>(endpoint: string, data: any, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método PUT genérico
+     */
+    put<T>(endpoint: string, data: any, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método PATCH genérico
+     */
+    patch<T>(endpoint: string, data: any, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método DELETE genérico
+     */
+    delete<T>(endpoint: string, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método para peticiones que necesitan esperar a que la config esté cargada
+     */
+    getWithConfig<T>(endpoint: string, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Método para POST que necesitan esperar a que la config esté cargada
+     */
+    postWithConfig<T>(endpoint: string, data: any, options?: ApiRequestOptions): Observable<T>;
+    /**
+     * Combina headers personalizados con los headers comunes
+     */
+    private mergeHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseApiService>;
+}

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

@@ -115,7 +115,7 @@ export declare class CartService {
      * @param item el item a actualizar.
      * @param quantity la cantidad nueva.
      */
-    updateItemQuantity(item: CartItem, quantity: number): boolean;
+    updateItemQuantity(item: CartItem, quantity: number): void;
     /**
      * Maneja el error en caso de que no se pueda agregar al carrito el producto.
      * @param err

package/lib/ec-services/filters.service.d.ts

@@ -1,6 +1,7 @@
 import { Observable } from 'rxjs';
 import { Filter } from '../classes';
 import { FilterElement, PaginationSettings, FilterType } from '../interfaces';
+import { Params } from '@angular/router';
 import * as i0 from "@angular/core";
 export declare class FiltersService {
     private _apiConsts;
@@ -16,6 +17,7 @@ export declare class FiltersService {
     private _defaultFilters;
     private _paginationSettings;
     private _filtersInitialized;
+    private _lastRouteQuery;
     constructor();
     /**
      * Retorna la url para el filtrado
@@ -30,7 +32,7 @@ export declare class FiltersService {
      */
     generateFinalApi(search_value?: string): string;
     private isUpdated;
-    setFilters(paginationSettings: PaginationSettings, search_value?: string): void;
+    setFilters(paginationSettings: PaginationSettings, search_value?: string, routeQueryParams?: any): void;
     getFilters(paginationSettings?: PaginationSettings): Filter[] | undefined;
     getSpecificFilters(types: FilterType[]): Filter[];
     setFilterSelected(filterObj: Filter, filterElem: FilterElement): void;
@@ -40,6 +42,21 @@ export declare class FiltersService {
      * el array de filtros para que PaginationService vuelva a llamar
      */
     updatePriceRangeFilter(min: number, max: number): void;
+    /**
+     * Fuerza a emitir de nuevo los filtros actuales.
+     * Útil cuando un filtro async (categorías, atributos) termina de cargarse
+     * y necesitamos que PaginationService vuelva a armar la URL.
+     */
+    refreshFilters(): void;
+    /**
+     * Punto central donde se hidratan los filtros a partir de la URL:
+     * - Lee type/value de la ruta (ej. /collection/categories/:value).
+     * - Lee query params (category, price_min, price_max, attributeCodes, search, etc.).
+     * - Crea instancias de filtros y les delega la hidratación específica.
+     *
+     * Este método se llama tanto en SSR como en navegador.
+     */
+    hydrateFromRoute(paginationSettings: PaginationSettings, routeParams: Params, routeQuery: Params): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FiltersService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FiltersService>;
 }

package/lib/ec-services/index.d.ts

@@ -24,3 +24,5 @@ export * from './order-utility.service';
 export * from './payment.service';
 export * from './test.service';
 export * from './orders.service';
+export * from './runtime-config.service';
+export * from './base-api.service';

package/lib/ec-services/pagination.service.d.ts

@@ -3,14 +3,30 @@ import { Pagination, Product } from '../interfaces';
 import { Filter } from '../classes';
 import * as i0 from "@angular/core";
 /**
- * Servicio para manejar la paginación de los productos.
- * @class PaginationService
+ * Servicio para manejar la paginación y la carga de productos.
+ *
+ * Se encarga de:
+ * - Escuchar los cambios en los filtros (categorías, atributos, precio, búsqueda, etc.).
+ * - Construir la URL al backend con esos filtros.
+ * - Pedir los productos al endpoint de product-search.
+ * - Exponer un observable con la última página de productos (`paginationData$`)
+ *   y otros helpers (precio mínimo/máximo, siguiente página, etc.).
  */
 export declare class PaginationService {
     private _connectionService;
     private _filtersService;
     private _constants;
-    paginationData$: Observable<any>;
+    /**
+     * Flujo principal: a partir de los filtros → arma URL → consulta backend → devuelve productos.
+     *
+     * Pasos:
+     * 1) Espera a que `FiltersService` emita filtros válidos.
+     * 2) Construye la URL final con `buildUrl()`.
+     * 3) Evita repetir llamadas si la URL no cambió (`distinctUntilChanged`).
+     * 4) Llama al backend con `getData(url)`.
+     * 5) Comparte el último resultado con todos los suscriptores (`shareReplay(1)`).
+     */
+    paginationData$: Observable<Product[]>;
     private _dataPagination;
     private _waiting;
     private _finished;
@@ -85,11 +101,11 @@ export declare class PaginationService {
      */
     buildUrl(filters: Filter[]): string;
     /**
-     * Devuelve un observable de los productos que devolvio la última página obtenida.
+     * Devuelve un observable de los productos que devolvió la última página obtenida.
      * @param url
      * @returns
      */
-    getData(url: string): Observable<any>;
+    getData(url: string): Observable<Product[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaginationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PaginationService>;
 }

package/lib/ec-services/products.service.d.ts

@@ -25,7 +25,7 @@ export declare class ProductsService {
      * @param paginationSettings
      * @param searchValue
      */
-    getProductsForFilter(paginationSettings?: PaginationSettings, searchValue?: any): any;
+    getProductsForFilter(paginationSettings?: PaginationSettings, searchValue?: any, routeQueryParams?: any): any;
     /**
      * Actualiza los productos con los de la siguiente pagina.
      */

package/lib/ec-services/runtime-config.service.d.ts

@@ -0,0 +1,63 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { RuntimeConfig } from '../interfaces/runtime-config';
+import * as i0 from "@angular/core";
+export declare class RuntimeConfigService {
+    private platformId;
+    private http;
+    private configSubject;
+    config$: Observable<RuntimeConfig | null>;
+    private _config;
+    private _loadPromise;
+    private _isLoaded;
+    constructor(platformId: Object, http: HttpClient);
+    /**
+     * Inicialización única - llamada por APP_INITIALIZER
+     * Garantiza que la configuración se carga solo una vez al inicio
+     */
+    initialize(): Promise<RuntimeConfig>;
+    /**
+     * Carga la configuración en runtime (optimizada para una sola carga)
+     * - En SSR: Lee desde el objeto window inyectado por el servidor
+     * - En Browser: Hace petición HTTP a /runtime-config.json (solo si no está en window)
+     */
+    loadConfig(): Observable<RuntimeConfig>;
+    /**
+     * Obtiene la configuración actual (síncrono)
+     */
+    getConfig(): RuntimeConfig | null;
+    /**
+     * Obtiene la API URL actual
+     */
+    getApiUrl(): string;
+    /**
+     * Obtiene la Frontend URL actual
+     */
+    getFrontendUrl(): string | undefined;
+    /**
+     * Obtiene el entorno actual
+     */
+    getAppEnv(): string;
+    /**
+     * Verifica si estamos en producción
+     */
+    isProduction(): boolean;
+    /**
+     * Obtiene el locale actual
+     */
+    getLocale(): string;
+    /**
+     * Obtiene el canal actual
+     */
+    getChannel(): string;
+    /**
+     * Método helper para construir URLs de API
+     */
+    buildApiUrl(endpoint: string): string;
+    /**
+     * Método helper para construir URLs del frontend
+     */
+    buildFrontendUrl(path: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeConfigService>;
+}

package/lib/interceptors/index.d.ts

@@ -1 +1,2 @@
 export * from './auth.interceptor';
+export * from './runtime-config.interceptor';

package/lib/interceptors/runtime-config.interceptor.d.ts

@@ -0,0 +1,7 @@
+import { HttpInterceptorFn } from '@angular/common/http';
+/**
+ * Interceptor que garantiza que las peticiones HTTP no se hagan hasta que
+ * el runtime config esté completamente cargado
+ * Evita que se hagan peticiones con URLs incorrectas
+ */
+export declare const runtimeConfigInterceptor: HttpInterceptorFn;

package/lib/interfaces/environment.d.ts

@@ -4,4 +4,5 @@ export interface Environment {
     frontendUrl?: string;
     locale: string;
     channel: string;
+    appEnv?: string;
 }

package/lib/interfaces/filter.d.ts

@@ -20,6 +20,7 @@ export interface FilterElement {
     title: string;
     type: ElementType;
     code: string;
+    isVisible?: boolean;
     multi?: boolean;
     children?: FilterElement[];
     shape?: FilterShape;

package/lib/interfaces/index.d.ts

@@ -16,3 +16,4 @@ export * from './coupon';
 export * from './step';
 export * from './checkout';
 export * from './faqs';
+export * from './runtime-config';

package/lib/interfaces/options.d.ts

@@ -4,6 +4,7 @@ export interface Category {
     slug: string;
     position: number;
     path: string;
+    isVisible?: boolean;
     children?: Category[];
     images?: any[];
 }
@@ -23,4 +24,5 @@ export interface Attribute {
     slug: string;
     useToFilter: boolean;
     styles?: any[];
+    isVisible?: boolean;
 }

package/lib/interfaces/product.d.ts

@@ -5,9 +5,6 @@ export interface OptionValue {
     name: string;
     description?: string;
     selected?: boolean;
-    maximumItemsQuantity?: number;
-    minimumItemsQuantity?: number;
-    multipleQuantity?: number;
 }
 export interface Options {
     code: string;
@@ -37,9 +34,6 @@ export interface Product {
     productWithUniqueVariant?: Product[];
     stock?: number;
     variant_id?: number;
-    maximumItemsQuantity?: number;
-    minimumItemsQuantity?: number;
-    multipleQuantity?: number;
 }
 export interface ProductToCartItem {
     productCode?: string;

package/lib/interfaces/runtime-config.d.ts

@@ -0,0 +1,22 @@
+export interface RuntimeConfig {
+    apiUrl: string;
+    frontendUrl?: string;
+    /** Ambiente de la aplicación. Valores válidos: 'prod', 'preprod', 'test' */
+    appEnv: 'prod' | 'preprod' | 'test';
+    production: boolean;
+    locale: string;
+    channel: string;
+    port?: number;
+    host?: string;
+}
+export interface ServerEnvironmentVariables {
+    API_URL?: string;
+    FRONTEND_URL?: string;
+    /** Ambiente de la aplicación. Valores válidos: 'prod', 'preprod', 'test' */
+    APP_ENV?: 'prod' | 'preprod' | 'test';
+    PORT?: string;
+    HOST?: string;
+    NODE_ENV?: 'development' | 'production';
+    LOCALE?: string;
+    CHANNEL?: string;
+}

package/lib/providers/index.d.ts

@@ -1 +1,2 @@
 export * from './provideEnvironment';
+export * from './provideRuntimeConfig';

package/lib/providers/provideRuntimeConfig.d.ts

@@ -0,0 +1,13 @@
+import { EnvironmentProviders } from '@angular/core';
+import { RuntimeConfigService } from '../ec-services/runtime-config.service';
+/**
+ * Factory function para APP_INITIALIZER (OPTIMIZADA)
+ * Carga la configuración runtime UNA SOLA VEZ antes de que Angular bootstrap la aplicación
+ * Evita múltiples cargas y mejora el rendimiento
+ */
+export declare function initializeRuntimeConfig(runtimeConfigService: RuntimeConfigService): () => Promise<any>;
+/**
+ * Función que configura el RuntimeConfigService y su inicialización
+ * Debe ser usado en app.config.ts junto con provideEnvironment
+ */
+export declare function provideRuntimeConfig(): EnvironmentProviders;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-easycommerce-v18",
-  "version": "0.3.19-beta.1",
+  "version": "0.3.20-beta.1",
   "peerDependencies": {
     "@angular/common": "^18.2.0",
     "@angular/core": "^18.2.0"