@rotomeca/design-system 0.0.0-stage → 1.0.1

package/dist/core/scripts/decorators/set-attr.js

@@ -0,0 +1,62 @@
+/** Applique un attribut ; `true` donne un attribut vide, `false` le retire. */
+function setAttribute(element, name, value) {
+    if (value === false)
+        element.removeAttribute(name);
+    else
+        element.setAttribute(name, value === true ? '' : String(value));
+}
+/**
+ * @SetAttr : Ajoute un attribut avec une valeur fixe à l'élément, après l'appel de la méthode.
+ *
+ * @param attributeName Nom de l'attribut à ajouter.
+ * @param value Valeur de l'attribut à définir.
+ */
+export function SetAttr(attributeName, value) {
+    return function (originalMethod, context) {
+        if (context.kind !== 'method') {
+            throw new Error('@SetAttr ne peut être utilisé que sur des méthodes.');
+        }
+        return function (...args) {
+            const result = originalMethod.apply(this, args);
+            setAttribute(this, attributeName, value);
+            return result;
+        };
+    };
+}
+/**
+ * @SetAttrs : Ajoute plusieurs attributs à l'élément, avant l'appel de la méthode.
+ *
+ * @param attribs Attributs à définir, indexés par nom.
+ */
+export function SetAttrs(attribs) {
+    return function (originalMethod, context) {
+        if (context.kind !== 'method') {
+            throw new Error('@SetAttrs ne peut être utilisé que sur des méthodes.');
+        }
+        return function (...args) {
+            for (const [key, value] of Object.entries(attribs))
+                setAttribute(this, key, value);
+            return originalMethod.apply(this, args);
+        };
+    };
+}
+/**
+ * @InitAttr : Définit un attribut après l'appel de la méthode, seulement s'il est absent.
+ *
+ * @param attributeName Nom de l'attribut.
+ * @param value Valeur par défaut.
+ */
+export function InitAttr(attributeName, value) {
+    return function (originalMethod, context) {
+        if (context.kind !== 'method') {
+            throw new Error('@InitAttr ne peut être utilisé que sur des méthodes.');
+        }
+        return function (...args) {
+            const result = originalMethod.apply(this, args);
+            if (!this.hasAttribute(attributeName))
+                setAttribute(this, attributeName, value);
+            return result;
+        };
+    };
+}
+//# sourceMappingURL=set-attr.js.map

package/dist/core/scripts/decorators/ui.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @UI : Accesseur en lecture seule retournant un objet dont chaque clé résout paresseusement
+ * son sélecteur dans la racine de rendu.
+ *
+ * @param selectorMap - Sélecteur CSS par clé.
+ * @param options.shadowRoot - Cherche dans la racine de rendu plutôt que dans le Light DOM (défaut : `true`).
+ */
+export declare function UI<K extends string>(selectorMap: Record<K, string>, options?: {
+    shadowRoot?: boolean;
+}): <T extends HTMLElement, V extends Record<K, Element | null>>(_target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext<T, V>) => ClassAccessorDecoratorResult<T, V>;
+//# sourceMappingURL=ui.d.ts.map

package/dist/core/scripts/decorators/ui.js

