@stapel/search-react 0.1.0

package/dist/state/facets.js

@@ -0,0 +1,171 @@
+/**
+ * The facet panel's data model — and the two things about stapel-search's
+ * facets a panel is obliged to show.
+ *
+ * 1. **They are DRILL-DOWN.** Every facet is counted over the candidate set
+ *    with ITS OWN filter removed (`stapel-search/facets.py`). So picking
+ *    "Bosch" does not zero its neighbours: the other brands keep the counts
+ *    they would have if you swapped to them. A panel that greys the siblings
+ *    out has silently converted a drill-down facet into a naive one, and the
+ *    e2e leg in the spec (§7.2) exists to catch exactly that.
+ * 2. **The server does not send option LABELS** (`facets.py` returns
+ *    `{value: count}` and nothing else). The labels are in the category's
+ *    feature schema, which is why {@link buildFacetGroups} takes
+ *    `categoryFeatures` — the second slot-seam of the pair, filled by the
+ *    container from `categories-react` (spec §6.2 item 2). Without it the
+ *    panel still works and shows raw values; it does not invent labels.
+ *
+ * A slug the server SKIPPED (`facet_meta.skipped`, dropped at
+ * `MAX_FACET_FIELDS`) is not counted at all. Its options carry `count: null`,
+ * never `0` — "we did not count this" and "there are none" are different
+ * sentences and the honest one has to survive to the screen.
+ */
+import { featureConfig, featureName, featureType, formatFeatureValue } from "@stapel/attributes-react";
+function translate(t, key) {
+    if (t === undefined)
+        return key;
+    const resolved = t(key);
+    return resolved.length > 0 ? resolved : key;
+}
+/**
+ * The declared option ORDER for a closed set, if the schema declares one.
+ *
+ * Closed sets arrive zero-filled from the server (`fill_zero_options`), and a
+ * closed set is a list somebody authored: showing it in count order reshuffles
+ * a size chart on every click. Open sets have no authored order, so they fall
+ * back to count-descending.
+ */
+function declaredOptionValues(feature) {
+    if (feature === undefined)
+        return [];
+    const raw = featureConfig(feature)["options"];
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const option of raw) {
+        if (option !== null && typeof option === "object") {
+            const value = option.value;
+            if (value !== undefined && value !== null)
+                out.push(String(value));
+        }
+        else if (typeof option === "string") {
+            out.push(option);
+        }
+    }
+    return out;
+}
+/**
+ * A facet value as a person reads it, through
+ * `@stapel/attributes-react`'s `formatFeatureValue` — the same formatter the
+ * card and the spec table use, so a value cannot read one way in the filter
+ * and another way in the result.
+ *
+ * The wire carries facet values as STRINGS (they are index terms), so the raw
+ * value is coerced back into the shape the type's formatter expects before
+ * being handed over. `select` is a list even for one value
+ * (`types/select/dto.py`), `date` is a Unix timestamp integer, numbers are
+ * numbers. A type the formatter cannot read gives back the raw value — never
+ * an empty label, which would leave an unnameable checkbox on screen.
+ */
+export function facetOptionLabel(feature, value, options) {
+    if (feature === undefined)
+        return value;
+    const type = featureType(feature);
+    if (type === undefined)
+        return value;
+    let coerced = value;
+    switch (type) {
+        case "select":
+        case "hierarchical_select":
+            coerced = [value];
+            break;
+        case "int":
+        case "float":
+        case "date": {
+            const parsed = Number(value);
+            coerced = Number.isFinite(parsed) ? parsed : value;
+            break;
+        }
+        case "bool":
+            coerced = value === "true" || value === "1";
+            break;
+        default:
+            coerced = value;
+    }
+    const formatted = formatFeatureValue(feature, { type, value: coerced }, {
+        ...(options?.t !== undefined ? { t: options.t } : {}),
+        ...(options?.locale !== undefined ? { locale: options.locale } : {}),
+    });
+    return formatted !== undefined && formatted.length > 0 ? formatted : value;
+}
+/**
+ * Fold the response's counts, the URL's selections and the category schema
+ * into the panel's groups.
+ *
+ * Groups appear for every counted slug, every skipped slug, and every slug the
+ * person has filtered on — the last one matters: a filter whose slug fell out
+ * of the plan must stay visible, or it becomes a constraint with no control to
+ * remove it.
+ */
+export function buildFacetGroups(input) {
+    const bySlug = new Map();
+    for (const feature of input.categoryFeatures ?? [])
+        bySlug.set(feature.slug, feature);
+    const skipped = new Set(input.meta.skipped);
+    const slugs = [];
+    const seen = new Set();
+    for (const slug of [
+        ...Object.keys(input.facets),
+        ...input.meta.skipped,
+        ...Object.keys(input.state.filters),
+    ]) {
+        if (seen.has(slug))
+            continue;
+        seen.add(slug);
+        slugs.push(slug);
+    }
+    return slugs.map((slug) => {
+        const feature = bySlug.get(slug);
+        const counts = input.facets[slug] ?? {};
+        const counted = !skipped.has(slug) && slug in input.facets;
+        const selected = input.state.filters[slug] ?? [];
+        const declared = declaredOptionValues(feature);
+        const values = [];
+        const push = (value) => {
+            if (!values.includes(value))
+                values.push(value);
+        };
+        // Declared order first (closed sets), then whatever else the counter
+        // returned, then anything selected that neither of them mentioned.
+        for (const value of declared)
+            if (value in counts)
+                push(value);
+        const remaining = Object.keys(counts)
+            .filter((value) => !declared.includes(value))
+            .sort((a, b) => (counts[b] ?? 0) - (counts[a] ?? 0) || a.localeCompare(b));
+        for (const value of remaining)
+            push(value);
+        for (const value of selected)
+            push(value);
+        const labelOptions = {
+            ...(input.t !== undefined ? { t: input.t } : {}),
+            ...(input.locale !== undefined ? { locale: input.locale } : {}),
+        };
+        return {
+            slug,
+            label: feature === undefined
+                ? slug
+                : translate(input.t, featureName(feature)),
+            feature,
+            counted,
+            selected,
+            options: values.map((value) => ({
+                value,
+                count: counted ? (counts[value] ?? 0) : null,
+                label: facetOptionLabel(feature, value, labelOptions),
+                selected: selected.includes(value),
+            })),
+        };
+    });
+}
+//# sourceMappingURL=facets.js.map

