@bearmenu/ui 0.8.8 → 0.8.10

package/dist/components/menu-types.d.ts

@@ -0,0 +1,421 @@
+import { ComponentType, CSSProperties, ReactNode } from 'react';
+import { MenuSizeAndPrice, PlacePreview } from './place-types.js';
+
+/**
+ * Structural mirror of the openapi `Dish` / `Drink` schemas, decoupled from any
+ * one app's generated types. FE, admin and post-generator map their domain
+ * shapes into these before passing data to the menu-hub surfaces.
+ *
+ * Same contract as `place-types.ts` and `event-types.ts`: no app schemas, no
+ * app hooks, no i18n. Every user-facing string arrives through a `*Labels`
+ * object, every destination through an `href`, and every locale-sensitive
+ * format through an injected formatter — the DS never owns a translation key
+ * or an `Intl` locale.
+ *
+ * ## One set of components, two tabs
+ *
+ * Dishes and drinks are the same shape. `MenuItemPreview.kind` is the only
+ * discriminator, and nothing in this file branches on it — a drinks hub is a
+ * different view model and a different `*Labels` object, never a second set of
+ * components. Anything that would need a `if (kind === 'drink')` inside a
+ * component belongs in the caller's mapper instead.
+ */
+
+/**
+ * The shape every menu surface's `linkComponent` must accept.
+ *
+ * One type rather than a clone per component: these surfaces nest each other —
+ * a family card renders a `<MenuItem>`, a spotlight renders a signature block —
+ * and a caller passes ONE `next/link` down through all of them. Subtly
+ * different clones made those hand-offs fail to typecheck for no design reason.
+ */
+type MenuLinkProps = {
+    href: string;
+    className?: string;
+    'aria-label'?: string;
+    'aria-current'?: 'page';
+    /** Intent tiles paint their hue on the link element itself. */
+    style?: CSSProperties;
+    children?: ReactNode;
+};
+type MenuLinkComponent = ComponentType<MenuLinkProps>;
+/**
+ * A dish or a drink as every hub surface consumes it.
+ *
+ * `mentions` is the census count of review mentions and is populated on every
+ * item in the catalogue — it is the ranking signal the hub is built on. Do not
+ * confuse it with `review_count`, which counts full review objects and is zero
+ * for most items; a surface that ranks on `review_count` renders an empty page.
+ */
+type MenuItemPreview = {
+    id: string;
+    slug: string;
+    name: string;
+    kind: 'dish' | 'drink';
+    description?: string;
+    /** API category code (pizza, pasta, cocktail, non-alcoholic, …). Localised by the caller. */
+    category_slug?: string;
+    sizes_and_prices?: MenuSizeAndPrice[];
+    /** Censused review mentions. The hub's ranking signal. */
+    mentions?: number;
+    /** Full review objects citing this item. Sparse — not a ranking signal. */
+    review_count?: number;
+    /** 0–100 recommendation score. */
+    score?: number;
+    /** The venue serving it. Menu items are always venue-scoped. */
+    place?: MenuItemPlaceRef;
+    /**
+     * Pre-resolved photo URL. Menu-item photography is AI-generated and hidden in
+     * production, so hub surfaces draw a typographic `<MenuFieldTile>` instead
+     * and leave this unset. It exists for the surfaces that legitimately show one
+     * (concept detail) and for consumers outside the consumer app.
+     */
+    photo_url?: string;
+};
+/** The venue attribution carried on a menu item. */
+type MenuItemPlaceRef = {
+    slug: string;
+    name: string;
+    /** Pre-resolved venue thumbnail. Venue photography is real; item photography is not. */
+    thumbnail_url?: string;
+};
+/**
+ * A dish or drink concept — one item across every kitchen that makes it, under
+ * whatever name each of them uses. The page's keystone, and the one thing the
+ * catalogue can say that a single menu cannot.
+ */
+type MenuConceptPreview = {
+    slug: string;
+    /** Canonical concept name, e.g. "Margherita". */
+    title: string;
+    kind: 'dish' | 'drink';
+    /** Venues serving it. */
+    venue_count?: number;
+    price_low?: number;
+    price_high?: number;
+    /** Distinct names it appears under across those menus. */
+    alias_count?: number;
+    /** Summed censused mentions across every venue's version. */
+    mentions?: number;
+    rows?: MenuConceptRow[];
+};
+/** One venue's version of a concept, as drawn by `<ConceptCompare>`. */
+type MenuConceptRow = {
+    place_slug: string;
+    place_name: string;
+    /** What this kitchen calls it on its own menu. */
+    alias: string;
+    price: number;
+    mentions?: number;
+    rating?: number;
+    /** Venue type line, e.g. "pub". Localised by the caller. */
+    place_type?: string;
+    /** Neighbourhood, e.g. "Centru". */
+    place_area?: string;
+    /**
+     * Pre-resolved VENUE photograph.
+     *
+     * The row is place-led: five restaurants that disagree about a name, not five
+     * bars of similar length. A price bar was drawn here first and it measured
+     * the one thing already written beside it in words, while the venue — the
+     * thing you are actually choosing between — had no image at all.
+     */
+    place_thumbnail_url?: string;
+    open_now?: boolean;
+    /** Marks the row the surface should lead with (cheapest, or most named). */
+    featured?: boolean;
+    /** Portion, already formatted with its unit, e.g. "260g". */
+    portion_label?: string;
+};
+/**
+ * A browsable grouping of venues — a cuisine on the dishes tab, a drink family
+ * on the drinks tab. Both are sets of VENUES, never sets of items: cuisine
+ * exists only on places, so a card counting dishes cannot be built.
+ */
+type MenuFamilyPreview = {
+    slug: string;
+    /** Display name, already localised by the caller. */
+    name: string;
+    /** Venues in this family. */
+    venue_count: number;
+    /**
+     * Facet chips. Counts are VENUES, not items — they come from the places
+     * facet narrowed by this family. The drinks tab has no equivalent facet, so
+     * its chips ship without counts; `count` is optional for that reason.
+     */
+    chips?: MenuFamilyChip[];
+    /** Price band across the family's venues. */
+    price_low?: number;
+    price_high?: number;
+    price_median?: number;
+    /** Pre-resolved venue photos for the mosaic. Venue photography only. */
+    venue_photo_urls?: string[];
+};
+type MenuFamilyChip = {
+    slug: string;
+    label: string;
+    /** Venue count. Absent where no facet backs the chip. */
+    count?: number;
+};
+/**
+ * A venue as the hub's venue-scoped surfaces consume it: the place itself plus
+ * the pre-resolved bits a hub row needs and `PlacePreview` does not carry —
+ * which signature to lead with, and where the row points.
+ */
+type MenuVenuePreview = {
+    place: PlacePreview;
+    href: string;
+    /**
+     * The signature to draw. Callers pick it from `reviews_digest.must_try`
+     * rather than the surface re-deriving the rule on every row.
+     */
+    signature?: MenuVenueSignature;
+    /** Closing time as an already-formatted wall clock, e.g. "23:00". */
+    closes_at_label?: string;
+};
+/**
+ * The resolved signature on a venue row.
+ *
+ * It carries a whole `MenuItemPreview` rather than a flattened name and price,
+ * because every surface that draws one renders `<MenuItem>` — the same row a
+ * venue's own menu uses — and that component takes an item. Flattening it here
+ * was what let the hub's version drift into a different-looking row.
+ */
+type MenuVenueSignature = {
+    item: MenuItemPreview;
+    /** The reviewers' reason, from the digest. Rendered in place of the description. */
+    why?: string;
+    href?: string;
+    /** The digest called this the venue's signature rather than merely frequent. */
+    isSignature?: boolean;
+};
+/**
+ * An intent tile — a family plus a constraint, resolving to a category page.
+ *
+ * Only about thirty-two of the thirty-eight cuisines have a page, so `href` is
+ * required: a tile that cannot resolve to a real destination is not rendered
+ * rather than linking nowhere.
+ */
+type MenuIntentTile = {
+    slug: string;
+    label: string;
+    /** Supporting line, e.g. "247 kitchens". Already formatted by the caller. */
+    caption?: string;
+    href: string;
+    /**
+     * Finished CSS gradient for the tile's ground, e.g.
+     * `linear-gradient(150deg, …)`.
+     *
+     * A gradient rather than a token name, for the same reason `<MenuField>`
+     * takes one: the hue tables are app-owned, and a component referencing
+     * `var(--h-pizza)` renders an invisible tile in any consumer that does not
+     * happen to define that variable. A missing gradient falls back to `bg-muted`
+     * — visible and obviously unstyled, rather than white text on white.
+     */
+    gradient?: string;
+    /** Icon node, resolved by the caller — the DS does not pick icons for it. */
+    icon?: ReactNode;
+};
+/**
+ * One figure in the intent hero — a number the reader can tap to filter by.
+ *
+ * The value arrives pre-formatted because the figures are not all the same
+ * quantity: "247" is a count and "58" is a count of a subset, but a caller may
+ * also want "4 past midnight", and a component that formatted numbers itself
+ * would need the locale it is forbidden to own.
+ */
+type MenuIntentFigure = {
+    key: string;
+    /** Pre-formatted, e.g. "247". */
+    value: string;
+    /** The unit, e.g. "kitchens" or "make a pizza". */
+    label: string;
+    /**
+     * The state this figure applies, as a URL.
+     *
+     * An `href` rather than only a callback because the filter state lives in the
+     * query string: a link is server-rendered, crawlable, middle-clickable and
+     * survives with no JavaScript, and `?open=now` is an indexable state we
+     * actively want followed. `onSelect` remains for consumers holding the state
+     * in memory; `href` wins when both are set.
+     */
+    href?: string;
+    /**
+     * Applies this figure as a filter without navigating. A figure with neither
+     * `href` nor `onSelect` renders as a static fact rather than as a control
+     * that does nothing — the total is usually one, since filtering to "all of
+     * them" is not a state.
+     */
+    onSelect?: () => void;
+    /** The filter this figure applies is already on. */
+    active?: boolean;
+};
+/**
+ * A filter chip on the intent page.
+ *
+ * Every chip counts KITCHENS, whatever facet backs it — a dietary chip reads
+ * "has a vegetarian dish" and counts venues, not dishes. Mixing venue counts
+ * and item counts in one row is what made the earlier version unreadable, so
+ * the type carries no unit: there is only ever one.
+ */
+type MenuFilterChip = {
+    key: string;
+    label: string;
+    /** Kitchens this chip would leave. Absent where no facet backs it. */
+    count?: number;
+    active?: boolean;
+    /**
+     * Zero kitchens under the current filters — dimmed, but STILL TAPPABLE.
+     *
+     * Tapping swaps it in and drops whichever active filter conflicts, with a
+     * line saying which. A disabled chip would leave the reader guessing why the
+     * thing they want is unavailable; this one answers it by being pressed.
+     */
+    empty?: boolean;
+    /** Icon node, resolved by the caller. */
+    icon?: ReactNode;
+};
+/**
+ * A venue row on the intent page — the page's spine.
+ *
+ * Distinct from `MenuVenuePreview` (the hub's ranked row) in one structural
+ * way that is the whole point of the surface: the dish carries its own `href`,
+ * so the row has TWO targets. The row goes to the venue; the dish name opens
+ * the item drawer. `RankedVenueList` wraps its entire row in one link and
+ * therefore cannot express this, which is why this is a separate shape rather
+ * than a flag on that one.
+ */
+type MenuKitchenPreview = {
+    place: PlacePreview;
+    /** The venue page. The row's primary target. */
+    href: string;
+    /** Venue type and district, composed and localised by the caller, e.g. "pizzeria · Centru". */
+    metaLabel?: string;
+    /**
+     * "kitchen until 23:00", or "closed · opens 12:00". Composed by the caller
+     * because the wording differs by scope — a bar is not a kitchen.
+     */
+    hoursLabel?: string;
+    dish?: MenuKitchenDish;
+    /** Pre-formatted, e.g. "62 lei". */
+    priceLabel?: string;
+};
+/** The dish a kitchen row leads with. The row's second target. */
+type MenuKitchenDish = {
+    name: string;
+    /**
+     * Opens the item drawer. Omit for an inert dish line — a must-try the
+     * reviews named that has no live menu row behind it.
+     */
+    href?: string;
+    /** Kicker over the name: "MOST NAMED HERE", or "WHY IT MATCHES" when filtered. */
+    kicker: string;
+    /** Under the name: "17 reviews name it", or "mid-range · 300g" when matched. */
+    meta?: string;
+    /**
+     * This row is answering a filter rather than volunteering its most-named
+     * dish. Draws the match mark and tints the block, so a reader scanning a
+     * filtered list can see that every row changed its reason for being there.
+     */
+    matched?: boolean;
+    /** The filter it matched, e.g. "vegetarian". */
+    matchLabel?: string;
+};
+/**
+ * One row in a browse index — the complete set, at a glance.
+ *
+ * The index is the page's whole SEO job: it carries a crawlable link to every
+ * destination the city has, which is what frees the richer blocks below it to
+ * be progressive. So it holds nothing but what a reader needs to choose — a
+ * name, a count and a colour.
+ */
+type MenuIndexEntry = {
+    slug: string;
+    name: string;
+    count: number;
+    href: string;
+    /** Finished CSS gradient for the mark. Falls back to the border colour. */
+    gradient?: string;
+};
+/**
+ * A family on the cuisines index — the hub's card, opened out sideways.
+ *
+ * Deliberately thin. The reader here is choosing a cuisine, not a venue, and
+ * every field the block does NOT carry is a decision the next page owns.
+ */
+type MenuFamilyBlockPreview = {
+    slug: string;
+    name: string;
+    venueCount: number;
+    /** Facet chips. Labels only — the block never prints their counts. */
+    chips?: MenuFamilyChip[];
+    /** Composed price band, e.g. "22–86 lei". */
+    priceBandLabel?: string;
+    /** Venue photography only — item photography is AI-generated and never shown. */
+    photoUrls?: string[];
+    /**
+     * Venues, as kitchen rows. The block draws every one it is given — the caller
+     * decides how many, because how much of a claim the block makes is the page's
+     * decision, not the component's.
+     *
+     * The same `MenuKitchenPreview` the intent page's list takes, rendered by the
+     * same component — a family block that grew its own venue row would be the
+     * fourth near-identical row in the package, and they drift the moment one of
+     * them gets a fix.
+     */
+    venues?: MenuKitchenPreview[];
+    /** The family's own page. */
+    href: string;
+};
+/**
+ * One "loosen this" row on a dead end — a filter, and what dropping it returns.
+ *
+ * The count is the point: "drop Open now" is a guess, "+8 kitchens" is an
+ * answer, and a dead end that cannot say which filter costs the most is just
+ * an empty state with extra steps.
+ */
+type MenuLoosenOption = {
+    key: string;
+    /** e.g. 'Drop "Open now"'. */
+    label: string;
+    /** e.g. "+8 kitchens". Pre-formatted. */
+    gainLabel: string;
+    /**
+     * The state without this filter, as a URL.
+     *
+     * An `href` because dropping a filter IS a navigation wherever the filter set
+     * lives in the query string — which makes it server-renderable, shareable and
+     * undoable with the back button. `onSelect` remains for consumers holding the
+     * state in memory; `href` wins when both are set.
+     */
+    href?: string;
+    onSelect?: () => void;
+};
+/** One question and its answer. Static prose — never an accordion; see `<QaBlock>`. */
+type QaItem = {
+    question: string;
+    answer: string;
+};
+/** Formatters injected into every menu surface. The DS owns no `Intl` locale. */
+type MenuFormatters = {
+    /** 24 → "24 lei". */
+    price: (value: number) => string;
+    /** 1717 → "1,717". */
+    number: (value: number) => string;
+};
+/** Strings shared by every menu-hub surface. */
+type MenuHubLabels = {
+    /** Mention-count badge. Pass a translator that handles ICU pluralization. */
+    mentions: (count: number) => string;
+    /** Venue-count line. Pass a translator that handles ICU pluralization. */
+    venues: (count: number) => string;
+    /** "See all" affordance on a section header. */
+    seeAll: string;
+    /** Badge on a must-try row the digest called `signature`. */
+    signature: string;
+    openNow: string;
+    /** Prefixes a closing time, e.g. "until". */
+    until: string;
+};
+
+export { type MenuConceptPreview, type MenuConceptRow, type MenuFamilyBlockPreview, type MenuFamilyChip, type MenuFamilyPreview, type MenuFilterChip, type MenuFormatters, type MenuHubLabels, type MenuIndexEntry, type MenuIntentFigure, type MenuIntentTile, type MenuItemPlaceRef, type MenuItemPreview, type MenuKitchenDish, type MenuKitchenPreview, type MenuLinkComponent, type MenuLinkProps, type MenuLoosenOption, MenuSizeAndPrice, type MenuVenuePreview, type MenuVenueSignature, type QaItem };

