@bearmenu/ui 0.8.8 → 0.8.10

package/dist/components/top-ranking-hero.d.ts

@@ -0,0 +1,61 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { MenuLinkComponent } from './menu-types.js';
+import { TopExit } from './top-types.js';
+import 'react';
+import './place-types.js';
+
+type TopRankingHeroProps = {
+    /** e.g. "RANKED · CUISINE". */
+    kicker?: string;
+    title: string;
+    /** One paragraph: the size of the pool, and what the order means. */
+    lede?: string;
+    /** e.g. "Updated 6 September 2026". */
+    updatedLabel?: string;
+    /** e.g. "247 kitchens considered · 4,318 reviews read". */
+    metaLabel?: string;
+    exits?: TopExit[];
+    /** Finished CSS gradient for the ground. */
+    gradient?: string;
+    /** Watermark behind the text — the category's icon, resolved by the caller. */
+    icon?: React.ReactNode;
+    linkComponent?: MenuLinkComponent;
+    className?: string;
+};
+declare function TopRankingHero({ kicker, title, lede, updatedLabel, metaLabel, exits, gradient, icon, linkComponent: LinkComponent, className, }: TopRankingHeroProps): react_jsx_runtime.JSX.Element;
+/**
+ * TopMethodNote — how the ranking was computed, in one block.
+ *
+ * Under the hero rather than at the foot: a reader deciding whether to trust a
+ * list decides it before reading the list, not after.
+ */
+/**
+ * The note's surface, exported so a caller can put the same look on a TRIGGER.
+ *
+ * On `/top` the banner opens the grade explainer, and that explainer owns its
+ * own `<button>` (Radix clones it, so it cannot be handed a ready-made
+ * element). The caller therefore needs the surface without the element — hence
+ * a class string rather than a second component. `cn` at the call site lets the
+ * button's own `inline-flex` lose to the `flex` here.
+ */
+declare const topMethodNoteSurface = "flex w-full items-start gap-3 rounded-[14px] bg-muted p-4 text-left";
+type TopMethodNoteProps = {
+    /** The heading fragment, e.g. "How this is ranked." Rendered bold, inline. */
+    heading: string;
+    children: React.ReactNode;
+    /** Rendered after the prose — a chevron where the note is a disclosure trigger. */
+    affordance?: React.ReactNode;
+    className?: string;
+};
+/**
+ * The note's CONTENT, with no element of its own.
+ *
+ * Every tag here is phrasing content — spans, not paragraphs — because this
+ * renders inside a `<button>` when the note is a trigger, and a `<p>` inside a
+ * button is invalid. Keeping one definition of the content means the static
+ * note and the interactive one cannot drift apart.
+ */
+declare function TopMethodNoteBody({ heading, children, affordance, }: Omit<TopMethodNoteProps, "className">): react_jsx_runtime.JSX.Element;
+declare function TopMethodNote({ heading, children, affordance, className }: TopMethodNoteProps): react_jsx_runtime.JSX.Element;
+
+export { TopMethodNote, TopMethodNoteBody, type TopMethodNoteProps, TopRankingHero, type TopRankingHeroProps, topMethodNoteSurface };

package/dist/components/top-ranking-hero.js

