@doctocar/tooling 0.3.1-4 → 0.3.1-40

package/dist/utils/format/__tests__/formatObfuscatedFullName.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatObfuscatedFullName_1 = require("../formatObfuscatedFullName");
+describe("formatObfuscatedFullName", () => {
+    it("returns first name and last initial with period", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ firstName: "John", lastName: "Doe" })).toBe("John D.");
+    });
+    it("returns only the first name when last name is missing", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ firstName: "John" })).toBe("John");
+    });
+    it("returns empty string when both names are null", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ firstName: null, lastName: null })).toBe("");
+    });
+    it("returns empty string when both names are undefined", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({})).toBe("");
+    });
+    it("returns empty string when both names are blank", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ firstName: "  ", lastName: "\t" })).toBe("");
+    });
+    it("returns last initial only when first name is missing", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ lastName: "Doe" })).toBe("D.");
+    });
+    it("trims surrounding whitespace on names", () => {
+        expect((0, formatObfuscatedFullName_1.formatObfuscatedFullName)({ firstName: "  John  ", lastName: " Doe " })).toBe("John D.");
+    });
+});

package/dist/utils/format/__tests__/formatObfuscatedLicensePlate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/format/__tests__/formatObfuscatedLicensePlate.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatObfuscatedLicensePlate_1 = require("../formatObfuscatedLicensePlate");
+describe("formatObfuscatedLicensePlate", () => {
+    it("obfuscates a long hyphenated plate", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("ABC-DEF-GHI")).toBe("ABC****HI");
+    });
+    it("obfuscates a compact alphanumeric plate", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("AB123CD")).toBe("AB****CD");
+    });
+    it("ignores separators and uppercases", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("ab-12-3-cd")).toBe("AB****CD");
+    });
+    it("returns empty string for null or undefined", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)(null)).toBe("");
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)(undefined)).toBe("");
+    });
+    it("returns empty string when there are no alphanumeric characters", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("---")).toBe("");
+    });
+    it("uses a three-character prefix when length is greater than 7", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("ABCDEFGH")).toBe("ABC****GH");
+    });
+    it("shows the full normalized plate when it has fewer than 5 characters", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("ABCD")).toBe("ABCD");
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("ABC")).toBe("ABC");
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("AB")).toBe("AB");
+    });
+    it("starts heavy obfuscation from 5 characters onward", () => {
+        expect((0, formatObfuscatedLicensePlate_1.formatObfuscatedLicensePlate)("AB12E")).toBe("AB****2E");
+    });
+});

package/dist/utils/format/__tests__/formatPriceInCents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/format/__tests__/formatPriceInCents.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../enums");
+const formatPriceInCents_1 = require("../formatPriceInCents");
+describe("formatPriceInCents", () => {
+    it("formats price in EUR correctly", () => {
+        const result = (0, formatPriceInCents_1.formatPriceInCents)(12345, enums_1.SupportedIsoCurrency.EUR);
+        expect(result).toBe("123.45 €");
+    });
+    it("defaults to EUR if currency is unknown", () => {
+        const result = (0, formatPriceInCents_1.formatPriceInCents)(12345, "XYZ");
+        expect(result).toBe("123.45 €");
+    });
+    it("formats non-round cents values correctly", () => {
+        const result = (0, formatPriceInCents_1.formatPriceInCents)(129, enums_1.SupportedIsoCurrency.EUR);
+        expect(result).toBe("1.29 €");
+    });
+    it("formats zero price correctly", () => {
+        const result = (0, formatPriceInCents_1.formatPriceInCents)(0, enums_1.SupportedIsoCurrency.EUR);
+        expect(result).toBe("0.00 €");
+    });
+    it("formats negative price correctly", () => {
+        const result = (0, formatPriceInCents_1.formatPriceInCents)(-12345, enums_1.SupportedIsoCurrency.EUR);
+        expect(result).toBe("-123.45 €");
+    });
+    // it("formats price in USD correctly", () => {
+    //   const result = formatPriceInCents(12345, SupportedIsoCurrency.USD);
+    //   expect(result).toBe("$123.45");
+    // });
+    // it("formats price in GBP correctly", () => {
+    //   const result = formatPriceInCents(12345, SupportedIsoCurrency.GBP);
+    //   expect(result).toBe("£123.45");
+    // });
+});

package/dist/utils/format/escapeHtml.d.ts

@@ -0,0 +1 @@
+export declare function escapeHtml(str: string): string;

package/dist/utils/format/escapeHtml.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}

package/dist/utils/format/formatApproximateAddress.d.ts

@@ -0,0 +1,2 @@
+import type { FormatApproximateAddressParams } from "./types";
+export declare function formatApproximateAddress(params: FormatApproximateAddressParams): string;

