@sia-ui/utils 0.1.0

package/dist/clipboard.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+// src/clipboard.ts
+function canCopy() {
+  return typeof navigator !== "undefined" && typeof navigator.clipboard?.writeText === "function";
+}
+async function copyText(text) {
+  if (typeof document === "undefined") return false;
+  if (canCopy()) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  return copyWithTextarea(text);
+}
+async function readText() {
+  if (typeof navigator === "undefined" || typeof navigator.clipboard?.readText !== "function") {
+    return null;
+  }
+  try {
+    return await navigator.clipboard.readText();
+  } catch {
+    return null;
+  }
+}
+function copyWithTextarea(text) {
+  const field = document.createElement("textarea");
+  field.value = text;
+  field.setAttribute("readonly", "");
+  field.style.position = "fixed";
+  field.style.top = "-9999px";
+  field.style.opacity = "0";
+  document.body.appendChild(field);
+  const previous = document.activeElement;
+  try {
+    field.select();
+    field.setSelectionRange(0, field.value.length);
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    field.remove();
+    previous?.focus?.();
+  }
+}
+
+exports.canCopy = canCopy;
+exports.copyText = copyText;
+exports.readText = readText;

package/dist/clipboard.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Presse-papiers.
+ *
+ * L'API moderne demande un contexte sécurisé — HTTPS ou localhost. En HTTP
+ * simple, sur un réseau interne par exemple, elle n'existe pas : le repli par
+ * un champ de saisie hors écran est la seule façon de ne pas perdre la
+ * fonction là où elle sert le plus.
+ */
+/** Vrai si l'API moderne est disponible. Le repli marche de toute façon. */
+declare function canCopy(): boolean;
+/** Copie du texte. Rend `false` si rien n'a pu être copié. */
+declare function copyText(text: string): Promise<boolean>;
+/** Lit le presse-papiers. Souvent refusé : la permission est demandée. */
+declare function readText(): Promise<string | null>;
+
+export { canCopy, copyText, readText };

package/dist/clipboard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Presse-papiers.
+ *
+ * L'API moderne demande un contexte sécurisé — HTTPS ou localhost. En HTTP
+ * simple, sur un réseau interne par exemple, elle n'existe pas : le repli par
+ * un champ de saisie hors écran est la seule façon de ne pas perdre la
+ * fonction là où elle sert le plus.
+ */
+/** Vrai si l'API moderne est disponible. Le repli marche de toute façon. */
+declare function canCopy(): boolean;
+/** Copie du texte. Rend `false` si rien n'a pu être copié. */
+declare function copyText(text: string): Promise<boolean>;
+/** Lit le presse-papiers. Souvent refusé : la permission est demandée. */
+declare function readText(): Promise<string | null>;
+
+export { canCopy, copyText, readText };

package/dist/clipboard.js

@@ -0,0 +1 @@
+export { canCopy, copyText, readText } from './chunk-RIFUQ7JM.js';

