@stapel/search-react 0.20.0 → 0.22.0

package/src/default/PartitionChips.tsx

@@ -0,0 +1,161 @@
+/**
+ * `<PartitionChips>` — the children of a `chips` category, as one row of
+ * single-select chips.
+ *
+ * A partition is a category whose children are not subcategories but one
+ * template split by a value their names express: buy / sell / let / rent,
+ * new / used, for boys / for girls. They keep their
+ * ids, their paths and their URLs — a listing still lands on a child — and
+ * only the PRESENTATION changes: the parent draws a feed, and the children
+ * are a choice above it rather than a grid of tiles the visitor has to pass
+ * through.
+ *
+ * Which categories are a partition is not decided here and not decided by
+ * this pair: `children_as` is a stored, derivable field on the category, and
+ * the storefront hands this component the children it resolved. What this
+ * component owns is that the choice is SINGLE-select and that "all" — the
+ * parent, unnarrowed — is one of the options rather than a way of clearing
+ * the others.
+ *
+ * ── Why a radiogroup and not a row of toggles ─────────────────────────────
+ *
+ * Because exactly one of them is true at a time, and `aria-pressed` buttons
+ * say the opposite: they announce a set of independent switches, so a screen
+ * reader user hears no reason why pressing one released another. A radiogroup
+ * with roving tabindex is the pattern for "one of these": Tab reaches the row
+ * once and lands on the chosen chip, the arrow keys move along it, and the
+ * group's own name says what is being chosen.
+ */
+import { useRef } from "react";
+import type {
+  CSSProperties,
+  KeyboardEvent as ReactKeyboardEvent,
+  ReactElement,
+  ReactNode,
+} from "react";
+import { Button } from "antd";
+import { useT } from "@stapel/core";
+import { radii, spacing } from "@stapel/tokens";
+import { SEARCH_I18N_KEYS } from "../i18n/keys.js";
+
+/** One child of a partitioned category. `path` is the slash-joined id path
+ * the `category` parameter takes — the same string `SearchQueryState.category`
+ * carries, so a host never rebuilds it from ids. */
+export interface PartitionChild {
+  readonly id: number | string;
+  readonly path: string;
+  readonly name: string;
+}
+
+export interface PartitionChipsProps {
+  /** The children, in the order the catalogue declares them. */
+  readonly items: readonly PartitionChild[];
+  /** The chosen child's `path`, or `null` for the parent itself. CONTROLLED:
+   * this row keeps no state, because the choice is a `category` in the URL. */
+  readonly value: string | null;
+  readonly onChange: (path: string | null) => void;
+  /** The first chip's label. Defaults to `search.partition.all`. */
+  readonly allLabel?: ReactNode;
+  /** The row's accessible name. Defaults to `search.partition.label`. */
+  readonly label?: string;
+}
+
+const CHIP: CSSProperties = { borderRadius: radii.full };
+
+const ROW: CSSProperties = {
+  display: "flex",
+  flexWrap: "wrap",
+  gap: spacing[2],
+};
+
+/** The row's cells, as `[value, label]` — the parent first, then the
+ * children in catalogue order. */
+function cells(
+  items: readonly PartitionChild[],
+  allLabel: ReactNode
+): readonly (readonly [string | null, ReactNode])[] {
+  return [
+    [null, allLabel] as const,
+    ...items.map((item) => [item.path, item.name] as const),
+  ];
+}
+
+export function PartitionChips(props: PartitionChipsProps): ReactElement {
+  const t = useT();
+  const row = useRef<HTMLDivElement>(null);
+  const options = cells(
+    props.items,
+    props.allLabel ?? t(SEARCH_I18N_KEYS.partitionAll)
+  );
+
+  /**
+   * Arrow keys move the choice AND the focus, which is what a radiogroup
+   * does: in a single-select row the focused option is the selected one, so
+   * moving focus without choosing would leave the two disagreeing.
+   */
+  const onKeyDown =
+    (index: number) =>
+    (event: ReactKeyboardEvent): void => {
+    const step =
+      event.key === "ArrowRight" || event.key === "ArrowDown"
+        ? 1
+        : event.key === "ArrowLeft" || event.key === "ArrowUp"
+          ? -1
+          : event.key === "Home"
+            ? -index
+            : event.key === "End"
+              ? options.length - 1 - index
+              : 0;
+    if (step === 0) return;
+    event.preventDefault();
+    const next = (index + step + options.length) % options.length;
+    const cell = options[next];
+    if (cell === undefined) return;
+    props.onChange(cell[0]);
+    const buttons = row.current?.querySelectorAll<HTMLElement>('[role="radio"]');
+    buttons?.[next]?.focus();
+  };
+
+  // A `value` naming no cell (a link into a child that has since moved) must
+  // still leave the row reachable by Tab, so the roving stop falls back to the
+  // parent chip rather than vanishing.
+  const active = options.findIndex(([value]) => value === props.value);
+  const stop = active >= 0 ? active : 0;
+
+  return (
+    <div
+      style={ROW}
+      ref={row}
+      role="radiogroup"
+      aria-label={props.label ?? t(SEARCH_I18N_KEYS.partitionLabel)}
+      data-testid="partition-chips"
+    >
+      {options.map(([value, label], index) => {
+        const selected = value === props.value;
+        return (
+          <Button
+            key={value ?? "__all__"}
+            size="small"
+            shape="round"
+            type={selected ? "primary" : "default"}
+            role="radio"
+            aria-checked={selected}
+            // Roving tabindex: the row is ONE Tab stop and it lands on the
+            // chosen chip, not on the first of eight.
+            tabIndex={index === stop ? 0 : -1}
+            style={CHIP}
+            data-testid={`partition-chip-${value ?? "all"}`}
+            data-analytics="none"
+            data-analytics-reason="choosing a section is a read, not a flow step"
+            onKeyDown={onKeyDown(index)}
+            onClick={() => {
+              props.onChange(value);
+            }}
+          >
+            {label}
+          </Button>
+        );
+      })}
+    </div>
+  );
+}