@@ -0,0 +1,99 @@
+import { cn } from '../chunk-FEK5XGZW.js';
+import { __objRest, __spreadValues } from '../chunk-3GWWZKX7.js';
+import { Trophy, CalendarCheck, LayoutList, ArrowRight, Info } from 'lucide-react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+function DefaultLink(_a) {
+  var _b = _a, { href } = _b, props = __objRest(_b, ["href"]);
+  return /* @__PURE__ */ jsx("a", __spreadValues({ href }, props));
+}
+function TopRankingHero({
+  kicker,
+  title,
+  lede,
+  updatedLabel,
+  metaLabel,
+  exits,
+  gradient,
+  icon,
+  linkComponent: LinkComponent = DefaultLink,
+  className
+}) {
+  return /* @__PURE__ */ jsxs(
+    "header",
+    {
+      className: cn(
+        "relative overflow-hidden rounded-[18px] px-5 py-6 lg:px-8 lg:py-8",
+        !gradient && "bg-muted",
+        className
+      ),
+      children: [
+        gradient && /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: "absolute inset-0", style: { backgroundImage: gradient } }),
+        icon && /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": true,
+            className: "pointer-events-none absolute -right-6 -top-6 opacity-[0.14] [&>svg]:h-[150px] [&>svg]:w-[150px] lg:[&>svg]:h-[190px] lg:[&>svg]:w-[190px]",
+            children: icon
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "relative z-[1]", children: [
+          kicker && /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1.5 rounded-full bg-background/70 px-3 py-1 text-[11px] font-extrabold uppercase tracking-[0.09em] backdrop-blur-[2px]", children: [
+            /* @__PURE__ */ jsx(Trophy, { className: "h-3 w-3 shrink-0", "aria-hidden": true }),
+            kicker
+          ] }),
+          /* @__PURE__ */ jsx("h1", { className: "mt-3 max-w-[22ch] font-serif text-[30px] font-bold leading-[1.08] tracking-[-0.025em] lg:text-[44px]", children: title }),
+          lede && /* @__PURE__ */ jsx("p", { className: "mt-3 max-w-[62ch] text-[14.5px] leading-relaxed opacity-85", children: lede }),
+          (updatedLabel || metaLabel) && /* @__PURE__ */ jsxs("div", { className: "mt-4 flex flex-wrap items-center gap-x-3 gap-y-1.5 text-[12.5px]", children: [
+            updatedLabel && /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1.5 font-semibold", children: [
+              /* @__PURE__ */ jsx(CalendarCheck, { className: "h-3.5 w-3.5 shrink-0", "aria-hidden": true }),
+              updatedLabel
+            ] }),
+            updatedLabel && metaLabel && /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: "h-1 w-1 rounded-full bg-current opacity-40" }),
+            metaLabel && /* @__PURE__ */ jsx("span", { className: "opacity-75", children: metaLabel })
+          ] }),
+          exits && exits.length > 0 && /* @__PURE__ */ jsx("div", { className: "mt-5 hidden flex-col gap-2 sm:flex-row lg:flex", children: exits.map((exit, index) => {
+            var _a;
+            return /* @__PURE__ */ jsxs(
+              LinkComponent,
+              {
+                href: exit.href,
+                className: cn(
+                  "inline-flex h-11 items-center justify-center gap-2 rounded-xl px-4 text-sm font-bold transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 motion-reduce:transition-none",
+                  index === 0 ? "bg-background text-foreground hover:bg-background/90" : "border border-current/25 hover:bg-background/25"
+                ),
+                children: [
+                  (_a = exit.icon) != null ? _a : /* @__PURE__ */ jsx(LayoutList, { className: "h-4 w-4 shrink-0", "aria-hidden": true }),
+                  exit.label,
+                  /* @__PURE__ */ jsx(ArrowRight, { className: "h-3.5 w-3.5 shrink-0", "aria-hidden": true })
+                ]
+              },
+              exit.href
+            );
+          }) })
+        ] })
+      ]
+    }
+  );
+}
+var topMethodNoteSurface = "flex w-full items-start gap-3 rounded-[14px] bg-muted p-4 text-left";
+function TopMethodNoteBody({
+  heading,
+  children,
+  affordance
+}) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Info, { className: "mt-0.5 h-4 w-4 shrink-0 text-muted-foreground", "aria-hidden": true }),
+    /* @__PURE__ */ jsxs("span", { className: "block text-[13px] leading-relaxed text-muted-foreground", children: [
+      /* @__PURE__ */ jsx("b", { className: "font-bold text-foreground", children: heading }),
+      " ",
+      children
+    ] }),
+    affordance
+  ] });
+}
+function TopMethodNote({ heading, children, affordance, className }) {
+  return /* @__PURE__ */ jsx("aside", { className: cn(topMethodNoteSurface, className), children: /* @__PURE__ */ jsx(TopMethodNoteBody, { heading, affordance, children }) });
+}
+
+export { TopMethodNote, TopMethodNoteBody, TopRankingHero, topMethodNoteSurface };

