@sia-ui/utils 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+export { AsyncState, AsyncStatus, DebounceOptions, Debounced, RetryOptions, ToAsyncStateInput, createRetry, debounce, sleep, throttle, toAsyncState } from './async.cjs';
+export { ClassValue, cn, toneClass } from './classname.cjs';
+export { canCopy, copyText, readText } from './clipboard.cjs';
+export { SortDirection, averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy } from './collection.cjs';
+export { CurrencyFormatOptions, ParseCurrencyOptions, formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency } from './currency.cjs';
+export { DateFormatOptions, DateValue, TimeAgoOptions, addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate } from './date.cjs';
+export { composeEventHandlers } from './events.cjs';
+export { FileKind, FormatBytesOptions, baseName, downloadBlob, downloadText, exceedsSize, extension, fileKind, formatBytes, isImage, matchesAccept, readAsDataUrl, readAsText } from './file.cjs';
+export { DEFAULT_LOCALE, ListFormatOptions, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale } from './locale.cjs';
+export { NumberFormatOptions, clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber } from './number.cjs';
+export { DeepPartial, deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath } from './object.cjs';
+export { QueryParamsInput, QueryValue, ToQueryStringOptions, fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString } from './query.cjs';
+export { capitalize, initials, isBlank, maskMiddle, normalizeIdentifier, normalizeSpaces, slugify, titleCase, truncate } from './string.cjs';

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { AsyncState, AsyncStatus, DebounceOptions, Debounced, RetryOptions, ToAsyncStateInput, createRetry, debounce, sleep, throttle, toAsyncState } from './async.js';
+export { ClassValue, cn, toneClass } from './classname.js';
+export { canCopy, copyText, readText } from './clipboard.js';
+export { SortDirection, averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy } from './collection.js';
+export { CurrencyFormatOptions, ParseCurrencyOptions, formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency } from './currency.js';
+export { DateFormatOptions, DateValue, TimeAgoOptions, addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate } from './date.js';
+export { composeEventHandlers } from './events.js';
+export { FileKind, FormatBytesOptions, baseName, downloadBlob, downloadText, exceedsSize, extension, fileKind, formatBytes, isImage, matchesAccept, readAsDataUrl, readAsText } from './file.js';
+export { DEFAULT_LOCALE, ListFormatOptions, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale } from './locale.js';
+export { NumberFormatOptions, clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber } from './number.js';
+export { DeepPartial, deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath } from './object.js';
+export { QueryParamsInput, QueryValue, ToQueryStringOptions, fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString } from './query.js';
+export { capitalize, initials, isBlank, maskMiddle, normalizeIdentifier, normalizeSpaces, slugify, titleCase, truncate } from './string.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+export { baseName, downloadBlob, downloadText, exceedsSize, extension, fileKind, formatBytes, isImage, matchesAccept, readAsDataUrl, readAsText } from './chunk-ETJDEEF5.js';
+export { DEFAULT_LOCALE, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale } from './chunk-6P4YWHCJ.js';
+export { clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber } from './chunk-63IWZEOC.js';
+export { deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath } from './chunk-QMPHN3LG.js';
+export { fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString } from './chunk-DY6WSWXH.js';
+export { capitalize, initials, isBlank, maskMiddle, normalizeIdentifier, normalizeSpaces, slugify, titleCase, truncate } from './chunk-PTNHOSWH.js';
+export { createRetry, debounce, sleep, throttle, toAsyncState } from './chunk-DKWI2AZG.js';
+export { cn, toneClass } from './chunk-BMNZVRFN.js';
+export { canCopy, copyText, readText } from './chunk-RIFUQ7JM.js';
+export { averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy } from './chunk-L4BLBOLO.js';
+export { formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency } from './chunk-FX7K6FKW.js';
+export { addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate } from './chunk-JHYMIU2G.js';
+export { composeEventHandlers } from './chunk-YU5NRSDP.js';

