@coras-io/embed 0.1.0

package/dist/core/currency/constants.js

@@ -0,0 +1,101 @@
+export const supportedCurrencies = [
+    "AED",
+    "ALL",
+    "AUD",
+    "CAD",
+    "CHF",
+    "CNY",
+    "DKK",
+    "EUR",
+    "GBP",
+    "HRK",
+    "HUF",
+    "IDR",
+    "ISK",
+    "JPY",
+    "MAD",
+    "MYR",
+    "NOK",
+    "PHP",
+    "PLN",
+    "SEK",
+    "SGD",
+    "THB",
+    "TRY",
+    "USD",
+    "VND",
+];
+export const currencySymbol = {
+    AED: "د.إ",
+    ALL: "L",
+    AUD: "A$",
+    CAD: "C$",
+    CHF: "Fr",
+    CNY: "¥",
+    DKK: "kr",
+    EUR: "€",
+    GBP: "£",
+    HRK: "kn",
+    HUF: "Ft",
+    IDR: "Rp",
+    ISK: "kr",
+    JPY: "¥",
+    MAD: "MAD",
+    MYR: "RM",
+    NOK: "kr",
+    PHP: "₱",
+    PLN: "zł",
+    SEK: "kr",
+    SGD: "S$",
+    THB: "฿",
+    TRY: "TRY",
+    USD: "$",
+    VND: "₫",
+};
+export const currencyName = {
+    AED: "UAE Dirham",
+    ALL: "Albanian Lek",
+    AUD: "Australian Dollar",
+    CAD: "Canadian Dollar",
+    CHF: "Swiss Franc",
+    CNY: "人民币",
+    DKK: "Danske kroner",
+    EUR: "Euro",
+    GBP: "Pound sterling",
+    HRK: "Croatian Kuna",
+    HUF: "Hungarian Forint",
+    IDR: "Indonesian Rupiah",
+    ISK: "Íslensk króna",
+    JPY: "Japanese Yen",
+    MAD: "Moroccan Dirham",
+    MYR: "Ringgit",
+    NOK: "Norsk krone",
+    PHP: "Philippine Peso",
+    PLN: "Złoty",
+    SEK: "Svensk krona",
+    SGD: "Singapore Dollar",
+    THB: "Baht",
+    TRY: "Türk Lirası",
+    USD: "United States Dollar",
+    VND: "Vietnamese Dong",
+};
+export const localeToCurrencyMapping = {
+    "da-DK": "DKK",
+    "de-DE": "EUR",
+    "en-GB": "GBP",
+    "en-IE": "EUR",
+    "en-US": "USD",
+    "es-ES": "EUR",
+    "fr-FR": "EUR",
+    "fr-MA": "MAD",
+    "is-IS": "ISK",
+    "it-IT": "EUR",
+    "ms-MY": "MYR",
+    "nb-NO": "NOK",
+    "pl-PL": "PLN",
+    "pt-PT": "EUR",
+    "sv-SE": "SEK",
+    "th-TH": "THB",
+    "tr-TR": "TRY",
+    "zh-CN": "CNY",
+};

package/dist/core/currency/index.d.ts

@@ -0,0 +1,12 @@
+import { SupportedCurrencies } from "../types/index.js";
+import { allLocales } from "../i18n/locale-codes.js";
+type convertToLocaleCurrencyProps = {
+    value: number;
+    locale: (typeof allLocales)[number];
+    currency: SupportedCurrencies;
+    isSmallestCurrencyUnit?: boolean;
+    maximumFractionDigits?: number;
+    minimumFractionDigits?: number;
+};
+export declare const convertToLocaleCurrency: ({ value, locale, currency, maximumFractionDigits, minimumFractionDigits, isSmallestCurrencyUnit, }: convertToLocaleCurrencyProps) => string;
+export {};

package/dist/core/currency/index.js

