tempest-react-sdk 0.47.0 → 0.49.0

package/dist/components/FilterBar/filter-apply.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filter-apply.cjs","names":[],"sources":["../../../src/components/FilterBar/filter-apply.ts"],"sourcesContent":["// The other half of the filter model: evaluating a `Filter[]` instead of only\n// describing it. `FilterBar` produces filters, `applyFilters` runs them over an\n// in-memory list, and `filtersToQueryParams` (filter-query.ts) hands the same set\n// to a paginated backend. Without these two the model stops one step short of\n// useful and every app writes the eleven operator branches again.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete, isValueless } from \"./filter-model\";\n\n/** Matches a plain `yyyy-mm-dd`, the shape `<input type=\"date\">` produces. */\nconst DATE_ONLY = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * Read a property off a row without asserting the row's shape.\n *\n * `Filter.field` is a string chosen by the app's field list, so it cannot be a\n * `keyof T`; the lookup goes through an index signature and a missing property\n * yields `undefined`, which the operators treat as an empty value.\n *\n * @param item - The row being tested.\n * @param field - Property name from the filter.\n * @returns The property value, or `undefined` when the row has no such key.\n */\nfunction readField(item: unknown, field: string): unknown {\n    if (item == null || typeof item !== \"object\") return undefined;\n    return (item as Record<string, unknown>)[field];\n}\n\n/**\n * Local `yyyy-mm-dd` for a value that represents a date, or `null`.\n *\n * Built from the local calendar parts rather than `toISOString`, which converts\n * to UTC first and therefore reports the next day for anything after 21:00 in\n * UTC-3. A `yyyy-mm-dd` string is returned untouched, so a filter value and a\n * row value that already agree never round-trip through `Date` at all.\n *\n * @param value - A `Date`, a date-ish string, or anything else.\n * @returns The day key, or `null` when the value does not denote a date.\n */\nfunction dayKey(value: unknown): string | null {\n    if (typeof value === \"string\" && DATE_ONLY.test(value)) return value;\n\n    const date =\n        value instanceof Date\n            ? value\n            : typeof value === \"string\" && value.trim() !== \"\"\n              ? new Date(value)\n              : null;\n    if (date === null || Number.isNaN(date.getTime())) return null;\n\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Compare a row value against a filter value, in the row value's own type.\n *\n * The filter always carries strings — it comes from form inputs and from the\n * URL — while the row carries whatever the API returned. Comparing them as text\n * gets the two common cases wrong: `10` would sort before `9`, and a date would\n * be compared by however it happens to be formatted. So the row value picks the\n * comparison, and the filter value is coerced into it.\n *\n * Dates compare by **day**, not by instant: a row stamped `2026-03-05T13:00:00Z`\n * is `>= 2026-03-05`, which is what the person picking a date in the UI means.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Negative, zero or positive, or `null` when the two cannot be compared.\n */\nfunction compare(left: unknown, right: string): number | null {\n    if (left == null) return null;\n\n    if (typeof left === \"number\") {\n        const parsed = Number(right);\n        return Number.isNaN(parsed) ? null : left - parsed;\n    }\n\n    if (typeof left === \"boolean\") {\n        const parsed = right === \"true\" ? true : right === \"false\" ? false : null;\n        return parsed === null ? null : Number(left) - Number(parsed);\n    }\n\n    if (DATE_ONLY.test(right)) {\n        const key = dayKey(left);\n        return key === null ? null : key.localeCompare(right);\n    }\n\n    return String(left).localeCompare(right, undefined, { numeric: true });\n}\n\n/**\n * Equality in the row value's type, falling back to exact text.\n *\n * Case-sensitive on purpose: `eq` maps to a plain `WHERE column = value` on the\n * server side, so a case-insensitive client would quietly disagree with the\n * backend for the same filter. `contains` is the case-insensitive operator, and\n * it is also the default one for text fields, so the friendly behaviour is what\n * people get without asking.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Whether the two are equal.\n */\nfunction equals(left: unknown, right: string): boolean {\n    const result = compare(left, right);\n    if (result !== null) return result === 0;\n    return String(left ?? \"\") === right;\n}\n\n/**\n * Is this row value empty?\n *\n * Empty means absent, blank text or an empty list — never falsy. `0` and `false`\n * are values somebody chose, and a filter that hid them would be reporting the\n * wrong count on every dashboard that tracks zeroes.\n *\n * @param value - The row value.\n * @returns Whether the value counts as empty.\n */\nfunction isEmptyValue(value: unknown): boolean {\n    if (value == null) return true;\n    if (typeof value === \"string\") return value.trim() === \"\";\n    if (Array.isArray(value)) return value.length === 0;\n    return false;\n}\n\n/**\n * The filter's value as a list, whatever arity the operator uses.\n *\n * @param filter - The filter to read.\n * @returns Its values, trimmed of nothing — a leading space may be meaningful text.\n */\nfunction valuesOf(filter: Filter): string[] {\n    if (filter.value === undefined) return [];\n    return Array.isArray(filter.value) ? [...filter.value] : [String(filter.value)];\n}\n\n/**\n * Evaluate one operator against one row value.\n *\n * @param operator - The comparison to make.\n * @param left - The row value.\n * @param values - The filter values (one, two for `between`, many for `in`).\n * @returns Whether the row value satisfies the operator.\n */\nfunction matchesOperator(operator: FilterOperator, left: unknown, values: string[]): boolean {\n    switch (operator) {\n        case \"empty\":\n            return isEmptyValue(left);\n        case \"notEmpty\":\n            return !isEmptyValue(left);\n        case \"eq\":\n            return equals(left, values[0] ?? \"\");\n        case \"ne\":\n            return !equals(left, values[0] ?? \"\");\n        case \"contains\":\n            return String(left ?? \"\")\n                .toLowerCase()\n                .includes((values[0] ?? \"\").toLowerCase());\n        case \"in\":\n            return values.some((value) => equals(left, value));\n        case \"between\": {\n            const [first = \"\", second = \"\"] = values;\n            const low = compare(left, first);\n            const high = compare(left, second);\n            if (low === null || high === null) return false;\n            return low >= 0 && high <= 0;\n        }\n        default: {\n            const result = compare(left, values[0] ?? \"\");\n            if (result === null) return false;\n            if (operator === \"gt\") return result > 0;\n            if (operator === \"gte\") return result >= 0;\n            if (operator === \"lt\") return result < 0;\n            return result <= 0;\n        }\n    }\n}\n\n/**\n * Order the two values of a `between` so the range is never empty by accident.\n *\n * A person who picks the later date first means the range between the two dates,\n * not \"no rows\". The server-side `BETWEEN` needs `(lo, hi)` in order too, which\n * is why the normalisation lives here and is shared by `filtersToQueryParams`.\n *\n * @param values - The raw pair.\n * @returns The pair, ascending.\n */\nexport function orderRange(values: readonly string[]): string[] {\n    const [first = \"\", second = \"\"] = values;\n    if (DATE_ONLY.test(first) && DATE_ONLY.test(second)) {\n        return first <= second ? [first, second] : [second, first];\n    }\n    const low = Number(first);\n    const high = Number(second);\n    if (!Number.isNaN(low) && !Number.isNaN(high)) {\n        return low <= high ? [first, second] : [second, first];\n    }\n    return first.localeCompare(second, undefined, { numeric: true }) <= 0\n        ? [first, second]\n        : [second, first];\n}\n\n/**\n * Run a filter set over an in-memory list.\n *\n * Closes the loop `FilterBar` opens: the bar produces `Filter[]`, this applies\n * them. Filters combine with `AND`, matching the flat model the bar builds, and\n * an incomplete filter is skipped rather than treated as a match of nothing — a\n * half-filled form should not empty the table underneath it.\n *\n * Comparison follows the row's type, not the filter's: numbers compare\n * numerically, dates compare by day, and everything else compares as text with\n * `numeric: true` so `\"item 2\"` lands before `\"item 10\"`.\n *\n * A few behaviours differ from the SQL the server-side twin produces, and the\n * difference is deliberate rather than accidental:\n *\n * - `ne` matches rows whose value is absent. In SQL, `column <> 'x'` is `NULL`\n *   for a `NULL` column and the row drops out. Here \"is not paid\" shows the rows\n *   with no status at all, which is what the chip claims.\n * - `empty` matches `NULL`, blank text and empty lists; `__isnull` on the server\n *   only matches `NULL`. A column that stores `\"\"` instead of `NULL` is where\n *   the two disagree.\n *\n * @example\n * const visible = applyFilters(orders, filters);\n *\n * @param items - The full list.\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns A new array with the rows that satisfy every complete filter.\n */\nexport function applyFilters<T>(items: readonly T[], filters: readonly Filter[]): T[] {\n    const active = filters.filter(isComplete);\n    if (active.length === 0) return [...items];\n\n    return items.filter((item) =>\n        active.every((filter) => {\n            const left = readField(item, filter.field);\n            if (isValueless(filter.operator)) {\n                return matchesOperator(filter.operator, left, []);\n            }\n            const values =\n                filter.operator === \"between\" ? orderRange(valuesOf(filter)) : valuesOf(filter);\n            return matchesOperator(filter.operator, left, values);\n        }),\n    );\n}\n"],"mappings":"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"}
+{"version":3,"file":"filter-apply.cjs","names":[],"sources":["../../../src/components/FilterBar/filter-apply.ts"],"sourcesContent":["// The other half of the filter model: evaluating a `Filter[]` instead of only\n// describing it. `FilterBar` produces filters, `applyFilters` runs them over an\n// in-memory list, and `filtersToQueryParams` (filter-query.ts) hands the same set\n// to a paginated backend. Without these two the model stops one step short of\n// useful and every app writes the eleven operator branches again.\n\nimport { formatDateForInput } from \"@/utils/format\";\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\n\n/** Matches a plain `yyyy-mm-dd`, the shape `<input type=\"date\">` produces. */\nconst DATE_ONLY = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * One collator for every text comparison in this module.\n *\n * `localeCompare(value, undefined, { numeric: true })` builds a collator on each\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and this comparison runs once per row per filter. Measured at 200k\n * comparisons: 453 ms through `localeCompare` against 25 ms through a hoisted\n * collator, i.e. ~23 ms of main thread per keystroke on a 10k-row list.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Read a property off a row without asserting the row's shape.\n *\n * `Filter.field` is a string chosen by the app's field list, so it cannot be a\n * `keyof T`; the lookup goes through an index signature and a missing property\n * yields `undefined`, which the operators treat as an empty value.\n *\n * @param item - The row being tested.\n * @param field - Property name from the filter.\n * @returns The property value, or `undefined` when the row has no such key.\n */\nfunction readField(item: unknown, field: string): unknown {\n    if (item == null || typeof item !== \"object\") return undefined;\n    return (item as Record<string, unknown>)[field];\n}\n\n/**\n * Local `yyyy-mm-dd` for a value that represents a date, or `null`.\n *\n * Delegates the formatting to {@link formatDateForInput}, which owns the rule\n * that the key is built from the local calendar parts rather than `toISOString`.\n * This adds only the narrowing from `unknown` and maps \"not a date\" to `null`\n * instead of to the empty string a date input wants.\n *\n * @param value - A `Date`, a date-ish string, or anything else.\n * @returns The day key, or `null` when the value does not denote a date.\n */\nfunction dayKey(value: unknown): string | null {\n    if (value instanceof Date) return formatDateForInput(value) || null;\n    if (typeof value !== \"string\" || value.trim() === \"\") return null;\n    return formatDateForInput(value) || null;\n}\n\n/**\n * Compare a row value against a filter value, in the row value's own type.\n *\n * The filter always carries strings — it comes from form inputs and from the\n * URL — while the row carries whatever the API returned. Comparing them as text\n * gets the two common cases wrong: `10` would sort before `9`, and a date would\n * be compared by however it happens to be formatted. So the row value picks the\n * comparison, and the filter value is coerced into it.\n *\n * Dates compare by **day**, not by instant: a row stamped `2026-03-05T13:00:00Z`\n * is `>= 2026-03-05`, which is what the person picking a date in the UI means.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Negative, zero or positive, or `null` when the two cannot be compared.\n */\nfunction compare(left: unknown, right: string): number | null {\n    if (left == null) return null;\n\n    if (typeof left === \"number\") {\n        const parsed = Number(right);\n        return Number.isNaN(parsed) ? null : left - parsed;\n    }\n\n    if (typeof left === \"boolean\") {\n        const parsed = right === \"true\" ? true : right === \"false\" ? false : null;\n        return parsed === null ? null : Number(left) - Number(parsed);\n    }\n\n    if (DATE_ONLY.test(right)) {\n        const key = dayKey(left);\n        return key === null ? null : key.localeCompare(right);\n    }\n\n    return TEXT_COLLATOR.compare(String(left), right);\n}\n\n/**\n * Equality in the row value's type, falling back to exact text.\n *\n * Case-sensitive on purpose: `eq` maps to a plain `WHERE column = value` on the\n * server side, so a case-insensitive client would quietly disagree with the\n * backend for the same filter. `contains` is the case-insensitive operator, and\n * it is also the default one for text fields, so the friendly behaviour is what\n * people get without asking.\n *\n * Identical strings take a fast path out, since the row value is text in the\n * common case and the collator is the expensive part.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Whether the two are equal.\n */\nfunction equals(left: unknown, right: string): boolean {\n    if (left === right) return true;\n    const result = compare(left, right);\n    if (result !== null) return result === 0;\n    return String(left ?? \"\") === right;\n}\n\n/**\n * Is this row value empty?\n *\n * Empty means absent, blank text or an empty list — never falsy. `0` and `false`\n * are values somebody chose, and a filter that hid them would be reporting the\n * wrong count on every dashboard that tracks zeroes.\n *\n * @param value - The row value.\n * @returns Whether the value counts as empty.\n */\nfunction isEmptyValue(value: unknown): boolean {\n    if (value == null) return true;\n    if (typeof value === \"string\") return value.trim() === \"\";\n    if (Array.isArray(value)) return value.length === 0;\n    return false;\n}\n\n/**\n * The filter's value as a list, whatever arity the operator uses.\n *\n * @param filter - The filter to read.\n * @returns Its values, trimmed of nothing — a leading space may be meaningful text.\n */\nfunction valuesOf(filter: Filter): string[] {\n    if (filter.value === undefined) return [];\n    return Array.isArray(filter.value) ? [...filter.value] : [String(filter.value)];\n}\n\n/**\n * Evaluate one operator against one row value.\n *\n * @param operator - The comparison to make.\n * @param left - The row value.\n * @param values - The filter values (one, two for `between`, many for `in`).\n * @returns Whether the row value satisfies the operator.\n */\nfunction matchesOperator(operator: FilterOperator, left: unknown, values: string[]): boolean {\n    switch (operator) {\n        case \"empty\":\n            return isEmptyValue(left);\n        case \"notEmpty\":\n            return !isEmptyValue(left);\n        case \"eq\":\n            return equals(left, values[0] ?? \"\");\n        case \"ne\":\n            return !equals(left, values[0] ?? \"\");\n        case \"contains\":\n            return String(left ?? \"\")\n                .toLowerCase()\n                .includes((values[0] ?? \"\").toLowerCase());\n        case \"in\":\n            return values.some((value) => equals(left, value));\n        case \"between\": {\n            const [first = \"\", second = \"\"] = values;\n            const low = compare(left, first);\n            const high = compare(left, second);\n            if (low === null || high === null) return false;\n            return low >= 0 && high <= 0;\n        }\n        default: {\n            const result = compare(left, values[0] ?? \"\");\n            if (result === null) return false;\n            if (operator === \"gt\") return result > 0;\n            if (operator === \"gte\") return result >= 0;\n            if (operator === \"lt\") return result < 0;\n            return result <= 0;\n        }\n    }\n}\n\n/**\n * Order the two values of a `between` so the range is never empty by accident.\n *\n * A person who picks the later date first means the range between the two dates,\n * not \"no rows\". The server-side `BETWEEN` needs `(lo, hi)` in order too, which\n * is why the normalisation lives here and is shared by `filtersToQueryParams`.\n *\n * @param values - The raw pair.\n * @returns The pair, ascending.\n */\nexport function orderRange(values: readonly string[]): string[] {\n    const [first = \"\", second = \"\"] = values;\n    if (DATE_ONLY.test(first) && DATE_ONLY.test(second)) {\n        return first <= second ? [first, second] : [second, first];\n    }\n    const low = Number(first);\n    const high = Number(second);\n    if (!Number.isNaN(low) && !Number.isNaN(high)) {\n        return low <= high ? [first, second] : [second, first];\n    }\n    return TEXT_COLLATOR.compare(first, second) <= 0 ? [first, second] : [second, first];\n}\n\n/**\n * Run a filter set over an in-memory list.\n *\n * Closes the loop `FilterBar` opens: the bar produces `Filter[]`, this applies\n * them. Filters combine with `AND`, matching the flat model the bar builds, and\n * an incomplete filter is skipped rather than treated as a match of nothing — a\n * half-filled form should not empty the table underneath it.\n *\n * Comparison follows the row's type, not the filter's: numbers compare\n * numerically, dates compare by day, and everything else compares as text with\n * `numeric: true` so `\"item 2\"` lands before `\"item 10\"`.\n *\n * A few behaviours differ from the SQL the server-side twin produces, and the\n * difference is deliberate rather than accidental:\n *\n * - `ne` matches rows whose value is absent. In SQL, `column <> 'x'` is `NULL`\n *   for a `NULL` column and the row drops out. Here \"is not paid\" shows the rows\n *   with no status at all, which is what the chip claims.\n * - `empty` matches `NULL`, blank text and empty lists; `__isnull` on the server\n *   only matches `NULL`. A column that stores `\"\"` instead of `NULL` is where\n *   the two disagree.\n *\n * @example\n * const visible = applyFilters(orders, filters);\n *\n * Each filter's values are normalised once, before the scan, rather than inside\n * the per-row predicate: the arity, the `between` ordering and the value array\n * depend only on the filter, so deriving them per row multiplied that work by\n * the row count. `empty`/`notEmpty` ignore their values entirely, which is why\n * the prepared shape does not need to distinguish them.\n *\n * @param items - The full list.\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns A new array with the rows that satisfy every complete filter.\n */\nexport function applyFilters<T>(items: readonly T[], filters: readonly Filter[]): T[] {\n    const active = filters.filter(isComplete).map((filter) => ({\n        field: filter.field,\n        operator: filter.operator,\n        values: filter.operator === \"between\" ? orderRange(valuesOf(filter)) : valuesOf(filter),\n    }));\n    if (active.length === 0) return [...items];\n\n    return items.filter((item) =>\n        active.every(({ field, operator, values }) =>\n            matchesOperator(operator, readField(item, field), values),\n        ),\n    );\n}\n"],"mappings":"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"}