@@ -0,0 +1,51 @@
+import { BaseElement } from '../../../components/base/BaseElement';
+/**
+ * @UI : Accesseur en lecture seule retournant un objet dont chaque clé résout paresseusement
+ * son sélecteur dans la racine de rendu.
+ *
+ * @param selectorMap - Sélecteur CSS par clé.
+ * @param options.shadowRoot - Cherche dans la racine de rendu plutôt que dans le Light DOM (défaut : `true`).
+ */
+export function UI(selectorMap, options) {
+    const { shadowRoot = true } = options || {};
+    return function (_target, context) {
+        // Symbole pour stocker l'objet UI une fois créé
+        const uiCacheKey = Symbol(String(context.name));
+        return {
+            get() {
+                const store = this;
+                if (store[uiCacheKey])
+                    return store[uiCacheKey];
+                const root = shadowRoot
+                    ? this instanceof BaseElement
+                        ? this.renderRoot
+                        : (this.shadowRoot ?? this)
+                    : this;
+                const uiObject = {};
+                // Cache granulaire : un élément retiré du DOM est recherché à nouveau.
+                const domCache = new Map();
+                for (const [key, selector] of Object.entries(selectorMap)) {
+                    Object.defineProperty(uiObject, key, {
+                        configurable: true,
+                        enumerable: true,
+                        get: () => {
+                            const cached = domCache.get(key);
+                            if (cached?.isConnected)
+                                return cached;
+                            const element = root.querySelector(selector);
+                            domCache.set(key, element);
+                            return element;
+                        },
+                        // Permet d'écraser manuellement si besoin
+                        set: (value) => {
+                            domCache.set(key, value);
+                        },
+                    });
+                }
+                store[uiCacheKey] = uiObject;
+                return uiObject;
+            },
+        };
+    };
+}
+//# sourceMappingURL=ui.js.map

package/dist/core/scripts/decorators/updateAll.d.ts

@@ -0,0 +1,19 @@
+import type { AcceptedFunction } from '../utils/types';
+/**
+ * Décorateur de classe : marque le composant comme se redessinant en entier
+ * (`static updateAll = true`) à chaque mise à jour.
+ *
+ * @remarks
+ * {@link BaseElement} planifie déjà `update` à chaque changement d'attribut observé ;
+ * le drapeau sert aux classes dérivées pour ignorer {@link UpdateContext.attributes}
+ * et reconstruire tout le rendu.
+ *
+ * @example
+ * ```tsx
+ * @Define({ ... })
+ * @UpdateAll()
+ * export class MyComponent extends BaseElement {}
+ * ```
+ */
+export declare function UpdateAll(): (_target: AcceptedFunction, context: ClassDecoratorContext) => void;
+//# sourceMappingURL=updateAll.d.ts.map

package/dist/core/scripts/decorators/updateAll.js

@@ -0,0 +1,27 @@
+/**
+ * Décorateur de classe : marque le composant comme se redessinant en entier
+ * (`static updateAll = true`) à chaque mise à jour.
+ *
+ * @remarks
+ * {@link BaseElement} planifie déjà `update` à chaque changement d'attribut observé ;
+ * le drapeau sert aux classes dérivées pour ignorer {@link UpdateContext.attributes}
+ * et reconstruire tout le rendu.
+ *
+ * @example
+ * ```tsx
+ * @Define({ ... })
+ * @UpdateAll()
+ * export class MyComponent extends BaseElement {}
+ * ```
+ */
+export function UpdateAll() {
+    return function (_target, context) {
+        if (context.kind !== 'class') {
+            throw new Error('@UpdateAll ne peut être utilisé que sur une classe.');
+        }
+        context.addInitializer(function () {
+            this.updateAll = true;
+        });
+    };
+}
+//# sourceMappingURL=updateAll.js.map

package/dist/core/scripts/jsx/index.d.ts

@@ -0,0 +1,24 @@
+import type { AcceptedAny } from '../utils/types';
+/** Props d'un élément JSX. */
+type Props = Record<string, AcceptedAny> | null | undefined;
+/** Composant fonction : reçoit ses props et ses enfants, retourne du HTML. */
+type Component = (props: Record<string, AcceptedAny>) => string;
+/** Classe de Custom Element exposant son nom de balise (ex. `BaseElement`). */
+type ElementClass = {
+    tagName: string;
+};
+/**
+ * Fabrique JSX : produit une chaîne HTML.
+ *
+ * @param tag - Nom de balise, composant fonction, ou classe de Custom Element (`static tagName`).
+ * @param props - Propriétés ; `children` est ignoré si des enfants sont passés en argument.
+ * @param argsChildren - Enfants (chaînes, tableaux, `null`/booléens ignorés).
+ * @returns Le HTML correspondant.
+ */
+export declare function h(tag: string | Component | ElementClass, props: Props, ...argsChildren: AcceptedAny[]): string;
+/** Fragment JSX : rend uniquement ses enfants. */
+export declare const Fragment: (props: {
+    children?: AcceptedAny;
+}) => string;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/core/scripts/jsx/index.js