@@ -0,0 +1,6 @@
+export const convertToLocaleCurrency = ({ value = 10000, locale = "en-US", currency = "USD", maximumFractionDigits = 2, minimumFractionDigits = 2, isSmallestCurrencyUnit = true, }) => new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currency,
+    maximumFractionDigits: maximumFractionDigits,
+    minimumFractionDigits: minimumFractionDigits,
+}).format(isSmallestCurrencyUnit ? value / 100 : value);

package/dist/core/events.d.ts

@@ -0,0 +1,196 @@
+import type { SeatingChart, SelectableObject } from "@seatsio/seatsio-types";
+import type { PaymentMethodCreateParams, Stripe } from "@stripe/stripe-js";
+import type { components } from "./types/api-schema.js";
+import type { CorasHostEventMap, CorasHostEventName } from "../sdk/types.js";
+import type { PaymentFiatMethodType } from "../components/payment-fiat-method/payment-fiat-method.component.js";
+import type { PhoneCodeSelection } from "../views/payment-page/payment-page.types.js";
+export interface ValueChangedEventDetail {
+    value: unknown;
+    fieldName?: string;
+}
+export interface DateSelectedEventDetail {
+    date: string;
+}
+export interface CalendarMonthChangedEventDetail {
+    date: string;
+}
+export interface OtpCompleteEventDetail {
+    code: string;
+}
+export interface TabChangeEventDetail {
+    tab: string;
+}
+/**
+ * Event detail for selection-changed events.
+ * Contains comma-separated slugs string of selected categories.
+ */
+export type SelectionChangeEventDetail = string;
+export interface GeolocationSelectedEventDetail {
+    latitude: number;
+    longitude: number;
+}
+export interface PaymentTypeSelectedEventDetail {
+    type: "stripe" | "crypto";
+}
+export interface PaymentMethodSelectedEventDetail {
+    method: PaymentFiatMethodType;
+}
+export interface MarketingChangedEventDetail {
+    accepted?: boolean;
+    value?: boolean;
+}
+export interface EmailChangedEventDetail {
+    value: string;
+}
+export interface TermsChangedEventDetail {
+    value: boolean;
+}
+export interface StripeInitializedEventDetail {
+    stripe: Stripe;
+}
+export interface StripeErrorEventDetail {
+    error: unknown;
+}
+export interface CanMakePaymentChangeEventDetail {
+    applePay: boolean;
+    googlePay: boolean;
+}
+export type CardElementType = "cardNumber" | "cardExpiry" | "cardCvc";
+export interface CardValidationChangeEventDetail {
+    isValid: boolean;
+    error: string;
+    elementType: CardElementType;
+}
+export interface PaymentMethodAuthorizedEventDetail {
+    paymentMethod: PaymentMethodCreateParams;
+    event: unknown;
+}
+export interface CodeSubmittedEventDetail {
+    code: string;
+}
+export interface SeatsConfirmedEventDetail {
+    instanceId: string;
+    tickets: components["schemas"]["AttractionTicketRequestSchema"][];
+}
+/**
+ * Internal component-to-page events. These are non-composed and must not reach
+ * the host application.
+ */
+export interface InternalEventMap {
+    "checkout-requested": Record<string, never>;
+    "value-changed": ValueChangedEventDetail;
+    "selection-changed": SelectionChangeEventDetail;
+    "code-selected": PhoneCodeSelection;
+    "phone-code-selected": PhoneCodeSelection;
+    "terms-changed": TermsChangedEventDetail;
+    "email-changed": EmailChangedEventDetail;
+    "marketing-changed": MarketingChangedEventDetail;
+    "date-selected": DateSelectedEventDetail;
+    "calendar-month-changed": CalendarMonthChangedEventDetail;
+    "otp-completed": OtpCompleteEventDetail;
+    "payment-type-selected": PaymentTypeSelectedEventDetail;
+    "payment-method-selected": PaymentMethodSelectedEventDetail;
+    "stripe-initialized": StripeInitializedEventDetail;
+    "stripe-error": StripeErrorEventDetail;
+    "can-make-payment-changed": CanMakePaymentChangeEventDetail;
+    "card-validation-changed": CardValidationChangeEventDetail;
+    "payment-method-authorized": PaymentMethodAuthorizedEventDetail;
+    "auth-cancelled": Record<string, never>;
+    "back-to-email-input": Record<string, never>;
+    "back-to-sms-prompt": Record<string, never>;
+    "send-code": Record<string, never>;
+    "verify-code": CodeSubmittedEventDetail;
+    "resend-email-code": Record<string, never>;
+    "initiate-mfa-enrollment": Record<string, never>;
+    "verify-mfa-enrollment": CodeSubmittedEventDetail;
+    "resend-mfa-code": Record<string, never>;
+    "show-phone-input": Record<string, never>;
+    "phone-changed": ValueChangedEventDetail;
+    "transfer-cancelled": Record<string, never>;
+    "mfa-code-submitted": CodeSubmittedEventDetail;
+    "mfa-resend-requested": Record<string, never>;
+    "seats-io-object-selected": SelectableObject;
+    "seats-io-object-deselected": SelectableObject;
+    "seats-io-orphan-seats-changed": SelectableObject;
+    "seats-io-chart-rendered": SeatingChart;
+    "seats-io-chart-rendering-failed": SeatingChart | Record<string, never>;
+    "seats-io-selection-valid": Record<string, never>;
+    "seats-io-selection-invalid": {
+        violations: string[];
+    };
+    "seats-unavailable": Record<string, never>;
+    "seats-confirmed": SeatsConfirmedEventDetail;
+    "geolocation-selected": GeolocationSelectedEventDetail;
+    "tab-changed": TabChangeEventDetail;
+    "chip-removed": Record<string, never>;
+    "coras-image-load": Record<string, never>;
+    "coras-image-error": Record<string, never>;
+    "dropdown-close-request": Record<string, never>;
+    "dialog-back": Record<string, never>;
+    "dialog-closed": Record<string, never>;
+    "modal-closed": Record<string, never>;
+    "overlay-animation-started": Record<string, never>;
+    "overlay-animation-ended": Record<string, never>;
+}
+export type CorasEventMap = CorasHostEventMap & InternalEventMap;
+export type HostFacingEventName = CorasHostEventName;
+export type InternalEventName = keyof InternalEventMap;
+export type CorasCustomEventMap = {
+    [K in HostFacingEventName]: CustomEvent<CorasEventMap[K]>;
+};
+export type CorasEvent<K extends keyof CorasEventMap> = CustomEvent<CorasEventMap[K]>;
+declare global {
+    interface HTMLElementEventMap {
+        "coras:ready": CorasCustomEventMap["coras:ready"];
+        "coras:navigate": CorasCustomEventMap["coras:navigate"];
+        "coras:state-change": CorasCustomEventMap["coras:state-change"];
+        "coras:reservation-created": CorasCustomEventMap["coras:reservation-created"];
+        "coras:payment-status": CorasCustomEventMap["coras:payment-status"];
+        "coras:error": CorasCustomEventMap["coras:error"];
+    }
+    interface GlobalEventHandlersEventMap {
+        "coras:ready": CorasCustomEventMap["coras:ready"];
+        "coras:navigate": CorasCustomEventMap["coras:navigate"];
+        "coras:state-change": CorasCustomEventMap["coras:state-change"];
+        "coras:reservation-created": CorasCustomEventMap["coras:reservation-created"];
+        "coras:payment-status": CorasCustomEventMap["coras:payment-status"];
+        "coras:error": CorasCustomEventMap["coras:error"];
+    }
+}
+/**
+ * Dispatches a custom event with the specified name and detail.
+ * By default, events bubble through Shadow DOM boundaries (composed: true).
+ *
+ * Use this for host-facing events that should reach the embedding application.
+ * For internal component-to-container events, prefer `fireInternalEvent`.
+ *
+ * @param element - The element to dispatch the event from
+ * @param name - The event name (must be a host-facing event name)
+ * @param detail - The event detail payload
+ * @param options - Optional event configuration overrides
+ * @returns Whether the event was not cancelled via preventDefault()
+ */
+export declare function fireEvent<K extends HostFacingEventName>(element: HTMLElement, name: K, detail: CorasEventMap[K], options?: {
+    bubbles?: boolean;
+    composed?: boolean;
+    cancelable?: boolean;
+}): boolean;
+/**
+ * Dispatches an internal event that should NOT reach the host application.
+ * Events are NOT composed (do not cross Shadow DOM boundaries) by default.
+ *
+ * Use this for component-to-container communication within the widget.
+ * Internal events do not bubble by default. Consumers should listen directly on
+ * the child element or explicitly opt into bubbling for delegated listeners.
+ *
+ * @param element - The element to dispatch the event from
+ * @param name - The event name (must be an internal event key)
+ * @param detail - The event detail payload
+ * @param options - Optional event configuration overrides
+ * @returns Whether the event was not cancelled via preventDefault()
+ */
+export declare function fireInternalEvent<K extends InternalEventName>(element: HTMLElement, name: K, detail: CorasEventMap[K], options?: {
+    bubbles?: boolean;
+    composed?: boolean;
+    cancelable?: boolean;
+}): boolean;

