@voyant-travel/storefront 0.120.1

package/dist/service-boundary-sql.js

@@ -0,0 +1,307 @@
+import { sql } from "drizzle-orm";
+export { getStorefrontSlotResourceAvailability, getStorefrontSlotsResourceAvailability, } from "./service-boundary-resource-sql.js";
+function isRowsResult(value) {
+    return (typeof value === "object" && value !== null && Array.isArray(value.rows));
+}
+async function executeBoundaryRows(db, query) {
+    const result = await db.execute(query);
+    return (Array.isArray(result) ? result : isRowsResult(result) ? result.rows : []);
+}
+function sqlList(values) {
+    // agent-quality: raw-sql reviewed -- owner: storefront; callers pass only parameter-bound scalar ids into this SQL fragment.
+    return sql.join(values.map((value) => sql `${value}`), sql `, `);
+}
+function sqlAnd(conditions) {
+    return sql.join([...conditions], sql ` AND `);
+}
+function toNumber(value) {
+    if (value === null)
+        return null;
+    return typeof value === "number" ? value : Number(value);
+}
+function mapSlot(row) {
+    return {
+        id: row.id,
+        productId: row.product_id,
+        itineraryId: row.itinerary_id,
+        optionId: row.option_id,
+        startTimeId: row.start_time_id,
+        dateLocal: row.date_local,
+        startsAt: row.starts_at,
+        endsAt: row.ends_at,
+        timezone: row.timezone,
+        status: row.status,
+        unlimited: row.unlimited,
+        initialPax: toNumber(row.initial_pax),
+        remainingPax: toNumber(row.remaining_pax),
+        remainingResources: toNumber(row.remaining_resources),
+        pastCutoff: row.past_cutoff,
+        tooEarly: row.too_early,
+        nights: toNumber(row.nights),
+        days: toNumber(row.days),
+        startTimeLabel: row.start_time_label,
+        startTimeLocal: row.start_time_local,
+        durationMinutes: toNumber(row.duration_minutes),
+    };
+}
+function buildSlotFilters(filters) {
+    const conditions = [
+        sql `p.status = 'active'`,
+        sql `p.activated = true`,
+        sql `p.visibility = 'public'`,
+    ];
+    if (filters.productId) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; product id is parameter-bound in the public slot filter.
+        conditions.push(sql `s.product_id = ${filters.productId}`);
+    }
+    if (filters.slotId) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; slot id is parameter-bound in the public slot filter.
+        conditions.push(sql `s.id = ${filters.slotId}`);
+    }
+    if (filters.optionId) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; option id is parameter-bound in the public slot filter.
+        conditions.push(sql `s.option_id = ${filters.optionId}`);
+    }
+    if (filters.status) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; slot status is validated by Storefront before binding.
+        conditions.push(sql `s.status = ${filters.status}`);
+    }
+    else if (!filters.includeCancelled) {
+        conditions.push(sql `s.status <> 'cancelled'`);
+    }
+    if (filters.dateFrom) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; dateFrom is schema-validated and parameter-bound.
+        conditions.push(sql `s.date_local >= ${filters.dateFrom}`);
+    }
+    if (filters.dateTo) {
+        // agent-quality: raw-sql reviewed -- owner: storefront; dateTo is schema-validated and parameter-bound.
+        conditions.push(sql `s.date_local <= ${filters.dateTo}`);
+    }
+    return conditions;
+}
+export async function listStorefrontSlots(db, filters = {}) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; public slot reads are filtered by parameter-bound user inputs and public Product flags.
+    sql `
+      SELECT
+        s.id,
+        s.product_id,
+        s.itinerary_id,
+        s.option_id,
+        s.start_time_id,
+        s.date_local,
+        s.starts_at,
+        s.ends_at,
+        s.timezone,
+        s.status,
+        s.unlimited,
+        s.initial_pax,
+        s.remaining_pax,
+        s.remaining_resources,
+        s.past_cutoff,
+        s.too_early,
+        s.nights,
+        s.days,
+        st.label AS start_time_label,
+        st.start_time_local,
+        st.duration_minutes
+      FROM availability_slots s
+      JOIN products p ON p.id = s.product_id
+      LEFT JOIN availability_start_times st ON st.id = s.start_time_id
+      WHERE ${sqlAnd(buildSlotFilters(filters))}
+      ORDER BY s.starts_at ASC
+      LIMIT ${filters.limit ?? 100}
+      OFFSET ${filters.offset ?? 0}
+    `);
+    return rows.map(mapSlot);
+}
+export async function countStorefrontSlots(db, filters = {}) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; count uses the same public slot predicates as listStorefrontSlots.
+    sql `
+      SELECT COUNT(*)::int AS value
+      FROM availability_slots s
+      JOIN products p ON p.id = s.product_id
+      WHERE ${sqlAnd(buildSlotFilters(filters))}
+    `);
+    return Number(rows[0]?.value ?? 0);
+}
+export async function loadStorefrontAvailabilitySlot(db, slotId) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; bootstrap validates a specific parameter-bound Availability slot id.
+    sql `
+      SELECT
+        s.id,
+        s.product_id,
+        s.itinerary_id,
+        s.option_id,
+        s.start_time_id,
+        s.date_local,
+        s.starts_at,
+        s.ends_at,
+        s.timezone,
+        s.status,
+        s.unlimited,
+        s.initial_pax,
+        s.remaining_pax,
+        s.remaining_resources,
+        s.past_cutoff,
+        s.too_early,
+        s.nights,
+        s.days,
+        st.label AS start_time_label,
+        st.start_time_local,
+        st.duration_minutes
+      FROM availability_slots s
+      LEFT JOIN availability_start_times st ON st.id = s.start_time_id
+      WHERE s.id = ${slotId}
+      LIMIT 1
+    `);
+    return rows[0] ? mapSlot(rows[0]) : null;
+}
+export async function listMeetingPointsByProductIds(db, productIds) {
+    const uniqueIds = [...new Set(productIds)].filter(Boolean);
+    if (uniqueIds.length === 0)
+        return new Map();
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; Product location ids are parameter-bound and read-only for public meeting points.
+    sql `
+      SELECT product_id, title
+      FROM product_locations
+      WHERE product_id IN (${sqlList(uniqueIds)})
+      ORDER BY location_type ASC, sort_order ASC, created_at ASC
+    `);
+    const byProduct = new Map();
+    for (const row of rows) {
+        if (!byProduct.has(row.product_id)) {
+            byProduct.set(row.product_id, row.title);
+        }
+    }
+    return byProduct;
+}
+export async function listDefaultItineraryIdsByProductIds(db, productIds) {
+    const uniqueIds = [...new Set(productIds)].filter(Boolean);
+    if (uniqueIds.length === 0)
+        return new Map();
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; Product itinerary ids are parameter-bound and read-only.
+    sql `
+      SELECT product_id, id AS itinerary_id
+      FROM product_itineraries
+      WHERE product_id IN (${sqlList(uniqueIds)})
+        AND is_default = true
+      ORDER BY sort_order ASC, created_at ASC
+    `);
+    return new Map(rows.map((row) => [row.product_id, row.itinerary_id]));
+}
+export async function loadProductPricingFacts(db, productId) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; Product pricing facts are read-only and product id is parameter-bound.
+    sql `
+      SELECT id, sell_currency, sell_amount_cents, capacity_mode
+      FROM products
+      WHERE id = ${productId}
+      LIMIT 1
+    `);
+    const row = rows[0];
+    return row
+        ? {
+            id: row.id,
+            sellCurrency: row.sell_currency,
+            sellAmountCents: toNumber(row.sell_amount_cents),
+            capacityMode: row.capacity_mode,
+        }
+        : null;
+}
+export async function loadProductOptionFacts(db, input) {
+    // agent-quality: raw-sql reviewed -- owner: storefront; optional Product option id is parameter-bound when present.
+    const optionFilter = input.optionId ? sql `AND id = ${input.optionId}` : sql ``;
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; Product option facts are read-only and filters are parameter-bound.
+    sql `
+      SELECT id, name, description
+      FROM product_options
+      WHERE product_id = ${input.productId}
+        AND status = 'active'
+        ${optionFilter}
+      ORDER BY is_default DESC, sort_order ASC, name ASC
+      LIMIT 1
+    `);
+    return rows[0] ?? null;
+}
+export async function listOptionUnitFacts(db, optionId) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; option unit facts are read-only and option id is parameter-bound.
+    sql `
+      SELECT
+        id,
+        name,
+        unit_type,
+        min_age,
+        max_age,
+        occupancy_min,
+        occupancy_max,
+        is_required
+      FROM option_units
+      WHERE option_id = ${optionId}
+        AND is_hidden = false
+      ORDER BY sort_order ASC, name ASC
+    `);
+    return rows.map((row) => ({
+        id: row.id,
+        name: row.name,
+        unitType: row.unit_type,
+        minAge: toNumber(row.min_age),
+        maxAge: toNumber(row.max_age),
+        occupancyMin: toNumber(row.occupancy_min),
+        occupancyMax: toNumber(row.occupancy_max),
+        isRequired: row.is_required,
+    }));
+}
+export async function listItineraryDays(db, itineraryId) {
+    return executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; itinerary id is parameter-bound and rows are read-only.
+    sql `
+      SELECT id, day_number AS "dayNumber", title, description
+      FROM product_days
+      WHERE itinerary_id = ${itineraryId}
+      ORDER BY day_number ASC
+    `);
+}
+export async function listItineraryDayServices(db, dayIds) {
+    const uniqueIds = [...new Set(dayIds)].filter(Boolean);
+    if (uniqueIds.length === 0)
+        return [];
+    return executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; day ids are parameter-bound and service rows are read-only.
+    sql `
+      SELECT
+        id,
+        day_id AS "dayId",
+        name,
+        description,
+        sort_order AS "sortOrder"
+      FROM product_day_services
+      WHERE day_id IN (${sqlList(uniqueIds)})
+      ORDER BY sort_order ASC, created_at ASC
+    `);
+}
+export async function listItineraryDayMedia(db, input) {
+    const uniqueDayIds = [...new Set(input.dayIds)].filter(Boolean);
+    if (uniqueDayIds.length === 0)
+        return [];
+    return executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: storefront; product/day ids are parameter-bound and media rows are read-only.
+    sql `
+      SELECT
+        id,
+        day_id AS "dayId",
+        url,
+        is_cover AS "isCover",
+        sort_order AS "sortOrder"
+      FROM product_media
+      WHERE product_id = ${input.productId}
+        AND day_id IN (${sqlList(uniqueDayIds)})
+      ORDER BY is_cover DESC, sort_order ASC, created_at ASC
+    `);
+}

