monkey-front-core 0.0.469 → 0.0.471

package/esm2020/lib/core/services/commons/index.mjs

@@ -1,3 +1,4 @@
+export * from './monkeyecx-commons-resolve-base.service';
 export * from './monkeyecx-commons-resolve.service';
 export * from './monkeyecx-commons.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvY29tbW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1jb21tb25zLXJlc29sdmUuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWNvbW1vbnMuc2VydmljZSc7XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvY29tbW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWNvbW1vbnMtcmVzb2x2ZS1iYXNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9tb25rZXllY3gtY29tbW9ucy1yZXNvbHZlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9tb25rZXllY3gtY29tbW9ucy5zZXJ2aWNlJztcbiJdfQ==

package/esm2020/lib/core/services/commons/monkeyecx-commons-resolve-base.service.mjs

@@ -0,0 +1,109 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { Store } from '@ngrx/store';
+import { TranslateService } from '@ngx-translate/core';
+import { MonkeyEcxCommonsService } from '.';
+import { MonkeyEcxDiscoveryParamsService, MonkeyEcxPaginationService } from '../..';
+import { MonkeyEcxUtils } from '../../utils';
+export class MonkeyEcxCommonsResolveBaseService extends MonkeyEcxCommonsService {
+    constructor(monkeyecxService, tokenStorage, config) {
+        super(monkeyecxService, tokenStorage);
+        this.route = null;
+        this.currentRoute = null;
+        this.paginationService = inject(MonkeyEcxPaginationService);
+        this.translateService = inject(TranslateService);
+        this.router = inject(Router);
+        this.store = inject(Store);
+        this.monkeyDiscovery = inject(MonkeyEcxDiscoveryParamsService);
+        const { actions } = config;
+        this.action = actions;
+    }
+    async getData() {
+        try {
+            const { store, route, action, tokenStorage } = this;
+            const { companyId, governmentId } = await tokenStorage?.getToken();
+            if (!route)
+                return;
+            const url = MonkeyEcxUtils.replaceVariables(route, { companyId, governmentId });
+            store.dispatch(action.load({ url }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method getData -> ${e}`);
+        }
+    }
+    async loadPage(actionType) {
+        try {
+            const { store, action } = this;
+            store.dispatch(action.loadPagination({
+                pagination: {
+                    action: actionType
+                }
+            }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method loadPage -> ${e}`);
+        }
+    }
+    /**
+     * @description Inicializar a class genérica
+     * @param (args: MonkeyEcxInitialResolverConfig)
+     * => route é obrigátorio pois ele quem inicializa a store.
+     * A searchClass só se faz necessaria quando for usar filtros
+     */
+    init(args) {
+        try {
+            const { searchClass, route } = args;
+            this.route = route;
+            if (searchClass) {
+                // eslint-disable-next-line new-cap
+                const searchInstance = new searchClass(this.__search);
+                this.route = `${route}${searchInstance.buildParams()}`;
+                this.__onSearchChanged$.next(searchInstance);
+            }
+            this.getData();
+        }
+        catch (e) {
+            throw new Error(`${e?.message}`);
+        }
+    }
+    resolve(route, state, otherArgs) {
+        this.__search = route?.queryParams;
+        const [currentRoute] = state?.url.split('?') || [null];
+        this.currentRoute = currentRoute;
+        super.resolve(route, state, otherArgs);
+    }
+    /**
+     * @description Atualizar os filtros da tela
+     * @param (search: T, route?: string)
+     * => route é opcional, passar ele apenas se a rota for diferente do padrão
+     */
+    setSearch(search, route) {
+        try {
+            const { currentRoute, router } = this;
+            this.setSearchByUrl(router, route || `${currentRoute}`, search);
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method setSearch -> ${e}`);
+        }
+    }
+    /**
+     * @description Navegação para details.
+     * Por padrão sera redirecionado para '${currentRoute}/details'
+     * @param (detailsData: T, route?: string)
+     * => route é opcional, passar ele apenas se a rota for diferente do padrão
+     */
+    navigateToDetails(detailsData, route) {
+        try {
+            const { router, currentRoute } = this;
+            router.navigate([route || `${currentRoute}/details`], {
+                state: {
+                    detailsData
+                }
+            });
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method navigateToDetails -> ${e}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monkeyecx-commons-resolve-base.service.js","sourceRoot":"","sources":["../../../../../../../projects/monkey-front-core/src/lib/core/services/commons/monkeyecx-commons-resolve-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';\nimport { Action, Store } from '@ngrx/store';\nimport { TranslateService } from '@ngx-translate/core';\nimport { MonkeyEcxCommonsService } from '.';\nimport {\n  MonkeyEcxDiscoveryParamsService,\n  MonkeyEcxPaginationService,\n  MonkeyEcxTokenStorageService\n} from '../..';\nimport {\n  MonkeyEcxCommonsConfig,\n  MonkeyEcxCommonsSearch,\n  MonkeyEcxInitialResolverConfig\n} from '../../interfaces';\nimport { MonkeyEcxUtils } from '../../utils';\nimport { MonkeyEcxService } from '../monkeyecx-service.service';\n\nexport abstract class MonkeyEcxCommonsResolveBaseService extends MonkeyEcxCommonsService {\n  private action: any;\n\n  protected route: string | null = null;\n\n  protected currentRoute: string | null = null;\n\n  protected paginationService = inject(MonkeyEcxPaginationService);\n\n  protected translateService = inject(TranslateService);\n\n  protected router = inject(Router);\n\n  protected store = inject(Store);\n\n  protected monkeyDiscovery = inject(MonkeyEcxDiscoveryParamsService);\n\n  constructor(\n    monkeyecxService: MonkeyEcxService,\n    tokenStorage: MonkeyEcxTokenStorageService,\n    config: {\n      actions: {\n        load: Action;\n        loadPagination?: Action;\n      }\n    }\n  ) {\n    super(monkeyecxService, tokenStorage);\n    const { actions } = config;\n    this.action = actions;\n  }\n\n  protected async getData() {\n    try {\n      const { store, route, action, tokenStorage } = this;\n      const { companyId, governmentId } = await tokenStorage?.getToken();\n\n      if (!route) return;\n\n      const url = MonkeyEcxUtils.replaceVariables(route, { companyId, governmentId });\n\n      store.dispatch(action.load({ url }));\n    } catch (e) {\n      throw new Error(`MECX Core - Method getData -> ${e}`);\n    }\n  }\n\n  protected async loadPage(actionType: string) {\n    try {\n      const { store, action } = this;\n      store.dispatch(\n        action.loadPagination({\n          pagination: {\n            action: actionType\n          }\n        })\n      );\n    } catch (e) {\n      throw new Error(`MECX Core - Method loadPage -> ${e}`);\n    }\n  }\n\n  /**\n   * @description Inicializar a class genérica\n   * @param (args: MonkeyEcxInitialResolverConfig)\n   * => route é obrigátorio pois ele quem inicializa a store.\n   * A searchClass só se faz necessaria quando for usar filtros\n   */\n  protected init(args: MonkeyEcxInitialResolverConfig) {\n    try {\n      const { searchClass, route } = args;\n\n      this.route = route;\n\n      if (searchClass) {\n        // eslint-disable-next-line new-cap\n        const searchInstance: MonkeyEcxCommonsSearch = new searchClass(this.__search);\n\n        this.route = `${route}${searchInstance.buildParams()}`;\n\n        this.__onSearchChanged$.next(searchInstance);\n      }\n\n      this.getData();\n    } catch (e: any) {\n      throw new Error(`${e?.message}`);\n    }\n  }\n\n  resolve(\n    route: ActivatedRouteSnapshot | null,\n    state: RouterStateSnapshot | null,\n    otherArgs?: MonkeyEcxCommonsConfig\n  ) {\n    this.__search = route?.queryParams;\n\n    const [currentRoute] = state?.url.split('?') || [null];\n\n    this.currentRoute = currentRoute;\n\n    super.resolve(route, state, otherArgs);\n  }\n\n  /**\n   * @description Atualizar os filtros da tela\n   * @param (search: T, route?: string)\n   * => route é opcional, passar ele apenas se a rota for diferente do padrão\n   */\n  public setSearch<T>(search: T, route?: string): void {\n    try {\n      const { currentRoute, router } = this;\n\n      this.setSearchByUrl(router, route || `${currentRoute}`, search);\n    } catch (e) {\n      throw new Error(`MECX Core - Method setSearch -> ${e}`);\n    }\n  }\n\n  /**\n   * @description Navegação para details.\n   * Por padrão sera redirecionado para '${currentRoute}/details'\n   * @param (detailsData: T, route?: string)\n   * => route é opcional, passar ele apenas se a rota for diferente do padrão\n   */\n  public navigateToDetails<T>(detailsData: T, route?: string) {\n    try {\n      const { router, currentRoute } = this;\n\n      router.navigate([route || `${currentRoute}/details`], {\n        state: {\n          detailsData\n        }\n      });\n    } catch (e) {\n      throw new Error(`MECX Core - Method navigateToDetails -> ${e}`);\n    }\n  }\n}\n"]}

package/esm2020/lib/core/services/store/index.mjs

@@ -1,4 +1,5 @@
+export * from './monkeyecx-store-base.service';
 export * from './monkeyecx-store.actions';
 export * from './monkeyecx-store.selector';
 export * from './monkeyecx-store.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1zdG9yZS5hY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LXN0b3JlLnNlbGVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LXN0b3JlLnNlcnZpY2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LXN0b3JlLWJhc2Uuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1zdG9yZS5hY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LXN0b3JlLnNlbGVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LXN0b3JlLnNlcnZpY2UnO1xuIl19

package/esm2020/lib/core/services/store/monkeyecx-store-base.service.mjs

@@ -0,0 +1,169 @@
+import { __decorate } from "tslib";
+import { take } from 'rxjs/operators';
+import { MonkeyEcxCoreService } from '../../decorators';
+import { MonkeyEcxLinksModel } from '../../model';
+import { MonkeyEcxCommonsService } from '../commons';
+/**
+ * Classe genérica que recebe duas interfaces como tipos genéricos.
+ *
+ * @typeparam T deve ser a mesma interface utilizada na Entity da Store
+ * @typeparam K faz referência ao tipo de configuração.
+ *
+ * @description interfaces de configuração:
+ * ```
+ * MonkeyEcxCollectionStore e MonkeyEcxEntityStore
+ * ```
+ */
+export class MonkeyEcxCommonsStoreBaseService extends MonkeyEcxCommonsService {
+    constructor(monkeyecxService, tokenStorage, store, config) {
+        super(monkeyecxService, tokenStorage);
+        this.store = store;
+        const { actions, selectors } = config;
+        this.action = actions;
+        this.selector = selectors;
+    }
+    handleResponseData(resp, updateLinks = true) {
+        try {
+            let data;
+            if (resp?._embedded) {
+                const { _embedded, _links, page } = resp;
+                const key = Object.keys(_embedded)[0];
+                data = _embedded[key];
+                if (updateLinks) {
+                    this.updateLinks?.(_links);
+                }
+                this.updatePage?.(page);
+            }
+            else
+                data = resp;
+            this.update?.(data);
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method handleResponseData -> ${e}`);
+        }
+    }
+    updateControl(data) {
+        try {
+            this.store.dispatch(this.action.updateControl({
+                data
+            }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method updateControl -> ${e}`);
+        }
+    }
+    mappingData(args) {
+        try {
+            const handle = (item) => {
+                let id = '';
+                const { href } = new MonkeyEcxLinksModel(item)?.getAction('self') || {
+                    href: ''
+                };
+                if (href) {
+                    id = href.split('/').pop() || '';
+                }
+                return {
+                    ...item,
+                    id
+                };
+            };
+            if (args instanceof Array) {
+                return args.map((item) => {
+                    return handle(item);
+                });
+            }
+            return handle(args);
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method mappingData -> ${e}`);
+        }
+    }
+    update(args) {
+        try {
+            let typeAction = 'updateOne';
+            if (args instanceof Array) {
+                typeAction = 'updateAll';
+            }
+            this.store.dispatch(this.action[typeAction]({
+                data: this.mappingData(args)
+            }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method update -> ${e}`);
+        }
+    }
+    updatePage(data) {
+        try {
+            this.store.dispatch(this.action.updatePage({
+                data
+            }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method updatePage -> ${e}`);
+        }
+    }
+    updateLinks(data) {
+        try {
+            this.store.dispatch(this.action.updateLinks({
+                data
+            }));
+        }
+        catch (e) {
+            throw new Error(`MECX Core - Method updateLinks -> ${e}`);
+        }
+    }
+    async loadData(url, updateLinks = true) {
+        this.updateControl({ isLoading: true });
+        try {
+            const data = await this.monkeyecxService?.get(url).toPromise();
+            this.handleResponseData(data, updateLinks);
+        }
+        catch (e) {
+            throw new Error(`${e?.message}`);
+        }
+        this.updateControl({ isLoading: false });
+    }
+    async loadPageData(pagination) {
+        const { store, selector } = this;
+        const data = await store
+            .select(selector.selectLinks())
+            .pipe(take(1))
+            .toPromise();
+        const { action } = pagination;
+        const { href } = new MonkeyEcxLinksModel({ _links: data }).getAction(action) || {
+            href: ''
+        };
+        if (href) {
+            this.loadData(href);
+        }
+    }
+    /**
+     * @description Neste método precisamos incluir a lógica para conferir se precisa limpar a
+     * entidade ou não
+     * E depois precisa invocar o método loadData
+     * @param (url) ou de acordo com a action criada
+     * @example
+     * ```
+     * const hasDifference = .....
+     * if(hasDifference) {
+     *    store.dispatch(clear)
+     * }
+     *
+     * this.loadData(...)
+     * ```
+     */
+    load(args) {
+        throw new Error('MECX Core - Method load not implemented.');
+    }
+    loadPage(args) {
+        throw new Error('MECX Core - Method loadPage not implemented.');
+    }
+}
+__decorate([
+    MonkeyEcxCoreService({
+        requestInProgress: {
+            showProgress: true
+        }
+    })
+], MonkeyEcxCommonsStoreBaseService.prototype, "loadData", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monkeyecx-store-base.service.js","sourceRoot":"","sources":["../../../../../../../projects/monkey-front-core/src/lib/core/services/store/monkeyecx-store-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Store } from '@ngrx/store';\nimport { take } from 'rxjs/operators';\nimport { MonkeyEcxCoreService } from '../../decorators';\nimport {\n  MonkeyEcxConfigStore,\n  MonkeyEcxControlStore,\n  MonkeyEcxLinks,\n  MonkeyEcxPage,\n  MonkeyEcxPagination\n} from '../../interfaces';\nimport { MonkeyEcxLinksModel } from '../../model';\nimport { MonkeyEcxCommonsService } from '../commons';\nimport { MonkeyEcxService } from '../monkeyecx-service.service';\nimport { MonkeyEcxTokenStorageService } from '../storage';\n\n/**\n * Classe genérica que recebe duas interfaces como tipos genéricos.\n *\n * @typeparam T deve ser a mesma interface utilizada na Entity da Store\n * @typeparam K faz referência ao tipo de configuração.\n *\n * @description interfaces de configuração:\n * ```\n * MonkeyEcxCollectionStore e MonkeyEcxEntityStore\n * ```\n */\nexport abstract class MonkeyEcxCommonsStoreBaseService<\n  T,\n  K extends MonkeyEcxConfigStore\n> extends MonkeyEcxCommonsService {\n  private action: any;\n\n  private selector: any;\n\n  constructor(\n    monkeyecxService: MonkeyEcxService,\n    tokenStorage: MonkeyEcxTokenStorageService,\n    protected store: Store,\n    config: K\n  ) {\n    super(monkeyecxService, tokenStorage);\n    const { actions, selectors } = config;\n\n    this.action = actions;\n    this.selector = selectors;\n  }\n\n  private handleResponseData(resp: any, updateLinks = true) {\n    try {\n      let data: T;\n\n      if (resp?._embedded) {\n        const { _embedded, _links, page } = resp;\n        const key = Object.keys(_embedded)[0];\n\n        data = _embedded[key];\n\n        if (updateLinks) {\n          this.updateLinks?.(_links);\n        }\n\n        this.updatePage?.(page);\n      } else data = resp;\n\n      this.update?.(data);\n    } catch (e) {\n      throw new Error(`MECX Core - Method handleResponseData -> ${e}`);\n    }\n  }\n\n  protected updateControl(data: MonkeyEcxControlStore) {\n    try {\n      this.store.dispatch(\n        this.action.updateControl({\n          data\n        })\n      );\n    } catch (e) {\n      throw new Error(`MECX Core - Method updateControl -> ${e}`);\n    }\n  }\n\n  protected mappingData(args: T | T[]): T | T[] {\n    try {\n      const handle = (item: T) => {\n        let id = '';\n        const { href } = new MonkeyEcxLinksModel(item)?.getAction('self') || {\n          href: ''\n        };\n\n        if (href) {\n          id = href.split('/').pop() || '';\n        }\n\n        return {\n          ...item,\n          id\n        };\n      };\n\n      if (args instanceof Array) {\n        return args.map((item: T) => {\n          return handle(item);\n        });\n      }\n\n      return handle(args);\n    } catch (e) {\n      throw new Error(`MECX Core - Method mappingData -> ${e}`);\n    }\n  }\n\n  protected update?(args: T | T[]) {\n    try {\n      let typeAction = 'updateOne';\n\n      if (args instanceof Array) {\n        typeAction = 'updateAll';\n      }\n\n      this.store.dispatch(\n        this.action[typeAction]({\n          data: this.mappingData(args)\n        })\n      );\n    } catch (e) {\n      throw new Error(`MECX Core - Method update -> ${e}`);\n    }\n  }\n\n  protected updatePage?(data: MonkeyEcxPage) {\n    try {\n      this.store.dispatch(\n        this.action.updatePage({\n          data\n        })\n      );\n    } catch (e) {\n      throw new Error(`MECX Core - Method updatePage -> ${e}`);\n    }\n  }\n\n  protected updateLinks?(data: MonkeyEcxLinks) {\n    try {\n      this.store.dispatch(\n        this.action.updateLinks({\n          data\n        })\n      );\n    } catch (e) {\n      throw new Error(`MECX Core - Method updateLinks -> ${e}`);\n    }\n  }\n\n  @MonkeyEcxCoreService({\n    requestInProgress: {\n      showProgress: true\n    }\n  })\n  protected async loadData(url: string, updateLinks = true) {\n    this.updateControl({ isLoading: true });\n\n    try {\n      const data = await this.monkeyecxService?.get<any>(url).toPromise();\n      this.handleResponseData(data, updateLinks);\n    } catch (e: any) {\n      throw new Error(`${e?.message}`);\n    }\n\n    this.updateControl({ isLoading: false });\n  }\n\n  protected async loadPageData(pagination: MonkeyEcxPagination) {\n    const { store, selector } = this;\n    const data = await store\n      .select(selector.selectLinks())\n      .pipe(take(1))\n      .toPromise();\n\n    const { action } = pagination;\n    const { href } = new MonkeyEcxLinksModel({ _links: data }).getAction(action) || {\n      href: ''\n    };\n\n    if (href) {\n      this.loadData(href);\n    }\n  }\n\n  /**\n   * @description Neste método precisamos incluir a lógica para conferir se precisa limpar a\n   * entidade ou não\n   * E depois precisa invocar o método loadData\n   * @param (url) ou de acordo com a action criada\n   * @example\n   * ```\n   * const hasDifference = .....\n   * if(hasDifference) {\n   *    store.dispatch(clear)\n   * }\n   *\n   * this.loadData(...)\n   * ```\n   */\n  public load?(args: any) {\n    throw new Error('MECX Core - Method load not implemented.');\n  }\n\n  public loadPage?(args: any) {\n    throw new Error('MECX Core - Method loadPage not implemented.');\n  }\n}\n"]}

package/esm2020/lib/core/services/store/monkeyecx-store.selector.mjs

@@ -29,12 +29,18 @@ export class MonkeyEcxCommonsSelectors {
         };
         const selectLinks = (props) => {
             return createSelector(selectState, (state) => {
-                return state.links?.[props.identifier];
+                if (props?.identifier) {
+                    return state.links?.[props.identifier];
+                }
+                return state.links;
             });
         };
         const selectPage = (props) => {
             return createSelector(selectState, (state) => {
-                return state.page?.[props.identifier];
+                if (props?.identifier) {
+                    return state.page?.[props.identifier];
+                }
+                return state.page;
             });
         };
         const linksHasDifference = (props) => {
@@ -72,4 +78,4 @@ export class MonkeyEcxCommonsSelectors {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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