package/dist/core/events.js

@@ -0,0 +1,46 @@
+// ---------------------------------------------------------------------------
+// Typed fire functions
+// ---------------------------------------------------------------------------
+/**
+ * Dispatches a custom event with the specified name and detail.
+ * By default, events bubble through Shadow DOM boundaries (composed: true).
+ *
+ * Use this for host-facing events that should reach the embedding application.
+ * For internal component-to-container events, prefer `fireInternalEvent`.
+ *
+ * @param element - The element to dispatch the event from
+ * @param name - The event name (must be a host-facing event name)
+ * @param detail - The event detail payload
+ * @param options - Optional event configuration overrides
+ * @returns Whether the event was not cancelled via preventDefault()
+ */
+export function fireEvent(element, name, detail, options) {
+    return element.dispatchEvent(new CustomEvent(name, {
+        bubbles: options?.bubbles ?? true,
+        cancelable: options?.cancelable ?? false,
+        composed: options?.composed ?? true,
+        detail,
+    }));
+}
+/**
+ * Dispatches an internal event that should NOT reach the host application.
+ * Events are NOT composed (do not cross Shadow DOM boundaries) by default.
+ *
+ * Use this for component-to-container communication within the widget.
+ * Internal events do not bubble by default. Consumers should listen directly on
+ * the child element or explicitly opt into bubbling for delegated listeners.
+ *
+ * @param element - The element to dispatch the event from
+ * @param name - The event name (must be an internal event key)
+ * @param detail - The event detail payload
+ * @param options - Optional event configuration overrides
+ * @returns Whether the event was not cancelled via preventDefault()
+ */
+export function fireInternalEvent(element, name, detail, options) {
+    return element.dispatchEvent(new CustomEvent(name, {
+        bubbles: options?.bubbles ?? false,
+        cancelable: options?.cancelable ?? false,
+        composed: options?.composed ?? false, // Internal events don't cross Shadow DOM
+        detail,
+    }));
+}

