@sincpro/mobile-ui 3.0.1 → 3.1.0

package/dist/utils/criteria.js

@@ -1,99 +1,80 @@
 export function parseCriteriaDate(value) {
-    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value))
-        return null;
-    const date = new Date(`${value}T00:00:00Z`);
-    if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value)
-        return null;
-    return new Date(`${value}T12:00:00`);
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const date = new Date(`${value}T00:00:00Z`);
+  if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value) return null;
+  return new Date(`${value}T12:00:00`);
 }
 export function criteriaAt(root, path) {
-    let node = root;
-    for (const index of path) {
-        if (node.kind !== "group" || !node.children[index])
-            throw new Error("Invalid criteria path");
-        node = node.children[index];
-    }
-    return node;
+  let node = root;
+  for (const index of path) {
+    if (node.kind !== "group" || !node.children[index]) throw new Error("Invalid criteria path");
+    node = node.children[index];
+  }
+  return node;
 }
 export function replaceCriteria(root, path, replacement) {
-    if (path.length === 0) {
-        if (replacement?.kind !== "group")
-            throw new Error("Criteria root must remain a group");
-        return replacement;
-    }
-    const [index, ...rest] = path;
-    const child = root.children[index];
-    if (!child)
-        throw new Error("Invalid criteria path");
-    if (rest.length && child.kind !== "group")
-        throw new Error("Invalid criteria path");
-    const next = rest.length && child.kind === "group"
-        ? replaceCriteria(child, rest, replacement)
-        : replacement;
-    return {
-        ...root,
-        children: root.children.flatMap((item, position) => position !== index ? [item] : next ? [next] : []),
-    };
+  if (path.length === 0) {
+    if (replacement?.kind !== "group") throw new Error("Criteria root must remain a group");
+    return replacement;
+  }
+  const [index, ...rest] = path;
+  const child = root.children[index];
+  if (!child) throw new Error("Invalid criteria path");
+  if (rest.length && child.kind !== "group") throw new Error("Invalid criteria path");
+  const next = rest.length && child.kind === "group" ? replaceCriteria(child, rest, replacement) : replacement;
+  return {
+    ...root,
+    children: root.children.flatMap((item, position) => position !== index ? [item] : next ? [next] : [])
+  };
 }
 export function describeCriteria(node, fields) {
-    if (node.kind === "group") {
-        if (!node.children.length)
-            return "Sin condiciones";
-        const join = { all: "Todas", any: "Cualquiera", none: "Ninguna" }[node.join];
-        return `${join}: (${node.children.map((child) => describeCriteria(child, fields)).join("; ")})`;
-    }
-    const field = fields.find((item) => item.id === node.field);
-    const operator = field?.operators.find((item) => item.id === node.operator);
-    const values = node.values.map((value) => field?.options?.find((option) => option.value === value)?.label ?? String(value));
-    return `${field?.label ?? node.field} ${operator?.label ?? node.operator}${values.length ? ` ${values.join(" — ")}` : ""}`;
+  if (node.kind === "group") {
+    if (!node.children.length) return "Sin condiciones";
+    const join = {
+      all: "Todas",
+      any: "Cualquiera",
+      none: "Ninguna"
+    }[node.join];
+    return `${join}: (${node.children.map(child => describeCriteria(child, fields)).join("; ")})`;
+  }
+  const field = fields.find(item => item.id === node.field);
+  const operator = field?.operators.find(item => item.id === node.operator);
+  const values = node.values.map(value => field?.options?.find(option => option.value === value)?.label ?? String(value));
+  return `${field?.label ?? node.field} ${operator?.label ?? node.operator}${values.length ? ` ${values.join(" — ")}` : ""}`;
 }
 export function validateCondition(condition, fields) {
-    const field = fields.find((item) => item.id === condition.field);
-    if (!field)
-        return "El campo ya no está disponible.";
-    const operator = field.operators.find((item) => item.id === condition.operator);
-    if (!operator)
-        return "El operador no está disponible para este campo.";
-    const count = { none: 0, one: 1, range: 2 }[operator.arity];
-    if (condition.values.length !== count)
-        return "Completa los valores de la condición.";
-    for (const value of condition.values) {
-        if (field.type === "number" && (typeof value !== "number" || !Number.isFinite(value)))
-            return "Introduce un número válido.";
-        if (field.type === "text" && (typeof value !== "string" || !value.trim()))
-            return "Introduce un texto.";
-        if (field.type === "date" && !parseCriteriaDate(value))
-            return "Introduce una fecha válida (AAAA-MM-DD).";
-        if (field.type === "choice" && !field.options?.some((option) => option.value === value))
-            return "Selecciona un valor disponible.";
-    }
-    if (operator.arity === "range" &&
-        field.type === "number" &&
-        Number(condition.values[0]) > Number(condition.values[1]))
-        return "El inicio no puede superar el final.";
-    if (operator.arity === "range" &&
-        field.type === "date" &&
-        String(condition.values[0]) > String(condition.values[1]))
-        return "El inicio no puede superar el final.";
-    return undefined;
+  const field = fields.find(item => item.id === condition.field);
+  if (!field) return "El campo ya no está disponible.";
+  const operator = field.operators.find(item => item.id === condition.operator);
+  if (!operator) return "El operador no está disponible para este campo.";
+  const count = {
+    none: 0,
+    one: 1,
+    range: 2
+  }[operator.arity];
+  if (condition.values.length !== count) return "Completa los valores de la condición.";
+  for (const value of condition.values) {
+    if (field.type === "number" && (typeof value !== "number" || !Number.isFinite(value))) return "Introduce un número válido.";
+    if (field.type === "text" && (typeof value !== "string" || !value.trim())) return "Introduce un texto.";
+    if (field.type === "date" && !parseCriteriaDate(value)) return "Introduce una fecha válida (AAAA-MM-DD).";
+    if (field.type === "choice" && !field.options?.some(option => option.value === value)) return "Selecciona un valor disponible.";
+  }
+  if (operator.arity === "range" && field.type === "number" && Number(condition.values[0]) > Number(condition.values[1])) return "El inicio no puede superar el final.";
+  if (operator.arity === "range" && field.type === "date" && String(condition.values[0]) > String(condition.values[1])) return "El inicio no puede superar el final.";
+  return undefined;
 }
 export function validateCriteria(group, fields) {
-    for (const child of group.children) {
-        if (child.kind === "group" && !child.children.length)
-            return "Completa o elimina el grupo vacío.";
-        const error = child.kind === "group"
-            ? validateCriteria(child, fields)
-            : validateCondition(child, fields);
-        if (error)
-            return error;
-    }
-    return undefined;
+  for (const child of group.children) {
+    if (child.kind === "group" && !child.children.length) return "Completa o elimina el grupo vacío.";
+    const error = child.kind === "group" ? validateCriteria(child, fields) : validateCondition(child, fields);
+    if (error) return error;
+  }
+  return undefined;
 }
 export function moveCollectionEntry(items, index, direction) {
-    const target = index + direction;
-    if (index < 0 || index >= items.length || target < 0 || target >= items.length)
-        throw new Error("Invalid collection reorder");
-    const next = [...items];
-    [next[index], next[target]] = [next[target], next[index]];
-    return next;
+  const target = index + direction;
+  if (index < 0 || index >= items.length || target < 0 || target >= items.length) throw new Error("Invalid collection reorder");
+  const next = [...items];
+  [next[index], next[target]] = [next[target], next[index]];
+  return next;
 }