package/dist/components/FilterBar/filter-apply.js

@@ -1,17 +1,14 @@
-import { isComplete as e, isValueless as t } from "./filter-model.js";
+import { isComplete as e } from "./filter-model.js";
+import { formatDateForInput as t } from "../../utils/format.js";
 //#region src/components/FilterBar/filter-apply.ts
-var n = /^\d{4}-\d{2}-\d{2}$/;
-function r(e, t) {
+var n = /^\d{4}-\d{2}-\d{2}$/, r = new Intl.Collator(void 0, { numeric: !0 });
+function i(e, t) {
 	if (!(typeof e != "object" || !e)) return e[t];
 }
-function i(e) {
-	if (typeof e == "string" && n.test(e)) return e;
-	let t = e instanceof Date ? e : typeof e == "string" && e.trim() !== "" ? new Date(e) : null;
-	if (t === null || Number.isNaN(t.getTime())) return null;
-	let r = `${t.getMonth() + 1}`.padStart(2, "0"), i = `${t.getDate()}`.padStart(2, "0");
-	return `${t.getFullYear()}-${r}-${i}`;
+function a(e) {
+	return e instanceof Date ? t(e) || null : typeof e != "string" || e.trim() === "" ? null : t(e) || null;
 }
-function a(e, t) {
+function o(e, t) {
 	if (e == null) return null;
 	if (typeof e == "number") {
 		let n = Number(t);
@@ -22,55 +19,55 @@ function a(e, t) {
 		return n === null ? null : Number(e) - Number(n);
 	}
 	if (n.test(t)) {
-		let n = i(e);
+		let n = a(e);
 		return n === null ? null : n.localeCompare(t);
 	}
-	return String(e).localeCompare(t, void 0, { numeric: !0 });
+	return r.compare(String(e), t);
 }
-function o(e, t) {
-	let n = a(e, t);
+function s(e, t) {
+	if (e === t) return !0;
+	let n = o(e, t);
 	return n === null ? String(e ?? "") === t : n === 0;
 }
-function s(e) {
+function c(e) {
 	return e == null ? !0 : typeof e == "string" ? e.trim() === "" : Array.isArray(e) ? e.length === 0 : !1;
 }
-function c(e) {
+function l(e) {
 	return e.value === void 0 ? [] : Array.isArray(e.value) ? [...e.value] : [String(e.value)];
 }
-function l(e, t, n) {
+function u(e, t, n) {
 	switch (e) {
-		case "empty": return s(t);
-		case "notEmpty": return !s(t);
-		case "eq": return o(t, n[0] ?? "");
-		case "ne": return !o(t, n[0] ?? "");
+		case "empty": return c(t);
+		case "notEmpty": return !c(t);
+		case "eq": return s(t, n[0] ?? "");
+		case "ne": return !s(t, n[0] ?? "");
 		case "contains": return String(t ?? "").toLowerCase().includes((n[0] ?? "").toLowerCase());
-		case "in": return n.some((e) => o(t, e));
+		case "in": return n.some((e) => s(t, e));
 		case "between": {
-			let [e = "", r = ""] = n, i = a(t, e), o = a(t, r);
-			return i === null || o === null ? !1 : i >= 0 && o <= 0;
+			let [e = "", r = ""] = n, i = o(t, e), a = o(t, r);
+			return i === null || a === null ? !1 : i >= 0 && a <= 0;
 		}
 		default: {
-			let r = a(t, n[0] ?? "");
+			let r = o(t, n[0] ?? "");
 			return r === null ? !1 : e === "gt" ? r > 0 : e === "gte" ? r >= 0 : e === "lt" ? r < 0 : r <= 0;
 		}
 	}
 }
-function u(e) {
-	let [t = "", r = ""] = e;
-	if (n.test(t) && n.test(r)) return t <= r ? [t, r] : [r, t];
-	let i = Number(t), a = Number(r);
-	return !Number.isNaN(i) && !Number.isNaN(a) ? i <= a ? [t, r] : [r, t] : t.localeCompare(r, void 0, { numeric: !0 }) <= 0 ? [t, r] : [r, t];
+function d(e) {
+	let [t = "", i = ""] = e;
+	if (n.test(t) && n.test(i)) return t <= i ? [t, i] : [i, t];
+	let a = Number(t), o = Number(i);
+	return !Number.isNaN(a) && !Number.isNaN(o) ? a <= o ? [t, i] : [i, t] : r.compare(t, i) <= 0 ? [t, i] : [i, t];
 }
-function d(n, i) {
-	let a = i.filter(e);
-	return a.length === 0 ? [...n] : n.filter((e) => a.every((n) => {
-		let i = r(e, n.field);
-		if (t(n.operator)) return l(n.operator, i, []);
-		let a = n.operator === "between" ? u(c(n)) : c(n);
-		return l(n.operator, i, a);
+function f(t, n) {
+	let r = n.filter(e).map((e) => ({
+		field: e.field,
+		operator: e.operator,
+		values: e.operator === "between" ? d(l(e)) : l(e)
 	}));
+	return r.length === 0 ? [...t] : t.filter((e) => r.every(({ field: t, operator: n, values: r }) => u(n, i(e, t), r)));
 }
 //#endregion
-export { d as applyFilters, u as orderRange };
+export { f as applyFilters, d as orderRange };
 
 //# sourceMappingURL=filter-apply.js.map

package/dist/components/FilterBar/filter-apply.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-apply.js","names":[],"sources":["../../../src/components/FilterBar/filter-apply.ts"],"sourcesContent":["// The other half of the filter model: evaluating a `Filter[]` instead of only\n// describing it. `FilterBar` produces filters, `applyFilters` runs them over an\n// in-memory list, and `filtersToQueryParams` (filter-query.ts) hands the same set\n// to a paginated backend. Without these two the model stops one step short of\n// useful and every app writes the eleven operator branches again.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete, isValueless } from \"./filter-model\";\n\n/** Matches a plain `yyyy-mm-dd`, the shape `<input type=\"date\">` produces. */\nconst DATE_ONLY = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * Read a property off a row without asserting the row's shape.\n *\n * `Filter.field` is a string chosen by the app's field list, so it cannot be a\n * `keyof T`; the lookup goes through an index signature and a missing property\n * yields `undefined`, which the operators treat as an empty value.\n *\n * @param item - The row being tested.\n * @param field - Property name from the filter.\n * @returns The property value, or `undefined` when the row has no such key.\n */\nfunction readField(item: unknown, field: string): unknown {\n    if (item == null || typeof item !== \"object\") return undefined;\n    return (item as Record<string, unknown>)[field];\n}\n\n/**\n * Local `yyyy-mm-dd` for a value that represents a date, or `null`.\n *\n * Built from the local calendar parts rather than `toISOString`, which converts\n * to UTC first and therefore reports the next day for anything after 21:00 in\n * UTC-3. A `yyyy-mm-dd` string is returned untouched, so a filter value and a\n * row value that already agree never round-trip through `Date` at all.\n *\n * @param value - A `Date`, a date-ish string, or anything else.\n * @returns The day key, or `null` when the value does not denote a date.\n */\nfunction dayKey(value: unknown): string | null {\n    if (typeof value === \"string\" && DATE_ONLY.test(value)) return value;\n\n    const date =\n        value instanceof Date\n            ? value\n            : typeof value === \"string\" && value.trim() !== \"\"\n              ? new Date(value)\n              : null;\n    if (date === null || Number.isNaN(date.getTime())) return null;\n\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Compare a row value against a filter value, in the row value's own type.\n *\n * The filter always carries strings — it comes from form inputs and from the\n * URL — while the row carries whatever the API returned. Comparing them as text\n * gets the two common cases wrong: `10` would sort before `9`, and a date would\n * be compared by however it happens to be formatted. So the row value picks the\n * comparison, and the filter value is coerced into it.\n *\n * Dates compare by **day**, not by instant: a row stamped `2026-03-05T13:00:00Z`\n * is `>= 2026-03-05`, which is what the person picking a date in the UI means.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Negative, zero or positive, or `null` when the two cannot be compared.\n */\nfunction compare(left: unknown, right: string): number | null {\n    if (left == null) return null;\n\n    if (typeof left === \"number\") {\n        const parsed = Number(right);\n        return Number.isNaN(parsed) ? null : left - parsed;\n    }\n\n    if (typeof left === \"boolean\") {\n        const parsed = right === \"true\" ? true : right === \"false\" ? false : null;\n        return parsed === null ? null : Number(left) - Number(parsed);\n    }\n\n    if (DATE_ONLY.test(right)) {\n        const key = dayKey(left);\n        return key === null ? null : key.localeCompare(right);\n    }\n\n    return String(left).localeCompare(right, undefined, { numeric: true });\n}\n\n/**\n * Equality in the row value's type, falling back to exact text.\n *\n * Case-sensitive on purpose: `eq` maps to a plain `WHERE column = value` on the\n * server side, so a case-insensitive client would quietly disagree with the\n * backend for the same filter. `contains` is the case-insensitive operator, and\n * it is also the default one for text fields, so the friendly behaviour is what\n * people get without asking.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Whether the two are equal.\n */\nfunction equals(left: unknown, right: string): boolean {\n    const result = compare(left, right);\n    if (result !== null) return result === 0;\n    return String(left ?? \"\") === right;\n}\n\n/**\n * Is this row value empty?\n *\n * Empty means absent, blank text or an empty list — never falsy. `0` and `false`\n * are values somebody chose, and a filter that hid them would be reporting the\n * wrong count on every dashboard that tracks zeroes.\n *\n * @param value - The row value.\n * @returns Whether the value counts as empty.\n */\nfunction isEmptyValue(value: unknown): boolean {\n    if (value == null) return true;\n    if (typeof value === \"string\") return value.trim() === \"\";\n    if (Array.isArray(value)) return value.length === 0;\n    return false;\n}\n\n/**\n * The filter's value as a list, whatever arity the operator uses.\n *\n * @param filter - The filter to read.\n * @returns Its values, trimmed of nothing — a leading space may be meaningful text.\n */\nfunction valuesOf(filter: Filter): string[] {\n    if (filter.value === undefined) return [];\n    return Array.isArray(filter.value) ? [...filter.value] : [String(filter.value)];\n}\n\n/**\n * Evaluate one operator against one row value.\n *\n * @param operator - The comparison to make.\n * @param left - The row value.\n * @param values - The filter values (one, two for `between`, many for `in`).\n * @returns Whether the row value satisfies the operator.\n */\nfunction matchesOperator(operator: FilterOperator, left: unknown, values: string[]): boolean {\n    switch (operator) {\n        case \"empty\":\n            return isEmptyValue(left);\n        case \"notEmpty\":\n            return !isEmptyValue(left);\n        case \"eq\":\n            return equals(left, values[0] ?? \"\");\n        case \"ne\":\n            return !equals(left, values[0] ?? \"\");\n        case \"contains\":\n            return String(left ?? \"\")\n                .toLowerCase()\n                .includes((values[0] ?? \"\").toLowerCase());\n        case \"in\":\n            return values.some((value) => equals(left, value));\n        case \"between\": {\n            const [first = \"\", second = \"\"] = values;\n            const low = compare(left, first);\n            const high = compare(left, second);\n            if (low === null || high === null) return false;\n            return low >= 0 && high <= 0;\n        }\n        default: {\n            const result = compare(left, values[0] ?? \"\");\n            if (result === null) return false;\n            if (operator === \"gt\") return result > 0;\n            if (operator === \"gte\") return result >= 0;\n            if (operator === \"lt\") return result < 0;\n            return result <= 0;\n        }\n    }\n}\n\n/**\n * Order the two values of a `between` so the range is never empty by accident.\n *\n * A person who picks the later date first means the range between the two dates,\n * not \"no rows\". The server-side `BETWEEN` needs `(lo, hi)` in order too, which\n * is why the normalisation lives here and is shared by `filtersToQueryParams`.\n *\n * @param values - The raw pair.\n * @returns The pair, ascending.\n */\nexport function orderRange(values: readonly string[]): string[] {\n    const [first = \"\", second = \"\"] = values;\n    if (DATE_ONLY.test(first) && DATE_ONLY.test(second)) {\n        return first <= second ? [first, second] : [second, first];\n    }\n    const low = Number(first);\n    const high = Number(second);\n    if (!Number.isNaN(low) && !Number.isNaN(high)) {\n        return low <= high ? [first, second] : [second, first];\n    }\n    return first.localeCompare(second, undefined, { numeric: true }) <= 0\n        ? [first, second]\n        : [second, first];\n}\n\n/**\n * Run a filter set over an in-memory list.\n *\n * Closes the loop `FilterBar` opens: the bar produces `Filter[]`, this applies\n * them. Filters combine with `AND`, matching the flat model the bar builds, and\n * an incomplete filter is skipped rather than treated as a match of nothing — a\n * half-filled form should not empty the table underneath it.\n *\n * Comparison follows the row's type, not the filter's: numbers compare\n * numerically, dates compare by day, and everything else compares as text with\n * `numeric: true` so `\"item 2\"` lands before `\"item 10\"`.\n *\n * A few behaviours differ from the SQL the server-side twin produces, and the\n * difference is deliberate rather than accidental:\n *\n * - `ne` matches rows whose value is absent. In SQL, `column <> 'x'` is `NULL`\n *   for a `NULL` column and the row drops out. Here \"is not paid\" shows the rows\n *   with no status at all, which is what the chip claims.\n * - `empty` matches `NULL`, blank text and empty lists; `__isnull` on the server\n *   only matches `NULL`. A column that stores `\"\"` instead of `NULL` is where\n *   the two disagree.\n *\n * @example\n * const visible = applyFilters(orders, filters);\n *\n * @param items - The full list.\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns A new array with the rows that satisfy every complete filter.\n */\nexport function applyFilters<T>(items: readonly T[], filters: readonly Filter[]): T[] {\n    const active = filters.filter(isComplete);\n    if (active.length === 0) return [...items];\n\n    return items.filter((item) =>\n        active.every((filter) => {\n            const left = readField(item, filter.field);\n            if (isValueless(filter.operator)) {\n                return matchesOperator(filter.operator, left, []);\n            }\n            const values =\n                filter.operator === \"between\" ? orderRange(valuesOf(filter)) : valuesOf(filter);\n            return matchesOperator(filter.operator, left, values);\n        }),\n    );\n}\n"],"mappings":"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"}
+{"version":3,"file":"filter-apply.js","names":[],"sources":["../../../src/components/FilterBar/filter-apply.ts"],"sourcesContent":["// The other half of the filter model: evaluating a `Filter[]` instead of only\n// describing it. `FilterBar` produces filters, `applyFilters` runs them over an\n// in-memory list, and `filtersToQueryParams` (filter-query.ts) hands the same set\n// to a paginated backend. Without these two the model stops one step short of\n// useful and every app writes the eleven operator branches again.\n\nimport { formatDateForInput } from \"@/utils/format\";\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\n\n/** Matches a plain `yyyy-mm-dd`, the shape `<input type=\"date\">` produces. */\nconst DATE_ONLY = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * One collator for every text comparison in this module.\n *\n * `localeCompare(value, undefined, { numeric: true })` builds a collator on each\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and this comparison runs once per row per filter. Measured at 200k\n * comparisons: 453 ms through `localeCompare` against 25 ms through a hoisted\n * collator, i.e. ~23 ms of main thread per keystroke on a 10k-row list.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Read a property off a row without asserting the row's shape.\n *\n * `Filter.field` is a string chosen by the app's field list, so it cannot be a\n * `keyof T`; the lookup goes through an index signature and a missing property\n * yields `undefined`, which the operators treat as an empty value.\n *\n * @param item - The row being tested.\n * @param field - Property name from the filter.\n * @returns The property value, or `undefined` when the row has no such key.\n */\nfunction readField(item: unknown, field: string): unknown {\n    if (item == null || typeof item !== \"object\") return undefined;\n    return (item as Record<string, unknown>)[field];\n}\n\n/**\n * Local `yyyy-mm-dd` for a value that represents a date, or `null`.\n *\n * Delegates the formatting to {@link formatDateForInput}, which owns the rule\n * that the key is built from the local calendar parts rather than `toISOString`.\n * This adds only the narrowing from `unknown` and maps \"not a date\" to `null`\n * instead of to the empty string a date input wants.\n *\n * @param value - A `Date`, a date-ish string, or anything else.\n * @returns The day key, or `null` when the value does not denote a date.\n */\nfunction dayKey(value: unknown): string | null {\n    if (value instanceof Date) return formatDateForInput(value) || null;\n    if (typeof value !== \"string\" || value.trim() === \"\") return null;\n    return formatDateForInput(value) || null;\n}\n\n/**\n * Compare a row value against a filter value, in the row value's own type.\n *\n * The filter always carries strings — it comes from form inputs and from the\n * URL — while the row carries whatever the API returned. Comparing them as text\n * gets the two common cases wrong: `10` would sort before `9`, and a date would\n * be compared by however it happens to be formatted. So the row value picks the\n * comparison, and the filter value is coerced into it.\n *\n * Dates compare by **day**, not by instant: a row stamped `2026-03-05T13:00:00Z`\n * is `>= 2026-03-05`, which is what the person picking a date in the UI means.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Negative, zero or positive, or `null` when the two cannot be compared.\n */\nfunction compare(left: unknown, right: string): number | null {\n    if (left == null) return null;\n\n    if (typeof left === \"number\") {\n        const parsed = Number(right);\n        return Number.isNaN(parsed) ? null : left - parsed;\n    }\n\n    if (typeof left === \"boolean\") {\n        const parsed = right === \"true\" ? true : right === \"false\" ? false : null;\n        return parsed === null ? null : Number(left) - Number(parsed);\n    }\n\n    if (DATE_ONLY.test(right)) {\n        const key = dayKey(left);\n        return key === null ? null : key.localeCompare(right);\n    }\n\n    return TEXT_COLLATOR.compare(String(left), right);\n}\n\n/**\n * Equality in the row value's type, falling back to exact text.\n *\n * Case-sensitive on purpose: `eq` maps to a plain `WHERE column = value` on the\n * server side, so a case-insensitive client would quietly disagree with the\n * backend for the same filter. `contains` is the case-insensitive operator, and\n * it is also the default one for text fields, so the friendly behaviour is what\n * people get without asking.\n *\n * Identical strings take a fast path out, since the row value is text in the\n * common case and the collator is the expensive part.\n *\n * @param left - The row value.\n * @param right - The raw filter value.\n * @returns Whether the two are equal.\n */\nfunction equals(left: unknown, right: string): boolean {\n    if (left === right) return true;\n    const result = compare(left, right);\n    if (result !== null) return result === 0;\n    return String(left ?? \"\") === right;\n}\n\n/**\n * Is this row value empty?\n *\n * Empty means absent, blank text or an empty list — never falsy. `0` and `false`\n * are values somebody chose, and a filter that hid them would be reporting the\n * wrong count on every dashboard that tracks zeroes.\n *\n * @param value - The row value.\n * @returns Whether the value counts as empty.\n */\nfunction isEmptyValue(value: unknown): boolean {\n    if (value == null) return true;\n    if (typeof value === \"string\") return value.trim() === \"\";\n    if (Array.isArray(value)) return value.length === 0;\n    return false;\n}\n\n/**\n * The filter's value as a list, whatever arity the operator uses.\n *\n * @param filter - The filter to read.\n * @returns Its values, trimmed of nothing — a leading space may be meaningful text.\n */\nfunction valuesOf(filter: Filter): string[] {\n    if (filter.value === undefined) return [];\n    return Array.isArray(filter.value) ? [...filter.value] : [String(filter.value)];\n}\n\n/**\n * Evaluate one operator against one row value.\n *\n * @param operator - The comparison to make.\n * @param left - The row value.\n * @param values - The filter values (one, two for `between`, many for `in`).\n * @returns Whether the row value satisfies the operator.\n */\nfunction matchesOperator(operator: FilterOperator, left: unknown, values: string[]): boolean {\n    switch (operator) {\n        case \"empty\":\n            return isEmptyValue(left);\n        case \"notEmpty\":\n            return !isEmptyValue(left);\n        case \"eq\":\n            return equals(left, values[0] ?? \"\");\n        case \"ne\":\n            return !equals(left, values[0] ?? \"\");\n        case \"contains\":\n            return String(left ?? \"\")\n                .toLowerCase()\n                .includes((values[0] ?? \"\").toLowerCase());\n        case \"in\":\n            return values.some((value) => equals(left, value));\n        case \"between\": {\n            const [first = \"\", second = \"\"] = values;\n            const low = compare(left, first);\n            const high = compare(left, second);\n            if (low === null || high === null) return false;\n            return low >= 0 && high <= 0;\n        }\n        default: {\n            const result = compare(left, values[0] ?? \"\");\n            if (result === null) return false;\n            if (operator === \"gt\") return result > 0;\n            if (operator === \"gte\") return result >= 0;\n            if (operator === \"lt\") return result < 0;\n            return result <= 0;\n        }\n    }\n}\n\n/**\n * Order the two values of a `between` so the range is never empty by accident.\n *\n * A person who picks the later date first means the range between the two dates,\n * not \"no rows\". The server-side `BETWEEN` needs `(lo, hi)` in order too, which\n * is why the normalisation lives here and is shared by `filtersToQueryParams`.\n *\n * @param values - The raw pair.\n * @returns The pair, ascending.\n */\nexport function orderRange(values: readonly string[]): string[] {\n    const [first = \"\", second = \"\"] = values;\n    if (DATE_ONLY.test(first) && DATE_ONLY.test(second)) {\n        return first <= second ? [first, second] : [second, first];\n    }\n    const low = Number(first);\n    const high = Number(second);\n    if (!Number.isNaN(low) && !Number.isNaN(high)) {\n        return low <= high ? [first, second] : [second, first];\n    }\n    return TEXT_COLLATOR.compare(first, second) <= 0 ? [first, second] : [second, first];\n}\n\n/**\n * Run a filter set over an in-memory list.\n *\n * Closes the loop `FilterBar` opens: the bar produces `Filter[]`, this applies\n * them. Filters combine with `AND`, matching the flat model the bar builds, and\n * an incomplete filter is skipped rather than treated as a match of nothing — a\n * half-filled form should not empty the table underneath it.\n *\n * Comparison follows the row's type, not the filter's: numbers compare\n * numerically, dates compare by day, and everything else compares as text with\n * `numeric: true` so `\"item 2\"` lands before `\"item 10\"`.\n *\n * A few behaviours differ from the SQL the server-side twin produces, and the\n * difference is deliberate rather than accidental:\n *\n * - `ne` matches rows whose value is absent. In SQL, `column <> 'x'` is `NULL`\n *   for a `NULL` column and the row drops out. Here \"is not paid\" shows the rows\n *   with no status at all, which is what the chip claims.\n * - `empty` matches `NULL`, blank text and empty lists; `__isnull` on the server\n *   only matches `NULL`. A column that stores `\"\"` instead of `NULL` is where\n *   the two disagree.\n *\n * @example\n * const visible = applyFilters(orders, filters);\n *\n * Each filter's values are normalised once, before the scan, rather than inside\n * the per-row predicate: the arity, the `between` ordering and the value array\n * depend only on the filter, so deriving them per row multiplied that work by\n * the row count. `empty`/`notEmpty` ignore their values entirely, which is why\n * the prepared shape does not need to distinguish them.\n *\n * @param items - The full list.\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns A new array with the rows that satisfy every complete filter.\n */\nexport function applyFilters<T>(items: readonly T[], filters: readonly Filter[]): T[] {\n    const active = filters.filter(isComplete).map((filter) => ({\n        field: filter.field,\n        operator: filter.operator,\n        values: filter.operator === \"between\" ? orderRange(valuesOf(filter)) : valuesOf(filter),\n    }));\n    if (active.length === 0) return [...items];\n\n    return items.filter((item) =>\n        active.every(({ field, operator, values }) =>\n            matchesOperator(operator, readField(item, field), values),\n        ),\n    );\n}\n"],"mappings":"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"}

package/dist/components/FilterBar/filter-query.cjs

@@ -1,2 +1,2 @@
-const e=require("./filter-model.cjs"),t=require("./filter-apply.cjs");var n={eq:``,ne:`__ne`,contains:`__icontains`,gt:`__gt`,gte:`__gte`,lt:`__lt`,lte:`__lte`,between:`__between`,in:`__in`,empty:`__isnull`,notEmpty:`__isnull`},r=`name`;function i(i){let a=new URLSearchParams;for(let o of i){if(!e.isComplete(o))continue;let i=n[o.operator],s=o.operator===`eq`&&o.field===r?`${o.field}__iexact`:`${o.field}${i}`;if(o.operator===`empty`||o.operator===`notEmpty`){a.append(s,o.operator===`empty`?`true`:`false`);continue}let c=Array.isArray(o.value)?[...o.value]:[String(o.value??``)];if(o.operator===`between`){for(let e of t.orderRange(c))a.append(s,e);continue}for(let e of c)a.append(s,e)}return a}exports.filtersToQueryParams=i;
+const e=require("./filter-model.cjs"),t=require("./filter-apply.cjs");var n={eq:``,ne:`__ne`,contains:`__icontains`,gt:`__gt`,gte:`__gte`,lt:`__lt`,lte:`__lte`,between:`__between`,in:`__in`,empty:`__isnull`,notEmpty:`__isnull`},r=new Set([`name`]);function i(i,a={}){let o=a.operatorSuffix?{...n,...a.operatorSuffix}:n,s=a.substringColumns?new Set(a.substringColumns):r,c=new URLSearchParams;for(let n of i){if(!e.isComplete(n))continue;let r=o[n.operator],i=n.operator===`eq`&&s.has(n.field)?`${n.field}__iexact`:`${n.field}${r}`;if(n.operator===`empty`||n.operator===`notEmpty`){c.append(i,n.operator===`empty`?`true`:`false`);continue}let a=Array.isArray(n.value)?[...n.value]:[String(n.value??``)];if(n.operator===`between`){for(let e of t.orderRange(a))c.append(i,e);continue}for(let e of a)c.append(i,e)}return c}exports.filtersToQueryParams=i;
 //# sourceMappingURL=filter-query.cjs.map

package/dist/components/FilterBar/filter-query.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filter-query.cjs","names":[],"sources":["../../../src/components/FilterBar/filter-query.ts"],"sourcesContent":["// Server-side half of the filter model: the same `Filter[]` the bar produces,\n// encoded the way a paginated backend expects to read it. Kept apart from\n// `filtersToSearchParams` (filter-model.ts) because the two answer different\n// questions — that one round-trips the UI state through the URL, this one talks\n// to an API and its shape is the API's, not ours.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\nimport { orderRange } from \"./filter-apply\";\n\n/**\n * Operator suffix per filter operator, following the `<column>__<op>` convention\n * of `tempest-fastapi-sdk`.\n *\n * Ported from `build_filter_condition` in\n * `tempest_fastapi_sdk/db/expressions.py`, which is what `BaseRepository`\n * dict filters and `Q` both resolve through. An empty suffix means the bare\n * column name, which that function resolves to plain equality.\n *\n * `contains` maps to `icontains` (case-insensitive, and the backend escapes the\n * `LIKE` wildcards) and both emptiness operators map to `isnull`, whose value\n * carries the direction.\n */\nconst OPERATOR_SUFFIX: Record<FilterOperator, string> = {\n    eq: \"\",\n    ne: \"__ne\",\n    contains: \"__icontains\",\n    gt: \"__gt\",\n    gte: \"__gte\",\n    lt: \"__lt\",\n    lte: \"__lte\",\n    between: \"__between\",\n    in: \"__in\",\n    empty: \"__isnull\",\n    notEmpty: \"__isnull\",\n};\n\n/**\n * Column name the backend treats as a substring search when it carries no\n * operator suffix.\n *\n * Ported from `build_filter_condition`, which special-cases a string `name` into\n * `ILIKE %value%`. Sending a bare `name=` for an `eq` filter would therefore ask\n * for \"contains\" while the chip says \"is\", so `eq` on this column is emitted as\n * `name__iexact` instead.\n */\nconst SUBSTRING_COLUMN = \"name\";\n\n/**\n * Encode filters as query params for a paginated backend.\n *\n * The counterpart of {@link applyFilters}: same filter set, evaluated by the\n * database instead of by the browser, which is the only option once the list is\n * paginated on the server and the page in memory is not the whole result.\n *\n * The encoding is the `<column>__<op>` convention `tempest-fastapi-sdk` already\n * reads (`BaseRepository._apply_filters` → `build_filter_condition`):\n *\n * | Operator | Param |\n * | --- | --- |\n * | `eq` | `field` (or `field__iexact` for the `name` column) |\n * | `ne` | `field__ne` |\n * | `contains` | `field__icontains` |\n * | `gt` `gte` `lt` `lte` | `field__gt` … `field__lte` |\n * | `between` | `field__between` twice, low value first |\n * | `in` | `field__in` once per value |\n * | `empty` / `notEmpty` | `field__isnull=true` / `=false` |\n *\n * Returns `URLSearchParams` rather than a plain object because `between` carries\n * a pair and `in` carries a list: an object would keep only the last value of\n * each, silently narrowing the filter. Repeated params are also how FastAPI\n * receives a `list[str]` declared with `Query`.\n *\n * Two things the backend has to hold up its end of, or the filter fails quietly:\n *\n * - **Every key must be declared.** `BasePaginationFilterSchema.get_conditions()`\n *   only forwards fields the subclass declares, so a `status__ne` the schema\n *   never mentions is dropped by FastAPI before the repository sees it — no\n *   error, no filtering.\n * - **`isnull` matches `NULL` only.** A column that stores `\"\"` for \"no value\"\n *   will not answer an `empty` filter, while {@link applyFilters} treats blank\n *   text as empty.\n *\n * @example\n * const params = filtersToQueryParams(filters);\n * params.set(\"page\", String(page));\n * const data = await api.get(`/orders?${params}`);\n *\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns Params ready to append to a request URL.\n */\nexport function filtersToQueryParams(filters: readonly Filter[]): URLSearchParams {\n    const params = new URLSearchParams();\n\n    for (const filter of filters) {\n        if (!isComplete(filter)) continue;\n\n        const suffix = OPERATOR_SUFFIX[filter.operator];\n        const key =\n            filter.operator === \"eq\" && filter.field === SUBSTRING_COLUMN\n                ? `${filter.field}__iexact`\n                : `${filter.field}${suffix}`;\n\n        if (filter.operator === \"empty\" || filter.operator === \"notEmpty\") {\n            params.append(key, filter.operator === \"empty\" ? \"true\" : \"false\");\n            continue;\n        }\n\n        const values = Array.isArray(filter.value)\n            ? [...filter.value]\n            : [String(filter.value ?? \"\")];\n\n        if (filter.operator === \"between\") {\n            for (const value of orderRange(values)) params.append(key, value);\n            continue;\n        }\n\n        for (const value of values) params.append(key, value);\n    }\n\n    return params;\n}\n"],"mappings":"sEAuBA,IAAM,EAAkD,CACpD,GAAI,GACJ,GAAI,OACJ,SAAU,cACV,GAAI,OACJ,IAAK,QACL,GAAI,OACJ,IAAK,QACL,QAAS,YACT,GAAI,OACJ,MAAO,WACP,SAAU,UACd,EAWM,EAAmB,OA6CzB,SAAgB,EAAqB,EAA6C,CAC9E,IAAM,EAAS,IAAI,gBAEnB,IAAK,IAAM,KAAU,EAAS,CAC1B,GAAI,CAAC,EAAA,WAAW,CAAM,EAAG,SAEzB,IAAM,EAAS,EAAgB,EAAO,UAChC,EACF,EAAO,WAAa,MAAQ,EAAO,QAAU,EACvC,GAAG,EAAO,MAAM,UAChB,GAAG,EAAO,QAAQ,IAE5B,GAAI,EAAO,WAAa,SAAW,EAAO,WAAa,WAAY,CAC/D,EAAO,OAAO,EAAK,EAAO,WAAa,QAAU,OAAS,OAAO,EACjE,QACJ,CAEA,IAAM,EAAS,MAAM,QAAQ,EAAO,KAAK,EACnC,CAAC,GAAG,EAAO,KAAK,EAChB,CAAC,OAAO,EAAO,OAAS,EAAE,CAAC,EAEjC,GAAI,EAAO,WAAa,UAAW,CAC/B,IAAK,IAAM,KAAS,EAAA,WAAW,CAAM,EAAG,EAAO,OAAO,EAAK,CAAK,EAChE,QACJ,CAEA,IAAK,IAAM,KAAS,EAAQ,EAAO,OAAO,EAAK,CAAK,CACxD,CAEA,OAAO,CACX"}
+{"version":3,"file":"filter-query.cjs","names":[],"sources":["../../../src/components/FilterBar/filter-query.ts"],"sourcesContent":["// Server-side half of the filter model: the same `Filter[]` the bar produces,\n// encoded the way a paginated backend expects to read it. Kept apart from\n// `filtersToSearchParams` (filter-model.ts) because the two answer different\n// questions — that one round-trips the UI state through the URL, this one talks\n// to an API and its shape is the API's, not ours.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\nimport { orderRange } from \"./filter-apply\";\n\n/**\n * Operator suffix per filter operator, following the `<column>__<op>` convention\n * of `tempest-fastapi-sdk`.\n *\n * Ported from `build_filter_condition` in\n * `tempest_fastapi_sdk/db/expressions.py`, which is what `BaseRepository`\n * dict filters and `Q` both resolve through. An empty suffix means the bare\n * column name, which that function resolves to plain equality.\n *\n * `contains` maps to `icontains` (case-insensitive, and the backend escapes the\n * `LIKE` wildcards) and both emptiness operators map to `isnull`, whose value\n * carries the direction.\n */\nconst DEFAULT_OPERATOR_SUFFIX: Record<FilterOperator, string> = {\n    eq: \"\",\n    ne: \"__ne\",\n    contains: \"__icontains\",\n    gt: \"__gt\",\n    gte: \"__gte\",\n    lt: \"__lt\",\n    lte: \"__lte\",\n    between: \"__between\",\n    in: \"__in\",\n    empty: \"__isnull\",\n    notEmpty: \"__isnull\",\n};\n\n/**\n * Columns the backend treats as a substring search when they carry no operator\n * suffix.\n *\n * Ported from `build_filter_condition`, which special-cases a string `name` into\n * `ILIKE %value%`. Sending a bare `name=` for an `eq` filter would therefore ask\n * for \"contains\" while the chip says \"is\", so `eq` on such a column is emitted as\n * `name__iexact` instead.\n */\nconst DEFAULT_SUBSTRING_COLUMNS: ReadonlySet<string> = new Set([\"name\"]);\n\n/** Overrides for the backend dialect {@link filtersToQueryParams} encodes into. */\nexport interface FiltersToQueryParamsOptions {\n    /**\n     * Columns whose `eq` is emitted as `<column>__iexact` rather than as the bare\n     * column name. Default `[\"name\"]`, which is what `build_filter_condition`\n     * special-cases.\n     *\n     * Pass the columns **your** backend treats that way — `nome`, `titulo`,\n     * `razao_social` — or `[]` when it treats none of them specially and a bare\n     * `eq` should stay bare.\n     */\n    substringColumns?: readonly string[];\n    /**\n     * Operator suffixes, merged over the `tempest-fastapi-sdk` dialect, so an\n     * override names only the operators that differ.\n     *\n     * @example\n     * // A DRF-style backend\n     * filtersToQueryParams(filters, {\n     *     substringColumns: [],\n     *     operatorSuffix: { contains: \"__icontains\", ne: \"__exclude\" },\n     * });\n     */\n    operatorSuffix?: Partial<Record<FilterOperator, string>>;\n}\n\n/**\n * Encode filters as query params for a paginated backend.\n *\n * The counterpart of {@link applyFilters}: same filter set, evaluated by the\n * database instead of by the browser, which is the only option once the list is\n * paginated on the server and the page in memory is not the whole result.\n *\n * The encoding is the `<column>__<op>` convention `tempest-fastapi-sdk` already\n * reads (`BaseRepository._apply_filters` → `build_filter_condition`):\n *\n * | Operator | Param |\n * | --- | --- |\n * | `eq` | `field` (or `field__iexact` for the `name` column) |\n * | `ne` | `field__ne` |\n * | `contains` | `field__icontains` |\n * | `gt` `gte` `lt` `lte` | `field__gt` … `field__lte` |\n * | `between` | `field__between` twice, low value first |\n * | `in` | `field__in` once per value |\n * | `empty` / `notEmpty` | `field__isnull=true` / `=false` |\n *\n * Returns `URLSearchParams` rather than a plain object because `between` carries\n * a pair and `in` carries a list: an object would keep only the last value of\n * each, silently narrowing the filter. Repeated params are also how FastAPI\n * receives a `list[str]` declared with `Query`.\n *\n * Two things the backend has to hold up its end of, or the filter fails quietly:\n *\n * - **Every key must be declared.** `BasePaginationFilterSchema.get_conditions()`\n *   only forwards fields the subclass declares, so a `status__ne` the schema\n *   never mentions is dropped by FastAPI before the repository sees it — no\n *   error, no filtering.\n * - **`isnull` matches `NULL` only.** A column that stores `\"\"` for \"no value\"\n *   will not answer an `empty` filter, while {@link applyFilters} treats blank\n *   text as empty.\n *\n * The defaults are that dialect, not a universal truth. A backend that names its\n * substring column something other than `name`, or that spells its operators\n * differently, passes `options` — the alternative was an encoder whose special\n * cases were a wall for anyone not on the Tempest stack.\n *\n * @example\n * const params = filtersToQueryParams(filters);\n * params.set(\"page\", String(page));\n * const data = await api.get(`/orders?${params}`);\n *\n * @example\n * // A backend whose searchable column is `razao_social` and that spells `ne`\n * // the Django way.\n * const params = filtersToQueryParams(filters, {\n *     substringColumns: [\"razao_social\"],\n *     operatorSuffix: { ne: \"__exclude\" },\n * });\n *\n * @param filters - Applied filters; incomplete ones are ignored.\n * @param options - Dialect overrides. Defaults to the `tempest-fastapi-sdk` one.\n * @returns Params ready to append to a request URL.\n */\nexport function filtersToQueryParams(\n    filters: readonly Filter[],\n    options: FiltersToQueryParamsOptions = {},\n): URLSearchParams {\n    const suffixes = options.operatorSuffix\n        ? { ...DEFAULT_OPERATOR_SUFFIX, ...options.operatorSuffix }\n        : DEFAULT_OPERATOR_SUFFIX;\n    const substringColumns = options.substringColumns\n        ? new Set(options.substringColumns)\n        : DEFAULT_SUBSTRING_COLUMNS;\n\n    const params = new URLSearchParams();\n\n    for (const filter of filters) {\n        if (!isComplete(filter)) continue;\n\n        const suffix = suffixes[filter.operator];\n        const key =\n            filter.operator === \"eq\" && substringColumns.has(filter.field)\n                ? `${filter.field}__iexact`\n                : `${filter.field}${suffix}`;\n\n        if (filter.operator === \"empty\" || filter.operator === \"notEmpty\") {\n            params.append(key, filter.operator === \"empty\" ? \"true\" : \"false\");\n            continue;\n        }\n\n        const values = Array.isArray(filter.value)\n            ? [...filter.value]\n            : [String(filter.value ?? \"\")];\n\n        if (filter.operator === \"between\") {\n            for (const value of orderRange(values)) params.append(key, value);\n            continue;\n        }\n\n        for (const value of values) params.append(key, value);\n    }\n\n    return params;\n}\n"],"mappings":"sEAuBA,IAAM,EAA0D,CAC5D,GAAI,GACJ,GAAI,OACJ,SAAU,cACV,GAAI,OACJ,IAAK,QACL,GAAI,OACJ,IAAK,QACL,QAAS,YACT,GAAI,OACJ,MAAO,WACP,SAAU,UACd,EAWM,EAAiD,IAAI,IAAI,CAAC,MAAM,CAAC,EAqFvE,SAAgB,EACZ,EACA,EAAuC,CAAC,EACzB,CACf,IAAM,EAAW,EAAQ,eACnB,CAAE,GAAG,EAAyB,GAAG,EAAQ,cAAe,EACxD,EACA,EAAmB,EAAQ,iBAC3B,IAAI,IAAI,EAAQ,gBAAgB,EAChC,EAEA,EAAS,IAAI,gBAEnB,IAAK,IAAM,KAAU,EAAS,CAC1B,GAAI,CAAC,EAAA,WAAW,CAAM,EAAG,SAEzB,IAAM,EAAS,EAAS,EAAO,UACzB,EACF,EAAO,WAAa,MAAQ,EAAiB,IAAI,EAAO,KAAK,EACvD,GAAG,EAAO,MAAM,UAChB,GAAG,EAAO,QAAQ,IAE5B,GAAI,EAAO,WAAa,SAAW,EAAO,WAAa,WAAY,CAC/D,EAAO,OAAO,EAAK,EAAO,WAAa,QAAU,OAAS,OAAO,EACjE,QACJ,CAEA,IAAM,EAAS,MAAM,QAAQ,EAAO,KAAK,EACnC,CAAC,GAAG,EAAO,KAAK,EAChB,CAAC,OAAO,EAAO,OAAS,EAAE,CAAC,EAEjC,GAAI,EAAO,WAAa,UAAW,CAC/B,IAAK,IAAM,KAAS,EAAA,WAAW,CAAM,EAAG,EAAO,OAAO,EAAK,CAAK,EAChE,QACJ,CAEA,IAAK,IAAM,KAAS,EAAQ,EAAO,OAAO,EAAK,CAAK,CACxD,CAEA,OAAO,CACX"}

package/dist/components/FilterBar/filter-query.js

@@ -13,24 +13,27 @@ var n = {
 	in: "__in",
 	empty: "__isnull",
 	notEmpty: "__isnull"
-}, r = "name";
-function i(i) {
-	let a = new URLSearchParams();
-	for (let o of i) {
-		if (!e(o)) continue;
-		let i = n[o.operator], s = o.operator === "eq" && o.field === r ? `${o.field}__iexact` : `${o.field}${i}`;
-		if (o.operator === "empty" || o.operator === "notEmpty") {
-			a.append(s, o.operator === "empty" ? "true" : "false");
+}, r = /* @__PURE__ */ new Set(["name"]);
+function i(i, a = {}) {
+	let o = a.operatorSuffix ? {
+		...n,
+		...a.operatorSuffix
+	} : n, s = a.substringColumns ? new Set(a.substringColumns) : r, c = new URLSearchParams();
+	for (let n of i) {
+		if (!e(n)) continue;
+		let r = o[n.operator], i = n.operator === "eq" && s.has(n.field) ? `${n.field}__iexact` : `${n.field}${r}`;
+		if (n.operator === "empty" || n.operator === "notEmpty") {
+			c.append(i, n.operator === "empty" ? "true" : "false");
 			continue;
 		}
-		let c = Array.isArray(o.value) ? [...o.value] : [String(o.value ?? "")];
-		if (o.operator === "between") {
-			for (let e of t(c)) a.append(s, e);
+		let a = Array.isArray(n.value) ? [...n.value] : [String(n.value ?? "")];
+		if (n.operator === "between") {
+			for (let e of t(a)) c.append(i, e);
 			continue;
 		}
-		for (let e of c) a.append(s, e);
+		for (let e of a) c.append(i, e);
 	}
-	return a;
+	return c;
 }
 //#endregion
 export { i as filtersToQueryParams };

package/dist/components/FilterBar/filter-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-query.js","names":[],"sources":["../../../src/components/FilterBar/filter-query.ts"],"sourcesContent":["// Server-side half of the filter model: the same `Filter[]` the bar produces,\n// encoded the way a paginated backend expects to read it. Kept apart from\n// `filtersToSearchParams` (filter-model.ts) because the two answer different\n// questions — that one round-trips the UI state through the URL, this one talks\n// to an API and its shape is the API's, not ours.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\nimport { orderRange } from \"./filter-apply\";\n\n/**\n * Operator suffix per filter operator, following the `<column>__<op>` convention\n * of `tempest-fastapi-sdk`.\n *\n * Ported from `build_filter_condition` in\n * `tempest_fastapi_sdk/db/expressions.py`, which is what `BaseRepository`\n * dict filters and `Q` both resolve through. An empty suffix means the bare\n * column name, which that function resolves to plain equality.\n *\n * `contains` maps to `icontains` (case-insensitive, and the backend escapes the\n * `LIKE` wildcards) and both emptiness operators map to `isnull`, whose value\n * carries the direction.\n */\nconst OPERATOR_SUFFIX: Record<FilterOperator, string> = {\n    eq: \"\",\n    ne: \"__ne\",\n    contains: \"__icontains\",\n    gt: \"__gt\",\n    gte: \"__gte\",\n    lt: \"__lt\",\n    lte: \"__lte\",\n    between: \"__between\",\n    in: \"__in\",\n    empty: \"__isnull\",\n    notEmpty: \"__isnull\",\n};\n\n/**\n * Column name the backend treats as a substring search when it carries no\n * operator suffix.\n *\n * Ported from `build_filter_condition`, which special-cases a string `name` into\n * `ILIKE %value%`. Sending a bare `name=` for an `eq` filter would therefore ask\n * for \"contains\" while the chip says \"is\", so `eq` on this column is emitted as\n * `name__iexact` instead.\n */\nconst SUBSTRING_COLUMN = \"name\";\n\n/**\n * Encode filters as query params for a paginated backend.\n *\n * The counterpart of {@link applyFilters}: same filter set, evaluated by the\n * database instead of by the browser, which is the only option once the list is\n * paginated on the server and the page in memory is not the whole result.\n *\n * The encoding is the `<column>__<op>` convention `tempest-fastapi-sdk` already\n * reads (`BaseRepository._apply_filters` → `build_filter_condition`):\n *\n * | Operator | Param |\n * | --- | --- |\n * | `eq` | `field` (or `field__iexact` for the `name` column) |\n * | `ne` | `field__ne` |\n * | `contains` | `field__icontains` |\n * | `gt` `gte` `lt` `lte` | `field__gt` … `field__lte` |\n * | `between` | `field__between` twice, low value first |\n * | `in` | `field__in` once per value |\n * | `empty` / `notEmpty` | `field__isnull=true` / `=false` |\n *\n * Returns `URLSearchParams` rather than a plain object because `between` carries\n * a pair and `in` carries a list: an object would keep only the last value of\n * each, silently narrowing the filter. Repeated params are also how FastAPI\n * receives a `list[str]` declared with `Query`.\n *\n * Two things the backend has to hold up its end of, or the filter fails quietly:\n *\n * - **Every key must be declared.** `BasePaginationFilterSchema.get_conditions()`\n *   only forwards fields the subclass declares, so a `status__ne` the schema\n *   never mentions is dropped by FastAPI before the repository sees it — no\n *   error, no filtering.\n * - **`isnull` matches `NULL` only.** A column that stores `\"\"` for \"no value\"\n *   will not answer an `empty` filter, while {@link applyFilters} treats blank\n *   text as empty.\n *\n * @example\n * const params = filtersToQueryParams(filters);\n * params.set(\"page\", String(page));\n * const data = await api.get(`/orders?${params}`);\n *\n * @param filters - Applied filters; incomplete ones are ignored.\n * @returns Params ready to append to a request URL.\n */\nexport function filtersToQueryParams(filters: readonly Filter[]): URLSearchParams {\n    const params = new URLSearchParams();\n\n    for (const filter of filters) {\n        if (!isComplete(filter)) continue;\n\n        const suffix = OPERATOR_SUFFIX[filter.operator];\n        const key =\n            filter.operator === \"eq\" && filter.field === SUBSTRING_COLUMN\n                ? `${filter.field}__iexact`\n                : `${filter.field}${suffix}`;\n\n        if (filter.operator === \"empty\" || filter.operator === \"notEmpty\") {\n            params.append(key, filter.operator === \"empty\" ? \"true\" : \"false\");\n            continue;\n        }\n\n        const values = Array.isArray(filter.value)\n            ? [...filter.value]\n            : [String(filter.value ?? \"\")];\n\n        if (filter.operator === \"between\") {\n            for (const value of orderRange(values)) params.append(key, value);\n            continue;\n        }\n\n        for (const value of values) params.append(key, value);\n    }\n\n    return params;\n}\n"],"mappings":";;;AAuBA,IAAM,IAAkD;CACpD,IAAI;CACJ,IAAI;CACJ,UAAU;CACV,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,KAAK;CACL,SAAS;CACT,IAAI;CACJ,OAAO;CACP,UAAU;AACd,GAWM,IAAmB;AA6CzB,SAAgB,EAAqB,GAA6C;CAC9E,IAAM,IAAS,IAAI,gBAAgB;CAEnC,KAAK,IAAM,KAAU,GAAS;EAC1B,IAAI,CAAC,EAAW,CAAM,GAAG;EAEzB,IAAM,IAAS,EAAgB,EAAO,WAChC,IACF,EAAO,aAAa,QAAQ,EAAO,UAAU,IACvC,GAAG,EAAO,MAAM,YAChB,GAAG,EAAO,QAAQ;EAE5B,IAAI,EAAO,aAAa,WAAW,EAAO,aAAa,YAAY;GAC/D,EAAO,OAAO,GAAK,EAAO,aAAa,UAAU,SAAS,OAAO;GACjE;EACJ;EAEA,IAAM,IAAS,MAAM,QAAQ,EAAO,KAAK,IACnC,CAAC,GAAG,EAAO,KAAK,IAChB,CAAC,OAAO,EAAO,SAAS,EAAE,CAAC;EAEjC,IAAI,EAAO,aAAa,WAAW;GAC/B,KAAK,IAAM,KAAS,EAAW,CAAM,GAAG,EAAO,OAAO,GAAK,CAAK;GAChE;EACJ;EAEA,KAAK,IAAM,KAAS,GAAQ,EAAO,OAAO,GAAK,CAAK;CACxD;CAEA,OAAO;AACX"}
+{"version":3,"file":"filter-query.js","names":[],"sources":["../../../src/components/FilterBar/filter-query.ts"],"sourcesContent":["// Server-side half of the filter model: the same `Filter[]` the bar produces,\n// encoded the way a paginated backend expects to read it. Kept apart from\n// `filtersToSearchParams` (filter-model.ts) because the two answer different\n// questions — that one round-trips the UI state through the URL, this one talks\n// to an API and its shape is the API's, not ours.\n\nimport type { Filter, FilterOperator } from \"./filter-model\";\nimport { isComplete } from \"./filter-model\";\nimport { orderRange } from \"./filter-apply\";\n\n/**\n * Operator suffix per filter operator, following the `<column>__<op>` convention\n * of `tempest-fastapi-sdk`.\n *\n * Ported from `build_filter_condition` in\n * `tempest_fastapi_sdk/db/expressions.py`, which is what `BaseRepository`\n * dict filters and `Q` both resolve through. An empty suffix means the bare\n * column name, which that function resolves to plain equality.\n *\n * `contains` maps to `icontains` (case-insensitive, and the backend escapes the\n * `LIKE` wildcards) and both emptiness operators map to `isnull`, whose value\n * carries the direction.\n */\nconst DEFAULT_OPERATOR_SUFFIX: Record<FilterOperator, string> = {\n    eq: \"\",\n    ne: \"__ne\",\n    contains: \"__icontains\",\n    gt: \"__gt\",\n    gte: \"__gte\",\n    lt: \"__lt\",\n    lte: \"__lte\",\n    between: \"__between\",\n    in: \"__in\",\n    empty: \"__isnull\",\n    notEmpty: \"__isnull\",\n};\n\n/**\n * Columns the backend treats as a substring search when they carry no operator\n * suffix.\n *\n * Ported from `build_filter_condition`, which special-cases a string `name` into\n * `ILIKE %value%`. Sending a bare `name=` for an `eq` filter would therefore ask\n * for \"contains\" while the chip says \"is\", so `eq` on such a column is emitted as\n * `name__iexact` instead.\n */\nconst DEFAULT_SUBSTRING_COLUMNS: ReadonlySet<string> = new Set([\"name\"]);\n\n/** Overrides for the backend dialect {@link filtersToQueryParams} encodes into. */\nexport interface FiltersToQueryParamsOptions {\n    /**\n     * Columns whose `eq` is emitted as `<column>__iexact` rather than as the bare\n     * column name. Default `[\"name\"]`, which is what `build_filter_condition`\n     * special-cases.\n     *\n     * Pass the columns **your** backend treats that way — `nome`, `titulo`,\n     * `razao_social` — or `[]` when it treats none of them specially and a bare\n     * `eq` should stay bare.\n     */\n    substringColumns?: readonly string[];\n    /**\n     * Operator suffixes, merged over the `tempest-fastapi-sdk` dialect, so an\n     * override names only the operators that differ.\n     *\n     * @example\n     * // A DRF-style backend\n     * filtersToQueryParams(filters, {\n     *     substringColumns: [],\n     *     operatorSuffix: { contains: \"__icontains\", ne: \"__exclude\" },\n     * });\n     */\n    operatorSuffix?: Partial<Record<FilterOperator, string>>;\n}\n\n/**\n * Encode filters as query params for a paginated backend.\n *\n * The counterpart of {@link applyFilters}: same filter set, evaluated by the\n * database instead of by the browser, which is the only option once the list is\n * paginated on the server and the page in memory is not the whole result.\n *\n * The encoding is the `<column>__<op>` convention `tempest-fastapi-sdk` already\n * reads (`BaseRepository._apply_filters` → `build_filter_condition`):\n *\n * | Operator | Param |\n * | --- | --- |\n * | `eq` | `field` (or `field__iexact` for the `name` column) |\n * | `ne` | `field__ne` |\n * | `contains` | `field__icontains` |\n * | `gt` `gte` `lt` `lte` | `field__gt` … `field__lte` |\n * | `between` | `field__between` twice, low value first |\n * | `in` | `field__in` once per value |\n * | `empty` / `notEmpty` | `field__isnull=true` / `=false` |\n *\n * Returns `URLSearchParams` rather than a plain object because `between` carries\n * a pair and `in` carries a list: an object would keep only the last value of\n * each, silently narrowing the filter. Repeated params are also how FastAPI\n * receives a `list[str]` declared with `Query`.\n *\n * Two things the backend has to hold up its end of, or the filter fails quietly:\n *\n * - **Every key must be declared.** `BasePaginationFilterSchema.get_conditions()`\n *   only forwards fields the subclass declares, so a `status__ne` the schema\n *   never mentions is dropped by FastAPI before the repository sees it — no\n *   error, no filtering.\n * - **`isnull` matches `NULL` only.** A column that stores `\"\"` for \"no value\"\n *   will not answer an `empty` filter, while {@link applyFilters} treats blank\n *   text as empty.\n *\n * The defaults are that dialect, not a universal truth. A backend that names its\n * substring column something other than `name`, or that spells its operators\n * differently, passes `options` — the alternative was an encoder whose special\n * cases were a wall for anyone not on the Tempest stack.\n *\n * @example\n * const params = filtersToQueryParams(filters);\n * params.set(\"page\", String(page));\n * const data = await api.get(`/orders?${params}`);\n *\n * @example\n * // A backend whose searchable column is `razao_social` and that spells `ne`\n * // the Django way.\n * const params = filtersToQueryParams(filters, {\n *     substringColumns: [\"razao_social\"],\n *     operatorSuffix: { ne: \"__exclude\" },\n * });\n *\n * @param filters - Applied filters; incomplete ones are ignored.\n * @param options - Dialect overrides. Defaults to the `tempest-fastapi-sdk` one.\n * @returns Params ready to append to a request URL.\n */\nexport function filtersToQueryParams(\n    filters: readonly Filter[],\n    options: FiltersToQueryParamsOptions = {},\n): URLSearchParams {\n    const suffixes = options.operatorSuffix\n        ? { ...DEFAULT_OPERATOR_SUFFIX, ...options.operatorSuffix }\n        : DEFAULT_OPERATOR_SUFFIX;\n    const substringColumns = options.substringColumns\n        ? new Set(options.substringColumns)\n        : DEFAULT_SUBSTRING_COLUMNS;\n\n    const params = new URLSearchParams();\n\n    for (const filter of filters) {\n        if (!isComplete(filter)) continue;\n\n        const suffix = suffixes[filter.operator];\n        const key =\n            filter.operator === \"eq\" && substringColumns.has(filter.field)\n                ? `${filter.field}__iexact`\n                : `${filter.field}${suffix}`;\n\n        if (filter.operator === \"empty\" || filter.operator === \"notEmpty\") {\n            params.append(key, filter.operator === \"empty\" ? \"true\" : \"false\");\n            continue;\n        }\n\n        const values = Array.isArray(filter.value)\n            ? [...filter.value]\n            : [String(filter.value ?? \"\")];\n\n        if (filter.operator === \"between\") {\n            for (const value of orderRange(values)) params.append(key, value);\n            continue;\n        }\n\n        for (const value of values) params.append(key, value);\n    }\n\n    return params;\n}\n"],"mappings":";;;AAuBA,IAAM,IAA0D;CAC5D,IAAI;CACJ,IAAI;CACJ,UAAU;CACV,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,KAAK;CACL,SAAS;CACT,IAAI;CACJ,OAAO;CACP,UAAU;AACd,GAWM,oBAAiD,IAAI,IAAI,CAAC,MAAM,CAAC;AAqFvE,SAAgB,EACZ,GACA,IAAuC,CAAC,GACzB;CACf,IAAM,IAAW,EAAQ,iBACnB;EAAE,GAAG;EAAyB,GAAG,EAAQ;CAAe,IACxD,GACA,IAAmB,EAAQ,mBAC3B,IAAI,IAAI,EAAQ,gBAAgB,IAChC,GAEA,IAAS,IAAI,gBAAgB;CAEnC,KAAK,IAAM,KAAU,GAAS;EAC1B,IAAI,CAAC,EAAW,CAAM,GAAG;EAEzB,IAAM,IAAS,EAAS,EAAO,WACzB,IACF,EAAO,aAAa,QAAQ,EAAiB,IAAI,EAAO,KAAK,IACvD,GAAG,EAAO,MAAM,YAChB,GAAG,EAAO,QAAQ;EAE5B,IAAI,EAAO,aAAa,WAAW,EAAO,aAAa,YAAY;GAC/D,EAAO,OAAO,GAAK,EAAO,aAAa,UAAU,SAAS,OAAO;GACjE;EACJ;EAEA,IAAM,IAAS,MAAM,QAAQ,EAAO,KAAK,IACnC,CAAC,GAAG,EAAO,KAAK,IAChB,CAAC,OAAO,EAAO,SAAS,EAAE,CAAC;EAEjC,IAAI,EAAO,aAAa,WAAW;GAC/B,KAAK,IAAM,KAAS,EAAW,CAAM,GAAG,EAAO,OAAO,GAAK,CAAK;GAChE;EACJ;EAEA,KAAK,IAAM,KAAS,GAAQ,EAAO,OAAO,GAAK,CAAK;CACxD;CAEA,OAAO;AACX"}

package/dist/components/NotificationCenter/NotificationCenter.cjs

@@ -1,2 +1,2 @@
-const e=require("../../utils/cn.cjs"),t=require("../../utils/relative-time.cjs"),n=require("../Badge/Badge.cjs"),r=require("../EmptyState/EmptyState.cjs"),i=require("./NotificationCenter.module.cjs");let a=require("react/jsx-runtime");function o({items:o,title:s=`Notificações`,onSelect:c,onMarkRead:l,onMarkAllRead:u,onDismiss:d,renderIcon:f,locale:p=`pt-BR`,emptyState:m,now:h,className:g,..._}){let v=o.filter(e=>!e.read).length,y=h??new Date().getTime(),b=e=>{e.read||l?.(e.id),c?.(e)},x=!!(c||l);return(0,a.jsxs)(`div`,{className:e.cn(i.default.panel,g),..._,children:[(s||u&&v>0)&&(0,a.jsxs)(`header`,{className:i.default.header,children:[s?(0,a.jsxs)(`h2`,{className:i.default.title,children:[s,v>0&&(0,a.jsx)(n.Badge,{variant:`primary`,"aria-label":`${v} não lidas`,children:v})]}):(0,a.jsx)(`span`,{}),u&&v>0&&(0,a.jsx)(`button`,{type:`button`,className:i.default.headerAction,onClick:u,children:`Marcar todas como lidas`})]}),o.length===0?m??(0,a.jsx)(r.EmptyState,{title:`Nenhuma notificação`}):(0,a.jsx)(`ul`,{className:i.default.list,children:o.map(n=>(0,a.jsxs)(`li`,{className:e.cn(i.default.item,!n.read&&i.default.unread),"aria-current":n.read?void 0:`true`,children:[f&&(0,a.jsx)(`span`,{className:i.default.icon,children:f(n)}),(0,a.jsxs)(`div`,{className:i.default.body,children:[x?(0,a.jsxs)(`button`,{type:`button`,className:i.default.trigger,onClick:()=>b(n),children:[(0,a.jsx)(`span`,{className:i.default.itemTitle,children:n.title}),n.body&&(0,a.jsx)(`span`,{className:i.default.itemBody,children:n.body})]}):(0,a.jsxs)(a.Fragment,{children:[(0,a.jsx)(`span`,{className:i.default.itemTitle,children:n.title}),n.body&&(0,a.jsx)(`span`,{className:i.default.itemBody,children:n.body})]}),(0,a.jsx)(`time`,{className:i.default.time,dateTime:new Date(n.receivedAt).toISOString(),children:t.relativeTime(n.receivedAt,{locale:p,now:y})})]}),d&&(0,a.jsx)(`button`,{type:`button`,className:i.default.dismiss,onClick:()=>d(n.id),"aria-label":`Descartar: ${n.title}`,children:`×`})]},n.id))})]})}exports.NotificationCenter=o;
+const e=require("../../utils/cn.cjs"),t=require("../Badge/Badge.cjs"),n=require("../EmptyState/EmptyState.cjs"),r=require("../../utils/relative-time.cjs"),i=require("./NotificationCenter.module.cjs");let a=require("react/jsx-runtime");function o({items:o,title:s=`Notificações`,onSelect:c,onMarkRead:l,onMarkAllRead:u,onDismiss:d,renderIcon:f,locale:p=`pt-BR`,emptyState:m,now:h,className:g,..._}){let v=o.filter(e=>!e.read).length,y=h??new Date().getTime(),b=e=>{e.read||l?.(e.id),c?.(e)},x=!!(c||l);return(0,a.jsxs)(`div`,{className:e.cn(i.default.panel,g),..._,children:[(s||u&&v>0)&&(0,a.jsxs)(`header`,{className:i.default.header,children:[s?(0,a.jsxs)(`h2`,{className:i.default.title,children:[s,v>0&&(0,a.jsx)(t.Badge,{variant:`primary`,"aria-label":`${v} não lidas`,children:v})]}):(0,a.jsx)(`span`,{}),u&&v>0&&(0,a.jsx)(`button`,{type:`button`,className:i.default.headerAction,onClick:u,children:`Marcar todas como lidas`})]}),o.length===0?m??(0,a.jsx)(n.EmptyState,{title:`Nenhuma notificação`}):(0,a.jsx)(`ul`,{className:i.default.list,children:o.map(t=>(0,a.jsxs)(`li`,{className:e.cn(i.default.item,!t.read&&i.default.unread),"aria-current":t.read?void 0:`true`,children:[f&&(0,a.jsx)(`span`,{className:i.default.icon,children:f(t)}),(0,a.jsxs)(`div`,{className:i.default.body,children:[x?(0,a.jsxs)(`button`,{type:`button`,className:i.default.trigger,onClick:()=>b(t),children:[(0,a.jsx)(`span`,{className:i.default.itemTitle,children:t.title}),t.body&&(0,a.jsx)(`span`,{className:i.default.itemBody,children:t.body})]}):(0,a.jsxs)(a.Fragment,{children:[(0,a.jsx)(`span`,{className:i.default.itemTitle,children:t.title}),t.body&&(0,a.jsx)(`span`,{className:i.default.itemBody,children:t.body})]}),(0,a.jsx)(`time`,{className:i.default.time,dateTime:new Date(t.receivedAt).toISOString(),children:r.relativeTime(t.receivedAt,{locale:p,now:y})})]}),d&&(0,a.jsx)(`button`,{type:`button`,className:i.default.dismiss,onClick:()=>d(t.id),"aria-label":`Descartar: ${t.title}`,children:`×`})]},t.id))})]})}exports.NotificationCenter=o;
 //# sourceMappingURL=NotificationCenter.cjs.map

package/dist/components/NotificationCenter/NotificationCenter.js

@@ -1,7 +1,7 @@
 import { cn as e } from "../../utils/cn.js";
-import { relativeTime as t } from "../../utils/relative-time.js";
-import { Badge as n } from "../Badge/Badge.js";
-import { EmptyState as r } from "../EmptyState/EmptyState.js";
+import { Badge as t } from "../Badge/Badge.js";
+import { EmptyState as n } from "../EmptyState/EmptyState.js";
+import { relativeTime as r } from "../../utils/relative-time.js";
 import i from "./NotificationCenter.module.js";
 import { Fragment as a, jsx as o, jsxs as s } from "react/jsx-runtime";
 //#region src/components/NotificationCenter/NotificationCenter.tsx
@@ -16,7 +16,7 @@ function c({ items: c, title: l = "Notificações", onSelect: u, onMarkRead: d,
 			className: i.header,
 			children: [l ? /* @__PURE__ */ s("h2", {
 				className: i.title,
-				children: [l, b > 0 && /* @__PURE__ */ o(n, {
+				children: [l, b > 0 && /* @__PURE__ */ o(t, {
 					variant: "primary",
 					"aria-label": `${b} não lidas`,
 					children: b
@@ -27,39 +27,39 @@ function c({ items: c, title: l = "Notificações", onSelect: u, onMarkRead: d,
 				onClick: f,
 				children: "Marcar todas como lidas"
 			})]
-		}), c.length === 0 ? g ?? /* @__PURE__ */ o(r, { title: "Nenhuma notificação" }) : /* @__PURE__ */ o("ul", {
+		}), c.length === 0 ? g ?? /* @__PURE__ */ o(n, { title: "Nenhuma notificação" }) : /* @__PURE__ */ o("ul", {
 			className: i.list,
-			children: c.map((n) => /* @__PURE__ */ s("li", {
-				className: e(i.item, !n.read && i.unread),
-				"aria-current": n.read ? void 0 : "true",
+			children: c.map((t) => /* @__PURE__ */ s("li", {
+				className: e(i.item, !t.read && i.unread),
+				"aria-current": t.read ? void 0 : "true",
 				children: [
 					m && /* @__PURE__ */ o("span", {
 						className: i.icon,
-						children: m(n)
+						children: m(t)
 					}),
 					/* @__PURE__ */ s("div", {
 						className: i.body,
 						children: [C ? /* @__PURE__ */ s("button", {
 							type: "button",
 							className: i.trigger,
-							onClick: () => S(n),
+							onClick: () => S(t),
 							children: [/* @__PURE__ */ o("span", {
 								className: i.itemTitle,
-								children: n.title
-							}), n.body && /* @__PURE__ */ o("span", {
+								children: t.title
+							}), t.body && /* @__PURE__ */ o("span", {
 								className: i.itemBody,
-								children: n.body
+								children: t.body
 							})]
 						}) : /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ o("span", {
 							className: i.itemTitle,
-							children: n.title
-						}), n.body && /* @__PURE__ */ o("span", {
+							children: t.title
+						}), t.body && /* @__PURE__ */ o("span", {
 							className: i.itemBody,
-							children: n.body
+							children: t.body
 						})] }), /* @__PURE__ */ o("time", {
 							className: i.time,
-							dateTime: new Date(n.receivedAt).toISOString(),
-							children: t(n.receivedAt, {
+							dateTime: new Date(t.receivedAt).toISOString(),
+							children: r(t.receivedAt, {
 								locale: h,
 								now: x
 							})
@@ -68,12 +68,12 @@ function c({ items: c, title: l = "Notificações", onSelect: u, onMarkRead: d,
 					p && /* @__PURE__ */ o("button", {
 						type: "button",
 						className: i.dismiss,
-						onClick: () => p(n.id),
-						"aria-label": `Descartar: ${n.title}`,
+						onClick: () => p(t.id),
+						"aria-label": `Descartar: ${t.title}`,
 						children: "×"
 					})
 				]
-			}, n.id))
+			}, t.id))
 		})]
 	});
 }

package/dist/components/Sidebar/Sidebar.cjs

@@ -1,2 +1,2 @@
-const e=require("../../utils/cn.cjs"),t=require("./Sidebar.module.cjs");let n=require("react/jsx-runtime");function r({header:r,items:i,value:a,onChange:o,footer:s,collapsed:c=!1,width:l=240,collapsedWidth:u=64,className:d,style:f,...p}){let m=typeof(c?u:l)==`number`?`${c?u:l}px`:c?u:l;return(0,n.jsxs)(`aside`,{className:e.cn(t.default.sidebar,c&&t.default.collapsed,d),style:{width:m,...f},...p,children:[r&&(0,n.jsx)(`div`,{className:t.default.header,children:r}),(0,n.jsx)(`nav`,{className:t.default.nav,"aria-label":`Navegação lateral`,children:i.map(r=>{let i=r.key===a;return(0,n.jsxs)(`button`,{type:`button`,className:e.cn(t.default.item,i&&t.default.active),"aria-current":i?`page`:void 0,disabled:r.disabled,onClick:()=>o?.(r.key),title:c&&typeof r.label==`string`?r.label:void 0,children:[r.icon&&(0,n.jsx)(`span`,{className:t.default.icon,children:r.icon}),!c&&(0,n.jsx)(`span`,{className:t.default.label,children:r.label}),!c&&r.badge!==void 0&&(0,n.jsx)(`span`,{className:t.default.badge,children:r.badge})]},r.key)})}),s&&(0,n.jsx)(`div`,{className:t.default.footer,children:s})]})}exports.Sidebar=r;
+const e=require("../../utils/cn.cjs"),t=require("./Sidebar.module.cjs");let n=require("react"),r=require("react/jsx-runtime");function i(e){let t=[],n;for(let r of e){if(r.type===`separator`){t.push({kind:`separator`,key:r.key}),n=void 0;continue}if(r.type===`section`){n={kind:`items`,key:r.key,section:r,items:[]},t.push(n);continue}n||(n={kind:`items`,key:`loose-${r.key}`,items:[]},t.push(n)),n.items.push(r)}return t}function a({header:a,items:o,value:s,onChange:c,footer:l,collapsed:u=!1,width:d=240,collapsedWidth:f=64,className:p,style:m,...h}){let g=(0,n.useId)(),_=i(o),v=typeof(u?f:d)==`number`?`${u?f:d}px`:u?f:d,y=n=>{let i=n.key===s,a=u&&typeof n.label==`string`?n.label:void 0,o=(0,r.jsxs)(r.Fragment,{children:[n.icon&&(0,r.jsx)(`span`,{className:t.default.icon,children:n.icon}),!u&&(0,r.jsx)(`span`,{className:t.default.label,children:n.label}),!u&&n.badge!==void 0&&(0,r.jsx)(`span`,{className:t.default.badge,children:n.badge})]});return n.href&&!n.disabled?(0,r.jsx)(`a`,{href:n.href,className:e.cn(t.default.item,i&&t.default.active),"aria-current":i?`page`:void 0,onClick:()=>c?.(n.key),title:a,children:o},n.key):(0,r.jsx)(`button`,{type:`button`,className:e.cn(t.default.item,i&&t.default.active),"aria-current":i?`page`:void 0,disabled:n.disabled,onClick:()=>c?.(n.key),title:a,children:o},n.key)};return(0,r.jsxs)(`aside`,{className:e.cn(t.default.sidebar,u&&t.default.collapsed,p),style:{width:v,...m},...h,children:[a&&(0,r.jsx)(`div`,{className:t.default.header,children:a}),(0,r.jsx)(`nav`,{className:t.default.nav,"aria-label":`Navegação lateral`,children:_.map(n=>{if(n.kind===`separator`)return(0,r.jsx)(`hr`,{className:t.default.separator},n.key);if(!n.section)return(0,r.jsx)(`div`,{className:t.default.group,children:n.items.map(y)},n.key);let i=`${g}-${n.key}`;return(0,r.jsxs)(`div`,{role:`group`,"aria-labelledby":i,className:t.default.group,children:[(0,r.jsx)(`div`,{id:i,role:`presentation`,className:e.cn(t.default.section,u&&t.default.sectionCollapsed),children:n.section.label}),n.items.map(y)]},n.key)})}),l&&(0,r.jsx)(`div`,{className:t.default.footer,children:l})]})}exports.Sidebar=a;
 //# sourceMappingURL=Sidebar.cjs.map

package/dist/components/Sidebar/Sidebar.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"Sidebar.cjs","names":[],"sources":["../../../src/components/Sidebar/Sidebar.tsx"],"sourcesContent":["/**\n * @tempest-limits props-count — header, items, footer are the three regions,\n * value/onChange the selection, and collapsed/width/collapsedWidth the two layout\n * modes it switches between.\n */\nimport type { HTMLAttributes, ReactNode } from \"react\";\nimport { cn } from \"@/utils/cn\";\nimport styles from \"./Sidebar.module.css\";\n\nexport interface SidebarItem {\n    key: string;\n    label: ReactNode;\n    icon?: ReactNode;\n    badge?: ReactNode;\n    disabled?: boolean;\n    href?: string;\n}\n\nexport interface SidebarProps extends Omit<HTMLAttributes<HTMLElement>, \"onChange\"> {\n    /** Top slot — typically the logo + brand. */\n    header?: ReactNode;\n    /** Navigation items. */\n    items: SidebarItem[];\n    /** Active item key. */\n    value?: string;\n    /** Fires when an item is clicked. Receives the item's `key`. */\n    onChange?: (key: string) => void;\n    /** Bottom slot — typically settings/profile/logout. */\n    footer?: ReactNode;\n    /** Collapsed mode — only icons visible. Default `false`. */\n    collapsed?: boolean;\n    /** Width when expanded, in pixels or any CSS length. Default `240px`. */\n    width?: number | string;\n    /** Width when collapsed, in pixels or any CSS length. Default `64px`. */\n    collapsedWidth?: number | string;\n}\n\n/**\n * Desktop sidebar navigation. Pair with `<Show above=\"md\">` and a `Drawer`\n * for mobile.\n *\n * @example\n * const [tab, setTab] = useState(\"home\");\n * <Show above=\"md\">\n *     <Sidebar\n *         header={<Brand />}\n *         items={[{ key: \"home\", label: \"Home\", icon: <Home /> }]}\n *         value={tab}\n *         onChange={setTab}\n *     />\n * </Show>\n */\nexport function Sidebar({\n    header,\n    items,\n    value,\n    onChange,\n    footer,\n    collapsed = false,\n    width = 240,\n    collapsedWidth = 64,\n    className,\n    style,\n    ...props\n}: SidebarProps) {\n    const finalWidth =\n        typeof (collapsed ? collapsedWidth : width) === \"number\"\n            ? `${collapsed ? collapsedWidth : width}px`\n            : collapsed\n              ? collapsedWidth\n              : width;\n    return (\n        <aside\n            className={cn(styles.sidebar, collapsed && styles.collapsed, className)}\n            style={{ width: finalWidth, ...style }}\n            {...props}\n        >\n            {header && <div className={styles.header}>{header}</div>}\n            <nav className={styles.nav} aria-label=\"Navegação lateral\">\n                {items.map((item) => {\n                    const active = item.key === value;\n                    return (\n                        <button\n                            key={item.key}\n                            type=\"button\"\n                            className={cn(styles.item, active && styles.active)}\n                            aria-current={active ? \"page\" : undefined}\n                            disabled={item.disabled}\n                            onClick={() => onChange?.(item.key)}\n                            title={\n                                collapsed && typeof item.label === \"string\" ? item.label : undefined\n                            }\n                        >\n                            {item.icon && <span className={styles.icon}>{item.icon}</span>}\n                            {!collapsed && <span className={styles.label}>{item.label}</span>}\n                            {!collapsed && item.badge !== undefined && (\n                                <span className={styles.badge}>{item.badge}</span>\n                            )}\n                        </button>\n                    );\n                })}\n            </nav>\n            {footer && <div className={styles.footer}>{footer}</div>}\n        </aside>\n    );\n}\n"],"mappings":"2GAoDA,SAAgB,EAAQ,CACpB,SACA,QACA,QACA,WACA,SACA,YAAY,GACZ,QAAQ,IACR,iBAAiB,GACjB,YACA,QACA,GAAG,GACU,CACb,IAAM,EACF,OAAQ,EAAY,EAAiB,IAAW,SAC1C,GAAG,EAAY,EAAiB,EAAM,IACtC,EACE,EACA,EACZ,OACI,EAAA,EAAA,KAAA,CAAC,QAAD,CACI,UAAW,EAAA,GAAG,EAAA,QAAO,QAAS,GAAa,EAAA,QAAO,UAAW,CAAS,EACtE,MAAO,CAAE,MAAO,EAAY,GAAG,CAAM,EACrC,GAAI,EAHR,SAAA,CAKK,IAAU,EAAA,EAAA,IAAA,CAAC,MAAD,CAAK,UAAW,EAAA,QAAO,OAAS,SAAA,CAAY,CAAA,GACvD,EAAA,EAAA,IAAA,CAAC,MAAD,CAAK,UAAW,EAAA,QAAO,IAAK,aAAW,oBAClC,SAAA,EAAM,IAAK,GAAS,CACjB,IAAM,EAAS,EAAK,MAAQ,EAC5B,OACI,EAAA,EAAA,KAAA,CAAC,SAAD,CAEI,KAAK,SACL,UAAW,EAAA,GAAG,EAAA,QAAO,KAAM,GAAU,EAAA,QAAO,MAAM,EAClD,eAAc,EAAS,OAAS,IAAA,GAChC,SAAU,EAAK,SACf,YAAe,IAAW,EAAK,GAAG,EAClC,MACI,GAAa,OAAO,EAAK,OAAU,SAAW,EAAK,MAAQ,IAAA,GARnE,SAAA,CAWK,EAAK,OAAQ,EAAA,EAAA,IAAA,CAAC,OAAD,CAAM,UAAW,EAAA,QAAO,KAAO,SAAA,EAAK,IAAW,CAAA,EAC5D,CAAC,IAAa,EAAA,EAAA,IAAA,CAAC,OAAD,CAAM,UAAW,EAAA,QAAO,MAAQ,SAAA,EAAK,KAAY,CAAA,EAC/D,CAAC,GAAa,EAAK,QAAU,IAAA,KAC1B,EAAA,EAAA,IAAA,CAAC,OAAD,CAAM,UAAW,EAAA,QAAO,MAAQ,SAAA,EAAK,KAAY,CAAA,CAEjD,CAfC,EAAA,EAAK,GAeN,CAEhB,CAAC,CACA,CAAA,EACJ,IAAU,EAAA,EAAA,IAAA,CAAC,MAAD,CAAK,UAAW,EAAA,QAAO,OAAS,SAAA,CAAY,CAAA,CACpD,GAEf"}
+{"version":3,"file":"Sidebar.cjs","names":[],"sources":["../../../src/components/Sidebar/Sidebar.tsx"],"sourcesContent":["/**\n * @tempest-limits props-count — header, items, footer are the three regions,\n * value/onChange the selection, and collapsed/width/collapsedWidth the two layout\n * modes it switches between.\n */\nimport { useId, type HTMLAttributes, type ReactNode } from \"react\";\nimport { cn } from \"@/utils/cn\";\nimport styles from \"./Sidebar.module.css\";\n\nexport interface SidebarItem {\n    key: string;\n    label: ReactNode;\n    icon?: ReactNode;\n    badge?: ReactNode;\n    disabled?: boolean;\n    /**\n     * Renders the entry as a link to this URL instead of a button.\n     *\n     * `onChange` still fires on click, so an app that tracks the active key keeps\n     * working — the difference is that the entry now behaves like navigation:\n     * middle-click, ctrl-click and \"copy link address\" do what the user expects,\n     * and a screen reader announces a link rather than a button.\n     *\n     * A `disabled` entry ignores this and stays a `<button disabled>`: there is no\n     * disabled state for an anchor, and dropping the `href` to fake one leaves a\n     * link that announces itself as actionable and is not.\n     */\n    href?: string;\n}\n\n/**\n * A section heading. Every item after it belongs to the section, until the next\n * section or separator.\n */\nexport interface SidebarSection {\n    type: \"section\";\n    key: string;\n    label: ReactNode;\n}\n\n/** A plain divider, for splitting the list without naming the parts. */\nexport interface SidebarSeparator {\n    type: \"separator\";\n    key: string;\n}\n\n/**\n * One entry of the navigation list.\n *\n * An entry with no `type` is an item, which is what keeps a plain\n * `SidebarItem[]` a valid `SidebarEntry[]`: adding sections to this component\n * needed no change at any existing call site.\n */\nexport type SidebarEntry = ({ type?: \"item\" } & SidebarItem) | SidebarSection | SidebarSeparator;\n\nexport interface SidebarProps extends Omit<HTMLAttributes<HTMLElement>, \"onChange\"> {\n    /** Top slot — typically the logo + brand. */\n    header?: ReactNode;\n    /** Navigation entries. An entry with no `type` is an item. */\n    items: SidebarEntry[];\n    /** Active item key. */\n    value?: string;\n    /** Fires when an item is clicked. Receives the item's `key`. */\n    onChange?: (key: string) => void;\n    /** Bottom slot — typically settings/profile/logout. */\n    footer?: ReactNode;\n    /** Collapsed mode — only icons visible. Default `false`. */\n    collapsed?: boolean;\n    /** Width when expanded, in pixels or any CSS length. Default `240px`. */\n    width?: number | string;\n    /** Width when collapsed, in pixels or any CSS length. Default `64px`. */\n    collapsedWidth?: number | string;\n}\n\n/** A run of items, optionally under a section heading. */\ninterface ItemBlock {\n    kind: \"items\";\n    key: string;\n    section?: SidebarSection;\n    items: SidebarItem[];\n}\n\n/** A standalone divider between blocks. */\ninterface SeparatorBlock {\n    kind: \"separator\";\n    key: string;\n}\n\ntype Block = ItemBlock | SeparatorBlock;\n\n/**\n * Fold the flat entry list into the blocks that get rendered.\n *\n * A section opens a block that swallows every following item; a separator closes\n * whatever is open, so items after it are loose again. Items before the first\n * section are loose too — which is the whole existing behaviour, and why a list\n * with no sections comes out of here as one unnamed block.\n *\n * @param entries - The `items` prop, as given.\n * @returns Blocks in render order.\n */\nfunction toBlocks(entries: readonly SidebarEntry[]): Block[] {\n    const blocks: Block[] = [];\n    let open: ItemBlock | undefined;\n\n    for (const entry of entries) {\n        if (entry.type === \"separator\") {\n            blocks.push({ kind: \"separator\", key: entry.key });\n            open = undefined;\n            continue;\n        }\n        if (entry.type === \"section\") {\n            open = { kind: \"items\", key: entry.key, section: entry, items: [] };\n            blocks.push(open);\n            continue;\n        }\n        if (!open) {\n            open = { kind: \"items\", key: `loose-${entry.key}`, items: [] };\n            blocks.push(open);\n        }\n        open.items.push(entry);\n    }\n    return blocks;\n}\n\n/**\n * Desktop sidebar navigation. Pair with `<Show above=\"md\">` and a `Drawer`\n * for mobile.\n *\n * Sixteen screens in one flat list is a wall, so `items` also takes section\n * headings and separators. A section renders as a labelled `role=\"group\"`, which\n * is what tells a screen reader \"Monitoring, group, 3 items\" — the reason it is\n * not a styled `disabled` item, which would announce an unavailable button and\n * stay in the navigation order.\n *\n * @example\n * const [tab, setTab] = useState(\"home\");\n * <Show above=\"md\">\n *     <Sidebar\n *         header={<Brand />}\n *         items={[{ key: \"home\", label: \"Home\", icon: <Home /> }]}\n *         value={tab}\n *         onChange={setTab}\n *     />\n * </Show>\n *\n * @example\n * <Sidebar\n *     items={[\n *         { type: \"section\", key: \"monitoring\", label: \"Monitoring\" },\n *         { key: \"overview\", label: \"Overview\", href: \"/overview\" },\n *         { key: \"activity\", label: \"Activity\", href: \"/activity\" },\n *         { type: \"section\", key: \"admin\", label: \"Administration\" },\n *         { key: \"settings\", label: \"Settings\", href: \"/settings\" },\n *     ]}\n *     value={tab}\n *     onChange={setTab}\n * />\n */\nexport function Sidebar({\n    header,\n    items,\n    value,\n    onChange,\n    footer,\n    collapsed = false,\n    width = 240,\n    collapsedWidth = 64,\n    className,\n    style,\n    ...props\n}: SidebarProps) {\n    const baseId = useId();\n    const blocks = toBlocks(items);\n    const finalWidth =\n        typeof (collapsed ? collapsedWidth : width) === \"number\"\n            ? `${collapsed ? collapsedWidth : width}px`\n            : collapsed\n              ? collapsedWidth\n              : width;\n\n    /**\n     * Render one navigation entry.\n     *\n     * @param item - The entry to render.\n     * @returns The button, or the anchor when the entry carries an `href`.\n     */\n    const renderItem = (item: SidebarItem): ReactNode => {\n        const active = item.key === value;\n        const title = collapsed && typeof item.label === \"string\" ? item.label : undefined;\n        const body = (\n            <>\n                {item.icon && <span className={styles.icon}>{item.icon}</span>}\n                {!collapsed && <span className={styles.label}>{item.label}</span>}\n                {!collapsed && item.badge !== undefined && (\n                    <span className={styles.badge}>{item.badge}</span>\n                )}\n            </>\n        );\n\n        if (item.href && !item.disabled) {\n            return (\n                <a\n                    key={item.key}\n                    href={item.href}\n                    className={cn(styles.item, active && styles.active)}\n                    aria-current={active ? \"page\" : undefined}\n                    onClick={() => onChange?.(item.key)}\n                    title={title}\n                >\n                    {body}\n                </a>\n            );\n        }\n\n        return (\n            <button\n                key={item.key}\n                type=\"button\"\n                className={cn(styles.item, active && styles.active)}\n                aria-current={active ? \"page\" : undefined}\n                disabled={item.disabled}\n                onClick={() => onChange?.(item.key)}\n                title={title}\n            >\n                {body}\n            </button>\n        );\n    };\n\n    return (\n        <aside\n            className={cn(styles.sidebar, collapsed && styles.collapsed, className)}\n            style={{ width: finalWidth, ...style }}\n            {...props}\n        >\n            {header && <div className={styles.header}>{header}</div>}\n            <nav className={styles.nav} aria-label=\"Navegação lateral\">\n                {blocks.map((block) => {\n                    if (block.kind === \"separator\") {\n                        return <hr key={block.key} className={styles.separator} />;\n                    }\n                    if (!block.section) {\n                        return (\n                            <div key={block.key} className={styles.group}>\n                                {block.items.map(renderItem)}\n                            </div>\n                        );\n                    }\n                    const labelId = `${baseId}-${block.key}`;\n                    return (\n                        <div\n                            key={block.key}\n                            role=\"group\"\n                            aria-labelledby={labelId}\n                            className={styles.group}\n                        >\n                            <div\n                                id={labelId}\n                                role=\"presentation\"\n                                className={cn(styles.section, collapsed && styles.sectionCollapsed)}\n                            >\n                                {block.section.label}\n                            </div>\n                            {block.items.map(renderItem)}\n                        </div>\n                    );\n                })}\n            </nav>\n            {footer && <div className={styles.footer}>{footer}</div>}\n        </aside>\n    );\n}\n"],"mappings":"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"}