package/dist/core/i18n/date.d.ts

@@ -0,0 +1,7 @@
+import { Locale } from "date-fns";
+import { allLocales } from "./locale-codes.js";
+export declare const localeMapping: Partial<Record<(typeof allLocales)[number], Locale>>;
+export declare const getCalendarLocale: (locale: (typeof allLocales)[number]) => Locale;
+export declare const weekdayNames: (locale: (typeof allLocales)[number]) => (string | undefined)[];
+export declare const formatDate: (date: Date | string, locale: (typeof allLocales)[number], showYear?: boolean) => string;
+export declare const getDateRangeLabel: (startDate: string, endDate: string, locale: (typeof allLocales)[number]) => string | undefined;

package/dist/core/i18n/date.js

@@ -0,0 +1,65 @@
+import { addDays, format, startOfWeek } from "date-fns";
+import { da, de, enGB, enIE, enUS, es, fr, is, it, ms, nb, pl, pt, sv, th, tr, zhCN, } from "date-fns/locale";
+export const localeMapping = {
+    "da-DK": da,
+    "de-DE": de,
+    "en-GB": enGB,
+    "en-IE": enIE,
+    "en-US": enUS,
+    "es-ES": es,
+    "fr-MA": fr,
+    "fr-FR": fr,
+    "is-IS": is,
+    "it-IT": it,
+    "ms-MY": ms,
+    "nb-NO": nb,
+    "pl-PL": pl,
+    "pt-PT": pt,
+    "sv-SE": sv,
+    "th-TH": th,
+    "tr-TR": tr,
+    "zh-CN": zhCN,
+};
+export const getCalendarLocale = (locale) => localeMapping[locale] || enGB;
+export const weekdayNames = (locale) => {
+    const firstDOW = startOfWeek(new Date());
+    const names = Array.from(Array(7)).map((_, i) => format(addDays(firstDOW, i), "EEEEEE", {
+        locale: getCalendarLocale(locale),
+    }));
+    return [...names.slice(1), names[0]];
+};
+export const formatDate = (date, locale, showYear = false) => {
+    if (typeof date === "string") {
+        date = new Date(date);
+    }
+    return Intl.DateTimeFormat(locale, {
+        year: showYear ? "numeric" : undefined,
+        month: "short",
+        day: "numeric",
+    }).format(date);
+};
+export const getDateRangeLabel = (startDate, endDate, locale) => {
+    switch (true) {
+        case startDate === "" && endDate === "":
+            return;
+        case startDate !== "" && endDate === "":
+            return new Date(startDate).getFullYear() !== new Date().getFullYear()
+                ? formatDate(startDate, locale, true)
+                : formatDate(startDate, locale);
+        case startDate === "" && endDate !== "":
+            return new Date(endDate).getFullYear() !== new Date().getFullYear()
+                ? formatDate(endDate, locale, true)
+                : formatDate(endDate, locale);
+        case startDate === endDate &&
+            new Date(startDate).getFullYear() !== new Date().getFullYear():
+            return formatDate(startDate, locale, true);
+        case startDate === endDate:
+            return formatDate(startDate, locale);
+        case new Date(startDate).getFullYear() !== new Date(endDate).getFullYear():
+            return `${formatDate(startDate, locale, true)} - ${formatDate(endDate, locale, true)}`;
+        case new Date(startDate).getMonth() !== new Date(endDate).getMonth():
+            return `${formatDate(startDate, locale)} - ${formatDate(endDate, locale)}`;
+        default:
+            return `${new Date(startDate).getDate()} - ${formatDate(endDate, locale)}`;
+    }
+};

