@coras-io/embed 0.1.0

package/dist/core/images/preset-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { components } from "../types/api-schema.js";
+type MediaAsset = components["schemas"]["MediaAssetSchema"];
+/**
+ * Loose record shape covering every preset-dict the API still emits
+ * (`EventImages`, `TourImages`, the generic `{[k: string]: string | null}`
+ * search result variant). The adapter parses keys defensively; unrecognised
+ * keys are ignored.
+ */
+type PresetImages = Record<string, string | string[] | null | undefined>;
+/**
+ * Adapter that lifts the legacy `EventImages` / `TourImages` preset-key dicts
+ * into `MediaAssetSchema[]` so they flow through the same selection pipeline
+ * as fresh `media` arrays.
+ *
+ * Keys match `image_wN_hN: string` (single asset) or `images_wN_hN: string[]`
+ * (asset list). Unknown keys are ignored. Banned legacy sizes are dropped at
+ * the boundary so they never reach selection scoring.
+ *
+ * Backend will deprecate these dicts in Phase E (P-068b); this adapter is
+ * temporary scaffolding for `search-page` and other dict-only call sites.
+ */
+export declare function adaptPresetImages(presets: PresetImages | null | undefined): MediaAsset[];
+export {};

package/dist/core/images/preset-adapter.js

@@ -0,0 +1,52 @@
+import { isBannedSize } from "./filters.js";
+/**
+ * Adapter that lifts the legacy `EventImages` / `TourImages` preset-key dicts
+ * into `MediaAssetSchema[]` so they flow through the same selection pipeline
+ * as fresh `media` arrays.
+ *
+ * Keys match `image_wN_hN: string` (single asset) or `images_wN_hN: string[]`
+ * (asset list). Unknown keys are ignored. Banned legacy sizes are dropped at
+ * the boundary so they never reach selection scoring.
+ *
+ * Backend will deprecate these dicts in Phase E (P-068b); this adapter is
+ * temporary scaffolding for `search-page` and other dict-only call sites.
+ */
+export function adaptPresetImages(presets) {
+    if (!presets)
+        return [];
+    const out = [];
+    for (const [key, value] of Object.entries(presets)) {
+        const dims = parsePresetKey(key);
+        if (!dims)
+            continue;
+        if (isBannedSize(dims.width, dims.height))
+            continue;
+        if (typeof value === "string" && value) {
+            out.push(toMediaAsset(value, dims));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const url of value) {
+                if (typeof url === "string" && url)
+                    out.push(toMediaAsset(url, dims));
+            }
+        }
+    }
+    return out;
+}
+function parsePresetKey(key) {
+    const match = /^images?_w(\d+)_h(\d+)$/.exec(key);
+    if (!match)
+        return null;
+    return { width: Number(match[1]), height: Number(match[2]) };
+}
+function toMediaAsset(url, dims) {
+    return {
+        type: "image",
+        url,
+        width: dims.width,
+        height: dims.height,
+        content_type: null,
+        languages: null,
+    };
+}

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

@@ -0,0 +1,45 @@
+import type { components } from "../types/api-schema.js";
+type MediaAsset = components["schemas"]["MediaAssetSchema"];
+export type ImageSlotName = "card-desktop" | "card-mobile" | "carousel-hero" | "gallery" | "thumbnail";
+export interface SelectOptions {
+    slot: ImageSlotName;
+    /** CSS px width of the slot's container; enables width-aware scoring. */
+    containerWidth?: number;
+    /** Defaults to `globalThis.devicePixelRatio` or 1. */
+    dpr?: number;
+    /** Overrides the slot's preferred aspect ratio. */
+    preferredAspect?: number;
+    /** Overrides the slot's min-resolution floor (px on the short side). */
+    minResolution?: number;
+}
+export interface SelectedImage {
+    url: string;
+    width: number;
+    height: number;
+}
+export interface SelectionResult {
+    primary: SelectedImage;
+    /** Remaining candidates, sorted; useful as an `error` fallback chain. */
+    fallbacks: SelectedImage[];
+}
+/**
+ * Pick the best `MediaAsset` for a slot.
+ *
+ * Selection runs three tiers and stops at the first non-empty result:
+ *   1. Strict — the slot's full rules (min-resolution, aspect filter).
+ *   2. Drop the min-resolution floor; keep the aspect filter.
+ *   3. Drop the aspect filter; accept any candidate with dimensions.
+ *
+ * Returns `null` only when no candidate carries usable dimensions. A small or
+ * off-aspect image beats a blank card; the slot rules are a preference, not a
+ * cliff. Catalog quality is enforced backend-side (see P-068c) — the SDK
+ * degrades gracefully when an attraction was uploaded with sub-spec assets.
+ */
+export declare function selectCorasImage(images: readonly MediaAsset[], options: SelectOptions): SelectionResult | null;
+/**
+ * Filter a list of `MediaAsset` candidates to those eligible for a slot.
+ * Use when you need every passing candidate (e.g. an image carousel), not
+ * just the single best — `selectCorasImage` is the single-pick variant.
+ */
+export declare function filterForSlot(images: readonly MediaAsset[], slot: ImageSlotName, minResolution?: number): MediaAsset[];
+export {};

