@sia-ui/utils 0.1.0

package/dist/chunk-ETJDEEF5.js

@@ -0,0 +1,129 @@
+// src/file.ts
+var UNITS = ["o", "ko", "Mo", "Go", "To"];
+function formatBytes(bytes, options = {}) {
+  const { decimals = 1, locale = "fr-FR" } = options;
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 o";
+  const exponent = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    UNITS.length - 1
+  );
+  const value = bytes / 1024 ** exponent;
+  return `${value.toLocaleString(locale, {
+    // Les octets n'ont pas de décimale : « 1 024,0 o » n'a pas de sens.
+    maximumFractionDigits: exponent === 0 ? 0 : decimals
+  })} ${UNITS[exponent]}`;
+}
+function extension(name) {
+  const index = name.lastIndexOf(".");
+  if (index <= 0 || index === name.length - 1) return "";
+  return name.slice(index + 1).toLowerCase();
+}
+function baseName(name) {
+  const index = name.lastIndexOf(".");
+  return index <= 0 ? name : name.slice(0, index);
+}
+var BY_EXTENSION = {
+  jpg: "image",
+  jpeg: "image",
+  png: "image",
+  gif: "image",
+  webp: "image",
+  avif: "image",
+  svg: "image",
+  bmp: "image",
+  heic: "image",
+  mp4: "video",
+  webm: "video",
+  mov: "video",
+  avi: "video",
+  mkv: "video",
+  mp3: "audio",
+  wav: "audio",
+  ogg: "audio",
+  m4a: "audio",
+  flac: "audio",
+  pdf: "pdf",
+  zip: "archive",
+  rar: "archive",
+  "7z": "archive",
+  tar: "archive",
+  gz: "archive",
+  xls: "spreadsheet",
+  xlsx: "spreadsheet",
+  csv: "spreadsheet",
+  ods: "spreadsheet",
+  doc: "document",
+  docx: "document",
+  odt: "document",
+  txt: "document",
+  rtf: "document",
+  md: "document"
+};
+function fileKind(file) {
+  if (typeof file !== "string" && file.type) {
+    const [group] = file.type.split("/");
+    if (group === "image") return "image";
+    if (group === "video") return "video";
+    if (group === "audio") return "audio";
+    if (file.type === "application/pdf") return "pdf";
+  }
+  const name = typeof file === "string" ? file : file.name;
+  return BY_EXTENSION[extension(name)] ?? "other";
+}
+function isImage(file) {
+  return fileKind(file) === "image";
+}
+function exceedsSize(file, maxMegabytes) {
+  return file.size > maxMegabytes * 1024 * 1024;
+}
+function matchesAccept(file, accept) {
+  const rules = accept.split(",").map((rule) => rule.trim().toLowerCase()).filter(Boolean);
+  if (rules.length === 0) return true;
+  const type = file.type.toLowerCase();
+  const ext = `.${extension(file.name)}`;
+  return rules.some((rule) => {
+    if (rule.startsWith(".")) return rule === ext;
+    if (rule.endsWith("/*")) return type.startsWith(rule.slice(0, -1));
+    return rule === type;
+  });
+}
+function requireBrowser(what) {
+  if (typeof window === "undefined") {
+    throw new Error(`${what} n'est disponible que dans un navigateur.`);
+  }
+}
+function readAsDataUrl(file) {
+  requireBrowser("readAsDataUrl");
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error ?? new Error("Lecture \xE9chou\xE9e"));
+    reader.readAsDataURL(file);
+  });
+}
+function readAsText(file, encoding = "utf-8") {
+  requireBrowser("readAsText");
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error ?? new Error("Lecture \xE9chou\xE9e"));
+    reader.readAsText(file, encoding);
+  });
+}
+function downloadBlob(blob, filename) {
+  requireBrowser("downloadBlob");
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  URL.revokeObjectURL(url);
+}
+function downloadText(content, filename, type = "text/plain;charset=utf-8") {
+  const prefix = type.startsWith("text/csv") ? "\uFEFF" : "";
+  downloadBlob(new Blob([prefix + content], { type }), filename);
+}
+
+export { baseName, downloadBlob, downloadText, exceedsSize, extension, fileKind, formatBytes, isImage, matchesAccept, readAsDataUrl, readAsText };

package/dist/chunk-FX7K6FKW.js

@@ -0,0 +1,57 @@
+// 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;
+}
+
+export { formatAmount, formatCurrency, getCurrencySymbol, majorToMinor, minorToMajor, parseCurrency };

package/dist/chunk-JHYMIU2G.js