package/dist/service-departures-core.d.ts

@@ -0,0 +1,41 @@
+import { countStorefrontSlots, listDefaultItineraryIdsByProductIds, listMeetingPointsByProductIds, listStorefrontSlots, type StorefrontSlotResourceAvailability, type StorefrontSlotRow, type StorefrontSlotStatus } from "./service-boundary-sql.js";
+export type SlotResourceAvailability = StorefrontSlotResourceAvailability;
+export type SlotRow = StorefrontSlotRow;
+export type SlotStatus = StorefrontSlotStatus;
+export { countStorefrontSlots as countSlots, listDefaultItineraryIdsByProductIds, listMeetingPointsByProductIds, listStorefrontSlots as listSlots, };
+export declare function normalizeIso(value: Date | string | null | undefined): string | null;
+export declare function normalizeLocalDate(value: Date | string | null | undefined): string | null;
+export declare function buildResourceManifest(resources: SlotResourceAvailability[]): {
+    kinds: {
+        capacity: number;
+        assigned: number;
+        available: number;
+        kind: string;
+    }[];
+    resources: {
+        id: string;
+        kind: string;
+        label: string | null;
+        refType: string | null;
+        refId: string | null;
+        capacity: number;
+        assigned: number;
+        available: number;
+        parentId: string | null;
+        flags: Record<string, unknown>;
+    }[];
+} | null;
+export type StorefrontProductAvailabilityState = "available" | "sold_out" | "closed" | "cancelled" | "on_request" | "past_cutoff" | "too_early" | "unavailable";
+export declare function todayLocalDate(): string;
+export declare function buildAvailabilityState(args: {
+    status: "open" | "closed" | "sold_out" | "cancelled" | "on_request";
+    remaining: number | null;
+    capacity: number | null;
+    pastCutoff: boolean;
+    tooEarly: boolean;
+}): StorefrontProductAvailabilityState;
+export declare function summarizeProductAvailability(departures: Array<{
+    availabilityState: StorefrontProductAvailabilityState;
+    status: "open" | "closed" | "sold_out" | "cancelled" | "on_request";
+}>): StorefrontProductAvailabilityState;
+//# sourceMappingURL=service-departures-core.d.ts.map