package/dist/core/i18n/locale-codes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The locale code that templates in this source code are written in.
+ */
+export declare const sourceLocale = "en-GB";
+/**
+ * The other locale codes that this application is localized into. Sorted
+ * lexicographically.
+ */
+export declare const targetLocales: readonly ["da-DK", "de-DE", "en-IE", "en-US", "es-ES", "fr-FR", "fr-MA", "is-IS", "it-IT", "ms-MY", "nb-NO", "pl-PL", "pt-PT", "sv-SE", "th-TH", "tr-TR", "zh-CN"];
+/**
+ * All valid project locale codes. Sorted lexicographically.
+ */
+export declare const allLocales: readonly ["da-DK", "de-DE", "en-GB", "en-IE", "en-US", "es-ES", "fr-FR", "fr-MA", "is-IS", "it-IT", "ms-MY", "nb-NO", "pl-PL", "pt-PT", "sv-SE", "th-TH", "tr-TR", "zh-CN"];

package/dist/core/i18n/locale-codes.js

@@ -0,0 +1,52 @@
+// Do not modify this file by hand!
+// Re-generate this file by running lit-localize.
+/**
+ * The locale code that templates in this source code are written in.
+ */
+export const sourceLocale = `en-GB`;
+/**
+ * The other locale codes that this application is localized into. Sorted
+ * lexicographically.
+ */
+export const targetLocales = [
+    `da-DK`,
+    `de-DE`,
+    `en-IE`,
+    `en-US`,
+    `es-ES`,
+    `fr-FR`,
+    `fr-MA`,
+    `is-IS`,
+    `it-IT`,
+    `ms-MY`,
+    `nb-NO`,
+    `pl-PL`,
+    `pt-PT`,
+    `sv-SE`,
+    `th-TH`,
+    `tr-TR`,
+    `zh-CN`,
+];
+/**
+ * All valid project locale codes. Sorted lexicographically.
+ */
+export const allLocales = [
+    `da-DK`,
+    `de-DE`,
+    `en-GB`,
+    `en-IE`,
+    `en-US`,
+    `es-ES`,
+    `fr-FR`,
+    `fr-MA`,
+    `is-IS`,
+    `it-IT`,
+    `ms-MY`,
+    `nb-NO`,
+    `pl-PL`,
+    `pt-PT`,
+    `sv-SE`,
+    `th-TH`,
+    `tr-TR`,
+    `zh-CN`,
+];