@@ -0,0 +1,83 @@
+import { EMPTY_STRING } from '@rotomeca/utils';
+const VOID_TAGS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+/**
+ * Fabrique JSX : produit une chaîne HTML.
+ *
+ * @param tag - Nom de balise, composant fonction, ou classe de Custom Element (`static tagName`).
+ * @param props - Propriétés ; `children` est ignoré si des enfants sont passés en argument.
+ * @param argsChildren - Enfants (chaînes, tableaux, `null`/booléens ignorés).
+ * @returns Le HTML correspondant.
+ */
+export function h(tag, props, ...argsChildren) {
+    let name;
+    if (typeof tag === 'function') {
+        const tagName = tag.tagName;
+        if (typeof tagName === 'string') {
+            if (!tagName)
+                throw new Error(`[jsx] La classe ${tag.name} n'a pas de static tagName.`);
+            name = tagName;
+        }
+        else {
+            const children = argsChildren.length ? argsChildren : (props?.children ?? []);
+            return tag({ ...props, children });
+        }
+    }
+    else
+        name = tag;
+    let attrs = EMPTY_STRING;
+    if (props) {
+        for (const key in props) {
+            const value = props[key];
+            if (key === 'children' || value == null || value === false)
+                continue;
+            const attrName = key === 'className' ? 'class' : key;
+            if (key === 'style' && typeof value === 'object') {
+                let styleStr = EMPTY_STRING;
+                for (const sKey in value)
+                    styleStr += `${sKey}:${value[sKey]};`;
+                attrs += ` ${attrName}="${styleStr}"`;
+            }
+            else if (value === true) {
+                attrs += ` ${attrName}`;
+            }
+            else {
+                attrs += ` ${attrName}="${value}"`;
+            }
+        }
+    }
+    const open = `<${name}${attrs}>`;
+    if (VOID_TAGS.has(name))
+        return open;
+    const rawChildren = argsChildren.length > 0 ? argsChildren : props?.children;
+    return `${open}${renderChildren(rawChildren)}</${name}>`;
+}
+/** Rend récursivement les enfants en chaîne. */
+function renderChildren(child) {
+    if (child == null || child === false || child === true)
+        return EMPTY_STRING;
+    if (Array.isArray(child)) {
+        let str = EMPTY_STRING;
+        for (const item of child)
+            str += renderChildren(item);
+        return str;
+    }
+    return String(child);
+}
+/** Fragment JSX : rend uniquement ses enfants. */
+export const Fragment = (props) => props.children ? renderChildren(props.children) : EMPTY_STRING;
+//# sourceMappingURL=index.js.map

package/dist/core/scripts/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export * from './jsx-runtime';
+//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/core/scripts/jsx/jsx-dev-runtime.js

@@ -0,0 +1,2 @@
+export * from './jsx-runtime';
+//# sourceMappingURL=jsx-dev-runtime.js.map

package/dist/core/scripts/jsx/jsx-runtime.d.ts

@@ -0,0 +1,19 @@
+import { h, Fragment } from './index';
+import type { AcceptedAny } from '../utils/types';
+/**
+ * Runtime JSX automatique (`jsx: "react-jsx"`) : `jsx(type, props, key)`.
+ * Les enfants sont dans `props.children` ; `key` n'a pas de sens pour du HTML en chaîne.
+ */
+export declare function jsx(type: Parameters<typeof h>[0], props: Record<string, AcceptedAny>): string;
+export { jsx as jsxs, jsx as jsxDEV, Fragment };
+export declare namespace JSX {
+    /** Toute expression JSX retourne une chaîne HTML. */
+    type Element = string;
+    interface IntrinsicElements {
+        [elemName: string]: AcceptedAny;
+    }
+    interface ElementChildrenAttribute {
+        children: unknown;
+    }
+}
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist/core/scripts/jsx/jsx-runtime.js

