@voyant-travel/catalog 0.117.2

package/dist/search/rerank.test.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { rerank } from "./rerank.js";
+const hit = (id, score) => ({
+    id,
+    score,
+    document: { id, fields: {} },
+});
+const baseResults = {
+    hits: [hit("a", 100), hit("b", 90), hit("c", 80)],
+    total: 3,
+};
+describe("rerank", () => {
+    it("resorts head by live price ascending", async () => {
+        const livePrice = async () => new Map([
+            ["a", { amount: 300, currency: "EUR", source: "live" }],
+            ["b", { amount: 100, currency: "EUR", source: "live" }],
+            ["c", { amount: 200, currency: "EUR", source: "live" }],
+        ]);
+        const reranked = await rerank(baseResults, livePrice, { market: "default", currency: "EUR" }, { topN: 3 });
+        expect(reranked.hits.map((h) => h.id)).toEqual(["b", "c", "a"]);
+    });
+    it("places stale fallbacks after live results", async () => {
+        const livePrice = async () => new Map([
+            ["a", { amount: 200, currency: "EUR", source: "live" }],
+            ["b", { amount: 100, currency: "EUR", source: "stale" }],
+            ["c", { amount: 50, currency: "EUR", source: "live" }],
+        ]);
+        const reranked = await rerank(baseResults, livePrice, { market: "default", currency: "EUR" }, { topN: 3 });
+        // Live hits sort by price (c=50, a=200), then stale hits (b=100).
+        expect(reranked.hits.map((h) => h.id)).toEqual(["c", "a", "b"]);
+    });
+    it("retains hits with no live price unless dropOnLiveMiss is set", async () => {
+        const livePrice = async () => new Map([["a", { amount: 100, currency: "EUR", source: "live" }]]);
+        const keepDefault = await rerank(baseResults, livePrice, { market: "default", currency: "EUR" }, { topN: 3 });
+        expect(keepDefault.hits.map((h) => h.id)).toContain("b");
+        expect(keepDefault.hits.map((h) => h.id)).toContain("c");
+        const dropped = await rerank(baseResults, livePrice, { market: "default", currency: "EUR" }, { topN: 3, dropOnLiveMiss: true });
+        expect(dropped.hits.map((h) => h.id)).toEqual(["a"]);
+    });
+    it("returns un-reranked results when the live function throws", async () => {
+        const livePrice = async () => {
+            throw new Error("upstream timeout");
+        };
+        const reranked = await rerank(baseResults, livePrice, {
+            market: "default",
+            currency: "EUR",
+        });
+        expect(reranked.hits.map((h) => h.id)).toEqual(["a", "b", "c"]);
+    });
+    it("preserves the indexer-ranked tail beyond topN", async () => {
+        const longResults = {
+            hits: [hit("a", 100), hit("b", 90), hit("c", 80), hit("d", 70), hit("e", 60)],
+            total: 5,
+        };
+        const livePrice = async (ids) => new Map(ids.map((id) => [id, { amount: 100, currency: "EUR", source: "live" }]));
+        const reranked = await rerank(longResults, livePrice, { market: "default", currency: "EUR" }, { topN: 2 });
+        // Tail (c, d, e) keeps its original order.
+        expect(reranked.hits.slice(2).map((h) => h.id)).toEqual(["c", "d", "e"]);
+    });
+});

package/dist/search/routes.d.ts