package/src/default/PopularValues.tsx

@@ -0,0 +1,151 @@
+/**
+ * `<PopularValues>` — the busiest values of one facet, printed as words a
+ * person can click, above the results.
+ *
+ * A dictionary facet in the rail answers "narrow this list"; it does not
+ * answer "what is IN this category". On a feed page of a cars leaf the second
+ * question is the one a visitor arrives with, and its answer is already in the
+ * envelope: `Toyota 802` is a bucket and its count. Printed as a multi-column
+ * block it is a table of contents for the category — the eleven makes that
+ * account for most of it, in one glance, each one a filter.
+ *
+ * ── What it is NOT ────────────────────────────────────────────────────────
+ *
+ * Not a replacement for the facet control: it shows the busy head of ONE
+ * group and says so with a link into the whole thing (`onShowAll`). Not a
+ * second source of counts either — the numbers are the answer's own
+ * drill-down counts, the same ones the checkbox rows carry, so a value cannot
+ * read `802` here and `93` in the panel.
+ *
+ * ── Hidden on a phone by a PROP ───────────────────────────────────────────
+ *
+ * `hidden` rather than a media query inside, because whether a 390px screen
+ * has room for a block of forty links is a decision about the PAGE, and the
+ * page is the storefront's. A component that hid itself below some width of
+ * its own choosing would take that decision away from the only surface that
+ * knows what else is on screen — and would still render the DOM, which is
+ * what `display: none` costs a screen reader.
+ */
+import type { CSSProperties, ReactElement, ReactNode } from "react";
+import { Button, Flex, Typography } from "antd";
+import { useT } from "@stapel/core";
+import { spacing } from "@stapel/tokens";
+import type { FacetGroup, FacetOption } from "../state/facets.js";
+import { SEARCH_I18N_KEYS } from "../i18n/keys.js";
+
+/** How many values the block prints before the link into the full control. */
+export const POPULAR_VALUES_LIMIT = 12;
+
+/** How many columns the list flows into. Three fills a desktop content column
+ * without turning a make into a two-line wrap. */
+export const POPULAR_VALUES_COLUMNS = 3;
+
+/** A value with no evidence behind it is not a popular value. Uncounted
+ * options carry `count: null` and are dropped here rather than printed with a
+ * blank where the number belongs — the block IS the numbers. */
+function hasEvidence(option: FacetOption): boolean {
+  return option.count !== null && option.count > 0;
+}
+
+/** The busiest values of the group, count-descending, capped. */
+export function popularOptions(
+  group: FacetGroup,
+  limit: number = POPULAR_VALUES_LIMIT
+): readonly FacetOption[] {
+  return [...group.options.filter(hasEvidence)]
+    .sort((a, b) => (b.count ?? 0) - (a.count ?? 0))
+    .slice(0, limit);
+}
+
+const ROW: CSSProperties = {
+  // `break-inside` keeps a value and its count on one line when the browser
+  // decides where the column ends.
+  breakInside: "avoid",
+  display: "flex",
+  gap: spacing[2],
+  alignItems: "baseline",
+};
+
+export interface PopularValuesProps {
+  /** The group to print — normally the first `ref_select` of the plan. */
+  readonly group: FacetGroup;
+  /** Apply one value. Same signature as the panel's `toggle`, so a host can
+   * hand the facet bag's own function straight in. */
+  readonly onApply: (slug: string, value: string) => void;
+  /** Draw nothing. The phone, decided by the page — see the module note. */
+  readonly hidden?: boolean;
+  /** How many values. Default {@link POPULAR_VALUES_LIMIT}. */
+  readonly limit?: number;
+  /** How many columns. Default {@link POPULAR_VALUES_COLUMNS}. */
+  readonly columns?: number;
+  /** The block's heading. Defaults to the group's own label; `null` draws
+   * none, for a surface that has already named the axis. */
+  readonly heading?: ReactNode;
+  /** Open the full control. Absent draws no link — a link that goes nowhere
+   * is worse than a block that stops. */
+  readonly onShowAll?: () => void;
+}
+
+export function PopularValues(props: PopularValuesProps): ReactElement | null {
+  const t = useT();
+  const { group } = props;
+  if (props.hidden === true) return null;
+  const options = popularOptions(group, props.limit ?? POPULAR_VALUES_LIMIT);
+  if (options.length === 0) return null;
+
+  return (
+    <Flex
+      vertical
+      gap={spacing[2]}
+      data-testid={`popular-values-${group.slug}`}
+      data-label-source={group.labelSource}
+    >
+      {props.heading !== null && (
+        <Typography.Text strong>{props.heading ?? group.label}</Typography.Text>
+      )}
+      <div
+        style={{
+          columnCount: props.columns ?? POPULAR_VALUES_COLUMNS,
+          columnGap: spacing[4],
+        }}
+      >
+        {options.map((option) => (
+          <div key={option.value} style={ROW}>
+            <Button
+              type="link"
+              size="small"
+              style={{ paddingInline: 0, height: "auto" }}
+              data-testid={`popular-value-${group.slug}-${option.value}`}
+              data-analytics="none"
+              data-analytics-reason="a filter is a read, not a flow step"
+              onClick={() => {
+                props.onApply(group.slug, option.value);
+              }}
+            >
+              {option.label}
+            </Button>
+            <Typography.Text
+              type="secondary"
+              data-testid={`popular-count-${group.slug}-${option.value}`}
+            >
+              {option.count}
+            </Typography.Text>
+          </div>
+        ))}
+      </div>
+      {props.onShowAll !== undefined && (
+        <Button
+          type="link"
+          size="small"
+          style={{ alignSelf: "flex-start", paddingInline: 0 }}
+          data-testid={`popular-all-${group.slug}`}
+          data-analytics="none"
+          data-analytics-reason="opening a filter control is a read, not a flow step"
+          onClick={props.onShowAll}
+        >
+          {t(SEARCH_I18N_KEYS.facetsPopularAll)}
+        </Button>
+      )}
+    </Flex>
+  );
+}