package/dist/service-departures-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-departures-core.d.ts","sourceRoot":"","sources":["../src/service-departures-core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mCAAmC,EACnC,6BAA6B,EAC7B,mBAAmB,EACnB,KAAK,kCAAkC,EACvC,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAA;AAElC,MAAM,MAAM,wBAAwB,GAAG,kCAAkC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,iBAAiB,CAAA;AACvC,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAA;AAC7C,OAAO,EACL,oBAAoB,IAAI,UAAU,EAClC,mCAAmC,EACnC,6BAA6B,EAC7B,mBAAmB,IAAI,SAAS,GACjC,CAAA;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,iBAWnE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,iBAUzE;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,wBAAwB,EAAE;;kBAE9B,MAAM;kBAAY,MAAM;mBAAa,MAAM;;;;;;;;;;;;;;;SAuBvF;AAED,MAAM,MAAM,kCAAkC,GAC1C,WAAW,GACX,UAAU,GACV,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,aAAa,GACb,WAAW,GACX,aAAa,CAAA;AAEjB,wBAAgB,cAAc,WAE7B;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAA;IACnE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;CAClB,GAAG,kCAAkC,CAUrC;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,KAAK,CAAC;IAChB,iBAAiB,EAAE,kCAAkC,CAAA;IACrD,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAA;CACpE,CAAC,GACD,kCAAkC,CAwBpC"}