package/dist/components/top-ranking-legend.d.ts

@@ -0,0 +1,69 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * TopRankingLegend — the ranking as a place you are inside of, not a table.
+ *
+ * ## What it stopped being
+ *
+ * It was a two-column table: rank, name, grade, with a rule under every row.
+ * Three things were wrong with that, and they compounded.
+ *
+ * The **grade column** was the loudest thing in it and the least useful thing
+ * for navigating — twenty-five near-identical numbers in accent colour,
+ * duplicating a grade shown at full size two inches to the right, and eating
+ * the width that was truncating the names. The one field you navigate by was
+ * the one being cut. It is gone.
+ *
+ * The **dividers** ran full-bleed to the column's right edge, so every rule was
+ * a small arrow pointing at the article and nothing ever visually ended the
+ * aside. Space separates now; contrast is spent on state instead.
+ *
+ * And there was **no active row at all** — twenty-five identical entries in a
+ * component whose entire job is orientation. That is what the observer below
+ * is for.
+ *
+ * ## The rank numeral is the rail
+ *
+ * The reference this is drawn from uses a status ring down the left edge. A
+ * ring is wrong here: it promises completion state we do not track and would
+ * never fill. The rank numeral is already present, already tabular, and is
+ * itself the thing being ranked — a better rail, for free.
+ *
+ * ## Grouped, because twenty-five is not a list you can hold
+ *
+ * By grade band, which is the one honest grouping available: the tiers are
+ * already printed on the entries, so the aside is not inventing a taxonomy. It
+ * also says something true — that the top few are a different class.
+ *
+ * The column will still exceed the viewport at twenty-five, and that is
+ * accepted rather than solved: an internally-scrolling sidebar is a second page,
+ * and grouping plus a live active row makes the overflow navigable.
+ *
+ * ## The phone keeps its chips
+ *
+ * Below `lg` this is a horizontal scroller of the flat list, unchanged. None of
+ * the above applies to a chip row — there is nothing to group, no column to
+ * inset, and the active state is a press away rather than a scroll away.
+ */
+type TopRankingLegendEntry = {
+    rank: number;
+    slug: string;
+    name: string;
+};
+type TopRankingLegendGroup = {
+    key: string;
+    /** Grade band, e.g. "Exceptional". Letterspaced caps — structure, not content. */
+    label: string;
+    entries: TopRankingLegendEntry[];
+};
+type TopRankingLegendProps = {
+    groups: TopRankingLegendGroup[];
+    /** e.g. "The ranking". */
+    heading: string;
+    /** The size and freshness of the thing, e.g. "25 places · updated September 2026". */
+    meta?: string;
+    className?: string;
+};
+declare function TopRankingLegend({ groups, heading, meta, className }: TopRankingLegendProps): react_jsx_runtime.JSX.Element;
+
+export { TopRankingLegend, type TopRankingLegendEntry, type TopRankingLegendGroup, type TopRankingLegendProps };

package/dist/components/top-ranking-legend.js