@@ -0,0 +1,144 @@
+import type { HonoModule } from "@voyant-travel/hono/module";
+import type { Context, Hono as HonoApp } from "hono";
+import { z } from "zod";
+import type { IndexerAdapter, IndexerSlice, SearchFilter, SearchRequest, SearchResults, SearchSortOption } from "../indexer/contract.js";
+declare const searchProjectionSchema: z.ZodEnum<{
+    raw: "raw";
+    "storefront-card": "storefront-card";
+}>;
+declare const catalogSearchBodySchema: z.ZodObject<{
+    vertical: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        keyword: "keyword";
+        hybrid: "hybrid";
+        semantic: "semantic";
+    }>>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        "price-asc": "price-asc";
+        relevance: "relevance";
+        "price-desc": "price-desc";
+        "departure-asc": "departure-asc";
+        newest: "newest";
+    }>>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        raw: "raw";
+        "storefront-card": "storefront-card";
+    }>>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodType<SearchFilter, unknown, z.core.$ZodTypeInternals<SearchFilter, unknown>>>>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    alpha: z.ZodOptional<z.ZodNumber>;
+    distance_threshold: z.ZodOptional<z.ZodNumber>;
+    query_embedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    market: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CatalogSearchBody = z.infer<typeof catalogSearchBodySchema>;
+export type CatalogSearchProjection = z.infer<typeof searchProjectionSchema>;
+export type CatalogSearchSort = SearchSortOption;
+export interface StorefrontCatalogCard {
+    id: string;
+    name: string | null;
+    slug: string | null;
+    primaryCategory: StorefrontCatalogCardTaxon | null;
+    media: {
+        thumbnailUrl: string | null;
+        coverMediaUrl: string | null;
+    };
+    priceFrom: {
+        amountCents: number;
+        currency: string | null;
+        originalAmountCents: number | null;
+    } | null;
+    offerBadges: StorefrontCatalogCardOffer[];
+    departures: {
+        upcomingCount: number | null;
+        nextDepartureAt: string | null;
+        nextDepartureDate: string | null;
+        months: string[];
+        dates: string[];
+    };
+    destinations: {
+        regions: string[];
+        countries: string[];
+        cities: string[];
+        ids: string[];
+        slugs: string[];
+    };
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    } | null;
+}
+export interface StorefrontCatalogCardTaxon {
+    id: string | null;
+    name: string | null;
+    slug: string | null;
+}
+export interface StorefrontCatalogCardOffer {
+    id: string | null;
+    name: string | null;
+    discountKind: string | null;
+    discountPercent: number | null;
+    discountAmountCents: number | null;
+    minPax?: number | null;
+}
+export interface CatalogSearchRuntime {
+    indexer?: IndexerAdapter;
+    /**
+     * Template-owned embedding provider. Kept intentionally unknown so
+     * deployments can decide whether semantic search is enabled.
+     */
+    embeddings?: unknown;
+    defaultScope: {
+        locale: string;
+        audience: IndexerSlice["audience"];
+        market: string;
+    };
+}
+export interface CatalogSearchExecuteInput {
+    c: Context;
+    adapter: IndexerAdapter;
+    embeddings?: unknown;
+    slice: IndexerSlice;
+    request: SearchRequest;
+}
+export interface CatalogSearchFallbackInput extends CatalogSearchExecuteInput {
+    error: unknown;
+}
+export interface CatalogSearchRoutesOptions {
+    resolveRuntime(c: Context): CatalogSearchRuntime;
+    /**
+     * Optional semantic/hybrid executor. Templates that use
+     * `@voyant-travel/catalog/search/semantic` should pass `executeSemanticSearch` here.
+     * Without this hook, the route delegates directly to `adapter.search`.
+     */
+    executeSearch?(input: CatalogSearchExecuteInput): Promise<SearchResults>;
+    /**
+     * Retry semantic/hybrid requests as keyword when embedding generation or
+     * vector search fails. Defaults to true to preserve the operator starter's
+     * "best available search mode" behavior.
+     */
+    fallbackToKeywordOnSearchError?: boolean | ((input: CatalogSearchFallbackInput) => boolean);
+    /** Public route audience. Defaults to the customer projection. */
+    publicAudience?: IndexerSlice["audience"];
+    /** Admin route audience. Defaults to the runtime default scope audience. */
+    adminAudience?: IndexerSlice["audience"];
+    indexerUnavailableMessage?: string;
+}
+export type CatalogSearchSurface = "admin" | "public";
+export interface CatalogSearchRoutesWithSurfaceOptions extends CatalogSearchRoutesOptions {
+    surface: CatalogSearchSurface;
+}
+export declare function createCatalogSearchRoutes(options: CatalogSearchRoutesWithSurfaceOptions): HonoApp;
+export declare function createCatalogSearchHonoModule(options: CatalogSearchRoutesOptions): HonoModule;
+export declare function mountCatalogSearchRoutes(hono: HonoApp, options: CatalogSearchRoutesOptions): void;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/search/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/search/routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,MAAM,CAAA;AAEpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,YAAY,EAEZ,aAAa,EACb,aAAa,EACb,gBAAgB,EACjB,MAAM,wBAAwB,CAAA;AAI/B,QAAA,MAAM,sBAAsB;;;EAAqC,CAAA;AA8BjE,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC5E,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAA;AAEhD,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,eAAe,EAAE,0BAA0B,GAAG,IAAI,CAAA;IAClD,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;QAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;KAC7B,CAAA;IACD,SAAS,EAAE;QACT,WAAW,EAAE,MAAM,CAAA;QACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACvB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;KACnC,GAAG,IAAI,CAAA;IACR,WAAW,EAAE,0BAA0B,EAAE,CAAA;IACzC,UAAU,EAAE;QACV,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;QAC5B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;QAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;QAChC,MAAM,EAAE,MAAM,EAAE,CAAA;QAChB,KAAK,EAAE,MAAM,EAAE,CAAA;KAChB,CAAA;IACD,YAAY,EAAE;QACZ,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,SAAS,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,EAAE,MAAM,EAAE,CAAA;QAChB,GAAG,EAAE,MAAM,EAAE,CAAA;QACb,KAAK,EAAE,MAAM,EAAE,CAAA;KAChB,CAAA;IACD,WAAW,EAAE;QACX,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;KAClB,GAAG,IAAI,CAAA;CACT;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,YAAY,EAAE;QACZ,MAAM,EAAE,MAAM,CAAA;QACd,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,CAAA;QAClC,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,MAAM,WAAW,yBAAyB;IACxC,CAAC,EAAE,OAAO,CAAA;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,MAAM,WAAW,0BAA2B,SAAQ,yBAAyB;IAC3E,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,oBAAoB,CAAA;IAChD;;;;OAIG;IACH,aAAa,CAAC,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IACxE;;;;OAIG;IACH,8BAA8B,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,0BAA0B,KAAK,OAAO,CAAC,CAAA;IAC3F,kEAAkE;IAClE,cAAc,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,CAAA;IACzC,4EAA4E;IAC5E,aAAa,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,CAAA;IACxC,yBAAyB,CAAC,EAAE,MAAM,CAAA;CACnC;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,QAAQ,CAAA;AAErD,MAAM,WAAW,qCAAsC,SAAQ,0BAA0B;IACvF,OAAO,EAAE,oBAAoB,CAAA;CAC9B;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qCAAqC,GAAG,OAAO,CAEjG;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,0BAA0B,GAAG,UAAU,CAM7F;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,0BAA0B,GAAG,IAAI,CAGjG"}

