@po-ui/ng-storage 5.22.3 → 6.2.0

package/esm2020/lib/services/po-storage.service.mjs

@@ -0,0 +1,520 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import * as LocalForage from 'localforage';
+import 'localforage';
+import IdleQueue from 'custom-idle-queue';
+import { PoLokiDriver } from '../drivers/lokijs/po-loki-driver';
+import * as i0 from "@angular/core";
+export const PO_STORAGE_CONFIG_TOKEN = new InjectionToken('PO_STORAGE_CONFIG_TOKEN');
+/**
+ * @description
+ *
+ * O PO Storage é uma biblioteca que fornece um serviço para armazenamento de dados no dispositivo local, sendo semelhante
+ * ao funcionamento do [IonicStorage](https://ionicframework.com/docs/storage/).
+ * É possível utilizar os drivers [Websql](https://dev.w3.org/html5/webdatabase/), [Indexeddb](https://www.w3.org/TR/IndexedDB/),
+ * [LocalStorage](https://html.spec.whatwg.org/multipage/webstorage.html) e também [LokiJS](https://github.com/techfort/LokiJS/wiki).
+ *
+ * Para um melhor ganho de performance ao buscar e salvar dados, recomendamos a utilização do `LokiJS`, um *database*
+ * orientado a documento semelhante ao MongoDB, que além de permitir a persistência dos dados no dispositivo possibilita
+ * também o armazenamento dos dados em memória. Outra vantagem, é o aumento do limite de armazenamento para
+ * aproximadamente `300mb`.
+ *
+ * A estrutura utilizada para armazenar os dados é a de chave/valor, onde uma chave funciona como um identificador exclusivo.
+ *
+ * #### Instalando o PO Storage
+ *
+ * Para instalar o `po-storage` em sua aplicação execute o seguinte comando:
+ *
+ * ```shell
+ * ng add @po-ui/ng-storage
+ * ```
+ * Será instalado o pacote `@po-ui/ng-storage` e também já importará `PoStorageModule` no módulo principal da sua aplicação, conforme abaixo:
+ *
+ * ```typescript
+ * import { PoStorageModule } from '@po-ui/ng-storage';
+ *
+ * @NgModule({
+ *  declarations: [...],
+ *  imports: [
+ *    // Importação do módulo PoStorageModule
+ *    PoStorageModule.forRoot(),
+ *  ],
+ *  bootstrap: [IonicApp],
+ *  providers: [...]
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Com a declaração do módulo, é criada uma base de dados no armazenamento local e o serviço `PoStorageService` estará
+ * pronto para ser utilizada na sua aplicação.
+ *
+ * #### Configurando as opções de armazenamento
+ *
+ * Na importação do módulo, o método `PoStorageModule.forRoot()` pode receber como parâmetro um objeto do tipo
+ * [`PoStorageConfig`](documentation/po-storage#po-storage-config),
+ * que serve para configurar as opções personalizadas do armazenamento, como por exemplo: o tipo de armazenamento
+ * preferêncial.
+ *
+ * Caso não seja passada nenhuma configuração a ordem padrão será: ['websql', 'indexeddb', 'localstorage', 'lokijs'].
+ *
+ * Abaixo segue um exemplo de configuração onde o storage preferencial passa a ser o `lokijs`:
+ *
+ * ```typescript
+ * import { PoStorageModule } from '@po-ui/ng-storage';
+ *
+ * @NgModule({
+ *  declarations: [...],
+ *  imports: [
+ *    // Importação do módulo PoStorageModule com a configuração personalizada
+ *    PoStorageModule.forRoot({
+ *      name: 'mystorage',
+ *      storeName: '_mystore',
+ *      driverOrder: ['lokijs', 'websql', 'indexeddb', 'localstorage']
+ *    }),
+ *  ],
+ *  bootstrap: [IonicApp],
+ *  providers: [...]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export class PoStorageService {
+    constructor(config) {
+        this.driver = null;
+        this.idleQueue = new IdleQueue();
+        this.lokijsDriver = new PoLokiDriver();
+        this.setStoragePromise(config);
+    }
+    /**
+     * Retorna a configuração padrão para o armazenamento. Caso nenhuma configuração seja inserida,
+     * essa configuração será utilizada.
+     *
+     * @returns {PoStorageConfig} Objeto com a configuração padrão do armazenamento.
+     */
+    static getDefaultConfig() {
+        return {
+            name: '_postorage',
+            storeName: '_pokv',
+            driverOrder: ['websql', 'indexeddb', 'localstorage', 'lokijs']
+        };
+    }
+    /**
+     * Cria uma instância do `PoStorageService` com a configuração de armazenamento passada como parâmetro.
+     *
+     * @param {PoStorageConfig} storageConfig Configuração para o armazenamento.
+     * @returns {PoStorageService} Instância do `PoStorageService`.
+     */
+    static providePoStorage(storageConfig) {
+        return new PoStorageService(PoStorageService.getConfig(storageConfig));
+    }
+    static getConfig(storageConfig) {
+        return storageConfig || PoStorageService.getDefaultConfig();
+    }
+    /**
+     * Busca uma lista armazenada pela chave e concatena com a lista passada por parâmetro.
+     *
+     * Por exemplo:
+     *
+     * ``` typescript
+     * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];
+     *
+     * this.poStorageService.set('clientKey', clients).then(() => {});
+     *
+     * ...
+     *
+     * const newClients = [ { name: 'Lisa', age: 36 }, { name: 'Bruce', age: 18 } ];
+     *
+     * this.poStorageService.appendArrayToArray('clientKey', newClients).then(() => {
+     *   // A lista agora será:
+     *   // [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }, { name: 'Lisa', age: 36 }, { name: 'Bruce', age: 18 }];
+     * });
+     * ```
+     *
+     * @param {string} key Chave da lista armazenada.
+     * @param {Array} value Lista que será concatenada.
+     *
+     * @returns {Promise<any>} Promessa que é resolvida após as duas listas serem concatenadas e armazenadas localmente.
+     */
+    async appendArrayToArray(key, value) {
+        const data = await this.getArrayOfStorage(key);
+        const newData = [...data, ...value];
+        return this.set(key, newData);
+    }
+    /**
+     * Acrescenta um item em uma lista armazenada pela chave.
+     *
+     * @param {string} key Chave da lista armazenada.
+     * @param {Array} value Item que será acrescentado na lista.
+     *
+     * @returns {Promise<any>} Promessa que é resolvida após o item ser acrescentado na lista armazenada.
+     */
+    async appendItemToArray(key, value) {
+        const data = await this.getArrayOfStorage(key);
+        data.push(value);
+        return this.set(key, data);
+    }
+    /**
+     * Remove todos os itens da base de dados local configurada na declaração do módulo `PoStorageModule`.
+     *
+     * > Utilize este método com cautela, para evitar a perda indesejada de dados.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida após todos os itens da base de dados local serem removidos.
+     */
+    clear() {
+        return this.storagePromise.then(store => store.clear());
+    }
+    /**
+     * Verifica se existe um valor dentro de uma determinada chave.
+     *
+     * @param {string} key Chave que será verificada.
+     *
+     * @returns {Promise<boolean>} Promessa que é resolvida quando a verificação da existência do valor na chave é concluída.
+     */
+    exists(key) {
+        return this.get(key).then(data => Promise.resolve(data !== null));
+    }
+    /**
+     * Itera sobre todas as chaves armazenadas.
+     *
+     * @param {any} iteratorCallback Função de `callback` que é chamada a cada iteração, com os seguintes parâmetros:
+     * valor, chave e número da iteração.
+     *
+     * Exemplo de utilização:
+     *
+     * ``` typescript
+     * this.poStorageService.forEach((value: any, key: string, iterationNumber: number) => {
+     *   // Iteração sobre cada chave armazenada.
+     * });
+     * ```
+     *
+     * @returns {Promise<void>} Promessa que é resolvida após a iteração sobre todas as chaves armazenadas.
+     */
+    forEach(iteratorCallback) {
+        return this.storagePromise.then(store => store.iterate(iteratorCallback));
+    }
+    /**
+     * Retorna o valor armazenado em uma determinada chave.
+     *
+     * @param {string} key Chave que identifica o item.
+     * @param {boolean} lock Define se irá travar a leitura e a escrita da base de dados para não ser acessada de forma paralela.
+     * Caso outra leitura/escrita já tenha sido iniciada, este método irá esperar o outro terminar para então começar.
+     *
+     * Padrão: `false`.
+     *
+     * > Esta definição só será válida se o outro acesso paralelo a este método também estiver com o parâmetro *lock* ativado.
+     * @returns {Promise<any>} Promessa que é resolvida após o item ser buscado.
+     */
+    async get(key, lock = false) {
+        if (lock) {
+            await this.requestIdlePromise();
+            return await this.idleQueue.wrapCall(async () => {
+                await this.getImmutableItem(key);
+            });
+        }
+        return await this.getImmutableItem(key);
+    }
+    /**
+     * Retorna o nome do *driver* que está sendo usado para armazenar os dados, por exemplo: localStorage.
+     *
+     * @returns {string | null} Nome do *driver*.
+     */
+    getDriver() {
+        return this.driver;
+    }
+    /**
+     * Retorna o primeiro item de uma lista para uma determinada chave.
+     *
+     * @param {string} key Chave da lista.
+     * @returns {Promise<any>} Promessa que é resolvida após o primeiro item ser encontrado.
+     */
+    getFirstItem(key) {
+        return this.get(key).then((data) => Promise.resolve(data ? data[0] : null));
+    }
+    /**
+     * Remove o primeiro item de uma lista a partir da chave.
+     *
+     * @param {string} key Chave da lista que será removido o primeiro item.
+     * @returns {Promise<any>} Promessa que é resolvida após o primeiro item da lista ser removido.
+     */
+    getItemAndRemove(key) {
+        return this.get(key).then((data) => {
+            if (data === null) {
+                return null;
+            }
+            const item = data.shift();
+            return this.set(key, data).then(() => Promise.resolve(item));
+        });
+    }
+    /**
+     * Busca o primeiro objeto encontrado dentro de uma lista pelo do valor de um campo.
+     *
+     * Por exemplo:
+     *
+     * ``` typescript
+     * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];
+     *
+     * this.poStorageService.set('clientKey', clients).then(() => {});
+     *
+     * ...
+     *
+     * this.poStorageService.getItemByField('clientKey', 'name', 'Marie').then(client => {
+     *   // Resultado do console.log: { name: 'Marie', age: 23 }
+     *   console.log(client);
+     * });
+     * ```
+     *
+     * @param {string} key Chave da lista.
+     * @param {string} fieldName O campo a ser filtrado.
+     * @param {any} fieldValue O valor do campo.
+     * @returns {Promise<any>} Promessa que é resolvida com o item que foi encontrado.
+     */
+    getItemByField(key, fieldName, fieldValue) {
+        return this.get(key).then((storageRecords) => {
+            let storageRecordsFiltered = storageRecords.find(storageRecord => storageRecord[fieldName] === fieldValue);
+            storageRecordsFiltered = storageRecordsFiltered || null;
+            return Promise.resolve(storageRecordsFiltered);
+        });
+    }
+    /**
+     * Lista com todas as chaves armazenadas.
+     *
+     * @returns {Promise<Array<string>>} Promessa que é resolvida com todas as chaves armazenadas.
+     */
+    keys() {
+        return this.storagePromise.then(store => store.keys());
+    }
+    /**
+     * Quantidade de chaves armazenadas.
+     *
+     * @returns {Promise<number>} Promessa que é resolvida com o número de chaves armazenadas.
+     */
+    length() {
+        return this.storagePromise.then(store => store.length());
+    }
+    /**
+     * Utilizado para gerenciar o bloqueio e desbloqueio de recursos no `PoStorageService`.
+     * Aguardando a liberação da utilização dos recursos que participam deste comportamento e posteriormente envolve o recurso
+     * passado como parâmetro em um comportamento de bloqueio e desbloqueio.
+     *
+     * Este método se comporta igual a utilização em conjunta dos métodos: `PoStorageService.requestIdlePromise()`,
+     * `PoStorageService.lock()` e `PoStorageService.unlook()`.
+     *
+     * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).
+     *
+     * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.
+     */
+    async limitedCallWrap(limitedResource) {
+        await this.requestIdlePromise();
+        return this.idleQueue.wrapCall(limitedResource);
+    }
+    /**
+     * Incrementa um valor na fila de bloqueio do `PoStorageService`. Utilizado juntamente com o método `unlock` para poder
+     * controlar a execução de uma determinada tarefa com o `PoStorage.requestIdlePromise()`.
+     *
+     * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).
+     */
+    lock() {
+        this.idleQueue.lock();
+    }
+    /**
+     * Determina se o processo de inicialização do *driver* assíncrono foi concluído.
+     *
+     * @returns {Promise<LocalForage>} Promessa que é resolvida quando o processo de inicialização do *driver* assíncrono
+     * for concluído.
+     */
+    ready() {
+        return this.storagePromise;
+    }
+    /**
+     * Remove um valor associado a uma chave.
+     *
+     * @param {key} key Chave do valor que será removido.
+     * @returns {Promise<any>} Promessa que é resolvida após o valor ser removido.
+     */
+    remove(key) {
+        return this.storagePromise.then(store => store.removeItem(key));
+    }
+    /**
+     * Remove uma propriedade de um objeto armazenado.
+     *
+     * @param {string} key Chave do objeto armazenado.
+     * @param {string} property Propriedade que será removida.
+     *
+     * @returns {Promise<any>} Promessa que é resolvida após a propriedade ser removida.
+     */
+    async removeIndexFromObject(key, property) {
+        const data = await this.getObjectOfStorage(key);
+        delete data[property];
+        return this.set(key, data);
+    }
+    /**
+     * Remove um objeto de uma lista armazenada pelo valor de uma propriedade.
+     *
+     * Por exemplo:
+     *
+     * ``` typescript
+     * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];
+     *
+     * this.poStorageService.set('clientKey', clients).then(() => {});
+     *
+     * ...
+     *
+     * this.poStorageService.removeItemFromArray('clientKey', 'name', 'Marie').then(() => {
+     *   // O objeto { name: 'Marie', age: 23 } foi removido da lista que está na chave 'clientKey'
+     * });
+     * ```
+     *
+     * @param {string} key Chave da lista que contém o item que será removido.
+     * @param {string} field O campo a ser filtrado no item.
+     * @param {string} value O valor do filtro.
+     * @returns {Promise<any>} Promessa que é resolvida quando o objeto for removido da lista.
+     */
+    async removeItemFromArray(key, field, value) {
+        let data = await this.getArrayOfStorage(key);
+        data = data.filter(item => item[field] !== value);
+        return this.set(key, data);
+    }
+    /**
+     * <a id="request-idle-promise"></a>
+     * Método que verifica se o acesso a base de dados configurada está liberado.
+     *
+     * Utilizado em conjunto com os métodos `lock()` e `unlock()` entre tarefas que não podem ser executadas de forma
+     * paralela, para não causar inconsistências nos dados.
+     *
+     * Exemplo de utilização:
+     *
+     * ```
+     * // Aguarda a liberação para continuar
+     * await this.poStorage.requestIdlePromise();
+     *
+     * this.poStorage.lock();
+     *
+     * // Executa uma tarefa que irá ler e/ou escrever na base de dados configurada.
+     *
+     * this.poStorage.unlock();
+     * ```
+     *
+     * > É importante sempre utilizá-lo antes de executar os métodos `lock()` e `unlock()` para garantir que a tarefa só
+     * será executada caso o acesso esteja livre.
+     *
+     * @returns {Promise<any>} Promessa que é resolvida quando o acesso a base de dados configurada estiver liberado.
+     */
+    requestIdlePromise() {
+        return this.idleQueue.requestIdlePromise();
+    }
+    /**
+     * Grava um valor em uma determinada chave.
+     *
+     * @param {string} key Chave para o valor que será gravado.
+     * @param {any} value Valor que será gravado.
+     * @param {boolean} lock Define se irá travar a leitura e a escrita da base de dados para não ser acessada de forma paralela.
+     * Caso outra leitura/escrita já tenha sido iniciada, este método irá esperar o outro terminar para então começar.
+     *
+     * Padrão: `false`.
+     *
+     * > Esta definição só será válida se o outro acesso paralelo a este método também estiver com o parâmetro *lock* ativado.
+     * @returns {Promise<any>} Promessa que é resolvida após o valor ter sido gravado.
+     */
+    async set(key, value, lock = false) {
+        const store = await this.storagePromise;
+        const newValue = typeof value === 'object' ? JSON.parse(JSON.stringify(value)) : value;
+        if (lock) {
+            await this.requestIdlePromise();
+            return this.idleQueue.wrapCall(() => store.setItem(key, newValue));
+        }
+        return store.setItem(key, newValue);
+    }
+    /**
+     * Atribui um valor a uma propriedade de um objeto armazenado pela chave.
+     *
+     * Por exemplo:
+     *
+     * ``` typescript
+     * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];
+     *
+     * this.poStorageService.set('clientKey', clients).then(() => {});
+     *
+     * ...
+     *
+     * this.poStorageService.setIndexToObject('clientKey', 'name', 'Clare').then(() => {
+     *   // O objeto { name: 'Marie', age: 23 } passa a ser { name: 'Clare', age: 23 }
+     * });
+     * ```
+     *
+     * @param {string} key Chave do objeto.
+     * @param {string} property Nome da propriedade do objeto.
+     * @param {any} value Valor que será gravado na propriedade do objeto.
+     */
+    async setIndexToObject(key, property, value) {
+        const data = await this.getObjectOfStorage(key);
+        data[property] = value;
+        return this.set(key, data);
+    }
+    /**
+     * Decrementa um valor na fila de bloqueio. Utilizado juntamente com o método `lock` para poder
+     * controlar a execução de uma determinada tarefa com o `PoStorage.requestIdlePromise()`.
+     *
+     * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).
+     */
+    unlock() {
+        this.idleQueue.unlock();
+    }
+    async getArrayOfStorage(key) {
+        const data = await this.get(key);
+        return data || [];
+    }
+    async getImmutableItem(key) {
+        const store = await this.storagePromise;
+        const items = await store.getItem(key);
+        return items ? JSON.parse(JSON.stringify(items)) : null;
+    }
+    async defineLocalForageDriver(localForageInstance, driverOrder) {
+        await localForageInstance.defineDriver(this.lokijsDriver.getDriver());
+        await this.setDriver(localForageInstance, driverOrder);
+        return localForageInstance;
+    }
+    getDriverOrder(driverOrder) {
+        return driverOrder.map(driver => {
+            switch (driver) {
+                case 'indexeddb':
+                    return LocalForage.INDEXEDDB;
+                case 'websql':
+                    return LocalForage.WEBSQL;
+                case 'localstorage':
+                    return LocalForage.LOCALSTORAGE;
+                default:
+                    return driver;
+            }
+        });
+    }
+    async getObjectOfStorage(key) {
+        const data = await this.get(key);
+        return data || {};
+    }
+    async setDriver(localForageInstance, driverOrder) {
+        await localForageInstance.setDriver(this.getDriverOrder(driverOrder));
+        this.driver = localForageInstance.driver();
+    }
+    setStoragePromise(config) {
+        this.storagePromise = this.getStorageInstance(config);
+    }
+    async getStorageInstance(config) {
+        const defaultConfig = PoStorageService.getDefaultConfig();
+        const actualConfig = Object.assign(defaultConfig, config || {});
+        const localForageInstance = LocalForage.createInstance(actualConfig);
+        try {
+            return await this.defineLocalForageDriver(localForageInstance, actualConfig.driverOrder);
+        }
+        catch {
+            throw new Error(`Cannot use this drivers: ${actualConfig.driverOrder.join(', ')}.`);
+        }
+    }
+}
+PoStorageService.ɵfac = function PoStorageService_Factory(t) { return new (t || PoStorageService)(i0.ɵɵinject(PO_STORAGE_CONFIG_TOKEN)); };
+PoStorageService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoStorageService, factory: PoStorageService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoStorageService, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [PO_STORAGE_CONFIG_TOKEN]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-storage.service.js","sourceRoot":"","sources":["../../../../../projects/storage/src/lib/services/po-storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken } from '@angular/core';\n\nimport * as LocalForage from 'localforage';\nimport 'localforage';\n\nimport IdleQueue from 'custom-idle-queue';\n\nimport { PoLokiDriver } from '../drivers/lokijs/po-loki-driver';\nimport { PoStorageConfig } from './po-storage-config.interface';\n\nexport const PO_STORAGE_CONFIG_TOKEN = new InjectionToken('PO_STORAGE_CONFIG_TOKEN');\n\n/**\n * @description\n *\n * O PO Storage é uma biblioteca que fornece um serviço para armazenamento de dados no dispositivo local, sendo semelhante\n * ao funcionamento do [IonicStorage](https://ionicframework.com/docs/storage/).\n * É possível utilizar os drivers [Websql](https://dev.w3.org/html5/webdatabase/), [Indexeddb](https://www.w3.org/TR/IndexedDB/),\n * [LocalStorage](https://html.spec.whatwg.org/multipage/webstorage.html) e também [LokiJS](https://github.com/techfort/LokiJS/wiki).\n *\n * Para um melhor ganho de performance ao buscar e salvar dados, recomendamos a utilização do `LokiJS`, um *database*\n * orientado a documento semelhante ao MongoDB, que além de permitir a persistência dos dados no dispositivo possibilita\n * também o armazenamento dos dados em memória. Outra vantagem, é o aumento do limite de armazenamento para\n * aproximadamente `300mb`.\n *\n * A estrutura utilizada para armazenar os dados é a de chave/valor, onde uma chave funciona como um identificador exclusivo.\n *\n * #### Instalando o PO Storage\n *\n * Para instalar o `po-storage` em sua aplicação execute o seguinte comando:\n *\n * ```shell\n * ng add @po-ui/ng-storage\n * ```\n * Será instalado o pacote `@po-ui/ng-storage` e também já importará `PoStorageModule` no módulo principal da sua aplicação, conforme abaixo:\n *\n * ```typescript\n * import { PoStorageModule } from '@po-ui/ng-storage';\n *\n * @NgModule({\n *  declarations: [...],\n *  imports: [\n *    // Importação do módulo PoStorageModule\n *    PoStorageModule.forRoot(),\n *  ],\n *  bootstrap: [IonicApp],\n *  providers: [...]\n * })\n * export class AppModule {}\n * ```\n *\n * Com a declaração do módulo, é criada uma base de dados no armazenamento local e o serviço `PoStorageService` estará\n * pronto para ser utilizada na sua aplicação.\n *\n * #### Configurando as opções de armazenamento\n *\n * Na importação do módulo, o método `PoStorageModule.forRoot()` pode receber como parâmetro um objeto do tipo\n * [`PoStorageConfig`](documentation/po-storage#po-storage-config),\n * que serve para configurar as opções personalizadas do armazenamento, como por exemplo: o tipo de armazenamento\n * preferêncial.\n *\n * Caso não seja passada nenhuma configuração a ordem padrão será: ['websql', 'indexeddb', 'localstorage', 'lokijs'].\n *\n * Abaixo segue um exemplo de configuração onde o storage preferencial passa a ser o `lokijs`:\n *\n * ```typescript\n * import { PoStorageModule } from '@po-ui/ng-storage';\n *\n * @NgModule({\n *  declarations: [...],\n *  imports: [\n *    // Importação do módulo PoStorageModule com a configuração personalizada\n *    PoStorageModule.forRoot({\n *      name: 'mystorage',\n *      storeName: '_mystore',\n *      driverOrder: ['lokijs', 'websql', 'indexeddb', 'localstorage']\n *    }),\n *  ],\n *  bootstrap: [IonicApp],\n *  providers: [...]\n * })\n * export class AppModule {}\n * ```\n */\n@Injectable()\nexport class PoStorageService {\n  private driver: string = null;\n  private idleQueue = new IdleQueue();\n  private storagePromise: Promise<LocalForage>;\n  private lokijsDriver: PoLokiDriver;\n\n  constructor(@Inject(PO_STORAGE_CONFIG_TOKEN) config?: PoStorageConfig) {\n    this.lokijsDriver = new PoLokiDriver();\n    this.setStoragePromise(config);\n  }\n\n  /**\n   * Retorna a configuração padrão para o armazenamento. Caso nenhuma configuração seja inserida,\n   * essa configuração será utilizada.\n   *\n   * @returns {PoStorageConfig} Objeto com a configuração padrão do armazenamento.\n   */\n  static getDefaultConfig(): PoStorageConfig {\n    return {\n      name: '_postorage',\n      storeName: '_pokv',\n      driverOrder: ['websql', 'indexeddb', 'localstorage', 'lokijs']\n    };\n  }\n\n  /**\n   * Cria uma instância do `PoStorageService` com a configuração de armazenamento passada como parâmetro.\n   *\n   * @param {PoStorageConfig} storageConfig Configuração para o armazenamento.\n   * @returns {PoStorageService} Instância do `PoStorageService`.\n   */\n  static providePoStorage(storageConfig?: PoStorageConfig): PoStorageService {\n    return new PoStorageService(PoStorageService.getConfig(storageConfig));\n  }\n\n  private static getConfig(storageConfig?: PoStorageConfig) {\n    return storageConfig || PoStorageService.getDefaultConfig();\n  }\n\n  /**\n   * Busca uma lista armazenada pela chave e concatena com a lista passada por parâmetro.\n   *\n   * Por exemplo:\n   *\n   * ``` typescript\n   * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];\n   *\n   * this.poStorageService.set('clientKey', clients).then(() => {});\n   *\n   * ...\n   *\n   * const newClients = [ { name: 'Lisa', age: 36 }, { name: 'Bruce', age: 18 } ];\n   *\n   * this.poStorageService.appendArrayToArray('clientKey', newClients).then(() => {\n   *   // A lista agora será:\n   *   // [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }, { name: 'Lisa', age: 36 }, { name: 'Bruce', age: 18 }];\n   * });\n   * ```\n   *\n   * @param {string} key Chave da lista armazenada.\n   * @param {Array} value Lista que será concatenada.\n   *\n   * @returns {Promise<any>} Promessa que é resolvida após as duas listas serem concatenadas e armazenadas localmente.\n   */\n  async appendArrayToArray(key: string, value: Array<any>): Promise<any> {\n    const data = await this.getArrayOfStorage(key);\n\n    const newData = [...data, ...value];\n    return this.set(key, newData);\n  }\n\n  /**\n   * Acrescenta um item em uma lista armazenada pela chave.\n   *\n   * @param {string} key Chave da lista armazenada.\n   * @param {Array} value Item que será acrescentado na lista.\n   *\n   * @returns {Promise<any>} Promessa que é resolvida após o item ser acrescentado na lista armazenada.\n   */\n  async appendItemToArray(key: string, value: any): Promise<any> {\n    const data = await this.getArrayOfStorage(key);\n\n    data.push(value);\n    return this.set(key, data);\n  }\n\n  /**\n   * Remove todos os itens da base de dados local configurada na declaração do módulo `PoStorageModule`.\n   *\n   * > Utilize este método com cautela, para evitar a perda indesejada de dados.\n   *\n   * @returns {Promise<void>} Promessa que é resolvida após todos os itens da base de dados local serem removidos.\n   */\n  clear(): Promise<void> {\n    return this.storagePromise.then(store => store.clear());\n  }\n\n  /**\n   * Verifica se existe um valor dentro de uma determinada chave.\n   *\n   * @param {string} key Chave que será verificada.\n   *\n   * @returns {Promise<boolean>} Promessa que é resolvida quando a verificação da existência do valor na chave é concluída.\n   */\n  exists(key: string): Promise<boolean> {\n    return this.get(key).then(data => Promise.resolve(data !== null));\n  }\n\n  /**\n   * Itera sobre todas as chaves armazenadas.\n   *\n   * @param {any} iteratorCallback Função de `callback` que é chamada a cada iteração, com os seguintes parâmetros:\n   * valor, chave e número da iteração.\n   *\n   * Exemplo de utilização:\n   *\n   * ``` typescript\n   * this.poStorageService.forEach((value: any, key: string, iterationNumber: number) => {\n   *   // Iteração sobre cada chave armazenada.\n   * });\n   * ```\n   *\n   * @returns {Promise<void>} Promessa que é resolvida após a iteração sobre todas as chaves armazenadas.\n   */\n  forEach(iteratorCallback: (value: any, key: string, iterationNumber: number) => any): Promise<void> {\n    return this.storagePromise.then(store => store.iterate(iteratorCallback));\n  }\n\n  /**\n   * Retorna o valor armazenado em uma determinada chave.\n   *\n   * @param {string} key Chave que identifica o item.\n   * @param {boolean} lock Define se irá travar a leitura e a escrita da base de dados para não ser acessada de forma paralela.\n   * Caso outra leitura/escrita já tenha sido iniciada, este método irá esperar o outro terminar para então começar.\n   *\n   * Padrão: `false`.\n   *\n   * > Esta definição só será válida se o outro acesso paralelo a este método também estiver com o parâmetro *lock* ativado.\n   * @returns {Promise<any>} Promessa que é resolvida após o item ser buscado.\n   */\n  async get(key: string, lock: boolean = false): Promise<any> {\n    if (lock) {\n      await this.requestIdlePromise();\n      return await this.idleQueue.wrapCall(async () => {\n        await this.getImmutableItem(key);\n      });\n    }\n    return await this.getImmutableItem(key);\n  }\n\n  /**\n   * Retorna o nome do *driver* que está sendo usado para armazenar os dados, por exemplo: localStorage.\n   *\n   * @returns {string | null} Nome do *driver*.\n   */\n  getDriver(): string {\n    return this.driver;\n  }\n\n  /**\n   * Retorna o primeiro item de uma lista para uma determinada chave.\n   *\n   * @param {string} key Chave da lista.\n   * @returns {Promise<any>} Promessa que é resolvida após o primeiro item ser encontrado.\n   */\n  getFirstItem(key: string): Promise<any> {\n    return this.get(key).then((data: Array<any>) => Promise.resolve(data ? data[0] : null));\n  }\n\n  /**\n   * Remove o primeiro item de uma lista a partir da chave.\n   *\n   * @param {string} key Chave da lista que será removido o primeiro item.\n   * @returns {Promise<any>} Promessa que é resolvida após o primeiro item da lista ser removido.\n   */\n  getItemAndRemove(key: string): Promise<any> {\n    return this.get(key).then((data: Array<any>) => {\n      if (data === null) {\n        return null;\n      }\n\n      const item = data.shift();\n      return this.set(key, data).then(() => Promise.resolve(item));\n    });\n  }\n\n  /**\n   * Busca o primeiro objeto encontrado dentro de uma lista pelo do valor de um campo.\n   *\n   * Por exemplo:\n   *\n   * ``` typescript\n   * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];\n   *\n   * this.poStorageService.set('clientKey', clients).then(() => {});\n   *\n   * ...\n   *\n   * this.poStorageService.getItemByField('clientKey', 'name', 'Marie').then(client => {\n   *   // Resultado do console.log: { name: 'Marie', age: 23 }\n   *   console.log(client);\n   * });\n   * ```\n   *\n   * @param {string} key Chave da lista.\n   * @param {string} fieldName O campo a ser filtrado.\n   * @param {any} fieldValue O valor do campo.\n   * @returns {Promise<any>} Promessa que é resolvida com o item que foi encontrado.\n   */\n  getItemByField(key: string, fieldName: string, fieldValue: any): Promise<any> {\n    return this.get(key).then((storageRecords: Array<any>) => {\n      let storageRecordsFiltered = storageRecords.find(storageRecord => storageRecord[fieldName] === fieldValue);\n      storageRecordsFiltered = storageRecordsFiltered || null;\n\n      return Promise.resolve(storageRecordsFiltered);\n    });\n  }\n\n  /**\n   * Lista com todas as chaves armazenadas.\n   *\n   * @returns {Promise<Array<string>>} Promessa que é resolvida com todas as chaves armazenadas.\n   */\n  keys(): Promise<Array<string>> {\n    return this.storagePromise.then(store => store.keys());\n  }\n\n  /**\n   * Quantidade de chaves armazenadas.\n   *\n   * @returns {Promise<number>} Promessa que é resolvida com o número de chaves armazenadas.\n   */\n  length(): Promise<number> {\n    return this.storagePromise.then(store => store.length());\n  }\n\n  /**\n   * Utilizado para gerenciar o bloqueio e desbloqueio de recursos no `PoStorageService`.\n   * Aguardando a liberação da utilização dos recursos que participam deste comportamento e posteriormente envolve o recurso\n   * passado como parâmetro em um comportamento de bloqueio e desbloqueio.\n   *\n   * Este método se comporta igual a utilização em conjunta dos métodos: `PoStorageService.requestIdlePromise()`,\n   * `PoStorageService.lock()` e `PoStorageService.unlook()`.\n   *\n   * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).\n   *\n   * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.\n   */\n  async limitedCallWrap(limitedResource: Function): Promise<any> {\n    await this.requestIdlePromise();\n    return this.idleQueue.wrapCall(limitedResource);\n  }\n\n  /**\n   * Incrementa um valor na fila de bloqueio do `PoStorageService`. Utilizado juntamente com o método `unlock` para poder\n   * controlar a execução de uma determinada tarefa com o `PoStorage.requestIdlePromise()`.\n   *\n   * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).\n   */\n  lock() {\n    this.idleQueue.lock();\n  }\n\n  /**\n   * Determina se o processo de inicialização do *driver* assíncrono foi concluído.\n   *\n   * @returns {Promise<LocalForage>} Promessa que é resolvida quando o processo de inicialização do *driver* assíncrono\n   * for concluído.\n   */\n  ready(): Promise<LocalForage> {\n    return this.storagePromise;\n  }\n\n  /**\n   * Remove um valor associado a uma chave.\n   *\n   * @param {key} key Chave do valor que será removido.\n   * @returns {Promise<any>} Promessa que é resolvida após o valor ser removido.\n   */\n  remove(key: string): Promise<any> {\n    return this.storagePromise.then(store => store.removeItem(key));\n  }\n\n  /**\n   * Remove uma propriedade de um objeto armazenado.\n   *\n   * @param {string} key Chave do objeto armazenado.\n   * @param {string} property Propriedade que será removida.\n   *\n   * @returns {Promise<any>} Promessa que é resolvida após a propriedade ser removida.\n   */\n  async removeIndexFromObject(key: string, property: string): Promise<any> {\n    const data = await this.getObjectOfStorage(key);\n\n    delete data[property];\n    return this.set(key, data);\n  }\n\n  /**\n   * Remove um objeto de uma lista armazenada pelo valor de uma propriedade.\n   *\n   * Por exemplo:\n   *\n   * ``` typescript\n   * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];\n   *\n   * this.poStorageService.set('clientKey', clients).then(() => {});\n   *\n   * ...\n   *\n   * this.poStorageService.removeItemFromArray('clientKey', 'name', 'Marie').then(() => {\n   *   // O objeto { name: 'Marie', age: 23 } foi removido da lista que está na chave 'clientKey'\n   * });\n   * ```\n   *\n   * @param {string} key Chave da lista que contém o item que será removido.\n   * @param {string} field O campo a ser filtrado no item.\n   * @param {string} value O valor do filtro.\n   * @returns {Promise<any>} Promessa que é resolvida quando o objeto for removido da lista.\n   */\n  async removeItemFromArray(key: string, field: string, value: any): Promise<any> {\n    let data = await this.getArrayOfStorage(key);\n\n    data = data.filter(item => item[field] !== value);\n    return this.set(key, data);\n  }\n\n  /**\n   * <a id=\"request-idle-promise\"></a>\n   * Método que verifica se o acesso a base de dados configurada está liberado.\n   *\n   * Utilizado em conjunto com os métodos `lock()` e `unlock()` entre tarefas que não podem ser executadas de forma\n   * paralela, para não causar inconsistências nos dados.\n   *\n   * Exemplo de utilização:\n   *\n   * ```\n   * // Aguarda a liberação para continuar\n   * await this.poStorage.requestIdlePromise();\n   *\n   * this.poStorage.lock();\n   *\n   * // Executa uma tarefa que irá ler e/ou escrever na base de dados configurada.\n   *\n   * this.poStorage.unlock();\n   * ```\n   *\n   * > É importante sempre utilizá-lo antes de executar os métodos `lock()` e `unlock()` para garantir que a tarefa só\n   * será executada caso o acesso esteja livre.\n   *\n   * @returns {Promise<any>} Promessa que é resolvida quando o acesso a base de dados configurada estiver liberado.\n   */\n  requestIdlePromise(): Promise<any> {\n    return this.idleQueue.requestIdlePromise();\n  }\n\n  /**\n   * Grava um valor em uma determinada chave.\n   *\n   * @param {string} key Chave para o valor que será gravado.\n   * @param {any} value Valor que será gravado.\n   * @param {boolean} lock Define se irá travar a leitura e a escrita da base de dados para não ser acessada de forma paralela.\n   * Caso outra leitura/escrita já tenha sido iniciada, este método irá esperar o outro terminar para então começar.\n   *\n   * Padrão: `false`.\n   *\n   * > Esta definição só será válida se o outro acesso paralelo a este método também estiver com o parâmetro *lock* ativado.\n   * @returns {Promise<any>} Promessa que é resolvida após o valor ter sido gravado.\n   */\n  async set(key: string, value: any, lock: boolean = false): Promise<any> {\n    const store = await this.storagePromise;\n    const newValue = typeof value === 'object' ? JSON.parse(JSON.stringify(value)) : value;\n\n    if (lock) {\n      await this.requestIdlePromise();\n      return this.idleQueue.wrapCall(() => store.setItem(key, newValue));\n    }\n\n    return store.setItem(key, newValue);\n  }\n\n  /**\n   * Atribui um valor a uma propriedade de um objeto armazenado pela chave.\n   *\n   * Por exemplo:\n   *\n   * ``` typescript\n   * const clients = [ { name: 'Marie', age: 23 }, { name: 'Pether', age: 39 }];\n   *\n   * this.poStorageService.set('clientKey', clients).then(() => {});\n   *\n   * ...\n   *\n   * this.poStorageService.setIndexToObject('clientKey', 'name', 'Clare').then(() => {\n   *   // O objeto { name: 'Marie', age: 23 } passa a ser { name: 'Clare', age: 23 }\n   * });\n   * ```\n   *\n   * @param {string} key Chave do objeto.\n   * @param {string} property Nome da propriedade do objeto.\n   * @param {any} value Valor que será gravado na propriedade do objeto.\n   */\n  async setIndexToObject(key: string, property: string, value: any): Promise<any> {\n    const data = await this.getObjectOfStorage(key);\n\n    data[property] = value;\n    return this.set(key, data);\n  }\n\n  /**\n   * Decrementa um valor na fila de bloqueio. Utilizado juntamente com o método `lock` para poder\n   * controlar a execução de uma determinada tarefa com o `PoStorage.requestIdlePromise()`.\n   *\n   * Veja mais no método: [`PoStorage.requestIdlePromise()`](documentation/po-storage#request-idle-promise).\n   */\n  unlock() {\n    this.idleQueue.unlock();\n  }\n\n  private async getArrayOfStorage(key: string) {\n    const data = await this.get(key);\n    return data || [];\n  }\n\n  private async getImmutableItem(key: string) {\n    const store = await this.storagePromise;\n    const items = await store.getItem(key);\n    return items ? JSON.parse(JSON.stringify(items)) : null;\n  }\n\n  private async defineLocalForageDriver(localForageInstance: any, driverOrder) {\n    await localForageInstance.defineDriver(this.lokijsDriver.getDriver());\n    await this.setDriver(localForageInstance, driverOrder);\n    return localForageInstance;\n  }\n\n  private getDriverOrder(driverOrder: Array<string>): Array<string> {\n    return driverOrder.map(driver => {\n      switch (driver) {\n        case 'indexeddb':\n          return LocalForage.INDEXEDDB;\n        case 'websql':\n          return LocalForage.WEBSQL;\n        case 'localstorage':\n          return LocalForage.LOCALSTORAGE;\n        default:\n          return driver;\n      }\n    });\n  }\n\n  private async getObjectOfStorage(key: string) {\n    const data = await this.get(key);\n    return data || {};\n  }\n\n  private async setDriver(localForageInstance: LocalForage, driverOrder) {\n    await localForageInstance.setDriver(this.getDriverOrder(driverOrder));\n    this.driver = localForageInstance.driver();\n  }\n\n  private setStoragePromise(config: PoStorageConfig) {\n    this.storagePromise = this.getStorageInstance(config);\n  }\n\n  private async getStorageInstance(config: PoStorageConfig) {\n    const defaultConfig = PoStorageService.getDefaultConfig();\n    const actualConfig = Object.assign(defaultConfig, config || {});\n\n    const localForageInstance = LocalForage.createInstance(actualConfig);\n\n    try {\n      return await this.defineLocalForageDriver(localForageInstance, actualConfig.driverOrder);\n    } catch {\n      throw new Error(`Cannot use this drivers: ${actualConfig.driverOrder.join(', ')}.`);\n    }\n  }\n}\n"]}

package/esm2020/po-ui-ng-storage.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tdWktbmctc3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N0b3JhZ2Uvc3JjL3BvLXVpLW5nLXN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/{esm2015/public-api.js → esm2020/public-api.mjs}

@@ -1,2 +1,2 @@
-export * from './lib/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N0b3JhZ2Uvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XHJcbiJdfQ==
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N0b3JhZ2Uvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XG4iXX0=