package/dist/core/images/selection.js

@@ -0,0 +1,125 @@
+const ASPECT_TOLERANCE = 0.08;
+/** Aspect-delta below this counts as "equivalent" for ranking. */
+const ASPECT_TIE = 0.02;
+/** Width-delta below this counts as "equivalent" for ranking. */
+const WIDTH_TIE_PX = 50;
+const SLOTS = {
+    "card-desktop": {
+        preferredAspect: 1,
+        allowedAspects: [1, 4 / 3, 3 / 2],
+        minResolution: 400,
+    },
+    "card-mobile": {
+        preferredAspect: 3 / 2,
+        allowedAspects: [3 / 2, 4 / 3, 16 / 9],
+        minResolution: 400,
+    },
+    "carousel-hero": {
+        preferredAspect: 3 / 2,
+        allowedAspects: [3 / 2, 16 / 9, 4 / 3],
+        minResolution: 600,
+    },
+    gallery: {
+        preferredAspect: 3 / 2,
+        allowedAspects: [],
+        excludeSquare: true,
+        minResolution: 600,
+    },
+    thumbnail: {
+        preferredAspect: 1,
+        allowedAspects: [1, 4 / 3],
+        minResolution: 96,
+    },
+};
+/**
+ * Pick the best `MediaAsset` for a slot.
+ *
+ * Selection runs three tiers and stops at the first non-empty result:
+ *   1. Strict — the slot's full rules (min-resolution, aspect filter).
+ *   2. Drop the min-resolution floor; keep the aspect filter.
+ *   3. Drop the aspect filter; accept any candidate with dimensions.
+ *
+ * Returns `null` only when no candidate carries usable dimensions. A small or
+ * off-aspect image beats a blank card; the slot rules are a preference, not a
+ * cliff. Catalog quality is enforced backend-side (see P-068c) — the SDK
+ * degrades gracefully when an attraction was uploaded with sub-spec assets.
+ */
+export function selectCorasImage(images, options) {
+    const config = SLOTS[options.slot];
+    if (!config)
+        return null;
+    const preferredAspect = options.preferredAspect ?? config.preferredAspect;
+    const minResolution = options.minResolution ?? config.minResolution;
+    const eligible = chooseEligible(images, config, minResolution);
+    if (eligible.length === 0)
+        return null;
+    const target = options.containerWidth != null
+        ? options.containerWidth * (options.dpr ?? defaultDpr())
+        : null;
+    const sorted = [...eligible].sort((a, b) => compare(a, b, preferredAspect, target));
+    const [primary, ...rest] = sorted.map(toSelected);
+    return { primary, fallbacks: rest };
+}
+function chooseEligible(images, config, minResolution) {
+    const strict = images.filter((img) => isEligible(img, config, minResolution));
+    if (strict.length > 0)
+        return strict;
+    const noFloor = images.filter((img) => isEligible(img, config, 0));
+    if (noFloor.length > 0)
+        return noFloor;
+    return images.filter((img) => Boolean(img.width && img.height));
+}
+/**
+ * Filter a list of `MediaAsset` candidates to those eligible for a slot.
+ * Use when you need every passing candidate (e.g. an image carousel), not
+ * just the single best — `selectCorasImage` is the single-pick variant.
+ */
+export function filterForSlot(images, slot, minResolution) {
+    const config = SLOTS[slot];
+    if (!config)
+        return [];
+    const floor = minResolution ?? config.minResolution;
+    return images.filter((img) => isEligible(img, config, floor));
+}
+function isEligible(img, config, minResolution) {
+    if (!img.width || !img.height)
+        return false;
+    if (Math.min(img.width, img.height) < minResolution)
+        return false;
+    return isAspectAllowed(img.width / img.height, config);
+}
+function isAspectAllowed(aspect, config) {
+    if (config.excludeSquare && Math.abs(aspect - 1) <= ASPECT_TOLERANCE) {
+        return false;
+    }
+    if (config.allowedAspects.length === 0)
+        return true;
+    return config.allowedAspects.some((target) => Math.abs(aspect - target) <= ASPECT_TOLERANCE);
+}
+function compare(a, b, preferredAspect, targetWidth) {
+    const aspectA = Math.abs(a.width / a.height - preferredAspect);
+    const aspectB = Math.abs(b.width / b.height - preferredAspect);
+    if (Math.abs(aspectA - aspectB) > ASPECT_TIE)
+        return aspectA - aspectB;
+    if (targetWidth != null) {
+        const aMeets = a.width >= targetWidth;
+        const bMeets = b.width >= targetWidth;
+        if (aMeets !== bMeets)
+            return aMeets ? -1 : 1;
+        const widthDelta = aMeets
+            ? a.width - b.width // smallest adequate first (avoid waste)
+            : b.width - a.width; // largest fallback first (least upscaling)
+        if (Math.abs(widthDelta) > WIDTH_TIE_PX)
+            return widthDelta;
+    }
+    return b.width * b.height - a.width * a.height;
+}
+function toSelected(img) {
+    return { url: img.url, width: img.width, height: img.height };
+}
+function defaultDpr() {
+    return typeof globalThis !== "undefined" &&
+        typeof globalThis.devicePixelRatio === "number"
+        ? globalThis.devicePixelRatio
+        : 1;
+}

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

