ng-easycommerce-v18 0.0.1 → 0.0.2

package/esm2022/lib/classes/filters/filter.mjs

@@ -0,0 +1,83 @@
+export class Filter {
+    data = [];
+    multi = false;
+    type() {
+        throw new Error("Method not implemented.");
+    }
+    setContent(options) {
+        throw new Error("Method not implemented.");
+    }
+    getContent() {
+        throw new Error("Method not implemented.");
+    }
+    toUrlParams() {
+        throw new Error("Method not implemented.");
+    }
+    createElement(filter, original, initialValue) {
+        throw new Error("Method not implemented.");
+    }
+    removeAccents = (str) => {
+        return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    };
+    setSelected(element, value) {
+        //console.log(element, value);
+        ((element.multi != undefined) && !element.multi) ? this.cleanFilter(this.data, element) : null;
+        this.setSelectedValue(element, value);
+    }
+    cleanFilter = (data, element_to_change) => {
+        //console.log("cleanFilter");
+        element_to_change && data.forEach((element) => {
+            element_to_change != element ? element.selected = false : null;
+            (element.children && element.children.length > 0) && this.cleanFilter(element.children, element_to_change);
+        });
+    };
+    setSelectedValue(element, value, sublist, multi) {
+        let elements = sublist || this.data;
+        let index = elements.findIndex((subelement) => {
+            return (element.code || element) == subelement.code;
+        });
+        if (index >= 0) {
+            elements[index].selected = elements[index].selected ? false : true;
+            !multi && elements.forEach((child, i) => {
+                if (i != index)
+                    child.selected = false;
+            });
+            return {
+                elements,
+                founded: true
+            };
+        }
+        else {
+            elements.some((elem) => elem.type == 'sub') && elements.some((filter) => {
+                let founded = false;
+                if (filter.type == 'sub') {
+                    const result = this.setSelectedValue(element, value, filter.children, filter.multi);
+                    if (result && result.founded) {
+                        filter.children = result.elements;
+                        founded = true;
+                    }
+                }
+                return founded;
+            });
+        }
+        return null;
+    }
+    ;
+    getSelectedList = () => this.findSelected(this.data, []);
+    findSelected = (elements, result) => {
+        let element = elements.find(elem => elem.selected);
+        if (element) {
+            result.push(element.code);
+            return result;
+        }
+        elements.forEach(elem => {
+            if (elem.children && elem.children.length) {
+                let new_result = this.findSelected(elem.children, result);
+                if (new_result)
+                    result = new_result;
+            }
+        });
+        return result;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../../../../../projects/ng-easycommerce-v18/src/lib/classes/filters/filter.ts"],"names":[],"mappings":"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","sourcesContent":["import { FilterElement, FilterType, IFilter } from \"../../interfaces\";\n\nexport class Filter implements IFilter  {\n    \n    data: FilterElement[] = [];\n    multi: boolean = false;\n    \n    type(): FilterType {\n        throw new Error(\"Method not implemented.\");\n    }\n    setContent(options: any): void {\n        throw new Error(\"Method not implemented.\");\n    }\n    getContent(): FilterElement[] {\n        throw new Error(\"Method not implemented.\");\n    }\n    toUrlParams(): string {\n        throw new Error(\"Method not implemented.\");\n    }\n    createElement(filter: any, original: any, initialValue?: any) {\n        throw new Error(\"Method not implemented.\");\n    }\n    removeAccents = (str:string) => {\n        return str.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\");\n    }\n\n    setSelected(element:any, value?:any){\n        //console.log(element, value);\n        ((element.multi != undefined) && !element.multi) ? this.cleanFilter(this.data, element) : null;\n        this.setSelectedValue(element, value);\n    }\n\n    cleanFilter = (data:any, element_to_change:any) => {\n        //console.log(\"cleanFilter\");\n        element_to_change && data.forEach((element:any) => {\n            element_to_change != element ? element.selected = false : null;\n            (element.children && element.children.length > 0) && this.cleanFilter(element.children, element_to_change);\n        })\n    }\n\n    setSelectedValue(element:any, value?:any, sublist?:any, multi?:any){\n        let elements = sublist || this.data;\n        let index = elements.findIndex((subelement:any) => {\n            return (element.code || element) == subelement.code;\n        });\n        if (index >= 0) {\n            elements[index].selected = elements[index].selected ? false : true;\n            !multi && elements.forEach((child:any, i:number) => {\n                if (i != index) child.selected = false;\n            });\n            return {\n                elements,\n                founded: true\n            };\n        } else {\n            elements.some((elem:any) => elem.type == 'sub') && elements.some(\n                (filter:any) => {\n                    let founded = false;\n                    if (filter.type == 'sub') {\n                        const result = this.setSelectedValue(element, value, filter.children, filter.multi);\n                        if (result && result.founded) {\n                            filter.children = result.elements;\n                            founded = true;\n                        }\n                    }\n                    return founded;\n                }\n            )\n        }\n        return null;\n    };\n\n    getSelectedList = (): any => this.findSelected(this.data, []);\n\n    findSelected = (elements: any[], result:any) => {\n        let element = elements.find(elem => elem.selected);\n        if (element) {\n            result.push(element.code);\n            return result;\n        }\n        elements.forEach(elem => {\n            if (elem.children && elem.children.length) {\n                let new_result = this.findSelected(elem.children, result);\n                if (new_result) result = new_result;\n            }\n        })\n        return result;\n    }\n}\n"]}