package/dist/utils/format/formatApproximateAddress.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatApproximateAddress = formatApproximateAddress;
+function pickNonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function formatApproximateAddress(params) {
+    const parts = [];
+    const city = pickNonEmpty(params.city);
+    const district = pickNonEmpty(params.district);
+    const administrativeAreaLevel2 = pickNonEmpty(params.administrativeAreaLevel2);
+    const administrativeAreaLevel1 = pickNonEmpty(params.administrativeAreaLevel1);
+    const postalCode = pickNonEmpty(params.postalCode);
+    const country = pickNonEmpty(params.country);
+    if (city) {
+        parts.push(city);
+    }
+    if (district) {
+        parts.push(district);
+    }
+    if (administrativeAreaLevel2) {
+        parts.push(administrativeAreaLevel2);
+    }
+    if (administrativeAreaLevel1) {
+        parts.push(administrativeAreaLevel1);
+    }
+    if (postalCode) {
+        parts.push(postalCode);
+    }
+    if (country) {
+        parts.push(country);
+    }
+    return parts.join(" • ");
+}

package/dist/utils/format/formatFullName.d.ts

@@ -0,0 +1,2 @@
+import type { FormatFullNameParams } from "./types";
+export declare function formatFullName(params: FormatFullNameParams): string;

package/dist/utils/format/formatFullName.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFullName = formatFullName;
+function formatFullName(params) {
+    const firstName = params.firstName?.trim() ?? "";
+    const lastName = params.lastName?.trim() ?? "";
+    if (!firstName) {
+        return lastName;
+    }
+    if (!lastName) {
+        return firstName;
+    }
+    return `${firstName} ${lastName}`;
+}

package/dist/utils/format/formatObfuscatedFullName.d.ts

@@ -0,0 +1,2 @@
+import type { FormatObfuscatedFullNameParams } from "./types";
+export declare function formatObfuscatedFullName(params: FormatObfuscatedFullNameParams): string;

package/dist/utils/format/formatObfuscatedFullName.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatObfuscatedFullName = formatObfuscatedFullName;
+function trimOrEmpty(value) {
+    return value?.trim() ?? "";
+}
+function obfuscatedLastInitial(lastName) {
+    const trimmed = lastName.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return `${trimmed[0]}.`;
+}
+function formatObfuscatedFullName(params) {
+    const firstName = trimOrEmpty(params.firstName);
+    const lastName = trimOrEmpty(params.lastName);
+    if (!firstName && !lastName) {
+        return "";
+    }
+    if (!lastName) {
+        return firstName;
+    }
+    const initial = obfuscatedLastInitial(lastName);
+    if (!firstName) {
+        return initial;
+    }
+    return `${firstName} ${initial}`;
+}

package/dist/utils/format/formatObfuscatedLicensePlate.d.ts

@@ -0,0 +1 @@
+export declare function formatObfuscatedLicensePlate(licensePlate?: string | null): string;

package/dist/utils/format/formatObfuscatedLicensePlate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatObfuscatedLicensePlate = formatObfuscatedLicensePlate;
+const OBFUSCATION = "****";
+const MIN_LENGTH_FOR_HEAVY_OBFUSCATION = 5;
+function normalizeLicensePlate(licensePlate) {
+    return licensePlate.replace(/[^a-zA-Z0-9]/g, "").toUpperCase();
+}
+function formatObfuscatedLicensePlate(licensePlate) {
+    if (licensePlate == null) {
+        return "";
+    }
+    const normalized = normalizeLicensePlate(licensePlate);
+    if (!normalized) {
+        return "";
+    }
+    const n = normalized.length;
+    if (n < MIN_LENGTH_FOR_HEAVY_OBFUSCATION) {
+        return normalized;
+    }
+    const prefixLength = n > 7 ? 3 : 2;
+    const suffixLength = 2;
+    const prefix = normalized.slice(0, prefixLength);
+    const suffix = normalized.slice(-suffixLength);
+    return `${prefix}${OBFUSCATION}${suffix}`;
+}

package/dist/utils/format/formatPriceInCents.d.ts

@@ -0,0 +1,2 @@
+import { SupportedIsoCurrency } from "../../enums";
+export declare function formatPriceInCents(priceInCents: number, currency: SupportedIsoCurrency): string;