@@ -0,0 +1,28 @@
+import { type ImgixOptions } from "./url.js";
+/**
+ * Responsive width matrix from Appendix K. Drives `srcset` candidate
+ * generation. Includes 2x-DPR entries up to ~1536 so high-density screens get
+ * a sharp candidate without us setting explicit `dpr=2`.
+ */
+export declare const RESPONSIVE_WIDTHS: readonly number[];
+export type ImagePreset = "card-grid" | "carousel-hero" | "gallery" | "thumbnail" | "header-banner";
+interface BuildSrcsetOptions extends Omit<ImgixOptions, "w" | "h" | "dpr"> {
+    /**
+     * Aspect ratio (`width / height`) used to derive `h` for each candidate.
+     * Mutually exclusive with a fixed `height`.
+     */
+    aspectRatio?: number;
+    /** Fixed height (px). Rare — only set for fixed-height surfaces. */
+    height?: number;
+    /** Maximum width to emit; candidates wider than this are dropped. */
+    maxWidth?: number;
+}
+/**
+ * Build an imgix-flavoured `srcset` from a base URL.
+ *
+ * Returns an empty string when `src` is empty so callers can pass the result
+ * straight to a `srcset` attribute without conditionals.
+ */
+export declare function buildSrcset(src: string, widths?: readonly number[], options?: BuildSrcsetOptions): string;
+export declare function buildSizes(preset: ImagePreset): string;
+export {};

package/dist/core/images/srcset.js