package/esm2022/lib/classes/filters/index.mjs

@@ -0,0 +1,7 @@
+export * from './category-filter';
+export * from './attributes-filter';
+export * from './dynamics-filter';
+export * from './sort-filter';
+export * from './filter-factory';
+export * from './filter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvY2xhc3Nlcy9maWx0ZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWEsbUJBQW1CLENBQUM7QUFDakMsY0FBYSxxQkFBcUIsQ0FBQztBQUNuQyxjQUFhLG1CQUFtQixDQUFDO0FBQ2pDLGNBQWEsZUFBZSxDQUFDO0FBQzdCLGNBQWEsa0JBQWtCLENBQUM7QUFDaEMsY0FBYSxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tJy4vY2F0ZWdvcnktZmlsdGVyJztcbmV4cG9ydCAqIGZyb20nLi9hdHRyaWJ1dGVzLWZpbHRlcic7XG5leHBvcnQgKiBmcm9tJy4vZHluYW1pY3MtZmlsdGVyJztcbmV4cG9ydCAqIGZyb20nLi9zb3J0LWZpbHRlcic7XG5leHBvcnQgKiBmcm9tJy4vZmlsdGVyLWZhY3RvcnknO1xuZXhwb3J0ICogZnJvbScuL2ZpbHRlcic7Il19

package/esm2022/lib/classes/filters/sort-filter.mjs

