@arkyn/shared 1.4.57 → 1.5.1

package/src/formats/__test__/formatDate.spec.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { formatDate } from "../formatDate";
+
+describe("formatDate", () => {
+  it("should format a Brazilian date to ISO format", () => {
+    const result = formatDate(
+      "25/12/2023",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2023-12-25");
+  });
+
+  it("should format an ISO date to Brazilian format", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "00:00:00",
+      "isoDate",
+      "DD/MM/YYYY"
+    );
+    expect(result).toBe("25/12/2023");
+  });
+
+  it("should format a date with time components", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "14:30:00",
+      "isoDate",
+      "YYYY-MM-DD hh:mm:ss"
+    );
+    expect(result).toBe("2023-12-25 14:30:00");
+  });
+
+  it("should apply timezone adjustment when formatting", () => {
+    const result = formatDate(
+      "2023-12-25",
+      "14:30:00",
+      "isoDate",
+      "YYYY-MM-DD hh:mm:ss",
+      -3
+    );
+    expect(result).toBe("2023-12-25 11:30:00");
+  });
+
+  it("should handle single-digit days and months in Brazilian format", () => {
+    const result = formatDate(
+      "5/1/2023",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2023-01-05");
+  });
+
+  it("should handle single-digit days and months in ISO format", () => {
+    const result = formatDate("2023-1-5", "00:00:00", "isoDate", "DD/MM/YYYY");
+    expect(result).toBe("05/01/2023");
+  });
+
+  it("should handle leap years correctly", () => {
+    const result = formatDate(
+      "29/02/2024",
+      "00:00:00",
+      "brazilianDate",
+      "YYYY-MM-DD"
+    );
+    expect(result).toBe("2024-02-29");
+  });
+
+  it("should throw an error for invalid input format", () => {
+    expect(() =>
+      formatDate("25/12/2023", "00:00:00", "invalidFormat" as any, "YYYY-MM-DD")
+    ).toThrow("Invalid input format");
+  });
+
+  it("should throw an error for invalid date string", () => {
+    expect(() =>
+      formatDate("invalid-date", "00:00:00", "brazilianDate", "YYYY-MM-DD")
+    ).toThrow("Invalid date");
+  });
+
+  it("should throw an error for invalid time string", () => {
+    expect(() =>
+      formatDate("25/12/2023", "invalid-time", "brazilianDate", "YYYY-MM-DD")
+    ).toThrow("Invalid date");
+  });
+});

package/src/formats/__test__/formatJsonObject.spec.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { formatJsonObject } from "../formatJsonObject";
+
+describe("formatJsonObject", () => {
+  it("should format a simple JSON object", () => {
+    const obj = { name: "John", age: 30 };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "age": 30
+}`);
+  });
+
+  it("should format a nested JSON object", () => {
+    const obj = { name: "John", details: { age: 30, city: "New York" } };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "details": {
+    "age": 30,
+    "city": "New York"
+  }
+}`);
+  });
+
+  it("should format a JSON array", () => {
+    const obj = ["apple", "banana", "cherry"];
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`[
+  "apple",
+  "banana",
+  "cherry"
+]`);
+  });
+
+  it("should format a nested JSON array", () => {
+    const obj = { fruits: ["apple", "banana", "cherry"] };
+    const result = formatJsonObject(obj, 0);
+    expect(result).toBe(`{
+  "fruits": [
+    "apple",
+    "banana",
+    "cherry"
+  ]
+}`);
+  });
+
+  it("should format a primitive value", () => {
+    const result = formatJsonObject(42, 0);
+    expect(result).toBe("42");
+  });
+
+  it("should format a string value", () => {
+    const result = formatJsonObject("hello", 0);
+    expect(result).toBe('"hello"');
+  });
+
+  it("should format a JSON string", () => {
+    const jsonString = '{"name":"John","age":30}';
+    const result = formatJsonObject(jsonString, 0);
+    expect(result).toBe(`{
+  "name": "John",
+  "age": 30
+}`);
+  });
+
+  it("should handle invalid JSON strings as plain strings", () => {
+    const invalidJson = "{name:John}";
+    const result = formatJsonObject(invalidJson, 0);
+    expect(result).toBe('"{name:John}"');
+  });
+
+  it("should handle null values", () => {
+    const result = formatJsonObject(null, 0);
+    expect(result).toBe("null");
+  });
+
+  it("should handle empty objects", () => {
+    const result = formatJsonObject({}, 0);
+    expect(result).toBe(`{}`);
+  });
+
+  it("should handle empty arrays", () => {
+    const result = formatJsonObject([], 0);
+    expect(result).toBe(`[]`);
+  });
+});

