@arkyn/shared 1.5.0 → 1.5.1

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/formats/formatDate.ts

@@ -0,0 +1,97 @@
+import type { FormatDateFunction } from "@arkyn/types";
+
+function formatDateString(date: Date, format: string): string {
+  const pad = (num: number) => num.toString().padStart(2, "0");
+
+  const replacements: Record<string, string> = {
+    YYYY: date.getFullYear().toString(),
+    YY: date.getFullYear().toString().slice(-2),
+    MM: pad(date.getMonth() + 1),
+    DD: pad(date.getDate()),
+    hh: pad(date.getHours()),
+    mm: pad(date.getMinutes()),
+    ss: pad(date.getSeconds()),
+  };
+
+  return format.replace(
+    /YYYY|YY|MM|DD|hh|mm|ss/g,
+    (match) => replacements[match]
+  );
+}
+
+/**
+ * Formats a date string from a given input format to a specified output format,
+ * with optional timezone adjustment.
+ *
+ * @param date - The date string to be formatted. It should match the specified `inputFormat`.
+ * @param time - The time string in the format `hh:mm:ss` (e.g., `14:30:00`).
+ * @param inputFormat - The format of the input date string. Supported formats:
+ *   - `"brazilianDate"`: Expects the date in `DD/MM/YYYY` format.
+ *   - `"isoDate"`: Expects the date in `YYYY-MM-DD` format.
+ *   - `"timestamp"`: Expects the date as a numeric timestamp (e.g., `YYYY-MM-DD`).
+ *
+ * @param outputFormat - The desired format for the output date string. Supported tokens:
+ *   - `YYYY`: Full year (e.g., 2023)
+ *   - `YY`: Last two digits of the year (e.g., 23)
+ *   - `MM`: Month (zero-padded, e.g., 01)
+ *   - `DD`: Day of the month (zero-padded, e.g., 09)
+ *   - `hh`: Hours (zero-padded, 24-hour format, e.g., 08)
+ *   - `mm`: Minutes (zero-padded, e.g., 05)
+ *   - `ss`: Seconds (zero-padded, e.g., 07)
+ * @param timezone - (Optional) The timezone offset in hours to adjust the date. Defaults to `0`.
+ *
+ * @returns The formatted date string in the specified `outputFormat`.
+ *
+ * @throws Will throw an error if:
+ *   - The `inputFormat` is invalid.
+ *   - The `date` string does not match the expected `inputFormat`.
+ *   - The `time` string is not in the format `hh:mm:ss`.
+ *   - The resulting date is invalid.
+ *
+ * @example
+ * ```typescript
+ * import { formatDate } from "./formatDate";
+ *
+ * const date = "25/12/2023";
+ * const time = "14:30:00";
+ * const formatted = formatDate(date, time, "brazilianDate", "YYYY-MM-DD hh:mm:ss", -3);
+ * console.log(formatted); // Outputs: "2023-12-25 14:30:00"
+ * ```
+ */
+
+const formatDate: FormatDateFunction = (
+  date,
+  time,
+  inputFormat,
+  outputFormat,
+  timezone = 0
+) => {
+  const dateParts = date.split(/[-/]/).map(Number);
+  const timeParts = time.split(":").map(Number);
+
+  let day, month, year;
+  const [hours = 0, minutes = 0, seconds = 0] = timeParts;
+
+  switch (inputFormat) {
+    case "brazilianDate":
+      [day, month, year] = dateParts;
+      break;
+    case "isoDate":
+      [year, month, day] = dateParts;
+      break;
+    case "timestamp":
+      [year, month, day] = dateParts.map(Number);
+      break;
+    default:
+      throw new Error("Invalid input format");
+  }
+
+  const formattedDate = new Date(year, month - 1, day, hours, minutes, seconds);
+  if (isNaN(formattedDate.getTime())) throw new Error("Invalid date");
+
+  formattedDate.setUTCHours(formattedDate.getUTCHours() + timezone);
+
+  return formatDateString(formattedDate, outputFormat);
+};
+
+export { formatDate };

package/src/formats/formatJsonObject.ts

@@ -1,35 +1,77 @@
-function formatJsonObject(obj: any, indentLevel: number): string {
+import type { FormatJsonObjectFunction } from "@arkyn/types";
+
+/**
+ * Formats a JSON object into a human-readable string with proper indentation.
+ *
+ * @param obj - The JSON object or value to format. It can be an object, array, string, or primitive value.
+ * @param indentLevel - The current level of indentation to apply. This is used recursively to format nested structures.
+ * @returns A formatted string representation of the JSON object.
+ *
+ * @remarks
+ * - If the input is an object, it will be formatted with keys and values properly indented.
+ * - If the input is an array, each element will be formatted and indented on a new line.
+ * - If the input is a string that can be parsed as JSON, it will attempt to parse and format it.
+ * - Primitive values (e.g., numbers, booleans, null) will be converted to their string representation.
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John", age: 30, hobbies: ["reading", "gaming"] };
+ * const formatted = formatJsonObject(obj, 0);
+ * console.log(formatted);
+ * // Output:
+ * // {
+ * //   "name": "John",
+ * //   "age": 30,
+ * //   "hobbies": [
+ * //     "reading",
+ * //     "gaming"
+ * //   ]
+ * // }
+ * ```
+ */
+
+const formatJsonObject: FormatJsonObjectFunction = (obj, indentLevel) => {
   const indent = "  ".repeat(indentLevel);
   let formattedString = "";
 
   if (typeof obj === "object" && obj !== null) {
     if (Array.isArray(obj)) {
-      formattedString += "[\n";
-      obj.forEach((item, index) => {
-        formattedString +=
-          indent + "  " + formatJsonObject(item, indentLevel + 1);
-        if (index < obj.length - 1) {
-          formattedString += ",";
-        }
-        formattedString += "\n";
-      });
-      formattedString += indent + "]";
+      if (obj.length === 0) {
+        // Caso especial para arrays vazios
+        formattedString += "[]";
+      } else {
+        formattedString += "[\n";
+        obj.forEach((item, index) => {
+          formattedString +=
+            indent + "  " + formatJsonObject(item, indentLevel + 1);
+          if (index < obj.length - 1) {
+            formattedString += ",";
+          }
+          formattedString += "\n";
+        });
+        formattedString += indent + "]";
+      }
     } else {
-      formattedString += "{\n";
       const keys = Object.keys(obj);
-      keys.forEach((key, index) => {
-        formattedString +=
-          indent +
-          '  "' +
-          key +
-          '": ' +
-          formatJsonObject(obj[key], indentLevel + 1);
-        if (index < keys.length - 1) {
-          formattedString += ",";
-        }
-        formattedString += "\n";
-      });
-      formattedString += indent + "}";
+      if (keys.length === 0) {
+        // Caso especial para objetos vazios
+        formattedString += "{}";
+      } else {
+        formattedString += "{\n";
+        keys.forEach((key, index) => {
+          formattedString +=
+            indent +
+            '  "' +
+            key +
+            '": ' +
+            formatJsonObject(obj[key], indentLevel + 1);
+          if (index < keys.length - 1) {
+            formattedString += ",";
+          }
+          formattedString += "\n";
+        });
+        formattedString += indent + "}";
+      }
     }
   } else if (typeof obj === "string") {
     try {
@@ -43,6 +85,6 @@ function formatJsonObject(obj: any, indentLevel: number): string {
   }
 
   return formattedString;
-}
+};
 
 export { formatJsonObject };