@@ -0,0 +1,121 @@
+// 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));
+}
+
+export { addDays, addMonths, addYears, diffInDays, formatDate, formatDateRange, formatDateTime, formatRelativeDate, formatTimeAgo, getFirstDayOfMonth, getLastDayOfMonth, isPastDate, parseDate, subDays, subMonths, subYears, toDisplayDate, toIsoDate };

package/dist/chunk-L4BLBOLO.js

@@ -0,0 +1,93 @@
+// 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];
+}
+
+export { averageBy, chunk, compact, groupBy, isDefined, keyBy, move, partition, range, sortBy, sum, sumBy, toggleItem, unique, uniqueBy };

package/dist/chunk-PTNHOSWH.js

@@ -0,0 +1,40 @@
+// src/string.ts
+function removeDiacritics(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function truncate(text, maxLength) {
+  if (maxLength <= 0) return "";
+  if (text.length <= maxLength) return text;
+  if (maxLength <= 3) return ".".repeat(maxLength);
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+function capitalize(text) {
+  if (!text) return "";
+  return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+}
+function titleCase(text) {
+  return normalizeSpaces(text).split(" ").filter(Boolean).map(capitalize).join(" ");
+}
+function initials(text) {
+  return normalizeSpaces(text).split(" ").filter(Boolean).slice(0, 2).map((part) => part[0]?.toUpperCase() ?? "").join("");
+}
+function slugify(text) {
+  return removeDiacritics(text).toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeSpaces(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function normalizeIdentifier(text, maxLength = 120) {
+  return removeDiacritics(text).toLowerCase().trim().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength);
+}
+function maskMiddle(text, options = {}) {
+  const { visibleStart = 2, visibleEnd = 2, maskChar = "*" } = options;
+  if (text.length <= visibleStart + visibleEnd) return text;
+  const maskedLength = text.length - visibleStart - visibleEnd;
+  return `${text.slice(0, visibleStart)}${maskChar.repeat(maskedLength)}${text.slice(text.length - visibleEnd)}`;
+}
+function isBlank(value) {
+  return !value || normalizeSpaces(value).length === 0;
+}
+
+export { capitalize, initials, isBlank, maskMiddle, normalizeIdentifier, normalizeSpaces, slugify, titleCase, truncate };

package/dist/chunk-QMPHN3LG.js

@@ -0,0 +1,78 @@
+// 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;
+}
+
+export { deepMerge, diff, getPath, isEmpty, isEqual, omit, pick, setPath };

package/dist/chunk-RIFUQ7JM.js

@@ -0,0 +1,47 @@
+// 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?.();
+  }
+}
+
+export { canCopy, copyText, readText };

package/dist/chunk-YU5NRSDP.js

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

package/dist/classname.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+// src/classname.ts
+function append(tokens, value) {
+  if (!value) return;
+  if (typeof value === "string" || typeof value === "number") {
+    tokens.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) append(tokens, item);
+    return;
+  }
+  for (const [key, enabled] of Object.entries(value)) {
+    if (enabled) tokens.push(key);
+  }
+}
+function cn(...inputs) {
+  const tokens = [];
+  for (const input of inputs) append(tokens, input);
+  return tokens.join(" ");
+}
+function toneClass(block, tone) {
+  return `${block}--${tone}`;
+}
+
+exports.cn = cn;
+exports.toneClass = toneClass;

package/dist/classname.d.cts

@@ -0,0 +1,15 @@
+type ClassValue = string | number | boolean | null | undefined | ClassDictionary | ClassArray;
+type ClassDictionary = Record<string, boolean | null | undefined>;
+type ClassArray = ClassValue[];
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Le nom de classe d'un ton : `toneClass("sia-button", "danger")`.
+ *
+ * Ici et non dans `@sia-ui/tokens` : le ton est une valeur, mais un nom de
+ * classe est une convention de rendu. Une implémentation native traduira le
+ * même ton en objet de style et n'appellera jamais cette fonction.
+ */
+declare function toneClass(block: string, tone: string): string;
+
+export { type ClassValue, cn, toneClass };

package/dist/classname.d.ts

@@ -0,0 +1,15 @@
+type ClassValue = string | number | boolean | null | undefined | ClassDictionary | ClassArray;
+type ClassDictionary = Record<string, boolean | null | undefined>;
+type ClassArray = ClassValue[];
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Le nom de classe d'un ton : `toneClass("sia-button", "danger")`.
+ *
+ * Ici et non dans `@sia-ui/tokens` : le ton est une valeur, mais un nom de
+ * classe est une convention de rendu. Une implémentation native traduira le
+ * même ton en objet de style et n'appellera jamais cette fonction.
+ */
+declare function toneClass(block: string, tone: string): string;
+
+export { type ClassValue, cn, toneClass };

package/dist/classname.js

@@ -0,0 +1 @@
+export { cn, toneClass } from './chunk-BMNZVRFN.js';