package/src/formats/__test__/formatJsonString.spec.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from "vitest";
+import { formatJsonString } from "../formatJsonString";
+
+describe("formatJsonString", () => {
+  it("should format a valid JSON string", () => {
+    const jsonString =
+      '{"name":"John","age":30,"hobbies":["reading","gaming"]}';
+    const result = formatJsonString(jsonString);
+    expect(result).toBe(`{
+  "name": "John",
+  "age": 30,
+  "hobbies": [
+    "reading",
+    "gaming"
+  ]
+}`);
+  });
+
+  it("should handle a nested JSON string", () => {
+    const jsonString =
+      '{"user":{"name":"John","details":{"age":30,"city":"New York"}}}';
+    const result = formatJsonString(jsonString);
+    expect(result).toBe(`{
+  "user": {
+    "name": "John",
+    "details": {
+      "age": 30,
+      "city": "New York"
+    }
+  }
+}`);
+  });
+
+  it("should handle an empty JSON object", () => {
+    const jsonString = "{}";
+    const result = formatJsonString(jsonString);
+    expect(result).toBe(`{}`);
+  });
+
+  it("should handle an empty JSON array", () => {
+    const jsonString = "[]";
+    const result = formatJsonString(jsonString);
+    expect(result).toBe(`[]`);
+  });
+
+  it("should handle a JSON array", () => {
+    const jsonString = '["apple","banana","cherry"]';
+    const result = formatJsonString(jsonString);
+    expect(result).toBe(`[
+  "apple",
+  "banana",
+  "cherry"
+]`);
+  });
+
+  it("should return an empty string for invalid JSON", () => {
+    const invalidJsonString = '{"name":"John", "age":30,';
+    expect(() => formatJsonString(invalidJsonString)).toThrow();
+  });
+
+  it("should log an error for invalid JSON", () => {
+    const invalidJsonString = '{"name":"John", "age":30,';
+    expect(() => formatJsonString(invalidJsonString)).toThrow();
+  });
+
+  it("should handle a primitive JSON value", () => {
+    const jsonString = "42";
+    const result = formatJsonString(jsonString);
+    expect(result).toBe("42");
+  });
+
+  it("should handle a JSON string value", () => {
+    const jsonString = '"hello"';
+    const result = formatJsonString(jsonString);
+    expect(result).toBe('"hello"');
+  });
+
+  it("should handle null JSON value", () => {
+    const jsonString = "null";
+    const result = formatJsonString(jsonString);
+    expect(result).toBe("null");
+  });
+});

package/src/formats/__test__/formatToCep.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { formatToCep } from "../formatToCep";
+
+describe("formatToCep", () => {
+  it("should format a valid CEP with only numeric characters", () => {
+    const result = formatToCep("12345678");
+    expect(result).toBe("12345-678");
+  });
+
+  it("should format a valid CEP with non-numeric characters", () => {
+    const result = formatToCep("12345-678");
+    expect(result).toBe("12345-678");
+  });
+
+  it("should throw an error for invalid CEP length", () => {
+    expect(() => formatToCep("1234")).toThrow("Invalid CEP format");
+    expect(() => formatToCep("123456789")).toThrow("Invalid CEP format");
+  });
+
+  it("should handle empty input and throw an error", () => {
+    expect(() => formatToCep("")).toThrow("Invalid CEP format");
+  });
+
+  it("should ignore non-numeric characters and format correctly", () => {
+    const result = formatToCep("12345-678abc");
+    expect(result).toBe("12345-678");
+  });
+
+  it("should format a CEP with extra spaces", () => {
+    const result = formatToCep("  12345678  ");
+    expect(result).toBe("12345-678");
+  });
+
+  it("should throw an error for completely invalid input", () => {
+    expect(() => formatToCep("abcdefg")).toThrow("Invalid CEP format");
+  });
+});