package/dist/service-departures-core.js

@@ -0,0 +1,92 @@
+import { countStorefrontSlots, listDefaultItineraryIdsByProductIds, listMeetingPointsByProductIds, listStorefrontSlots, } from "./service-boundary-sql.js";
+export { countStorefrontSlots as countSlots, listDefaultItineraryIdsByProductIds, listMeetingPointsByProductIds, listStorefrontSlots as listSlots, };
+export function normalizeIso(value) {
+    if (!value) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? String(value) : parsed.toISOString();
+}
+export function normalizeLocalDate(value) {
+    if (!value) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    return String(value).slice(0, 10);
+}
+export function buildResourceManifest(resources) {
+    if (resources.length === 0)
+        return null;
+    const totals = new Map();
+    for (const resource of resources) {
+        const bucket = totals.get(resource.kind) ?? { capacity: 0, assigned: 0, available: 0 };
+        bucket.capacity += resource.capacity;
+        bucket.assigned += resource.assigned;
+        bucket.available += resource.available;
+        totals.set(resource.kind, bucket);
+    }
+    return {
+        kinds: [...totals.entries()].map(([kind, totals]) => ({ kind, ...totals })),
+        resources: resources.map((resource) => ({
+            id: resource.id,
+            kind: resource.kind,
+            label: resource.label,
+            refType: resource.refType,
+            refId: resource.refId,
+            capacity: resource.capacity,
+            assigned: resource.assigned,
+            available: resource.available,
+            parentId: resource.parentId,
+            flags: resource.flags,
+        })),
+    };
+}
+export function todayLocalDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+export function buildAvailabilityState(args) {
+    if (args.status === "cancelled")
+        return "cancelled";
+    if (args.status === "closed")
+        return "closed";
+    if (args.status === "sold_out")
+        return "sold_out";
+    if (args.status === "on_request")
+        return "on_request";
+    if (args.pastCutoff)
+        return "past_cutoff";
+    if (args.tooEarly)
+        return "too_early";
+    if (args.capacity != null && args.remaining === 0)
+        return "sold_out";
+    return "available";
+}
+export function summarizeProductAvailability(departures) {
+    if (departures.some((departure) => departure.availabilityState === "available")) {
+        return "available";
+    }
+    if (departures.some((departure) => departure.availabilityState === "on_request")) {
+        return "on_request";
+    }
+    if (departures.some((departure) => departure.availabilityState === "too_early")) {
+        return "too_early";
+    }
+    if (departures.some((departure) => departure.availabilityState === "past_cutoff")) {
+        return "past_cutoff";
+    }
+    if (departures.some((departure) => departure.availabilityState === "sold_out")) {
+        return "sold_out";
+    }
+    if (departures.some((departure) => departure.availabilityState === "closed")) {
+        return "closed";
+    }
+    if (departures.some((departure) => departure.availabilityState === "cancelled")) {
+        return "cancelled";
+    }
+    return "unavailable";
+}

package/dist/service-departures-extensions.d.ts