@@ -0,0 +1,10 @@
+import { h, Fragment } from './index';
+/**
+ * Runtime JSX automatique (`jsx: "react-jsx"`) : `jsx(type, props, key)`.
+ * Les enfants sont dans `props.children` ; `key` n'a pas de sens pour du HTML en chaîne.
+ */
+export function jsx(type, props) {
+    return h(type, props);
+}
+export { jsx as jsxs, jsx as jsxDEV, Fragment };
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/core/scripts/utils/DateUtils.d.ts

@@ -0,0 +1,71 @@
+export { DateUtils };
+export type { DateLocale };
+/** Locale d'affichage : code `Intl` (`fr`, `en`, `fr-FR`, ou `fr_FR`). */
+type DateLocale = string;
+/**
+ * Utilitaires de date : formatage par tokens, parsing et calculs, sans dépendance externe.
+ *
+ * @remarks
+ * Tokens de format :
+ * - `P` / `PP` / `PPP` / `PPPP` : formats `Intl` court, moyen, long, complet
+ * - `yyyy`, `yy` : année sur 4 / 2 chiffres
+ * - `M`, `MM`, `MMM`, `MMMM` : mois numérique, avec zéro initial, abrégé, complet
+ * - `d`, `dd` : jour du mois sans / avec zéro initial
+ * - `E` (à `EEE`), `EEEE` : jour de la semaine abrégé / complet
+ * - `H`, `HH`, `m`, `mm`, `s`, `ss` : heures (0-23), minutes, secondes
+ *
+ * Le parsing (`parse`) ne gère que les tokens numériques.
+ */
+declare abstract class DateUtils {
+    /** Locale utilisée quand aucune n'est fournie. */
+    static readonly DEFAULT_LOCALE: DateLocale;
+    /** Format utilisé quand aucun n'est fourni. */
+    static readonly DEFAULT_FORMAT = "P";
+    /** Format spécial : date relative à maintenant (« il y a 3 jours »). */
+    static readonly RELATIVE_FORMAT = "relative";
+    /**
+     * Date relative à maintenant, avec `Intl.RelativeTimeFormat` (`numeric: 'auto'` : « hier », « demain »).
+     *
+     * @param date - Date à situer.
+     * @param locale - Locale `Intl` (déjà normalisée ou non).
+     * @returns Le texte, ex. « il y a 3 jours », « dans 2 heures ».
+     */
+    static relative(date: Date, locale?: DateLocale): string;
+    /** Convertit `fr_FR` en `fr-FR` et vérifie la locale.
+     * @throws {RangeError} Si la locale n'est pas valide. */
+    static normalizeLocale(locale: DateLocale): string;
+    /** `true` si `date` est une date valide. */
+    static isValid(date: unknown): date is Date;
+    /**
+     * Formate une date selon un format à tokens.
+     *
+     * @param date - Date à formater.
+     * @param format - Format (ex. `dd/MM/yyyy HH:mm`, `PPPP`).
+     * @param locale - Locale d'affichage.
+     * @throws {RangeError} Si la date ou la locale est invalide.
+     */
+    static format(date: Date, format: string, locale?: DateLocale): string;
+    /**
+     * Analyse une chaîne selon un format à tokens numériques.
+     *
+     * @param input - Texte à analyser (ex. `12/08/1997`).
+     * @param format - Format (ex. `dd/MM/yyyy`).
+     * @returns La date, ou `null` si le texte ne correspond pas, si le format contient un token non
+     * numérique, ou si la date n'existe pas (ex. `31/02`).
+     */
+    static parse(input: string, format: string): Date | null;
+    /**
+     * Analyse une date sans format : `now`, ISO 8601 ou tout ce que `Date` accepte.
+     * Une date seule (`1997-08-12`) est lue en heure locale, pas en UTC, pour ne pas décaler le jour.
+     */
+    static parseAuto(input: string): Date | null;
+    /** Date locale au format ISO `yyyy-MM-ddTHH:mm:ss` (valeur de l'attribut `datetime` de `<time>`). */
+    static toISODate(date: Date): string;
+    /** Nouvelle date décalée de `days` jours. */
+    static addDays(date: Date, days: number): Date;
+    /** Nouvelle date décalée de `months` mois (le jour est borné au dernier jour du mois). */
+    static addMonths(date: Date, months: number): Date;
+    /** Nouvelle date décalée de `years` années. */
+    static addYears(date: Date, years: number): Date;
+}
+//# sourceMappingURL=DateUtils.d.ts.map