package/dist/locale.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+// src/locale.ts
+var DEFAULT_LOCALE = "fr-FR";
+function resolveLocale(preferred) {
+  if (preferred) return preferred;
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return DEFAULT_LOCALE;
+}
+function languageOf(locale = DEFAULT_LOCALE) {
+  return locale.split("-")[0] ?? locale;
+}
+function regionOf(locale = DEFAULT_LOCALE) {
+  return locale.split("-")[1];
+}
+var collators = /* @__PURE__ */ new Map();
+function collator(locale = DEFAULT_LOCALE) {
+  let found = collators.get(locale);
+  if (!found) {
+    found = new Intl.Collator(locale, { sensitivity: "base", numeric: true });
+    collators.set(locale, found);
+  }
+  return found;
+}
+function compareStrings(a, b, locale = DEFAULT_LOCALE) {
+  return collator(locale).compare(a, b);
+}
+function looseIncludes(text, needle, locale = DEFAULT_LOCALE) {
+  if (!needle) return true;
+  const strip = (value) => value.toLocaleLowerCase(locale).normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  return strip(text).includes(strip(needle));
+}
+function formatList(items, options = {}) {
+  const { locale = DEFAULT_LOCALE, type = "conjunction" } = options;
+  if (items.length === 0) return "";
+  return new Intl.ListFormat(locale, { style: "long", type }).format(items);
+}
+function plural(count, singular, pluralForm) {
+  return Math.abs(count) < 2 ? singular : pluralForm ?? `${singular}s`;
+}
+function countLabel(count, singular, options = {}) {
+  const { pluralForm, zero, locale = DEFAULT_LOCALE } = options;
+  if (count === 0 && zero) return zero;
+  return `${count.toLocaleString(locale)} ${plural(count, singular, pluralForm)}`;
+}
+
+exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+exports.collator = collator;
+exports.compareStrings = compareStrings;
+exports.countLabel = countLabel;
+exports.formatList = formatList;
+exports.languageOf = languageOf;
+exports.looseIncludes = looseIncludes;
+exports.plural = plural;
+exports.regionOf = regionOf;
+exports.resolveLocale = resolveLocale;

package/dist/locale.d.cts

@@ -0,0 +1,51 @@
+/**
+ * Langue et région.
+ *
+ * Le dépôt écrit `"fr-FR"` en dur à une douzaine d'endroits. Ce module donne
+ * le seul défaut, et la façon d'en changer.
+ */
+declare const DEFAULT_LOCALE = "fr-FR";
+/**
+ * La locale à utiliser.
+ *
+ * Ordre : ce qui est demandé, puis la préférence du navigateur, puis le
+ * français. La préférence du navigateur n'est lue qu'à défaut — une
+ * application de gestion camerounaise ne doit pas passer en anglais parce que
+ * le poste est configuré ainsi.
+ */
+declare function resolveLocale(preferred?: string | null): string;
+/** La langue seule : `fr` pour `fr-FR`. */
+declare function languageOf(locale?: string): string;
+/** La région seule : `FR` pour `fr-FR`, `undefined` pour `fr`. */
+declare function regionOf(locale?: string): string | undefined;
+/** Comparateur de chaînes localisé, réutilisé d'un appel à l'autre. */
+declare function collator(locale?: string): Intl.Collator;
+/** Compare deux chaînes : « Émile » se range avant « Zoé ». */
+declare function compareStrings(a: string, b: string, locale?: string): number;
+/**
+ * Vrai si le texte contient la recherche, accents et casse ignorés.
+ *
+ * C'est ce qu'attend quiconque tape « cote » pour trouver « Côte d'Ivoire ».
+ */
+declare function looseIncludes(text: string, needle: string, locale?: string): boolean;
+interface ListFormatOptions {
+    locale?: string;
+    type?: "conjunction" | "disjunction";
+}
+/** « Douala, Yaoundé et Bafoussam ». */
+declare function formatList(items: readonly string[], options?: ListFormatOptions): string;
+/**
+ * Accorde un mot avec un nombre.
+ *
+ * Règle française, pas anglaise : le singulier couvre `0` et `1`, le pluriel
+ * commence à `2`. « 0 facture » et non « 0 factures ».
+ */
+declare function plural(count: number, singular: string, pluralForm?: string): string;
+/** « 1 facture », « 3 factures », « aucune facture ». */
+declare function countLabel(count: number, singular: string, options?: {
+    pluralForm?: string;
+    zero?: string;
+    locale?: string;
+}): string;
+
+export { DEFAULT_LOCALE, type ListFormatOptions, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale };

package/dist/locale.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Langue et région.
+ *
+ * Le dépôt écrit `"fr-FR"` en dur à une douzaine d'endroits. Ce module donne
+ * le seul défaut, et la façon d'en changer.
+ */
+declare const DEFAULT_LOCALE = "fr-FR";
+/**
+ * La locale à utiliser.
+ *
+ * Ordre : ce qui est demandé, puis la préférence du navigateur, puis le
+ * français. La préférence du navigateur n'est lue qu'à défaut — une
+ * application de gestion camerounaise ne doit pas passer en anglais parce que
+ * le poste est configuré ainsi.
+ */
+declare function resolveLocale(preferred?: string | null): string;
+/** La langue seule : `fr` pour `fr-FR`. */
+declare function languageOf(locale?: string): string;
+/** La région seule : `FR` pour `fr-FR`, `undefined` pour `fr`. */
+declare function regionOf(locale?: string): string | undefined;
+/** Comparateur de chaînes localisé, réutilisé d'un appel à l'autre. */
+declare function collator(locale?: string): Intl.Collator;
+/** Compare deux chaînes : « Émile » se range avant « Zoé ». */
+declare function compareStrings(a: string, b: string, locale?: string): number;
+/**
+ * Vrai si le texte contient la recherche, accents et casse ignorés.
+ *
+ * C'est ce qu'attend quiconque tape « cote » pour trouver « Côte d'Ivoire ».
+ */
+declare function looseIncludes(text: string, needle: string, locale?: string): boolean;
+interface ListFormatOptions {
+    locale?: string;
+    type?: "conjunction" | "disjunction";
+}
+/** « Douala, Yaoundé et Bafoussam ». */
+declare function formatList(items: readonly string[], options?: ListFormatOptions): string;
+/**
+ * Accorde un mot avec un nombre.
+ *
+ * Règle française, pas anglaise : le singulier couvre `0` et `1`, le pluriel
+ * commence à `2`. « 0 facture » et non « 0 factures ».
+ */
+declare function plural(count: number, singular: string, pluralForm?: string): string;
+/** « 1 facture », « 3 factures », « aucune facture ». */
+declare function countLabel(count: number, singular: string, options?: {
+    pluralForm?: string;
+    zero?: string;
+    locale?: string;
+}): string;
+
+export { DEFAULT_LOCALE, type ListFormatOptions, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale };

package/dist/locale.js

@@ -0,0 +1 @@
+export { DEFAULT_LOCALE, collator, compareStrings, countLabel, formatList, languageOf, looseIncludes, plural, regionOf, resolveLocale } from './chunk-6P4YWHCJ.js';