@@ -0,0 +1,46 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export declare function getStorefrontProductExtensions(db: PostgresJsDatabase, productId: string, optionId?: string): Promise<{
+    extensions: {
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        selectable: boolean;
+        hasOptions: boolean;
+        refProductId: string | null;
+        thumb: string | null;
+        pricePerPerson: number | null;
+        currencyCode: string;
+        pricingMode: string;
+        defaultQuantity: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+    }[];
+    items: {
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        selectable: boolean;
+        hasOptions: boolean;
+        refProductId: string | null;
+        thumb: string | null;
+        pricePerPerson: number | null;
+        currencyCode: string;
+        pricingMode: string;
+        defaultQuantity: number | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+    }[];
+    details: {
+        [k: string]: {
+            description: string | null;
+            media: {
+                url: string;
+                alt: string | null;
+            }[];
+        };
+    };
+    currencyCode: string;
+}>;
+//# sourceMappingURL=service-departures-extensions.d.ts.map

package/dist/service-departures-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-departures-extensions.d.ts","sourceRoot":"","sources":["../src/service-departures-extensions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AASjE,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGlB"}

package/dist/service-departures-extensions.js

@@ -0,0 +1,81 @@
+import { and, asc, eq } from "drizzle-orm";
+import { productExtrasRef } from "./product-extra-ref.js";
+import { centsToAmount, getPreferredCurrency, resolvePricingContext, } from "./service-departures-pricing-context.js";
+export async function getStorefrontProductExtensions(db, productId, optionId) {
+    const context = await resolvePricingContext(db, productId, optionId);
+    const extras = await db
+        .select({
+        id: productExtrasRef.id,
+        name: productExtrasRef.name,
+        description: productExtrasRef.description,
+        selectionType: productExtrasRef.selectionType,
+        pricingMode: productExtrasRef.pricingMode,
+        pricedPerPerson: productExtrasRef.pricedPerPerson,
+        defaultQuantity: productExtrasRef.defaultQuantity,
+        minQuantity: productExtrasRef.minQuantity,
+        maxQuantity: productExtrasRef.maxQuantity,
+        metadata: productExtrasRef.metadata,
+    })
+        .from(productExtrasRef)
+        .where(and(eq(productExtrasRef.productId, productId), eq(productExtrasRef.active, true)))
+        .orderBy(asc(productExtrasRef.sortOrder), asc(productExtrasRef.name));
+    const priceRuleByExtraId = new Map(context.extraRules
+        .filter((rule) => rule.productExtraId)
+        .map((rule) => [rule.productExtraId, rule]));
+    const extensions = extras.map((extra) => {
+        const metadata = (extra.metadata ?? {});
+        const rule = priceRuleByExtraId.get(extra.id);
+        const pricingMode = rule?.pricingMode ?? (extra.pricedPerPerson ? "per_person" : extra.pricingMode);
+        const amount = centsToAmount(rule?.sellAmountCents);
+        return {
+            id: extra.id,
+            name: extra.name,
+            label: extra.name,
+            required: extra.selectionType === "required",
+            selectable: extra.selectionType !== "unavailable",
+            hasOptions: false,
+            refProductId: typeof metadata.refProductId === "string"
+                ? metadata.refProductId
+                : typeof metadata.productId === "string"
+                    ? metadata.productId
+                    : null,
+            thumb: typeof metadata.thumbUrl === "string" ? metadata.thumbUrl : null,
+            pricePerPerson: pricingMode === "per_person" || extra.pricedPerPerson ? (amount ?? null) : null,
+            currencyCode: getPreferredCurrency(context),
+            pricingMode,
+            defaultQuantity: extra.defaultQuantity ?? null,
+            minQuantity: extra.minQuantity ?? null,
+            maxQuantity: extra.maxQuantity ?? null,
+        };
+    });
+    const details = Object.fromEntries(extras.map((extra) => {
+        const metadata = (extra.metadata ?? {});
+        const media = Array.isArray(metadata.media)
+            ? metadata.media
+                .map((entry) => entry && typeof entry === "object"
+                ? {
+                    url: typeof entry.url === "string"
+                        ? String(entry.url)
+                        : "",
+                    alt: typeof entry.alt === "string"
+                        ? String(entry.alt)
+                        : null,
+                }
+                : null)
+                .filter((value) => Boolean(value?.url))
+            : [];
+        return [
+            extra.id,
+            {
+                description: extra.description ?? null,
+                media,
+            },
+        ];
+    }));
+    return {
+        extensions,
+        items: extensions,
+        details,
+        currencyCode: getPreferredCurrency(context),
+    };
+}