@cofondateurauchomage/libs 1.1.171 → 1.1.177

package/build/api.validate.js

@@ -38,6 +38,15 @@ function optionalStr(schema) {
 }
 const zSkillsRequired = zod_1.z.array(zSkill).min(1).max(2);
 const zSkillsOptional = zod_1.z.array(zSkill).min(1).max(2).optional();
+const zProfileLocation = zod_1.z.object({
+    lat: zod_1.z.number().min(-90).max(90),
+    lng: zod_1.z.number().min(-180).max(180),
+    label: zStrMax50,
+    regionCode: zStrMax50,
+    departmentCode: zStrMax50,
+    cityCode: zStrMax50.optional(),
+    postcode: zStrMax50.optional(),
+});
 const contactCreate = {
     email: zod_1.z.string(),
     emailProspect: zod_1.z.string(),
@@ -65,7 +74,7 @@ const projectBody = {
     skills: zSkillsRequired,
     yearsOfExperience: zod_1.z.number().min(0).max(100).optional(),
     availability: zAvailabilityWithNeverMind.optional(),
-    city: zName,
+    location: zProfileLocation,
     invest: zod_1.z.number().min(0).max(1_000_000).optional(),
     partner: zStrMax1000.optional(),
     logo: zod_1.z.string().optional(),
@@ -76,7 +85,7 @@ const userBody = {
     skills: zSkillsRequired,
     yearsOfExperience: zod_1.z.number().min(0).max(100).optional(),
     availability: zAvailability.optional(),
-    city: zName,
+    location: zProfileLocation,
     invest: zod_1.z.number().min(0).max(1_000_000).optional(),
     motivations: zStrMax1000.optional(),
     partner: zStrMax1000.optional(),
@@ -93,7 +102,6 @@ const FIELDS_LABEL = {
     availability: "Disponibilité",
     bestStrength: "Meilleur atout",
     business: "Business",
-    city: "Ville",
     description: "Description",
     email: "Email",
     firstName: "Prénom",
@@ -101,6 +109,7 @@ const FIELDS_LABEL = {
     invest: "Investissement",
     lastName: "Nom",
     linkedin: "Linkedin",
+    location: "Localisation",
     motivations: "Motivations",
     name: "Nom",
     partner: "Partenaire",
@@ -207,7 +216,7 @@ const schemasForAllRoutes = {
         skills: zSkillsOptional,
         yearsOfExperience: zod_1.z.number().min(0).max(100).optional(),
         availability: zAvailabilityWithNeverMind.optional(),
-        city: optionalStr(zName),
+        location: zProfileLocation.optional(),
         invest: zod_1.z.number().min(0).max(1_000_000).optional(),
         partner: zStrMax1000.optional(),
         partner_swanbase: zod_1.z.boolean().optional(),

package/build/crm/searchText.js

@@ -15,14 +15,14 @@ function buildCrmProfileSearchText(doc) {
         pushPart(parts, profile.email);
         pushPart(parts, profile.firstName);
         pushPart(parts, profile.lastName);
-        pushPart(parts, profile.city);
+        pushPart(parts, profile.location?.label);
         pushPart(parts, profile.linkedin);
     }
     else if (doc.type === "user") {
         const profile = doc.profile;
         pushPart(parts, profile.firstName);
         pushPart(parts, profile.lastName);
-        pushPart(parts, profile.city);
+        pushPart(parts, profile.location?.label);
         pushPart(parts, doc.contact?.email);
         pushPart(parts, doc.contact?.linkedin);
     }
@@ -31,7 +31,7 @@ function buildCrmProfileSearchText(doc) {
         pushPart(parts, profile.name);
         pushPart(parts, profile.firstName);
         pushPart(parts, profile.lastName);
-        pushPart(parts, profile.city);
+        pushPart(parts, profile.location?.label);
         pushPart(parts, doc.contact?.email);
         pushPart(parts, doc.contact?.linkedin);
     }

package/build/db.model.d.ts

@@ -29,13 +29,22 @@ export interface IClicks {
     share: number;
     website: number;
 }
+export interface IProfileLocation {
+    lat: number;
+    lng: number;
+    label: string;
+    regionCode: string;
+    departmentCode: string;
+    cityCode?: string;
+    postcode?: string;
+}
 export interface IUser {
     lastName: string;
     firstName: string;
     skills: TSkill[];
     yearsOfExperience?: number;
     availability?: TAvailability;
-    city: string;
+    location?: IProfileLocation;
     invest?: number;
     motivations?: string;
     bestStrength?: string;
@@ -69,7 +78,7 @@ export interface IProject {
     skills: TSkill[];
     yearsOfExperience?: number;
     availability?: (TAvailability | 'never_mind');
-    city: string;
+    location?: IProfileLocation;
     invest?: number;
     partner?: string;
     logo?: string;

package/build/geo/distance.d.ts

@@ -0,0 +1,8 @@
+/** Great-circle distance between two WGS84 points (V2 radius filter). */
+export declare function haversineKm(a: {
+    lat: number;
+    lng: number;
+}, b: {
+    lat: number;
+    lng: number;
+}): number;

package/build/geo/distance.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.haversineKm = haversineKm;
+const EARTH_RADIUS_KM = 6371;
+/** Great-circle distance between two WGS84 points (V2 radius filter). */
+function haversineKm(a, b) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(b.lat - a.lat);
+    const dLng = toRad(b.lng - a.lng);
+    const lat1 = toRad(a.lat);
+    const lat2 = toRad(b.lat);
+    const h = Math.sin(dLat / 2) ** 2 +
+        Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+    return 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(h));
+}

package/build/geo/fetch.d.ts

@@ -0,0 +1,6 @@
+import type { ILocationSuggestion } from "./types";
+export declare function getRegionCodeForDepartment(departmentCode: string): Promise<string | undefined>;
+/** Search regions, departments (geo.api) and cities/postcodes (API Adresse). */
+export declare function searchLocationSuggestions(query: string): Promise<ILocationSuggestion[]>;
+/** Geocode a legacy free-text city label (migration script). */
+export declare function geocodeCityLabel(cityLabel: string): Promise<ILocationSuggestion | null>;

package/build/geo/fetch.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegionCodeForDepartment = getRegionCodeForDepartment;
+exports.searchLocationSuggestions = searchLocationSuggestions;
+exports.geocodeCityLabel = geocodeCityLabel;
+const legacyCityLabel_1 = require("./legacyCityLabel");
+const parse_1 = require("./parse");
+const GEO_API = "https://geo.api.gouv.fr";
+const ADRESSE_API = "https://api-adresse.data.gouv.fr";
+const departmentRegionCache = new Map();
+async function getRegionCodeForDepartment(departmentCode) {
+    if (!departmentCode) {
+        return undefined;
+    }
+    if (departmentRegionCache.has(departmentCode)) {
+        return departmentRegionCache.get(departmentCode);
+    }
+    try {
+        const res = await fetch(`${GEO_API}/departements/${departmentCode}`);
+        if (!res.ok) {
+            return undefined;
+        }
+        const data = (await res.json());
+        departmentRegionCache.set(departmentCode, data.codeRegion);
+        return data.codeRegion;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fetchGeoApi(path) {
+    try {
+        const res = await fetch(`${GEO_API}${path}`);
+        if (!res.ok) {
+            return [];
+        }
+        const data = await res.json();
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchAdresseFeatures(q) {
+    try {
+        const params = new URLSearchParams({ q, limit: "8", autocomplete: "1" });
+        const res = await fetch(`${ADRESSE_API}/search/?${params}`);
+        if (!res.ok) {
+            return [];
+        }
+        const data = (await res.json());
+        return data.features ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function rankSuggestion(suggestion, q) {
+    const normalized = q.trim().toLowerCase();
+    if (/^\d{5}$/.test(normalized) && suggestion.postcode === normalized) {
+        return 0;
+    }
+    if (suggestion.type === "department" &&
+        suggestion.departmentCode?.toLowerCase() === normalized) {
+        return 1;
+    }
+    if (suggestion.label.toLowerCase().startsWith(normalized)) {
+        return 2;
+    }
+    return 3;
+}
+function dedupeSuggestions(suggestions) {
+    const seen = new Set();
+    return suggestions.filter((s) => {
+        const key = `${s.type}:${s.regionCode}:${s.departmentCode ?? ""}:${s.cityCode ?? ""}:${s.postcode ?? ""}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+/** Search regions, departments (geo.api) and cities/postcodes (API Adresse). */
+async function searchLocationSuggestions(query) {
+    const q = query.trim();
+    if (q.length < 2) {
+        return [];
+    }
+    const encoded = encodeURIComponent(q);
+    const [regions, departments, features] = await Promise.all([
+        fetchGeoApi(`/regions?nom=${encoded}`),
+        fetchGeoApi(`/departements?nom=${encoded}`),
+        fetchAdresseFeatures(q),
+    ]);
+    const suggestions = [
+        ...regions.map(parse_1.parseGeoApiRegion),
+        ...departments.map(parse_1.parseGeoApiDepartment),
+    ];
+    // Match department by code (e.g. "35", "2A")
+    if (/^\d{1,3}[ab]?$/i.test(q)) {
+        try {
+            const res = await fetch(`${GEO_API}/departements/${q.toUpperCase()}`);
+            if (res.ok) {
+                const dept = (await res.json());
+                suggestions.push((0, parse_1.parseGeoApiDepartment)(dept));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const departmentCodes = new Set();
+    for (const feature of features) {
+        const ctx = feature.properties.context?.split(",")[0]?.trim();
+        if (ctx) {
+            departmentCodes.add(ctx);
+        }
+    }
+    const regionByDepartment = new Map();
+    await Promise.all([...departmentCodes].map(async (code) => {
+        const regionCode = await getRegionCodeForDepartment(code);
+        if (regionCode) {
+            regionByDepartment.set(code, regionCode);
+        }
+    }));
+    for (const feature of features) {
+        const deptCode = feature.properties.context?.split(",")[0]?.trim() ?? "";
+        const regionCode = regionByDepartment.get(deptCode);
+        if (!regionCode) {
+            continue;
+        }
+        const parsed = (0, parse_1.parseAdresseFeature)(feature, regionCode);
+        if (parsed) {
+            suggestions.push(parsed);
+        }
+    }
+    return dedupeSuggestions(suggestions)
+        .sort((a, b) => rankSuggestion(a, q) - rankSuggestion(b, q))
+        .slice(0, 12);
+}
+/** Geocode a legacy free-text city label (migration script). */
+async function geocodeCityLabel(cityLabel) {
+    if ((0, legacyCityLabel_1.isUngeocodableLegacyCityLabel)(cityLabel)) {
+        return null;
+    }
+    const q = `${cityLabel.trim()}, France`;
+    const features = await fetchAdresseFeatures(q);
+    if (!features.length) {
+        return null;
+    }
+    const feature = features[0];
+    const deptCode = feature.properties.context?.split(",")[0]?.trim() ?? "";
+    const regionCode = await getRegionCodeForDepartment(deptCode);
+    if (!regionCode) {
+        return null;
+    }
+    return (0, parse_1.parseAdresseFeature)(feature, regionCode);
+}

package/build/geo/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./distance";
+export * from "./fetch";
+export * from "./parse";
+export * from "./types";

package/build/geo/index.js

@@ -0,0 +1,20 @@
+"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("./distance"), exports);
+__exportStar(require("./fetch"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./types"), exports);

package/build/geo/legacyCityLabel.d.ts

@@ -0,0 +1,4 @@
+/** Normalize legacy free-text city labels for comparison. */
+export declare function normalizeLegacyCityLabel(label: string): string;
+/** Returns true when a legacy city string is too vague to geocode reliably. */
+export declare function isUngeocodableLegacyCityLabel(cityLabel: string): boolean;

package/build/geo/legacyCityLabel.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLegacyCityLabel = normalizeLegacyCityLabel;
+exports.isUngeocodableLegacyCityLabel = isUngeocodableLegacyCityLabel;
+/** Normalize legacy free-text city labels for comparison. */
+function normalizeLegacyCityLabel(label) {
+    return label
+        .trim()
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[.!,;:]+$/g, "")
+        .replace(/\s+/g, " ");
+}
+/** Country-wide or non-local labels that must not be sent to API Adresse. */
+const UNGEOCODABLE_LEGACY_CITY_LABELS = new Set([
+    "france",
+    "toute la france",
+    "en france",
+    "france entiere",
+    "france metropolitaine",
+    "metropole",
+    "remote",
+    "teletravail",
+    "partout",
+    "n/a",
+    "na",
+]);
+/** Returns true when a legacy city string is too vague to geocode reliably. */
+function isUngeocodableLegacyCityLabel(cityLabel) {
+    const normalized = normalizeLegacyCityLabel(cityLabel);
+    if (!normalized) {
+        return true;
+    }
+    return UNGEOCODABLE_LEGACY_CITY_LABELS.has(normalized);
+}

package/build/geo/parse.d.ts

@@ -0,0 +1,40 @@
+import type { IProfileLocation } from "../db.model";
+import type { ILocationSuggestion } from "./types";
+type GeoApiCentre = {
+    coordinates?: [number, number];
+};
+type GeoApiRegion = {
+    code: string;
+    nom: string;
+    centre?: GeoApiCentre;
+};
+type GeoApiDepartment = {
+    code: string;
+    nom: string;
+    codeRegion: string;
+    centre?: GeoApiCentre;
+};
+type AdresseFeature = {
+    properties: {
+        label: string;
+        score?: number;
+        city?: string;
+        postcode?: string;
+        citycode?: string;
+        context?: string;
+    };
+    geometry: {
+        coordinates: [number, number];
+    };
+};
+export declare function parseGeoApiRegion(region: GeoApiRegion): ILocationSuggestion;
+export declare function parseGeoApiDepartment(department: GeoApiDepartment): ILocationSuggestion;
+/** Parse API Adresse `context`: "68, Haut-Rhin, Grand Est". */
+export declare function parseAdresseContext(context?: string): {
+    departmentCode: string;
+    regionName: string;
+};
+export declare function parseAdresseFeature(feature: AdresseFeature, regionCode: string): ILocationSuggestion | null;
+export declare function suggestionToProfileLocation(suggestion: ILocationSuggestion): IProfileLocation;
+export declare function normalizeProfileLocation(location: IProfileLocation): IProfileLocation;
+export type { AdresseFeature, GeoApiDepartment, GeoApiRegion };

package/build/geo/parse.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGeoApiRegion = parseGeoApiRegion;
+exports.parseGeoApiDepartment = parseGeoApiDepartment;
+exports.parseAdresseContext = parseAdresseContext;
+exports.parseAdresseFeature = parseAdresseFeature;
+exports.suggestionToProfileLocation = suggestionToProfileLocation;
+exports.normalizeProfileLocation = normalizeProfileLocation;
+const coordsFromCentre = (centre) => {
+    const [lng, lat] = centre?.coordinates ?? [0, 0];
+    return { lat, lng };
+};
+function parseGeoApiRegion(region) {
+    const { lat, lng } = coordsFromCentre(region.centre);
+    return {
+        type: "region",
+        label: region.nom,
+        regionCode: region.code,
+        lat,
+        lng,
+    };
+}
+function parseGeoApiDepartment(department) {
+    const { lat, lng } = coordsFromCentre(department.centre);
+    return {
+        type: "department",
+        label: `${department.nom} (${department.code})`,
+        regionCode: department.codeRegion,
+        departmentCode: department.code,
+        lat,
+        lng,
+    };
+}
+/** Parse API Adresse `context`: "68, Haut-Rhin, Grand Est". */
+function parseAdresseContext(context) {
+    if (!context) {
+        return { departmentCode: "", regionName: "" };
+    }
+    const parts = context.split(",").map((p) => p.trim());
+    return {
+        departmentCode: parts[0] ?? "",
+        regionName: parts[2] ?? parts[1] ?? "",
+    };
+}
+function parseAdresseFeature(feature, regionCode) {
+    const { properties, geometry } = feature;
+    const city = properties.city?.trim();
+    if (!city) {
+        return null;
+    }
+    const { departmentCode } = parseAdresseContext(properties.context);
+    const [lng, lat] = geometry.coordinates;
+    const postcode = properties.postcode?.trim();
+    const cityCode = properties.citycode?.trim();
+    const label = postcode ? `${city} (${postcode})` : city;
+    return {
+        type: "city",
+        label,
+        regionCode,
+        departmentCode: departmentCode || undefined,
+        cityCode: cityCode || undefined,
+        lat,
+        lng,
+        postcode,
+    };
+}
+function suggestionToProfileLocation(suggestion) {
+    const displayLabel = suggestion.label
+        .replace(/\s*\(\d{5}\)$/, "")
+        .replace(/\s*\(\d{1,3}[ABab]?\)$/, "")
+        .trim();
+    const base = {
+        lat: suggestion.lat,
+        lng: suggestion.lng,
+        label: displayLabel,
+        regionCode: suggestion.regionCode,
+        departmentCode: suggestion.departmentCode ?? "",
+        postcode: suggestion.postcode,
+    };
+    if (suggestion.type === "city" && suggestion.cityCode) {
+        return { ...base, cityCode: suggestion.cityCode };
+    }
+    return base;
+}
+function normalizeProfileLocation(location) {
+    return {
+        ...location,
+        label: location.label.trim(),
+        regionCode: location.regionCode.trim(),
+        departmentCode: location.departmentCode.trim(),
+        cityCode: location.cityCode?.trim() || undefined,
+        postcode: location.postcode?.trim() || undefined,
+    };
+}

package/build/geo/types.d.ts

@@ -0,0 +1,12 @@
+export type TLocationSuggestionType = "region" | "department" | "city";
+/** Unified autocomplete row and filter selection. */
+export interface ILocationSuggestion {
+    type: TLocationSuggestionType;
+    label: string;
+    regionCode: string;
+    departmentCode?: string;
+    cityCode?: string;
+    lat: number;
+    lng: number;
+    postcode?: string;
+}

package/build/geo/types.js

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

package/build/index.d.ts

@@ -3,5 +3,6 @@ export * from "./api.validate";
 export * from "./const";
 export * from "./crm";
 export * from "./db.model";
+export * from "./geo";
 export * from "./regex";
 export * from "./utils";

package/build/index.js

@@ -19,5 +19,6 @@ __exportStar(require("./api.validate"), exports);
 __exportStar(require("./const"), exports);
 __exportStar(require("./crm"), exports);
 __exportStar(require("./db.model"), exports);
+__exportStar(require("./geo"), exports);
 __exportStar(require("./regex"), exports);
 __exportStar(require("./utils"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofondateurauchomage/libs",
-  "version": "1.1.171",
+  "version": "1.1.177",
   "description": "",
   "main": "build/index",
   "scripts": {