@doctocar/tooling 0.3.1-18 → 0.3.1-19

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/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/index.d.ts

@@ -1,2 +1,7 @@
+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("./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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doctocar/tooling",
-  "version": "0.3.1-18",
+  "version": "0.3.1-19",
   "description": "A set of tools for DoctoCar projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",