package/dist/number.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+// src/number.ts
+function formatter(locale, options) {
+  return new Intl.NumberFormat(locale, options);
+}
+function formatNumber(value, options = {}) {
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatter(locale, { maximumFractionDigits: 2, ...formatOptions }).format(value);
+}
+function formatPercent(value, options = {}) {
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatter(locale, {
+    style: "percent",
+    maximumFractionDigits: 2,
+    ...formatOptions
+  }).format(value);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function round(value, digits = 0) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+function parseDecimal(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error("The provided numeric value is invalid.");
+  }
+  return parsed;
+}
+function roundCurrency(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function formatRate(value) {
+  return value.toFixed(4);
+}
+function safeDivide(a, b, fallback = 0) {
+  if (b === 0) return fallback;
+  const result = a / b;
+  return Number.isFinite(result) ? result : fallback;
+}
+
+exports.clamp = clamp;
+exports.formatNumber = formatNumber;
+exports.formatPercent = formatPercent;
+exports.formatRate = formatRate;
+exports.parseDecimal = parseDecimal;
+exports.round = round;
+exports.roundCurrency = roundCurrency;
+exports.safeDivide = safeDivide;
+exports.toNumber = toNumber;

package/dist/number.d.cts

@@ -0,0 +1,14 @@
+interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    locale?: string;
+}
+declare function formatNumber(value: number, options?: NumberFormatOptions): string;
+declare function formatPercent(value: number, options?: NumberFormatOptions): string;
+declare function clamp(value: number, min: number, max: number): number;
+declare function round(value: number, digits?: number): number;
+declare function toNumber(value: number | string | null | undefined, fallback?: number): number;
+declare function parseDecimal(value: string | number): number;
+declare function roundCurrency(value: number): number;
+declare function formatRate(value: number): string;
+declare function safeDivide(a: number, b: number, fallback?: number): number;
+
+export { type NumberFormatOptions, clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber };

package/dist/number.d.ts

@@ -0,0 +1,14 @@
+interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    locale?: string;
+}
+declare function formatNumber(value: number, options?: NumberFormatOptions): string;
+declare function formatPercent(value: number, options?: NumberFormatOptions): string;
+declare function clamp(value: number, min: number, max: number): number;
+declare function round(value: number, digits?: number): number;
+declare function toNumber(value: number | string | null | undefined, fallback?: number): number;
+declare function parseDecimal(value: string | number): number;
+declare function roundCurrency(value: number): number;
+declare function formatRate(value: number): string;
+declare function safeDivide(a: number, b: number, fallback?: number): number;
+
+export { type NumberFormatOptions, clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber };

package/dist/number.js

@@ -0,0 +1 @@
+export { clamp, formatNumber, formatPercent, formatRate, parseDecimal, round, roundCurrency, safeDivide, toNumber } from './chunk-63IWZEOC.js';

package/dist/object.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+// src/object.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function pick(source, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (key in source) out[key] = source[key];
+  }
+  return out;
+}
+function omit(source, keys) {
+  const out = { ...source };
+  for (const key of keys) delete out[key];
+  return out;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (isPlainObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) continue;
+    const current = out[key];
+    out[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+  }
+  return out;
+}
+function getPath(source, path, fallback) {
+  const segments = path.split(".").filter(Boolean);
+  let current = source;
+  for (const segment of segments) {
+    if (current === null || current === void 0) return fallback;
+    if (typeof current !== "object") return fallback;
+    current = current[segment];
+  }
+  return current ?? fallback;
+}
+function setPath(source, path, value) {
+  const segments = path.split(".").filter(Boolean);
+  if (segments.length === 0) return source;
+  const [head, ...rest] = segments;
+  const child = source[head];
+  return {
+    ...source,
+    [head]: rest.length === 0 ? value : setPath(isPlainObject(child) ? child : {}, rest.join("."), value)
+  };
+}
+function isEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => isEqual(item, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+    return keys.every((key) => key in b && isEqual(a[key], b[key]));
+  }
+  return false;
+}
+function diff(before, after) {
+  const out = {};
+  for (const [key, value] of Object.entries(after)) {
+    if (!isEqual(before[key], value)) out[key] = value;
+  }
+  return out;
+}
+
+exports.deepMerge = deepMerge;
+exports.diff = diff;
+exports.getPath = getPath;
+exports.isEmpty = isEmpty;
+exports.isEqual = isEqual;
+exports.omit = omit;
+exports.pick = pick;
+exports.setPath = setPath;

package/dist/object.d.cts

