@sankhyalabs/core 1.0.42 → 1.0.43

package/src/utils/TimeFormatter.ts

@@ -1,98 +1,98 @@
-import { MaskFormatter } from "./MaskFormatter.js";
-
-/**
- * `TimeFormatter` é um utilitário para formatação de strings desformatadas em strings válidas de horários
- */
-export class TimeFormatter {
-
-    static _maskFormatter: MaskFormatter = new MaskFormatter("##:##");
-
-    /**
-    * @prepareValue: converts an unformated time string into a formatted time.
-    *
-    * @param value unformated time string to convert
-    * 
-    * @returns formatted time string
-    * 
-    * @Exemples
-    * @"1012"       |       "10:12"
-    * @"10:12"      |       "10:12:00"
-    * @"100112"     |       "10:01:12"
-    */
-    static prepareValue(value: string, showSeconds: boolean): string {
-        if (value && value.length > 0 && value != "NaN") {
-            let validationValue = value.replace(/:/g, "");
-            if (showSeconds) {
-                this._maskFormatter.mask = "##:##:##"
-                if (validationValue.length < 6) {
-                    while (validationValue.length < 6) {
-                        validationValue = "0".concat(validationValue);
-                    }
-                }
-            } else {
-                this._maskFormatter.mask = "##:##";
-                if (validationValue.length < 4) {
-                    while (validationValue.length < 4) {
-                        validationValue = "0".concat(validationValue);
-                    }
-                }
-            }
-            if (this._maskFormatter) {
-                try {
-                    value = this._maskFormatter.format(validationValue);
-                    return value;
-                } catch (e:any) {
-                    throw new Error(e.message);
-                }
-            }
-        }
-        return '';
-    }
-
-    /**
-    * @validateTime: validates if an input string has the corect time format.
-    *
-    * @param value input string to validate
-    * 
-    * @returns true or false
-    * 
-    * @Exemples
-    * @"1012"       |       true
-    * @"14e4"       |       false
-    * @"2624"       |       false
-    */
-    static validateTime(value: string, showSeconds: boolean) {
-        let isValid: boolean = true;
-        if (value) {
-            let validationValue = value.replace(/:/g, "");
-            if (showSeconds) {
-                if (!["1", "2", "0"].includes(validationValue[0])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[4])) {
-                    isValid = false;
-                }
-                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
-                    isValid = false;
-                }
-            } else {
-                if (!["1", "2", "0"].includes(validationValue[0])) {
-                    isValid = false;
-                }
-                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
-                    isValid = false;
-                }
-                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
-                    isValid = false;
-                }
-            }
-        }else{
-            isValid = false;
-        }
-        return isValid;
-    }
-
+import { MaskFormatter } from "./MaskFormatter.js";
+
+/**
+ * `TimeFormatter` é um utilitário para formatação de strings desformatadas em strings válidas de horários
+ */
+export class TimeFormatter {
+
+    static _maskFormatter: MaskFormatter = new MaskFormatter("##:##");
+
+    /**
+    * @prepareValue: converts an unformated time string into a formatted time.
+    *
+    * @param value unformated time string to convert
+    * 
+    * @returns formatted time string
+    * 
+    * @Exemples
+    * @"1012"       |       "10:12"
+    * @"10:12"      |       "10:12:00"
+    * @"100112"     |       "10:01:12"
+    */
+    static prepareValue(value: string, showSeconds: boolean): string {
+        if (value && value.length > 0 && value != "NaN") {
+            let validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                this._maskFormatter.mask = "##:##:##"
+                if (validationValue.length < 6) {
+                    while (validationValue.length < 6) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            } else {
+                this._maskFormatter.mask = "##:##";
+                if (validationValue.length < 4) {
+                    while (validationValue.length < 4) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            }
+            if (this._maskFormatter) {
+                try {
+                    value = this._maskFormatter.format(validationValue);
+                    return value;
+                } catch (e:any) {
+                    throw new Error(e.message);
+                }
+            }
+        }
+        return '';
+    }
+
+    /**
+    * @validateTime: validates if an input string has the corect time format.
+    *
+    * @param value input string to validate
+    * 
+    * @returns true or false
+    * 
+    * @Exemples
+    * @"1012"       |       true
+    * @"14e4"       |       false
+    * @"2624"       |       false
+    */
+    static validateTime(value: string, showSeconds: boolean) {
+        let isValid: boolean = true;
+        if (value) {
+            let validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[4])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            } else {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            }
+        }else{
+            isValid = false;
+        }
+        return isValid;
+    }
+
 }