package/dist/utils/date.d.ts

@@ -2,14 +2,20 @@ interface FormatDateOptions {
     locale?: string | null;
     showTime?: boolean;
 }
+/**
+ * Reads ISO strings, SQLite `YYYY-MM-DD HH:mm:ss` and Date instances as one instant.
+ * A timestamp without a zone is UTC. A date-only value is UTC midnight.
+ */
+export declare function parseInstant(input: string | Date): Date | null;
 /**
  * Formats a date in the given timezone, respecting the granularity of the input.
  *
  * Detection rules:
  * 1. If `input` is a 'YYYY-MM-DD' string (date only) => interpreted as midnight (00:00:00)
  *    in the target timezone and ONLY the date part is returned (no time).
- * 2. If `input` includes a time component (full ISO or Date) => converted to the target timezone
- *    and shown as date + time (HH:MM) unless overridden via `options.showTime`.
+ * 2. If `input` includes a time component (ISO, `YYYY-MM-DD HH:mm:ss`, or Date) => that
+ *    instant is formatted in the target timezone as date + time (HH:MM) unless overridden
+ *    via `options.showTime`. A value without a zone is read as UTC.
  * 3. When `options.showTime` is `true` or `false` it overrides the auto-detection.
  * 4. If `timezone` is null/undefined or invalid, the string "Error de formateo" is returned.
  *

package/dist/utils/date.js

@@ -1,3 +1,4 @@
+import { dateTimeFormat } from "./intl.js";
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone";
 import utc from "dayjs/plugin/utc";
@@ -6,14 +7,31 @@ const DEFAULT_TIMEZONE = "America/Costa_Rica";
 const DEFAULT_LOCALE = "es-CR";
 dayjs.extend(utc);
 dayjs.extend(timezone);
+/**
+ * Reads ISO strings, SQLite `YYYY-MM-DD HH:mm:ss` and Date instances as one instant.
+ * A timestamp without a zone is UTC. A date-only value is UTC midnight.
+ */
+export function parseInstant(input) {
+  if (input instanceof Date) {
+    return Number.isNaN(input.getTime()) ? null : input;
+  }
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const withT = trimmed.replace(/^(\d{4}-\d{2}-\d{2}) /, "$1T");
+  const zoned = /(?:Z|[+-]\d{2}:?\d{2})$/.test(withT);
+  const parsed = new Date(zoned || !withT.includes("T") ? withT : `${withT}Z`);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
 /**
  * Formats a date in the given timezone, respecting the granularity of the input.
  *
  * Detection rules:
  * 1. If `input` is a 'YYYY-MM-DD' string (date only) => interpreted as midnight (00:00:00)
  *    in the target timezone and ONLY the date part is returned (no time).
- * 2. If `input` includes a time component (full ISO or Date) => converted to the target timezone
- *    and shown as date + time (HH:MM) unless overridden via `options.showTime`.
+ * 2. If `input` includes a time component (ISO, `YYYY-MM-DD HH:mm:ss`, or Date) => that
+ *    instant is formatted in the target timezone as date + time (HH:MM) unless overridden
+ *    via `options.showTime`. A value without a zone is read as UTC.
  * 3. When `options.showTime` is `true` or `false` it overrides the auto-detection.
  * 4. If `timezone` is null/undefined or invalid, the string "Error de formateo" is returned.
  *
@@ -46,39 +64,34 @@ dayjs.extend(timezone);
  * @returns          Localized string, or "Error de formateo" if it can't be processed
  */
 export function formatDate(input, timezone, options) {
-    // Use the default timezone when none is provided
-    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
-    const fallbackLocale = DEFAULT_LOCALE.split("-")[0]; // "es" from "es-CR"
-    const deviceLocale = getLocales()?.[0]?.languageTag ?? fallbackLocale;
-    const usedLocale = options?.locale ?? deviceLocale;
-    try {
-        const rawStr = typeof input === "string" ? input : input.toISOString();
-        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(rawStr);
-        // Auto-detect showTime when not passed explicitly
-        const effectiveShowTime = options?.showTime !== undefined
-            ? options.showTime
-            : !isDateOnly && /T\d{2}:\d{2}/.test(rawStr); // has a time component
-        const dateInstance = isDateOnly
-            ? dayjs.tz(`${rawStr}T00:00:00`, effectiveTimezone)
-            : dayjs.utc(rawStr).tz(effectiveTimezone);
-        const dateInZone = dateInstance.toDate();
-        const formatOptions = {
-            year: "numeric",
-            month: "long",
-            day: "numeric",
-            timeZone: effectiveTimezone,
-        };
-        if (effectiveShowTime) {
-            formatOptions.hour = "2-digit";
-            formatOptions.minute = "2-digit";
-        }
-        return new Intl.DateTimeFormat(usedLocale, formatOptions).format(dateInZone);
-    }
-    catch (error) {
-        console.warn("Error formatting date:", error);
-        return "Error de formateo";
+  // Use the default timezone when none is provided
+  const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+  const fallbackLocale = DEFAULT_LOCALE.split("-")[0]; // "es" from "es-CR"
+  const deviceLocale = getLocales()?.[0]?.languageTag ?? fallbackLocale;
+  const usedLocale = options?.locale ?? deviceLocale;
+  const raw = typeof input === "string" ? input.trim() : input.toISOString();
+  const normalized = raw.replace(/^(\d{4}-\d{2}-\d{2}) /, "$1T");
+  const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(normalized);
+  const effectiveShowTime = options?.showTime !== undefined ? options.showTime : !isDateOnly && /T\d{2}:\d{2}/.test(normalized);
+  try {
+    const date = isDateOnly ? dayjs.tz(`${normalized}T00:00:00`, effectiveTimezone).toDate() : parseInstant(input);
+    if (!date || Number.isNaN(date.getTime())) return "Error de formateo";
+    const formatOptions = {
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+      timeZone: effectiveTimezone
+    };
+    if (effectiveShowTime) {
+      formatOptions.hour = "2-digit";
+      formatOptions.minute = "2-digit";
     }
+    return dateTimeFormat(usedLocale, formatOptions).format(date);
+  } catch {
+    return "Error de formateo";
+  }
 }
+
 /**
  * Formats a date using the default timezone automatically (Costa Rica).
  * Useful when the user's timezone isn't available.
@@ -88,8 +101,9 @@ export function formatDate(input, timezone, options) {
  * @returns          Localized string in the Costa Rica timezone
  */
 export function formatDateWithDefaultTimezone(input, options) {
-    return formatDate(input, DEFAULT_TIMEZONE, options);
+  return formatDate(input, DEFAULT_TIMEZONE, options);
 }
+
 /**
  * Returns the current date as YYYY-MM-DD in the given timezone.
  * Useful to build scheduling dates that respect the user's timezone.
@@ -98,15 +112,15 @@ export function formatDateWithDefaultTimezone(input, options) {
  * @returns Current date as YYYY-MM-DD in the given timezone
  */
 export function getCurrentDateInTimezone(timezone) {
-    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
-    try {
-        return dayjs().tz(effectiveTimezone).format("YYYY-MM-DD");
-    }
-    catch (error) {
-        console.warn("Error getting current date in timezone:", error);
-        return dayjs().format("YYYY-MM-DD"); // Fallback to local
-    }
+  const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+  try {
+    return dayjs().tz(effectiveTimezone).format("YYYY-MM-DD");
+  } catch (error) {
+    console.warn("Error getting current date in timezone:", error);
+    return dayjs().format("YYYY-MM-DD"); // Fallback to local
+  }
 }
+
 /**
  * Returns the current date-time as an ISO string in the given timezone.
  * Useful for timestamps that need to reflect the user's timezone.
@@ -115,12 +129,11 @@ export function getCurrentDateInTimezone(timezone) {
  * @returns Current date-time as an ISO string in the given timezone
  */
 export function getCurrentDateTimeInTimezone(timezone) {
-    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
-    try {
-        return dayjs().tz(effectiveTimezone).toISOString();
-    }
-    catch (error) {
-        console.warn("Error getting current date-time in timezone:", error);
-        return dayjs().toISOString(); // Fallback to local
-    }
+  const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+  try {
+    return dayjs().tz(effectiveTimezone).toISOString();
+  } catch (error) {
+    console.warn("Error getting current date-time in timezone:", error);
+    return dayjs().toISOString(); // Fallback to local
+  }
 }

package/dist/utils/image.js

@@ -1,13 +1,13 @@
 const sharedSourceKeys = new WeakMap();
 let nextSharedSourceKey = 0;
 export function imageSourceKey(source) {
-    if (source && typeof source === "object" && "nativeRefType" in source) {
-        let key = sharedSourceKeys.get(source);
-        if (key === undefined) {
-            key = nextSharedSourceKey++;
-            sharedSourceKeys.set(source, key);
-        }
-        return `shared-image-${key}`;
+  if (source && typeof source === "object" && "nativeRefType" in source) {
+    let key = sharedSourceKeys.get(source);
+    if (key === undefined) {
+      key = nextSharedSourceKey++;
+      sharedSourceKeys.set(source, key);
     }
-    return JSON.stringify(source);
+    return `shared-image-${key}`;
+  }
+  return JSON.stringify(source);
 }

package/dist/utils/intl.d.ts

@@ -0,0 +1 @@
+export declare function dateTimeFormat(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;

package/dist/utils/intl.js

@@ -0,0 +1,13 @@
+// Building an Intl formatter resolves locale and time-zone data, which is the slow
+// part; format() on an existing one is cheap. Lists format the same few shapes
+// over and over, so formatters are shared per locale and options.
+const dateFormats = new Map();
+export function dateTimeFormat(locale, options) {
+  const key = `${locale ?? ""}|${JSON.stringify(options)}`;
+  let format = dateFormats.get(key);
+  if (!format) {
+    format = new Intl.DateTimeFormat(locale, options);
+    dateFormats.set(key, format);
+  }
+  return format;
+}

package/dist/utils/keys.js

@@ -1,7 +1,5 @@
 export function uniqueKeys(items, keyExtractor, component) {
-    const keys = items.map(keyExtractor);
-    if (keys.some((key) => typeof key !== "string" || !key.trim()) ||
-        new Set(keys).size !== keys.length)
-        throw new Error(`${component} requires unique, non-empty string keys.`);
-    return keys;
+  const keys = items.map(keyExtractor);
+  if (keys.some(key => typeof key !== "string" || !key.trim()) || new Set(keys).size !== keys.length) throw new Error(`${component} requires unique, non-empty string keys.`);
+  return keys;
 }

package/dist/utils/monetary.d.ts

@@ -1,3 +1,4 @@
 export declare function parseToMonetaryNumber(input?: string | number | null): number;
+/** `1234.5` → `"1.234,50"`. Rounds half-up in decimal (Big), not in binary floating point. */
 export declare function formatTwoDecimals(value?: number | string | null): string;
 export declare function calculateDiscountedTotal(total: number, discount: number): number;

package/dist/utils/monetary.js

@@ -1,31 +1,35 @@
 import { Big } from "big.js";
 export function parseToMonetaryNumber(input) {
-    if (input == null)
-        return 0;
-    const s = String(input).trim();
-    if (!/[0-9]/.test(s))
-        return 0;
-    const cleaned = s.replace(/[^0-9.-]+/g, "");
-    try {
-        return Number(new Big(cleaned).toString());
-    }
-    catch {
-        return 0;
-    }
+  if (input == null) return 0;
+  // A finite number is already a number: skip the string round trip, which also
+  // misread exponent forms (1e21 → "121").
+  if (typeof input === "number") return Number.isFinite(input) ? input : 0;
+  const s = String(input).trim();
+  if (!/[0-9]/.test(s)) return 0;
+  const cleaned = s.replace(/[^0-9.-]+/g, "");
+  try {
+    return Number(new Big(cleaned).toString());
+  } catch {
+    return 0;
+  }
 }
+
+// Building an Intl formatter is the expensive part (locale data lookup); format()
+// is cheap. One shared instance for every amount the app renders.
+const TWO_DECIMALS = new Intl.NumberFormat("de-DE", {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+
+/** `1234.5` → `"1.234,50"`. Rounds half-up in decimal (Big), not in binary floating point. */
 export function formatTwoDecimals(value) {
-    const raw = parseToMonetaryNumber(value);
-    const rounded = new Big(raw).toFixed(2);
-    const num = Number(rounded);
-    return new Intl.NumberFormat("de-DE", {
-        minimumFractionDigits: 2,
-        maximumFractionDigits: 2,
-    }).format(num);
+  const rounded = new Big(parseToMonetaryNumber(value)).toFixed(2);
+  return TWO_DECIMALS.format(Number(rounded));
 }
 export function calculateDiscountedTotal(total, discount) {
-    if (discount === 0) {
-        return 0;
-    }
-    const result = (parseToMonetaryNumber(total) * discount) / 100;
-    return parseToMonetaryNumber(result);
+  if (discount === 0) {
+    return 0;
+  }
+  const result = parseToMonetaryNumber(total) * discount / 100;
+  return parseToMonetaryNumber(result);
 }

package/dist/utils/progress.js

@@ -1,5 +1,4 @@
 export function normalizeProgress(value) {
-    if (!Number.isFinite(value))
-        throw new RangeError("Progress value must be a finite number");
-    return Math.max(0, Math.min(1, value));
+  if (!Number.isFinite(value)) throw new RangeError("Progress value must be a finite number");
+  return Math.max(0, Math.min(1, value));
 }

package/dist/utils/quantity.js

@@ -1,44 +1,43 @@
 import { Big } from "big.js";
+
 /** Redondea a la precisión indicada usando round half up */
 export function roundTo(value, precision) {
-    if (isNaN(value))
-        return 0;
-    const factor = new Big(10).pow(precision);
-    return Number(new Big(value).times(factor).round(0, 1).div(factor).toString());
+  if (isNaN(value)) return 0;
+  const factor = new Big(10).pow(precision);
+  return Number(new Big(value).times(factor).round(0, 1).div(factor).toString());
 }
+
 /** Normaliza la cantidad al múltiplo más cercano del incremento mínimo */
 export function normalizeQuantity(value, minIncrement, precision) {
-    if (!isFinite(value))
-        return 0;
-    if (value < 0)
-        value = 0;
-    if (minIncrement <= 0)
-        return roundTo(value, precision);
-    const steps = Math.round(value / minIncrement);
-    const normalized = steps * minIncrement;
-    return roundTo(normalized, precision);
+  if (!isFinite(value)) return 0;
+  if (value < 0) value = 0;
+  if (minIncrement <= 0) return roundTo(value, precision);
+  const steps = Math.round(value / minIncrement);
+  const normalized = steps * minIncrement;
+  return roundTo(normalized, precision);
 }
+
 /** Convierte un valor a entero escalado según precisión para cálculos seguros */
 export function toScaledInt(value, precision) {
-    if (!isFinite(value))
-        return 0;
-    const factor = Math.pow(10, precision);
-    return Math.round(value * factor);
+  if (!isFinite(value)) return 0;
+  const factor = Math.pow(10, precision);
+  return Math.round(value * factor);
 }
 export function fromScaledInt(scaled, precision) {
-    const factor = Math.pow(10, precision);
-    return scaled / factor;
+  const factor = Math.pow(10, precision);
+  return scaled / factor;
 }
+
 /** Multiplicación segura evitando errores binarios típicos */
 export function safeMul(a, b, precision) {
-    const factor = Math.pow(10, precision);
-    return (Math.round(a * factor) * Math.round(b * factor)) / (factor * factor);
+  const factor = Math.pow(10, precision);
+  return Math.round(a * factor) * Math.round(b * factor) / (factor * factor);
 }
+
 /** Valida si un valor es múltiplo del incremento mínimo dentro de la precisión */
 export function isMultipleOfIncrement(value, minIncrement, precision) {
-    if (minIncrement <= 0)
-        return true;
-    const scaledValue = toScaledInt(value, precision + 3); // extra precisión para reducir error
-    const scaledInc = toScaledInt(minIncrement, precision + 3);
-    return scaledValue % scaledInc === 0;
+  if (minIncrement <= 0) return true;
+  const scaledValue = toScaledInt(value, precision + 3); // extra precisión para reducir error
+  const scaledInc = toScaledInt(minIncrement, precision + 3);
+  return scaledValue % scaledInc === 0;
 }

package/dist/utils/reorder.js

@@ -1,29 +1,20 @@
 import { uniqueKeys } from "./keys.js";
 export function reorderKeys(items, keyExtractor) {
-    return uniqueKeys(items, keyExtractor, "ReorderableList");
+  return uniqueKeys(items, keyExtractor, "ReorderableList");
 }
 export function sameOrder(left, right) {
-    return left.length === right.length && left.every((key, index) => key === right[index]);
+  return left.length === right.length && left.every((key, index) => key === right[index]);
 }
 export function moveReorderItem(items, fromIndex, toIndex) {
-    if (!Number.isInteger(fromIndex) ||
-        !Number.isInteger(toIndex) ||
-        fromIndex < 0 ||
-        fromIndex >= items.length ||
-        toIndex < 0 ||
-        toIndex >= items.length)
-        throw new Error("ReorderableList received an invalid move.");
-    const next = [...items];
-    const [item] = next.splice(fromIndex, 1);
-    next.splice(toIndex, 0, item);
-    return next;
+  if (!Number.isInteger(fromIndex) || !Number.isInteger(toIndex) || fromIndex < 0 || fromIndex >= items.length || toIndex < 0 || toIndex >= items.length) throw new Error("ReorderableList received an invalid move.");
+  const next = [...items];
+  const [item] = next.splice(fromIndex, 1);
+  next.splice(toIndex, 0, item);
+  return next;
 }
 export function applyReorder(items, keyExtractor, order) {
-    const keys = reorderKeys(items, keyExtractor);
-    const indices = new Map(keys.map((key, index) => [key, index]));
-    if (order.length !== keys.length ||
-        new Set(order).size !== order.length ||
-        order.some((key) => !indices.has(key)))
-        throw new Error("ReorderableList received an order that does not match the current items.");
-    return order.map((key) => items[indices.get(key)]);
+  const keys = reorderKeys(items, keyExtractor);
+  const indices = new Map(keys.map((key, index) => [key, index]));
+  if (order.length !== keys.length || new Set(order).size !== order.length || order.some(key => !indices.has(key))) throw new Error("ReorderableList received an order that does not match the current items.");
+  return order.map(key => items[indices.get(key)]);
 }

package/dist/utils/search.d.ts

@@ -0,0 +1,4 @@
+/** Lowercase, no accents, single spaces: "  Páez  Núñez " -> "paez nunez". */
+export declare function searchKey(text: string): string;
+/** True when every word of the query appears in some field, ignoring accents and case. */
+export declare function matchesSearch(query: string, ...fields: (string | null | undefined)[]): boolean;

package/dist/utils/search.js

@@ -0,0 +1,12 @@
+/** Lowercase, no accents, single spaces: "  Páez  Núñez " -> "paez nunez". */
+export function searchKey(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+/** True when every word of the query appears in some field, ignoring accents and case. */
+export function matchesSearch(query, ...fields) {
+  const words = searchKey(query).split(" ").filter(Boolean);
+  if (!words.length) return true;
+  const haystack = searchKey(fields.filter(Boolean).join(" "));
+  return words.every(word => haystack.includes(word));
+}