@@ -0,0 +1,48 @@
+/** Objets. */
+type Plain = Record<string, unknown>;
+/** Garde uniquement les clés demandées. */
+declare function pick<T extends object, K extends keyof T>(source: T, keys: readonly K[]): Pick<T, K>;
+/** Retire les clés demandées. */
+declare function omit<T extends object, K extends keyof T>(source: T, keys: readonly K[]): Omit<T, K>;
+/** Vrai pour `{}`, `[]`, `""`, `null`, `undefined`, une `Map` vide. */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Le correctif d'une fusion profonde.
+ *
+ * `Partial<T>` ne rend facultatif que le premier niveau : passer
+ * `{ nested: { y: 9 } }` exigerait alors de réécrire tout `nested`, ce qui
+ * annule l'intérêt de la fusion. Les types qui ne se fusionnent pas champ
+ * par champ — tableau, `Date`, `File`, `Map`, `Set` — sont laissés entiers.
+ */
+type DeepPartial<T> = T extends readonly unknown[] | Date | File | Blob | Map<unknown, unknown> | Set<unknown> ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Fusionne en profondeur, sans modifier les objets d'origine.
+ *
+ * Les tableaux sont **remplacés**, jamais concaténés : une liste d'options
+ * fusionnée se retrouverait sinon avec les valeurs par défaut collées aux
+ * nouvelles, ce que personne n'attend.
+ */
+declare function deepMerge<T extends Plain>(base: T, patch: DeepPartial<T>): T;
+/**
+ * Lit une valeur par son chemin : `get(client, "adresse.ville")`.
+ *
+ * Utile pour une colonne de tableau décrite par une chaîne, ou un message
+ * d'erreur du serveur dont le champ est `adresse.ville`.
+ */
+declare function getPath<T = unknown>(source: unknown, path: string, fallback?: T): T | undefined;
+/** Écrit une valeur par son chemin, en rendant une copie. */
+declare function setPath<T extends Plain>(source: T, path: string, value: unknown): T;
+/**
+ * Compare deux valeurs en profondeur.
+ *
+ * Volontairement limitée aux objets simples, tableaux, dates et primitives :
+ * c'est tout ce qu'on compare dans une interface, et une comparaison
+ * universelle coûte plus qu'elle ne rapporte.
+ */
+declare function isEqual(a: unknown, b: unknown): boolean;
+/** Ce qui a changé entre deux objets — pour un `PATCH` minimal. */
+declare function diff<T extends Plain>(before: T, after: T): Partial<T>;
+
+export { type DeepPartial, deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath };

package/dist/object.d.ts

@@ -0,0 +1,48 @@
+/** Objets. */
+type Plain = Record<string, unknown>;
+/** Garde uniquement les clés demandées. */
+declare function pick<T extends object, K extends keyof T>(source: T, keys: readonly K[]): Pick<T, K>;
+/** Retire les clés demandées. */
+declare function omit<T extends object, K extends keyof T>(source: T, keys: readonly K[]): Omit<T, K>;
+/** Vrai pour `{}`, `[]`, `""`, `null`, `undefined`, une `Map` vide. */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Le correctif d'une fusion profonde.
+ *
+ * `Partial<T>` ne rend facultatif que le premier niveau : passer
+ * `{ nested: { y: 9 } }` exigerait alors de réécrire tout `nested`, ce qui
+ * annule l'intérêt de la fusion. Les types qui ne se fusionnent pas champ
+ * par champ — tableau, `Date`, `File`, `Map`, `Set` — sont laissés entiers.
+ */
+type DeepPartial<T> = T extends readonly unknown[] | Date | File | Blob | Map<unknown, unknown> | Set<unknown> ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Fusionne en profondeur, sans modifier les objets d'origine.
+ *
+ * Les tableaux sont **remplacés**, jamais concaténés : une liste d'options
+ * fusionnée se retrouverait sinon avec les valeurs par défaut collées aux
+ * nouvelles, ce que personne n'attend.
+ */
+declare function deepMerge<T extends Plain>(base: T, patch: DeepPartial<T>): T;
+/**
+ * Lit une valeur par son chemin : `get(client, "adresse.ville")`.
+ *
+ * Utile pour une colonne de tableau décrite par une chaîne, ou un message
+ * d'erreur du serveur dont le champ est `adresse.ville`.
+ */
+declare function getPath<T = unknown>(source: unknown, path: string, fallback?: T): T | undefined;
+/** Écrit une valeur par son chemin, en rendant une copie. */
+declare function setPath<T extends Plain>(source: T, path: string, value: unknown): T;
+/**
+ * Compare deux valeurs en profondeur.
+ *
+ * Volontairement limitée aux objets simples, tableaux, dates et primitives :
+ * c'est tout ce qu'on compare dans une interface, et une comparaison
+ * universelle coûte plus qu'elle ne rapporte.
+ */
+declare function isEqual(a: unknown, b: unknown): boolean;
+/** Ce qui a changé entre deux objets — pour un `PATCH` minimal. */
+declare function diff<T extends Plain>(before: T, after: T): Partial<T>;
+
+export { type DeepPartial, deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath };

package/dist/object.js

@@ -0,0 +1 @@
+export { deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath } from './chunk-QMPHN3LG.js';

package/dist/query.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+// src/query.ts
+function serialize(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function toQueryString(params, options = {}) {
+  if (!params) return "";
+  const { prefix = true, skipEmpty = false } = options;
+  const entries = Object.entries(params).filter(([, value]) => value !== void 0 && value !== null).flatMap(([key, value]) => {
+    const values = Array.isArray(value) ? value : [value];
+    return values.filter((item) => item !== void 0 && item !== null).map((item) => serialize(item)).filter((item) => !skipEmpty || item !== "").map(
+      (item) => `${encodeURIComponent(key)}=${encodeURIComponent(item)}`
+    );
+  });
+  if (entries.length === 0) return "";
+  return `${prefix ? "?" : ""}${entries.join("&")}`;
+}
+function fromQueryString(search) {
+  const params = new URLSearchParams(
+    search.startsWith("?") ? search.slice(1) : search
+  );
+  const out = {};
+  for (const [key, value] of params) {
+    const existing = out[key];
+    if (existing === void 0) out[key] = value;
+    else if (Array.isArray(existing)) existing.push(value);
+    else out[key] = [existing, value];
+  }
+  return out;
+}
+function removeEmptyParams(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === void 0) continue;
+    if (value === "") continue;
+    if (Array.isArray(value) && value.length === 0) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function mergeSearchParams(base, patch, options = {}) {
+  const params = new URLSearchParams(
+    base.startsWith("?") ? base.slice(1) : base
+  );
+  for (const [key, value] of Object.entries(patch)) {
+    params.delete(key);
+    if (value === null || value === void 0) continue;
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item === null || item === void 0) continue;
+      params.append(key, serialize(item));
+    }
+  }
+  const result = params.toString();
+  if (!result) return "";
+  return `${options.prefix === false ? "" : "?"}${result}`;
+}
+
+exports.fromQueryString = fromQueryString;
+exports.mergeSearchParams = mergeSearchParams;
+exports.removeEmptyParams = removeEmptyParams;
+exports.toQueryString = toQueryString;

package/dist/query.d.cts