package/dist/core/scripts/utils/DateUtils.js

@@ -0,0 +1,209 @@
+export { DateUtils };
+/** Découpe un format en tokens ; un texte entre `'…'` ou tout autre caractère est littéral. */
+const TOKEN_REGEX = /'([^']*)'|P{1,4}|y{4}|y{2}|M{1,4}|d{1,2}|E{1,4}|H{1,2}|m{1,2}|s{1,2}/g;
+/** Unités de la date relative, de la plus grande à la plus petite (durée en secondes). */
+const RELATIVE_UNITS = [
+    ['year', 31536000],
+    ['month', 2592000],
+    ['week', 604800],
+    ['day', 86400],
+    ['hour', 3600],
+    ['minute', 60],
+];
+const DATE_STYLES = {
+    P: 'short',
+    PP: 'medium',
+    PPP: 'long',
+    PPPP: 'full',
+};
+const pad = (value, length = 2) => String(value).padStart(length, '0');
+/**
+ * Utilitaires de date : formatage par tokens, parsing et calculs, sans dépendance externe.
+ *
+ * @remarks
+ * Tokens de format :
+ * - `P` / `PP` / `PPP` / `PPPP` : formats `Intl` court, moyen, long, complet
+ * - `yyyy`, `yy` : année sur 4 / 2 chiffres
+ * - `M`, `MM`, `MMM`, `MMMM` : mois numérique, avec zéro initial, abrégé, complet
+ * - `d`, `dd` : jour du mois sans / avec zéro initial
+ * - `E` (à `EEE`), `EEEE` : jour de la semaine abrégé / complet
+ * - `H`, `HH`, `m`, `mm`, `s`, `ss` : heures (0-23), minutes, secondes
+ *
+ * Le parsing (`parse`) ne gère que les tokens numériques.
+ */
+class DateUtils {
+    /** Locale utilisée quand aucune n'est fournie. */
+    static DEFAULT_LOCALE = 'fr';
+    /** Format utilisé quand aucun n'est fourni. */
+    static DEFAULT_FORMAT = 'P';
+    /** Format spécial : date relative à maintenant (« il y a 3 jours »). */
+    static RELATIVE_FORMAT = 'relative';
+    /**
+     * Date relative à maintenant, avec `Intl.RelativeTimeFormat` (`numeric: 'auto'` : « hier », « demain »).
+     *
+     * @param date - Date à situer.
+     * @param locale - Locale `Intl` (déjà normalisée ou non).
+     * @returns Le texte, ex. « il y a 3 jours », « dans 2 heures ».
+     */
+    static relative(date, locale = DateUtils.DEFAULT_LOCALE) {
+        const rtf = new Intl.RelativeTimeFormat(DateUtils.normalizeLocale(locale), { numeric: 'auto' });
+        const diff = (date.getTime() - Date.now()) / 1000;
+        for (const [unit, seconds] of RELATIVE_UNITS) {
+            if (Math.abs(diff) >= seconds)
+                return rtf.format(Math.round(diff / seconds), unit);
+        }
+        return rtf.format(Math.round(diff), 'second');
+    }
+    /** Convertit `fr_FR` en `fr-FR` et vérifie la locale.
+     * @throws {RangeError} Si la locale n'est pas valide. */
+    static normalizeLocale(locale) {
+        const normalized = locale.replace(/_/g, '-');
+        Intl.getCanonicalLocales(normalized);
+        return normalized;
+    }
+    /** `true` si `date` est une date valide. */
+    static isValid(date) {
+        return date instanceof Date && !Number.isNaN(date.getTime());
+    }
+    /**
+     * Formate une date selon un format à tokens.
+     *
+     * @param date - Date à formater.
+     * @param format - Format (ex. `dd/MM/yyyy HH:mm`, `PPPP`).
+     * @param locale - Locale d'affichage.
+     * @throws {RangeError} Si la date ou la locale est invalide.
+     */
+    static format(date, format, locale = DateUtils.DEFAULT_LOCALE) {
+        if (!DateUtils.isValid(date))
+            throw new RangeError('Date invalide');
+        const tag = DateUtils.normalizeLocale(locale);
+        if (format === DateUtils.RELATIVE_FORMAT)
+            return DateUtils.relative(date, tag);
+        const intl = (options) => new Intl.DateTimeFormat(tag, options).format(date);
+        return format.replace(TOKEN_REGEX, (token, literal) => {
+            if (literal !== undefined)
+                return literal;
+            if (token[0] === 'P')
+                return intl({ dateStyle: DATE_STYLES[token] });
+            switch (token) {
+                case 'yyyy':
+                    return pad(date.getFullYear(), 4);
+                case 'yy':
+                    return pad(date.getFullYear() % 100);
+                case 'M':
+                    return String(date.getMonth() + 1);
+                case 'MM':
+                    return pad(date.getMonth() + 1);
+                case 'MMM':
+                    return intl({ month: 'short' });
+                case 'MMMM':
+                    return intl({ month: 'long' });
+                case 'd':
+                    return String(date.getDate());
+                case 'dd':
+                    return pad(date.getDate());
+                case 'EEEE':
+                    return intl({ weekday: 'long' });
+                case 'H':
+                    return String(date.getHours());
+                case 'HH':
+                    return pad(date.getHours());
+                case 'm':
+                    return String(date.getMinutes());
+                case 'mm':
+                    return pad(date.getMinutes());
+                case 's':
+                    return String(date.getSeconds());
+                case 'ss':
+                    return pad(date.getSeconds());
+                default: // E, EE, EEE
+                    return intl({ weekday: 'short' });
+            }
+        });
+    }
+    /**
+     * Analyse une chaîne selon un format à tokens numériques.
+     *
+     * @param input - Texte à analyser (ex. `12/08/1997`).
+     * @param format - Format (ex. `dd/MM/yyyy`).
+     * @returns La date, ou `null` si le texte ne correspond pas, si le format contient un token non
+     * numérique, ou si la date n'existe pas (ex. `31/02`).
+     */
+    static parse(input, format) {
+        const order = [];
+        let unsupported = false;
+        let last = 0;
+        let pattern = '^';
+        const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        for (const match of format.matchAll(TOKEN_REGEX)) {
+            const token = match[0];
+            pattern += escape(format.slice(last, match.index));
+            last = match.index + token.length;
+            if (/^(P+|M{3,}|E+)$/.test(token))
+                unsupported = true;
+            order.push(token);
+            pattern += token === 'yyyy' ? '(\\d{4})' : token.length === 2 ? '(\\d{2})' : '(\\d{1,2})';
+        }
+        if (unsupported || order.length === 0)
+            return null;
+        pattern += `${escape(format.slice(last))}$`;
+        const found = new RegExp(pattern).exec(input.trim());
+        if (!found)
+            return null;
+        const parts = { y: 1970, M: 1, d: 1, H: 0, m: 0, s: 0 };
+        order.forEach((token, index) => {
+            const value = Number(found[index + 1]);
+            const key = token[0];
+            parts[key] = token === 'yy' ? (value < 70 ? 2000 + value : 1900 + value) : value;
+        });
+        const date = new Date(parts.y, parts.M - 1, parts.d, parts.H, parts.m, parts.s);
+        // Rejette les débordements (31/02 -> 03/03).
+        const exact = date.getFullYear() === parts.y &&
+            date.getMonth() === parts.M - 1 &&
+            date.getDate() === parts.d &&
+            date.getHours() === parts.H &&
+            date.getMinutes() === parts.m &&
+            date.getSeconds() === parts.s;
+        return exact ? date : null;
+    }
+    /**
+     * Analyse une date sans format : `now`, ISO 8601 ou tout ce que `Date` accepte.
+     * Une date seule (`1997-08-12`) est lue en heure locale, pas en UTC, pour ne pas décaler le jour.
+     */
+    static parseAuto(input) {
+        const text = input.trim();
+        if (text === 'now')
+            return new Date();
+        const dateOnly = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+        const date = dateOnly
+            ? new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]))
+            : new Date(text);
+        return DateUtils.isValid(date) ? date : null;
+    }
+    /** Date locale au format ISO `yyyy-MM-ddTHH:mm:ss` (valeur de l'attribut `datetime` de `<time>`). */
+    static toISODate(date) {
+        return (`${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+            `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`);
+    }
+    /** Nouvelle date décalée de `days` jours. */
+    static addDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+    /** Nouvelle date décalée de `months` mois (le jour est borné au dernier jour du mois). */
+    static addMonths(date, months) {
+        const result = new Date(date);
+        const day = result.getDate();
+        result.setDate(1);
+        result.setMonth(result.getMonth() + months);
+        const lastDay = new Date(result.getFullYear(), result.getMonth() + 1, 0).getDate();
+        result.setDate(Math.min(day, lastDay));
+        return result;
+    }
+    /** Nouvelle date décalée de `years` années. */
+    static addYears(date, years) {
+        return DateUtils.addMonths(date, years * 12);
+    }
+}
+//# sourceMappingURL=DateUtils.js.map

package/dist/core/scripts/utils/Log.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Journalisation minimale, préfixée par une étiquette.
+ */
+export declare abstract class Log {
+    /**
+     * Journalise un avertissement.
+     *
+     * @param tag - Étiquette de la source (ex. `@Listen`).
+     * @param message - Message.
+     * @param data - Données complémentaires.
+     */
+    static warn(tag: string, message: string, ...data: unknown[]): void;
+    /**
+     * Journalise une erreur.
+     *
+     * @param tag - Étiquette de la source (ex. `@Listener`).
+     * @param message - Message.
+     * @param data - Données complémentaires.
+     */
+    static error(tag: string, message: string, ...data: unknown[]): void;
+}
+//# sourceMappingURL=Log.d.ts.map

package/dist/core/scripts/utils/Log.js

@@ -0,0 +1,26 @@
+/**
+ * Journalisation minimale, préfixée par une étiquette.
+ */
+export class Log {
+    /**
+     * Journalise un avertissement.
+     *
+     * @param tag - Étiquette de la source (ex. `@Listen`).
+     * @param message - Message.
+     * @param data - Données complémentaires.
+     */
+    static warn(tag, message, ...data) {
+        console.warn(`[${tag}] ${message}`, ...data);
+    }
+    /**
+     * Journalise une erreur.
+     *
+     * @param tag - Étiquette de la source (ex. `@Listener`).
+     * @param message - Message.
+     * @param data - Données complémentaires.
+     */
+    static error(tag, message, ...data) {
+        console.error(`[${tag}] ${message}`, ...data);
+    }
+}
+//# sourceMappingURL=Log.js.map