package/src/formats/__test__/formatToCnpj.spec.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { formatToCnpj } from "../formatToCnpj";
+
+describe("formatToCnpj", () => {
+  it("should format a valid CNPJ with only numeric characters", () => {
+    const result = formatToCnpj("12345678000195");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+
+  it("should format a valid CNPJ with non-numeric characters", () => {
+    const result = formatToCnpj("12.345.678/0001-95");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+
+  it("should throw an error for invalid CNPJ length", () => {
+    expect(() => formatToCnpj("123")).toThrow("Invalid CNPJ length");
+    expect(() => formatToCnpj("123456789012345")).toThrow(
+      "Invalid CNPJ length"
+    );
+  });
+
+  it("should handle empty input and throw an error", () => {
+    expect(() => formatToCnpj("")).toThrow("Invalid CNPJ length");
+  });
+
+  it("should ignore non-numeric characters and format correctly", () => {
+    const result = formatToCnpj("12.345.678/0001-95abc");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+
+  it("should format a CNPJ with extra spaces", () => {
+    const result = formatToCnpj("  12345678000195  ");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+});

package/src/formats/__test__/formatToCpf.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { formatToCpf } from "../formatToCpf";
+
+describe("formatToCpf", () => {
+  it("should format a valid CPF with only numeric characters", () => {
+    const result = formatToCpf("12345678909");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should format a valid CPF with non-numeric characters", () => {
+    const result = formatToCpf("123.456.789-09");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should throw an error for invalid CPF length", () => {
+    expect(() => formatToCpf("12345")).toThrow("Invalid CPF format");
+    expect(() => formatToCpf("123456789012")).toThrow("Invalid CPF format");
+  });
+
+  it("should handle empty input and throw an error", () => {
+    expect(() => formatToCpf("")).toThrow("Invalid CPF format");
+  });
+
+  it("should ignore non-numeric characters and format correctly", () => {
+    const result = formatToCpf("123.456.789-09abc");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should format a CPF with extra spaces", () => {
+    const result = formatToCpf("  12345678909  ");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should throw an error for completely invalid input", () => {
+    expect(() => formatToCpf("abcdefg")).toThrow("Invalid CPF format");
+  });
+});

package/src/formats/__test__/formatToCpfCnpj.spec.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { formatToCpfCnpj } from "../formatToCpfCnpj";
+
+describe("formatToCpfCnpj", () => {
+  it("should format a valid CPF with non-numeric characters", () => {
+    const result = formatToCpfCnpj("123.456.789-09");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should format a valid CPF with only numeric characters", () => {
+    const result = formatToCpfCnpj("12345678909");
+    expect(result).toBe("123.456.789-09");
+  });
+
+  it("should format a valid CNPJ with non-numeric characters", () => {
+    const result = formatToCpfCnpj("12.345.678/0001-95");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+
+  it("should format a valid CNPJ with only numeric characters", () => {
+    const result = formatToCpfCnpj("12345678000195");
+    expect(result).toBe("12.345.678/0001-95");
+  });
+
+  it("should throw an error for invalid CPF or CNPJ length", () => {
+    expect(() => formatToCpfCnpj("123")).toThrow("Invalid CPF or CNPJ length");
+    expect(() => formatToCpfCnpj("123456")).toThrow(
+      "Invalid CPF or CNPJ length"
+    );
+    expect(() => formatToCpfCnpj("123456789012345")).toThrow(
+      "Invalid CPF or CNPJ length"
+    );
+  });
+
+  it("should handle empty input and throw an error", () => {
+    expect(() => formatToCpfCnpj("")).toThrow("Invalid CPF or CNPJ length");
+  });
+
+  it("should ignore non-numeric characters and format correctly", () => {
+    const result = formatToCpfCnpj("123.456.789-09abc");
+    expect(result).toBe("123.456.789-09");
+  });
+});

package/src/formats/__test__/formatToCurrency.spec.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { formatToCurrency } from "../formatToCurrency";
+
+describe("formatToCurrency", () => {
+  it("should format a number to USD currency with prefix", () => {
+    const result = formatToCurrency(1234.56, "USD", { showPrefix: true });
+    expect(result).toBe("$1,234.56");
+  });
+
+  it("should format a number to USD currency without prefix", () => {
+    const result = formatToCurrency(1234.56, "USD", { showPrefix: false });
+    expect(result).toBe("1,234.56");
+  });
+
+  it("should format a number to BRL currency with prefix", () => {
+    const result = formatToCurrency(1234.56, "BRL", { showPrefix: true });
+    expect(result).toBe("R$ 1.234,56");
+  });
+
+  it("should format a number to BRL currency without prefix", () => {
+    const result = formatToCurrency(1234.56, "BRL", { showPrefix: false });
+    expect(result).toBe("1.234,56");
+  });
+
+  it("should format a number to EUR currency with prefix", () => {
+    const result = formatToCurrency(1234.56, "EUR", { showPrefix: true });
+    expect(result).toEqual("1.234,56 €");
+  });
+
+  it("should format a number to EUR currency without prefix", () => {
+    const result = formatToCurrency(1234.56, "EUR", { showPrefix: false });
+    expect(result).toBe("1.234,56");
+  });
+
+  it("should handle zero value correctly", () => {
+    const result = formatToCurrency(0, "USD", { showPrefix: true });
+    expect(result).toBe("$0.00");
+  });
+
+  it("should handle negative values correctly", () => {
+    const result = formatToCurrency(-1234.56, "USD", { showPrefix: true });
+    expect(result).toBe("-$1,234.56");
+  });
+
+  it("should throw an error for unsupported currency codes", () => {
+    expect(() =>
+      formatToCurrency(1234.56, "XYZ" as any, { showPrefix: true })
+    ).toThrow("Unsupported currency code");
+  });
+});

package/src/formats/__test__/formatToEllipsis.spec.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { formatToEllipsis } from "../formatToEllipsis";
+
+describe("formatToEllipsis", () => {
+  it("should truncate text and append ellipsis if it exceeds the maxLength", () => {
+    const result = formatToEllipsis("Hello, world!", 5);
+    expect(result).toBe("Hello...");
+  });
+
+  it("should return the original text if it does not exceed the maxLength", () => {
+    const result = formatToEllipsis("Hello", 10);
+    expect(result).toBe("Hello");
+  });
+
+  it("should handle empty strings", () => {
+    const result = formatToEllipsis("", 5);
+    expect(result).toBe("");
+  });
+
+  it("should handle maxLength of 0", () => {
+    const result = formatToEllipsis("Hello, world!", 0);
+    expect(result).toBe("...");
+  });
+
+  it("should handle maxLength greater than the text length", () => {
+    const result = formatToEllipsis("Short text", 20);
+    expect(result).toBe("Short text");
+  });
+
+  it("should handle text exactly equal to maxLength", () => {
+    const result = formatToEllipsis("Exact", 5);
+    expect(result).toBe("Exact");
+  });
+
+  it("should handle special characters in the text", () => {
+    const result = formatToEllipsis("Olá, mundo!", 4);
+    expect(result).toBe("Olá...");
+  });
+
+  it("should handle whitespace correctly", () => {
+    const result = formatToEllipsis("Hello world", 6);
+    expect(result).toBe("Hello...");
+  });
+});

package/src/formats/__test__/formatToHiddenDigits.spec.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { formatToHiddenDigits } from "../formatToHiddenDigits";
+
+describe("formatToHiddenDigits", () => {
+  it("should hide the first 3 digits by default", () => {
+    const result = formatToHiddenDigits("123-456-7890", {});
+    expect(result).toBe("***-456-7890");
+  });
+
+  it("should hide the first n digits when range is a positive number", () => {
+    const result = formatToHiddenDigits("123-456-7890", { range: 5 });
+    expect(result).toBe("***-**6-7890");
+  });
+
+  it("should hide the last n digits when range is a negative number", () => {
+    const result = formatToHiddenDigits("123-456-7890", { range: -4 });
+    expect(result).toBe("123-456-****");
+  });
+
+  it("should hide digits within a specific range", () => {
+    const result = formatToHiddenDigits("123-456-7890", { range: [4, 6] });
+    expect(result).toBe("123-***-7890");
+  });
+
+  it("should use a custom hider character", () => {
+    const result = formatToHiddenDigits("123-456-7890", {
+      range: 3,
+      hider: "#",
+    });
+
+    expect(result).toBe("###-456-7890");
+  });
+
+  it("should handle strings with no digits", () => {
+    const result = formatToHiddenDigits("abc-def-ghij", { range: 3 });
+    expect(result).toBe("abc-def-ghij");
+  });
+
+  it("should handle empty strings", () => {
+    const result = formatToHiddenDigits("", { range: 3 });
+    expect(result).toBe("");
+  });
+
+  it("should handle ranges larger than the number of digits", () => {
+    const result = formatToHiddenDigits("123-456", { range: 10 });
+    expect(result).toBe("***-***");
+  });
+
+  it("should handle ranges that do not overlap with any digits", () => {
+    const result = formatToHiddenDigits("123-456-7890", { range: [11, 12] });
+    expect(result).toBe("123-456-7890");
+  });
+
+  it("should hide all digits when range covers all digits", () => {
+    const result = formatToHiddenDigits("123-456-7890", { range: [1, 10] });
+    expect(result).toBe("***-***-****");
+  });
+});

package/src/formats/__test__/formatToPhone.spec.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { formatToPhone } from "../formatToPhone";
+
+describe("formatToPhone", () => {
+  it("should format a Brazilian phone number with 9 digits", () => {
+    const result = formatToPhone("+55 11912345678");
+    expect(result).toBe("(11) 91234-5678");
+  });
+
+  it("should format a Brazilian phone number with 8 digits", () => {
+    const result = formatToPhone("+55 1123456789");
+    expect(result).toBe("(11) 2345-6789");
+  });
+
+  it("should format a US phone number with a prefix", () => {
+    const result = formatToPhone("+1-408 4567890");
+    expect(result).toBe("(408) 456-7890");
+  });
+
+  it("should format a US phone number without a prefix", () => {
+    expect(() => formatToPhone("+1 4567890")).toThrow("Invalid country code");
+  });
+
+  it("should throw an error for invalid phone number format", () => {
+    expect(() => formatToPhone("+55")).toThrow("Invalid phone number format");
+    expect(() => formatToPhone("+55-11")).toThrow(
+      "Invalid phone number format"
+    );
+  });
+
+  it("should throw an error for unrecognized country code", () => {
+    expect(() => formatToPhone("+99 123456789")).toThrow(
+      "Invalid country code"
+    );
+  });
+
+  it("should throw an error for unrecognized country code or prefix", () => {
+    expect(() => formatToPhone("+1-999 123456789")).toThrow(
+      "Invalid country code or prefix"
+    );
+  });
+
+  it("should handle empty input and throw an error", () => {
+    expect(() => formatToPhone("")).toThrow("Invalid phone number format");
+  });
+
+  it("should format a phone number with special characters removed", () => {
+    expect(() => formatToPhone("+55 11 91234-5678")).toThrow(
+      "Invalid phone number format. Expected format: +<countryCode>-<optionalPrefix> <phoneNumber>"
+    );
+  });
+
+  it("should format a phone number with spaces and special characters", () => {
+    expect(() => formatToPhone("+55 11 91234 5678")).toThrow(
+      "Invalid phone number format. Expected format: +<countryCode>-<optionalPrefix> <phoneNumber>"
+    );
+  });
+});

package/src/generators/__test__/generateColorByString.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { generateColorByString } from "../generateColorByString";
+
+describe("generateColorByString", () => {
+  it("should generate a consistent hex color for the same input string", () => {
+    const color1 = generateColorByString("example");
+    const color2 = generateColorByString("example");
+    expect(color1).toBe(color2);
+  });
+
+  it("should generate different hex colors for different input strings", () => {
+    const color1 = generateColorByString("example1");
+    const color2 = generateColorByString("example2");
+    expect(color1).not.toBe(color2);
+  });
+
+  it("should return a valid hex color code", () => {
+    const color = generateColorByString("test");
+    expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+
+  it("should handle empty strings and return a valid hex color", () => {
+    const color = generateColorByString("");
+    expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+
+  it("should handle strings with special characters", () => {
+    const color = generateColorByString("!@#$%^&*()");
+    expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+
+  it("should handle long strings and return a valid hex color", () => {
+    const longString = "a".repeat(1000);
+    const color = generateColorByString(longString);
+    expect(color).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+});