@@ -0,0 +1,124 @@
+import { cn } from '../chunk-FEK5XGZW.js';
+import '../chunk-3GWWZKX7.js';
+import { useState, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var ACTIVE_BAND = "-20% 0px -75% 0px";
+function TopRankingLegend({ groups, heading, meta, className }) {
+  const entries = groups.flatMap((group) => group.entries);
+  const [activeSlug, setActiveSlug] = useState(null);
+  useEffect(() => {
+    if (typeof IntersectionObserver === "undefined") return void 0;
+    const nodes = entries.map((entry) => document.getElementById(entry.slug)).filter((node) => Boolean(node));
+    if (nodes.length === 0) return void 0;
+    const observer = new IntersectionObserver(
+      (observed) => {
+        const inBand = observed.filter((record) => record.isIntersecting);
+        if (inBand.length === 0) return;
+        const topmost = inBand.reduce(
+          (best, record) => record.boundingClientRect.top < best.boundingClientRect.top ? record : best
+        );
+        setActiveSlug(topmost.target.id);
+      },
+      { rootMargin: ACTIVE_BAND }
+    );
+    nodes.forEach((node) => observer.observe(node));
+    return () => observer.disconnect();
+  }, [entries.map((entry) => entry.slug).join("|")]);
+  return (
+    /*
+     * The height cap is a safety net, not the navigation model.
+     *
+     * `position: sticky` on an element TALLER than the viewport leaves its
+     * bottom permanently unreachable — at twenty-five rows on a 900px laptop
+     * you could never see ranks 20–25, however you scrolled. That is broken
+     * rather than merely tight, so the column scrolls internally once it
+     * exceeds the space available.
+     *
+     * It only ever engages on a viewport too short to fit the list: `max-height`
+     * with `overflow-y-auto` is inert when the content already fits, so nothing
+     * changes on a tall screen. `overscroll-contain` stops a flick inside the
+     * column from carrying on into the article behind it.
+     */
+    /* @__PURE__ */ jsxs(
+      "nav",
+      {
+        "aria-label": heading,
+        className: cn(
+          /*
+           * Sticky at BOTH widths now, with a different offset and a different
+           * shape at each.
+           *
+           * On desktop it is the grouped column, pinned beside the article. On a
+           * phone it is the flat chip rail, pinned for the same reason the column
+           * is: this page is twenty-five long entries, so a reader at rank 14 is
+           * several screens from any means of jumping, and the rail scrolled away
+           * inside the first entry.
+           *
+           * The phone offset comes from `--legend-sticky-top`, which the CALLER
+           * sets, because it is that app's chrome — the consumer app pins under a
+           * fixed header at `calc(var(--header-offset) + env(safe-area-inset-top))`,
+           * exactly as its events day rail does. Reading the app's own
+           * `--header-offset` here would resolve to nothing in Storybook and in
+           * the other three consumers, and an invalid `calc` silently kills
+           * `top`, which turns the rail from mispositioned into not-sticky.
+           */
+          "sticky top-[var(--legend-sticky-top,0px)] z-20 lg:top-4 lg:z-auto",
+          "lg:max-h-[calc(100vh-2rem)] lg:self-start lg:overflow-y-auto lg:overscroll-contain",
+          "lg:[scrollbar-width:thin]",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "hidden lg:block", children: [
+            /* @__PURE__ */ jsx("h2", { className: "text-[15px] font-bold tracking-[-0.01em]", children: heading }),
+            meta && /* @__PURE__ */ jsx("p", { className: "mt-1 text-[11.5px] text-muted-foreground", children: meta })
+          ] }),
+          /* @__PURE__ */ jsx("ul", { className: "scrollbar-hide -mx-[var(--page-gutter)] flex gap-2 overflow-x-auto bg-background px-[var(--page-gutter)] pb-3 pt-1 lg:hidden", children: entries.map((entry) => /* @__PURE__ */ jsx("li", { className: "shrink-0", children: /* @__PURE__ */ jsxs(
+            "a",
+            {
+              href: `#${entry.slug}`,
+              className: "inline-flex h-9 items-center gap-2 whitespace-nowrap rounded-full border border-border bg-card px-3.5 text-[13px] transition-colors hover:border-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring motion-reduce:transition-none",
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "font-bold tabular-nums text-muted-foreground", children: entry.rank }),
+                entry.name
+              ]
+            }
+          ) }, entry.slug)) }),
+          /* @__PURE__ */ jsx("div", { className: "hidden lg:mt-5 lg:-mx-3 lg:block", children: groups.map((group) => /* @__PURE__ */ jsxs("div", { className: "mb-4 last:mb-0", children: [
+            /* @__PURE__ */ jsx("p", { className: "px-3 pb-1.5 text-[10.5px] font-bold uppercase tracking-[0.11em] text-muted-foreground", children: group.label }),
+            /* @__PURE__ */ jsx("ul", { children: group.entries.map((entry) => {
+              const isActive = entry.slug === activeSlug;
+              return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs(
+                "a",
+                {
+                  href: `#${entry.slug}`,
+                  "aria-current": isActive ? "location" : void 0,
+                  className: cn(
+                    "flex gap-2.5 rounded-lg px-3 py-2 text-[13px] leading-snug transition-colors motion-reduce:transition-none",
+                    "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                    isActive ? "bg-accent-subtle font-semibold text-foreground" : "text-muted-foreground hover:bg-muted/50 hover:text-foreground"
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        className: cn(
+                          "w-5 shrink-0 text-right font-bold tabular-nums",
+                          isActive ? "text-accent" : "text-muted-foreground/70"
+                        ),
+                        children: entry.rank
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1", children: entry.name })
+                  ]
+                }
+              ) }, entry.slug);
+            }) })
+          ] }, group.key)) })
+        ]
+      }
+    )
+  );
+}
+
+export { TopRankingLegend };

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