package/dist/components/menu-types.js

@@ -0,0 +1 @@
+

package/dist/components/motion-icon-controls.js

@@ -1,4 +1,4 @@
-export { MotionBookmark, MotionCheck, MotionChevron, MotionCopy, MotionEye, MotionHeart, MotionPlayPause, MotionRefresh, MotionSearch, MotionShare, MotionSliders, MotionSort, MotionStar, MotionTheme } from '../chunk-TT3WFS6S.js';
-import '../chunk-2WDJR6K7.js';
+export { MotionBookmark, MotionCheck, MotionChevron, MotionCopy, MotionEye, MotionHeart, MotionPlayPause, MotionRefresh, MotionSearch, MotionShare, MotionSliders, MotionSort, MotionStar, MotionTheme } from '../chunk-YOKHBAIH.js';
+import '../chunk-G7IFL4Z4.js';
 import '../chunk-FEK5XGZW.js';
 import '../chunk-3GWWZKX7.js';

package/dist/components/motion-icon-set.js

@@ -1,4 +1,4 @@
-import { beats, MotionIcon, returnTransition } from '../chunk-2WDJR6K7.js';
+import { beats, pivot, MotionIcon, returnTransition } from '../chunk-G7IFL4Z4.js';
 import '../chunk-FEK5XGZW.js';
 import { __spreadProps, __spreadValues } from '../chunk-3GWWZKX7.js';
 import * as React from 'react';