package/dist/collection.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+// src/collection.ts
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function uniqueBy(values, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of values) {
+    const id = key(item);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(item);
+  }
+  return out;
+}
+function compact(values) {
+  return values.filter(isDefined);
+}
+function groupBy(values, key) {
+  const out = {};
+  for (const item of values) {
+    const group = key(item);
+    (out[group] ??= []).push(item);
+  }
+  return out;
+}
+function keyBy(values, key) {
+  const out = {};
+  for (const item of values) out[key(item)] = item;
+  return out;
+}
+function chunk(values, size) {
+  if (size <= 0) return [[...values]];
+  const out = [];
+  for (let index = 0; index < values.length; index += size) {
+    out.push(values.slice(index, index + size));
+  }
+  return out;
+}
+function partition(values, predicate) {
+  const yes = [];
+  const no = [];
+  values.forEach((item, index) => {
+    (predicate(item, index) ? yes : no).push(item);
+  });
+  return [yes, no];
+}
+function sortBy(values, key, direction = "asc", locale = "fr-FR") {
+  const sign = direction === "asc" ? 1 : -1;
+  return [...values].sort((a, b) => {
+    const left = key(a);
+    const right = key(b);
+    if (!isDefined(left)) return isDefined(right) ? 1 : 0;
+    if (!isDefined(right)) return -1;
+    if (typeof left === "string" && typeof right === "string") {
+      return left.localeCompare(right, locale) * sign;
+    }
+    const l = left instanceof Date ? left.getTime() : Number(left);
+    const r = right instanceof Date ? right.getTime() : Number(right);
+    return (l - r) * sign;
+  });
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function sumBy(values, key) {
+  return values.reduce((total, item) => total + key(item), 0);
+}
+function averageBy(values, key) {
+  if (values.length === 0) return 0;
+  return sumBy(values, key) / values.length;
+}
+function range(start, end, step = 1) {
+  if (step === 0) return [];
+  const out = [];
+  if (step > 0) for (let i = start; i <= end; i += step) out.push(i);
+  else for (let i = start; i >= end; i += step) out.push(i);
+  return out;
+}
+function move(values, from, to) {
+  const out = [...values];
+  const [item] = out.splice(from, 1);
+  if (item !== void 0) out.splice(to, 0, item);
+  return out;
+}
+function toggleItem(values, item) {
+  return values.includes(item) ? values.filter((entry) => entry !== item) : [...values, item];
+}
+
+exports.averageBy = averageBy;
+exports.chunk = chunk;
+exports.compact = compact;
+exports.groupBy = groupBy;
+exports.isDefined = isDefined;
+exports.keyBy = keyBy;
+exports.move = move;
+exports.partition = partition;
+exports.range = range;
+exports.sortBy = sortBy;
+exports.sum = sum;
+exports.sumBy = sumBy;
+exports.toggleItem = toggleItem;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;

package/dist/collection.d.cts

@@ -0,0 +1,44 @@
+/**
+ * Listes.
+ *
+ * Rien qui ne s'écrive en trois lignes — mais ces trois lignes étaient
+ * écrites dans chaque projet, chaque fois légèrement différemment.
+ */
+/** Retire `null` et `undefined`, et le dit au typage. */
+declare function isDefined<T>(value: T | null | undefined): value is T;
+/** Les valeurs distinctes, dans l'ordre d'apparition. */
+declare function unique<T>(values: readonly T[]): T[];
+/** Les valeurs distinctes selon une clé — un identifiant, le plus souvent. */
+declare function uniqueBy<T, K>(values: readonly T[], key: (item: T) => K): T[];
+/** Retire les trous : `null`, `undefined`. */
+declare function compact<T>(values: readonly (T | null | undefined)[]): T[];
+/** Regroupe par clé. Les groupes gardent l'ordre de la liste d'origine. */
+declare function groupBy<T, K extends string | number>(values: readonly T[], key: (item: T) => K): Record<K, T[]>;
+/** Indexe par clé. En cas de doublon, le dernier gagne. */
+declare function keyBy<T, K extends string | number>(values: readonly T[], key: (item: T) => K): Record<K, T>;
+/** Découpe en tranches de taille fixe. La dernière peut être plus courte. */
+declare function chunk<T>(values: readonly T[], size: number): T[][];
+/** Sépare en deux : ce qui passe le test, ce qui ne le passe pas. */
+declare function partition<T>(values: readonly T[], predicate: (item: T, index: number) => boolean): [T[], T[]];
+type SortDirection = "asc" | "desc";
+/**
+ * Trie sans modifier la liste d'origine.
+ *
+ * Les chaînes sont comparées avec `localeCompare` : sans cela « Émile » se
+ * range après « Zoé », ce qui se voit immédiatement dans une liste de noms.
+ */
+declare function sortBy<T>(values: readonly T[], key: (item: T) => string | number | Date | null | undefined, direction?: SortDirection, locale?: string): T[];
+/** Somme d'une liste de nombres. */
+declare function sum(values: readonly number[]): number;
+/** Somme d'une propriété — un montant, une quantité. */
+declare function sumBy<T>(values: readonly T[], key: (item: T) => number): number;
+/** Moyenne. Une liste vide rend `0` plutôt que `NaN`. */
+declare function averageBy<T>(values: readonly T[], key: (item: T) => number): number;
+/** Une suite d'entiers, bornes incluses. */
+declare function range(start: number, end: number, step?: number): number[];
+/** Déplace un élément d'une position à une autre — un glisser-déposer. */
+declare function move<T>(values: readonly T[], from: number, to: number): T[];
+/** Ajoute ou retire selon la présence — une sélection multiple. */
+declare function toggleItem<T>(values: readonly T[], item: T): T[];
+
+export { type SortDirection, averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy };

package/dist/collection.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Listes.
+ *
+ * Rien qui ne s'écrive en trois lignes — mais ces trois lignes étaient
+ * écrites dans chaque projet, chaque fois légèrement différemment.
+ */
+/** Retire `null` et `undefined`, et le dit au typage. */
+declare function isDefined<T>(value: T | null | undefined): value is T;
+/** Les valeurs distinctes, dans l'ordre d'apparition. */
+declare function unique<T>(values: readonly T[]): T[];
+/** Les valeurs distinctes selon une clé — un identifiant, le plus souvent. */
+declare function uniqueBy<T, K>(values: readonly T[], key: (item: T) => K): T[];
+/** Retire les trous : `null`, `undefined`. */
+declare function compact<T>(values: readonly (T | null | undefined)[]): T[];
+/** Regroupe par clé. Les groupes gardent l'ordre de la liste d'origine. */
+declare function groupBy<T, K extends string | number>(values: readonly T[], key: (item: T) => K): Record<K, T[]>;
+/** Indexe par clé. En cas de doublon, le dernier gagne. */
+declare function keyBy<T, K extends string | number>(values: readonly T[], key: (item: T) => K): Record<K, T>;
+/** Découpe en tranches de taille fixe. La dernière peut être plus courte. */
+declare function chunk<T>(values: readonly T[], size: number): T[][];
+/** Sépare en deux : ce qui passe le test, ce qui ne le passe pas. */
+declare function partition<T>(values: readonly T[], predicate: (item: T, index: number) => boolean): [T[], T[]];
+type SortDirection = "asc" | "desc";
+/**
+ * Trie sans modifier la liste d'origine.
+ *
+ * Les chaînes sont comparées avec `localeCompare` : sans cela « Émile » se
+ * range après « Zoé », ce qui se voit immédiatement dans une liste de noms.
+ */
+declare function sortBy<T>(values: readonly T[], key: (item: T) => string | number | Date | null | undefined, direction?: SortDirection, locale?: string): T[];
+/** Somme d'une liste de nombres. */
+declare function sum(values: readonly number[]): number;
+/** Somme d'une propriété — un montant, une quantité. */
+declare function sumBy<T>(values: readonly T[], key: (item: T) => number): number;
+/** Moyenne. Une liste vide rend `0` plutôt que `NaN`. */
+declare function averageBy<T>(values: readonly T[], key: (item: T) => number): number;
+/** Une suite d'entiers, bornes incluses. */
+declare function range(start: number, end: number, step?: number): number[];
+/** Déplace un élément d'une position à une autre — un glisser-déposer. */
+declare function move<T>(values: readonly T[], from: number, to: number): T[];
+/** Ajoute ou retire selon la présence — une sélection multiple. */
+declare function toggleItem<T>(values: readonly T[], item: T): T[];
+
+export { type SortDirection, averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy };

package/dist/collection.js

@@ -0,0 +1 @@
+export { averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy } from './chunk-L4BLBOLO.js';

package/dist/currency.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+// src/currency.ts
+function getNumberFormat(locale, options) {
+  return new Intl.NumberFormat(locale, options);
+}
+function normalizeNumberInput(input, decimalSeparator) {
+  const trimmed = input.trim();
+  const sanitized = trimmed.replace(/[^\d,.-]/g, "");
+  if (!sanitized) return "";
+  if (decimalSeparator) {
+    const normalized = decimalSeparator === "," ? sanitized.replace(/\./g, "").replace(",", ".") : sanitized.replace(/,/g, "");
+    return normalized;
+  }
+  const lastComma = sanitized.lastIndexOf(",");
+  const lastDot = sanitized.lastIndexOf(".");
+  if (lastComma > lastDot) {
+    return sanitized.replace(/\./g, "").replace(",", ".");
+  }
+  return sanitized.replace(/,/g, "");
+}
+function formatCurrency(value, options = {}) {
+  const { locale = "fr-FR", currency = "XAF", ...formatOptions } = options;
+  return getNumberFormat(locale, {
+    style: "currency",
+    currency,
+    maximumFractionDigits: currency === "XAF" || currency === "XOF" ? 0 : 2,
+    ...formatOptions
+  }).format(value);
+}
+function formatAmount(value, options = {}) {
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return getNumberFormat(locale, {
+    maximumFractionDigits: 2,
+    ...formatOptions
+  }).format(value);
+}
+function parseCurrency(input, options = {}) {
+  const normalized = normalizeNumberInput(input, options.decimalSeparator);
+  if (!normalized) return null;
+  const value = Number(normalized);
+  return Number.isFinite(value) ? value : null;
+}
+function minorToMajor(amount, digits = 2) {
+  return amount / 10 ** digits;
+}
+function majorToMinor(amount, digits = 2) {
+  return Math.round(amount * 10 ** digits);
+}
+function getCurrencySymbol(currency, locale = "fr-FR") {
+  const parts = getNumberFormat(locale, {
+    style: "currency",
+    currency,
+    currencyDisplay: "narrowSymbol"
+  }).formatToParts(1);
+  return parts.find((part) => part.type === "currency")?.value ?? currency;
+}
+
+exports.formatAmount = formatAmount;
+exports.formatCurrency = formatCurrency;
+exports.getCurrencySymbol = getCurrencySymbol;
+exports.majorToMinor = majorToMinor;
+exports.minorToMajor = minorToMajor;
+exports.parseCurrency = parseCurrency;

package/dist/currency.d.cts

@@ -0,0 +1,16 @@
+interface CurrencyFormatOptions extends Intl.NumberFormatOptions {
+    locale?: string;
+    currency?: string;
+}
+interface ParseCurrencyOptions {
+    locale?: string;
+    decimalSeparator?: "." | ",";
+}
+declare function formatCurrency(value: number, options?: CurrencyFormatOptions): string;
+declare function formatAmount(value: number, options?: CurrencyFormatOptions): string;
+declare function parseCurrency(input: string, options?: ParseCurrencyOptions): number | null;
+declare function minorToMajor(amount: number, digits?: number): number;
+declare function majorToMinor(amount: number, digits?: number): number;
+declare function getCurrencySymbol(currency: string, locale?: string): string;
+
+export { type CurrencyFormatOptions, type ParseCurrencyOptions, formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency };

package/dist/currency.d.ts

@@ -0,0 +1,16 @@
+interface CurrencyFormatOptions extends Intl.NumberFormatOptions {
+    locale?: string;
+    currency?: string;
+}
+interface ParseCurrencyOptions {
+    locale?: string;
+    decimalSeparator?: "." | ",";
+}
+declare function formatCurrency(value: number, options?: CurrencyFormatOptions): string;
+declare function formatAmount(value: number, options?: CurrencyFormatOptions): string;
+declare function parseCurrency(input: string, options?: ParseCurrencyOptions): number | null;
+declare function minorToMajor(amount: number, digits?: number): number;
+declare function majorToMinor(amount: number, digits?: number): number;
+declare function getCurrencySymbol(currency: string, locale?: string): string;
+
+export { type CurrencyFormatOptions, type ParseCurrencyOptions, formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency };

package/dist/currency.js

@@ -0,0 +1 @@
+export { formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency } from './chunk-FX7K6FKW.js';

package/dist/date.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+// src/date.ts
+function toDate(value) {
+  const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function shiftDate(value, mutate) {
+  const date = toDate(value);
+  if (!date) return null;
+  const next = new Date(date.getTime());
+  mutate(next);
+  return next;
+}
+function formatWith(locale, value, options) {
+  return new Intl.DateTimeFormat(locale, options).format(value);
+}
+function parseDate(value) {
+  return /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+}
+function diffInDays(startDate, endDate) {
+  const start = parseDate(startDate);
+  const end = parseDate(endDate);
+  const diffInMilliseconds = end.getTime() - start.getTime();
+  return Math.trunc(diffInMilliseconds / (1e3 * 60 * 60 * 24));
+}
+function formatDate(value, options = {}) {
+  const date = toDate(value);
+  if (!date) return "";
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatWith(locale, date, { dateStyle: "medium", ...formatOptions });
+}
+function formatDateTime(value, options = {}) {
+  const date = toDate(value);
+  if (!date) return "";
+  const { locale = "fr-FR", ...formatOptions } = options;
+  return formatWith(locale, date, { dateStyle: "medium", timeStyle: "short", ...formatOptions });
+}
+function formatRelativeDate(value, options = {}) {
+  const date = toDate(value);
+  const now = toDate(options.now ?? /* @__PURE__ */ new Date());
+  if (!date || !now) return "";
+  const diffMs = date.getTime() - now.getTime();
+  const units = [
+    ["year", 1e3 * 60 * 60 * 24 * 365],
+    ["month", 1e3 * 60 * 60 * 24 * 30],
+    ["day", 1e3 * 60 * 60 * 24],
+    ["hour", 1e3 * 60 * 60],
+    ["minute", 1e3 * 60],
+    ["second", 1e3]
+  ];
+  for (const [unit, size] of units) {
+    if (Math.abs(diffMs) >= size || unit === "second") {
+      const valueForUnit = Math.round(diffMs / size);
+      return new Intl.RelativeTimeFormat(options.locale ?? "fr-FR", { numeric: "auto" }).format(valueForUnit, unit);
+    }
+  }
+  return "";
+}
+function formatTimeAgo(value, options = {}) {
+  const relative = formatRelativeDate(value, options);
+  if (!relative) return "";
+  const prefix = options.prefix?.trim();
+  return prefix ? `${prefix} ${relative}` : relative;
+}
+function formatDateRange(start, end, options = {}) {
+  const startDate = toDate(start);
+  const endDate = toDate(end);
+  if (!startDate || !endDate) return "";
+  const { locale = "fr-FR", ...formatOptions } = options;
+  const formatter = new Intl.DateTimeFormat(locale, { dateStyle: "medium", ...formatOptions });
+  if (typeof formatter.formatRange === "function") {
+    return formatter.formatRange(startDate, endDate);
+  }
+  return `${formatter.format(startDate)} - ${formatter.format(endDate)}`;
+}
+function isPastDate(value, now = /* @__PURE__ */ new Date()) {
+  const date = toDate(value);
+  const reference = toDate(now);
+  if (!date || !reference) return false;
+  return date.getTime() < reference.getTime();
+}
+function toIsoDate(value) {
+  const date = toDate(value);
+  if (!date) return "";
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function toDisplayDate(value, locale = "fr-FR") {
+  return formatDate(value, { locale });
+}
+function addDays(value, days) {
+  return shiftDate(value, (date) => date.setDate(date.getDate() + days));
+}
+function subDays(value, days) {
+  return addDays(value, -days);
+}
+function addMonths(value, months) {
+  return shiftDate(value, (date) => date.setMonth(date.getMonth() + months));
+}
+function subMonths(value, months) {
+  return addMonths(value, -months);
+}
+function addYears(value, years) {
+  return shiftDate(value, (date) => date.setFullYear(date.getFullYear() + years));
+}
+function subYears(value, years) {
+  return addYears(value, -years);
+}
+function getFirstDayOfMonth(value) {
+  const date = toDate(value);
+  if (!date) return null;
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1));
+}
+function getLastDayOfMonth(value) {
+  const date = toDate(value);
+  if (!date) return null;
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 0));
+}
+
+exports.addDays = addDays;
+exports.addMonths = addMonths;
+exports.addYears = addYears;
+exports.diffInDays = diffInDays;
+exports.formatDate = formatDate;
+exports.formatDateRange = formatDateRange;
+exports.formatDateTime = formatDateTime;
+exports.formatRelativeDate = formatRelativeDate;
+exports.formatTimeAgo = formatTimeAgo;
+exports.getFirstDayOfMonth = getFirstDayOfMonth;
+exports.getLastDayOfMonth = getLastDayOfMonth;
+exports.isPastDate = isPastDate;
+exports.parseDate = parseDate;
+exports.subDays = subDays;
+exports.subMonths = subMonths;
+exports.subYears = subYears;
+exports.toDisplayDate = toDisplayDate;
+exports.toIsoDate = toIsoDate;

