@sincpro/web-ui 0.0.0-stage → 0.1.0

package/dist/components/search/criteria.js

@@ -0,0 +1,159 @@
+/** Las instancias de agrupado, en orden. Van SIEMPRE a la izquierda y no se
+ *  cruzan con nada: el orden ES la jerarquía. */
+export function groupsOf(all) {
+    return all.filter((one) => one.kind === "group");
+}
+/** Las de filtro, que son las que se anidan. */
+export function filtersOf(all) {
+    return all.filter((one) => one.kind !== "group");
+}
+/** La instancia que hay en esa ruta, si hay alguna. */
+export function at(all, path) {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return undefined;
+    const here = all[head];
+    if (here === undefined)
+        return undefined;
+    if (rest.length === 0)
+        return here;
+    return here.kind === "join" ? at(here.of, rest) : undefined;
+}
+/** El mismo árbol con una instancia cambiada. Devolver uno nuevo y no tocar el
+ *  viejo es lo que deja comparar antes y después —y deshacer. */
+export function replaceAt(all, path, next) {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return [...all];
+    return all.map((one, index) => {
+        if (index !== head)
+            return one;
+        if (rest.length === 0)
+            return next;
+        return one.kind === "join" ? { ...one, of: replaceAt(one.of, rest, next) } : one;
+    });
+}
+/**
+ * El mismo árbol sin esa instancia.
+ *
+ * Un nodo que se queda con un solo hijo se DESARMA: «cualquiera de: (a)» es un
+ * paréntesis alrededor de nada, y dejarlo obliga a leer un grupo que no agrupa.
+ */
+export function removeAt(all, path) {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return [...all];
+    if (rest.length === 0)
+        return all.filter((_, index) => index !== head);
+    return all.flatMap((one, index) => {
+        if (index !== head || one.kind !== "join")
+            return [one];
+        const inside = removeAt(one.of, rest);
+        if (inside.length === 0)
+            return [];
+        if (inside.length === 1 && one.join !== "not")
+            return inside;
+        return [{ ...one, of: inside }];
+    });
+}
+/** Cómo se juntan los de un nodo: `all` → `any` → `not` y vuelta a empezar. Es
+ *  la misma rueda que el selector muestra abierta, para quien prefiera el
+ *  atajo. */
+export function nextJoin(join) {
+    return join === "all" ? "any" : join === "any" ? "not" : "all";
+}
+/** Un id que no choca con otro. Corto, porque se lee en el DOM. */
+export function criteriaId(prefix) {
+    return `${prefix}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/** Una instancia de agrupado, a partir de un nivel ya legible. */
+export function groupCriteria(level, label) {
+    return { id: criteriaId("g"), kind: "group", label, level };
+}
+/** Una instancia de filtro. `label` es lo único que distingue a uno declarado en
+ *  código de uno escrito en la barra; sin `where`, es uno que sólo contesta
+ *  quien lo declaró. */
+export function filterCriteria(where, label, id) {
+    return {
+        id: id ?? criteriaId("f"),
+        kind: "filter",
+        label,
+        ...(where === undefined ? {} : { where }),
+    };
+}
+/**
+ * Lo que VIAJA: el `where` del motor, armado con las instancias de filtro.
+ *
+ * Es lo único que sale de acá hacia afuera, y sale sin rótulos, sin ids y sin
+ * clases: la UI se queda con lo que la UI necesita.
+ */
+export function whereOf(all) {
+    const parts = filtersOf(all)
+        .map(expressionOf)
+        .filter((one) => one !== undefined);
+    if (parts.length === 0)
+        return undefined;
+    if (parts.length === 1)
+        return parts[0];
+    return { all: parts };
+}
+function expressionOf(one) {
+    if (one.kind === "group")
+        return undefined;
+    /* Una instancia sin `where` no viaja: no hay manera de preguntarla, y mandar
+       algo parecido sería contestar otra cosa. La contesta quien la declaró. */
+    if (one.kind === "filter")
+        return one.where;
+    const inside = one.of
+        .map(expressionOf)
+        .filter((each) => each !== undefined);
+    if (inside.length === 0)
+        return undefined;
+    if (one.join === "not") {
+        const only = inside.length === 1 ? inside[0] : { any: inside };
+        return { negate: only };
+    }
+    if (inside.length === 1)
+        return inside[0];
+    return one.join === "all" ? { all: inside } : { any: inside };
+}
+/** Los niveles que viajan, en orden. */
+export function levelsOf(all) {
+    return groupsOf(all).flatMap((one) => (one.kind === "group" ? [one.level] : []));
+}
+/* ---------------------------------------------------------------- *
+ *  Las dos operaciones que todo consumidor necesita
+ * ---------------------------------------------------------------- */
+/**
+ * Los niveles de agrupado, puestos al día.
+ *
+ * Reemplaza TODAS las instancias de grupo por las que salen de `levels`, y no
+ * toca ninguna de filtro. Existe porque el control de niveles es una lista
+ * ordenada que se edita entera —se agrega, se saca, se mueve— y reconciliarla
+ * instancia por instancia desde afuera es el mismo bucle escrito en cada
+ * pantalla.
+ *
+ * Los de grupo quedan ADELANTE, que es donde se dibujan.
+ */
+export function withLevels(all, levels, labelOf) {
+    return [...levels.map((level) => groupCriteria(level, labelOf(level))), ...filtersOf(all)];
+}
+/**
+ * Un filtro CON NOMBRE, puesto o sacado.
+ *
+ * Es lo único que hace un filtro declarado en código: traer su rótulo y su
+ * condición ya pensadas. Tildarlo lo agrega, destildarlo lo saca, y se reconoce
+ * por su `id` — el mismo que declaró quien lo escribió, así que sobrevive a
+ * guardarlo como favorito y volver a leerlo.
+ */
+export function toggleNamed(all, named) {
+    const at = all.findIndex((one) => one.id === named.id);
+    if (at >= 0)
+        return all.filter((_, index) => index !== at);
+    return [...all, filterCriteria(named.where, named.label, named.id)];
+}
+/** Si ese filtro con nombre está puesto. Lo usa el panel para dibujar la marca:
+ *  la marca sale de lo PUESTO y no de un estado aparte que podría discrepar. */
+export function hasNamed(all, id) {
+    return all.some((one) => one.id === id);
+}

package/dist/components/search/datePeriods.d.ts

@@ -0,0 +1,122 @@
+/**
+ * EL FILTRO DE FECHA, como lo hace Odoo: meses, trimestres y años que se
+ * combinan.
+ *
+ *     Fecha de orden
+ *       ─ septiembre        ← los tres meses más recientes, por nombre
+ *       ─ agosto
+ *       ─ julio
+ *       ────────────
+ *       ─ Q1  Q2  Q3  Q4    ← los cuatro trimestres
+ *       ────────────
+ *       ─ 2026  2025  2024  ← los tres años más recientes
+ *
+ * ── Por qué se combinan y no se eligen ──────────────────────────────
+ *
+ * Porque así se contestan las preguntas que la gente tiene. «Septiembre» y
+ * «agosto» juntos son los dos meses: opciones del MISMO renglón se suman con O.
+ * Pero «septiembre» y «2025» no es «septiembre o 2025», es **septiembre de
+ * 2025**: renglones distintos se cruzan con Y. Un selector de un solo período no
+ * puede decir ninguna de las dos.
+ *
+ * Sin ningún año tildado, los meses y trimestres son los del año en curso — que
+ * es lo que alguien quiere decir cuando tilda «septiembre» y nada más.
+ *
+ * ── Lo que se guarda es la INTENCIÓN ────────────────────────────────
+ *
+ * «Los últimos tres meses» guardado en septiembre tiene que contestar otra cosa
+ * en diciembre. Por eso lo que viaja es `month:9`, no `2026-09-01`, y el
+ * intervalo se calcula cada vez que se lee. Un favorito con fechas absolutas
+ * miente desde el día siguiente.
+ */
+/** Un período tildado. El año es aparte y por eso no está acá: es el otro eje. */
+export type DatePeriod = {
+    kind: "month";
+    month: number;
+} | {
+    kind: "quarter";
+    quarter: 1 | 2 | 3 | 4;
+} | {
+    kind: "year";
+    year: number;
+};
+/** Un intervalo SEMIABIERTO `[from, to)`. El final queda AFUERA, y no es un
+ *  detalle: con un `between` inclusivo, una fila guardada a las 00:00:00 del
+ *  primero del mes siguiente cae en dos períodos contiguos y se cuenta dos
+ *  veces. */
+export type DateRange = {
+    from: Date;
+    to: Date;
+};
+export declare function periodId(period: DatePeriod): string;
+export declare function readPeriodId(id: string): DatePeriod | null;
+/** Los tres meses más recientes, del actual hacia atrás. Cada uno con el año al
+ *  que pertenece, porque en enero los tres anteriores son de dos años. */
+export declare function recentMonths(now?: Date, howMany?: number): {
+    month: number;
+    year: number;
+}[];
+/** Los años más recientes, del actual hacia atrás. */
+export declare function recentYears(now?: Date, howMany?: number): number[];
+/**
+ * Las opciones que se ofrecen, en tres renglones y en este orden: meses,
+ * trimestres, años. Es el orden de Odoo y el de la pregunta — de lo fino a lo
+ * grueso, porque «este mes» se pide mucho más seguido que «2024».
+ */
+export declare function datePeriodOptions(now?: Date, 
+/** Cómo se llama un mes. Sin esto, como lo llama el calendario del sistema en
+ *  el idioma activo — una lista de doce meses escrita a mano es una lista que
+ *  hay que volver a escribir para el idioma siguiente. */
+monthName?: (month: number) => string): {
+    months: {
+        id: string;
+        label: string;
+    }[];
+    quarters: {
+        id: string;
+        label: string;
+    }[];
+    years: {
+        id: string;
+        label: string;
+    }[];
+};
+/**
+ * Los intervalos que un juego de períodos tildados representa.
+ *
+ * Devuelve VARIOS y no uno: «septiembre y julio» son dos tramos con un agujero
+ * en el medio, y aplastarlos en un solo `[julio, octubre)` metería agosto, que
+ * nadie pidió. Quien los use los cruza con O.
+ *
+ * La regla es la de Odoo: los años multiplican, los meses y trimestres recortan.
+ * Sin años tildados se usa el año en curso; sin meses ni trimestres, el año
+ * entero.
+ */
+export declare function resolvePeriods(periods: readonly DatePeriod[], now?: Date): DateRange[];
+/**
+ * El recorte de una fecha como GRUPO del panel de filtros: plegable, con su
+ * nombre, y los tres renglones separados por una línea.
+ *
+ * Es una función y no un componente porque los filtros del panel son datos —el
+ * panel dibuja, el dominio declara—, y así una fecha no necesita una ranura
+ * aparte ni un camino propio adentro de `SearchBar`.
+ */
+export declare function datePeriodGroup(options: {
+    /** Cómo se llama el campo: «Fecha de pedido». */
+    label: string;
+    /** Los ids tildados, de `periodId`. */
+    active: readonly string[];
+    now?: Date;
+    /** Cómo se llama un mes, cuando el producto lo dice con otras palabras. Sin
+     *  esto, como lo llama el calendario del sistema en el idioma activo. */
+    monthName?: (month: number) => string;
+}): {
+    label: string;
+    collapsible: true;
+    options: {
+        id: string;
+        label: string;
+        checked: boolean;
+        divider?: boolean;
+    }[];
+};

package/dist/components/search/datePeriods.js

@@ -0,0 +1,134 @@
+import { monthName as calendarMonthName } from "../../foundations/calendar.js";
+import { currentCopy, fillCopy } from "../../foundations/copy.js";
+export function periodId(period) {
+    if (period.kind === "month")
+        return `month:${period.month}`;
+    if (period.kind === "quarter")
+        return `quarter:${period.quarter}`;
+    return `year:${period.year}`;
+}
+export function readPeriodId(id) {
+    const [kind, raw] = id.split(":");
+    const value = Number(raw);
+    if (!Number.isInteger(value))
+        return null;
+    if (kind === "month")
+        return value >= 1 && value <= 12 ? { kind: "month", month: value } : null;
+    if (kind === "quarter") {
+        return value >= 1 && value <= 4
+            ? { kind: "quarter", quarter: value }
+            : null;
+    }
+    if (kind === "year")
+        return { kind: "year", year: value };
+    return null;
+}
+/** Los tres meses más recientes, del actual hacia atrás. Cada uno con el año al
+ *  que pertenece, porque en enero los tres anteriores son de dos años. */
+export function recentMonths(now = new Date(), howMany = 3) {
+    const out = [];
+    for (let back = 0; back < howMany; back += 1) {
+        const when = new Date(now.getFullYear(), now.getMonth() - back, 1);
+        out.push({ month: when.getMonth() + 1, year: when.getFullYear() });
+    }
+    return out;
+}
+/** Los años más recientes, del actual hacia atrás. */
+export function recentYears(now = new Date(), howMany = 3) {
+    return Array.from({ length: howMany }, (_, back) => now.getFullYear() - back);
+}
+const QUARTERS = [1, 2, 3, 4];
+/**
+ * Las opciones que se ofrecen, en tres renglones y en este orden: meses,
+ * trimestres, años. Es el orden de Odoo y el de la pregunta — de lo fino a lo
+ * grueso, porque «este mes» se pide mucho más seguido que «2024».
+ */
+export function datePeriodOptions(now = new Date(), 
+/** Cómo se llama un mes. Sin esto, como lo llama el calendario del sistema en
+ *  el idioma activo — una lista de doce meses escrita a mano es una lista que
+ *  hay que volver a escribir para el idioma siguiente. */
+monthName = calendarMonthName) {
+    return {
+        months: recentMonths(now).map(({ month }) => ({
+            id: periodId({ kind: "month", month }),
+            label: monthName(month),
+        })),
+        quarters: QUARTERS.map((quarter) => ({
+            id: periodId({ kind: "quarter", quarter }),
+            label: fillCopy(currentCopy().calendar.quarter, { n: quarter }),
+        })),
+        years: recentYears(now).map((year) => ({
+            id: periodId({ kind: "year", year }),
+            label: String(year),
+        })),
+    };
+}
+/** Un mes de un año, como intervalo semiabierto. */
+function monthRange(year, month) {
+    return { from: new Date(year, month - 1, 1), to: new Date(year, month, 1) };
+}
+function quarterRange(year, quarter) {
+    const first = (quarter - 1) * 3;
+    return { from: new Date(year, first, 1), to: new Date(year, first + 3, 1) };
+}
+function yearRange(year) {
+    return { from: new Date(year, 0, 1), to: new Date(year + 1, 0, 1) };
+}
+/**
+ * Los intervalos que un juego de períodos tildados representa.
+ *
+ * Devuelve VARIOS y no uno: «septiembre y julio» son dos tramos con un agujero
+ * en el medio, y aplastarlos en un solo `[julio, octubre)` metería agosto, que
+ * nadie pidió. Quien los use los cruza con O.
+ *
+ * La regla es la de Odoo: los años multiplican, los meses y trimestres recortan.
+ * Sin años tildados se usa el año en curso; sin meses ni trimestres, el año
+ * entero.
+ */
+export function resolvePeriods(periods, now = new Date()) {
+    if (periods.length === 0)
+        return [];
+    const years = periods.filter((one) => one.kind === "year").map((one) => one.year);
+    const months = periods.filter((one) => one.kind === "month").map((one) => one.month);
+    const quarters = periods.filter((one) => one.kind === "quarter").map((one) => one.quarter);
+    /* Sin año tildado, el año en curso. Es lo que alguien quiere decir cuando
+       tilda «septiembre» y nada más — y no «todos los septiembres de la
+       historia», que además nadie sabría escribir. */
+    const overYears = years.length > 0 ? years : [now.getFullYear()];
+    if (months.length === 0 && quarters.length === 0) {
+        return overYears.map(yearRange);
+    }
+    return overYears.flatMap((year) => [
+        ...months.map((month) => monthRange(year, month)),
+        ...quarters.map((quarter) => quarterRange(year, quarter)),
+    ]);
+}
+/**
+ * El recorte de una fecha como GRUPO del panel de filtros: plegable, con su
+ * nombre, y los tres renglones separados por una línea.
+ *
+ * Es una función y no un componente porque los filtros del panel son datos —el
+ * panel dibuja, el dominio declara—, y así una fecha no necesita una ranura
+ * aparte ni un camino propio adentro de `SearchBar`.
+ */
+export function datePeriodGroup(options) {
+    /* Se REENVÍA lo que llegó, sin default propio: con `?? String` acá, el panel
+       de filtros dibujaba «9 · 8 · 7» en vez de «Septiembre · Agosto · Julio»
+       —este `String` pisaba el default del calendario— y nadie veía por qué. Un
+       default repetido en dos lugares es un default que dice dos cosas. */
+    const { months, quarters, years } = datePeriodOptions(options.now ?? new Date(), options.monthName);
+    const mark = (one, divider) => ({
+        ...one,
+        checked: options.active.includes(one.id),
+        ...(divider === true ? { divider: true } : {}),
+    });
+    return {
+        label: options.label,
+        collapsible: true,
+        options: [
+            ...months.map((one) => mark(one)),
+            ...quarters.map((one, index) => mark(one, index === 0)),
+            ...years.map((one, index) => mark(one, index === 0)),
+        ],
+    };
+}

package/dist/components/search/dateRanges.d.ts

@@ -0,0 +1,54 @@
+import type { GroupGrain } from "../../foundations/grouping.js";
+/**
+ * LOS RECORTES DE FECHA, en RELATIVO.
+ *
+ * Context: un filtro de fecha escrito en absoluto —«desde el 2026-06-01»— es una
+ * respuesta que envejece. Alguien guarda «los últimos tres meses» como favorito
+ * en septiembre y en diciembre le sigue mostrando junio, julio y agosto: el
+ * filtro dice lo que dijo, no lo que quiso decir. Lo que hay que guardar es la
+ * INTENCIÓN —«los últimos 3 meses»— y resolverla cada vez que se lee.
+ *
+ * **Y por eso lo resuelve la UI.** No hace falta preguntarle a nadie cuándo
+ * empieza el trimestre pasado: es aritmética de calendario sobre el reloj del
+ * que mira. Mandar al servidor «relativo: últimos 3 meses» y que él decida
+ * agrega un viaje y una segunda definición de «mes» — y la del servidor está en
+ * su huso, no en el de la persona.
+ *
+ * Lo que sale de acá es un intervalo SEMIABIERTO `[desde, hasta)`. El final
+ * queda AFUERA, y no es un detalle: con un `between` inclusivo, una fila guardada
+ * a las 00:00:00 del primero del mes siguiente cae en los dos recortes, y dos
+ * filtros contiguos devuelven la misma fila.
+ */
+export type DateRange = {
+    /** Desde, inclusive. */
+    from: Date;
+    /** Hasta, EXCLUSIVE. */
+    to: Date;
+};
+/**
+ * Un recorte relativo, tal como se guarda: una unidad y cuántas.
+ *
+ * `last` cuenta hacia atrás desde ahora incluyendo el período en curso; `prior`
+ * cuenta los períodos COMPLETOS anteriores, sin el que está corriendo. Son
+ * distintos y la diferencia importa el día 2 del mes: «este mes» tiene un día y
+ * «el mes pasado» tiene treinta.
+ */
+export type RelativeRange = {
+    unit: GroupGrain | "quarter";
+    count: number;
+    mode: "last" | "prior";
+};
+/** El id con el que viaja un recorte relativo, para guardarlo y reconocerlo. */
+export declare function rangeId(range: RelativeRange): string;
+export declare function readRangeId(id: string): RelativeRange | null;
+/**
+ * Resuelve un recorte relativo contra un reloj.
+ *
+ * `now` se pasa y no se lee de adentro: una función que mira el reloj no se
+ * puede probar, y la que la prueba tendría que congelar el tiempo global.
+ */
+export declare function resolveRange(range: RelativeRange, now?: Date): DateRange;
+/** Los recortes que vale la pena ofrecer, en el orden en que se leen. Es una
+ *  sugerencia con nombre y no una lista cerrada: un consumidor arma la suya con
+ *  `rangeId` si su dominio mira el tiempo de otra manera. */
+export declare const COMMON_RANGES: readonly RelativeRange[];

package/dist/components/search/dateRanges.js

@@ -0,0 +1,89 @@
+/** El id con el que viaja un recorte relativo, para guardarlo y reconocerlo. */
+export function rangeId(range) {
+    return `${range.mode}:${range.count}:${range.unit}`;
+}
+export function readRangeId(id) {
+    const [mode, count, unit] = id.split(":");
+    if (mode !== "last" && mode !== "prior")
+        return null;
+    const howMany = Number(count);
+    if (!Number.isInteger(howMany) || howMany < 1)
+        return null;
+    if (unit !== "day" &&
+        unit !== "week" &&
+        unit !== "month" &&
+        unit !== "quarter" &&
+        unit !== "year") {
+        return null;
+    }
+    return { mode, count: howMany, unit };
+}
+/** El arranque del período que contiene a `when`. Es donde empieza «este mes»,
+ *  «esta semana», «este trimestre». */
+function startOf(unit, when) {
+    const year = when.getFullYear();
+    const month = when.getMonth();
+    if (unit === "year")
+        return new Date(year, 0, 1);
+    if (unit === "quarter")
+        return new Date(year, Math.floor(month / 3) * 3, 1);
+    if (unit === "month")
+        return new Date(year, month, 1);
+    if (unit === "week") {
+        /* La semana arranca el LUNES, que es ISO y es lo que el motor usa para
+           recortar por semana. Con domingo, dos capas partirían el mismo dato en
+           semanas distintas y los conteos no cerrarían. */
+        const day = new Date(year, month, when.getDate());
+        const weekday = (day.getDay() + 6) % 7;
+        day.setDate(day.getDate() - weekday);
+        return day;
+    }
+    return new Date(year, month, when.getDate());
+}
+/** Corre `count` períodos desde `from`. Negativo va para atrás. */
+function shift(unit, from, count) {
+    const out = new Date(from);
+    if (unit === "year")
+        out.setFullYear(out.getFullYear() + count);
+    else if (unit === "quarter")
+        out.setMonth(out.getMonth() + count * 3);
+    else if (unit === "month")
+        out.setMonth(out.getMonth() + count);
+    else if (unit === "week")
+        out.setDate(out.getDate() + count * 7);
+    else
+        out.setDate(out.getDate() + count);
+    return out;
+}
+/**
+ * Resuelve un recorte relativo contra un reloj.
+ *
+ * `now` se pasa y no se lee de adentro: una función que mira el reloj no se
+ * puede probar, y la que la prueba tendría que congelar el tiempo global.
+ */
+export function resolveRange(range, now = new Date()) {
+    const current = startOf(range.unit, now);
+    if (range.mode === "last") {
+        /* «Los últimos 3 meses» INCLUYE el que corre: termina al final del actual.
+           Que termine «ahora» dejaría afuera lo que se guarde en el resto del día, y
+           un filtro que esconde lo que acabás de crear se lee como un error. */
+        return {
+            from: shift(range.unit, current, -(range.count - 1)),
+            to: shift(range.unit, current, 1),
+        };
+    }
+    return { from: shift(range.unit, current, -range.count), to: current };
+}
+/** Los recortes que vale la pena ofrecer, en el orden en que se leen. Es una
+ *  sugerencia con nombre y no una lista cerrada: un consumidor arma la suya con
+ *  `rangeId` si su dominio mira el tiempo de otra manera. */
+export const COMMON_RANGES = [
+    { mode: "last", count: 7, unit: "day" },
+    { mode: "last", count: 30, unit: "day" },
+    { mode: "last", count: 3, unit: "month" },
+    { mode: "prior", count: 1, unit: "month" },
+    { mode: "last", count: 1, unit: "quarter" },
+    { mode: "prior", count: 1, unit: "quarter" },
+    { mode: "last", count: 1, unit: "year" },
+    { mode: "last", count: 3, unit: "year" },
+];

package/dist/components/search/index.d.ts

@@ -0,0 +1,9 @@
+export { type BuiltCriteria, type BuiltLevel, type BuiltSort, CriteriaBuilder, } from "./CriteriaBuilder.js";
+export { blankGroup, type BuiltCondition, type BuiltFilter, describeFilter, FilterBuilder, type TreeCondition, treeFromFilter, type TreeGroup, type TreeNode, treeToFilter, } from "./FilterBuilder.js";
+export { formatJson, JsonEditor } from "./JsonEditor.js";
+export { SearchBar, type SearchBarProps, type SearchFacet, } from "./SearchBar.js";
+export { at, criteriaId, type CriteriaJoin, type CriteriaPath, filterCriteria, filtersOf, type GroupCriteria, groupCriteria, groupsOf, hasNamed, levelsOf, nextJoin, removeAt, replaceAt, type SearchCriteria, toggleNamed, whereOf, withLevels, } from "./criteria.js";
+export { CriteriaChips, type CriteriaChipsProps, } from "./CriteriaChips.js";
+export { type FieldDefinition, fieldLabel, filterableNames, isFilterable, type ModelDefinition, type ModelTranslations, } from "./model.js";
+export { answers, defaultOp, describeCondition, globToLike, opLabel, type QueryDraft, type QueryField, queryFields, type QueryKind, type QuerySuggestion, readTyped, suggest, type TypedValue, valueFor, type ValueShape, withoutValue, } from "./query.js";
+export { type DatePeriod, datePeriodGroup, datePeriodOptions, type DateRange, periodId, readPeriodId, recentMonths, recentYears, resolvePeriods, } from "./datePeriods.js";

package/dist/components/search/index.js

@@ -0,0 +1,20 @@
+/* Buscar con facetas, con los recortes metidos adentro del campo. */
+export { CriteriaBuilder, } from "./CriteriaBuilder.js";
+export { blankGroup, describeFilter, FilterBuilder, treeFromFilter, treeToFilter, } from "./FilterBuilder.js";
+export { formatJson, JsonEditor } from "./JsonEditor.js";
+export { SearchBar, } from "./SearchBar.js";
+/* LO QUE LA BARRA TIENE PUESTO: instancias. Una sola cosa para las dos clases
+   —grupo y filtro—, con sus metadatos de UI afuera y el objeto del motor
+   adentro, intacto. */
+export { at, criteriaId, filterCriteria, filtersOf, groupCriteria, groupsOf, hasNamed, levelsOf, nextJoin, removeAt, replaceAt, toggleNamed, whereOf, withLevels, } from "./criteria.js";
+export { CriteriaChips, } from "./CriteriaChips.js";
+/* EL VOCABULARIO DEL MODELO — lo que el servidor publica sobre sus campos. Lo
+   hablan el constructor de filtros, el de criterias y la barra de búsqueda, así
+   que vive aparte de los tres. */
+export { fieldLabel, filterableNames, isFilterable, } from "./model.js";
+/* LA GRAMÁTICA DE LA BARRA: qué se puede preguntar sobre un modelo, y con qué.
+   Tres pasos —campo, operador, valor— que se pueden escribir en uno. */
+export { answers, defaultOp, describeCondition, globToLike, opLabel, queryFields, readTyped, suggest, valueFor, withoutValue, } from "./query.js";
+/* El recorte de fecha, como lo hace Odoo: meses, trimestres y años que se
+   combinan. Se guarda la INTENCIÓN y se resuelve al leer. */
+export { datePeriodGroup, datePeriodOptions, periodId, readPeriodId, recentMonths, recentYears, resolvePeriods, } from "./datePeriods.js";

package/dist/components/search/model.d.ts

@@ -0,0 +1,54 @@
+/** Un campo, tal como lo describe el modelo. Espeja `FieldMeta` del servidor.
+ *
+ *  `ops` vacío es la señal de que este campo no se filtra, ordena ni agrupa directo: la
+ *  publican tanto un valor-objeto (`embedded`) como cualquiera de los tres relacionales
+ *  (`many2one`/`one2many`/`many2many`) — ninguno tiene una comparación propia. Un relacional
+ *  se filtra por la columna que lo identifica (`identifiedBy`), que aparece como SU PROPIO
+ *  campo escalar en el modelo. */
+export interface FieldDefinition {
+    type: string;
+    nullable: boolean;
+    sortable: boolean;
+    ops: readonly string[];
+    /** La respuesta gruesa a «qué es este nombre»: un valor en la fila, un valor-objeto adentro
+     *  (JSON, sin identidad propia) u otro agregado que hay que traer. */
+    kind?: "scalar" | "embedded" | "relation";
+    /** Varios de ellos: un `one2many`, un `many2many`, o una lista de valores-objeto. */
+    many?: boolean;
+    /** Para un campo relacional, el agregado del otro lado, por nombre. */
+    relation?: string | null;
+    /** Para un campo relacional, la columna que lo identifica — nunca se ofrece el campo
+     *  relacional en sí como blanco de un filtro, un orden o un nivel de agrupado. */
+    identifiedBy?: string | null;
+    /** Los valores que un campo de enum puede tomar — de ahí sale un `<select>`. */
+    choices?: readonly unknown[];
+}
+/** Si este campo se puede usar en un `where`, un `order` o un `grouping.by` directamente.
+ *  `ops.length === 0` alcanza como señal: la publican tanto `embedded` como los tres
+ *  relacionales, así que no hace falta mirar `kind` aparte. */
+export declare function isFilterable(field: FieldDefinition): boolean;
+/** La definición del modelo que manda el servidor bajo `model_meta_data`. */
+/** Cada palabra que una pantalla necesita para el modelo o un campo suyo: siempre
+ *  `{"default": …, …idiomas}`. Espeja `Translated` del servidor. */
+export interface ModelTranslations {
+    name: Record<string, string>;
+    labels: Record<string, Record<string, string>>;
+    help?: Record<string, Record<string, string>>;
+}
+export interface ModelDefinition {
+    aggregate: string;
+    identity: string;
+    fields: Record<string, FieldDefinition>;
+    /** Ausente en un modelo armado a mano —el `having` sintético de `CriteriaBuilder`, por
+     *  ejemplo—; presente en cualquier `model_meta_data` real. */
+    translations?: ModelTranslations;
+}
+/** El rótulo de un campo en el idioma pedido: el que el modelo publicó para ese idioma, o el
+ *  que publicó como `default`, o el nombre del campo tal cual si el modelo no dijo nada —un
+ *  modelo sintético, o uno que todavía no llegó. Nunca inventa una palabra: lo que no está en
+ *  `translations` se ve tal cual sale de la tabla, y eso ya avisa que falta declararlo. */
+export declare function fieldLabel(model: ModelDefinition, field: string, locale: string): string;
+/** Los nombres del modelo que se pueden usar como blanco de un filtro, un orden o un nivel de
+ *  agrupado — nunca un relacional ni un valor-objeto, filtrados por `isFilterable`. Ordenados,
+ *  porque es la lista que arma cada `<select>` de este archivo. */
+export declare function filterableNames(model: ModelDefinition): string[];