package/src/default/SearchPage.tsx

@@ -426,6 +426,11 @@ function SearchPageBody(props: SearchPageBodyProps): ReactElement {
   const filtersEmpty =
     facets.state.status === "ready" &&
     facets.state.data.length === 0 &&
+    // Zero groups is not zero filters: `withheld` names groups the server
+    // counted and held back for covering too little of the result set, and
+    // the panel's job is to say how many (D175). Skipping the column would
+    // put that sentence nowhere.
+    facets.withheld.length === 0 &&
     facets.activeFilters === 0 &&
     ranges.length === 0 &&
     state.category === undefined &&

package/src/default/index.ts

@@ -72,6 +72,8 @@ export {
   FacetGroupControl,
   facetGroupShape,
   facetOptionNodes,
+  isDictionaryFacet,
+  FACET_DICTIONARY_THRESHOLD,
   FACET_VISIBLE_OPTIONS,
 } from "./FacetGroupControl.js";
 export type {
@@ -80,6 +82,19 @@ export type {
   FacetOptionNode,
 } from "./FacetGroupControl.js";
 
+// ── the browse surfaces a storefront PLACES (this pair does not lay them
+//    out: where a popular-values block or a partition row belongs on a
+//    category page is the page's decision) ──────────────────────────────────
+export {
+  PopularValues,
+  popularOptions,
+  POPULAR_VALUES_COLUMNS,
+  POPULAR_VALUES_LIMIT,
+} from "./PopularValues.js";
+export type { PopularValuesProps } from "./PopularValues.js";
+export { PartitionChips } from "./PartitionChips.js";
+export type { PartitionChild, PartitionChipsProps } from "./PartitionChips.js";
+
 export { FacetPanelPane } from "./FacetPanelPane.js";
 export type {
   FacetPanelPaneProps,

package/src/headless/FacetPanel.tsx

@@ -2,9 +2,15 @@ import type { ReactNode } from "react";
 import { loadStateFromQuery, mapLoad, useT } from "@stapel/core";
 import type { LoadState } from "@stapel/core";
 import type { FeatureDef } from "@stapel/attributes-react";
-import type { FacetMeta, SearchRange } from "../api/types.js";
+import type {
+  FacetCategoryCount,
+  FacetMeta,
+  FacetWithheldGroup,
+  SearchRange,
+} from "../api/types.js";
 import { useSearchQuery } from "../model/queries.js";
 import { buildFacetGroups } from "../state/facets.js";
+import { FACET_PLAN_EVIDENCE } from "../state/degradations.js";
 import type { FacetGroup } from "../state/facets.js";
 import { useHostFacetLabels } from "./useFacetLabels.js";
 import type { FacetLabelResolver } from "./useFacetLabels.js";
@@ -51,6 +57,34 @@ export interface FacetPanelBag {
   readonly currency: string | undefined;
   /** Size of the largest counted set — the number `approximate` is about. */
   readonly candidates: number;
+  /**
+   * Groups the counter COUNTED and then held back, because their buckets
+   * describe too little of the result set. Not empty means the panel may
+   * NOT say "this search offers no filters" — it says how many, instead.
+   */
+  readonly withheld: readonly FacetWithheldGroup[];
+  /**
+   * The categories this answer's candidate set is made of, busiest first —
+   * the evidence the plan was drawn from, and the counted category filter a
+   * text search has no other way to offer. Empty when the plan is the
+   * queried category's own. `category` is the same slash-joined id path
+   * `SearchQueryState.category` takes.
+   */
+  readonly categories: readonly FacetCategoryCount[];
+  /**
+   * Where the plan came from: `"category"` (the queried category's own
+   * authored schema) or `"evidence"` (the categories the candidate set
+   * actually contains).
+   */
+  readonly plan: string;
+  /**
+   * True when the server could not work out a plan AT ALL — the engine has
+   * no `category_counts` verb (`degraded: ["facet_plan_evidence"]`). An
+   * empty panel then means "we do not know", so a skin must not print
+   * "there are no filters" over it; the degradation notice is what tells
+   * the reader.
+   */
+  readonly planUnavailable: boolean;
   /** Facet values + ranges + geo currently applied. */
   readonly activeFilters: number;
 
@@ -67,6 +101,9 @@ const EMPTY_META: FacetMeta = {
   skipped: [],
   dropped_filters: [],
   core_ranges: [],
+  plan: "category",
+  withheld: [],
+  categories: [],
 };
 
 /**
@@ -174,6 +211,17 @@ export function useFacetPanel(props: {
             ?.card?.["currency"] as string | undefined
         : undefined,
     candidates: meta.candidates,
+    withheld: meta.withheld ?? [],
+    categories: meta.categories ?? [],
+    plan: meta.plan ?? "category",
+    // Read off the raw list rather than through `parseDegradations`: the
+    // question is whether THIS answer supports the sentence "no filters",
+    // and the banner's own parsing is a different job on a different
+    // surface. Guarded on the READY state, never flattened — a query still
+    // in flight has not said anything about its facet plan.
+    planUnavailable:
+      envelope.status === "ready" &&
+      envelope.data.degraded.includes(FACET_PLAN_EVIDENCE),
     activeFilters,
     toggle: toggleFilter,
     setRange,

package/src/headless/SearchStateProvider.tsx

@@ -71,6 +71,21 @@ export interface SearchStateBag {
    * Draw it as an invitation ("near me"), never as state.
    */
   readonly geoOffer: SearchGeo | undefined;
+  /**
+   * Whether the location this search is USING is the one the host offered —
+   * i.e. the visitor pressed "near me" (or followed a link built by somebody
+   * who did) and has not moved the pin since.
+   *
+   * A fact about provenance, and only the provider holds it: `state.geo` is a
+   * centre and a radius, and every way of arriving at a centre produces the
+   * same three numbers. Without it a summary line has to guess, and the guess
+   * it shipped was "a chosen place on the map" — said to a person who had
+   * pressed a button and never opened a map.
+   *
+   * `false` whenever there is no offer to compare against, which includes
+   * every search on a host that offers none.
+   */
+  readonly geoIsOffer: boolean;
 
   setText(q: string): void;
   setSort(sort: string | null): void;
@@ -92,6 +107,29 @@ export interface SearchStateBag {
   patch(patch: SearchStatePatch): void;
 }
 
+/**
+ * How close two coordinates have to be to be the same place, in degrees.
+ *
+ * The applied location makes a round trip through the query string, so the
+ * numbers that come back are the ones `String(lat)` produced rather than the
+ * float the device handed over. 1e-6 degrees is ~11cm — far below any
+ * position a browser reports and far above any rounding the codec introduces.
+ */
+const SAME_PLACE_EPSILON = 1e-6;
+
+/** Is the applied location the offered one? See {@link SearchStateBag.geoIsOffer}. */
+function sameCenter(
+  applied: SearchGeo | undefined,
+  offered: SearchGeo | undefined
+): boolean {
+  if (applied === undefined || offered === undefined) return false;
+  if (applied.kind !== "center" || offered.kind !== "center") return false;
+  return (
+    Math.abs(applied.lat - offered.lat) < SAME_PLACE_EPSILON &&
+    Math.abs(applied.lon - offered.lon) < SAME_PLACE_EPSILON
+  );
+}
+
 const StateContext = createContext<SearchStateBag | null>(null);
 
 export interface SearchStateProviderProps extends ParseSearchStateOptions {
@@ -178,6 +216,23 @@ export function SearchStateProvider(
 
   const bag = useMemo<SearchStateBag>(() => {
     const state = parsed.state;
+    /**
+     * The offer, carrying the radius the URL already asked for.
+     *
+     * `?radius_km=300` with no `lat`/`lon` narrows nothing — there is no
+     * point to measure from — but it IS a number the person typed, and the
+     * offer used to ignore it twice over: the button advertised the host's
+     * own 25km, and pressing it wrote 25 into the address over the 300 that
+     * was already there. Three things now agree, which is the whole of the
+     * fix: what the link asked for, what the button says, and what pressing
+     * it does. A bbox offer is left alone — a box has no radius to carry.
+     */
+    const offer: SearchGeo | undefined =
+      geoOffer !== undefined &&
+      geoOffer.kind === "center" &&
+      parsed.orphanRadiusKm !== undefined
+        ? { ...geoOffer, radiusKm: parsed.orphanRadiusKm }
+        : geoOffer;
     const apply = (
       next: SearchQueryState,
       options?: { readonly replace?: boolean }
@@ -193,7 +248,8 @@ export function SearchStateProvider(
       // — there is nothing left to offer, and a control that kept drawing
       // "near me" beside an applied location would be inviting a person to
       // re-answer a question they can already see the answer to.
-      geoOffer: state.geo === undefined ? geoOffer : undefined,
+      geoOffer: state.geo === undefined ? offer : undefined,
+      geoIsOffer: sameCenter(state.geo, offer),
 
       // Typing replaces rather than pushes: one history entry per letter
       // would make Back useless, which is the control the spec's acceptance
@@ -209,10 +265,10 @@ export function SearchStateProvider(
         apply(patchSearchState(state, { geo }));
       },
       acceptGeoOffer: () => {
-        if (geoOffer === undefined || state.geo !== undefined) return;
+        if (offer === undefined || state.geo !== undefined) return;
         // A PUSH, like any other filter the person applies: Back takes the
         // narrowing off again, which is the same promise every chip makes.
-        apply(patchSearchState(state, { geo: geoOffer }));
+        apply(patchSearchState(state, { geo: offer }));
       },
       // A page size is a preference, not a step through the results.
       setLimit: (limit) => apply(patchSearchState(state, { limit }), { replace: true }),

package/src/headless/useFacetLabels.ts

@@ -32,7 +32,7 @@
  *   4. the raw value.
  *
  * `buildFacetGroups` has already applied 1 and 2 by the time this hook runs,
- * and it leaves an option it could not name with `label === value` — which is
+ * and it marks an option it could not name `labelSource: "none"` — which is
  * what makes "did anyone name this?" answerable without a second lookup. Only
  * those values are asked about, so the host is never called for a value the
  * server or the schema already captioned, and a resolver that returns nothing
@@ -98,7 +98,7 @@ const NO_REQUESTS: readonly FacetLabelRequest[] = [];
 /** The values of one group nobody has named — see the precedence note above. */
 function unresolvedValues(group: FacetGroup): readonly string[] {
   return group.options
-    .filter((option) => option.label === option.value)
+    .filter((option) => option.labelSource === "none")
     .map((option) => option.value)
     .sort((a, b) => a.localeCompare(b));
 }
@@ -157,14 +157,14 @@ export function useHostFacetLabels(
       return {
         ...group,
         options: group.options.map((option) => {
-          // Precedence again, enforced rather than assumed: an option whose
-          // label already differs from its value was named by the server or
-          // the schema, and the host does not get to overwrite either.
-          if (option.label !== option.value) return option;
+          // Precedence again, enforced rather than assumed: an option the
+          // server or the schema already named is not the host's to
+          // overwrite. The source says so; the strings cannot.
+          if (option.labelSource !== "none") return option;
           const caption = named[option.value];
           return caption === undefined || caption.length === 0
             ? option
-            : { ...option, label: caption };
+            : { ...option, label: caption, labelSource: "host" as const };
         }),
       };
     })

package/src/i18n/es.ts

@@ -75,6 +75,10 @@ export const searchI18nBundleEs: I18nDictionary = {
     "Los recuentos son aproximados: había demasiados candidatos para contarlos todos.",
   "search.facets.skipped":
     "Estos filtros no se contaron para esta búsqueda: {slugs}",
+  "search.facets.withheld.one":
+    "{count} filtro se aplica a muy pocos de estos resultados",
+  "search.facets.withheld.other":
+    "{count} filtros se aplican a muy pocos de estos resultados",
   "search.facets.not_counted": "sin contar",
   "search.facets.drill_down_hint":
     "Cada recuento es lo que obtendrías eligiendo ese valor en lugar del actual.",
@@ -89,6 +93,12 @@ export const searchI18nBundleEs: I18nDictionary = {
   "search.facets.show_less": "Ver menos",
   "search.facets.search": "Buscar un filtro",
   "search.facets.search_empty": "Ningún filtro coincide con esto",
+  "search.facets.dictionary_search": "Buscar un valor",
+  "search.facets.dictionary_empty": "Ningún valor coincide con esto",
+  "search.facets.dictionary_chosen": "Elegido",
+  "search.facets.popular_all": "Todos",
+  "search.partition.all": "Todos",
+  "search.partition.label": "Sección",
   "search.facets.match_count.one": "{count} anuncio coincide",
   "search.facets.match_count.other": "{count} anuncios coinciden",
   "search.facets.range_invalid":
@@ -125,12 +135,14 @@ export const searchI18nBundleEs: I18nDictionary = {
 
   "search.geo.title": "Ubicación",
   "search.geo.radius_km": "A menos de {km} km",
+  "search.geo.radius_km_short": "{km} km",
   "search.geo.radius_label": "Radio, km",
   "search.geo.clear": "En cualquier lugar",
   "search.geo.near_me": "Cerca de mí",
   "search.geo.everywhere": "Buscando en todas partes",
   "search.geo.box": "Dentro del área mostrada",
   "search.geo.chosen_place": "Un lugar elegido en el mapa",
+  "search.geo.near_you": "Cerca de ti",
 
   "search.url.issues_title": "Parte de este enlace no se pudo leer",
   "search.url.issue.not_a_number":
@@ -141,6 +153,8 @@ export const searchI18nBundleEs: I18nDictionary = {
     "el área del mapa de este enlace está incompleta, así que se ignoró",
   "search.url.issue.range_malformed":
     "al rango «{param}» de este enlace le faltan números, así que se ignoró",
+  "search.url.issue.radius_without_place":
+    "este enlace pide un radio pero no nombra ningún lugar, así que aún no se acota nada — elige un lugar y se aplicará ese mismo radio",
 
   "search.degraded.title": "Lo que esta búsqueda no pudo hacer",
   "search.degraded.typo_tolerance":
@@ -151,6 +165,8 @@ export const searchI18nBundleEs: I18nDictionary = {
   "search.degraded.exact_facet_counts": "Los recuentos de filtros son aproximados.",
   "search.degraded.category_rollup":
     "Pueden faltar subcategorías en estos resultados: el servicio de categorías no respondió.",
+  "search.degraded.facet_plan_evidence":
+    "No pudimos determinar qué filtros encajan con estos resultados, así que puede haber más de los que muestra el panel.",
   "search.degraded.scorer":
     "El parámetro de ranking «{scorer}» no se aplicó: el motor configurado no puede evaluarlo.",
   "search.degraded.unknown":