package/dist/date.d.cts

@@ -0,0 +1,32 @@
+type DateValue = Date | string | number;
+interface DateFormatOptions extends Intl.DateTimeFormatOptions {
+    locale?: string;
+}
+interface TimeAgoOptions {
+    locale?: string;
+    now?: DateValue;
+    prefix?: string;
+}
+declare function parseDate(value: string): Date;
+declare function diffInDays(startDate: string, endDate: string): number;
+declare function formatDate(value: DateValue, options?: DateFormatOptions): string;
+declare function formatDateTime(value: DateValue, options?: DateFormatOptions): string;
+declare function formatRelativeDate(value: DateValue, options?: {
+    locale?: string;
+    now?: DateValue;
+}): string;
+declare function formatTimeAgo(value: DateValue, options?: TimeAgoOptions): string;
+declare function formatDateRange(start: DateValue, end: DateValue, options?: DateFormatOptions): string;
+declare function isPastDate(value: DateValue, now?: DateValue): boolean;
+declare function toIsoDate(value: DateValue): string;
+declare function toDisplayDate(value: DateValue, locale?: string): string;
+declare function addDays(value: DateValue, days: number): Date | null;
+declare function subDays(value: DateValue, days: number): Date | null;
+declare function addMonths(value: DateValue, months: number): Date | null;
+declare function subMonths(value: DateValue, months: number): Date | null;
+declare function addYears(value: DateValue, years: number): Date | null;
+declare function subYears(value: DateValue, years: number): Date | null;
+declare function getFirstDayOfMonth(value: DateValue): Date | null;
+declare function getLastDayOfMonth(value: DateValue): Date | null;
+
+export { type DateFormatOptions, type DateValue, type TimeAgoOptions, addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate };

package/dist/date.d.ts

@@ -0,0 +1,32 @@
+type DateValue = Date | string | number;
+interface DateFormatOptions extends Intl.DateTimeFormatOptions {
+    locale?: string;
+}
+interface TimeAgoOptions {
+    locale?: string;
+    now?: DateValue;
+    prefix?: string;
+}
+declare function parseDate(value: string): Date;
+declare function diffInDays(startDate: string, endDate: string): number;
+declare function formatDate(value: DateValue, options?: DateFormatOptions): string;
+declare function formatDateTime(value: DateValue, options?: DateFormatOptions): string;
+declare function formatRelativeDate(value: DateValue, options?: {
+    locale?: string;
+    now?: DateValue;
+}): string;
+declare function formatTimeAgo(value: DateValue, options?: TimeAgoOptions): string;
+declare function formatDateRange(start: DateValue, end: DateValue, options?: DateFormatOptions): string;
+declare function isPastDate(value: DateValue, now?: DateValue): boolean;
+declare function toIsoDate(value: DateValue): string;
+declare function toDisplayDate(value: DateValue, locale?: string): string;
+declare function addDays(value: DateValue, days: number): Date | null;
+declare function subDays(value: DateValue, days: number): Date | null;
+declare function addMonths(value: DateValue, months: number): Date | null;
+declare function subMonths(value: DateValue, months: number): Date | null;
+declare function addYears(value: DateValue, years: number): Date | null;
+declare function subYears(value: DateValue, years: number): Date | null;
+declare function getFirstDayOfMonth(value: DateValue): Date | null;
+declare function getLastDayOfMonth(value: DateValue): Date | null;
+
+export { type DateFormatOptions, type DateValue, type TimeAgoOptions, addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate };

package/dist/date.js

@@ -0,0 +1 @@
+export { addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate } from './chunk-JHYMIU2G.js';

package/dist/events.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+// src/events.ts
+function composeEventHandlers(consumerHandler, internalHandler) {
+  return (event) => {
+    consumerHandler?.(event);
+    if (!event.defaultPrevented) {
+      internalHandler?.(event);
+    }
+  };
+}
+
+exports.composeEventHandlers = composeEventHandlers;

package/dist/events.d.cts

@@ -0,0 +1,10 @@
+/**
+ * Enchaîne le gestionnaire d'un appelant et celui d'un composant.
+ *
+ * Celui de l'appelant passe en premier et peut couper la suite en appelant
+ * `preventDefault()` — c'est ce qui permet de neutraliser un comportement
+ * intégré sans avoir à le réécrire.
+ */
+declare function composeEventHandlers<E>(consumerHandler?: ((event: E) => void) | undefined, internalHandler?: ((event: E) => void) | undefined): (event: E) => void;
+
+export { composeEventHandlers };

package/dist/events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enchaîne le gestionnaire d'un appelant et celui d'un composant.
+ *
+ * Celui de l'appelant passe en premier et peut couper la suite en appelant
+ * `preventDefault()` — c'est ce qui permet de neutraliser un comportement
+ * intégré sans avoir à le réécrire.
+ */
+declare function composeEventHandlers<E>(consumerHandler?: ((event: E) => void) | undefined, internalHandler?: ((event: E) => void) | undefined): (event: E) => void;
+
+export { composeEventHandlers };

package/dist/events.js

@@ -0,0 +1 @@
+export { composeEventHandlers } from './chunk-YU5NRSDP.js';