package/dist/search/routes.js

@@ -0,0 +1,288 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { z } from "zod";
+const searchModeSchema = z.enum(["keyword", "semantic", "hybrid"]);
+const searchSortSchema = z.enum(["relevance", "price-asc", "price-desc", "departure-asc", "newest"]);
+const searchProjectionSchema = z.enum(["raw", "storefront-card"]);
+const searchFilterSchema = z.lazy(() => z.union([
+    z.object({
+        kind: z.literal("eq"),
+        field: z.string().min(1),
+        value: z.union([z.string(), z.number(), z.boolean()]),
+    }),
+    z.object({
+        kind: z.literal("in"),
+        field: z.string().min(1),
+        values: z.array(z.union([z.string(), z.number()])),
+    }),
+    z.object({
+        kind: z.literal("range"),
+        field: z.string().min(1),
+        gte: z.number().optional(),
+        lte: z.number().optional(),
+    }),
+    z.object({
+        kind: z.literal("and"),
+        clauses: z.array(searchFilterSchema),
+    }),
+    z.object({
+        kind: z.literal("or"),
+        clauses: z.array(searchFilterSchema),
+    }),
+]));
+const catalogSearchBodySchema = z.object({
+    vertical: z.string().min(1).optional(),
+    query: z.string().optional(),
+    mode: searchModeSchema.optional(),
+    sort: searchSortSchema.optional(),
+    projection: searchProjectionSchema.optional(),
+    filters: z.array(searchFilterSchema).optional(),
+    facets: z
+        .array(z.object({ field: z.string().min(1), limit: z.number().int().positive().optional() }))
+        .optional(),
+    pagination: z
+        .object({
+        limit: z.number().int().positive().optional(),
+        cursor: z.string().optional(),
+    })
+        .optional(),
+    alpha: z.number().optional(),
+    distance_threshold: z.number().optional(),
+    query_embedding: z.array(z.number()).optional(),
+    market: z.string().min(1).optional(),
+    locale: z.string().min(1).optional(),
+});
+export function createCatalogSearchRoutes(options) {
+    return new Hono().post("/search", async (c) => handleSearch(c, options));
+}
+export function createCatalogSearchHonoModule(options) {
+    return {
+        module: { name: "catalog" },
+        adminRoutes: createCatalogSearchRoutes({ ...options, surface: "admin" }),
+        publicRoutes: createCatalogSearchRoutes({ ...options, surface: "public" }),
+    };
+}
+export function mountCatalogSearchRoutes(hono, options) {
+    hono.route("/v1/admin/catalog", createCatalogSearchRoutes({ ...options, surface: "admin" }));
+    hono.route("/v1/public/catalog", createCatalogSearchRoutes({ ...options, surface: "public" }));
+}
+async function handleSearch(c, options) {
+    const body = await parseJsonBody(c, catalogSearchBodySchema);
+    if (!body.vertical)
+        return c.json({ error: "vertical is required" }, 400);
+    const runtime = options.resolveRuntime(c);
+    const indexer = runtime.indexer;
+    if (!indexer) {
+        return c.json({
+            error: options.indexerUnavailableMessage ??
+                "Search indexer is not configured (missing TYPESENSE_HOST)",
+        }, 503);
+    }
+    const requestedMode = body.mode ?? "hybrid";
+    const mode = shouldUseEmbeddingMode(requestedMode) && !runtime.embeddings && !body.query_embedding
+        ? "keyword"
+        : requestedMode;
+    const slice = {
+        vertical: body.vertical,
+        locale: body.locale ?? runtime.defaultScope.locale,
+        audience: resolveAudience(options, runtime),
+        market: body.market ?? runtime.defaultScope.market,
+    };
+    const request = buildSearchRequest(body, mode);
+    try {
+        const { results, responseMode } = await executeWithKeywordFallback(c, options, {
+            adapter: indexer,
+            embeddings: runtime.embeddings,
+            slice,
+            request,
+        });
+        return c.json({
+            vertical: body.vertical,
+            mode: responseMode,
+            total: results.total,
+            hits: results.hits,
+            cards: body.projection === "storefront-card"
+                ? results.hits.map((hit) => projectStorefrontCatalogCard(hit.document))
+                : undefined,
+            facets: results.facets ?? {},
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+}
+function resolveAudience(options, runtime) {
+    if (options.surface === "public")
+        return options.publicAudience ?? "customer";
+    return options.adminAudience ?? runtime.defaultScope.audience;
+}
+function buildSearchRequest(body, mode) {
+    return {
+        query: body.query ?? "",
+        mode,
+        sort: body.sort,
+        filters: body.filters,
+        facets: body.facets,
+        pagination: body.pagination,
+        alpha: body.alpha,
+        distance_threshold: body.distance_threshold,
+        query_embedding: body.query_embedding,
+    };
+}
+async function executeWithKeywordFallback(c, options, input) {
+    const executeSearch = options.executeSearch ?? defaultExecuteSearch;
+    const executeInput = { c, ...input };
+    try {
+        return {
+            results: await executeSearch(executeInput),
+            responseMode: input.request.mode,
+        };
+    }
+    catch (error) {
+        if (!shouldRetryAsKeyword(options, executeInput, error))
+            throw error;
+        const keywordRequest = {
+            ...input.request,
+            mode: "keyword",
+            query_embedding: undefined,
+        };
+        return {
+            results: await executeSearch({ ...executeInput, request: keywordRequest }),
+            responseMode: "keyword",
+        };
+    }
+}
+function shouldRetryAsKeyword(options, input, error) {
+    if (!shouldUseEmbeddingMode(input.request.mode))
+        return false;
+    const fallback = options.fallbackToKeywordOnSearchError ?? true;
+    if (typeof fallback === "function")
+        return fallback({ ...input, error });
+    return fallback;
+}
+function shouldUseEmbeddingMode(mode) {
+    return mode === "semantic" || mode === "hybrid";
+}
+async function defaultExecuteSearch(input) {
+    return input.adapter.search(input.slice, input.request);
+}
+function projectStorefrontCatalogCard(document) {
+    const fields = document.fields;
+    const priceAmount = numberField(fields, "priceFromAmountCents", "sellAmountCents");
+    const latitude = numberField(fields, "latitude");
+    const longitude = numberField(fields, "longitude");
+    return {
+        id: document.id,
+        name: stringField(fields, "name", "title"),
+        slug: stringField(fields, "slug"),
+        primaryCategory: taxonFromFields(fields),
+        media: {
+            thumbnailUrl: stringField(fields, "thumbnailUrl", "primaryMediaUrl", "coverMediaUrl"),
+            coverMediaUrl: stringField(fields, "coverMediaUrl", "primaryMediaUrl", "thumbnailUrl"),
+        },
+        priceFrom: priceAmount == null
+            ? null
+            : {
+                amountCents: priceAmount,
+                currency: stringField(fields, "priceFromCurrency", "sellCurrency"),
+                originalAmountCents: numberField(fields, "originalPriceFromAmountCents"),
+            },
+        offerBadges: offerBadgesFromFields(fields),
+        departures: {
+            upcomingCount: numberField(fields, "upcomingDepartureCount", "availableDeparturesCount", "availableUnitsTotal"),
+            nextDepartureAt: stringField(fields, "nextDepartureAt"),
+            nextDepartureDate: stringField(fields, "nextDepartureDate"),
+            months: stringArrayField(fields, "departureMonths"),
+            dates: stringArrayField(fields, "departureDates"),
+        },
+        destinations: {
+            regions: stringArrayField(fields, "regions"),
+            countries: stringArrayField(fields, "countries"),
+            cities: stringArrayField(fields, "cities"),
+            ids: stringArrayField(fields, "destinationIds"),
+            slugs: stringArrayField(fields, "destinationSlugs"),
+        },
+        coordinates: latitude == null || longitude == null
+            ? null
+            : {
+                latitude,
+                longitude,
+            },
+    };
+}
+function taxonFromFields(fields) {
+    const id = stringField(fields, "primaryCategoryId", "categoryIds");
+    const name = stringField(fields, "primaryCategoryName", "categories", "categoryNames");
+    const slug = stringField(fields, "primaryCategorySlug", "categorySlugs");
+    if (!id && !name && !slug)
+        return null;
+    return { id, name, slug };
+}
+function offerBadgesFromFields(fields) {
+    const badges = [];
+    if (booleanField(fields, "hasOffer")) {
+        badges.push({
+            id: stringField(fields, "bestOfferId"),
+            name: stringField(fields, "bestOfferName"),
+            discountKind: stringField(fields, "bestOfferDiscountKind"),
+            discountPercent: numberField(fields, "bestOfferDiscountPercent"),
+            discountAmountCents: numberField(fields, "bestOfferDiscountAmountCents"),
+        });
+    }
+    if (booleanField(fields, "hasConditionalOffer")) {
+        badges.push({
+            id: stringField(fields, "conditionalOfferId"),
+            name: stringField(fields, "conditionalOfferName"),
+            discountKind: stringField(fields, "conditionalOfferDiscountKind"),
+            discountPercent: numberField(fields, "conditionalOfferDiscountPercent"),
+            discountAmountCents: numberField(fields, "conditionalOfferDiscountAmountCents"),
+            minPax: numberField(fields, "conditionalOfferMinPax"),
+        });
+    }
+    return badges;
+}
+function stringField(fields, ...keys) {
+    for (const key of keys) {
+        const value = fieldValue(fields, key);
+        if (typeof value === "string" && value.length > 0)
+            return value;
+        if (Array.isArray(value)) {
+            const first = value.find((item) => typeof item === "string" && item.length > 0);
+            if (typeof first === "string")
+                return first;
+        }
+    }
+    return null;
+}
+function stringArrayField(fields, key) {
+    const value = fieldValue(fields, key);
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function numberField(fields, ...keys) {
+    for (const key of keys) {
+        const value = fieldValue(fields, key);
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim().length > 0) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return null;
+}
+function booleanField(fields, key) {
+    const value = fieldValue(fields, key);
+    return value === true || value === "true";
+}
+function fieldValue(fields, key) {
+    if (key in fields)
+        return fields[key];
+    const collectionKey = `${key}[]`;
+    if (collectionKey in fields)
+        return fields[collectionKey];
+    return undefined;
+}

package/dist/search/routes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routes.test.d.ts.map

package/dist/search/routes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.test.d.ts","sourceRoot":"","sources":["../../src/search/routes.test.ts"],"names":[],"mappings":""}