@bearmenu/ui 0.8.9 → 0.8.10

package/dist/components/menu-kitchen-list.d.ts

@@ -0,0 +1,82 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { MenuKitchenPreview, MenuLinkComponent, MenuLinkProps } from './menu-types.js';
+import 'react';
+import './place-types.js';
+
+/**
+ * MenuKitchenList — the intent page's spine.
+ *
+ * Venues ranked by how often reviews name their dishes, each row carrying the
+ * dish that earned it its place. Not a grid of dishes: a shortlist of rooms you
+ * could walk into.
+ *
+ * ## Two targets, and why this is not `<RankedVenueList>`
+ *
+ * The row goes to the venue. The dish name opens the item drawer — the same
+ * drawer the dish tiles open, listing every kitchen that makes it and for how
+ * much. Those are two different destinations inside one row, and the hub's
+ * `<RankedVenueList>` wraps its ENTIRE row in a single `LinkComponent`, so it
+ * structurally cannot express a second one. That is the reason this exists
+ * rather than a variant flag on that component.
+ *
+ * The mechanism is a stretched overlay, as in `<MenuItem>`: the venue link is
+ * an absolutely-positioned sibling at `z-[1]`, and the dish link sits above it
+ * at `z-[2]`. Nesting one anchor inside another is invalid HTML and breaks
+ * middle-click on both.
+ *
+ * The dish name is underlined so it reads as a target before it is pressed. The
+ * chevron belongs to the venue and stays on the right, away from it — an
+ * unmarked second target inside a row that already navigates is a trap.
+ *
+ * ## The filtered state changes the row's reason for being there
+ *
+ * With a dish or dietary filter on, each row swaps its most-named dish for the
+ * one that actually matched, and the kicker changes with it ("MOST NAMED HERE"
+ * → "WHY IT MATCHES"). A filtered list whose rows still advertise their
+ * most-named dish is claiming the filter matched something it did not.
+ *
+ * ## Header
+ *
+ * Deliberately none. The page composes `<SectionHeader>` above it, the same way
+ * the events hub does, because the heading here carries a count and a "see the
+ * full ranking" link into `/top` that the list knows nothing about.
+ */
+/** @deprecated Alias of `MenuLinkProps`; kept for symmetry with the other menu surfaces. */
+type MenuKitchenListLinkProps = MenuLinkProps;
+type MenuKitchenListLabels = {
+    /** Accessible prefix for the row's venue link, e.g. "Open". */
+    openVenue: (name: string) => string;
+    /** Accessible name for the dish link, e.g. "See Truffle Tagliatelle". */
+    openDish: (name: string) => string;
+    /** Accessible name for the open-now dot. */
+    openNow: string;
+    /** Reveals the next page of rows, e.g. "Show 10 more". */
+    showMore?: string;
+};
+type MenuKitchenListProps = {
+    kitchens: MenuKitchenPreview[];
+    labels: MenuKitchenListLabels;
+    /**
+     * Reveals more rows IN PLACE. The intent page pages ten at a time and never
+     * navigates for the eleventh — the list is the page.
+     */
+    onShowMore?: () => void;
+    linkComponent?: MenuLinkComponent;
+    className?: string;
+};
+declare function MenuKitchenList({ kitchens, labels, onShowMore, linkComponent, className, }: MenuKitchenListProps): react_jsx_runtime.JSX.Element;
+/**
+ * The list's own loading state, at the row's own footprint.
+ *
+ * It lives HERE, beside the component, and that is the whole point: a skeleton
+ * kept in the consuming app drifts the moment the row's padding or thumbnail
+ * size changes, and the drift is invisible until a page reflows on load. The
+ * measurements below are the same literals the row above uses — change one and
+ * the diff shows you the other.
+ */
+declare function MenuKitchenListSkeleton({ rows, className, }: {
+    rows?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+export { MenuKitchenList, type MenuKitchenListLabels, type MenuKitchenListLinkProps, type MenuKitchenListProps, MenuKitchenListSkeleton };

package/dist/components/menu-kitchen-list.js

@@ -0,0 +1,5 @@
+export { MenuKitchenList, MenuKitchenListSkeleton } from '../chunk-24RFI4RQ.js';
+import '../chunk-WSRWFA6K.js';
+import '../chunk-QXHMPJ35.js';
+import '../chunk-FEK5XGZW.js';
+import '../chunk-3GWWZKX7.js';

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

@@ -1,4 +1,4 @@
-import { MenuConceptPreview, MenuFamilyPreview, MenuIntentTile, MenuItemPreview, MenuVenuePreview } from './menu-types.js';
+import { MenuFamilyBlockPreview, MenuConceptPreview, MenuFamilyPreview, MenuFilterChip, MenuIndexEntry, MenuIntentFigure, MenuIntentTile, MenuItemPreview, MenuKitchenPreview, MenuLoosenOption, QaItem, MenuVenuePreview } from './menu-types.js';
 import { PlacePreview } from './place-types.js';
 import 'react';
 
@@ -51,5 +51,40 @@ declare const mockHubLabels: {
     openNow: string;
     until: string;
 };
+/**
+ * The intent page's kitchen rows.
+ *
+ * The gaps are the gaps the API actually has, and they are the reason the row
+ * degrades the way it does: `must_try` entries arrive from a LIST endpoint, so
+ * a third of them carry no `slug` (nothing to open — the dish line goes inert)
+ * and none of them carry `mentions` (only `review_ids.length`, which is absent
+ * for census items — so the count line disappears rather than reading zero).
+ * A layout that survives these survives production.
+ */
+declare const mockKitchens: MenuKitchenPreview[];
+/** The same rows in a filtered state — each answering the filter, not volunteering. */
+declare const mockMatchedKitchens: MenuKitchenPreview[];
+declare const mockIntentFigures: MenuIntentFigure[];
+/**
+ * Note there is no zero-count chip here, and that is not an oversight: the
+ * facets endpoint omits values that would match nothing, so a chip can only
+ * become `empty` client-side, after it was offered and the reader's next filter
+ * emptied it. The `Dead` story constructs that case deliberately.
+ */
+declare const mockFilterChips: MenuFilterChip[];
+declare const mockLoosenOptions: MenuLoosenOption[];
+/**
+ * The long tail is the point of these fixtures.
+ *
+ * Cluj's cuisine facet runs from 457 down to 1, and twenty-two of the
+ * thirty-eight have fewer than twenty places. A layout tested only on the head
+ * of that list looks fine and then ships a page whose last two columns are
+ * single digits.
+ */
+declare const mockIndexEntries: MenuIndexEntry[];
+declare const mockFamilyBlock: MenuFamilyBlockPreview;
+/** No photographs, no venue, no price — the degraded block still reads. */
+declare const mockBareFamilyBlock: MenuFamilyBlockPreview;
+declare const mockQa: QaItem[];
 
-export { mockConcept, mockDrinkFamily, mockFamily, mockFormatters, mockGradients, mockHubLabels, mockIntentTiles, mockItems, mockPlaces, mockVenues };
+export { mockBareFamilyBlock, mockConcept, mockDrinkFamily, mockFamily, mockFamilyBlock, mockFilterChips, mockFormatters, mockGradients, mockHubLabels, mockIndexEntries, mockIntentFigures, mockIntentTiles, mockItems, mockKitchens, mockLoosenOptions, mockMatchedKitchens, mockPlaces, mockQa, mockVenues };

package/dist/components/menu-mocks.js

@@ -1,4 +1,4 @@
-import '../chunk-3GWWZKX7.js';
+import { __spreadProps, __spreadValues } from '../chunk-3GWWZKX7.js';
 
 // src/components/menu-mocks.ts
 var mockGradients = {
@@ -312,19 +312,7 @@ var mockFamily = {
   price_low: 32,
   price_high: 84,
   price_median: 49,
-  venue_photo_urls: [],
-  signature: {
-    item: {
-      id: "f1",
-      slug: "truffle-tagliatelle",
-      name: "Truffle Tagliatelle",
-      kind: "dish",
-      mentions: 17,
-      sizes_and_prices: [{ size: 320, price: 62 }]
-    },
-    why: "Salt & Stone",
-    href: "/menu/dishes/truffle-tagliatelle"
-  }
+  venue_photo_urls: []
 };
 var mockDrinkFamily = {
   slug: "cocktail",
@@ -340,18 +328,7 @@ var mockDrinkFamily = {
   price_low: 18,
   price_high: 54,
   price_median: 28,
-  venue_photo_urls: [],
-  signature: {
-    item: {
-      id: "f2",
-      slug: "house-negroni",
-      name: "House negroni",
-      kind: "drink",
-      mentions: 16,
-      sizes_and_prices: [{ size: 150, price: 32 }]
-    },
-    why: "The Copper Yard"
-  }
+  venue_photo_urls: []
 };
 var intentGradient = (hue) => `linear-gradient(150deg, oklch(0.52 0.14 ${hue}), oklch(0.43 0.13 ${hue - 4}))`;
 var mockIntentTiles = [
@@ -375,5 +352,153 @@ var mockHubLabels = {
   openNow: "Open now",
   until: "until"
 };
+var mockKitchens = [
+  {
+    place: placeBySlug("salt-and-stone"),
+    href: "/places/salt-and-stone",
+    metaLabel: "courtyard \xB7 Centru",
+    hoursLabel: "kitchen until 23:00",
+    priceLabel: "62 lei",
+    dish: {
+      name: "Truffle Tagliatelle",
+      href: "/menu/dishes/truffle-tagliatelle",
+      kicker: "MOST NAMED HERE",
+      meta: "17 reviews name it"
+    }
+  },
+  {
+    place: placeBySlug("the-copper-yard"),
+    href: "/places/the-copper-yard",
+    metaLabel: "pizzeria \xB7 Centru",
+    hoursLabel: "kitchen until 23:30",
+    priceLabel: "54 lei",
+    dish: {
+      name: "Tagliatelle cu Hribi",
+      href: "/menu/dishes/tagliatelle-cu-hribi",
+      kicker: "MOST NAMED HERE",
+      meta: "14 reviews name it"
+    }
+  },
+  {
+    // Closed, and its must-try has no live menu row — the dish line is inert.
+    place: __spreadProps(__spreadValues({}, placeBySlug("the-quiet-hours")), { open_now: false }),
+    href: "/places/the-quiet-hours",
+    metaLabel: "bistro \xB7 Gheorgheni",
+    hoursLabel: "closed \xB7 opens 12:00",
+    priceLabel: "58 lei",
+    dish: { name: "Risotto ai Funghi", kicker: "MOST NAMED HERE" }
+  },
+  {
+    // No dish at all: the row must still read as a venue.
+    place: placeBySlug("green-room-canteen"),
+    href: "/places/green-room-canteen",
+    metaLabel: "bistro \xB7 Centru",
+    priceLabel: "38 lei"
+  }
+];
+var mockMatchedKitchens = mockKitchens.slice(0, 3).map((kitchen) => __spreadProps(__spreadValues({}, kitchen), {
+  dish: kitchen.dish && __spreadProps(__spreadValues({}, kitchen.dish), {
+    kicker: "WHY IT MATCHES",
+    meta: "mid-range \xB7 300g",
+    matched: true,
+    matchLabel: "vegetarian"
+  })
+}));
+var mockIntentFigures = [
+  { key: "total", value: "247", label: "kitchens" },
+  { key: "pizza", value: "120", label: "make a pizza", onSelect: () => {
+  } },
+  { key: "pasta", value: "96", label: "make pasta", onSelect: () => {
+  } },
+  { key: "open", value: "58", label: "open now", onSelect: () => {
+  } }
+];
+var mockFilterChips = [
+  { key: "open", label: "Open now", count: 58, active: true },
+  { key: "price", label: "Mid-range", count: 96 },
+  { key: "terrace", label: "Terrace", count: 31 },
+  { key: "veg", label: "Has a vegetarian dish", count: 84 },
+  { key: "late", label: "Serving past midnight", count: 4 },
+  { key: "centru", label: "Centru", count: 90 }
+];
+var mockLoosenOptions = [
+  { key: "open", label: "Drop \u201COpen now\u201D", gainLabel: "+8 kitchens" },
+  { key: "price", label: "Drop \u201CMid-range\u201D", gainLabel: "+7 kitchens" },
+  { key: "veg", label: "Drop \u201CVegetarian\u201D", gainLabel: "+2 kitchens" }
+];
+var mockIndexEntries = [
+  ["Breakfast & brunch", 314],
+  ["Romanian", 299],
+  ["Bakery", 250],
+  ["Italian", 247],
+  ["Pizza", 245],
+  ["Fast food", 229],
+  ["Vegetarian", 172],
+  ["American", 153],
+  ["Vegan", 108],
+  ["Mediterranean", 78],
+  ["Seafood", 77],
+  ["Eastern European", 67],
+  ["Fusion", 61],
+  ["Middle Eastern", 58],
+  ["BBQ", 57],
+  ["Deli", 51],
+  ["Steakhouse", 49],
+  ["Japanese", 34],
+  ["French", 26],
+  ["Sushi", 23],
+  ["Turkish", 22],
+  ["Chinese", 14],
+  ["Greek", 12],
+  ["Indian", 11],
+  ["Thai", 7],
+  ["German", 5],
+  ["Lebanese", 3],
+  ["Portuguese", 1]
+].map(([name, count], index) => ({
+  slug: String(name).toLowerCase().replace(/[^a-z]+/g, "-"),
+  name: String(name),
+  count: Number(count),
+  href: `/menu/cuisines/${String(name).toLowerCase().replace(/[^a-z]+/g, "-")}`,
+  gradient: Object.values(mockGradients)[index % 5]
+}));
+var mockFamilyBlock = {
+  slug: "italian",
+  name: "Italian",
+  venueCount: 247,
+  chips: [
+    { slug: "pizza", label: "Pizza", count: 120 },
+    { slug: "pasta", label: "Pasta", count: 96 },
+    { slug: "salad", label: "Salad", count: 88 }
+  ],
+  priceBandLabel: "22\u201386 lei",
+  photoUrls: [],
+  // Three, as the cuisines index sends, and stripped the same way: no dish and
+  // no price. The dish column is ~110px inside this card, which truncates the
+  // name and wraps its kicker to three lines; the price is already the band
+  // above.
+  venues: mockKitchens.slice(0, 3).map((kitchen) => __spreadProps(__spreadValues({}, kitchen), { dish: void 0, priceLabel: void 0 })),
+  href: "/menu/cuisines/italian"
+};
+var mockBareFamilyBlock = {
+  slug: "portuguese",
+  name: "Portuguese",
+  venueCount: 1,
+  href: "/menu/cuisines/portuguese"
+};
+var mockQa = [
+  {
+    question: "Which Italian kitchen is best in Cluj?",
+    answer: "Salt & Stone is named most often \u2014 seventeen reviews single out the truffle tagliatelle. The Copper Yard is second on volume and about eight lei cheaper across the menu."
+  },
+  {
+    question: "What does an Italian main cost?",
+    answer: "Pasta runs 38 to 84 lei and pizza 30 to 68 across these kitchens. Ninety-six of them sit in the mid-range price band."
+  },
+  {
+    question: "Anywhere open late?",
+    answer: "Four keep the kitchen going past midnight \u2014 The Copper Yard until 00:00 is the latest of the Italian rooms."
+  }
+];
 
-export { mockConcept, mockDrinkFamily, mockFamily, mockFormatters, mockGradients, mockHubLabels, mockIntentTiles, mockItems, mockPlaces, mockVenues };
+export { mockBareFamilyBlock, mockConcept, mockDrinkFamily, mockFamily, mockFamilyBlock, mockFilterChips, mockFormatters, mockGradients, mockHubLabels, mockIndexEntries, mockIntentFigures, mockIntentTiles, mockItems, mockKitchens, mockLoosenOptions, mockMatchedKitchens, mockPlaces, mockQa, mockVenues };

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

@@ -148,10 +148,8 @@ type MenuFamilyPreview = {
     price_low?: number;
     price_high?: number;
     price_median?: number;
-    /** Pre-resolved venue photos for the fanned deck. Venue photography only. */
+    /** Pre-resolved venue photos for the mosaic. Venue photography only. */
     venue_photo_urls?: string[];
-    /** The item this family is most named for. */
-    signature?: MenuFamilySignature;
 };
 type MenuFamilyChip = {
     slug: string;
@@ -159,8 +157,6 @@ type MenuFamilyChip = {
     /** Venue count. Absent where no facet backs the chip. */
     count?: number;
 };
-/** A family card's featured item. Same shape as a venue's, for the same reason. */
-type MenuFamilySignature = MenuVenueSignature;
 /**
  * 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 —
@@ -220,6 +216,186 @@ type MenuIntentTile = {
     /** 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". */
@@ -242,4 +418,4 @@ type MenuHubLabels = {
     until: string;
 };
 
-export { type MenuConceptPreview, type MenuConceptRow, type MenuFamilyChip, type MenuFamilyPreview, type MenuFamilySignature, type MenuFormatters, type MenuHubLabels, type MenuIntentTile, type MenuItemPlaceRef, type MenuItemPreview, type MenuLinkComponent, type MenuLinkProps, MenuSizeAndPrice, type MenuVenuePreview, type MenuVenueSignature };
+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/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" })
     ] })
@@ -60,7 +60,7 @@ 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 = {
@@ -108,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';