package/dist/state/facets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facets.js","sourceRoot":"","sources":["../../src/state/facets.ts"],"names":[],"mappings":"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"}

package/dist/state/urlState.d.ts

@@ -0,0 +1,143 @@
+/**
+ * THE URL IS THE STATE.
+ *
+ * Every parameter of a search — text, category, facet filters, ranges, geo,
+ * sort, page size and the keyset cursor — lives in the query string, and no
+ * component keeps a second copy. The acceptance test the spec sets (§4.2) is
+ * behavioural, not structural: copy the address into another tab and get the
+ * same results; press Back and lose exactly the last filter; reload and lose
+ * nothing. All three follow from there being one source.
+ *
+ * The parameter NAMES here are the backend's own (`type`, `q`, `f.<slug>`,
+ * `r.<slug>`, `lat`/`lon`/`radius_km`, `bbox`, `sort`, `facets`, `anchor`,
+ * `direction`, `limit`). That is deliberate: a browser URL is then the API
+ * query string, so a support ticket that pastes a link is a request anyone can
+ * replay with curl, and there is no translation table to drift.
+ *
+ * This module is PURE — no React, no router, no fetch. The React binding is
+ * `headless/SearchStateProvider`; the react-router binding is the `./router`
+ * subpath. Keeping the codec here is what makes the round trip testable in
+ * both directions without a DOM.
+ */
+import type { SearchQueryState, SearchRange } from "../api/types.js";
+/** Wire parameter names, in one place so a rename is one edit. */
+export declare const SEARCH_PARAM: {
+    readonly type: "type";
+    readonly q: "q";
+    readonly lang: "lang";
+    readonly category: "category";
+    readonly owner: "owner";
+    readonly sort: "sort";
+    readonly facets: "facets";
+    readonly anchor: "anchor";
+    readonly direction: "direction";
+    readonly limit: "limit";
+    readonly lat: "lat";
+    readonly lon: "lon";
+    readonly radiusKm: "radius_km";
+    readonly bbox: "bbox";
+};
+/** Prefix of a facet filter parameter (`f.brand=bosch`). */
+export declare const FILTER_PREFIX = "f.";
+/** Prefix of a range filter parameter (`r.price=100..500`). */
+export declare const RANGE_PREFIX = "r.";
+/**
+ * Something in the URL this codec could not make sense of.
+ *
+ * Reported rather than silently dropped, for the same reason a facet's
+ * `skipped` list is reported: a link whose location filter lost half of
+ * itself should say so, not quietly widen the search and let the person
+ * believe they are looking at what they shared. Each issue carries an i18n
+ * key so a skin can render a sentence.
+ */
+export interface SearchStateIssue {
+    /** The offending parameter name, as it appeared in the URL. */
+    readonly param: string;
+    readonly code: SearchStateIssueCode;
+    /** i18n key for the sentence (`search.url.issue.*`). */
+    readonly messageKey: string;
+}
+export type SearchStateIssueCode = 
+/** A numeric parameter was not a number. */
+"not_a_number"
+/** `lat` without `lon`, or the other way round. */
+ | "geo_incomplete"
+/** `bbox` was not four numbers. */
+ | "bbox_malformed"
+/** `r.<slug>` was not `from..to`. */
+ | "range_malformed";
+/** What {@link parseSearchState} answers: the state, plus what it could not read. */
+export interface ParsedSearchState {
+    readonly state: SearchQueryState;
+    readonly issues: readonly SearchStateIssue[];
+}
+export interface ParseSearchStateOptions {
+    /**
+     * The doc type to search when the URL carries none. Required in practice —
+     * `type` is the endpoint's only mandatory parameter — and supplied by the
+     * host, because which types exist is a deployment fact
+     * (`stapel-search`'s registry), not something this package can know.
+     */
+    readonly defaultType: string;
+    /** Applied when the URL carries no `q`. Defaults to `""`. */
+    readonly defaultQ?: string;
+    /** Applied when the URL carries no `sort`; omitted lets the server choose. */
+    readonly defaultSort?: string;
+    /** Applied when the URL carries no `limit`. */
+    readonly defaultLimit?: number;
+    /** Applied when the URL carries no `category` (e.g. a category page). */
+    readonly defaultCategory?: string;
+    /** Applied when the URL carries no `lang`. */
+    readonly defaultLang?: string;
+}
+/** URL → state. Never throws; anything unreadable lands in `issues`. */
+export declare function parseSearchState(params: URLSearchParams, options: ParseSearchStateOptions): ParsedSearchState;
+/**
+ * State → URL.
+ *
+ * `base` is the CURRENT query string: every parameter this codec does not own
+ * is copied through untouched, so a host's own `?ref=`/`utm_*` survives a
+ * facet click. Every parameter it DOES own is rewritten from the state, so a
+ * removed filter actually leaves the URL instead of lingering as a stale key.
+ */
+export declare function writeSearchState(state: SearchQueryState, base?: URLSearchParams): URLSearchParams;
+/** Is this URL parameter owned by the search codec? */
+export declare function ownsParam(key: string): boolean;
+/** A patch over {@link SearchQueryState}; `null` clears an optional member. */
+export type SearchStatePatch = {
+    readonly [K in keyof SearchQueryState]?: SearchQueryState[K] | null;
+};
+/**
+ * Apply a patch, and — unless the patch itself moves the page — DROP the
+ * keyset cursor.
+ *
+ * This is the single most load-bearing line in the module. `anchor` encodes a
+ * position inside ONE ordered candidate set (`{v, k, o}` over the active sort);
+ * carry it across a filter or sort change and the server either refuses it or,
+ * worse, honours it against a different set and answers page 4 of something
+ * the person never asked for. Every mutator in the provider goes through here,
+ * so "changing a filter returns you to the first page" is a property of the
+ * state machine rather than a rule each call site must remember.
+ */
+export declare function patchSearchState(state: SearchQueryState, patch: SearchStatePatch): SearchQueryState;
+/** Toggle one value of one facet slug, OR-style. Returns a new state with the
+ * cursor dropped (see {@link patchSearchState}). */
+export declare function toggleFilterValue(state: SearchQueryState, slug: string, value: string): SearchQueryState;
+/** Replace one slug's chosen values; an empty list removes the filter. */
+export declare function setFilterValues(state: SearchQueryState, slug: string, values: readonly string[]): SearchQueryState;
+/** Set or clear one `r.<slug>` range. */
+export declare function setRangeValue(state: SearchQueryState, slug: string, range: SearchRange | null): SearchQueryState;
+/**
+ * Drop every filter, range and geo constraint, keeping what identifies the
+ * search itself: the doc type, the text, the language, the category the
+ * person navigated into, and the page size.
+ *
+ * Category is KEPT on purpose: on `/c/:slug` it is the page, not a filter, and
+ * a "clear filters" button that teleported the visitor to the root catalogue
+ * would be removing something they never set.
+ */
+export declare function clearFilters(state: SearchQueryState): SearchQueryState;
+/** How many constraints the person has actually applied (facet values +
+ * ranges + geo) — what a "clear all (N)" control counts. */
+export declare function activeFilterCount(state: SearchQueryState): number;
+//# sourceMappingURL=urlState.d.ts.map

