ng-easycommerce-v18 0.0.1 → 0.0.3

package/README.md

@@ -1,26 +1,23 @@
-# 
+# NgEasycommerce
 
-This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.1.4.
-
-## Development server
-
-Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The application will automatically reload if you change any of the source files.
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.0.
 
 ## Code scaffolding
 
-Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.
+Run `ng generate component component-name --project ng-easycommerce` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ng-easycommerce`.
+> Note: Don't forget to add `--project ng-easycommerce` or else it will be added to the default project in your `angular.json` file. 
 
 ## Build
 
-Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory.
+Run `ng build ng-easycommerce` to build the project. The build artifacts will be stored in the `dist/` directory.
 
-## Running unit tests
+## Publishing
 
-Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
+After building your library with `ng build ng-easycommerce`, go to the dist folder `cd dist/ng-easycommerce` and run `npm publish`.
 
-## Running end-to-end tests
+## Running unit tests
 
-Run `ng e2e` to execute the end-to-end tests via a platform of your choice. To use this command, you need to first add a package that implements end-to-end testing capabilities.
+Run `ng test ng-easycommerce` to execute the unit tests via [Karma](https://karma-runner.github.io).
 
 ## Further help
 

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

@@ -0,0 +1,75 @@
+import { inject, Injectable } from '@angular/core';
+import { take } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { ApiConstantsService } from '../constants/api.constants.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que funciona como abstracción para manejar la conexión con la API
+ * @export
+ * @class ConnectionService
+ * @implements {Connection}
+ */
+export class ConnectionService {
+    /**
+     * Herrramienta usada para generar las peticiones.
+     * @memberof ConnectionService
+     */
+    _http = inject(HttpClient);
+    /**
+     * Servicio que contiene las constantes usadas para la API
+     * @memberof ConnectionService
+     */
+    constantsSvr = inject(ApiConstantsService);
+    /**
+     * URL Base para las peticiones.
+     * @type {string}
+     * @memberof ConnectionService
+     */
+    url;
+    constructor() {
+        this.url = this.constantsSvr.getUrlBase();
+    }
+    /**
+     * Función para generar peticiones de tipo GET
+     * @param apiurl url del endpoint
+     * @param data parametros para la url
+     * @returns
+     */
+    get(apiurl, data) {
+        return this._http.get(this.url + apiurl, { params: { ...data } }).pipe(take(1));
+    }
+    getErrorNotHandler(apiurl) {
+        return this._http.get(this.url + apiurl).pipe(take(1));
+    }
+    /**
+     * Funcion para generar peticiones de tipo POST
+     * @param apiurl url del endpoint
+     * @param data
+     */
+    post(apiurl, data) {
+        return this._http.post(this.url + apiurl, data || {}).pipe(take(1));
+    }
+    put(apiurl, data) {
+        return this._http.put(this.url + apiurl, data).pipe(take(1));
+    }
+    delete(apiurl, data) {
+        return this._http.delete(this.url + apiurl).pipe(take(1));
+    }
+    /**
+     * Genera un petición tipo GET pero usando el parametro como la url completa.
+     * @param fullurl
+     * @returns
+     */
+    getWithFullUrl(fullurl) {
+        return this._http.get(fullurl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ConnectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ConnectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZWFzeWNvbW1lcmNlLXYxOC9zcmMvbGliL2FwaS9jb25uZWN0aW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFbkQsT0FBTyxFQUF1QixJQUFJLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDakQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQUV6RTs7Ozs7R0FLRztBQUlILE1BQU0sT0FBTyxpQkFBaUI7SUFDN0I7OztPQUdHO0lBQ2MsS0FBSyxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUU1Qzs7O09BR0c7SUFDSyxZQUFZLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFFbkQ7Ozs7T0FJRztJQUNLLEdBQUcsQ0FBUztJQUVwQjtRQUNDLElBQUksQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUMzQyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxHQUFHLENBQUMsTUFBYyxFQUFFLElBQVU7UUFDN0IsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBTSxJQUFJLENBQUMsR0FBRyxHQUFHLE1BQU0sRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLEdBQUcsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN0RixDQUFDO0lBQ0Qsa0JBQWtCLENBQUMsTUFBYztRQUMxQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFNLElBQUksQ0FBQyxHQUFHLEdBQUcsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFSjs7OztPQUlHO0lBQ0gsSUFBSSxDQUFDLE1BQWMsRUFBRSxJQUFVO1FBQzlCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQU0sSUFBSSxDQUFDLEdBQUcsR0FBRyxNQUFNLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBQ0QsR0FBRyxDQUFDLE1BQWMsRUFBRSxJQUFVO1FBQzdCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQU0sSUFBSSxDQUFDLEdBQUcsR0FBRyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ25FLENBQUM7SUFDRCxNQUFNLENBQUMsTUFBYyxFQUFFLElBQVU7UUFDaEMsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBTSxJQUFJLENBQUMsR0FBRyxHQUFHLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBQ0Q7Ozs7T0FJRztJQUNILGNBQWMsQ0FBQyxPQUFlO1FBQzdCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQVEsT0FBTyxDQUFDLENBQUE7SUFDdEMsQ0FBQzt1R0ExRFcsaUJBQWlCOzJHQUFqQixpQkFBaUIsY0FGakIsTUFBTTs7MkZBRU4saUJBQWlCO2tCQUg3QixVQUFVO21CQUFDO29CQUNYLFVBQVUsRUFBRSxNQUFNO2lCQUNsQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDb25uZWN0aW9uIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XHJcbmltcG9ydCB7IG1hcCwgT2JzZXJ2YWJsZSwgb2YsIHRha2UgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcclxuaW1wb3J0IHsgQXBpQ29uc3RhbnRzU2VydmljZSB9IGZyb20gJy4uL2NvbnN0YW50cy9hcGkuY29uc3RhbnRzLnNlcnZpY2UnO1xyXG5cclxuLyoqXHJcbiAqIFNlcnZpY2lvIHF1ZSBmdW5jaW9uYSBjb21vIGFic3RyYWNjacOzbiBwYXJhIG1hbmVqYXIgbGEgY29uZXhpw7NuIGNvbiBsYSBBUElcclxuICogQGV4cG9ydFxyXG4gKiBAY2xhc3MgQ29ubmVjdGlvblNlcnZpY2VcclxuICogQGltcGxlbWVudHMge0Nvbm5lY3Rpb259XHJcbiAqL1xyXG5ASW5qZWN0YWJsZSh7XHJcblx0cHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDb25uZWN0aW9uU2VydmljZSBpbXBsZW1lbnRzIENvbm5lY3Rpb24ge1xyXG5cdC8qKlxyXG5cdCAqIEhlcnJyYW1pZW50YSB1c2FkYSBwYXJhIGdlbmVyYXIgbGFzIHBldGljaW9uZXMuXHJcblx0ICogQG1lbWJlcm9mIENvbm5lY3Rpb25TZXJ2aWNlXHJcblx0ICovXHJcblx0cHJpdmF0ZSByZWFkb25seSBfaHR0cCA9IGluamVjdChIdHRwQ2xpZW50KTtcclxuXHJcblx0LyoqXHJcblx0ICogU2VydmljaW8gcXVlIGNvbnRpZW5lIGxhcyBjb25zdGFudGVzIHVzYWRhcyBwYXJhIGxhIEFQSVxyXG5cdCAqIEBtZW1iZXJvZiBDb25uZWN0aW9uU2VydmljZVxyXG5cdCAqL1xyXG5cdHByaXZhdGUgY29uc3RhbnRzU3ZyID0gaW5qZWN0KEFwaUNvbnN0YW50c1NlcnZpY2UpO1xyXG5cclxuXHQvKipcclxuXHQgKiBVUkwgQmFzZSBwYXJhIGxhcyBwZXRpY2lvbmVzLlxyXG5cdCAqIEB0eXBlIHtzdHJpbmd9XHJcblx0ICogQG1lbWJlcm9mIENvbm5lY3Rpb25TZXJ2aWNlXHJcblx0ICovXHJcblx0cHJpdmF0ZSB1cmw6IHN0cmluZztcclxuXHJcblx0Y29uc3RydWN0b3IoKSB7XHJcblx0XHR0aGlzLnVybCA9IHRoaXMuY29uc3RhbnRzU3ZyLmdldFVybEJhc2UoKTtcclxuXHR9XHJcblxyXG5cdC8qKlxyXG5cdCAqIEZ1bmNpw7NuIHBhcmEgZ2VuZXJhciBwZXRpY2lvbmVzIGRlIHRpcG8gR0VUXHJcblx0ICogQHBhcmFtIGFwaXVybCB1cmwgZGVsIGVuZHBvaW50XHJcblx0ICogQHBhcmFtIGRhdGEgcGFyYW1ldHJvcyBwYXJhIGxhIHVybFxyXG5cdCAqIEByZXR1cm5zIFxyXG5cdCAqL1xyXG5cdGdldChhcGl1cmw6IHN0cmluZywgZGF0YT86IGFueSk6IE9ic2VydmFibGU8YW55PiB7XHJcblx0XHRyZXR1cm4gdGhpcy5faHR0cC5nZXQ8YW55Pih0aGlzLnVybCArIGFwaXVybCwgeyBwYXJhbXM6IHsgLi4uZGF0YSB9IH0pLnBpcGUodGFrZSgxKSk7XHJcblx0fVxyXG5cdGdldEVycm9yTm90SGFuZGxlcihhcGl1cmw6IHN0cmluZyk6IE9ic2VydmFibGU8YW55PiB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuX2h0dHAuZ2V0PGFueT4odGhpcy51cmwgKyBhcGl1cmwpLnBpcGUodGFrZSgxKSk7XHJcbiAgICB9XHJcblxyXG5cdC8qKlxyXG5cdCAqIEZ1bmNpb24gcGFyYSBnZW5lcmFyIHBldGljaW9uZXMgZGUgdGlwbyBQT1NUXHJcblx0ICogQHBhcmFtIGFwaXVybCB1cmwgZGVsIGVuZHBvaW50XHJcblx0ICogQHBhcmFtIGRhdGEgXHJcblx0ICovXHJcblx0cG9zdChhcGl1cmw6IHN0cmluZywgZGF0YT86IGFueSk6IE9ic2VydmFibGU8YW55PiB7XHJcblx0XHRyZXR1cm4gdGhpcy5faHR0cC5wb3N0PGFueT4odGhpcy51cmwgKyBhcGl1cmwsIGRhdGEgfHwge30pLnBpcGUodGFrZSgxKSk7XHJcblx0fVxyXG5cdHB1dChhcGl1cmw6IHN0cmluZywgZGF0YT86IGFueSk6IE9ic2VydmFibGU8YW55PiB7XHJcblx0XHRyZXR1cm4gdGhpcy5faHR0cC5wdXQ8YW55Pih0aGlzLnVybCArIGFwaXVybCwgZGF0YSkucGlwZSh0YWtlKDEpKTtcclxuXHR9XHJcblx0ZGVsZXRlKGFwaXVybDogc3RyaW5nLCBkYXRhPzogYW55KTogT2JzZXJ2YWJsZTxhbnk+IHtcclxuXHRcdHJldHVybiB0aGlzLl9odHRwLmRlbGV0ZTxhbnk+KHRoaXMudXJsICsgYXBpdXJsKS5waXBlKHRha2UoMSkpO1xyXG5cdH1cclxuXHQvKipcclxuXHQgKiBHZW5lcmEgdW4gcGV0aWNpw7NuIHRpcG8gR0VUIHBlcm8gdXNhbmRvIGVsIHBhcmFtZXRybyBjb21vIGxhIHVybCBjb21wbGV0YS5cclxuXHQgKiBAcGFyYW0gZnVsbHVybCBcclxuXHQgKiBAcmV0dXJucyBcclxuXHQgKi9cclxuXHRnZXRXaXRoRnVsbFVybChmdWxsdXJsOiBzdHJpbmcpOiBPYnNlcnZhYmxlPGFueT4ge1xyXG5cdFx0cmV0dXJuIHRoaXMuX2h0dHAuZ2V0PGFueVtdPihmdWxsdXJsKVxyXG5cdH1cclxuXHJcblx0LyogZm9ybVVybCA9IChhcGk6IHN0cmluZykgPT4ge1xyXG5cdCAgcmV0dXJuIHdpbmRvdy5sb2NhdGlvbi5wcm90b2NvbCA9PSAnaHR0cHM6JyAmJiAhdGhpcy51cmwuaW5jbHVkZXMoJ2h0dHBzJykgPyAodGhpcy51cmwucmVwbGFjZSgnaHR0cCcsICdodHRwcycpKSArIGFwaSA6IHRoaXMudXJsICsgYXBpO1xyXG5cdH0gKi9cclxufVxyXG4iXX0=

package/esm2022/lib/api/index.mjs

@@ -0,0 +1,2 @@
+export * from './connection.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Nvbm5lY3Rpb24uc2VydmljZSc7Il19

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

@@ -0,0 +1,2 @@
+export * from './steps';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvY2xhc3Nlcy9jaGVja291dC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RlcHMnOyJdfQ==

package/esm2022/lib/classes/checkout/steps.mjs

@@ -0,0 +1,29 @@
+export class Step {
+    name;
+    label = '';
+    priority;
+    type = null;
+    data;
+    state = 'pending';
+    constructor(name, priority, label, state) {
+        this.name = name;
+        this.label = label;
+        this.state = state || 'pending';
+        this.priority = priority;
+    }
+    doing = () => {
+        this.data = null;
+        this.state = 'doing';
+    };
+    restart = () => {
+        this.data = null;
+        this.state = 'pending';
+    };
+    ready = (data) => {
+        this.data = data;
+        this.state = 'ready';
+    };
+    isPending = () => this.state == 'pending' || this.state == 'doing';
+    isReady = () => this.state == 'ready' && this.data;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,73 @@
+import { inject } from "@angular/core";
+import { OptionsService } from "../../ec-services";
+import { Filter } from "./filter";
+export class AttributesFilter extends Filter {
+    _optionsService = inject(OptionsService);
+    data = [];
+    multi = false;
+    constructor(initialValue, options) {
+        super();
+        if (options) {
+            this.setContent(options, initialValue);
+        }
+        else {
+            this._optionsService.getAttributes().subscribe(res => {
+                //console.log(res);
+                this.setContent(res, initialValue);
+            });
+        }
+    }
+    type() { return 'attributes'; }
+    setContent(options, initialValue) {
+        const attributes = this._optionsService.generateMenu(options);
+        attributes.forEach((filter) => filter = this.createElement(filter, options, initialValue));
+        this.data = attributes;
+    }
+    getContent() {
+        return this.data;
+    }
+    toUrlParams(actual_url = '&attributeCodes=', sublist, already) {
+        let elements = sublist || this.data;
+        let aux_url = '';
+        elements.forEach((element) => {
+            if (element.type == 'sub') {
+                let result = this.toUrlParams('', element.children, (actual_url != '&attributeCodes=' && actual_url != ''));
+                if (!actual_url.includes(result))
+                    actual_url += this.cleanResult(result);
+            }
+            else if (element.selected) {
+                if (actual_url == '&attributeCodes=' && aux_url == '') {
+                    aux_url = element.code;
+                }
+                else {
+                    if (aux_url == '')
+                        aux_url = (already ? '<and>' : '') + element.code;
+                    else
+                        aux_url += ('<and>' + element.code);
+                }
+            }
+        });
+        //console.log(actual_url + aux_url);
+        return actual_url + aux_url;
+    }
+    ;
+    cleanResult(text) { return text.replace('&attributeCodes=', ''); }
+    ;
+    createElement(filter, original, initialValue) {
+        if (filter.type == 'sub') {
+            filter.multi = false;
+            filter.shape = 'text';
+            filter.value = original.code;
+            filter.children = filter.children.map((child, i) => {
+                return this.createElement(child, child.children, initialValue);
+            });
+        }
+        else {
+            filter.value = original.code;
+            filter.multi = false;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+        }
+        return filter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,59 @@
+import { inject } from "@angular/core";
+import { OptionsService } from "../../ec-services";
+import { Filter } from "./filter";
+export class CategoryFilter extends Filter {
+    initialValues;
+    _optionsService = inject(OptionsService);
+    data = [];
+    multi = false;
+    constructor(initialValues) {
+        super();
+        this.initialValues = initialValues;
+        this._optionsService.getCategories().subscribe(res => {
+            //console.log(res);
+            this.setContent(res, initialValues);
+        });
+    }
+    type() {
+        return 'categories';
+    }
+    setContent(options, initialValue) {
+        const categories = this._optionsService.generateMenu(options);
+        categories.forEach((filter, i) => filter = this.createElement(filter, options[i], initialValue));
+        this.data = categories;
+    }
+    getContent() {
+        throw new Error("Method not implemented.");
+    }
+    toUrlParams(actual_url = '', sublist) {
+        let elements = sublist || this.data;
+        elements.forEach((element) => {
+            if (element.type == 'sub' && !element.selected) {
+                const result = this.toUrlParams('', element.children);
+                !actual_url.includes(result) ? actual_url += result : null;
+            }
+            else if (element.selected) {
+                if (actual_url == '')
+                    actual_url = '&category=' + element.value;
+                else
+                    actual_url = element.value;
+            }
+        });
+        return actual_url;
+    }
+    createElement(filter, original, initialValue) {
+        if (filter.type == 'sub') {
+            filter.multi = false;
+            filter.shape = 'text';
+            filter.value = original.code;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+            filter.children = filter.children.map((child, i) => this.createElement(child, original.children[i], initialValue));
+        }
+        else {
+            filter.value = original.code;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+        }
+        return filter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+import { Filter } from "./filter";
+export class DynamicsFilter extends Filter {
+    generated_url = '';
+    data = [];
+    multi = true;
+    type() {
+        return 'dynamics';
+    }
+    setContent(options) {
+        options = options.map((option) => option = this.createElement(option));
+        this.data = options;
+    }
+    getContent() {
+        throw new Error("Method not implemented.");
+    }
+    toUrlParams = (actual_url = '&optionCodes=', sublist, already) => {
+        let elements = sublist || this.data;
+        let aux_url = '';
+        elements.forEach((element) => {
+            if (element.type == 'sub') {
+                let result = this.toUrlParams('', element.children, (actual_url != '&optionCodes=' && actual_url != ''));
+                if (!actual_url.includes(result))
+                    actual_url += this.cleanResult(result);
+            }
+            else if (element.selected) {
+                if (actual_url == '&optionCodes=' && aux_url == '') {
+                    aux_url = element.value;
+                }
+                else {
+                    if (aux_url == '')
+                        aux_url = (already ? '<and>' : '') + element.value;
+                    else
+                        aux_url += ('<and>' + element.value);
+                }
+            }
+        });
+        return actual_url + aux_url;
+    };
+    createElement(option) {
+        option = {
+            title: option.label, useToFilter: option.useToFilter, type: 'sub', multi: false, code: option.code, shape: option.type, children: option.values.map((value) => {
+                return {
+                    title: value.code,
+                    description: value.name,
+                    code: (option.code + ' ' + value.name),
+                    type: 'child',
+                    value: value.code,
+                    selected: false,
+                    image: value.image
+                };
+            })
+        };
+        return option;
+    }
+    cleanResult(text) { return text.replace('&optionCodes=', ''); }
+    ;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import { AttributesFilter } from "./attributes-filter";
+import { CategoryFilter } from "./category-filter";
+import { DynamicsFilter } from "./dynamics-filter";
+import { SortFilter } from "./sort-filter";
+export class FilterFactory {
+    create(filterType, productsFilter) {
+        switch (filterType) {
+            case 'categories':
+                return new CategoryFilter(productsFilter ? (productsFilter.type == 'categories' && productsFilter.value) : null);
+            case 'attributes':
+                return new AttributesFilter(productsFilter ? (productsFilter.type == 'attributes' && productsFilter.value) : null);
+            case 'dynamics':
+                return new DynamicsFilter();
+            case 'sort':
+                return new SortFilter();
+            default:
+                throw new Error("Not implemented");
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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\";\r\n\r\nexport class Filter implements IFilter  {\r\n    \r\n    data: FilterElement[] = [];\r\n    multi: boolean = false;\r\n    \r\n    type(): FilterType {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    setContent(options: any): void {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    getContent(): FilterElement[] {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    toUrlParams(): string {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    createElement(filter: any, original: any, initialValue?: any) {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    removeAccents = (str:string) => {\r\n        return str.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\");\r\n    }\r\n\r\n    setSelected(element:any, value?:any){\r\n        //console.log(element, value);\r\n        ((element.multi != undefined) && !element.multi) ? this.cleanFilter(this.data, element) : null;\r\n        this.setSelectedValue(element, value);\r\n    }\r\n\r\n    cleanFilter = (data:any, element_to_change:any) => {\r\n        //console.log(\"cleanFilter\");\r\n        element_to_change && data.forEach((element:any) => {\r\n            element_to_change != element ? element.selected = false : null;\r\n            (element.children && element.children.length > 0) && this.cleanFilter(element.children, element_to_change);\r\n        })\r\n    }\r\n\r\n    setSelectedValue(element:any, value?:any, sublist?:any, multi?:any){\r\n        let elements = sublist || this.data;\r\n        let index = elements.findIndex((subelement:any) => {\r\n            return (element.code || element) == subelement.code;\r\n        });\r\n        if (index >= 0) {\r\n            elements[index].selected = elements[index].selected ? false : true;\r\n            !multi && elements.forEach((child:any, i:number) => {\r\n                if (i != index) child.selected = false;\r\n            });\r\n            return {\r\n                elements,\r\n                founded: true\r\n            };\r\n        } else {\r\n            elements.some((elem:any) => elem.type == 'sub') && elements.some(\r\n                (filter:any) => {\r\n                    let founded = false;\r\n                    if (filter.type == 'sub') {\r\n                        const result = this.setSelectedValue(element, value, filter.children, filter.multi);\r\n                        if (result && result.founded) {\r\n                            filter.children = result.elements;\r\n                            founded = true;\r\n                        }\r\n                    }\r\n                    return founded;\r\n                }\r\n            )\r\n        }\r\n        return null;\r\n    };\r\n\r\n    getSelectedList = (): any => this.findSelected(this.data, []);\r\n\r\n    findSelected = (elements: any[], result:any) => {\r\n        let element = elements.find(elem => elem.selected);\r\n        if (element) {\r\n            result.push(element.code);\r\n            return result;\r\n        }\r\n        elements.forEach(elem => {\r\n            if (elem.children && elem.children.length) {\r\n                let new_result = this.findSelected(elem.children, result);\r\n                if (new_result) result = new_result;\r\n            }\r\n        })\r\n        return result;\r\n    }\r\n}\r\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvY2xhc3Nlcy9maWx0ZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWEsbUJBQW1CLENBQUM7QUFDakMsY0FBYSxxQkFBcUIsQ0FBQztBQUNuQyxjQUFhLG1CQUFtQixDQUFDO0FBQ2pDLGNBQWEsZUFBZSxDQUFDO0FBQzdCLGNBQWEsa0JBQWtCLENBQUM7QUFDaEMsY0FBYSxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tJy4vY2F0ZWdvcnktZmlsdGVyJztcclxuZXhwb3J0ICogZnJvbScuL2F0dHJpYnV0ZXMtZmlsdGVyJztcclxuZXhwb3J0ICogZnJvbScuL2R5bmFtaWNzLWZpbHRlcic7XHJcbmV4cG9ydCAqIGZyb20nLi9zb3J0LWZpbHRlcic7XHJcbmV4cG9ydCAqIGZyb20nLi9maWx0ZXItZmFjdG9yeSc7XHJcbmV4cG9ydCAqIGZyb20nLi9maWx0ZXInOyJdfQ==