@@ -0,0 +1,48 @@
+/**
+ * Chaînes de requête.
+ *
+ * Une seule implémentation pour tout le dépôt : `buildQueryString` de
+ * `@sia-ui/api` délègue ici, avec son propre typage. Deux sérialisations qui
+ * divergent d'un espace produisent des caches qui ne se recoupent jamais.
+ */
+type QueryValue = string | number | boolean | Date | null | undefined | Record<string, unknown>;
+type QueryParamsInput = Record<string, QueryValue | QueryValue[]>;
+interface ToQueryStringOptions {
+    /** Préfixe la chaîne d'un `?` quand elle n'est pas vide. */
+    prefix?: boolean;
+    /** Retire aussi les chaînes vides et les tableaux vides. */
+    skipEmpty?: boolean;
+}
+/**
+ * Sérialise un objet en chaîne de requête.
+ *
+ * `null` et `undefined` sont retirés — envoyer `?statut=undefined` est une
+ * source classique de filtre fantôme côté serveur. Un tableau produit une
+ * clé répétée, forme que tous les cadres serveur savent lire.
+ */
+declare function toQueryString(params?: QueryParamsInput, options?: ToQueryStringOptions): string;
+/**
+ * Lit une chaîne de requête.
+ *
+ * Une clé répétée rend un tableau, une clé unique rend une chaîne : c'est la
+ * forme que `toQueryString` accepte en retour, donc l'aller-retour est sûr.
+ */
+declare function fromQueryString(search: string): Record<string, string | string[]>;
+/**
+ * Retire les valeurs qui ne veulent rien dire dans une requête.
+ *
+ * `null`, `undefined`, la chaîne vide et le tableau vide. Le `0` et le
+ * `false` sont **gardés** : ce sont des filtres légitimes, et les perdre est
+ * le bogue le plus fréquent de ce genre de fonction.
+ */
+declare function removeEmptyParams<T extends Record<string, unknown>>(params: T): Partial<T>;
+/**
+ * Applique un correctif à une chaîne de requête existante.
+ *
+ * Une valeur `null` ou `undefined` **retire** la clé : c'est ce qui permet
+ * d'écrire `mergeSearchParams(location.search, { page: 2, statut: null })`
+ * sans reconstruire tout l'état.
+ */
+declare function mergeSearchParams(base: string, patch: QueryParamsInput, options?: ToQueryStringOptions): string;
+
+export { type QueryParamsInput, type QueryValue, type ToQueryStringOptions, fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString };

package/dist/query.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Chaînes de requête.
+ *
+ * Une seule implémentation pour tout le dépôt : `buildQueryString` de
+ * `@sia-ui/api` délègue ici, avec son propre typage. Deux sérialisations qui
+ * divergent d'un espace produisent des caches qui ne se recoupent jamais.
+ */
+type QueryValue = string | number | boolean | Date | null | undefined | Record<string, unknown>;
+type QueryParamsInput = Record<string, QueryValue | QueryValue[]>;
+interface ToQueryStringOptions {
+    /** Préfixe la chaîne d'un `?` quand elle n'est pas vide. */
+    prefix?: boolean;
+    /** Retire aussi les chaînes vides et les tableaux vides. */
+    skipEmpty?: boolean;
+}
+/**
+ * Sérialise un objet en chaîne de requête.
+ *
+ * `null` et `undefined` sont retirés — envoyer `?statut=undefined` est une
+ * source classique de filtre fantôme côté serveur. Un tableau produit une
+ * clé répétée, forme que tous les cadres serveur savent lire.
+ */
+declare function toQueryString(params?: QueryParamsInput, options?: ToQueryStringOptions): string;
+/**
+ * Lit une chaîne de requête.
+ *
+ * Une clé répétée rend un tableau, une clé unique rend une chaîne : c'est la
+ * forme que `toQueryString` accepte en retour, donc l'aller-retour est sûr.
+ */
+declare function fromQueryString(search: string): Record<string, string | string[]>;
+/**
+ * Retire les valeurs qui ne veulent rien dire dans une requête.
+ *
+ * `null`, `undefined`, la chaîne vide et le tableau vide. Le `0` et le
+ * `false` sont **gardés** : ce sont des filtres légitimes, et les perdre est
+ * le bogue le plus fréquent de ce genre de fonction.
+ */
+declare function removeEmptyParams<T extends Record<string, unknown>>(params: T): Partial<T>;
+/**
+ * Applique un correctif à une chaîne de requête existante.
+ *
+ * Une valeur `null` ou `undefined` **retire** la clé : c'est ce qui permet
+ * d'écrire `mergeSearchParams(location.search, { page: 2, statut: null })`
+ * sans reconstruire tout l'état.
+ */
+declare function mergeSearchParams(base: string, patch: QueryParamsInput, options?: ToQueryStringOptions): string;
+
+export { type QueryParamsInput, type QueryValue, type ToQueryStringOptions, fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString };

package/dist/query.js

@@ -0,0 +1 @@
+export { fromQueryString, mergeSearchParams, removeEmptyParams, toQueryString } from './chunk-DY6WSWXH.js';