package/dist/utils/format/formatPriceInCents.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPriceInCents = formatPriceInCents;
+const enums_1 = require("../../enums");
+function formatPriceInCents(priceInCents, currency) {
+    const negativePrice = priceInCents < 0;
+    priceInCents = Math.abs(priceInCents);
+    let formattedPrice = Math.abs(priceInCents / 100)
+        .toFixed(2)
+        .toString();
+    switch (currency) {
+        case enums_1.SupportedIsoCurrency.EUR:
+            formattedPrice = `${formattedPrice} €`;
+            break;
+        // case SupportedIsoCurrency.USD:
+        //   formattedPrice = `$${formattedPrice}`;
+        //   break;
+        // case SupportedIsoCurrency.GBP:
+        //   formattedPrice = `£${formattedPrice}`;
+        //   break;
+        default:
+            formattedPrice = `${formattedPrice} €`;
+    }
+    if (negativePrice) {
+        formattedPrice = `-${formattedPrice}`;
+    }
+    return formattedPrice;
+}

package/dist/utils/format/index.d.ts

@@ -1,2 +1,7 @@
-export * from "./formatPriceInCents.util";
-export * from "./escapeHtml.util";
+export * from "./types";
+export * from "./formatPriceInCents";
+export * from "./escapeHtml";
+export * from "./formatObfuscatedFullName";
+export * from "./formatFullName";
+export * from "./formatObfuscatedLicensePlate";
+export * from "./formatApproximateAddress";

package/dist/utils/format/index.js

@@ -14,5 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./formatPriceInCents.util"), exports);
-__exportStar(require("./escapeHtml.util"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./formatPriceInCents"), exports);
+__exportStar(require("./escapeHtml"), exports);
+__exportStar(require("./formatObfuscatedFullName"), exports);
+__exportStar(require("./formatFullName"), exports);
+__exportStar(require("./formatObfuscatedLicensePlate"), exports);
+__exportStar(require("./formatApproximateAddress"), exports);

package/dist/utils/format/types/FormatApproximateAddressParams.type.d.ts

@@ -0,0 +1,9 @@
+export type FormatApproximateAddressParams = {
+    city?: string | null;
+    administrativeAreaLevel1?: string | null;
+    administrativeAreaLevel2?: string | null;
+    postalCode?: string | null;
+    country?: string | null;
+    streetName?: string | null;
+    district?: string | null;
+};

package/dist/utils/format/types/FormatApproximateAddressParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/format/types/FormatFullNameParams.type.d.ts

@@ -0,0 +1,4 @@
+export type FormatFullNameParams = {
+    firstName?: string | null;
+    lastName?: string | null;
+};

package/dist/utils/format/types/FormatFullNameParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/format/types/FormatObfuscatedFullNameParams.type.d.ts

@@ -0,0 +1,4 @@
+export type FormatObfuscatedFullNameParams = {
+    firstName?: string | null;
+    lastName?: string | null;
+};

package/dist/utils/format/types/FormatObfuscatedFullNameParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/format/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FormatApproximateAddressParams.type";
+export * from "./FormatFullNameParams.type";
+export * from "./FormatObfuscatedFullNameParams.type";

package/dist/utils/format/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FormatApproximateAddressParams.type"), exports);
+__exportStar(require("./FormatFullNameParams.type"), exports);
+__exportStar(require("./FormatObfuscatedFullNameParams.type"), exports);

package/dist/utils/vat/__tests__/extractVATNumber.util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/vat/__tests__/extractVATNumber.util.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extractVATNumber_util_1 = require("../extractVATNumber.util");
+describe("extractVATNumber", () => {
+    test("should extract country code and VAT number correctly", () => {
+        expect((0, extractVATNumber_util_1.extractVATNumber)("FR123456789")).toEqual({
+            countryISOCode: "FR",
+            vatNumber: "123456789",
+        });
+        expect((0, extractVATNumber_util_1.extractVATNumber)("DE987654321")).toEqual({
+            countryISOCode: "DE",
+            vatNumber: "987654321",
+        });
+        expect((0, extractVATNumber_util_1.extractVATNumber)("IT12345678901")).toEqual({
+            countryISOCode: "IT",
+            vatNumber: "12345678901",
+        });
+    });
+    test("should return null for invalid VAT number formats", () => {
+        expect((0, extractVATNumber_util_1.extractVATNumber)("123456789")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("FR")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("fr123456789")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("F123456789")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("FR-123456789")).toBeNull();
+    });
+    test("should handle edge cases", () => {
+        expect((0, extractVATNumber_util_1.extractVATNumber)("GBGD123")).toEqual({
+            countryISOCode: "GB",
+            vatNumber: "GD123",
+        });
+        expect((0, extractVATNumber_util_1.extractVATNumber)("ESX1234567")).toEqual({
+            countryISOCode: "ES",
+            vatNumber: "X1234567",
+        });
+        expect((0, extractVATNumber_util_1.extractVATNumber)("")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("   ")).toBeNull();
+        expect((0, extractVATNumber_util_1.extractVATNumber)("FR 123456789")).toBeNull();
+    });
+});

package/dist/utils/vat/__tests__/validateVATFormat.util.test.d.ts

@@ -0,0 +1 @@
+export {};