@@ -0,0 +1,109 @@
+import { ReactNode } from 'react';
+import { MenuItemPreview } from './menu-types.js';
+import './place-types.js';
+
+/**
+ * The editorial ranking's view model — `/top/[category]`.
+ *
+ * Separate from `menu-types.ts` on purpose. The menu surfaces describe what a
+ * city HAS; these describe an argument the product is making about it, and the
+ * shapes reflect that: an entry carries a cited quote and a dated price because
+ * a rank is a claim and the page has to show why.
+ *
+ * Same contract as everywhere else: no app schemas, no hooks, no i18n. Strings
+ * arrive through labels, destinations through `href`, numbers through injected
+ * formatters.
+ */
+
+/** One entry in the ranking. */
+type TopRankEntry = {
+    rank: number;
+    slug: string;
+    name: string;
+    /** The venue page. */
+    href: string;
+    /** Neighbourhood, e.g. "Centru". */
+    district?: string;
+    /** Pre-resolved venue photograph. */
+    coverUrl?: string;
+    /** The app's grade, already formatted — "9.4". Absent where none exists. */
+    gradeLabel?: string;
+    /** The band that grade falls in, e.g. "Exceptional". Composed by the caller. */
+    tierLabel?: string;
+    /** Third-party star rating, shown only where there is no grade. */
+    rating?: number;
+    /**
+     * The editorial line — why this one is here, in the product's own voice.
+     *
+     * Distinct from `evidence`, which is a reviewer's words. Conflating them was
+     * the old page's problem: a quote presented as editorial reads as invented,
+     * and editorial presented as a quote reads as dishonest.
+     */
+    editorial?: string;
+    /**
+     * The dishes this venue is named for, as PRODUCTION MENU ROWS.
+     *
+     * `MenuItemPreview`, so the entry renders the same `<MenuItem>` a venue's own
+     * menu and every hub surface renders. The first pass here hand-rolled a row —
+     * a bold name, a muted description, a price — which drifted from the real one
+     * immediately and meant a dish looked like a different object on this page
+     * than on every other.
+     *
+     * More than one, because a rank is a claim about a kitchen and one dish
+     * rarely carries it: the live page shows the group and two or three of its
+     * most-named plates.
+     */
+    menuItems?: MenuItemPreview[];
+    /** The group those items sit in, e.g. "Pizza". From the venue's own menu. */
+    menuGroupLabel?: string;
+    /** A reviewer's own words, and how many said it. */
+    evidence?: TopEvidence;
+};
+type TopEvidence = {
+    /**
+     * A reviewer's own words. OPTIONAL: a venue can carry a mention count with no
+     * quotable snippet behind it, and the count is evidence in its own right —
+     * dropping the whole block for want of a quote loses the number that
+     * justifies the rank.
+     */
+    quote?: string;
+    /**
+     * How many reviews back it — the figure alone, e.g. "37". Rendered as its own
+     * element beside `sourceLabel` so the number reads as a figure rather than as
+     * the first word of a sentence.
+     */
+    count?: string;
+    /** What the count is evidence OF, e.g. "reviews praise the shawarma here". */
+    sourceLabel: string;
+    /**
+     * The rest of the cited reviews, behind a disclosure.
+     *
+     * A `<details>`, not a drawer, and that is the whole point: its contents stay
+     * in the HTML, so the evidence is crawlable and readable with no JavaScript.
+     * A page whose entire argument is "here is why" cannot ship most of the why
+     * in a modal.
+     */
+    extraQuotes?: string[];
+    /** Summary text for the disclosure, e.g. "2 more reviews". Pluralised by the caller. */
+    extraLabel?: string;
+};
+/** One row of the side-by-side comparison. */
+type TopComparisonRow = {
+    rank: number;
+    name: string;
+    href: string;
+    gradeLabel?: string;
+    signature?: string;
+    priceLabel?: string;
+    /** Kitchen serving past midnight. */
+    late?: boolean;
+    terrace?: boolean;
+};
+/** A way out of the article and into the browsing tool. */
+type TopExit = {
+    label: string;
+    href: string;
+    icon?: ReactNode;
+};
+
+export type { TopComparisonRow, TopEvidence, TopExit, TopRankEntry };