@@ -0,0 +1,52 @@
+import { buildImgixUrl } from "./url.js";
+/**
+ * Responsive width matrix from Appendix K. Drives `srcset` candidate
+ * generation. Includes 2x-DPR entries up to ~1536 so high-density screens get
+ * a sharp candidate without us setting explicit `dpr=2`.
+ */
+export const RESPONSIVE_WIDTHS = [
+    280, 320, 375, 480, 640, 768, 1024, 1366, 1600,
+];
+/**
+ * Build an imgix-flavoured `srcset` from a base URL.
+ *
+ * Returns an empty string when `src` is empty so callers can pass the result
+ * straight to a `srcset` attribute without conditionals.
+ */
+export function buildSrcset(src, widths = RESPONSIVE_WIDTHS, options = {}) {
+    if (!src)
+        return "";
+    const { aspectRatio, height, maxWidth, ...imgix } = options;
+    const eligible = maxWidth
+        ? widths.filter((w) => w <= maxWidth)
+        : Array.from(widths);
+    return eligible
+        .map((w) => {
+        const h = aspectRatio
+            ? Math.round(w / aspectRatio)
+            : (height ?? undefined);
+        return `${buildImgixUrl(src, { ...imgix, w, h })} ${w}w`;
+    })
+        .join(", ");
+}
+/**
+ * Slot presets for the `sizes` attribute. These describe the rendered size of
+ * the image in the layout, NOT the viewport — which is exactly what `sizes`
+ * is for. Numbers are taken from the actual layouts:
+ *
+ * - `card-grid`     — attraction cards in landing/search grids
+ * - `carousel-hero` — better-carousel item on the details page
+ * - `gallery`       — image-carousel item (legacy 780px hero)
+ * - `thumbnail`     — basket-item, tour-ticket-type thumbs
+ * - `header-banner` — location-image full-width banner
+ */
+const SIZES_PRESETS = {
+    "card-grid": "(min-width: 1001px) 25vw, (min-width: 501px) 50vw, 100vw",
+    "carousel-hero": "(min-width: 1024px) 480px, 90vw",
+    gallery: "(min-width: 1024px) 780px, 100vw",
+    thumbnail: "70px",
+    "header-banner": "100vw",
+};
+export function buildSizes(preset) {
+    return SIZES_PRESETS[preset];
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Canonical imgix URL builder. Single source of truth for all image params
+ * across the SDK — replaces the four near-duplicates that grew in
+ * `details-page`, `attraction-card`, `image-viewer`, and `location-image`.
+ *
+ * The builder is non-opinionated about whether `src` is an imgix URL: it
+ * always appends params. Callers pointing at non-imgix hosts should simply
+ * not call this helper.
+ */
+export type ImgixFit = "crop" | "clip" | "contain" | "fill" | "max" | "scale";
+export type ImgixCrop = "faces" | "edges" | "entropy" | "focalpoint" | "top" | "bottom" | "left" | "right" | "center" | string;
+export interface ImgixOptions {
+    w?: number;
+    h?: number;
+    dpr?: number;
+    fit?: ImgixFit;
+    crop?: ImgixCrop;
+    q?: number;
+    /** Normalised 0..1 focal point. Only emitted when `crop` is `focalpoint`. */
+    fpX?: number;
+    fpY?: number;
+}
+export declare function buildImgixUrl(src: string, opts?: ImgixOptions): string;

package/dist/core/images/url.js

@@ -0,0 +1,40 @@
+/**
+ * Canonical imgix URL builder. Single source of truth for all image params
+ * across the SDK — replaces the four near-duplicates that grew in
+ * `details-page`, `attraction-card`, `image-viewer`, and `location-image`.
+ *
+ * The builder is non-opinionated about whether `src` is an imgix URL: it
+ * always appends params. Callers pointing at non-imgix hosts should simply
+ * not call this helper.
+ */
+const DEFAULT_AUTO = "compress,format";
+const DEFAULT_QUALITY = 85;
+export function buildImgixUrl(src, opts = {}) {
+    if (!src)
+        return "";
+    const params = new URLSearchParams({ auto: DEFAULT_AUTO });
+    params.set("q", String(opts.q ?? DEFAULT_QUALITY));
+    if (opts.fit)
+        params.set("fit", opts.fit);
+    if (opts.crop)
+        params.set("crop", opts.crop);
+    if (opts.w)
+        params.set("w", String(Math.round(opts.w)));
+    if (opts.h)
+        params.set("h", String(Math.round(opts.h)));
+    if (opts.dpr)
+        params.set("dpr", String(opts.dpr));
+    if (opts.crop === "focalpoint" && opts.fpX != null && opts.fpY != null) {
+        params.set("fp-x", String(clamp01(opts.fpX)));
+        params.set("fp-y", String(clamp01(opts.fpY)));
+    }
+    const separator = src.includes("?") ? "&" : "?";
+    return `${src}${separator}${params.toString()}`;
+}
+function clamp01(n) {
+    if (n <= 0)
+        return 0;
+    if (n >= 1)
+        return 1;
+    return n;
+}

package/dist/core/pages.d.ts

@@ -0,0 +1,68 @@
+import { PageName } from "./types/shared.js";
+export type LandingPageParamsEvent = {
+    page: PageName;
+    currency: string;
+    locale: string;
+    country: string;
+    city: string;
+    startDate: string;
+    endDate: string;
+    sort: string;
+    duration: string;
+    price: string;
+    categories: string;
+};
+export type DetailsPageParamsEvent = {
+    page: PageName;
+    currency: string;
+    locale: string;
+    id: string;
+    date: string;
+};
+export type SearchPageParamsEvent = {
+    page: PageName;
+    currency: string;
+    locale: string;
+    search: string;
+};
+export type PaymentPageParamsEvent = {
+    page: PageName;
+    currency: string;
+    locale: string;
+};
+export type HelpPageParamsEvent = {
+    page: PageName;
+    currency: string;
+    locale: string;
+    /** Help content identifier (e.g., "faq-attractions", "faq-music", "contact", "privacy-policy") */
+    content?: string;
+    /** External link href when user clicks an unhandled link in help content */
+    href?: string;
+    /** External link text when user clicks an unhandled link in help content */
+    text?: string;
+};
+export type PageParamsEvent = LandingPageParamsEvent | DetailsPageParamsEvent | SearchPageParamsEvent | PaymentPageParamsEvent | HelpPageParamsEvent;
+export type LandingPageParamsInput = {
+    country?: string;
+    city?: string;
+    startDate?: string;
+    endDate?: string;
+    sort?: string;
+    duration?: string;
+    price?: string;
+    categories?: string;
+};
+export type DetailsPageParamsInput = {
+    id?: string;
+    date?: string;
+};
+export type SearchPageParamsInput = {
+    search?: string;
+};
+export type PaymentPageParamsInput = Record<string, never>;
+export type HelpPageParamsInput = {
+    content?: string;
+    href?: string;
+    text?: string;
+};
+export type PageParamsEventInput = LandingPageParamsInput | DetailsPageParamsInput | SearchPageParamsInput | PaymentPageParamsInput | HelpPageParamsInput;

package/dist/core/pages.js

@@ -0,0 +1 @@
+export {};

package/dist/core/signals.d.ts

@@ -0,0 +1,2 @@
+export declare const isBasketDropdownOpen: import("@lit-labs/signals").Signal.State<boolean>;
+export declare const isBasketMobileOpen: import("@lit-labs/signals").Signal.State<boolean>;

package/dist/core/signals.js

@@ -0,0 +1,3 @@
+import { signal } from "@lit-labs/signals";
+export const isBasketDropdownOpen = signal(false);
+export const isBasketMobileOpen = signal(false);

package/dist/core/storybook/argTypes.d.ts

@@ -0,0 +1 @@
+export declare function defineComponentArgTypes(component: string): {} | undefined;

package/dist/core/storybook/argTypes.js

@@ -0,0 +1,46 @@
+const ARG_TYPES = ["string", "boolean", "number", "array", "object"];
+const CONTROL_TYPES_MAP = {
+    string: "text",
+    boolean: "boolean",
+    number: "number",
+    date: "date",
+    array: "object",
+    object: "object",
+};
+export function defineComponentArgTypes(component) {
+    const constructor = customElements.get(component);
+    if (!constructor) {
+        console.error(`Component ${component} is not defined`);
+        return;
+    }
+    const argTypes = {};
+    const litElement = new constructor();
+    const props = litElement.constructor.elementProperties;
+    if (!props) {
+        return argTypes;
+    }
+    for (const [key, declaration] of props.entries()) {
+        if (!declaration.type ||
+            !("name" in declaration.type)) {
+            continue;
+        }
+        const type = declaration.type.name.toLowerCase();
+        // @ts-expect-error // unknown type
+        argTypes[key] = {
+            name: typeof declaration.attribute === "string"
+                ? declaration.attribute
+                : key,
+            type: {
+                name: getArgTypeName(type),
+            },
+            control: { type: getControlType(type) },
+        };
+    }
+    return argTypes;
+}
+function getArgTypeName(type) {
+    return ARG_TYPES.includes(type) ? type : "string";
+}
+function getControlType(type) {
+    return CONTROL_TYPES_MAP[type] || "text";
+}

package/dist/core/storybook/cssprops.d.ts

@@ -0,0 +1,30 @@
+import { CSSResult } from "lit";
+interface ColorConfig {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export declare function createCSSProp(config: ColorConfig): Record<string, {
+    description: string;
+    value: string | number;
+}>;
+export type CSSVariableDefinition = {
+    name: string;
+    value: string | number;
+};
+export type CSSPropertiesDefinition = {
+    [key: string]: {
+        description: string;
+        value: string | number;
+    };
+};
+export type DesignTokenMatch = {
+    tokenName: string;
+    variableName: string;
+    value: string;
+};
+/**
+ * Defines CSS properties for Storybook for a component based on its CSS.
+ */
+export declare function defineComponentCSSProps(styles: CSSResult): CSSPropertiesDefinition;
+export {};

package/dist/core/storybook/cssprops.js

@@ -0,0 +1,46 @@
+export function createCSSProp(config) {
+    const formattedName = config.name.replace("--", "");
+    return {
+        [formattedName]: {
+            description: config.description,
+            value: config.value,
+        },
+    };
+}
+/**
+ * Defines CSS properties for Storybook for a component based on its CSS.
+ */
+export function defineComponentCSSProps(styles) {
+    const vars = findCssVars(styles.cssText);
+    return vars.reduce((acc, definition) => {
+        return {
+            ...acc,
+            ...{
+                [definition.variableName]: {
+                    description: kebabToSentenceCase(definition.tokenName),
+                    value: definition.value,
+                },
+            },
+        };
+    }, {});
+}
+function findCssVars(text) {
+    const matches = [];
+    // Regex to match entries like
+    // --component-variable-identifier: var(--coras-global-variable-identifier, value);
+    const regex = /--([\w-]+):\s*var\((?:\\n\s*|\s*)--([\w-]+)\s*,(?:\\n\s*|\s*)([^\\^\s]*)(?:\\n\s*|\s*)\);/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const [_, tokenName, variableName, value] = match;
+        matches.push({
+            tokenName: tokenName,
+            variableName: variableName,
+            value: value,
+        });
+    }
+    return matches;
+}
+function kebabToSentenceCase(input) {
+    // Replace hyphens with spaces and capitalize the first letter
+    return input.replace(/-/g, " ").replace(/\b\w/, (char) => char.toUpperCase());
+}

package/dist/core/types/api-errors.d.ts

@@ -0,0 +1,8 @@
+export type APIError = {
+    title: string;
+    description: string;
+    code: number;
+    timestamp: string;
+    exception_id: string;
+    request_id: string;
+};

package/dist/core/types/api-errors.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/basket.d.ts

@@ -0,0 +1,18 @@
+export type Ticket = {
+    id: string;
+    price: number;
+    section: string;
+    seatName: string;
+};
+export type BasketItem = {
+    id: string;
+    name: string;
+    type: string;
+    date: string;
+    image: string;
+    reservationID: string;
+    tickets: Ticket[];
+};
+export type Basket = {
+    items: BasketItem[];
+};

package/dist/core/types/basket.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/base.d.ts

@@ -0,0 +1,11 @@
+import { SupportedCurrencies } from "./currency.js";
+import { SupportedLocales } from "./locale.js";
+export type CorasBaseConfig = {
+    apiHost: string;
+    distributorID: string;
+    currency: SupportedCurrencies;
+    currencies: SupportedCurrencies[];
+    locale: SupportedLocales;
+    locales: SupportedLocales[];
+    search: string;
+};

package/dist/core/types/core/base.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/core/category.d.ts

@@ -0,0 +1,2 @@
+import { CorasCategoryTag } from "../../../components/category-tag/category-tag.js";
+export type Category = keyof typeof CorasCategoryTag.prototype.variants | undefined;

package/dist/core/types/core/category.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import { supportedCurrencies } from "../../currency/constants.js";
+export type SupportedCurrencies = (typeof supportedCurrencies)[number];

package/dist/core/types/core/currency.js

@@ -0,0 +1 @@
+export {};