package/dist/core/i18n/localization.d.ts

@@ -0,0 +1,5 @@
+export declare const getLocale: (() => string) & {
+    _LIT_LOCALIZE_GET_LOCALE_?: never;
+}, setLocale: ((newLocale: string) => Promise<void>) & {
+    _LIT_LOCALIZE_SET_LOCALE_?: never;
+};

package/dist/core/i18n/localization.js

@@ -0,0 +1,15 @@
+/// <reference types="vite/client" />
+import { configureLocalization } from "@lit/localize";
+import { sourceLocale, targetLocales } from "./locale-codes.js";
+export const { getLocale, setLocale } = configureLocalization({
+    sourceLocale,
+    targetLocales,
+    // Stale chunks vanish after deployment — catch to fall back to source locale
+    // rather than producing unhandled rejections.
+    loadLocale: (locale) => import(`../../locales/${locale}.js`).catch(() => ({ templates: {} })),
+});
+// Prevent full page reload on HMR - accept the module update
+// This is stripped from production builds
+if (import.meta.hot) {
+    import.meta.hot.accept();
+}

package/dist/core/images/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const IMAGE_BASE_URL = "https://static.example.com/images/locations";
+export declare const DEFAULT_LOCATION_IMAGE = "ireland/cork.png";
+export declare const DEFAULT_LOCATION_IMAGE_PARAMS: {
+    auto: string;
+    ar: string;
+    fit: string;
+};

package/dist/core/images/constants.js

@@ -0,0 +1,7 @@
+export const IMAGE_BASE_URL = "https://static.example.com/images/locations";
+export const DEFAULT_LOCATION_IMAGE = "ireland/cork.png";
+export const DEFAULT_LOCATION_IMAGE_PARAMS = {
+    auto: "compress,format",
+    ar: "10:1",
+    fit: "crop",
+};

package/dist/core/images/filters.d.ts

@@ -0,0 +1,28 @@
+import type { components } from "../types/api-schema.js";
+type MediaAsset = components["schemas"]["MediaAssetSchema"];
+/**
+ * Exact pixel sizes the backend still emits from legacy uploads that must never
+ * reach the UI. These are crops created for an old site (banner strips, awkward
+ * letterboxes) and should be filtered at every candidate, not just at the
+ * preset-dict adapter.
+ */
+export declare const BANNED_IMAGE_SIZES: ReadonlySet<string>;
+/** Minimum side length below which we treat an image as unusable. */
+export declare const MIN_IMAGE_RESOLUTION = 400;
+export declare function isBannedSize(width: number, height: number): boolean;
+export declare function isLowResolution(width: number, height: number, min?: number): boolean;
+export declare function isSquareish(width: number, height: number, tolerance?: number): boolean;
+/**
+ * Filter rules for the details-page image carousel.
+ *
+ * Strict pass keeps assets that are landscape and high-resolution. When the
+ * strict pass strips everything (legacy attractions with only small or square
+ * uploads), fall back to the original media — a blurry photo beats an empty
+ * carousel. Banned-dimension filtering does NOT apply here: `MediaAsset[]`
+ * carries source uploads whose dimensions may legitimately match the legacy
+ * crop sizes; banning belongs in the preset-dict adapter.
+ *
+ * Assets missing dimensions are kept defensively — we can't judge them.
+ */
+export declare function filterMediaForGallery(media: MediaAsset[]): MediaAsset[];
+export {};