package/dist/components/top-types.js

@@ -0,0 +1 @@
+

package/dist/components/venue-grade-dimensions.d.ts

@@ -0,0 +1,38 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { PlaceGradeDimensions } from './place-types.js';
+
+/**
+ * VenueGradeDimensions — the per-dimension review scores as a row of bars.
+ *
+ * ## Why this renders what it is given rather than a fixed row
+ *
+ * A dimension the reviews never mention is ABSENT from the payload, not zero,
+ * and exactly one of `food` / `coffee_quality` / `drinks_quality` is scored per
+ * place — a coffee bar has no food score and a restaurant has no coffee one.
+ * So a component drawing seven fixed columns would invent readings for a third
+ * of the catalogue. It iterates `order`, skips what is missing, and lays out
+ * however many survive.
+ *
+ * Scores arrive 0–100 and display on the 0–10 scale the rest of the product
+ * grades on, so the bar width is the raw value and the numeral is that value
+ * over ten. `formatScore` is injected because a decimal separator is
+ * locale-dependent.
+ *
+ * Server-safe.
+ */
+type VenueGradeDimensionKey = keyof PlaceGradeDimensions;
+/** Canonical order. Quality leads, and the three quality keys are mutually exclusive. */
+declare const DIMENSION_ORDER: VenueGradeDimensionKey[];
+type VenueGradeDimensionsProps = {
+    dimensions: PlaceGradeDimensions;
+    /** Dimension key → translated label. Keys with no label fall back to the key. */
+    labels: Partial<Record<VenueGradeDimensionKey, string>>;
+    /** Override the canonical order, or narrow which dimensions show at all. */
+    order?: VenueGradeDimensionKey[];
+    /** 0–100 → display numeral, e.g. `(v) => (v / 10).toFixed(1)`. */
+    formatScore: (value: number) => string;
+    className?: string;
+};
+declare function VenueGradeDimensions({ dimensions, labels, order, formatScore, className, }: VenueGradeDimensionsProps): react_jsx_runtime.JSX.Element | null;
+
+export { DIMENSION_ORDER, type VenueGradeDimensionKey, VenueGradeDimensions, type VenueGradeDimensionsProps };