@@ -28,11 +28,11 @@ function MotionHouse(props) {
       motion.path,
       {
         variants: houseRoof,
-        style: { originX: "12px", originY: "10px" },
+        style: pivot(12, 10),
         d: "M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10"
       }
     ),
-    /* @__PURE__ */ jsxs(motion.g, { variants: houseWalls, style: { originX: "12px", originY: "21px" }, children: [
+    /* @__PURE__ */ jsxs(motion.g, { variants: houseWalls, style: pivot(12, 21), children: [
       /* @__PURE__ */ jsx("path", { d: "M21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V10" }),
       /* @__PURE__ */ jsx("path", { d: "M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8" })
     ] })
@@ -40,12 +40,14 @@ function MotionHouse(props) {
 }
 var UTENSILS_TIMES = [0, 0.18, 0.72, 1];
 var SEPARATION = 5;
+var FORK_LIFT = -1.5;
 var fork = {
-  rest: { rotate: 0, x: 0, transition: returnTransition },
-  active: { rotate: -44, x: -SEPARATION, transition: returnTransition },
+  rest: { rotate: 0, x: 0, y: 0, transition: returnTransition },
+  active: { rotate: -44, x: -SEPARATION, y: FORK_LIFT, transition: returnTransition },
   play: {
     rotate: [0, 6, -50, -44],
     x: [0, 0.8, -6, -SEPARATION],
+    y: [0, 0, FORK_LIFT - 0.3, FORK_LIFT],
     transition: beats(UTENSILS_TIMES, 0.6)
   }
 };
@@ -58,7 +60,17 @@ var knife = {
     transition: beats(UTENSILS_TIMES, 0.6)
   }
 };
-var CROSSING = { originX: "12px", originY: "12px" };
+var CROSSING = pivot(12, 12);
+var HANDLE_CROSSED = "M2.1 21.8 8.5 15.4";
+var HANDLE_CLEAR = "M2.1 21.8 12 12";
+var forkHandle = {
+  rest: { d: HANDLE_CROSSED, transition: returnTransition },
+  active: { d: HANDLE_CLEAR, transition: returnTransition },
+  play: {
+    d: [HANDLE_CROSSED, HANDLE_CROSSED, HANDLE_CLEAR, HANDLE_CLEAR],
+    transition: beats(UTENSILS_TIMES, 0.6)
+  }
+};
 function MotionUtensils(props) {
   return /* @__PURE__ */ jsxs(MotionIcon, __spreadProps(__spreadValues({}, props), { children: [
     /* @__PURE__ */ jsx(
@@ -71,7 +83,7 @@ function MotionUtensils(props) {
     ),
     /* @__PURE__ */ jsxs(motion.g, { variants: fork, style: CROSSING, children: [
       /* @__PURE__ */ jsx("path", { d: "m16 2-2.3 2.3a3 3 0 0 0 0 4.2l1.8 1.8a3 3 0 0 0 4.2 0L22 8" }),
-      /* @__PURE__ */ jsx("path", { d: "m2.1 21.8 6.4-6.3" }),
+      /* @__PURE__ */ jsx(motion.path, { variants: forkHandle, d: HANDLE_CROSSED }),
       /* @__PURE__ */ jsx("path", { d: "m19 5-7 7" })
     ] })
   ] }));
@@ -96,13 +108,13 @@ var pinDot = {
   }
 };
 function MotionMapPin(props) {
-  return /* @__PURE__ */ jsx(MotionIcon, __spreadProps(__spreadValues({}, props), { children: /* @__PURE__ */ jsxs(motion.g, { variants: pinBody, style: { originX: "12px", originY: "22px" }, children: [
+  return /* @__PURE__ */ jsx(MotionIcon, __spreadProps(__spreadValues({}, props), { children: /* @__PURE__ */ jsxs(motion.g, { variants: pinBody, style: pivot(12, 22), children: [
     /* @__PURE__ */ jsx("path", { d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0" }),
     /* @__PURE__ */ jsx(
       motion.circle,
       {
         variants: pinDot,
-        style: { originX: "12px", originY: "10px" },
+        style: pivot(12, 10),
         fill: "currentColor",
         fillOpacity: 0,
         cx: "12",

package/dist/components/motion-icon.d.ts

@@ -23,6 +23,27 @@ type MotionIconVariant = "rest" | "active" | "play";
 declare function beats(times: number[], duration?: number): Transition;
 /** Leaving is not a performance — it returns the glyph, firmly and fast. */
 declare const returnTransition: Transition;
+/**
+ * A moving part's pivot, in the icon's 24-unit VIEWBOX coordinates.
+ *
+ * Every part in this family wrote `style={{ originX: "12px", originY: "12px" }}`
+ * meaning "the centre of the icon" — and every one of them was pivoting
+ * somewhere else. Framer Motion sets `transform-box: fill-box` on any SVG
+ * element it transforms, which makes `transform-origin` relative to that
+ * element's OWN bounding box, not the viewBox. The chevron `m6 9 6 6 6-6` has
+ * its box at (6, 9), so "12px 12px" resolved to user-space (18, 21): a 180°
+ * flip around a point outside the arrow, which is why it visibly slid as it
+ * turned. A house's walls pivoting at its floor, a pin at its tip, a lens at
+ * its centre — all of them missed by the same offset for the same reason.
+ *
+ * `transform-box: view-box` is the single switch that makes px origins mean
+ * what they say. Declared once here so the next icon cannot get it wrong.
+ */
+declare function pivot(x: number, y: number): {
+    readonly originX: `${number}px`;
+    readonly originY: `${number}px`;
+    readonly transformBox: "view-box";
+};
 type PoseValues = Record<string, number>;
 /**
  * Builds the three variants for a moving part.
@@ -41,4 +62,4 @@ declare function MotionIcon({ active, replayToken, className, children, }: Motio
     children: React.ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-export { MotionIcon, type MotionIconProps, type MotionIconVariant, beats, poses, returnTransition, useIconGesture };
+export { MotionIcon, type MotionIconProps, type MotionIconVariant, beats, pivot, poses, returnTransition, useIconGesture };

package/dist/components/motion-icon.js

@@ -1,3 +1,3 @@
-export { MotionIcon, beats, poses, returnTransition, useIconGesture } from '../chunk-2WDJR6K7.js';
+export { MotionIcon, beats, pivot, poses, returnTransition, useIconGesture } from '../chunk-G7IFL4Z4.js';
 import '../chunk-FEK5XGZW.js';
 import '../chunk-3GWWZKX7.js';

package/dist/components/open-now-list.d.ts

@@ -0,0 +1,40 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { MenuVenuePreview, MenuLinkComponent, MenuLinkProps } from './menu-types.js';
+import 'react';
+import './place-types.js';
+
+/**
+ * OpenNowList — who is still serving, and until when.
+ *
+ * At half past ten this beats every other sort, which is why it is its own
+ * surface rather than a filter chip: the question is not "what is good" but
+ * "what is possible", and every other module on a hub answers the first one.
+ *
+ * The closing time arrives pre-formatted on the view model (`closes_at_label`)
+ * because the venue's own trading day can cross midnight — a bar closing at
+ * 04:00 closes on the following date — and resolving that needs the venue's
+ * timezone and the reader's clock, neither of which the DS has.
+ *
+ * The live dot is never the only signal that a venue is open: the closing pill
+ * carries the same fact in words, so the row reads without colour.
+ *
+ * Server-safe.
+ */
+/** @deprecated Alias of `MenuLinkProps`; kept so existing imports keep working. */
+type OpenNowListLinkProps = MenuLinkProps;
+type OpenNowListProps = {
+    venues: MenuVenuePreview[];
+    /** Prefix on the closing pill, e.g. "until". */
+    untilLabel: string;
+    /** Composed meta line per venue, keyed by place slug, e.g. "pub · Centru". */
+    metaLabels?: Record<string, string>;
+    /** What the kitchen is still sending out, keyed by place slug. */
+    summaryLabels?: Record<string, string>;
+    /** Composed price band per venue, keyed by place slug, e.g. "19—62 lei". */
+    priceBandLabels?: Record<string, string>;
+    linkComponent?: MenuLinkComponent;
+    className?: string;
+};
+declare function OpenNowList({ venues, untilLabel, metaLabels, summaryLabels, priceBandLabels, linkComponent: LinkComponent, className, }: OpenNowListProps): react_jsx_runtime.JSX.Element;
+
+export { OpenNowList, type OpenNowListLinkProps, type OpenNowListProps };

package/dist/components/open-now-list.js

@@ -0,0 +1,69 @@
+import { Separator } from '../chunk-WSRWFA6K.js';
+import { cn } from '../chunk-FEK5XGZW.js';
+import { __objRest, __spreadValues } from '../chunk-3GWWZKX7.js';
+import { Clock, ChevronRight } from 'lucide-react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function DefaultLink(_a) {
+  var _b = _a, { href } = _b, props = __objRest(_b, ["href"]);
+  return /* @__PURE__ */ jsx("a", __spreadValues({ href }, props));
+}
+function OpenNowList({
+  venues,
+  untilLabel,
+  metaLabels,
+  summaryLabels,
+  priceBandLabels,
+  linkComponent: LinkComponent = DefaultLink,
+  className
+}) {
+  return /* @__PURE__ */ jsx("ul", { className: cn("flex flex-col", className), children: venues.map((venue, index) => {
+    const { place } = venue;
+    return /* @__PURE__ */ jsxs("li", { children: [
+      index > 0 && /* @__PURE__ */ jsx(Separator, {}),
+      /* @__PURE__ */ jsxs(
+        LinkComponent,
+        {
+          href: venue.href,
+          className: "flex flex-wrap items-center gap-x-3 gap-y-1.5 py-3 transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+          children: [
+            /* @__PURE__ */ jsxs("span", { className: "relative h-14 w-14 shrink-0 overflow-hidden rounded-xl bg-[repeating-linear-gradient(135deg,oklch(0.78_0.018_55)_0_8px,oklch(0.84_0.012_58)_8px_16px)]", children: [
+              place.thumbnail_url && // eslint-disable-next-line @next/next/no-img-element
+              /* @__PURE__ */ jsx(
+                "img",
+                {
+                  src: place.thumbnail_url,
+                  alt: "",
+                  className: "h-full w-full object-cover",
+                  loading: "lazy"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "i",
+                {
+                  "aria-hidden": true,
+                  className: "absolute right-1 top-1 h-[7px] w-[7px] rounded-full bg-[var(--free,currentColor)] ring-2 ring-white/80"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsx("span", { className: "block text-sm font-bold leading-snug tracking-[-0.01em]", children: place.name }),
+              (metaLabels == null ? void 0 : metaLabels[place.slug]) && /* @__PURE__ */ jsx("span", { className: "mt-px block truncate text-[11.5px] text-muted-foreground", children: metaLabels[place.slug] })
+            ] }),
+            (summaryLabels == null ? void 0 : summaryLabels[place.slug]) && /* @__PURE__ */ jsx("span", { className: "order-last w-full truncate text-[12.5px] text-muted-foreground lg:order-none lg:w-auto lg:flex-1", children: summaryLabels[place.slug] }),
+            (venue.closes_at_label || (priceBandLabels == null ? void 0 : priceBandLabels[place.slug])) && /* @__PURE__ */ jsxs("span", { className: "flex shrink-0 flex-col items-end gap-1 lg:flex-row lg:items-center lg:gap-3", children: [
+              (priceBandLabels == null ? void 0 : priceBandLabels[place.slug]) && /* @__PURE__ */ jsx("span", { className: "text-[12.5px] tabular-nums text-muted-foreground", children: priceBandLabels[place.slug] }),
+              venue.closes_at_label && /* @__PURE__ */ jsxs("span", { className: "inline-flex h-6 items-center gap-1 rounded-full bg-[var(--free-subtle,var(--accent-subtle))] px-2.5 text-[11.5px] font-semibold tabular-nums", children: [
+                /* @__PURE__ */ jsx(Clock, { className: "h-[11px] w-[11px]", "aria-hidden": true }),
+                `${untilLabel} ${venue.closes_at_label}`
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx(ChevronRight, { className: "h-4 w-4 shrink-0 text-muted-foreground", "aria-hidden": true })
+          ]
+        }
+      )
+    ] }, place.slug);
+  }) });
+}
+
+export { OpenNowList };