package/dist/state/urlState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlState.d.ts","sourceRoot":"","sources":["../../src/state/urlState.ts"],"names":[],"mappings":"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"}

package/dist/state/urlState.js

@@ -0,0 +1,319 @@
+/** Wire parameter names, in one place so a rename is one edit. */
+export const SEARCH_PARAM = {
+    type: "type",
+    q: "q",
+    lang: "lang",
+    category: "category",
+    owner: "owner",
+    sort: "sort",
+    facets: "facets",
+    anchor: "anchor",
+    direction: "direction",
+    limit: "limit",
+    lat: "lat",
+    lon: "lon",
+    radiusKm: "radius_km",
+    bbox: "bbox",
+};
+/** Prefix of a facet filter parameter (`f.brand=bosch`). */
+export const FILTER_PREFIX = "f.";
+/** Prefix of a range filter parameter (`r.price=100..500`). */
+export const RANGE_PREFIX = "r.";
+const ISSUE_KEY = {
+    not_a_number: "search.url.issue.not_a_number",
+    geo_incomplete: "search.url.issue.geo_incomplete",
+    bbox_malformed: "search.url.issue.bbox_malformed",
+    range_malformed: "search.url.issue.range_malformed",
+};
+function num(raw, param, issues) {
+    const value = Number(raw);
+    if (raw.trim().length === 0 || !Number.isFinite(value)) {
+        issues.push({ param, code: "not_a_number", messageKey: ISSUE_KEY.not_a_number });
+        return undefined;
+    }
+    return value;
+}
+function parseGeo(params, issues) {
+    const bbox = params.get(SEARCH_PARAM.bbox);
+    if (bbox !== null) {
+        const parts = bbox.split(",");
+        if (parts.length !== 4) {
+            issues.push({
+                param: SEARCH_PARAM.bbox,
+                code: "bbox_malformed",
+                messageKey: ISSUE_KEY.bbox_malformed,
+            });
+            return undefined;
+        }
+        const values = parts.map((p) => Number(p));
+        if (values.some((v) => !Number.isFinite(v))) {
+            issues.push({
+                param: SEARCH_PARAM.bbox,
+                code: "bbox_malformed",
+                messageKey: ISSUE_KEY.bbox_malformed,
+            });
+            return undefined;
+        }
+        // `minLon > maxLon` is LEGAL — it means the box crosses the antimeridian
+        // (`stapel-search/query.py`). Normalizing it here would silently turn a
+        // Pacific search into the rest of the world.
+        return {
+            kind: "bbox",
+            minLat: values[0],
+            minLon: values[1],
+            maxLat: values[2],
+            maxLon: values[3],
+        };
+    }
+    const rawLat = params.get(SEARCH_PARAM.lat);
+    const rawLon = params.get(SEARCH_PARAM.lon);
+    if (rawLat === null && rawLon === null)
+        return undefined;
+    if (rawLat === null || rawLon === null) {
+        issues.push({
+            param: rawLat === null ? SEARCH_PARAM.lat : SEARCH_PARAM.lon,
+            code: "geo_incomplete",
+            messageKey: ISSUE_KEY.geo_incomplete,
+        });
+        return undefined;
+    }
+    const lat = num(rawLat, SEARCH_PARAM.lat, issues);
+    const lon = num(rawLon, SEARCH_PARAM.lon, issues);
+    if (lat === undefined || lon === undefined)
+        return undefined;
+    const rawRadius = params.get(SEARCH_PARAM.radiusKm);
+    const radiusKm = rawRadius === null ? undefined : num(rawRadius, SEARCH_PARAM.radiusKm, issues);
+    return {
+        kind: "center",
+        lat,
+        lon,
+        ...(radiusKm !== undefined ? { radiusKm } : {}),
+    };
+}
+function parseFacetSelection(raw) {
+    if (raw === null)
+        return undefined;
+    const lowered = raw.trim().toLowerCase();
+    if (lowered === "on" || lowered === "off")
+        return lowered;
+    const slugs = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return slugs.length > 0 ? slugs : undefined;
+}
+/** URL → state. Never throws; anything unreadable lands in `issues`. */
+export function parseSearchState(params, options) {
+    const issues = [];
+    const filters = {};
+    const ranges = {};
+    for (const key of new Set(params.keys())) {
+        if (key.startsWith(FILTER_PREFIX) && key.length > FILTER_PREFIX.length) {
+            // `getAll` is the whole point: a repeated key is OR within the slug.
+            const values = params.getAll(key).filter((v) => v.length > 0);
+            if (values.length > 0)
+                filters[key.slice(FILTER_PREFIX.length)] = values;
+            continue;
+        }
+        if (key.startsWith(RANGE_PREFIX) && key.length > RANGE_PREFIX.length) {
+            const raw = params.get(key) ?? "";
+            const separator = raw.indexOf("..");
+            if (separator < 0) {
+                issues.push({
+                    param: key,
+                    code: "range_malformed",
+                    messageKey: ISSUE_KEY.range_malformed,
+                });
+                continue;
+            }
+            const from = raw.slice(0, separator);
+            const to = raw.slice(separator + 2);
+            if (from.length === 0 && to.length === 0)
+                continue;
+            ranges[key.slice(RANGE_PREFIX.length)] = {
+                ...(from.length > 0 ? { from } : {}),
+                ...(to.length > 0 ? { to } : {}),
+            };
+        }
+    }
+    const rawLimit = params.get(SEARCH_PARAM.limit);
+    const limit = rawLimit === null
+        ? options.defaultLimit
+        : num(rawLimit, SEARCH_PARAM.limit, issues);
+    const rawDirection = params.get(SEARCH_PARAM.direction);
+    // The server coerces anything unrecognised to "next" without complaining
+    // (`query.py`), so the codec mirrors that instead of inventing a refusal
+    // the backend does not have.
+    const direction = rawDirection === null ? undefined : rawDirection === "prev" ? "prev" : "next";
+    const state = {
+        type: params.get(SEARCH_PARAM.type) ?? options.defaultType,
+        q: params.get(SEARCH_PARAM.q) ?? options.defaultQ ?? "",
+        filters,
+        ranges,
+        ...optional(SEARCH_PARAM.lang, params.get(SEARCH_PARAM.lang) ?? options.defaultLang),
+        ...optional(SEARCH_PARAM.category, params.get(SEARCH_PARAM.category) ?? options.defaultCategory),
+        ...optional(SEARCH_PARAM.owner, params.get(SEARCH_PARAM.owner) ?? undefined),
+        ...optional("geo", parseGeo(params, issues)),
+        ...optional(SEARCH_PARAM.sort, params.get(SEARCH_PARAM.sort) ?? options.defaultSort),
+        ...optional("facets", parseFacetSelection(params.get(SEARCH_PARAM.facets))),
+        ...optional(SEARCH_PARAM.anchor, params.get(SEARCH_PARAM.anchor) ?? undefined),
+        ...optional("direction", direction),
+        ...optional("limit", limit),
+    };
+    return { state, issues };
+}
+/** `exactOptionalPropertyTypes` makes `{k: undefined}` and "absent" different
+ * types; this spreads to nothing when the value is absent. */
+function optional(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}
+/**
+ * State → URL.
+ *
+ * `base` is the CURRENT query string: every parameter this codec does not own
+ * is copied through untouched, so a host's own `?ref=`/`utm_*` survives a
+ * facet click. Every parameter it DOES own is rewritten from the state, so a
+ * removed filter actually leaves the URL instead of lingering as a stale key.
+ */
+export function writeSearchState(state, base) {
+    const next = new URLSearchParams();
+    if (base !== undefined) {
+        for (const key of new Set(base.keys())) {
+            if (ownsParam(key))
+                continue;
+            for (const value of base.getAll(key))
+                next.append(key, value);
+        }
+    }
+    next.set(SEARCH_PARAM.type, state.type);
+    if (state.q.length > 0)
+        next.set(SEARCH_PARAM.q, state.q);
+    if (state.lang !== undefined)
+        next.set(SEARCH_PARAM.lang, state.lang);
+    if (state.category !== undefined)
+        next.set(SEARCH_PARAM.category, state.category);
+    if (state.owner !== undefined)
+        next.set(SEARCH_PARAM.owner, state.owner);
+    for (const slug of Object.keys(state.filters).sort()) {
+        for (const value of state.filters[slug] ?? []) {
+            next.append(`${FILTER_PREFIX}${slug}`, value);
+        }
+    }
+    for (const slug of Object.keys(state.ranges).sort()) {
+        const range = state.ranges[slug];
+        if (range === undefined)
+            continue;
+        if (range.from === undefined && range.to === undefined)
+            continue;
+        next.set(`${RANGE_PREFIX}${slug}`, `${range.from ?? ""}..${range.to ?? ""}`);
+    }
+    if (state.geo !== undefined) {
+        if (state.geo.kind === "bbox") {
+            const { minLat, minLon, maxLat, maxLon } = state.geo;
+            next.set(SEARCH_PARAM.bbox, `${minLat},${minLon},${maxLat},${maxLon}`);
+        }
+        else {
+            next.set(SEARCH_PARAM.lat, String(state.geo.lat));
+            next.set(SEARCH_PARAM.lon, String(state.geo.lon));
+            if (state.geo.radiusKm !== undefined) {
+                next.set(SEARCH_PARAM.radiusKm, String(state.geo.radiusKm));
+            }
+        }
+    }
+    if (state.sort !== undefined)
+        next.set(SEARCH_PARAM.sort, state.sort);
+    if (state.facets !== undefined) {
+        next.set(SEARCH_PARAM.facets, Array.isArray(state.facets) ? state.facets.join(",") : state.facets);
+    }
+    if (state.anchor !== undefined)
+        next.set(SEARCH_PARAM.anchor, state.anchor);
+    if (state.direction !== undefined)
+        next.set(SEARCH_PARAM.direction, state.direction);
+    if (state.limit !== undefined)
+        next.set(SEARCH_PARAM.limit, String(state.limit));
+    return next;
+}
+/** Is this URL parameter owned by the search codec? */
+export function ownsParam(key) {
+    if (key.startsWith(FILTER_PREFIX) || key.startsWith(RANGE_PREFIX))
+        return true;
+    return Object.values(SEARCH_PARAM).includes(key);
+}
+/**
+ * Apply a patch, and — unless the patch itself moves the page — DROP the
+ * keyset cursor.
+ *
+ * This is the single most load-bearing line in the module. `anchor` encodes a
+ * position inside ONE ordered candidate set (`{v, k, o}` over the active sort);
+ * carry it across a filter or sort change and the server either refuses it or,
+ * worse, honours it against a different set and answers page 4 of something
+ * the person never asked for. Every mutator in the provider goes through here,
+ * so "changing a filter returns you to the first page" is a property of the
+ * state machine rather than a rule each call site must remember.
+ */
+export function patchSearchState(state, patch) {
+    const movesPage = "anchor" in patch || "direction" in patch;
+    const merged = { ...state, ...patch };
+    if (!movesPage) {
+        merged["anchor"] = undefined;
+        merged["direction"] = undefined;
+    }
+    // `type` and `q` are never absent: `q` has the empty string for "no text",
+    // and a state without `type` could not be requested at all.
+    if (typeof merged["q"] !== "string")
+        merged["q"] = "";
+    if (typeof merged["type"] !== "string")
+        merged["type"] = state.type;
+    // `null` in a patch CLEARS a member, and `exactOptionalPropertyTypes` makes
+    // "absent" and "present but undefined" different types — so the cleared
+    // members are filtered out rather than left as `undefined` holes.
+    return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== null && value !== undefined));
+}
+/** Toggle one value of one facet slug, OR-style. Returns a new state with the
+ * cursor dropped (see {@link patchSearchState}). */
+export function toggleFilterValue(state, slug, value) {
+    const current = state.filters[slug] ?? [];
+    const next = current.includes(value)
+        ? current.filter((v) => v !== value)
+        : [...current, value];
+    return setFilterValues(state, slug, next);
+}
+/** Replace one slug's chosen values; an empty list removes the filter. */
+export function setFilterValues(state, slug, values) {
+    const filters = Object.fromEntries(Object.entries(state.filters).filter(([key]) => key !== slug));
+    if (values.length > 0)
+        filters[slug] = values;
+    return patchSearchState(state, { filters });
+}
+/** Set or clear one `r.<slug>` range. */
+export function setRangeValue(state, slug, range) {
+    const ranges = Object.fromEntries(Object.entries(state.ranges).filter(([key]) => key !== slug));
+    if (range !== null && (range.from !== undefined || range.to !== undefined)) {
+        ranges[slug] = range;
+    }
+    return patchSearchState(state, { ranges });
+}
+/**
+ * Drop every filter, range and geo constraint, keeping what identifies the
+ * search itself: the doc type, the text, the language, the category the
+ * person navigated into, and the page size.
+ *
+ * Category is KEPT on purpose: on `/c/:slug` it is the page, not a filter, and
+ * a "clear filters" button that teleported the visitor to the root catalogue
+ * would be removing something they never set.
+ */
+export function clearFilters(state) {
+    return patchSearchState(state, { filters: {}, ranges: {}, geo: null });
+}
+/** How many constraints the person has actually applied (facet values +
+ * ranges + geo) — what a "clear all (N)" control counts. */
+export function activeFilterCount(state) {
+    let count = 0;
+    for (const values of Object.values(state.filters))
+        count += values.length;
+    count += Object.keys(state.ranges).length;
+    if (state.geo !== undefined)
+        count += 1;
+    return count;
+}
+//# sourceMappingURL=urlState.js.map