universal-parcel-scraper 0.49.0-main.523 → 0.49.0-main.526

package/dist/carriers/aliexpress/adapter.js

@@ -76,6 +76,28 @@ function scanTime(scan) {
     const offset = zone[1] ? `${zone[1]}${zone[2].padStart(2, '0')}:${zone[3] ?? '00'}` : 'Z';
     return explicitOffsetTime(`${wall.replace(' ', 'T')}${offset}`)?.iso ?? wall;
 }
+/** The carriers a module names, which a bracket can name too without being a place. */
+function carrierNames(trackingModule, scans) {
+    const named = [trackingModule.destCpInfo, ...[trackingModule.latestTrace, trackingModule.globalCombinedLogisticsTraceDTO, ...scans]
+            .map((scan) => record(scan).currentStatusCpInfo)];
+    return new Set(named.map((info) => text(record(info).cpName).trim().toLocaleLowerCase('en-US')).filter(Boolean));
+}
+/**
+ * Cainiao has no place field: it writes a scan's town in front of its standard
+ * wording, "[Bordeaux] Out for delivery", in every language. A bracket that
+ * reads as a place name becomes the location and the wording keeps the rest.
+ * Codes, capitals-only names and the module's own carrier names stay in the text.
+ */
+function placedWording(wording, carriers) {
+    const match = /^\s*\[([^[\]]{1,80})\]\s*(\S[\s\S]*)$/.exec(wording);
+    const place = match?.[1].trim() ?? '';
+    const letters = place.match(/\p{L}/gu)?.length ?? 0;
+    if (!match || letters < 3 || !/^\p{L}[\p{L}\p{M} .'’-]*$/u.test(place)
+        || (/\p{Lu}/u.test(place) && !/\p{Ll}/u.test(place)) || carriers.has(place.toLocaleLowerCase('en-US'))) {
+        return { description: wording, location: '' };
+    }
+    return { description: match[2].trim(), location: place };
+}
 const BEIJING_OFFSET_MS = 8 * 3_600_000;
 /**
  * Whether a zone-less scan is Cainiao's own record on the Beijing clock. Its
@@ -139,13 +161,15 @@ export function parseCainiaoTrackingResponse(value, trackingNumber) {
             ?? (rawStatus ? 'in_transit' : details.length === 0 ? 'pending' : 'unknown'));
     const latestAction = cainiaoActionCode(latest.actionCode);
     const actionStage = cainiaoStageByStatus(latestAction);
+    const carriers = carrierNames(trackingModule, details);
     const events = details.slice(0, MAX_EVENTS_TO_RETURN).map((event) => {
         const code = cainiaoActionCode(event.actionCode);
         const mapped = code ? CAINIAO_ACTION_STATUS.get(code) : undefined;
+        const { description, location } = placedWording(text(event.standerdDesc) || text(event.desc), carriers);
         return {
             time: scanTime(event),
-            location: '',
-            description: text(event.standerdDesc) || text(event.desc),
+            location,
+            description,
             ...(mapped ? { stage: actionStage[mapped] ?? 'in_transit' } : {}),
         };
     });
@@ -162,7 +186,7 @@ export function parseCainiaoTrackingResponse(value, trackingNumber) {
     return {
         status,
         ...(actionStage[status] || status === 'in_transit' ? { current_stage: actionStage[status] ?? 'in_transit' } : {}),
-        last_status_text: text(latest.standerdDesc) || text(latest.desc) || rawStatus,
+        last_status_text: placedWording(text(latest.standerdDesc) || text(latest.desc), carriers).description || rawStatus,
         last_update: scanTime(latest) || null,
         expected_delivery: status === 'delivered' ? null : expected,
         ...(status === 'delivered' || expectedFrom == null || expectedFrom === expected

package/dist/carriers/aliexpress/app.d.ts

@@ -0,0 +1,2 @@
+import type { SameInstantIdentityPolicy } from '../../core/catalog/eventIdentity.js';
+export declare const sameInstantIdentityPolicy: SameInstantIdentityPolicy;

package/dist/carriers/aliexpress/app.js

@@ -0,0 +1,14 @@
+const normalized = (value) => value.replace(/\s+/g, ' ').trim().toLocaleLowerCase('en-US');
+// A scan stored while its town was still part of the wording, "[Bordeaux] Out for
+// delivery" without a location, is the same scan as "Out for delivery" in Bordeaux.
+export const sameInstantIdentityPolicy = {
+    sourceCarrierId: 'aliexpress', storedSources: ['aliexpress'], requireProviderCode: false,
+    matchEachScan: true,
+    matches(incoming, stored) {
+        const wording = normalized(incoming.description);
+        const location = normalized(incoming.location);
+        return Boolean(wording && location) && !['', 'unknown'].includes(incoming.stage)
+            && incoming.stage === stored.stage && !normalized(stored.location)
+            && normalized(stored.description) === `[${location}] ${wording}`;
+    },
+};

package/dist/carriers/aliexpress/carrier.json

@@ -28,6 +28,7 @@
   },
   "capabilities": [
     "history",
+    "location",
     "eta",
     "eta_window",
     "delivered_at"
@@ -38,11 +39,13 @@
     "shows": [
       "status",
       "history",
+      "location",
       "eta"
     ],
     "scraped": [
       "status",
       "history",
+      "location",
       "eta"
     ],
     "discarded": [],

package/dist/carriers/la-poste/adapter.d.ts

@@ -25,7 +25,15 @@ export declare class LaPosteTracker {
     private readonly fetcher?;
     private readonly recorder?;
     private readonly userAgent;
+    /** The locator's page for a point is large and its address does not change. */
+    private readonly addresses;
     constructor(options?: LaPosteTrackerOptions);
     fetch(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;
+    /**
+     * The point's street and town, or nothing: the parcel is found, and its pickup point keeps its
+     * name without them. The request gets at most half of what is left, so the result still has
+     * time to return.
+     */
+    private pointAddress;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/la-poste/adapter.js

@@ -4,7 +4,7 @@ import { dpdParcelNumber } from '../../core/detection/dpd.js';
 import { CarrierError, InvalidInputError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
 import { isoTime } from '../../core/time/index.js';
-import { clean, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
+import { clean, decodeText, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { eventStage, eventStatus } from './status.js';
 // Protocol provenance:
@@ -20,10 +20,19 @@ import { eventStage, eventStatus } from './status.js';
 // - Production HTTP 403s carried La Poste's "Site indisponible - Incident en
 //   cours" page and immediately following checks succeeded, so a 403 is
 //   retried up to three times inside the original deadline (see README.md).
+// - The tracking page links the point holding a parcel to La Poste's locator,
+//   `localiser.laposte.fr/{idPoint}`, which redirects to the point's page. That
+//   page carries the point's record, address included, as JSON in
+//   `Yext["profile"]`; `meta.id` repeats the point's id.
 const TRACKING_API = 'https://www.laposte.fr/ssu/sun/back/suivi-unifie';
 const TRACKING_PAGE = 'https://www.laposte.fr/outils/suivre-vos-envois';
+const LOCATOR = 'https://localiser.laposte.fr';
 const TIMEZONE = 'Europe/Paris';
 const DEFAULT_TIMEOUT_MS = 15_000;
+/** The locator answers from a cache within a fraction of a second. */
+const ADDRESS_TIMEOUT_MS = 3_000;
+/** Points whose address a tracker remembers: a waiting parcel is looked up again and again. */
+const MAX_REMEMBERED_POINTS = 500;
 const MAX_RESPONSE_BYTES = 2_000_000;
 const MAX_EVENTS_TO_RETURN = 100;
 /** The provider's "unknown shipment" return code. */
@@ -116,7 +125,36 @@ export function laPosteTrackingApiUrl(trackingNumber) {
     url.searchParams.set('lang', 'fr');
     return url.toString();
 }
+/**
+ * The street and town of the point a locator page describes, a line each, if it is the
+ * requested one. Its phone, opening hours, services and coordinates are not read.
+ */
+function pointAddress(html, id) {
+    const marker = 'Yext["profile"] = ';
+    const start = html.indexOf(marker);
+    const end = start < 0 ? -1 : html.indexOf('; return Yext;', start);
+    if (end < 0)
+        return '';
+    let profile;
+    try {
+        profile = JSON.parse(html.slice(start + marker.length, end));
+    }
+    catch {
+        return '';
+    }
+    if (!isRecord(profile) || !isRecord(profile.meta) || clean(profile.meta.id, 40) !== id || !isRecord(profile.address))
+        return '';
+    const street = clean(profile.address.line1, 120);
+    const city = clean(profile.address.city, 80);
+    if (!street || !city)
+        return '';
+    return `${street}\n${[clean(profile.address.postalCode, 16), city].filter(Boolean).join(' ')}`;
+}
 export function parseLaPosteTrackingResponse(payload, trackingNumber) {
+    return parseShipment(payload, trackingNumber).result;
+}
+/** `point` is the locator id of the pickup point the result names, else empty. */
+function parseShipment(payload, trackingNumber) {
     const requested = normalizeLaPosteTrackingNumber(trackingNumber);
     if (!Array.isArray(payload) || payload.length === 0) {
         throw new SchemaError('La Poste', 'La Poste returned an invalid tracking response');
@@ -180,13 +218,15 @@ export function parseLaPosteTrackingResponse(payload, trackingNumber) {
     const shipped = clean(shipment.idShip, 64).toLocaleUpperCase('en-US');
     // The merchant La Poste shows on the tracking page. Recipient blocks stay unread.
     const sender = clean(context.merchantName, 200);
-    // The post office, locker or shop holding the parcel; only its name is read.
+    // The post office, locker or shop holding the parcel: its name, and its id
+    // on La Poste's locator, which gives its address.
     const removal = isRecord(context.removalPoint) ? context.removalPoint : {};
     const pickupPoint = latest?.stage === 'ready_for_pickup' && clean(removal.type, 20) ? clean(removal.name, 200) : '';
+    const point = clean(removal.idPoint, 40);
     const partner = isRecord(context.partner) ? context.partner : {};
     const deliveryCarrier = carrierIdFromPartner(clean(partner.name, 80), clean(partner.url, 2048));
     const deliveryNumber = clean(partner.reference, 64).toUpperCase();
-    return {
+    const result = {
         status: eventStatus(latestGroup, latestCode, latestLabel, events.length > 0),
         // The status vocabulary has no pickup or customs value; without the stage
         // the sync would re-read the sentence and fall back to "out for delivery".
@@ -207,12 +247,15 @@ export function parseLaPosteTrackingResponse(payload, trackingNumber) {
         } : {}),
         events,
     };
+    return { result, point: pickupPoint && /^[A-Za-z0-9]{1,20}$/.test(point) ? point : '' };
 }
 export class LaPosteTracker {
     timeoutMs;
     fetcher;
     recorder;
     userAgent;
+    /** The locator's page for a point is large and its address does not change. */
+    addresses = new Map();
     constructor(options = {}) {
         this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
@@ -241,7 +284,14 @@ export class LaPosteTracker {
                 maxBytes: MAX_RESPONSE_BYTES,
                 fetcher: this.fetcher,
             });
-            return parseLaPosteTrackingResponse(parseJsonBytes(bytes, 'La Poste'), normalized);
+            const { result, point } = parseShipment(parseJsonBytes(bytes, 'La Poste'), normalized);
+            // The feed names the point holding the parcel without its address, which the locator adds.
+            if (point) {
+                const address = await this.pointAddress(point, signal, deadline - performance.now());
+                if (address)
+                    result.pickup_point = `${result.pickup_point}\n${address}`;
+            }
+            return result;
         };
         // La Poste's edge answers single lookups with an HTTP 403 "Site indisponible
         // - Incident en cours" page while another parcel, or the same one a moment
@@ -268,6 +318,43 @@ export class LaPosteTracker {
             { ...retry },
         ]);
     }
+    /**
+     * The point's street and town, or nothing: the parcel is found, and its pickup point keeps its
+     * name without them. The request gets at most half of what is left, so the result still has
+     * time to return.
+     */
+    async pointAddress(id, signal, remainingMs) {
+        const known = this.addresses.get(id);
+        if (known)
+            return known;
+        const timeoutMs = Math.floor(Math.min(ADDRESS_TIMEOUT_MS, remainingMs / 2));
+        if (timeoutMs < 1)
+            return '';
+        try {
+            const { bytes } = await fetchBounded(`${LOCATOR}/${encodeURIComponent(id)}`, {
+                signal,
+                headers: { Accept: 'text/html', 'Accept-Language': 'fr-FR,fr;q=0.9', 'User-Agent': this.userAgent },
+            }, {
+                provider: 'La Poste locator',
+                timeoutMs,
+                maxBytes: MAX_RESPONSE_BYTES,
+                // The point's id redirects to its page, named after its town.
+                redirect: 'follow',
+                fetcher: this.fetcher,
+            });
+            const address = pointAddress(decodeText(bytes), id);
+            if (address) {
+                if (this.addresses.size >= MAX_REMEMBERED_POINTS)
+                    this.addresses.delete(this.addresses.keys().next().value);
+                this.addresses.set(id, address);
+            }
+            return address;
+        }
+        catch {
+            signal.throwIfAborted();
+            return '';
+        }
+    }
 }
 export const adapter = (environment) => {
     const tracker = new LaPosteTracker({

package/dist/carriers/swiss-post/adapter.d.ts

@@ -6,6 +6,17 @@ export interface SwissPostOptions {
     fetcher?: typeof fetch;
 }
 export declare function swissPostExpectedDelivery(item: JsonObject): string | null;
+/**
+ * The site number of the office or My Post 24 terminal holding the parcel, from its pickup
+ * notice, else empty. The tracker reads the arrival office first, as its own page does.
+ */
+export declare function swissPostPickupOffice(item: JsonObject): string;
+/**
+ * The site record's name, then its street and its town on their own lines, as the pickup
+ * notice shows them, if it is the requested site. A street that repeats the name, as a
+ * terminal's can, is left out; without a town the name stands alone.
+ */
+export declare function swissPostPickupPoint(office: unknown, site: string): string;
 export declare function parseSwissPostShipment(item: JsonObject, rawEvents: unknown[], translations?: Record<string, string>): CarrierResult;
 export declare class SwissPostTracker {
     #private;
@@ -14,5 +25,7 @@ export declare class SwissPostTracker {
     /** Cached for the process: the table is large, static, and shared by every lookup. */
     loadTranslations(fetcher: typeof fetch, budget?: LookupBudget): Promise<Record<string, string>>;
     fetch(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;
+    /** The pickup point, or nothing: the parcel is found without it. Only the caller's cancellation ends the lookup. */
+    private pickupPoint;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/swiss-post/adapter.js

@@ -14,8 +14,8 @@ const API_BASE = 'https://service.post.ch/ekp-web/api';
 const TRANSLATIONS_URL = 'https://service.post.ch/ekp-web/core/rest/translations/en/shipment-text-messages';
 const PROVIDER = 'Swiss Post';
 const REQUEST_TIMEOUT_MS = 10_000;
-/** The user, search, result, event and translation calls, each at its own bound. */
-const DEFAULT_BUDGET_MS = 5 * REQUEST_TIMEOUT_MS;
+/** The user, search, result, event, translation and pickup office calls, each at its own bound. */
+const DEFAULT_BUDGET_MS = 6 * REQUEST_TIMEOUT_MS;
 /** A request's own timer can fire a few milliseconds before the budget's clock runs out. */
 const BUDGET_SLACK_MS = 5;
 const HEADERS = {
@@ -146,6 +146,33 @@ function eventLocation(event) {
         return country && country !== 'ZZ' ? country : postcode;
     return [city, postcode].filter(Boolean).join(' ').slice(0, 160);
 }
+/**
+ * The site number of the office or My Post 24 terminal holding the parcel, from its pickup
+ * notice, else empty. The tracker reads the arrival office first, as its own page does.
+ */
+export function swissPostPickupOffice(item) {
+    const avis = isRecord(item.avis) ? item.avis : {};
+    const office = text(avis.arrivalPostOfficeZip, 20) || text(avis.deliveryPostOfficeZip, 20);
+    return /^\d{6}$/.test(office) ? office : '';
+}
+/**
+ * The site record's name, then its street and its town on their own lines, as the pickup
+ * notice shows them, if it is the requested site. A street that repeats the name, as a
+ * terminal's can, is left out; without a town the name stands alone.
+ */
+export function swissPostPickupPoint(office, site) {
+    if (!isRecord(office) || text(office.zip, 20) !== site)
+        return '';
+    const name = text(office.description, 120);
+    if (!name)
+        return '';
+    const postcode = text(office.zip4, 10);
+    const town = text(office.city, 80);
+    if (!/^\d{4}$/.test(postcode) || !town)
+        return name;
+    const street = [text(office.street, 120), text(office.streetNumber, 20)].filter(Boolean).join(' ');
+    return [name, street !== name && street, `${postcode} ${town}`].filter(Boolean).join('\n');
+}
 /**
  * Local ordering policy: event timestamps are read only to sort. Values without
  * an offset are treated as UTC for that comparison, which keeps the ordering
@@ -332,7 +359,25 @@ export class SwissPostTracker {
             }
         }
         const translations = events.length > 0 ? await this.loadTranslations(fetcher, budget) : {};
-        return parseSwissPostShipment(item, events, translations);
+        const result = parseSwissPostShipment(item, events, translations);
+        // The pickup notice names the site holding the parcel; that site's record gives its name and address.
+        const office = result.current_stage === 'ready_for_pickup' ? swissPostPickupOffice(item) : '';
+        if (office) {
+            const point = await this.pickupPoint(fetcher, headers, office, budget, context.signal);
+            if (point)
+                result.pickup_point = point;
+        }
+        return result;
+    }
+    /** The pickup point, or nothing: the parcel is found without it. Only the caller's cancellation ends the lookup. */
+    async pickupPoint(fetcher, headers, office, budget, signal) {
+        try {
+            return swissPostPickupPoint(await this.readJson(fetcher, `${API_BASE}/autocomplete/postoffice/id/${encodeURIComponent(office)}`, { headers }, budget), office);
+        }
+        catch {
+            signal?.throwIfAborted();
+            return '';
+        }
     }
 }
 export const adapter = (environment) => {

package/dist/carriers/swiss-post/carrier.json

@@ -29,6 +29,7 @@
     "history",
     "location",
     "eta",
+    "pickup_point",
     "provider_code",
     "weight",
     "dimensions",
@@ -43,6 +44,7 @@
       "location",
       "eta",
       "eta_window",
+      "pickup_point",
       "weight",
       "dimensions",
       "delivered_at",
@@ -57,6 +59,7 @@
       "history",
       "location",
       "eta",
+      "pickup_point",
       "provider_code",
       "weight",
       "dimensions",

package/dist/core/catalog/eventIdentity.js

@@ -1,10 +1,11 @@
+import { sameInstantIdentityPolicy as aliexpress } from '../../carriers/aliexpress/app.js';
 import { sameInstantIdentityPolicy as australiaPost } from '../../carriers/australia-post/app.js';
 import { sameInstantIdentityPolicy as dpd } from '../../carriers/dpd/app.js';
 import { sameInstantIdentityPolicy as indiaPost } from '../../carriers/india-post/app.js';
 import { sameInstantIdentityPolicy as ups } from '../../carriers/ups/app.js';
 import { sameInstantIdentityPolicy as swissPost } from '../../carriers/swiss-post/app.js';
 import { sameInstantIdentityPolicy as universal } from '../../providers/shared/app.js';
-const policies = new Map([australiaPost, dpd, indiaPost, ups, swissPost, universal].map((policy) => [policy.sourceCarrierId, policy]));
+const policies = new Map([aliexpress, australiaPost, dpd, indiaPost, ups, swissPost, universal].map((policy) => [policy.sourceCarrierId, policy]));
 /** Unlisted sources cannot identify a reworded scan by its instant alone. */
 export function sameInstantIdentityPolicy(sourceCarrierId, options = {}) {
     const policy = policies.get(sourceCarrierId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-parcel-scraper",
-  "version": "0.49.0-main.523",
+  "version": "0.49.0-main.526",
   "description": "Self-hosted parcel tracking: carrier detection, dedicated scrapers and optional universal providers.",
   "type": "module",
   "license": "Apache-2.0",