@po-ui/ng-sync 15.15.0 → 16.0.0-next.2

package/esm2022/lib/services/po-http-client/po-http-client.service.mjs

@@ -0,0 +1,149 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { PoHttpRequestType } from './po-http-request-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço para execução de requisições HTTP.
+ */
+export class PoHttpClientService {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * Constrói uma requisição HTTP personalizada.
+     *
+     * @param {PoHttpRequestData} poHttpOperationData Parâmetros para a construção
+     * da requisição.
+     */
+    createRequest(poHttpOperationData) {
+        const httpHeaders = this.createHttpHeaders(poHttpOperationData.headers);
+        return this.httpClient.request(poHttpOperationData.method, poHttpOperationData.url, {
+            observe: 'response',
+            headers: httpHeaders,
+            body: poHttpOperationData.body
+        });
+    }
+    /**
+     * Constrói uma requisição com o método `delete`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    delete(url, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.DELETE,
+            headers: httpHeaders
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `get`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    get(url, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.GET,
+            headers: httpHeaders
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `head`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    head(url, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.HEAD,
+            headers: httpHeaders
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `options`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    options(url, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.OPTIONS,
+            headers: httpHeaders
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `patch`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    patch(url, body, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.PATCH,
+            headers: httpHeaders,
+            body: body
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `post`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    post(url, body, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.POST,
+            headers: httpHeaders,
+            body: body
+        };
+        return this.createRequest(requestData);
+    }
+    /**
+     * Constrói uma requisição com o método `put`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    put(url, body, httpHeaders) {
+        const requestData = {
+            url: url,
+            method: PoHttpRequestType.PUT,
+            headers: httpHeaders,
+            body: body
+        };
+        return this.createRequest(requestData);
+    }
+    createHttpHeaders(poHttpOperationHeaders) {
+        let httpHeaders = new HttpHeaders();
+        if (poHttpOperationHeaders && poHttpOperationHeaders.length > 0) {
+            poHttpOperationHeaders.forEach(poHttpHeader => (httpHeaders = httpHeaders.append(poHttpHeader.name, poHttpHeader.value)));
+        }
+        return httpHeaders;
+    }
+    static ɵfac = function PoHttpClientService_Factory(t) { return new (t || PoHttpClientService)(i0.ɵɵinject(i1.HttpClient)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoHttpClientService, factory: PoHttpClientService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoHttpClientService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-http-client.service.js","sourceRoot":"","sources":["../../../../../../projects/sync/src/lib/services/po-http-client/po-http-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders, HttpResponse } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\n\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { PoHttpHeaderOption } from './interfaces/po-http-header-option.interface';\r\nimport { PoHttpRequestData } from './interfaces/po-http-request-data.interface';\r\nimport { PoHttpRequestType } from './po-http-request-type.enum';\r\n\r\n/**\r\n * @docsPrivate\r\n *\r\n * @description\r\n *\r\n * Serviço para execução de requisições HTTP.\r\n */\r\n@Injectable()\r\nexport class PoHttpClientService {\r\n  constructor(private httpClient: HttpClient) {}\r\n\r\n  /**\r\n   * Constrói uma requisição HTTP personalizada.\r\n   *\r\n   * @param {PoHttpRequestData} poHttpOperationData Parâmetros para a construção\r\n   * da requisição.\r\n   */\r\n  createRequest(poHttpOperationData: PoHttpRequestData): Observable<HttpResponse<Object>> {\r\n    const httpHeaders = this.createHttpHeaders(poHttpOperationData.headers);\r\n\r\n    return this.httpClient.request(poHttpOperationData.method, poHttpOperationData.url, {\r\n      observe: 'response',\r\n      headers: httpHeaders,\r\n      body: poHttpOperationData.body\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `delete`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  delete(url: string, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.DELETE,\r\n      headers: httpHeaders\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `get`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  get(url: string, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.GET,\r\n      headers: httpHeaders\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `head`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  head(url: string, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.HEAD,\r\n      headers: httpHeaders\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `options`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  options(url: string, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.OPTIONS,\r\n      headers: httpHeaders\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `patch`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {any} body Corpo da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  patch(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.PATCH,\r\n      headers: httpHeaders,\r\n      body: body\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `post`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {any} body Corpo da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  post(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.POST,\r\n      headers: httpHeaders,\r\n      body: body\r\n    };\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  /**\r\n   * Constrói uma requisição com o método `put`.\r\n   *\r\n   * @param {string} url URL da requisição.\r\n   * @param {any} body Corpo da requisição.\r\n   * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.\r\n   */\r\n  put(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>) {\r\n    const requestData: PoHttpRequestData = {\r\n      url: url,\r\n      method: PoHttpRequestType.PUT,\r\n      headers: httpHeaders,\r\n      body: body\r\n    };\r\n\r\n    return this.createRequest(requestData);\r\n  }\r\n\r\n  private createHttpHeaders(poHttpOperationHeaders) {\r\n    let httpHeaders = new HttpHeaders();\r\n\r\n    if (poHttpOperationHeaders && poHttpOperationHeaders.length > 0) {\r\n      poHttpOperationHeaders.forEach(\r\n        poHttpHeader => (httpHeaders = httpHeaders.append(poHttpHeader.name, poHttpHeader.value))\r\n      );\r\n    }\r\n\r\n    return httpHeaders;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/services/po-http-client/po-http-request-type.enum.mjs

@@ -1,25 +1,25 @@
-/**
- * @usedBy PoHttpClientService, PoHttpCommandResponse, PoSyncService
- *
- * @description
- *
- * Define o método de requisição HTTP.
- */
-export var PoHttpRequestType;
-(function (PoHttpRequestType) {
-    /** Método `delete` do protocolo HTTP. */
-    PoHttpRequestType["DELETE"] = "DELETE";
-    /** Método `get` do protocolo HTTP. */
-    PoHttpRequestType["GET"] = "GET";
-    /** Método `head` do protocolo HTTP. */
-    PoHttpRequestType["HEAD"] = "HEAD";
-    /** Método `options` do protocolo HTTP. */
-    PoHttpRequestType["OPTIONS"] = "OPTIONS";
-    /** Método `patch` do protocolo HTTP. */
-    PoHttpRequestType["PATCH"] = "PATCH";
-    /** Método `post` do protocolo HTTP. */
-    PoHttpRequestType["POST"] = "POST";
-    /** Método `put` do protocolo HTTP. */
-    PoHttpRequestType["PUT"] = "PUT";
-})(PoHttpRequestType || (PoHttpRequestType = {}));
+/**
+ * @usedBy PoHttpClientService, PoHttpCommandResponse, PoSyncService
+ *
+ * @description
+ *
+ * Define o método de requisição HTTP.
+ */
+export var PoHttpRequestType;
+(function (PoHttpRequestType) {
+    /** Método `delete` do protocolo HTTP. */
+    PoHttpRequestType["DELETE"] = "DELETE";
+    /** Método `get` do protocolo HTTP. */
+    PoHttpRequestType["GET"] = "GET";
+    /** Método `head` do protocolo HTTP. */
+    PoHttpRequestType["HEAD"] = "HEAD";
+    /** Método `options` do protocolo HTTP. */
+    PoHttpRequestType["OPTIONS"] = "OPTIONS";
+    /** Método `patch` do protocolo HTTP. */
+    PoHttpRequestType["PATCH"] = "PATCH";
+    /** Método `post` do protocolo HTTP. */
+    PoHttpRequestType["POST"] = "POST";
+    /** Método `put` do protocolo HTTP. */
+    PoHttpRequestType["PUT"] = "PUT";
+})(PoHttpRequestType || (PoHttpRequestType = {}));
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8taHR0cC1yZXF1ZXN0LXR5cGUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL2xpYi9zZXJ2aWNlcy9wby1odHRwLWNsaWVudC9wby1odHRwLXJlcXVlc3QtdHlwZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBTixJQUFZLGlCQXFCWDtBQXJCRCxXQUFZLGlCQUFpQjtJQUMzQix5Q0FBeUM7SUFDekMsc0NBQWlCLENBQUE7SUFFakIsc0NBQXNDO0lBQ3RDLGdDQUFXLENBQUE7SUFFWCx1Q0FBdUM7SUFDdkMsa0NBQWEsQ0FBQTtJQUViLDBDQUEwQztJQUMxQyx3Q0FBbUIsQ0FBQTtJQUVuQix3Q0FBd0M7SUFDeEMsb0NBQWUsQ0FBQTtJQUVmLHVDQUF1QztJQUN2QyxrQ0FBYSxDQUFBO0lBRWIsc0NBQXNDO0lBQ3RDLGdDQUFXLENBQUE7QUFDYixDQUFDLEVBckJXLGlCQUFpQixLQUFqQixpQkFBaUIsUUFxQjVCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEB1c2VkQnkgUG9IdHRwQ2xpZW50U2VydmljZSwgUG9IdHRwQ29tbWFuZFJlc3BvbnNlLCBQb1N5bmNTZXJ2aWNlXHJcbiAqXHJcbiAqIEBkZXNjcmlwdGlvblxyXG4gKlxyXG4gKiBEZWZpbmUgbyBtw6l0b2RvIGRlIHJlcXVpc2nDp8OjbyBIVFRQLlxyXG4gKi9cclxuZXhwb3J0IGVudW0gUG9IdHRwUmVxdWVzdFR5cGUge1xyXG4gIC8qKiBNw6l0b2RvIGBkZWxldGVgIGRvIHByb3RvY29sbyBIVFRQLiAqL1xyXG4gIERFTEVURSA9ICdERUxFVEUnLFxyXG5cclxuICAvKiogTcOpdG9kbyBgZ2V0YCBkbyBwcm90b2NvbG8gSFRUUC4gKi9cclxuICBHRVQgPSAnR0VUJyxcclxuXHJcbiAgLyoqIE3DqXRvZG8gYGhlYWRgIGRvIHByb3RvY29sbyBIVFRQLiAqL1xyXG4gIEhFQUQgPSAnSEVBRCcsXHJcblxyXG4gIC8qKiBNw6l0b2RvIGBvcHRpb25zYCBkbyBwcm90b2NvbG8gSFRUUC4gKi9cclxuICBPUFRJT05TID0gJ09QVElPTlMnLFxyXG5cclxuICAvKiogTcOpdG9kbyBgcGF0Y2hgIGRvIHByb3RvY29sbyBIVFRQLiAqL1xyXG4gIFBBVENIID0gJ1BBVENIJyxcclxuXHJcbiAgLyoqIE3DqXRvZG8gYHBvc3RgIGRvIHByb3RvY29sbyBIVFRQLiAqL1xyXG4gIFBPU1QgPSAnUE9TVCcsXHJcblxyXG4gIC8qKiBNw6l0b2RvIGBwdXRgIGRvIHByb3RvY29sbyBIVFRQLiAqL1xyXG4gIFBVVCA9ICdQVVQnXHJcbn1cclxuIl19

package/esm2022/lib/services/po-network/po-network.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Network } from '@capacitor/network';
+import { PoNetworkStatus } from './../../models';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ *
+ * O `PoNetworkService` é utilizado para verificar o status e o tipo da conexão de rede do dispositivo.
+ */
+export class PoNetworkService {
+    networkType;
+    networkTypeNow;
+    poNetworkStatus;
+    constructor() {
+        this.initNetwork();
+    }
+    /**
+     * Retorna as propriedades tipo e status da conexão do dispositivo no momento da chamada.
+     *
+     * @returns {PoNetworkStatus} Instância de [PoNetworkStatus](/documentation/po-network-status) com as
+     * propriedades da conexão.
+     */
+    getConnectionStatus() {
+        this.poNetworkStatus = new PoNetworkStatus(this.networkType);
+        return this.poNetworkStatus;
+    }
+    /**
+     * Notifica as mudanças no tipo de conexão de rede do dispositivo.
+     *
+     * @returns {Observable<{ status: boolean, type: string }>} Observable com as propriedades da conexão.
+     */
+    onChange() {
+        return this.networkTypeNow.asObservable();
+    }
+    initNetwork() {
+        this.networkTypeNow = new Subject();
+        this.initSubscriber();
+    }
+    async getStatus() {
+        return await Network.getStatus();
+    }
+    async initSubscriber() {
+        const networkStatus = await this.getStatus();
+        this.networkType = networkStatus.connected ? networkStatus.connectionType : 'none';
+        this.networkTypeNow.next({ status: networkStatus.connected, type: this.networkType });
+        /* istanbul ignore next */
+        Network.addListener('networkStatusChange', status => {
+            this.networkType = status.connected ? status.connectionType : 'none';
+            this.networkTypeNow.next({ status: status.connected, type: this.networkType });
+        });
+    }
+    static ɵfac = function PoNetworkService_Factory(t) { return new (t || PoNetworkService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoNetworkService, factory: PoNetworkService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoNetworkService, [{
+        type: Injectable
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/services/po-schema/index.mjs

@@ -1,4 +1,4 @@
-export * from './po-schema-definition/po-schema-definition.service';
-export * from './po-schema.service';
-export * from './po-schema-util/po-schema-util.model';
+export * from './po-schema-definition/po-schema-definition.service';
+export * from './po-schema.service';
+export * from './po-schema-util/po-schema-util.model';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zeW5jL3NyYy9saWIvc2VydmljZXMvcG8tc2NoZW1hL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscURBQXFELENBQUM7QUFDcEUsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wby1zY2hlbWEtZGVmaW5pdGlvbi9wby1zY2hlbWEtZGVmaW5pdGlvbi5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9wby1zY2hlbWEuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcG8tc2NoZW1hLXV0aWwvcG8tc2NoZW1hLXV0aWwubW9kZWwnO1xyXG4iXX0=

package/esm2022/lib/services/po-schema/po-schema-definition/po-schema-definition.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { PoSchemaUtil } from './../po-schema-util/po-schema-util.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@po-ui/ng-storage";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que disponibiliza métodos que permite operar sobre as definições dos *schemas*.
+ */
+export class PoSchemaDefinitionService {
+    poStorage;
+    constructor(poStorage) {
+        this.poStorage = poStorage;
+    }
+    /**
+     * Destrói a chave do *storage* que contém as definições dos *schemas*.
+     *
+     * > Para que não venham ocorrer erros em ações que dependam das definições dos *schemas*,
+     * recomenda-se utilizar o método `prepare()` em seguida.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando a chave referente as definições dos *schemas* for destruída.
+     */
+    destroy() {
+        return this.poStorage.remove(PoSchemaUtil.syncSchemasName);
+    }
+    /**
+     * Busca um *schema* a partir do nome informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @returns {Promise<PoSyncSchema>} Promessa que é resolvida quando o *schema* for retornado.
+     */
+    get(schemaName) {
+        return this.poStorage.getItemByField(PoSchemaUtil.syncSchemasName, 'name', schemaName);
+    }
+    /**
+     * Retorna uma promessa com a lista dos *schemas* definidos.
+     *
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista dos *schemas* definidos for retornada.
+     */
+    getAll() {
+        return this.poStorage.get(PoSchemaUtil.syncSchemasName);
+    }
+    /**
+     * Salva uma lista de *schemas*.
+     *
+     * @param {Array<PoSyncSchema>} schemas Lista de schemas que serão salvos.
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista de *schemas* for salva.
+     */
+    saveAll(schemas) {
+        return this.poStorage.set(PoSchemaUtil.syncSchemasName, schemas);
+    }
+    /**
+     * Atualiza um *schema* a partir do *schema name*.
+     *
+     * @param {PoSyncSchema} updatedSchema **Schema* que será atualizado.
+     */
+    async update(updatedSchema) {
+        let schemas = await this.getAll();
+        const replaceUpdatedSchema = schema => {
+            if (schema.name === updatedSchema.name) {
+                return updatedSchema;
+            }
+            else {
+                return schema;
+            }
+        };
+        schemas = schemas.map(replaceUpdatedSchema);
+        return this.saveAll(schemas);
+    }
+    static ɵfac = function PoSchemaDefinitionService_Factory(t) { return new (t || PoSchemaDefinitionService)(i0.ɵɵinject(i1.PoStorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoSchemaDefinitionService, factory: PoSchemaDefinitionService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoSchemaDefinitionService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/po-schema/po-schema-util/po-schema-util.model.mjs

@@ -0,0 +1,124 @@
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço utilitário para operações no PoSyncSchema.
+ */
+export class PoSchemaUtil {
+    /** Valor `default` para o campo `lastSync`. */
+    static defaultLastSync = new Date(-8640000000000000).toISOString();
+    /** Nome da chave do identificador interno do sync. */
+    static syncInternalIdFieldName = 'SyncInternalId';
+    /** Nome da chave no `storage` para os Schemas. */
+    static syncSchemasName = 'SyncSchemas';
+    /**
+     * Verica se existem campos locais no *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     *
+     * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.
+     */
+    static containsLocalFields(schema) {
+        if (schema.fields) {
+            return !!schema.fields.find(field => typeof field === 'object' && field.local);
+        }
+    }
+    /**
+     * Retorna o valor atual do `lastSync` para determinado *schema*.
+     *
+     * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.
+     * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.
+     *
+     * @returns {string} Retorna uma *string* com o valor da última sincronização.
+     */
+    static getLastSync(storageSchemas, schemaName) {
+        if (storageSchemas) {
+            const schemaFound = storageSchemas.find(schema => schema.name === schemaName);
+            return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;
+        }
+        return PoSchemaUtil.defaultLastSync;
+    }
+    /**
+     * Retorna a lista de campos locais definidos no *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getLocalFieldNames(schema) {
+        if (schema.fields) {
+            return schema.fields.reduce((fieldsAccumulator, currentField) => {
+                if (typeof currentField === 'object' && currentField.local) {
+                    fieldsAccumulator.push(currentField.name);
+                }
+                return fieldsAccumulator;
+            }, []);
+        }
+    }
+    /**
+     * Retorna a lista de campos não locais definidos no *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getNonLocalFieldNames(schema) {
+        if (schema.fields) {
+            return schema.fields.reduce((fieldsAccumulator, currentField) => {
+                if (typeof currentField === 'string' || !currentField.local) {
+                    fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);
+                }
+                return fieldsAccumulator;
+            }, []);
+        }
+    }
+    /**
+     * Retorna o `id` referente ao registro do *schema* informado.
+     *
+     * @param {object} record Registro que será buscado o id.
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     */
+    static getRecordId(record, schema) {
+        return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];
+    }
+    /**
+     * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.
+     *
+     * @param {PoSyncSchema} schema **Schema* a ser processado.
+     * @param {PoRequestType} requestType Tipo da requisição.
+     */
+    static getUrl(schema, requestType) {
+        return schema[`${requestType}UrlApi`];
+    }
+    /**
+     * Compara se dois objetos são iguais baseado na lista de campos.
+     *
+     * @param {Array<string>} fields Lista de campos a serem considerados na comparação.
+     * @param {any} model1 Objeto 1 a ser comparado.
+     * @param {any} model2 Objeto 2 a ser comparado.
+     */
+    static isModelsEqual(fields, model1, model2) {
+        if (fields) {
+            return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));
+        }
+    }
+    /**
+     * Retorna uma lista com dois objetos referentes ao registro informado.
+     * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.
+     *
+     * @param {PoSyncSchema} schema **Schema* do registro.
+     * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.
+     */
+    static separateSchemaFields(schema, record) {
+        const localFields = PoSchemaUtil.getLocalFieldNames(schema);
+        const localRecord = {};
+        const serverRecord = {};
+        Object.keys(record).forEach(field => {
+            if (localFields.includes(field)) {
+                localRecord[field] = record[field];
+            }
+            else {
+                serverRecord[field] = record[field];
+            }
+        });
+        return { serverRecord, localRecord };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-schema-util.model.js","sourceRoot":"","sources":["../../../../../../../projects/sync/src/lib/services/po-schema/po-schema-util/po-schema-util.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { PoRequestType } from '../../../models/po-request-type.enum';\r\nimport { PoSyncFieldOptions } from '../../po-sync/interfaces/po-sync-field-options.interface';\r\nimport { PoSyncSchema } from '../../po-sync/interfaces/po-sync-schema.interface';\r\n\r\n/**\r\n * @docsPrivate\r\n *\r\n * @description\r\n *\r\n * Serviço utilitário para operações no PoSyncSchema.\r\n */\r\nexport class PoSchemaUtil {\r\n  /** Valor `default` para o campo `lastSync`. */\r\n  public static readonly defaultLastSync: string = new Date(-8640000000000000).toISOString();\r\n\r\n  /** Nome da chave do identificador interno do sync. */\r\n  public static readonly syncInternalIdFieldName: string = 'SyncInternalId';\r\n\r\n  /** Nome da chave no `storage` para os Schemas. */\r\n  public static readonly syncSchemasName: string = 'SyncSchemas';\r\n\r\n  /**\r\n   * Verica se existem campos locais no *schema* informado.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   *\r\n   * @returns {boolean} Valor do tipo *boolean* que indica se existem campos locais no *schema* informado.\r\n   */\r\n  public static containsLocalFields(schema: PoSyncSchema): boolean {\r\n    if (schema.fields) {\r\n      return !!schema.fields.find(field => typeof field === 'object' && field.local);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna o valor atual do `lastSync` para determinado *schema*.\r\n   *\r\n   * @param {Array<PoSyncSchema>} storageSchemas Lista de *schemas* a serem pesquisados.\r\n   * @param {string} schemaName Nome do *schema* que se deseja ler o lastSync.\r\n   *\r\n   * @returns {string} Retorna uma *string* com o valor da última sincronização.\r\n   */\r\n  public static getLastSync(storageSchemas: Array<PoSyncSchema>, schemaName: string): string {\r\n    if (storageSchemas) {\r\n      const schemaFound = storageSchemas.find(schema => schema.name === schemaName);\r\n      return schemaFound && schemaFound.lastSync ? schemaFound.lastSync : PoSchemaUtil.defaultLastSync;\r\n    }\r\n    return PoSchemaUtil.defaultLastSync;\r\n  }\r\n\r\n  /**\r\n   * Retorna a lista de campos locais definidos no *schema*.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getLocalFieldNames(schema: PoSyncSchema): Array<string> {\r\n    if (schema.fields) {\r\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\r\n        if (typeof currentField === 'object' && currentField.local) {\r\n          fieldsAccumulator.push(currentField.name);\r\n        }\r\n        return fieldsAccumulator;\r\n      }, []);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna a lista de campos não locais definidos no *schema*.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getNonLocalFieldNames(schema: PoSyncSchema): Array<string> {\r\n    if (schema.fields) {\r\n      return schema.fields.reduce((fieldsAccumulator: Array<string>, currentField: string | PoSyncFieldOptions) => {\r\n        if (typeof currentField === 'string' || !currentField.local) {\r\n          fieldsAccumulator.push(typeof currentField === 'string' ? currentField : currentField.name);\r\n        }\r\n        return fieldsAccumulator;\r\n      }, []);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna o `id` referente ao registro do *schema* informado.\r\n   *\r\n   * @param {object} record Registro que será buscado o id.\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   */\r\n  public static getRecordId(record: object, schema: PoSyncSchema) {\r\n    return record[schema.idField] || record[PoSchemaUtil.syncInternalIdFieldName];\r\n  }\r\n\r\n  /**\r\n   * Retorna a url correspondente do `PoSyncSchema` dependendo do tipo da requisição `PoRequestType`.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* a ser processado.\r\n   * @param {PoRequestType} requestType Tipo da requisição.\r\n   */\r\n  public static getUrl(schema: PoSyncSchema, requestType: PoRequestType): string {\r\n    return schema[`${requestType}UrlApi`];\r\n  }\r\n\r\n  /**\r\n   * Compara se dois objetos são iguais baseado na lista de campos.\r\n   *\r\n   * @param {Array<string>} fields Lista de campos a serem considerados na comparação.\r\n   * @param {any} model1 Objeto 1 a ser comparado.\r\n   * @param {any} model2 Objeto 2 a ser comparado.\r\n   */\r\n  public static isModelsEqual(fields: Array<string>, model1: any, model2: any): boolean {\r\n    if (fields) {\r\n      return fields.every(field => JSON.stringify(model1[field]) === JSON.stringify(model2[field]));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna uma lista com dois objetos referentes ao registro informado.\r\n   * O primeiro é o registro com os campos que vão para o servidor e o segundo é com os campos locais.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* do registro.\r\n   * @param {object} record Registro que será realizada a separação dos campos locais e do servidor.\r\n   */\r\n  public static separateSchemaFields(\r\n    schema: PoSyncSchema,\r\n    record: object\r\n  ): { serverRecord: object; localRecord: object } {\r\n    const localFields = PoSchemaUtil.getLocalFieldNames(schema);\r\n    const localRecord = {};\r\n    const serverRecord = {};\r\n\r\n    Object.keys(record).forEach(field => {\r\n      if (localFields.includes(field)) {\r\n        localRecord[field] = record[field];\r\n      } else {\r\n        serverRecord[field] = record[field];\r\n      }\r\n    });\r\n\r\n    return { serverRecord, localRecord };\r\n  }\r\n}\r\n"]}