@doctocar/tooling 0.3.1-3 → 0.3.1-31

package/dist/pricing/calculateInvoiceTotalWithTax.js

@@ -31,7 +31,7 @@ const calculateMarketplaceFeeWithTax_util_1 = require("./utils/calculateMarketpl
  *  - Not handled here. Promo codes or marketplace-funded discounts should be applied later,
  *    without impacting the serviceProvider’s payout or service VAT lines.
  */
-function calculateInvoiceTotalsWithTax({ pricingPreTaxLines, prestationCountry, serviceProviderCountry, serviceProviderIsVatExempt, countriesPricingPublicConfigs, marketplaceCountry, customerCountry, customerIsSubjectToVAT, }) {
+function calculateInvoiceTotalsWithTax({ pricingPreTaxLines, prestationCountry, serviceProviderCountry, serviceProviderIsVatExempt, countriesPricingPublicConfigs, marketplaceCountry, customerCountry, customerIsSubjectToVat, }) {
     const placeOfSupplyCountry = prestationCountry;
     const pricingRatesForPlaceOfSupplyCountry = countriesPricingPublicConfigs[placeOfSupplyCountry];
     const pricingRatesForPrestationCountry = countriesPricingPublicConfigs[prestationCountry];
@@ -52,7 +52,7 @@ function calculateInvoiceTotalsWithTax({ pricingPreTaxLines, prestationCountry,
         pricingPreTaxLines,
         vatRateBasisPoints: effectiveServiceVatRateBasisPoints,
     });
-    const feeReverseChargeApplies = customerIsSubjectToVAT &&
+    const feeReverseChargeApplies = customerIsSubjectToVat &&
         customerCountry !== marketplaceCountry &&
         (0, country_1.isSupportedCountryEuMember)(customerCountry) &&
         (0, country_1.isSupportedCountryEuMember)(marketplaceCountry);

package/dist/pricing/types/CalculateInvoiceTotalsWithTaxParams.type.d.ts

@@ -7,7 +7,7 @@ export type CalculateInvoiceTotalsWithTaxParams = {
     serviceProviderCountry: SupportedCountryIsoCodes;
     serviceProviderIsVatExempt: boolean;
     customerCountry: SupportedCountryIsoCodes;
-    customerIsSubjectToVAT: boolean;
+    customerIsSubjectToVat: boolean;
     marketplaceCountry: SupportedCountryIsoCodes;
     countriesPricingPublicConfigs: Record<SupportedCountryIsoCodes, CountryPricingPublicConfig>;
 };

package/dist/pricing/utils/calculateMarketplaceFeeWithTax.util.js

@@ -22,4 +22,4 @@ function calculateMarketplaceFeeWithTax({ amountInCents, marketplaceFeeRateBasis
         totalMarketplaceFeeVatInCents: taxAmountInCents,
         totalMarketplaceFeePostTaxInCents: totalPostTaxInCents,
     };
-} // TODO update tests and update to handle tax based on pro location etc etc
+}

package/dist/stripe/types/StripeCustomPaymentIntentMetadata.type.d.ts

@@ -1,5 +1,7 @@
 export type StripeCustomPaymentIntentMetadata = {
     orderDocumentId: string;
     firestoreCustomerUserDocumentId: string;
-    firestoreProfessionalUserDocumentId: string;
+    firestoreServiceProviderEntityDocumentId: string;
+    firestoreServiceProviderUserDocumentId: string;
+    firestoreCustomerEntityDocumentId: string;
 };

package/dist/stripe/types/StripeCustomProfessionalPayoutMetadata.type.d.ts

@@ -1,3 +1,5 @@
 export type StripeCustomProfessionalPayoutMetadata = {
     walletWithdrawalIntentDocumentId: string;
+    entityDocumentId: string;
+    walletDocumentId: string;
 };

package/dist/stripe/types/StripeCustomServiceProviderPayoutMetadata.type.d.ts

@@ -0,0 +1,5 @@
+export type StripeCustomServiceProviderPayoutMetadata = {
+    walletWithdrawalIntentDocumentId: string;
+    entityDocumentId: string;
+    walletDocumentId: string;
+};

package/dist/stripe/types/StripeCustomServiceProviderPayoutMetadata.type.js

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

package/dist/stripe/types/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./StripeCustomPaymentIntentMetadata.type";
-export * from "./StripeCustomProfessionalPayoutMetadata.type";
+export * from "./StripeCustomServiceProviderPayoutMetadata.type";

package/dist/stripe/types/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./StripeCustomPaymentIntentMetadata.type"), exports);
-__exportStar(require("./StripeCustomProfessionalPayoutMetadata.type"), exports);
+__exportStar(require("./StripeCustomServiceProviderPayoutMetadata.type"), exports);

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable quotes */
+const escapeHtml_1 = require("../escapeHtml");
+describe("escapeHtml", () => {
+    it("should escape all HTML special characters", () => {
+        const input = `<div class="test" onclick='alert("x")'>& content</div>`;
+        const expected = `&lt;div class=&quot;test&quot; onclick=&#39;alert(&quot;x&quot;)&#39;&gt;&amp; content&lt;/div&gt;`;
+        expect((0, escapeHtml_1.escapeHtml)(input)).toBe(expected);
+    });
+    it("should escape only ampersand", () => {
+        expect((0, escapeHtml_1.escapeHtml)("Rock & Roll")).toBe("Rock &amp; Roll");
+    });
+    it("should escape only angle brackets", () => {
+        expect((0, escapeHtml_1.escapeHtml)("5 < 10 > 3")).toBe("5 &lt; 10 &gt; 3");
+    });
+    it("should escape both single and double quotes", () => {
+        expect((0, escapeHtml_1.escapeHtml)('She said: "It\'s fine"')).toBe("She said: &quot;It&#39;s fine&quot;");
+    });
+    it("should return the same string if there are no special characters", () => {
+        const input = "Hello world 123 !?";
+        expect((0, escapeHtml_1.escapeHtml)(input)).toBe(input);
+    });
+    it("should handle an empty string", () => {
+        expect((0, escapeHtml_1.escapeHtml)("")).toBe("");
+    });
+    it("should handle a string with only special characters", () => {
+        const input = "&<>\"'";
+        const expected = "&amp;&lt;&gt;&quot;&#39;";
+        expect((0, escapeHtml_1.escapeHtml)(input)).toBe(expected);
+    });
+});

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatApproximateAddress_1 = require("../formatApproximateAddress");
+describe("formatApproximateAddress", () => {
+    it("joins city and district with a bullet separator", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({
+            city: "Madrid",
+            district: "Salamanca",
+        })).toBe("Madrid • Salamanca");
+    });
+    it("returns only the city when no other fields are set", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({ city: "Barcelona" })).toBe("Barcelona");
+    });
+    it("returns only the country when it is the only field", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({ country: "France" })).toBe("France");
+    });
+    it("never includes street name in the output", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({
+            city: "Paris",
+            streetName: "10 Rue de Rivoli",
+        })).toBe("Paris");
+    });
+    it("appends administrative areas and postal code in a stable order", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({
+            city: "Lyon",
+            district: "Part-Dieu",
+            administrativeAreaLevel2: "Métropole",
+            administrativeAreaLevel1: "Auvergne-Rhône-Alpes",
+            postalCode: "69003",
+            country: "France",
+        })).toBe("Lyon • Part-Dieu • Métropole • Auvergne-Rhône-Alpes • 69003 • France");
+    });
+    it("skips empty, null, or whitespace-only fields", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({
+            city: "  Toulouse  ",
+            district: "   ",
+            country: null,
+        })).toBe("Toulouse");
+    });
+    it("returns empty string when no usable fields are present", () => {
+        expect((0, formatApproximateAddress_1.formatApproximateAddress)({
+            streetName: "Secret Street",
+        })).toBe("");
+    });
+});

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatFullName_1 = require("../formatFullName");
+describe("formatFullName", () => {
+    it("joins first and last name with a space", () => {
+        expect((0, formatFullName_1.formatFullName)({ firstName: "John", lastName: "Doe" })).toBe("John Doe");
+    });
+    it("returns only first name when last name is missing", () => {
+        expect((0, formatFullName_1.formatFullName)({ firstName: "John" })).toBe("John");
+    });
+    it("returns only last name when first name is missing", () => {
+        expect((0, formatFullName_1.formatFullName)({ lastName: "Doe" })).toBe("Doe");
+    });
+    it("returns empty string when both are missing", () => {
+        expect((0, formatFullName_1.formatFullName)({})).toBe("");
+    });
+    it("trims whitespace on parts", () => {
+        expect((0, formatFullName_1.formatFullName)({ firstName: "  John  ", lastName: " Doe " })).toBe("John Doe");
+    });
+});

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

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

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/regex/__tests__/isValidCompanyLegalName.util.test.js

@@ -97,6 +97,11 @@ const cases = [
         input: "123456",
         expected: true,
     },
+    {
+        name: "John Doe",
+        input: "John Doe",
+        expected: true,
+    },
     {
         name: "contains newline character",
         input: "Company\nName",

package/dist/utils/vat/__tests__/extractVatNumberAndCountryCode.test.d.ts

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

package/dist/utils/vat/__tests__/extractVatNumberAndCountryCode.test.js

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

package/dist/utils/vat/__tests__/validateVatNumberFormat.test.d.ts

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