package/dist/components/venue-grade-dimensions.js

@@ -0,0 +1,3 @@
+export { DIMENSION_ORDER, VenueGradeDimensions } from '../chunk-AKQ57NXY.js';
+import '../chunk-FEK5XGZW.js';
+import '../chunk-3GWWZKX7.js';

package/dist/components/venue-quotes.d.ts

@@ -0,0 +1,32 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CitedText } from './place-types.js';
+
+/**
+ * VenueQuotes — the digest's standout lines, as pull-quotes.
+ *
+ * These are `reviews_digest.highlights`: one to three short positives already
+ * resolved into the request locale. They are the only place on a hub where a
+ * reviewer speaks in their own register, so they are set in serif italic
+ * against the sans everything else uses.
+ *
+ * `onCite` turns a quote into a button that opens the reviews behind it —
+ * `review_ids` is what makes the claim checkable, and a quote nobody can trace
+ * is just copy. Without the handler the quote renders as inert prose, which is
+ * correct on surfaces that have nowhere to open.
+ *
+ * No directive: inert quotes render on the server; passing `onCite` needs a
+ * client caller.
+ */
+type VenueQuotesProps = {
+    quotes: CitedText[];
+    /** Opens the reviews behind one quote. Omit to render inert prose. */
+    onCite?: (quote: CitedText) => void;
+    /** Accessible name for the cite action, e.g. `(n) => "Read 5 reviews"`. */
+    citeLabel?: (reviewCount: number) => string;
+    /** Cap on how many render. The digest ships at most three. */
+    limit?: number;
+    className?: string;
+};
+declare function VenueQuotes({ quotes, onCite, citeLabel, limit, className }: VenueQuotesProps): react_jsx_runtime.JSX.Element | null;
+
+export { VenueQuotes, type VenueQuotesProps };

package/dist/components/venue-quotes.js

@@ -0,0 +1,3 @@
+export { VenueQuotes } from '../chunk-62ES6N32.js';
+import '../chunk-FEK5XGZW.js';
+import '../chunk-3GWWZKX7.js';

package/dist/components/venue-wall.d.ts

@@ -0,0 +1,41 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { MenuLinkComponent, MenuLinkProps } from './menu-types.js';
+import { PlacePreview } from './place-types.js';
+import 'react';
+
+/**
+ * VenueWall — the catalogue's scale, stated as a row of the venues in it.
+ *
+ * A closing beat rather than a browse surface: the avatars are named and
+ * linked, but the module's job is to make "we read every menu in the city"
+ * land as something specific. It shows a handful and counts the rest, because
+ * a wall long enough to be exhaustive stops reading as places.
+ *
+ * Server-safe.
+ */
+/** @deprecated Alias of `MenuLinkProps`; kept so existing imports keep working. */
+type VenueWallLinkProps = MenuLinkProps;
+type VenueWallProps = {
+    places: PlacePreview[];
+    /** Destination per place, keyed by slug. Without one an avatar is inert. */
+    hrefs?: Record<string, string>;
+    kicker?: string;
+    kickerIcon?: React.ReactNode;
+    headline?: string;
+    body?: string;
+    /** Composed overflow chip, e.g. "+393 more". */
+    overflowLabel?: string;
+    /**
+     * Tiles for the mosaic ground — the same licensed stills the hero uses.
+     * Without them the wall falls back to the flat diagonal texture, which is
+     * the degraded state rather than the design.
+     */
+    tileUrls?: string[];
+    /** The action — pass a rendered link or button. */
+    action?: React.ReactNode;
+    className?: string;
+    linkComponent?: MenuLinkComponent;
+};
+declare function VenueWall({ places, hrefs, kicker, kickerIcon, headline, body, overflowLabel, tileUrls, action, linkComponent: LinkComponent, className, }: VenueWallProps): react_jsx_runtime.JSX.Element;
+
+export { VenueWall, type VenueWallLinkProps, type VenueWallProps };