package/test/http/HttpProvider.spec.ts

@@ -1,35 +1,35 @@
-/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
--> Promisse<JSON> get(url);
--> Promisse<JSON> post(url, JSON);
--> Promisse<JSON> put(url, JSON);
--> Promisse<JSON> delete(url);
-Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
-através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
-irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
-A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
-HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
-
-// import { HttpProvider } from '../../src/http/HttpProvider';
-// import '../../mock/http/XMLHttpRequest-mock.js'
-
-describe('HttpProvider', () => {
-
-  it('Metodo GET', (async () => {
-
-    // const compareTo = {
-    //   "data": { "A": "B" },
-    //   "dataAsString": "{\"A\":\"B\"}",
-    //   "status": 200,
-    //   "statusText": "OK"
-    // };
-
-    // HttpProvider.get('get')
-    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
-    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
-
-    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
-
-    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
-
-  }));
+/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
+-> Promisse<JSON> get(url);
+-> Promisse<JSON> post(url, JSON);
+-> Promisse<JSON> put(url, JSON);
+-> Promisse<JSON> delete(url);
+Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
+através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
+irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
+A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
+HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
+
+// import { HttpProvider } from '../../src/http/HttpProvider';
+// import '../../mock/http/XMLHttpRequest-mock.js'
+
+describe('HttpProvider', () => {
+
+  it('Metodo GET', (async () => {
+
+    // const compareTo = {
+    //   "data": { "A": "B" },
+    //   "dataAsString": "{\"A\":\"B\"}",
+    //   "status": 200,
+    //   "statusText": "OK"
+    // };
+
+    // HttpProvider.get('get')
+    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
+    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
+
+    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
+
+    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
+
+  }));
 });

package/test/http/SkwHttpProvider.ts.spec.ts

@@ -1,34 +1,34 @@
-/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
--> Promisse<JSON> get(url);
--> Promisse<JSON> post(url, JSON);
--> Promisse<JSON> put(url, JSON);
--> Promisse<JSON> delete(url);
-Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
-através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
-irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
-A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
-HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
-
-// import { HttpProvider } from '../../src/http/HttpProvider';
-
-describe('HttpProvider', () => {
-
-  it('Metodo POST', (async () => {
-
-    // const compareTo = {
-    //   "data": { "A": "B" },
-    //   "dataAsString": "{\"A\":\"B\"}",
-    //   "status": 200,
-    //   "statusText": "OK"
-    // };
-
-    // HttpProvider.get('get')
-    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
-    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
-
-    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
-
-    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
-
-  }));
+/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
+-> Promisse<JSON> get(url);
+-> Promisse<JSON> post(url, JSON);
+-> Promisse<JSON> put(url, JSON);
+-> Promisse<JSON> delete(url);
+Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
+através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
+irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
+A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
+HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
+
+// import { HttpProvider } from '../../src/http/HttpProvider';
+
+describe('HttpProvider', () => {
+
+  it('Metodo POST', (async () => {
+
+    // const compareTo = {
+    //   "data": { "A": "B" },
+    //   "dataAsString": "{\"A\":\"B\"}",
+    //   "status": 200,
+    //   "statusText": "OK"
+    // };
+
+    // HttpProvider.get('get')
+    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
+    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
+
+    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
+
+    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
+
+  }));
 });