package/dist/core/images/filters.js

@@ -0,0 +1,51 @@
+/**
+ * Exact pixel sizes the backend still emits from legacy uploads that must never
+ * reach the UI. These are crops created for an old site (banner strips, awkward
+ * letterboxes) and should be filtered at every candidate, not just at the
+ * preset-dict adapter.
+ */
+export const BANNED_IMAGE_SIZES = new Set([
+    "279x213",
+    "288x125",
+    "304x81",
+    "345x237",
+]);
+/** Minimum side length below which we treat an image as unusable. */
+export const MIN_IMAGE_RESOLUTION = 400;
+/** Aspect-ratio tolerance for treating an image as square. */
+const SQUARE_TOLERANCE = 0.05;
+export function isBannedSize(width, height) {
+    return BANNED_IMAGE_SIZES.has(`${width}x${height}`);
+}
+export function isLowResolution(width, height, min = MIN_IMAGE_RESOLUTION) {
+    return Math.min(width, height) < min;
+}
+export function isSquareish(width, height, tolerance = SQUARE_TOLERANCE) {
+    if (!width || !height)
+        return false;
+    return Math.abs(width / height - 1) <= tolerance;
+}
+/**
+ * Filter rules for the details-page image carousel.
+ *
+ * Strict pass keeps assets that are landscape and high-resolution. When the
+ * strict pass strips everything (legacy attractions with only small or square
+ * uploads), fall back to the original media — a blurry photo beats an empty
+ * carousel. Banned-dimension filtering does NOT apply here: `MediaAsset[]`
+ * carries source uploads whose dimensions may legitimately match the legacy
+ * crop sizes; banning belongs in the preset-dict adapter.
+ *
+ * Assets missing dimensions are kept defensively — we can't judge them.
+ */
+export function filterMediaForGallery(media) {
+    const strict = media.filter(({ width, height }) => {
+        if (!width || !height)
+            return true;
+        if (isLowResolution(width, height))
+            return false;
+        if (isSquareish(width, height))
+            return false;
+        return true;
+    });
+    return strict.length > 0 ? strict : media;
+}

package/dist/core/images/helpers.d.ts

@@ -0,0 +1,12 @@
+export type ImageParams = {
+    auto: string;
+    ar: string;
+    fit: string;
+};
+export declare function getLocationImageURL({ baseURL, country, city, imageExtension, params, }: {
+    baseURL: string;
+    country: string;
+    city: string;
+    imageExtension: string;
+    params?: ImageParams;
+}): string;

package/dist/core/images/helpers.js

@@ -0,0 +1,14 @@
+import { DEFAULT_LOCATION_IMAGE, DEFAULT_LOCATION_IMAGE_PARAMS, } from "./constants.js";
+export function getLocationImageURL({ baseURL, country = "", city = "", imageExtension, params = DEFAULT_LOCATION_IMAGE_PARAMS, }) {
+    const urlParams = new URLSearchParams(params).toString();
+    // TODO: improve it
+    if (city && country !== "" && city !== "") {
+        return `${baseURL}/${country}/${city}.${imageExtension}?${urlParams}`;
+    }
+    else if (country !== "" && city === "") {
+        return `${baseURL}/${country}.${imageExtension}?${urlParams}`;
+    }
+    else {
+        return `${baseURL}/${DEFAULT_LOCATION_IMAGE}?${urlParams}`;
+    }
+}