@@ -0,0 +1,88 @@
+import { inject } from "@angular/core";
+import { CoreConstantsService } from "../../constants";
+import { Filter } from "./filter";
+export class SortFilter extends Filter {
+    _consts = inject(CoreConstantsService);
+    data = [];
+    multi = true;
+    constructor() {
+        super();
+        this.setContent();
+    }
+    type() {
+        return 'sort';
+    }
+    setContent() {
+        this.data = [
+            {
+                title: 'price', type: 'sub', multi: false, code: 'price', shape: 'text', children: [
+                    { title: 'cheapest-first', code: 'price chip', type: 'child', value: 'asc', selected: false, multi: false, },
+                    { title: 'most-expensive-first', code: 'price expensive', type: 'child', value: 'desc', selected: false, multi: false, }
+                ]
+            },
+            {
+                title: 'alphabetical-order', type: 'sub', code: 'order-alph', multi: false, shape: 'text', children: [
+                    // { title: 'order-alph', type: 'child', code: 'alpha default', value: '', selected: false, multi: false },
+                    { title: 'ascendancy', type: 'child', code: 'alpha asc', value: 'asc', selected: false, multi: false, },
+                    { title: 'descendant', type: 'child', code: 'alpha desc', value: 'desc', selected: false, multi: false, }
+                ]
+            },
+            {
+                title: 'created-date',
+                type: 'sub',
+                code: 'recent',
+                multi: false,
+                shape: 'text',
+                children: [
+                    { title: 'order-date', type: 'child', code: 'recent default', value: '', selected: false, multi: false },
+                    { title: 'newest-first', type: 'child', code: 'recent desc', value: 'desc', selected: false, multi: false },
+                    { title: 'oldest-first', type: 'child', code: 'recent asc', value: 'asc', selected: false, multi: false },
+                ]
+            },
+            {
+                title: 'date-created',
+                type: 'sub',
+                code: 'update',
+                multi: false,
+                shape: 'text',
+                children: [
+                    { noUrl: true, title: 'newest-first', type: 'child', code: 'update asc', value: 'asc', selected: false, multi: false },
+                    { noUrl: true, title: 'oldest-first', type: 'child', code: 'update desc', value: 'desc', selected: false, multi: false },
+                ]
+            }
+        ];
+        if (!this._consts.getSortFilters().includes('all')) {
+            this.data = this.data.filter(elem => this._consts.getSortFilters().includes(elem.code));
+        }
+    }
+    getContent() {
+        return this.data;
+    }
+    toUrlParams(actual_url = '', sublist, father) {
+        let elements = sublist || this.data;
+        elements.forEach((element) => {
+            if (!element.noUrl) { //Si es sin url, no se hace nada. Osea el filtrado es en la vista.
+                if (element.type == 'sub') {
+                    const result = this.toUrlParams(actual_url, element.children, element.title);
+                    !actual_url.includes(result) ? actual_url += result : null;
+                }
+                else if (element.selected) {
+                    actual_url = ('&sorting[' + this.translate(father) + ']=' + element.value);
+                }
+            }
+        });
+        return actual_url;
+    }
+    createElement(filter, original, initialValue) {
+        throw new Error("Method not implemented.");
+    }
+    translate(value) {
+        switch (value) {
+            case 'price': return 'price';
+            case 'created-date': return 'dateCreate';
+            case 'alphabetical-order': return 'name';
+            default: return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort-filter.js","sourceRoot":"","sources":["../../../../../../projects/ng-easycommerce-v18/src/lib/classes/filters/sort-filter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from \"@angular/core\";\nimport { CoreConstantsService } from \"../../constants\";\nimport { FilterElement, FilterType, IFilter } from \"../../interfaces\";\nimport { Filter } from \"./filter\";\n\nexport class SortFilter extends Filter {\n    private _consts: CoreConstantsService = inject(CoreConstantsService);\n\n    override data: FilterElement[] = [];\n    override multi: boolean = true;\n\n    constructor(){\n        super();\n        this.setContent();\n    }\n\n    override type(): FilterType {\n        return 'sort'\n    }\n    override setContent(): void {\n        this.data = [\n            {\n                title: 'price', type: 'sub', multi: false, code: 'price', shape: 'text', children: [\n                    { title: 'cheapest-first', code: 'price chip', type: 'child', value: 'asc', selected: false, multi: false, },\n                    { title: 'most-expensive-first', code: 'price expensive', type: 'child', value: 'desc', selected: false, multi: false, }\n                ]\n            },\n            {\n                title: 'alphabetical-order', type: 'sub', code: 'order-alph', multi: false, shape: 'text', children: [\n                    // { title: 'order-alph', type: 'child', code: 'alpha default', value: '', selected: false, multi: false },\n                    { title: 'ascendancy', type: 'child', code: 'alpha asc', value: 'asc', selected: false, multi: false, },\n                    { title: 'descendant', type: 'child', code: 'alpha desc', value: 'desc', selected: false, multi: false, }\n                ]\n            },\n            {\n                title: 'created-date',\n                type: 'sub',\n                code: 'recent',\n                multi: false,\n                shape: 'text',\n                children: [\n                    { title: 'order-date', type: 'child', code: 'recent default', value: '', selected: false, multi: false },\n                    { title: 'newest-first', type: 'child', code: 'recent desc', value: 'desc', selected: false, multi: false },\n                    { title: 'oldest-first', type: 'child', code: 'recent asc', value: 'asc', selected: false, multi: false },\n                ]\n            },\n            {\n                title: 'date-created',\n                type: 'sub',\n                code: 'update',\n                multi: false,\n                shape: 'text',\n                children: [\n                    { noUrl: true, title: 'newest-first', type: 'child', code: 'update asc', value: 'asc', selected: false, multi: false },\n                    { noUrl: true, title: 'oldest-first', type: 'child', code: 'update desc', value: 'desc', selected: false, multi: false },\n                ]\n            }\n        ]\n\n        if (!this._consts.getSortFilters().includes('all')) {\n            this.data = this.data.filter(elem => this._consts.getSortFilters().includes(elem.code))\n        }\n    }\n    override getContent(): FilterElement[] {\n        return this.data;\n    }\n    override toUrlParams(actual_url = '', sublist?:any, father?:any): string {\n        let elements = sublist || this.data;\n        elements.forEach((element:any) => {\n            if (!element.noUrl) { //Si es sin url, no se hace nada. Osea el filtrado es en la vista.\n                if (element.type == 'sub') {\n                    const result = this.toUrlParams(actual_url, element.children, element.title);\n                    !actual_url.includes(result) ? actual_url += result : null;\n                } else if (element.selected) {\n                    actual_url = ('&sorting[' + this.translate(father) + ']=' + element.value);\n                }\n            }\n        })\n        return actual_url;\n    }\n    override createElement(filter: any, original: any, initialValue?: any) {\n        throw new Error(\"Method not implemented.\");\n    }\n\n    translate(value:string):string | null{\n        switch (value) {\n            case 'price': return 'price';\n            case 'created-date': return 'dateCreate';\n            case 'alphabetical-order': return 'name';\n            default: return null;\n        }\n    }\n}\n"]}

package/esm2022/lib/classes/index.mjs

@@ -0,0 +1,4 @@
+export * from './user';
+export * from './filters';
+export * from './checkout';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvY2xhc3Nlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdXNlcic7XG5leHBvcnQgKiBmcm9tICcuL2ZpbHRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGVja291dCc7Il19

package/esm2022/lib/classes/user.mjs

@@ -0,0 +1,59 @@
+export class User {
+    USER = 'USER';
+    type = 'loguedin';
+    config = {};
+    client_id = 'demo_client';
+    client_secret = 'secret_demo_client';
+    grant_type = 'password';
+    email = '';
+    username = '';
+    password = '';
+    first_name = '';
+    last_name = '';
+    address = { country: '', city: '', state: '', address: '', postcode: '' };
+    birthday = '';
+    gender = '';
+    phone_number = '';
+    suscribed_to_newsletter = true;
+    document_type = '';
+    preferred_card = '';
+    document_number = '';
+    channels = [];
+    customers = [];
+    token = '';
+    typeUser = null;
+    initilized(res) {
+        this.token = res.token;
+        this.typeUser = res.hasOwnProperty('type') ? res.type : 'retail_customer';
+        this.username = res.username;
+        this.email = res.username;
+        this.channels = res.channels || [];
+        this.customers = res.customers || [];
+    }
+    deserialize(input) {
+        return Object.assign(this, input);
+    }
+    jsonify() {
+        return {
+            client_id: this.client_id,
+            client_secret: this.client_secret,
+            grant_type: this.grant_type,
+            username: this.username,
+            email: this.email,
+            password: this.password,
+            token: this.token,
+            typeUser: this.typeUser,
+            channels: this.channels,
+            customers: this.customers
+        };
+    }
+    isSeller() { return this.typeUser && this.typeUser == 'seller' || false; }
+    setChannels(...channels) { this.channels = channels; }
+    isWholesaler() {
+        return this.typeUser && (this.typeUser == 'wholesaler_customer' || this.typeUser == 'seller') || false;
+    }
+    static fromJson(data) {
+        return Object.assign(new User(), data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/constants/api.constants.service.mjs

@@ -0,0 +1,71 @@
+import { inject, Injectable } from '@angular/core';
+import { ENVIRONMENT_TOKEN } from '../providers';
+import { LocalStorageService } from '../ec-services';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que provee de datos que estan relacionado con las peticiones a la API
+ * @export
+ * @class ApiConstantsService
+ */
+export class ApiConstantsService {
+    _localStorage = inject(LocalStorageService);
+    _translate = inject(TranslateService);
+    /**
+     * Contiene los datos provisto por el frontend en el archivo environment.ts
+     */
+    environment = inject(ENVIRONMENT_TOKEN);
+    /**
+     * Canal actual del frontend
+     */
+    CHANNEL = this.environment.channel;
+    /**
+     * Locale actual del frontend
+     */
+    LOCALE = this.environment.locale;
+    /**
+     * URL del backend para realizar las peticiones
+     */
+    API_URL = this.environment.apiUrl;
+    /**
+     * URL para las peticiones a shop-api
+     */
+    SHOP_API_URL = 'shop-api/';
+    /**
+     * URL para las peticiones a cms
+     */
+    CMS_URL = 'cms/';
+    /**
+     * URL base para realizar las peticiones a la API
+     */
+    urlBase = this.environment.apiUrl;
+    /**
+     * Retorna la url base
+     * @returns {string}
+     */
+    getUrlBase() { return this.urlBase; }
+    ;
+    /**
+     * Cambia el canal actual
+     * @param code
+     * @returns
+     */
+    setChannel(code) { this.CHANNEL = code; }
+    setLocale(locale) {
+        this._localStorage.setItem(this.LOCALE_KEY, locale);
+        this._translate.use(locale.split('_')[0]);
+        this.LOCALE = locale;
+    }
+    //Storage key
+    LOCALE_KEY = 'LOCALE';
+    CHANNEL_KEY = 'CHANNEL';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ApiConstantsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ApiConstantsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ApiConstantsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/constants/core.constants.service.mjs

@@ -0,0 +1,196 @@
+import { inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { ApiConstantsService } from './api.constants.service';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que provee las constantes necesarias que se utilizan por toda la aplicación.
+ * @export
+ * @class CoreConstantsService
+ */
+export class CoreConstantsService {
+    /**
+     * Servicio que contiene las constantes usadas para la API
+     */
+    apiConstants = inject(ApiConstantsService);
+    /**
+     * Provee el ID de la plataforma en donde se esta ejecutando el codigo, esto sirve para poder diferenciar si es de un servidor o un navegador web.
+     */
+    platformId = inject(PLATFORM_ID);
+    /**
+     * Guarda la variable window del web browser.
+     */
+    window;
+    constructor() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.window = window;
+        }
+    }
+    /**
+     * Path usado en las colecciones de productos.
+     */
+    PRODUCT_LIST_ROUTE = 'collection/';
+    /**
+     * Path usado para acceder a las secciones.
+     */
+    SECTIONS_ROUTE = 'sections/';
+    /**
+     * Path que aloja la carpeta de los assets.
+     */
+    ASSETS_URL = this.apiConstants.API_URL;
+    /**
+     * Retorna la url donde se guarda las imagenes.
+     * @param postMedia
+     * @returns
+     */
+    mediaUrl = (postMedia) => this.ASSETS_URL + (this.ASSETS_URL == this.apiConstants.API_URL ? 'media/' : '') + (postMedia ? postMedia : "image/");
+    /**
+     * Retorna la url de las imagenes de los banners
+     * @returns
+     */
+    mediaBannerUrl = () => this.ASSETS_URL + (this.ASSETS_URL == this.apiConstants.API_URL ? 'media/' : '') + "banner-image/";
+    /**
+     * Retorna `true` si la vista es mobile, `false` caso contrario.
+     * @returns {boolean}
+     */
+    mobileScreen = () => this.window && this.window?.innerWidth < 750 || false;
+    /**
+     * Contiene los valores para la moneda actual
+     */
+    currency = {
+        code: 'ARG',
+        symbol: '$',
+        position: 'Left',
+        withoutDecimal: false
+    };
+    /**
+     * Arreglo de valores usados para el pipe currencyPrice
+     */
+    currencyTypeConfig = [
+        {
+            code: 'EUR',
+            symbol: '€',
+            position: 'Right',
+            withoutDecimal: false
+        },
+        {
+            code: 'ARG',
+            symbol: '$',
+            position: 'Left',
+            withoutDecimal: false
+        },
+        {
+            code: 'ARS',
+            symbol: '$',
+            position: 'Left',
+            withoutDecimal: false
+        },
+        {
+            code: 'USD',
+            symbol: '$',
+            position: 'Left',
+            withoutDecimal: false
+        },
+        {
+            code: 'PYG',
+            symbol: 'Gs.',
+            position: 'Left',
+            withoutDecimal: false
+        },
+        {
+            code: 'PEN',
+            symbol: 'S/',
+            position: 'Left',
+            withoutDecimal: false
+        },
+        {
+            code: 'SEK',
+            symbol: 'SEK',
+            position: 'Right',
+            withoutDecimal: true
+        },
+    ];
+    /**
+     * Cambia la configuración de la moneda.
+     * @param currencyTypeConfig Arreglo con las distintas monedas.
+     */
+    setCurrencyTypeConfig(currencyTypeConfig) {
+        this.currencyTypeConfig = currencyTypeConfig;
+    }
+    /**
+     * @param currencyTypeFind Definir el code del tipo de moneda que se quiera utilizar.
+     * Si el tipo es CUSTOM se toman los valores del segundo parametro donde se puede definir la simbología y posesión que se quiera.
+     * @param customType Formato del parámetro ejemplo { code: 'ARG', symbol: '$', position: 'L' , withoutDecimals: false } ,
+     * todas las key son opcionales y por defecto se toman los valores del ejemplo.
+     * @returns se retorna la configuración que se seteo a la propiedad currency del servicio.
+     */
+    setCurrency(currencyTypeFind, customType) {
+        this.currency = this.currencyTypeConfig.find((ct) => ct.code == currencyTypeFind.toUpperCase()) || this.currency;
+        customType && (this.currency = { ...this.currency, ...customType });
+        return this.currency;
+    }
+    ;
+    modifyChannelConfig(channelConfig) {
+        if (channelConfig.channel || channelConfig.code)
+            this.apiConstants.setChannel(channelConfig.channel || channelConfig.code);
+        if (channelConfig.locale || channelConfig.locales.code)
+            this.apiConstants.setLocale(channelConfig.locale || channelConfig.locales.code);
+        if (channelConfig.currency || channelConfig.baseCurrency)
+            this.setCurrency(channelConfig.currency || channelConfig.baseCurrency);
+        return channelConfig;
+    }
+    /**
+    * @description se utiliza para configurar que filtros del tipo `SortFilter` se quiere mostrar en la vista.
+    * Se usan los codigo de los filtros para indicar cuales se deben mostrar.
+    */
+    sortFilters = ['price', 'order-alph', 'recent'];
+    /**
+     *
+     * @param filtersCode arreglo de strings con los codigos de los filtros.
+     * Si se le pasa el parametro **all** este mostrara todos.
+     * @example price | order-alph | recent | update | all
+     * @returns
+     */
+    setSortFilters = (filtersCode = ['all']) => this.sortFilters = filtersCode;
+    getSortFilters = () => this.sortFilters;
+    // ABOUT PRODUCTS 
+    productsWithUniqueVariant = false;
+    setProductWithUniqueVariant(value) { this.productsWithUniqueVariant = value; }
+    getProductWithUniqueVariant() { return this.productsWithUniqueVariant; }
+    /**
+    * @description esta variable se utiliza para configurar los parametros cuando se desea mostrar
+    * variantes el listado de productos.
+    * @param {string}type tipo de options
+    * @param {string}code codigo de options
+    * @param {boolean}defaultFirstOption `true` toma el primer option del producto en general
+    * @param {boolean}checkIfStock `true` se realiza un chequeo de si la variante tiene stock para mostrarla
+    * @example  ```javascript
+    * {
+       type: 'color',
+       code: 'color',
+       defaultFirstOption: false ,
+       checkIfStock:true
+       } ```
+    */
+    paramsProductsWithUniqueVariant = {
+        type: 'color',
+        code: 'color',
+        defaultFirstOption: false,
+        checkIfStock: true
+    };
+    setParamsProductsWithUniqueVariant = (value) => {
+        this.paramsProductsWithUniqueVariant = {
+            ...this.paramsProductsWithUniqueVariant,
+            ...value
+        };
+    };
+    getParamsProductsWithUniqueVariant = () => this.paramsProductsWithUniqueVariant;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CoreConstantsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CoreConstantsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CoreConstantsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.constants.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/constants/core.constants.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, PLATFORM_ID } from '@angular/core';\nimport { ApiConstantsService } from './api.constants.service';\nimport { isPlatformBrowser } from '@angular/common';\nimport { CurrencyConfig, currencyType, ParamsProductsWithUniqueVariant } from '../interfaces';\n/**\n * Servicio que provee las constantes necesarias que se utilizan por toda la aplicación.\n * @export\n * @class CoreConstantsService\n */\n@Injectable({\n\tprovidedIn: 'root'\n})\nexport class CoreConstantsService {\n\n\t/**\n\t * Servicio que contiene las constantes usadas para la API\n\t */\n\tprivate apiConstants = inject(ApiConstantsService)\n\t/**\n\t * Provee el ID de la plataforma en donde se esta ejecutando el codigo, esto sirve para poder diferenciar si es de un servidor o un navegador web.\n\t */\n\tprivate platformId: any = inject(PLATFORM_ID)\n\t/**\n\t * Guarda la variable window del web browser.\n\t */\n\tprivate window?:Window;\n\n\tconstructor() {\n\t\tif (isPlatformBrowser(this.platformId)) {\n\t\t\tthis.window = window\n\t\t}\n\t}\n\t/**\n\t * Path usado en las colecciones de productos.\n\t */\n\tpublic PRODUCT_LIST_ROUTE: string = 'collection/';\n\t/**\n\t * Path usado para acceder a las secciones.\n\t */\n\tpublic SECTIONS_ROUTE: string = 'sections/';\n\t/**\n\t * Path que aloja la carpeta de los assets.\n\t */\n\tpublic readonly ASSETS_URL: string = this.apiConstants.API_URL;\n\t/**\n\t * Retorna la url donde se guarda las imagenes.\n\t * @param postMedia \n\t * @returns \n\t */\n\tpublic mediaUrl = (postMedia?: string) => this.ASSETS_URL + (this.ASSETS_URL == this.apiConstants.API_URL ? 'media/' : '') + (postMedia ? postMedia : \"image/\");\n\t/**\n\t * Retorna la url de las imagenes de los banners\n\t * @returns \n\t */\n\tpublic mediaBannerUrl = () => this.ASSETS_URL + (this.ASSETS_URL == this.apiConstants.API_URL ? 'media/' : '') + \"banner-image/\";\n\t/**\n\t * Retorna `true` si la vista es mobile, `false` caso contrario.\n\t * @returns {boolean}\n\t */\n\tpublic mobileScreen = (): boolean => this.window && this.window?.innerWidth < 750 || false;\n\t/**\n\t * Contiene los valores para la moneda actual\n\t */\n\tpublic currency: CurrencyConfig = {\n\t\tcode: 'ARG',\n\t\tsymbol: '$',\n\t\tposition: 'Left',\n\t\twithoutDecimal: false\n\t};\n\n\t/**\n\t * Arreglo de valores usados para el pipe currencyPrice\n\t */\n\tpublic currencyTypeConfig: CurrencyConfig[] = [\n\t\t{\n\t\t\tcode: 'EUR',\n\t\t\tsymbol: '€',\n\t\t\tposition: 'Right',\n\t\t\twithoutDecimal: false\n\n\t\t},\n\t\t{\n\t\t\tcode: 'ARG',\n\t\t\tsymbol: '$',\n\t\t\tposition: 'Left',\n\t\t\twithoutDecimal: false\n\t\t},\n\t\t{\n\t\t\tcode: 'ARS',\n\t\t\tsymbol: '$',\n\t\t\tposition: 'Left',\n\t\t\twithoutDecimal: false\n\t\t},\n\t\t{\n\t\t\tcode: 'USD',\n\t\t\tsymbol: '$',\n\t\t\tposition: 'Left',\n\t\t\twithoutDecimal: false\n\t\t},\n\t\t{\n\t\t\tcode: 'PYG',\n\t\t\tsymbol: 'Gs.',\n\t\t\tposition: 'Left',\n\t\t\twithoutDecimal: false\n\t\t},\n\t\t{\n\t\t\tcode: 'PEN',\n\t\t\tsymbol: 'S/',\n\t\t\tposition: 'Left',\n\t\t\twithoutDecimal: false\n\t\t},\n\t\t{\n\t\t\tcode: 'SEK',\n\t\t\tsymbol: 'SEK',\n\t\t\tposition: 'Right',\n\t\t\twithoutDecimal: true\n\t\t},\n\t]\n\t/**\n\t * Cambia la configuración de la moneda.\n\t * @param currencyTypeConfig Arreglo con las distintas monedas.\n\t */\n\tpublic setCurrencyTypeConfig(currencyTypeConfig: CurrencyConfig[]) {\n\t\tthis.currencyTypeConfig = currencyTypeConfig;\n\t}\n\n\t/**\n\t * @param currencyTypeFind Definir el code del tipo de moneda que se quiera utilizar.\n\t * Si el tipo es CUSTOM se toman los valores del segundo parametro donde se puede definir la simbología y posesión que se quiera.\n\t * @param customType Formato del parámetro ejemplo { code: 'ARG', symbol: '$', position: 'L' , withoutDecimals: false } ,\n\t * todas las key son opcionales y por defecto se toman los valores del ejemplo.\n\t * @returns se retorna la configuración que se seteo a la propiedad currency del servicio.\n\t */\n\tpublic setCurrency(currencyTypeFind: currencyType, customType?: CurrencyConfig): CurrencyConfig {\n\t\tthis.currency = this.currencyTypeConfig.find((ct: CurrencyConfig) => ct.code == currencyTypeFind.toUpperCase()) || this.currency\n\t\tcustomType && (this.currency = { ...this.currency, ...customType })\n\t\treturn this.currency;\n\t};\n\n\n\tpublic modifyChannelConfig(channelConfig: any) {\n\t\tif (channelConfig.channel || channelConfig.code)\n\t\t\tthis.apiConstants.setChannel(channelConfig.channel || channelConfig.code)\n\n\t\tif (channelConfig.locale || channelConfig.locales.code)\n\t\t\tthis.apiConstants.setLocale(channelConfig.locale || channelConfig.locales.code)\n\n\t\tif (channelConfig.currency || channelConfig.baseCurrency)\n\t\t\tthis.setCurrency(channelConfig.currency || channelConfig.baseCurrency)\n\n\t\treturn channelConfig;\n\t}\n\n\t/**\n\t* @description se utiliza para configurar que filtros del tipo `SortFilter` se quiere mostrar en la vista.\n\t* Se usan los codigo de los filtros para indicar cuales se deben mostrar.\n\t*/\n\tprivate sortFilters: string[] = ['price', 'order-alph', 'recent']\n\n\t/**\n\t *\n\t * @param filtersCode arreglo de strings con los codigos de los filtros.\n\t * Si se le pasa el parametro **all** este mostrara todos.\n\t * @example price | order-alph | recent | update | all\n\t * @returns\n\t */\n\tsetSortFilters = (filtersCode: string[] = ['all']) => this.sortFilters = filtersCode;\n\n\tgetSortFilters = () => this.sortFilters;\n\n\t// ABOUT PRODUCTS \n\tprivate productsWithUniqueVariant: boolean = false;\n\tsetProductWithUniqueVariant(value: boolean) { this.productsWithUniqueVariant = value; }\n\tgetProductWithUniqueVariant() { return this.productsWithUniqueVariant }\n\n\t/**\n\t* @description esta variable se utiliza para configurar los parametros cuando se desea mostrar\n\t* variantes el listado de productos.\n\t* @param {string}type tipo de options\n\t* @param {string}code codigo de options\n\t* @param {boolean}defaultFirstOption `true` toma el primer option del producto en general\n\t* @param {boolean}checkIfStock `true` se realiza un chequeo de si la variante tiene stock para mostrarla\n\t* @example  ```javascript\n\t* {\n\t   type: 'color',\n\t   code: 'color',\n\t   defaultFirstOption: false ,\n\t   checkIfStock:true\n\t   } ```\n\t*/\n\tprivate paramsProductsWithUniqueVariant: ParamsProductsWithUniqueVariant = {\n\t\ttype: 'color',\n\t\tcode: 'color',\n\t\tdefaultFirstOption: false,\n\t\tcheckIfStock: true\n\t}\n\n\tsetParamsProductsWithUniqueVariant = (value: ParamsProductsWithUniqueVariant) => {\n\t\tthis.paramsProductsWithUniqueVariant = {\n\t\t\t...this.paramsProductsWithUniqueVariant,\n\t\t\t...value\n\t\t}\n\t}\n\n\tgetParamsProductsWithUniqueVariant = () => this.paramsProductsWithUniqueVariant\n}\n"]}

package/esm2022/lib/constants/index.mjs

@@ -0,0 +1,3 @@
+export * from './api.constants.service';
+export * from './core.constants.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvY29uc3RhbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpLmNvbnN0YW50cy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29yZS5jb25zdGFudHMuc2VydmljZSc7Il19