@blackcube/aurelia2-bleet 1.0.0

package/dist/index.es.js

@@ -0,0 +1,4514 @@
+import { DI, resolve, ILogger, IPlatform, customAttribute, IEventAggregator, INode, bindable, customElement, queueTask } from 'aurelia';
+import { IHttpClient } from '@aurelia/fetch-client';
+import Resumable from 'resumablejs';
+import Quill from 'quill';
+
+var Transport;
+(function (Transport) {
+    Transport["Socketio"] = "socketio";
+    Transport["Http"] = "http";
+})(Transport || (Transport = {}));
+
+const IBleetConfiguration = DI.createInterface('IBleetConfiguration', x => x.singleton(Configure));
+class Configure {
+    _config = {
+        transports: Transport.Http,
+        csrf: {
+            enabled: true,
+            metaName: 'csrf',
+            headerName: 'X-CSRF-Token',
+        }
+    };
+    _container = null;
+    _transportInterfaces = new Map();
+    setContainer(container) {
+        this._container = container;
+    }
+    getContainer() {
+        return this._container;
+    }
+    registerTransportInterface(type, iface) {
+        this._transportInterfaces.set(type, iface);
+    }
+    getCsrfConfig() {
+        return this._config.csrf ?? { enabled: true, metaName: 'csrf', headerName: 'X-CSRF-Token' };
+    }
+    getConfig() {
+        return this._config;
+    }
+    get(key) {
+        return this._config[key];
+    }
+    set(key, val) {
+        this._config[key] = val;
+        return val;
+    }
+    getTransports() {
+        const cfg = this._config.transports ?? Transport.Http;
+        const entries = Array.isArray(cfg) ? cfg : [cfg];
+        return entries.map(entry => this.isTransportWithConfig(entry) ? entry.type : entry);
+    }
+    getBaseUrl(transport) {
+        const cfg = this._config.transports ?? Transport.Http;
+        const entries = Array.isArray(cfg) ? cfg : [cfg];
+        const entry = entries.find(e => this.isTransportWithConfig(e) ? e.type === transport : e === transport);
+        if (entry && this.isTransportWithConfig(entry) && entry.baseUrl !== undefined) {
+            return entry.baseUrl;
+        }
+        return this._config.baseUrl ?? '';
+    }
+    isTransportWithConfig(entry) {
+        return typeof entry === 'object' && 'type' in entry;
+    }
+    getTransport(type) {
+        if (!this._container) {
+            return null;
+        }
+        // HTTP : déjà enregistré
+        const iface = this._transportInterfaces.get(type);
+        if (iface) {
+            return this._container.get(iface);
+        }
+        // Socketio : require() synchrone à la demande
+        if (type === Transport.Socketio) {
+            try {
+                const { ISocketioService } = require('./services/socketio-service');
+                this._transportInterfaces.set(type, ISocketioService);
+                return this._container.get(ISocketioService);
+            }
+            catch (e) {
+                throw new Error('Transport Socketio configuré mais socket.io-client non installé. ' +
+                    'Installez-le avec : npm install socket.io-client');
+            }
+        }
+        return null;
+    }
+    getAvailableTransports() {
+        return this.getTransports()
+            .map(t => this.getTransport(t))
+            .filter((t) => t !== null);
+    }
+}
+
+const IHttpService = DI.createInterface('IHttpService', (x) => x.singleton(HttpService));
+class HttpService {
+    logger;
+    httpClient;
+    config;
+    type = Transport.Http;
+    constructor(logger = resolve(ILogger).scopeTo('HttpService'), httpClient = resolve(IHttpClient), config = resolve(IBleetConfiguration)) {
+        this.logger = logger;
+        this.httpClient = httpClient;
+        this.config = config;
+        this.logger.trace('constructor');
+        this.httpClient.configure((config) => {
+            config.withDefaults({
+                headers: {
+                    'X-Requested-With': 'XMLHttpRequest',
+                },
+                credentials: 'include'
+            });
+            return config;
+        });
+    }
+    isAvailable() {
+        return true;
+    }
+    prepareRequest(ctx) {
+        const baseUrl = this.config.getBaseUrl(Transport.Http);
+        let url = baseUrl + ctx.url;
+        const pathParams = ctx.pathParams ?? {};
+        // FormData: don't try to extract path params from it, keep as-is
+        if (ctx.data instanceof FormData) {
+            // Substitute :params in URL from pathParams only
+            const paramPattern = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+            const matches = ctx.url.match(paramPattern) ?? [];
+            for (const match of matches) {
+                const paramName = match.slice(1);
+                if (paramName in pathParams) {
+                    url = url.replace(match, encodeURIComponent(String(pathParams[paramName])));
+                }
+            }
+            return {
+                url,
+                method: ctx.method,
+                headers: ctx.headers,
+                data: ctx.data
+            };
+        }
+        const remainingData = { ...ctx.data };
+        // Substitute :params in URL (explicit > implicit) and remove from payload
+        const paramPattern = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+        const matches = ctx.url.match(paramPattern) ?? [];
+        for (const match of matches) {
+            const paramName = match.slice(1);
+            const value = paramName in pathParams ? pathParams[paramName] : remainingData[paramName];
+            url = url.replace(match, encodeURIComponent(String(value)));
+            delete remainingData[paramName];
+        }
+        return {
+            url,
+            method: ctx.method,
+            headers: ctx.headers,
+            data: remainingData
+        };
+    }
+    execute(ctx, responseType = 'json') {
+        this.logger.trace('execute', ctx.method, ctx.url);
+        const hasBody = ['POST', 'PATCH', 'PUT', 'DELETE'].includes(ctx.method.toUpperCase());
+        const headers = { ...ctx.headers };
+        const init = {
+            method: ctx.method.toUpperCase(),
+        };
+        if (hasBody && ctx.data) {
+            if (ctx.data instanceof FormData) {
+                // FormData: don't set Content-Type, browser will set it with boundary
+                delete headers['Content-Type'];
+                init.body = ctx.data;
+            }
+            else if (Object.keys(ctx.data).length > 0) {
+                init.body = JSON.stringify(ctx.data);
+            }
+        }
+        init.headers = headers;
+        return this.httpClient.fetch(ctx.url, init)
+            .then((response) => this.parseResponse(response, responseType));
+    }
+    parseResponse(response, responseType) {
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const effectiveType = responseType === 'auto'
+            ? this.detectResponseType(response.headers.get('Content-Type'))
+            : responseType;
+        return this.parseBody(response, effectiveType)
+            .then((body) => ({
+            statusCode: response.status,
+            headers,
+            body
+        }));
+    }
+    detectResponseType(contentType) {
+        if (!contentType) {
+            return 'text';
+        }
+        const ct = contentType.toLowerCase();
+        if (ct.includes('application/json')) {
+            return 'json';
+        }
+        if (ct.startsWith('text/')) {
+            return 'text';
+        }
+        if (ct.includes('application/')) {
+            return 'blob';
+        }
+        return 'text';
+    }
+    parseBody(response, responseType) {
+        switch (responseType) {
+            case 'json':
+                return response.json();
+            case 'text':
+                return response.text();
+            case 'blob':
+                return response.blob();
+            case 'arraybuffer':
+                return response.arrayBuffer();
+            default:
+                return response.json();
+        }
+    }
+}
+
+const ISvgService = /*@__PURE__*/ DI.createInterface('ISvgService', (x) => x.singleton(SvgService));
+class SvgService {
+    logger;
+    static ICONS = {
+        'information-circle': `<svg class="size-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path fill-rule="evenodd" d="M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm8.706-1.442c1.146-.573 2.437.463 2.126 1.706l-.709 2.836.042-.02a.75.75 0 0 1 .67 1.34l-.04.022c-1.147.573-2.438-.463-2.127-1.706l.71-2.836-.042.02a.75.75 0 1 1-.671-1.34l.041-.022ZM12 9a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z" clip-rule="evenodd"/></svg>`,
+        'check-circle': `<svg class="size-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path fill-rule="evenodd" d="M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm13.36-1.814a.75.75 0 1 0-1.22-.872l-3.236 4.53L9.53 12.22a.75.75 0 0 0-1.06 1.06l2.25 2.25a.75.75 0 0 0 1.14-.094l3.75-5.25Z" clip-rule="evenodd"/></svg>`,
+        'exclamation-triangle': `<svg class="size-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path fill-rule="evenodd" d="M9.401 3.003c1.155-2 4.043-2 5.197 0l7.355 12.748c1.154 2-.29 4.5-2.599 4.5H4.645c-2.309 0-3.752-2.5-2.598-4.5L9.4 3.003ZM12 8.25a.75.75 0 0 1 .75.75v3.75a.75.75 0 0 1-1.5 0V9a.75.75 0 0 1 .75-.75Zm0 8.25a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z" clip-rule="evenodd"/></svg>`,
+        'x-circle': `<svg class="size-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path fill-rule="evenodd" d="M12 2.25c-5.385 0-9.75 4.365-9.75 9.75s4.365 9.75 9.75 9.75 9.75-4.365 9.75-9.75S17.385 2.25 12 2.25Zm-1.72 6.97a.75.75 0 1 0-1.06 1.06L10.94 12l-1.72 1.72a.75.75 0 1 0 1.06 1.06L12 13.06l1.72 1.72a.75.75 0 1 0 1.06-1.06L13.06 12l1.72-1.72a.75.75 0 1 0-1.06-1.06L12 10.94l-1.72-1.72Z" clip-rule="evenodd"/></svg>`,
+        'x-mark': `<svg class="size-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path fill-rule="evenodd" d="M5.47 5.47a.75.75 0 0 1 1.06 0L12 10.94l5.47-5.47a.75.75 0 1 1 1.06 1.06L13.06 12l5.47 5.47a.75.75 0 1 1-1.06 1.06L12 13.06l-5.47 5.47a.75.75 0 0 1-1.06-1.06L10.94 12 5.47 6.53a.75.75 0 0 1 0-1.06Z" clip-rule="evenodd"/></svg>`,
+    };
+    constructor(logger = resolve(ILogger).scopeTo('SvgService')) {
+        this.logger = logger;
+        this.logger.trace('constructor');
+    }
+    /**
+     * Retourne le SVG pour une icône
+     * @param icon Clé heroicon (ex: 'check-circle') ou SVG inline custom
+     * @returns Le SVG du map si clé connue, sinon retourne icon tel quel (SVG custom)
+     */
+    get(icon) {
+        this.logger.trace('get', icon);
+        if (!icon)
+            return null;
+        return SvgService.ICONS[icon] ?? icon;
+    }
+    has(key) {
+        return key in SvgService.ICONS;
+    }
+}
+
+class CsrfCodec {
+    static codec = {
+        encode: (ctx) => {
+            const meta = document.querySelector('meta[name="csrf"]');
+            const token = meta?.getAttribute('content');
+            if (!token) {
+                return Promise.resolve(ctx);
+            }
+            return Promise.resolve({
+                ...ctx,
+                headers: {
+                    ...ctx.headers,
+                    'X-CSRF-Token': token,
+                }
+            });
+        }
+    };
+    static fromConfig(config) {
+        return {
+            encode: (ctx) => {
+                const meta = document.querySelector(`meta[name="${config.metaName}"]`);
+                const token = meta?.getAttribute('content');
+                if (!token) {
+                    return Promise.resolve(ctx);
+                }
+                return Promise.resolve({
+                    ...ctx,
+                    headers: {
+                        ...ctx.headers,
+                        [config.headerName]: token,
+                    }
+                });
+            }
+        };
+    }
+}
+
+const IApiService = /*@__PURE__*/ DI.createInterface('IApiService', (x) => x.singleton(ApiService));
+class ApiService {
+    logger;
+    config;
+    static PARAM_PATTERN = /:[a-zA-Z_][a-zA-Z0-9_-]*/g;
+    memoryCache = new Map();
+    constructor(logger = resolve(ILogger).scopeTo('ApiService'), config = resolve(IBleetConfiguration)) {
+        this.logger = logger;
+        this.config = config;
+        this.logger.trace('constructor');
+    }
+    url(path, params) {
+        return new ApiRequestBuilder(this, path, params);
+    }
+    /**
+     * Simple HTML fetch for AJAX dialogs (modal/drawer)
+     * Returns full response for status code checking
+     */
+    async fetchHtml(url) {
+        this.logger.trace('fetchHtml', url);
+        return this.url(url).toText().get();
+    }
+    execute(request) {
+        this.logger.trace('execute', request.method, request.url);
+        // 1. Validate path params are present in pathParams or data
+        this.validateParams(request.url, request.pathParams, request.data);
+        // 2. Build request context
+        const initialCtx = {
+            url: request.url,
+            method: request.method,
+            headers: request.headers,
+            data: request.data,
+            pathParams: request.pathParams
+        };
+        // 3. Build codec chain : CSRF auto + user codecs
+        const csrfConfig = this.config.getCsrfConfig();
+        const allInputCodecs = [];
+        if (csrfConfig.enabled) {
+            allInputCodecs.push(CsrfCodec.fromConfig(csrfConfig));
+        }
+        allInputCodecs.push(...request.inputCodecs);
+        // 4. Apply input codecs (encode) — chaîne de promesses
+        const ctxPromise = allInputCodecs.reduce((promise, codec) => codec.encode ? promise.then((ctx) => codec.encode(ctx)) : promise, Promise.resolve(initialCtx));
+        return ctxPromise.then((ctx) => {
+            // 4. Check cache
+            if (request.cache) {
+                const cached = this.getFromCache(request, ctx);
+                if (cached) {
+                    this.logger.trace('execute:cache-hit');
+                    return Promise.resolve(cached);
+                }
+            }
+            // 5. Execute via transport avec fallback
+            return this.executeWithFallback(ctx, request.responseType)
+                .then((response) => {
+                // 6. Apply output codecs (decode)
+                return request.outputCodecs.reduce((promise, codec) => codec.decode ? promise.then((r) => codec.decode(r)) : promise, Promise.resolve(response));
+            })
+                .then((response) => {
+                // 7. Store in cache
+                if (request.cache) {
+                    this.storeInCache(request, ctx, response);
+                }
+                return response;
+            });
+        });
+    }
+    executeWithFallback(ctx, responseType) {
+        const transports = this.config.getAvailableTransports();
+        if (transports.length === 0) {
+            return Promise.reject(new Error('No transport available'));
+        }
+        const tryTransport = (index, lastError) => {
+            if (index >= transports.length) {
+                return Promise.reject(lastError ?? new Error('All transports failed'));
+            }
+            const transport = transports[index];
+            if (!transport.isAvailable()) {
+                this.logger.trace('execute:transport-unavailable', transport.type);
+                return tryTransport(index + 1, lastError);
+            }
+            this.logger.trace('execute:trying', transport.type);
+            const preparedCtx = transport.prepareRequest(ctx);
+            return transport.execute(preparedCtx, responseType)
+                .catch((error) => {
+                this.logger.warn('execute:transport-failed', transport.type, error);
+                return tryTransport(index + 1, error);
+            });
+        };
+        return tryTransport(0, null);
+    }
+    validateParams(url, pathParams, data) {
+        const matches = url.match(ApiService.PARAM_PATTERN) ?? [];
+        for (const match of matches) {
+            const paramName = match.slice(1);
+            const inPathParams = pathParams !== undefined && paramName in pathParams;
+            const inData = data !== undefined && paramName in data;
+            if (!inPathParams && !inData) {
+                throw new Error(`Missing path param '${match}'`);
+            }
+        }
+    }
+    genCacheKey(request, ctx) {
+        const parts = [
+            request.method,
+            ctx.url,
+            JSON.stringify(ctx.data ?? {}),
+            request.pagination?.page ?? 0
+        ];
+        return 'api-cache:' + btoa(parts.join('|')).slice(0, 24);
+    }
+    getFromCache(request, ctx) {
+        const key = this.genCacheKey(request, ctx);
+        const storage = request.cache?.storage ?? 'session';
+        let entry = null;
+        if (storage === 'session') {
+            const raw = sessionStorage.getItem(key);
+            entry = raw ? JSON.parse(raw) : null;
+        }
+        else {
+            entry = this.memoryCache.get(key) ?? null;
+        }
+        if (!entry) {
+            return null;
+        }
+        // Check TTL
+        if (entry.expires && Date.now() > entry.expires) {
+            if (storage === 'session') {
+                sessionStorage.removeItem(key);
+            }
+            else {
+                this.memoryCache.delete(key);
+            }
+            return null;
+        }
+        return entry.data;
+    }
+    storeInCache(request, ctx, response) {
+        const key = this.genCacheKey(request, ctx);
+        const storage = request.cache?.storage ?? 'session';
+        const ttl = request.cache?.ttl;
+        const entry = {
+            data: response,
+            expires: ttl ? Date.now() + (ttl * 1000) : null,
+            created: Date.now()
+        };
+        if (storage === 'session') {
+            sessionStorage.setItem(key, JSON.stringify(entry));
+        }
+        else {
+            this.memoryCache.set(key, entry);
+        }
+    }
+}
+class ApiRequestBuilder {
+    api;
+    _url;
+    _method = 'GET';
+    _data;
+    _pathParams;
+    _queryString = {};
+    _headers = {};
+    _inputCodecs = [];
+    _outputCodecs = [];
+    _pagination = null;
+    _cache = null;
+    _contentType = 'application/json';
+    _accept = 'application/json';
+    _responseType = 'auto';
+    constructor(api, path, pathParams) {
+        this.api = api;
+        this._url = path;
+        this._pathParams = pathParams;
+    }
+    // Query string
+    queryString(params) {
+        this._queryString = { ...this._queryString, ...params };
+        return this;
+    }
+    // Format entrée
+    fromJson(data) {
+        this._contentType = 'application/json';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+    fromForm(data) {
+        this._contentType = 'application/x-www-form-urlencoded';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+    fromMultipart(data) {
+        this._contentType = 'multipart/form-data';
+        if (data !== undefined) {
+            this._data = data;
+        }
+        return this;
+    }
+    // Format sortie
+    toJson() {
+        this._accept = 'application/json';
+        this._responseType = 'json';
+        return this;
+    }
+    toXls() {
+        this._accept = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        this._responseType = 'blob';
+        return this;
+    }
+    toBlob() {
+        this._accept = 'application/octet-stream';
+        this._responseType = 'blob';
+        return this;
+    }
+    toText() {
+        this._accept = 'text/plain';
+        this._responseType = 'text';
+        return this;
+    }
+    toArrayBuffer() {
+        this._accept = 'application/octet-stream';
+        this._responseType = 'arraybuffer';
+        return this;
+    }
+    // Codecs
+    withInputCodec(codec) {
+        this._inputCodecs.push(codec);
+        return this;
+    }
+    withOutputCodec(codec) {
+        this._outputCodecs.push(codec);
+        return this;
+    }
+    // Pagination & Cache
+    withPagination(config) {
+        this._pagination = { pageSize: 20, ...config };
+        return this;
+    }
+    withCache(config) {
+        this._cache = { storage: 'session', ...config };
+        return this;
+    }
+    // Execution
+    get() {
+        this._method = 'GET';
+        return this.api.execute(this.build());
+    }
+    post() {
+        this._method = 'POST';
+        return this.api.execute(this.build());
+    }
+    put() {
+        this._method = 'PUT';
+        return this.api.execute(this.build());
+    }
+    patch() {
+        this._method = 'PATCH';
+        return this.api.execute(this.build());
+    }
+    delete() {
+        this._method = 'DELETE';
+        return this.api.execute(this.build());
+    }
+    request(verb) {
+        this._method = verb.toUpperCase();
+        return this.api.execute(this.build());
+    }
+    build() {
+        return {
+            url: this.appendQueryString(this._url),
+            method: this._method,
+            headers: {
+                'Content-Type': this._contentType,
+                'Accept': this._accept,
+                ...this._headers
+            },
+            data: this._data,
+            pathParams: this._pathParams,
+            responseType: this._responseType,
+            inputCodecs: this._inputCodecs,
+            outputCodecs: this._outputCodecs,
+            pagination: this._pagination,
+            cache: this._cache
+        };
+    }
+    appendQueryString(url) {
+        if (Object.keys(this._queryString).length === 0) {
+            return url;
+        }
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(this._queryString)) {
+            if (value !== undefined && value !== null) {
+                params.append(key, String(value));
+            }
+        }
+        const qs = params.toString();
+        if (!qs) {
+            return url;
+        }
+        return url.includes('?') ? `${url}&${qs}` : `${url}?${qs}`;
+    }
+}
+
+// io sera chargé à la demande via require()
+let io = null;
+function getSocketIo() {
+    if (!io) {
+        try {
+            io = require('socket.io-client').io;
+        }
+        catch {
+            throw new Error('socket.io-client non installé. ' +
+                'Installez-le avec : npm install socket.io-client');
+        }
+    }
+    return io;
+}
+const ISocketioService = DI.createInterface('ISocketioService', (x) => x.singleton(SocketioService));
+class SocketioService {
+    logger;
+    config;
+    type = Transport.Socketio;
+    timeout = 5000;
+    socket = null;
+    connected = false;
+    constructor(logger = resolve(ILogger).scopeTo('SocketioService'), config = resolve(IBleetConfiguration)) {
+        this.logger = logger;
+        this.config = config;
+        this.logger.trace('constructor');
+    }
+    isConnected() {
+        return this.connected && this.socket !== null;
+    }
+    isAvailable() {
+        return this.isConnected();
+    }
+    prepareRequest(ctx) {
+        return {
+            ...ctx,
+            data: { ...ctx.data, ...ctx.pathParams }
+        };
+    }
+    connect(namespace = '/', options) {
+        const baseUrl = this.config.getBaseUrl(Transport.Socketio);
+        const url = baseUrl + namespace;
+        this.logger.trace('connect', url);
+        if (this.socket !== null) {
+            this.logger.warn('connect:already-connected');
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const socketIo = getSocketIo();
+            this.socket = socketIo(url, {
+                transports: ['websocket'],
+                ...options
+            });
+            this.socket.on('connect', () => {
+                this.logger.trace('connect:success');
+                this.connected = true;
+                resolve();
+            });
+            this.socket.on('connect_error', (error) => {
+                this.logger.error('connect:error', error);
+                this.connected = false;
+                reject(error);
+            });
+            this.socket.on('disconnect', (reason) => {
+                this.logger.trace('disconnect', reason);
+                this.connected = false;
+            });
+        });
+    }
+    disconnect() {
+        this.logger.trace('disconnect');
+        if (this.socket !== null) {
+            this.socket.disconnect();
+            this.socket = null;
+            this.connected = false;
+        }
+    }
+    execute(ctx, responseType) {
+        this.logger.trace('execute', ctx.method, ctx.url);
+        if (!this.isConnected() || this.socket === null) {
+            return Promise.reject(new Error('Socket not connected'));
+        }
+        const channel = `${ctx.method.toLowerCase()}:${ctx.url}`;
+        let data = ctx.data ?? {};
+        // Convert FormData to plain object (Socket.io can't send FormData)
+        if (data instanceof FormData) {
+            const obj = {};
+            data.forEach((value, key) => {
+                // Skip File objects - can't be serialized for Socket.io
+                if (!(value instanceof File)) {
+                    obj[key] = value;
+                }
+            });
+            data = obj;
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error('Socket timeout'));
+            }, this.timeout);
+            this.socket.emit(channel, data, (response) => {
+                clearTimeout(timeoutId);
+                this.logger.trace('execute:response', channel, response);
+                resolve(response);
+            });
+        });
+    }
+}
+
+const IStorageService = /*@__PURE__*/ DI.createInterface('IStorageService', (x) => x.singleton(StorageService));
+class StorageService {
+    logger;
+    platform;
+    constructor(logger = resolve(ILogger).scopeTo('StorageService'), platform = resolve(IPlatform)) {
+        this.logger = logger;
+        this.platform = platform;
+        this.logger.trace('constructor');
+    }
+    load(key, def = null) {
+        this.logger.trace('load', key);
+        const value = localStorage.getItem(key);
+        if (value === null) {
+            return def;
+        }
+        return JSON.parse(value);
+    }
+    save(key, value) {
+        this.logger.trace('save', key, value);
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    remove(key) {
+        this.logger.trace('remove', key);
+        localStorage.removeItem(key);
+    }
+}
+
+const ITransitionService = /*@__PURE__*/ DI.createInterface('ITransitionService', (x) => x.singleton(TransitionService));
+class TransitionService {
+    logger;
+    platform;
+    securityTimeout = 2000;
+    constructor(logger = resolve(ILogger).scopeTo('TransitionService'), platform = resolve(IPlatform)) {
+        this.logger = logger;
+        this.platform = platform;
+        this.logger.trace('constructor');
+    }
+    run(element, before, after) {
+        let securityTimeout = undefined;
+        const endTransition = (evt) => {
+            if (securityTimeout !== undefined) {
+                this.platform.clearTimeout(securityTimeout);
+                securityTimeout = undefined;
+            }
+            element.removeEventListener('transitionend', endTransition);
+            if (after) {
+                this.logger.trace('after()');
+                after(element);
+            }
+        };
+        if (before) {
+            securityTimeout = this.platform.setTimeout(endTransition, this.securityTimeout);
+            element.addEventListener('transitionend', endTransition);
+            this.platform.requestAnimationFrame(() => {
+                this.logger.trace('before()');
+                before(element);
+            });
+        }
+    }
+}
+
+const ITrapFocusService = /*@__PURE__*/ DI.createInterface('ITrapFocusService', (x) => x.transient(TrapFocusService));
+class TrapFocusService {
+    logger;
+    platform;
+    focusableElementsQuerySelector = '[href], button, input, select, textarea, [tabindex]:not([tabindex="-1"]), [accesskey], summary, canvas, audio, video, details, iframe, [contenteditable]';
+    opener = null;
+    target = null;
+    globalElement = null;
+    startCallback = null;
+    stopCallback = null;
+    focusableElements = [];
+    lastFocusedElement = null;
+    started = false;
+    constructor(logger = resolve(ILogger).scopeTo('TrapFocusService'), platform = resolve(IPlatform)) {
+        this.logger = logger;
+        this.platform = platform;
+        this.logger.trace('constructor');
+    }
+    buildFocusableElements() {
+        this.focusableElements = [];
+        const focusableElements = this.target?.querySelectorAll(this.focusableElementsQuerySelector);
+        focusableElements?.forEach((element) => {
+            const isDisabled = element.hasAttribute('disabled');
+            const isAriaHidden = (element.getAttribute('aria-hidden') === 'true');
+            const isNotTabbable = (element.getAttribute('tabindex') === '-1');
+            if (isDisabled === false && isAriaHidden === false && isNotTabbable === false) {
+                this.focusableElements.push(element);
+            }
+        });
+    }
+    start(opener, target, globalElement, startCallback, stopCallback, initialFocusElement) {
+        this.logger.trace('start', opener, target);
+        this.startCallback = startCallback ?? null;
+        this.stopCallback = stopCallback ?? null;
+        this.opener = opener;
+        this.target = target;
+        this.globalElement = globalElement;
+        this.buildFocusableElements();
+        // Use provided initialFocusElement if valid, otherwise default to first focusable
+        if (initialFocusElement && this.focusableElements.includes(initialFocusElement)) {
+            this.lastFocusedElement = initialFocusElement;
+        }
+        else {
+            this.lastFocusedElement = this.focusableElements[0] || undefined;
+        }
+        this.logger.trace('start: add keydown listener');
+        this.platform.requestAnimationFrame(() => {
+            this.logger.trace('start: focus initial element', this.lastFocusedElement);
+            this.lastFocusedElement?.focus();
+        });
+        this.target.addEventListener('keydown', this.onKeyDown);
+        this.platform.document.addEventListener('click', this.onClickOutside);
+        this.started = true;
+        if (this.startCallback) {
+            const promise = this.startCallback();
+            if (promise && promise instanceof Promise) {
+                return promise;
+            }
+        }
+        return Promise.resolve();
+    }
+    stop() {
+        this.logger.trace('stop');
+        return new Promise((resolve, reject) => {
+            if (this.started) {
+                this.logger.trace('stop: remove keydown listener');
+                this.target?.removeEventListener('keydown', this.onKeyDown);
+                this.platform.document.removeEventListener('click', this.onClickOutside);
+                if (this.stopCallback) {
+                    const promise = this.stopCallback();
+                    if (promise && promise instanceof Promise) {
+                        this.platform.requestAnimationFrame(() => {
+                            this.opener?.focus();
+                            this.cleanup();
+                            promise.then((res) => {
+                                return resolve(res);
+                            });
+                        });
+                        return;
+                    }
+                    return resolve(void 0);
+                }
+                this.platform.requestAnimationFrame(() => {
+                    this.opener?.focus();
+                    this.cleanup();
+                    return resolve(void 0);
+                });
+                return;
+            }
+            return reject('TrapFocusService: not started');
+        });
+    }
+    cleanup() {
+        this.logger.trace('cleanup');
+        if (this.started) {
+            this.opener = null;
+            this.startCallback = null;
+            this.stopCallback = null;
+            this.target = null;
+            this.lastFocusedElement = null;
+            this.focusableElements = [];
+            this.started = false;
+        }
+    }
+    focusedElementIndex() {
+        let index = -1;
+        if (this.lastFocusedElement) {
+            index = this.focusableElements.indexOf(this.lastFocusedElement);
+        }
+        if (index === -1 && this.lastFocusedElement !== undefined) {
+            this.lastFocusedElement = null;
+        }
+        return index;
+    }
+    focusPreviousElement(loop = true) {
+        const currentIndex = this.focusedElementIndex();
+        if (currentIndex === -1) {
+            return null;
+        }
+        let changed = false;
+        if (currentIndex === 0 && loop === true) {
+            this.lastFocusedElement = this.focusableElements[this.focusableElements.length - 1];
+            changed = true;
+        }
+        else if (currentIndex > 0) {
+            this.lastFocusedElement = this.focusableElements[currentIndex - 1];
+            changed = true;
+        }
+        if (changed === true) {
+            this.platform.requestAnimationFrame(() => {
+                this.logger.trace('focusPreviousElement: focusing', this.lastFocusedElement);
+                this.lastFocusedElement?.focus();
+            });
+        }
+        return this.lastFocusedElement;
+    }
+    focusNextElement(loop = true) {
+        const currentIndex = this.focusedElementIndex();
+        if (currentIndex === -1) {
+            return null;
+        }
+        let changed = false;
+        if (currentIndex === this.focusableElements.length - 1 && loop === true) {
+            this.lastFocusedElement = this.focusableElements[0];
+            changed = true;
+        }
+        else if (currentIndex < this.focusableElements.length - 1) {
+            this.lastFocusedElement = this.focusableElements[currentIndex + 1];
+            changed = true;
+        }
+        if (changed === true) {
+            this.platform.requestAnimationFrame(() => {
+                this.logger.trace('focusNextElement: focusing', this.lastFocusedElement);
+                this.lastFocusedElement?.focus();
+            });
+        }
+        return this.lastFocusedElement;
+    }
+    onKeyDown = (event) => {
+        if (event.key === 'Tab') {
+            if (event.shiftKey) {
+                // shift + tab loop backwards
+                event.preventDefault();
+                this.lastFocusedElement = this.focusPreviousElement(true);
+            }
+            else {
+                // tab loop forwards
+                event.preventDefault();
+                this.lastFocusedElement = this.focusNextElement(true);
+            }
+        }
+        else if (event.key === 'ArrowUp') {
+            // up arrow, no loop
+            event.preventDefault();
+            this.lastFocusedElement = this.focusPreviousElement(false);
+        }
+        else if (event.key === 'ArrowDown') {
+            // down arrow, no loop
+            event.preventDefault();
+            this.lastFocusedElement = this.focusNextElement(false);
+        }
+        else if (event.key === 'Escape') {
+            // stop trap focus
+            event.preventDefault();
+            this.stop();
+        }
+    };
+    onClickOutside = (event) => {
+        this.logger.trace('onClickOutside', event);
+        if (this.started && this.globalElement && event.target) {
+            this.logger.trace('onClickOutside: checking if click is outside globalElement', event.target, this.globalElement);
+            if (!this.globalElement.contains(event.target)) {
+                this.stop();
+            }
+        }
+    };
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var Channels;
+(function (Channels) {
+    Channels["Overlay"] = "bleet:overlay";
+    Channels["OverlayStatus"] = "bleet:overlay:status";
+    Channels["Modal"] = "bleet:modal";
+    Channels["ModalStatus"] = "bleet:modal:status";
+    Channels["Drawer"] = "bleet:drawer";
+    Channels["DrawerStatus"] = "bleet:drawer:status";
+    Channels["Toaster"] = "bleet:toaster";
+    Channels["ToasterStatus"] = "bleet:toaster:status";
+    Channels["Menu"] = "bleet:menu";
+    Channels["MenuStatus"] = "bleet:menu:status";
+    Channels["Badge"] = "bleet:badge";
+    Channels["Profile"] = "bleet:profile";
+    Channels["ProfileStatus"] = "bleet:profile:status";
+    Channels["Ajaxify"] = "bleet:ajaxify";
+})(Channels || (Channels = {}));
+var OverlayAction;
+(function (OverlayAction) {
+    OverlayAction["Open"] = "open";
+    OverlayAction["Close"] = "close";
+    OverlayAction["Toggle"] = "toggle";
+})(OverlayAction || (OverlayAction = {}));
+var OverlayStatus;
+(function (OverlayStatus) {
+    OverlayStatus["Opening"] = "opening";
+    OverlayStatus["Closing"] = "closing";
+    OverlayStatus["Opened"] = "opened";
+    OverlayStatus["Closed"] = "closed";
+})(OverlayStatus || (OverlayStatus = {}));
+var ProfileAction;
+(function (ProfileAction) {
+    ProfileAction["Open"] = "open";
+    ProfileAction["Close"] = "close";
+    ProfileAction["Toggle"] = "toggle";
+})(ProfileAction || (ProfileAction = {}));
+var ProfileStatus;
+(function (ProfileStatus) {
+    ProfileStatus["Opening"] = "opening";
+    ProfileStatus["Closing"] = "closing";
+    ProfileStatus["Opened"] = "opened";
+    ProfileStatus["Closed"] = "closed";
+})(ProfileStatus || (ProfileStatus = {}));
+var ModalAction;
+(function (ModalAction) {
+    ModalAction["Open"] = "open";
+    ModalAction["Close"] = "close";
+    ModalAction["Toggle"] = "toggle";
+})(ModalAction || (ModalAction = {}));
+var ModalStatus;
+(function (ModalStatus) {
+    ModalStatus["Opening"] = "opening";
+    ModalStatus["Closing"] = "closing";
+    ModalStatus["Opened"] = "opened";
+    ModalStatus["Closed"] = "closed";
+})(ModalStatus || (ModalStatus = {}));
+var DrawerAction;
+(function (DrawerAction) {
+    DrawerAction["Open"] = "open";
+    DrawerAction["Close"] = "close";
+    DrawerAction["Toggle"] = "toggle";
+})(DrawerAction || (DrawerAction = {}));
+var DrawerStatus;
+(function (DrawerStatus) {
+    DrawerStatus["Opening"] = "opening";
+    DrawerStatus["Closing"] = "closing";
+    DrawerStatus["Opened"] = "opened";
+    DrawerStatus["Closed"] = "closed";
+})(DrawerStatus || (DrawerStatus = {}));
+var AjaxifyAction;
+(function (AjaxifyAction) {
+    AjaxifyAction["Refresh"] = "refresh";
+})(AjaxifyAction || (AjaxifyAction = {}));
+var ToasterAction;
+(function (ToasterAction) {
+    ToasterAction["Add"] = "add";
+    ToasterAction["Remove"] = "remove";
+})(ToasterAction || (ToasterAction = {}));
+var ToasterStatus;
+(function (ToasterStatus) {
+    ToasterStatus["Added"] = "added";
+    ToasterStatus["Removed"] = "removed";
+})(ToasterStatus || (ToasterStatus = {}));
+var MenuAction;
+(function (MenuAction) {
+    MenuAction["Open"] = "open";
+    MenuAction["Close"] = "close";
+    MenuAction["Toggle"] = "toggle";
+})(MenuAction || (MenuAction = {}));
+var BadgeAction;
+(function (BadgeAction) {
+    BadgeAction["Remove"] = "remove";
+})(BadgeAction || (BadgeAction = {}));
+var MenuStatus;
+(function (MenuStatus) {
+    MenuStatus["Opening"] = "opening";
+    MenuStatus["Closing"] = "closing";
+    MenuStatus["Opened"] = "opened";
+    MenuStatus["Closed"] = "closed";
+})(MenuStatus || (MenuStatus = {}));
+var UiColor;
+(function (UiColor) {
+    UiColor["Primary"] = "primary";
+    UiColor["Secondary"] = "secondary";
+    UiColor["Success"] = "success";
+    UiColor["Danger"] = "danger";
+    UiColor["Warning"] = "warning";
+    UiColor["Info"] = "info";
+    UiColor["Accent"] = "accent";
+})(UiColor || (UiColor = {}));
+var UiToastIcon;
+(function (UiToastIcon) {
+    UiToastIcon["Info"] = "information-circle";
+    UiToastIcon["Success"] = "check-circle";
+    UiToastIcon["Warning"] = "exclamation-triangle";
+    UiToastIcon["Danger"] = "x-circle";
+})(UiToastIcon || (UiToastIcon = {}));
+/**
+ * Icônes pour toasts et dialogs
+ * Double alias : court (Info) et long (InformationCircle) → même valeur
+ */
+var UiIcon;
+(function (UiIcon) {
+    // Alias courts (usage dev)
+    UiIcon["Info"] = "information-circle";
+    UiIcon["Success"] = "check-circle";
+    UiIcon["Warning"] = "exclamation-triangle";
+    UiIcon["Danger"] = "x-circle";
+    // Alias longs (match heroicon)
+    UiIcon["InformationCircle"] = "information-circle";
+    UiIcon["CheckCircle"] = "check-circle";
+    UiIcon["ExclamationTriangle"] = "exclamation-triangle";
+    UiIcon["XCircle"] = "x-circle";
+})(UiIcon || (UiIcon = {}));
+/**
+ * Actions primaires dialog (mutuellement exclusives)
+ */
+var DialogAction;
+(function (DialogAction) {
+    DialogAction["Keep"] = "keep";
+    DialogAction["Close"] = "close";
+    DialogAction["RefreshAndClose"] = "refreshAndClose";
+})(DialogAction || (DialogAction = {}));
+
+let BleetBurgerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-burger')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        ea;
+        element;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-burger'), ea = resolve(IEventAggregator), element = resolve(INode)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.element = element;
+            this.logger.trace('constructor');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.element.addEventListener('click', this.onClickButton);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener('click', this.onClickButton);
+        }
+        onClickButton = (event) => {
+            this.logger.trace('onClickButton', event);
+            event.preventDefault();
+            this.ea.publish(Channels.Menu, { action: MenuAction.Open });
+        };
+    });
+    return _classThis;
+})();
+
+let BleetMenuCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-menu')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        ea;
+        element;
+        platform;
+        transitionService;
+        storageService;
+        disposable;
+        disposableOverlay;
+        closeButton;
+        toggleButtons;
+        sublists = new Map();
+        isOpen = false;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-menu'), ea = resolve(IEventAggregator), element = resolve(INode), platform = resolve(IPlatform), transitionService = resolve(ITransitionService), storageService = resolve(IStorageService)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.element = element;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.storageService = storageService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.closeButton = this.element.querySelector('[data-menu=close]');
+            this.toggleButtons = this.element.querySelectorAll('[data-menu^="toggle-button"]');
+            this.initMenuButtons();
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.disposable = this.ea.subscribe(Channels.Menu, this.onMenuEvent);
+            this.disposableOverlay = this.ea.subscribe(Channels.OverlayStatus, this.onOverlayStatus);
+            this.closeButton?.addEventListener('click', this.onClickClose);
+            this.element.addEventListener('click', this.onClickToggleButtons);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.closeButton?.removeEventListener('click', this.onClickClose);
+            this.element.removeEventListener('click', this.onClickToggleButtons);
+            this.disposableOverlay?.dispose();
+            this.disposable?.dispose();
+        }
+        dispose() {
+            this.logger.trace('dispose');
+            this.disposableOverlay?.dispose();
+            this.disposable?.dispose();
+        }
+        open(fromOverlay = false) {
+            if (!this.isOpen) {
+                this.logger.trace('open');
+                this.isOpen = true;
+                this.transitionService.run(this.element, (element) => {
+                    if (!fromOverlay) {
+                        this.ea.publish(Channels.Overlay, { action: OverlayAction.Open });
+                    }
+                    this.ea.publish(Channels.MenuStatus, { status: MenuStatus.Opening });
+                    element.classList.add('translate-x-0');
+                    element.classList.remove('-translate-x-full');
+                    element.ariaHidden = 'false';
+                }, (element) => {
+                    this.ea.publish(Channels.MenuStatus, { status: MenuStatus.Opened });
+                });
+            }
+        }
+        close(fromOverlay = false) {
+            if (this.isOpen) {
+                this.logger.trace('close');
+                this.isOpen = false;
+                this.transitionService.run(this.element, (element) => {
+                    this.ea.publish(Channels.MenuStatus, { status: MenuStatus.Closing });
+                    if (!fromOverlay) {
+                        this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+                    }
+                    element.classList.add('-translate-x-full');
+                    element.classList.remove('translate-x-0');
+                    element.ariaHidden = 'true';
+                }, (element) => {
+                    this.ea.publish(Channels.MenuStatus, { status: MenuStatus.Closed });
+                });
+            }
+        }
+        onClickClose = (event) => {
+            this.logger.trace('onClickClose', event);
+            event.preventDefault();
+            this.close();
+        };
+        onClickToggleButtons = (event) => {
+            const target = event.target;
+            const btn = target.closest('[data-menu^="toggle-button"]');
+            if (btn && btn.matches('[data-menu^="toggle-button"]')) {
+                event.preventDefault();
+                this.toggleButton(btn);
+            }
+        };
+        initMenuButtons() {
+            this.logger.trace('initMenu');
+            this.toggleButtons?.forEach((btn) => {
+                if (!this.sublists.has(btn)) {
+                    const id = btn.dataset.menu?.replace('toggle-button-', '');
+                    const isOpen = this.storageService.load(`toggle-list-${id}`, false);
+                    const list = this.element.querySelector(`[data-menu="toggle-list-${id}"]`);
+                    const svg = btn.querySelector('svg[data-menu=icon]');
+                    this.sublists.set(btn, { list, svg });
+                    if (!isOpen) {
+                        svg.classList.remove('rotate-180');
+                        list.classList.add('hidden');
+                        btn.ariaExpanded = 'false';
+                    }
+                    else {
+                        svg.classList.add('rotate-180');
+                        list.classList.remove('hidden');
+                        btn.ariaExpanded = 'true';
+                    }
+                }
+            });
+        }
+        toggleButton(btn) {
+            if (this.sublists.has(btn)) {
+                const sublist = this.sublists.get(btn);
+                const id = btn.dataset.menu?.replace('toggle-button-', '');
+                if (sublist?.list.classList.contains('hidden')) {
+                    sublist?.list.classList.remove('hidden');
+                    sublist?.svg.classList.add('rotate-180');
+                    btn.ariaExpanded = 'true';
+                    this.storageService.save(`toggle-list-${id}`, true);
+                }
+                else {
+                    sublist?.list.classList.add('hidden');
+                    sublist?.svg.classList.remove('rotate-180');
+                    btn.ariaExpanded = 'false';
+                    this.storageService.save(`toggle-list-${id}`, false);
+                }
+            }
+        }
+        closeOtherButtons(except) {
+            this.sublists.forEach((value, key) => {
+                if (key !== except) {
+                    const id = key.dataset.menu?.replace('toggle-button-', '');
+                    this.storageService.save(`toggle-list-${id}`, false);
+                    value.list.classList.add('hidden');
+                    value.svg.classList.remove('rotate-180');
+                }
+            });
+        }
+        onMenuEvent = (data) => {
+            this.logger.trace('onMenuEvent', data);
+            if (data.action === MenuAction.Close) {
+                // this.element.classList.add('-translate-x-full');
+                this.logger.trace('Menu Close action received');
+                this.close();
+            }
+            else if (data.action === MenuAction.Open) {
+                // this.element.classList.remove('-translate-x-full');
+                this.logger.trace('Menu Open action received');
+                this.open();
+            }
+            else if (data.action === MenuAction.Toggle) {
+                // this.element.classList.toggle('-translate-x-full');
+                this.logger.trace('Menu Toggle action received');
+            }
+        };
+        onOverlayStatus = (data) => {
+            if (data.status === OverlayStatus.Closing) {
+                this.logger.trace('Overlay Close action received');
+                this.close(true);
+            }
+            else {
+                this.logger.trace('onOverlayStatus unhandled', data);
+            }
+        };
+    });
+    return _classThis;
+})();
+
+let BleetBadgeCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-badge', defaultProperty: 'id' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        ea;
+        element;
+        closeButton;
+        id = __runInitializers(this, _id_initializers, '');
+        constructor(logger = resolve(ILogger).scopeTo('bleet-badge'), ea = resolve(IEventAggregator), element = resolve(INode)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.element = element;
+            this.logger.trace('constructor');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.closeButton = this.element.querySelector('[data-badge=remove]') ?? undefined;
+            this.closeButton?.addEventListener('click', this.onClickRemove);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.closeButton?.removeEventListener('click', this.onClickRemove);
+        }
+        onClickRemove = (__runInitializers(this, _id_extraInitializers), (event) => {
+            this.logger.trace('onClickRemove', event);
+            event.preventDefault();
+            this.ea.publish(Channels.Badge, { action: BadgeAction.Remove, id: this.id });
+            this.element.remove();
+        });
+    });
+    return _classThis;
+})();
+
+// @ts-ignore
+let BleetSelectCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-select')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        trapFocusService;
+        select;
+        button;
+        buttonText;
+        optionTemplate;
+        itemsPlace;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-select'), element = resolve(INode), trapFocusService = resolve(ITrapFocusService)) {
+            this.logger = logger;
+            this.element = element;
+            this.trapFocusService = trapFocusService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.select = this.element.querySelector('select');
+            this.button = this.element.querySelector('button');
+            this.buttonText = this.button.querySelector('[data-select=value]');
+            this.optionTemplate = this.element.querySelector('[data-select=item-template]');
+            this.itemsPlace = this.element.querySelector('[data-select=items]');
+        }
+        attached() {
+            this.logger.trace('attached');
+            if (!this.itemsPlace) {
+                throw new Error('Items place element not found');
+            }
+            if (!this.itemsPlace.id) {
+                this.itemsPlace.id = `data-select-items-${Math.random().toString(36).substring(2, 15)}`;
+            }
+            if (!this.select?.options) {
+                throw new Error('Select options not found');
+            }
+            if (!this.optionTemplate) {
+                throw new Error('Option template not found');
+            }
+            if (!this.button) {
+                throw new Error('Button element not found');
+            }
+            if (!this.buttonText) {
+                throw new Error('Button text element not found');
+            }
+            this.preparePanel();
+            // ARIA setup
+            this.button.ariaHasPopup = 'listbox';
+            this.button.setAttribute('aria-controls', this.itemsPlace.id);
+            this.itemsPlace.role = 'listbox';
+            // Event listeners
+            this.button?.addEventListener('click', this.onClickToggleMenu);
+            this.itemsPlace?.addEventListener('click', this.onClickToggleItem);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.button?.removeEventListener('click', this.onClickToggleMenu);
+            this.itemsPlace?.removeEventListener('click', this.onClickToggleItem);
+        }
+        onClickToggleMenu = (event) => {
+            this.logger.trace('onClick', event);
+            event.preventDefault();
+            if (this.select?.disabled) {
+                return;
+            }
+            return this.toggleMenu();
+        };
+        onStopTrapFocus = () => {
+            this.logger.trace('onStopTrapFocus');
+            this.itemsPlace?.classList.add('hidden');
+            return Promise.resolve();
+        };
+        toggleMenu = () => {
+            const isClosed = this.itemsPlace?.classList.contains('hidden');
+            return new Promise((resolve) => {
+                if (isClosed) {
+                    // Opening menu
+                    this.button.ariaExpanded = 'true';
+                    // Find selected option to focus initially
+                    const selectedOption = this.itemsPlace?.querySelector('[aria-selected="true"]');
+                    return this.trapFocusService.start(this.button, this.itemsPlace, this.element, undefined, this.onStopTrapFocus, selectedOption // Pass selected option as initial focus
+                    )
+                        .then(() => {
+                        this.logger.trace('toggleMenu opened');
+                        this.itemsPlace?.classList.remove('hidden');
+                        resolve(void 0);
+                    });
+                }
+                else {
+                    // Closing menu
+                    this.button.ariaExpanded = 'false';
+                    return this.trapFocusService.stop()
+                        .then(() => {
+                        this.logger.trace('toggleMenu closed');
+                        this.itemsPlace?.classList.add('hidden');
+                        resolve(void 0);
+                    });
+                }
+            });
+        };
+        onClickToggleItem = (event) => {
+            this.logger.trace('onClickItem', event);
+            event.preventDefault();
+            const element = event.target.closest('[data-value]');
+            // Update select options
+            Array.from(this.select.options).forEach((option) => {
+                option.selected = option.value == element.dataset.value;
+            });
+            // Dispatch change event sur le select natif pour active-form
+            this.select?.dispatchEvent(new Event('change', { bubbles: true }));
+            this.synchSelect();
+        };
+        synchSelect() {
+            this.swapItemClasses();
+            // Close menu
+            return this.toggleMenu();
+        }
+        swapItemClasses() {
+            Array.from(this.select.options).forEach((option) => {
+                const item = this.itemsPlace?.querySelector(`[data-value="${option.value}"]`);
+                if (!item)
+                    return;
+                const checkmark = item.querySelector('[data-select=item-check]');
+                // Récupérer les classes depuis les data-attributes de l'élément
+                const itemInactiveClasses = item.dataset.classInactive?.split(' ') || [];
+                const itemActiveClasses = item.dataset.classActive?.split(' ') || [];
+                const checkInactiveClasses = checkmark?.dataset.classInactive?.split(' ') || [];
+                const checkActiveClasses = checkmark?.dataset.classActive?.split(' ') || [];
+                if (option.selected) {
+                    // Swap vers active
+                    item.classList.remove(...itemInactiveClasses);
+                    item.classList.add(...itemActiveClasses);
+                    checkmark?.classList.remove(...checkInactiveClasses);
+                    checkmark?.classList.add(...checkActiveClasses);
+                    // Update ARIA
+                    item.setAttribute('aria-selected', 'true');
+                    this.button?.setAttribute('aria-activedescendant', item.id);
+                    // Update button text
+                    this.buttonText.innerHTML = option.innerHTML;
+                }
+                else {
+                    // Swap vers inactive
+                    item.classList.remove(...itemActiveClasses);
+                    item.classList.add(...itemInactiveClasses);
+                    checkmark?.classList.remove(...checkActiveClasses);
+                    checkmark?.classList.add(...checkInactiveClasses);
+                    // Update ARIA
+                    item.setAttribute('aria-selected', 'false');
+                }
+            });
+        }
+        preparePanel() {
+            this.logger.trace('preparePanel');
+            if (!this.select) {
+                throw new Error('Select element not found');
+            }
+            // Vider le panel (sauf les templates)
+            this.itemsPlace?.querySelectorAll('button').forEach((child) => child.remove());
+            const options = Array.from(this.select.options);
+            options.forEach((option) => {
+                // @ts-ignore
+                const item = this.optionTemplate.content.cloneNode(true);
+                const button = item.querySelector('button');
+                // ARIA attributes
+                button.role = 'option';
+                button.id = `bleet-option-${option.value}-${Math.random().toString(36).substring(2, 9)}`;
+                // Content
+                const itemText = item.querySelector('[data-select=item-text]');
+                const itemValue = item.querySelector('[data-value]');
+                itemValue.dataset.value = option.value;
+                itemText.innerHTML = option.innerHTML;
+                this.itemsPlace?.append(item);
+            });
+            // Appliquer les classes active/inactive
+            this.swapItemClasses();
+        }
+    });
+    return _classThis;
+})();
+
+// @ts-ignore
+let BleetDropdownCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-dropdown')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        trapFocusService;
+        select;
+        button;
+        buttonText;
+        optionTemplate;
+        tagTemplate;
+        tagsContainer;
+        placeholder;
+        itemsPlace;
+        itemsContainer;
+        searchInput;
+        emptyMessage;
+        isMultiple = false;
+        withTags = false;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-dropdown'), element = resolve(INode), trapFocusService = resolve(ITrapFocusService)) {
+            this.logger = logger;
+            this.element = element;
+            this.trapFocusService = trapFocusService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.select = this.element.querySelector('select');
+            this.button = this.element.querySelector('button');
+            this.buttonText = this.button.querySelector('[data-dropdown=value]');
+            this.tagsContainer = this.button.querySelector('[data-dropdown=tags]');
+            this.placeholder = this.button.querySelector('[data-dropdown=placeholder]');
+            this.optionTemplate = this.element.querySelector('[data-dropdown=item-template]');
+            this.tagTemplate = this.element.querySelector('[data-dropdown=tag-template]');
+            this.itemsPlace = this.element.querySelector('[data-dropdown=items]');
+            this.itemsContainer = this.element.querySelector('[data-dropdown=items-container]');
+            this.searchInput = this.element.querySelector('[data-dropdown=search]');
+            this.emptyMessage = this.element.querySelector('[data-dropdown=empty]');
+            this.isMultiple = this.select?.multiple || false;
+            this.withTags = this.tagTemplate !== null;
+        }
+        attached() {
+            this.logger.trace('attached');
+            if (!this.itemsPlace) {
+                throw new Error('Items place element not found');
+            }
+            if (!this.itemsPlace.id) {
+                this.itemsPlace.id = `data-dropdown-items-${Math.random().toString(36).substring(2, 15)}`;
+            }
+            if (!this.select?.options) {
+                throw new Error('Select options not found');
+            }
+            if (!this.optionTemplate) {
+                throw new Error('Option template not found');
+            }
+            if (!this.button) {
+                throw new Error('Button element not found');
+            }
+            if (!this.buttonText && !this.tagsContainer) {
+                throw new Error('Button text or tags container element not found');
+            }
+            this.preparePanel();
+            // ARIA setup
+            this.button.ariaHasPopup = 'listbox';
+            this.button.setAttribute('aria-controls', this.itemsPlace.id);
+            this.itemsPlace.role = 'listbox';
+            // Event listeners
+            this.button?.addEventListener('click', this.onClickToggleMenu);
+            this.itemsPlace?.addEventListener('click', this.onClickToggleItem);
+            this.searchInput?.addEventListener('input', this.onSearchInput);
+            // Tag remove event listener (delegation)
+            if (this.withTags) {
+                this.tagsContainer?.addEventListener('click', this.onClickRemoveTag);
+            }
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.button?.removeEventListener('click', this.onClickToggleMenu);
+            this.itemsPlace?.removeEventListener('click', this.onClickToggleItem);
+            this.searchInput?.removeEventListener('input', this.onSearchInput);
+            if (this.withTags) {
+                this.tagsContainer?.removeEventListener('click', this.onClickRemoveTag);
+            }
+        }
+        onClickToggleMenu = (event) => {
+            this.logger.trace('onClick', event);
+            // Ne pas ouvrir si on clique sur un bouton de suppression de tag
+            if (event.target.closest('[data-dropdown=tag-remove]')) {
+                return;
+            }
+            event.preventDefault();
+            return this.toggleMenu();
+        };
+        onClickRemoveTag = (event) => {
+            const removeButton = event.target.closest('[data-dropdown=tag-remove]');
+            if (!removeButton)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            const tagElement = removeButton.closest('[data-tag-value]');
+            if (!tagElement)
+                return;
+            const value = tagElement.dataset.tagValue;
+            // Désélectionner l'option
+            Array.from(this.select.options).forEach((option) => {
+                if (option.value == value) {
+                    option.selected = false;
+                }
+            });
+            // Dispatch change event sur le select natif pour active-form
+            this.select?.dispatchEvent(new Event('change', { bubbles: true }));
+            this.swapItemClasses();
+            this.updateDisplay();
+        };
+        onStopTrapFocus = () => {
+            this.logger.trace('onStopTrapFocus');
+            this.itemsPlace?.classList.add('hidden');
+            // Reset search on close
+            if (this.searchInput) {
+                this.searchInput.value = '';
+                this.filterItems('');
+            }
+            return Promise.resolve();
+        };
+        toggleMenu = () => {
+            const isClosed = this.itemsPlace?.classList.contains('hidden');
+            return new Promise((resolve) => {
+                if (isClosed) {
+                    // Opening menu
+                    this.button.ariaExpanded = 'true';
+                    // Find selected option to focus initially, or search input if searchable
+                    const initialFocus = this.searchInput || this.itemsPlace?.querySelector('[aria-selected="true"]');
+                    return this.trapFocusService.start(this.button, this.itemsPlace, this.element, undefined, this.onStopTrapFocus, initialFocus)
+                        .then(() => {
+                        this.logger.trace('toggleMenu opened');
+                        this.itemsPlace?.classList.remove('hidden');
+                        resolve(void 0);
+                    });
+                }
+                else {
+                    // Closing menu
+                    this.button.ariaExpanded = 'false';
+                    return this.trapFocusService.stop()
+                        .then(() => {
+                        this.logger.trace('toggleMenu closed');
+                        this.itemsPlace?.classList.add('hidden');
+                        resolve(void 0);
+                    });
+                }
+            });
+        };
+        onClickToggleItem = (event) => {
+            this.logger.trace('onClickItem', event);
+            event.preventDefault();
+            const element = event.target.closest('[data-value]');
+            if (!element)
+                return;
+            const clickedValue = element.dataset.value;
+            if (this.isMultiple) {
+                // Toggle la sélection de l'option cliquée
+                Array.from(this.select.options).forEach((option) => {
+                    if (option.value == clickedValue) {
+                        option.selected = !option.selected;
+                    }
+                });
+                // Dispatch change event sur le select natif pour active-form
+                this.select?.dispatchEvent(new Event('change', { bubbles: true }));
+                // Ne pas fermer le menu en mode multiple
+                this.swapItemClasses();
+                this.updateDisplay();
+            }
+            else {
+                // Mode simple : une seule sélection
+                Array.from(this.select.options).forEach((option) => {
+                    option.selected = option.value == clickedValue;
+                });
+                // Dispatch change event sur le select natif pour active-form
+                this.select?.dispatchEvent(new Event('change', { bubbles: true }));
+                this.synchSelect();
+            }
+        };
+        onSearchInput = (event) => {
+            const query = event.target.value;
+            this.filterItems(query);
+        };
+        filterItems(query) {
+            const normalizedQuery = query.toLowerCase().trim();
+            let visibleCount = 0;
+            this.itemsContainer?.querySelectorAll('[data-value]').forEach((item) => {
+                const text = item.querySelector('[data-dropdown=item-text]')?.textContent?.toLowerCase() || '';
+                const isVisible = normalizedQuery === '' || text.includes(normalizedQuery);
+                if (isVisible) {
+                    item.classList.remove('hidden');
+                    visibleCount++;
+                }
+                else {
+                    item.classList.add('hidden');
+                }
+            });
+            // Show/hide empty message
+            if (this.emptyMessage) {
+                if (visibleCount === 0 && normalizedQuery !== '') {
+                    this.emptyMessage.classList.remove('hidden');
+                }
+                else {
+                    this.emptyMessage.classList.add('hidden');
+                }
+            }
+        }
+        synchSelect() {
+            this.swapItemClasses();
+            // Close menu
+            return this.toggleMenu();
+        }
+        updateDisplay() {
+            if (this.withTags) {
+                this.updateTags();
+            }
+            else {
+                this.updateButtonText();
+            }
+        }
+        updateButtonText() {
+            const selectedOptions = Array.from(this.select.options).filter(opt => opt.selected);
+            if (selectedOptions.length === 0) {
+                // Afficher le placeholder s'il existe
+                const placeholder = Array.from(this.select.options).find(opt => opt.value === '');
+                this.buttonText.innerHTML = placeholder?.innerHTML || '';
+            }
+            else if (selectedOptions.length === 1) {
+                this.buttonText.innerHTML = selectedOptions[0].innerHTML;
+            }
+            else {
+                this.buttonText.textContent = `${selectedOptions.length} sélectionnés`;
+            }
+        }
+        updateTags() {
+            if (!this.tagsContainer || !this.tagTemplate)
+                return;
+            const selectedOptions = Array.from(this.select.options).filter(opt => opt.selected && opt.value !== '');
+            // Supprimer les tags existants (sauf le placeholder)
+            this.tagsContainer.querySelectorAll('[data-tag-value]').forEach(tag => tag.remove());
+            // Afficher/masquer le placeholder
+            if (this.placeholder) {
+                if (selectedOptions.length === 0) {
+                    this.placeholder.classList.remove('hidden');
+                }
+                else {
+                    this.placeholder.classList.add('hidden');
+                }
+            }
+            // Créer les tags
+            selectedOptions.forEach((option) => {
+                const tagFragment = this.tagTemplate.content.cloneNode(true);
+                const tagElement = tagFragment.querySelector('[data-tag-value]');
+                const tagText = tagFragment.querySelector('[data-dropdown=tag-text]');
+                tagElement.dataset.tagValue = option.value;
+                tagText.textContent = option.textContent;
+                this.tagsContainer?.appendChild(tagFragment);
+            });
+        }
+        swapItemClasses() {
+            Array.from(this.select.options).forEach((option) => {
+                const item = this.itemsContainer?.querySelector(`[data-value="${option.value}"]`);
+                if (!item)
+                    return;
+                const checkmark = item.querySelector('[data-dropdown=item-check]');
+                // Récupérer les classes depuis les data-attributes de l'élément
+                const itemInactiveClasses = item.dataset.classInactive?.split(' ') || [];
+                const itemActiveClasses = item.dataset.classActive?.split(' ') || [];
+                const checkInactiveClasses = checkmark?.dataset.classInactive?.split(' ') || [];
+                const checkActiveClasses = checkmark?.dataset.classActive?.split(' ') || [];
+                if (option.selected) {
+                    // Swap vers active
+                    item.classList.remove(...itemInactiveClasses);
+                    item.classList.add(...itemActiveClasses);
+                    checkmark?.classList.remove(...checkInactiveClasses);
+                    checkmark?.classList.add(...checkActiveClasses);
+                    // Update ARIA
+                    item.setAttribute('aria-selected', 'true');
+                    this.button?.setAttribute('aria-activedescendant', item.id);
+                }
+                else {
+                    // Swap vers inactive
+                    item.classList.remove(...itemActiveClasses);
+                    item.classList.add(...itemInactiveClasses);
+                    checkmark?.classList.remove(...checkActiveClasses);
+                    checkmark?.classList.add(...checkInactiveClasses);
+                    // Update ARIA
+                    item.setAttribute('aria-selected', 'false');
+                }
+            });
+            // Update display (text or tags)
+            this.updateDisplay();
+        }
+        preparePanel() {
+            this.logger.trace('preparePanel');
+            if (!this.select) {
+                throw new Error('Select element not found');
+            }
+            // Vider le container
+            if (this.itemsContainer) {
+                this.itemsContainer.innerHTML = '';
+            }
+            const options = Array.from(this.select.options);
+            options.forEach((option) => {
+                // @ts-ignore
+                const item = this.optionTemplate.content.cloneNode(true);
+                const button = item.querySelector('button');
+                // ARIA attributes
+                button.role = 'option';
+                button.id = `bleet-option-${option.value}-${Math.random().toString(36).substring(2, 9)}`;
+                // Content
+                const itemText = item.querySelector('[data-dropdown=item-text]');
+                const itemValue = item.querySelector('[data-value]');
+                itemValue.dataset.value = option.value;
+                itemText.innerHTML = option.innerHTML;
+                this.itemsContainer?.append(item);
+            });
+            // Appliquer les classes active/inactive
+            this.swapItemClasses();
+        }
+    });
+    return _classThis;
+})();
+
+let BleetPasswordCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-password')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        button;
+        iconHidden;
+        iconVisible;
+        input;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-password'), element = resolve(INode)) {
+            this.logger = logger;
+            this.element = element;
+        }
+        attaching() {
+            this.button = this.element.querySelector('[data-password=toggle]') ?? undefined;
+            this.iconHidden = this.button?.querySelector('[data-password=icon-hidden]') ?? undefined;
+            this.iconVisible = this.button?.querySelector('[data-password=icon-visible]') ?? undefined;
+            this.input = this.element.querySelector('input') ?? undefined;
+        }
+        attached() {
+            this.button?.addEventListener('click', this.onToggle);
+        }
+        detaching() {
+            this.button?.removeEventListener('click', this.onToggle);
+        }
+        onToggle = (event) => {
+            event.preventDefault();
+            const isPassword = this.input?.type === 'password';
+            if (this.input) {
+                this.input.type = isPassword ? 'text' : 'password';
+            }
+            this.iconHidden?.classList.toggle('hidden', isPassword);
+            this.iconVisible?.classList.toggle('hidden', !isPassword);
+        };
+    });
+    return _classThis;
+})();
+
+let BleetTabsCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-tabs')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        p;
+        activeClasses = '';
+        inactiveClasses = '';
+        select;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-tabs'), element = resolve(INode), p = resolve(IPlatform)) {
+            this.logger = logger;
+            this.element = element;
+            this.p = p;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            const activeButton = this.element.querySelector('[data-tabs^="tab-"][aria-selected="true"]');
+            const inactiveButton = this.element.querySelector('[data-tabs^="tab-"][aria-selected="false"]');
+            this.activeClasses = activeButton?.className || '';
+            this.inactiveClasses = inactiveButton?.className || '';
+            this.select = this.element.querySelector('select');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.element.querySelectorAll('[data-tabs^="tab-"]').forEach((button) => {
+                button.addEventListener('click', this.onClickTab);
+            });
+            // Écouter le select mobile
+            if (this.select) {
+                this.select.addEventListener('change', this.onChangeSelect);
+            }
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.querySelectorAll('[data-tabs^="tab-"]').forEach((button) => {
+                button.removeEventListener('click', this.onClickTab);
+            });
+            if (this.select) {
+                this.select.removeEventListener('change', this.onChangeSelect);
+            }
+        }
+        onClickTab = (event) => {
+            this.logger.trace('onClickTab', event);
+            event.preventDefault();
+            const tabIndex = event.currentTarget.getAttribute('data-tabs')?.replace('tab-', '') || '0';
+            // Mettre à jour les tabs
+            this.element.querySelectorAll('[data-tabs^="tab-"]').forEach((button) => {
+                const buttonTabIndex = button.getAttribute('data-tabs')?.replace('tab-', '') || '0';
+                if (buttonTabIndex === tabIndex) {
+                    button.setAttribute('aria-selected', 'true');
+                    button.className = this.activeClasses;
+                }
+                else {
+                    button.setAttribute('aria-selected', 'false');
+                    button.className = this.inactiveClasses;
+                }
+            });
+            // Mettre à jour les panels
+            this.element.querySelectorAll('[data-tabs^="panel-"]').forEach((panel) => {
+                const panelIndex = panel.getAttribute('data-tabs')?.replace('panel-', '') || '0';
+                if (panelIndex === tabIndex) {
+                    panel.classList.remove('hidden');
+                    panel.setAttribute('aria-hidden', 'false');
+                }
+                else {
+                    panel.classList.add('hidden');
+                    panel.setAttribute('aria-hidden', 'true');
+                }
+            });
+            // Synchroniser le select
+            if (this.select) {
+                this.select.value = tabIndex;
+            }
+        };
+        onChangeSelect = (event) => {
+            this.logger.trace('onChangeSelect', event);
+            const tabIndex = this.select?.value;
+            const button = this.element.querySelector(`[data-tabs="tab-${tabIndex}"]`);
+            if (button) {
+                button.click();
+            }
+        };
+    });
+    return _classThis;
+})();
+
+let BleetProfileCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-profile', defaultProperty: 'id' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        ea;
+        element;
+        transitionService;
+        platform;
+        trapFocusService;
+        id = __runInitializers(this, _id_initializers, '');
+        toggleButton = __runInitializers(this, _id_extraInitializers);
+        panel;
+        isOpen = false;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-profile'), ea = resolve(IEventAggregator), element = resolve(INode), transitionService = resolve(ITransitionService), platform = resolve(IPlatform), trapFocusService = resolve(ITrapFocusService)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.element = element;
+            this.transitionService = transitionService;
+            this.platform = platform;
+            this.trapFocusService = trapFocusService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.toggleButton = this.element.querySelector('[data-profile=toggle]');
+            this.panel = this.element.querySelector('[data-profile=panel]');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.toggleButton?.addEventListener('click', this.onClickToggle);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.toggleButton?.removeEventListener('click', this.onClickToggle);
+            if (this.isOpen) {
+                this.trapFocusService.stop();
+            }
+        }
+        onClickToggle = (event) => {
+            this.logger.trace('onClickToggle', event);
+            event.preventDefault();
+            if (this.isOpen) {
+                this.close();
+            }
+            else {
+                this.open();
+            }
+        };
+        onStopTrapFocus = () => {
+            this.logger.trace('onStopTrapFocus');
+            this.isOpen = false;
+            this.toggleButton?.setAttribute('aria-expanded', 'false');
+            this.transitionService.run(this.panel, (element) => {
+                this.ea.publish(Channels.Profile, { action: ProfileAction.Close, id: this.id });
+                this.ea.publish(Channels.ProfileStatus, { status: ProfileStatus.Closing, id: this.id });
+                this.platform.requestAnimationFrame(() => {
+                    element.classList.remove('opacity-100', 'scale-100');
+                    element.classList.add('opacity-0', 'scale-95', 'pointer-events-none');
+                });
+            }, (element) => {
+                element.classList.add('hidden');
+                this.ea.publish(Channels.ProfileStatus, { status: ProfileStatus.Closed, id: this.id });
+            });
+            return Promise.resolve();
+        };
+        open() {
+            this.logger.trace('open');
+            this.isOpen = true;
+            this.toggleButton?.setAttribute('aria-expanded', 'true');
+            // Find first focusable item in panel
+            const firstItem = this.panel?.querySelector('a, button');
+            this.trapFocusService.start(this.toggleButton, this.panel, this.element, undefined, this.onStopTrapFocus, firstItem).then(() => {
+                this.transitionService.run(this.panel, (element) => {
+                    this.ea.publish(Channels.Profile, { action: ProfileAction.Open, id: this.id });
+                    this.ea.publish(Channels.ProfileStatus, { status: ProfileStatus.Opening, id: this.id });
+                    element.classList.remove('hidden');
+                    this.platform.requestAnimationFrame(() => {
+                        element.classList.add('opacity-100', 'scale-100');
+                        element.classList.remove('opacity-0', 'scale-95', 'pointer-events-none');
+                    });
+                }, () => {
+                    this.ea.publish(Channels.ProfileStatus, { status: ProfileStatus.Opened, id: this.id });
+                });
+            });
+        }
+        close() {
+            this.logger.trace('close');
+            this.trapFocusService.stop();
+        }
+    });
+    return _classThis;
+})();
+
+let BleetToasterTriggerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-toaster-trigger', defaultProperty: 'id' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    let _icon_decorators;
+    let _icon_initializers = [];
+    let _icon_extraInitializers = [];
+    let _title_decorators;
+    let _title_initializers = [];
+    let _title_extraInitializers = [];
+    let _content_decorators;
+    let _content_initializers = [];
+    let _content_extraInitializers = [];
+    let _duration_decorators;
+    let _duration_initializers = [];
+    let _duration_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            _color_decorators = [bindable()];
+            _icon_decorators = [bindable()];
+            _title_decorators = [bindable()];
+            _content_decorators = [bindable()];
+            _duration_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _color_decorators, { kind: "field", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+            __esDecorate(null, null, _icon_decorators, { kind: "field", name: "icon", static: false, private: false, access: { has: obj => "icon" in obj, get: obj => obj.icon, set: (obj, value) => { obj.icon = value; } }, metadata: _metadata }, _icon_initializers, _icon_extraInitializers);
+            __esDecorate(null, null, _title_decorators, { kind: "field", name: "title", static: false, private: false, access: { has: obj => "title" in obj, get: obj => obj.title, set: (obj, value) => { obj.title = value; } }, metadata: _metadata }, _title_initializers, _title_extraInitializers);
+            __esDecorate(null, null, _content_decorators, { kind: "field", name: "content", static: false, private: false, access: { has: obj => "content" in obj, get: obj => obj.content, set: (obj, value) => { obj.content = value; } }, metadata: _metadata }, _content_initializers, _content_extraInitializers);
+            __esDecorate(null, null, _duration_decorators, { kind: "field", name: "duration", static: false, private: false, access: { has: obj => "duration" in obj, get: obj => obj.duration, set: (obj, value) => { obj.duration = value; } }, metadata: _metadata }, _duration_initializers, _duration_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        id = __runInitializers(this, _id_initializers, '');
+        color = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _color_initializers, UiColor.Info));
+        icon = (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _icon_initializers, UiToastIcon.Info));
+        title = (__runInitializers(this, _icon_extraInitializers), __runInitializers(this, _title_initializers, ''));
+        content = (__runInitializers(this, _title_extraInitializers), __runInitializers(this, _content_initializers, ''));
+        duration = (__runInitializers(this, _content_extraInitializers), __runInitializers(this, _duration_initializers, 0)); // Duration in milliseconds
+        constructor(logger = resolve(ILogger).scopeTo('bleet-toaster-trigger'), element = resolve(INode), ea = resolve(IEventAggregator)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.element.addEventListener('click', this.onClick);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener('click', this.onClick);
+        }
+        onClick = (__runInitializers(this, _duration_extraInitializers), (event) => {
+            this.logger.trace('onClick', event);
+            event.preventDefault();
+            this.ea.publish(Channels.Toaster, {
+                action: ToasterAction.Add, toast: {
+                    id: this.id,
+                    duration: this.duration,
+                    color: this.color,
+                    icon: this.icon,
+                    title: this.title,
+                    content: this.content
+                }
+            });
+        });
+    });
+    return _classThis;
+})();
+
+let BleetAlertCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-alert')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        platform;
+        transitionService;
+        closeButton;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-alert'), element = resolve(INode), platform = resolve(IPlatform), transitionService = resolve(ITransitionService)) {
+            this.logger = logger;
+            this.element = element;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.closeButton = this.element.querySelector('[data-alert=close]');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.closeButton?.addEventListener('click', this.onClose);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.closeButton?.removeEventListener('click', this.onClose);
+        }
+        onClose = (event) => {
+            this.logger.trace('onClose', event);
+            event.preventDefault();
+            this.transitionService.run(this.element, (element) => {
+                const currentHeight = element.scrollHeight;
+                element.style.height = currentHeight + 'px';
+                // Force reflow
+                element.offsetHeight;
+                element.style.height = '0px';
+                element.classList.remove('opacity-100');
+                element.classList.add('opacity-0');
+            }, (element) => {
+                element.classList.add('hidden');
+                this.platform.requestAnimationFrame(() => {
+                    element.style.height = '';
+                    element.remove();
+                });
+            });
+        };
+    });
+    return _classThis;
+})();
+
+let BleetDrawerTriggerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-drawer-trigger', defaultProperty: 'id' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _url_decorators;
+    let _url_initializers = [];
+    let _url_extraInitializers = [];
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            _url_decorators = [bindable()];
+            _color_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _url_decorators, { kind: "field", name: "url", static: false, private: false, access: { has: obj => "url" in obj, get: obj => obj.url, set: (obj, value) => { obj.url = value; } }, metadata: _metadata }, _url_initializers, _url_extraInitializers);
+            __esDecorate(null, null, _color_decorators, { kind: "field", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        id = __runInitializers(this, _id_initializers, '');
+        url = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _url_initializers, ''));
+        color = (__runInitializers(this, _url_extraInitializers), __runInitializers(this, _color_initializers, 'primary'));
+        constructor(logger = resolve(ILogger).scopeTo('bleet-drawer-trigger'), element = resolve(INode), ea = resolve(IEventAggregator)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.element.addEventListener('click', this.onClick);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener('click', this.onClick);
+        }
+        dispose() {
+            this.logger.trace('dispose');
+        }
+        onClick = (__runInitializers(this, _color_extraInitializers), (event) => {
+            this.logger.trace('onClick', event);
+            event.preventDefault();
+            this.ea.publish(Channels.Drawer, {
+                action: DrawerAction.Toggle,
+                id: this.id,
+                url: this.url,
+                color: this.color,
+            });
+        });
+    });
+    return _classThis;
+})();
+
+let BleetModalTriggerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-modal-trigger', defaultProperty: 'id' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _url_decorators;
+    let _url_initializers = [];
+    let _url_extraInitializers = [];
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            _url_decorators = [bindable()];
+            _color_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _url_decorators, { kind: "field", name: "url", static: false, private: false, access: { has: obj => "url" in obj, get: obj => obj.url, set: (obj, value) => { obj.url = value; } }, metadata: _metadata }, _url_initializers, _url_extraInitializers);
+            __esDecorate(null, null, _color_decorators, { kind: "field", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        id = __runInitializers(this, _id_initializers, '');
+        url = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _url_initializers, ''));
+        color = (__runInitializers(this, _url_extraInitializers), __runInitializers(this, _color_initializers, 'primary'));
+        constructor(logger = resolve(ILogger).scopeTo('bleet-modal-trigger'), element = resolve(INode), ea = resolve(IEventAggregator)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.element.addEventListener('click', this.onClick);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener('click', this.onClick);
+        }
+        dispose() {
+            this.logger.trace('dispose');
+        }
+        onClick = (__runInitializers(this, _color_extraInitializers), (event) => {
+            this.logger.trace('onClick', event);
+            event.preventDefault();
+            this.ea.publish(Channels.Modal, {
+                action: ModalAction.Toggle,
+                id: this.id,
+                url: this.url,
+                color: this.color,
+            });
+        });
+    });
+    return _classThis;
+})();
+
+let BleetPagerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute('bleet-pager')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        p;
+        select;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-pager'), element = resolve(INode), p = resolve(IPlatform)) {
+            this.logger = logger;
+            this.element = element;
+            this.p = p;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.select = this.element.querySelector('[data-pager="select"]');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.select?.addEventListener('change', this.onChangeSelect);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.select?.removeEventListener('change', this.onChangeSelect);
+        }
+        onChangeSelect = (event) => {
+            this.logger.trace('onChangeSelect', event);
+            const pageNumber = this.select?.value;
+            const link = this.element.querySelector(`[data-pager="page-${pageNumber}"]`);
+            if (link) {
+                link.click();
+            }
+        };
+    });
+    return _classThis;
+})();
+
+let BleetUploadCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-upload', defaultProperty: 'endpoint' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _endpoint_decorators;
+    let _endpoint_initializers = [];
+    let _endpoint_extraInitializers = [];
+    let _previewEndpoint_decorators;
+    let _previewEndpoint_initializers = [];
+    let _previewEndpoint_extraInitializers = [];
+    let _deleteEndpoint_decorators;
+    let _deleteEndpoint_initializers = [];
+    let _deleteEndpoint_extraInitializers = [];
+    let _accept_decorators;
+    let _accept_initializers = [];
+    let _accept_extraInitializers = [];
+    let _maxFiles_decorators;
+    let _maxFiles_initializers = [];
+    let _maxFiles_extraInitializers = [];
+    let _multiple_decorators;
+    let _multiple_initializers = [];
+    let _multiple_extraInitializers = [];
+    let _chunkSize_decorators;
+    let _chunkSize_initializers = [];
+    let _chunkSize_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _endpoint_decorators = [bindable];
+            _previewEndpoint_decorators = [bindable()];
+            _deleteEndpoint_decorators = [bindable()];
+            _accept_decorators = [bindable()];
+            _maxFiles_decorators = [bindable()];
+            _multiple_decorators = [bindable()];
+            _chunkSize_decorators = [bindable()];
+            __esDecorate(null, null, _endpoint_decorators, { kind: "field", name: "endpoint", static: false, private: false, access: { has: obj => "endpoint" in obj, get: obj => obj.endpoint, set: (obj, value) => { obj.endpoint = value; } }, metadata: _metadata }, _endpoint_initializers, _endpoint_extraInitializers);
+            __esDecorate(null, null, _previewEndpoint_decorators, { kind: "field", name: "previewEndpoint", static: false, private: false, access: { has: obj => "previewEndpoint" in obj, get: obj => obj.previewEndpoint, set: (obj, value) => { obj.previewEndpoint = value; } }, metadata: _metadata }, _previewEndpoint_initializers, _previewEndpoint_extraInitializers);
+            __esDecorate(null, null, _deleteEndpoint_decorators, { kind: "field", name: "deleteEndpoint", static: false, private: false, access: { has: obj => "deleteEndpoint" in obj, get: obj => obj.deleteEndpoint, set: (obj, value) => { obj.deleteEndpoint = value; } }, metadata: _metadata }, _deleteEndpoint_initializers, _deleteEndpoint_extraInitializers);
+            __esDecorate(null, null, _accept_decorators, { kind: "field", name: "accept", static: false, private: false, access: { has: obj => "accept" in obj, get: obj => obj.accept, set: (obj, value) => { obj.accept = value; } }, metadata: _metadata }, _accept_initializers, _accept_extraInitializers);
+            __esDecorate(null, null, _maxFiles_decorators, { kind: "field", name: "maxFiles", static: false, private: false, access: { has: obj => "maxFiles" in obj, get: obj => obj.maxFiles, set: (obj, value) => { obj.maxFiles = value; } }, metadata: _metadata }, _maxFiles_initializers, _maxFiles_extraInitializers);
+            __esDecorate(null, null, _multiple_decorators, { kind: "field", name: "multiple", static: false, private: false, access: { has: obj => "multiple" in obj, get: obj => obj.multiple, set: (obj, value) => { obj.multiple = value; } }, metadata: _metadata }, _multiple_initializers, _multiple_extraInitializers);
+            __esDecorate(null, null, _chunkSize_decorators, { kind: "field", name: "chunkSize", static: false, private: false, access: { has: obj => "chunkSize" in obj, get: obj => obj.chunkSize, set: (obj, value) => { obj.chunkSize = value; } }, metadata: _metadata }, _chunkSize_initializers, _chunkSize_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        endpoint = __runInitializers(this, _endpoint_initializers, '');
+        previewEndpoint = (__runInitializers(this, _endpoint_extraInitializers), __runInitializers(this, _previewEndpoint_initializers, ''));
+        deleteEndpoint = (__runInitializers(this, _previewEndpoint_extraInitializers), __runInitializers(this, _deleteEndpoint_initializers, ''));
+        accept = (__runInitializers(this, _deleteEndpoint_extraInitializers), __runInitializers(this, _accept_initializers, ''));
+        maxFiles = (__runInitializers(this, _accept_extraInitializers), __runInitializers(this, _maxFiles_initializers, 1));
+        multiple = (__runInitializers(this, _maxFiles_extraInitializers), __runInitializers(this, _multiple_initializers, false));
+        chunkSize = (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, _chunkSize_initializers, 512 * 1024));
+        resumable = (__runInitializers(this, _chunkSize_extraInitializers), null);
+        dropzone = null;
+        browseButton = null;
+        fileList = null;
+        hiddenInput = null;
+        previewTemplate = null;
+        handledFiles = [];
+        parentForm = null;
+        csrfToken = null;
+        constructor(logger = resolve(ILogger).scopeTo('bleet-upload'), element = resolve(INode), ea = resolve(IEventAggregator)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.dropzone = this.element.querySelector('[data-upload=dropzone]');
+            this.browseButton = this.element.querySelector('[data-upload=browse]');
+            this.fileList = this.element.querySelector('[data-upload=list]');
+            this.hiddenInput = this.element.querySelector('[data-upload=value]');
+            this.previewTemplate = this.element.querySelector('[data-upload=preview-template]');
+        }
+        attached() {
+            if (!this.endpoint || !this.dropzone) {
+                this.logger.warn('Missing endpoint or dropzone');
+                return;
+            }
+            if (this.element.hasAttribute('data-disabled')) {
+                return;
+            }
+            this.parentForm = this.element.closest('form');
+            this.extractCsrfToken();
+            this.initResumable();
+            this.setFiles(this.hiddenInput?.value || '');
+        }
+        detaching() {
+            if (this.resumable && this.dropzone) {
+                this.dropzone.removeEventListener('dragover', this.onDragEnter);
+                this.dropzone.removeEventListener('dragenter', this.onDragEnter);
+                this.dropzone.removeEventListener('dragleave', this.onDragLeave);
+                this.dropzone.removeEventListener('drop', this.onDragLeave);
+            }
+        }
+        extractCsrfToken() {
+            if (!this.parentForm)
+                return;
+            const csrfInput = this.parentForm.querySelector('input[name=_csrf]');
+            if (csrfInput) {
+                this.csrfToken = {
+                    name: csrfInput.name,
+                    value: csrfInput.value
+                };
+            }
+        }
+        initResumable() {
+            const resumableConfig = {
+                target: this.endpoint,
+                chunkSize: this.chunkSize,
+                simultaneousUploads: 3,
+                permanentErrors: [400, 404, 415, 422, 500, 501],
+                maxChunkRetries: 0
+            };
+            if (this.accept) {
+                const fileTypes = this.accept.split(/\s*,\s*/).filter(v => v.trim() !== '');
+                resumableConfig.fileType = fileTypes;
+                resumableConfig.fileTypeErrorCallback = (file) => {
+                    this.showErrorToast(`Le fichier "${file.fileName}" n'est pas un type autorise (${fileTypes.map(t => t.toUpperCase()).join(', ')})`);
+                };
+            }
+            if (this.csrfToken) {
+                resumableConfig.headers = {
+                    'X-CSRF-Token': this.csrfToken.value
+                };
+            }
+            this.resumable = new Resumable(resumableConfig);
+            if (!this.resumable.support) {
+                this.logger.warn('Resumable.js not supported');
+                return;
+            }
+            if (this.browseButton) {
+                this.resumable.assignBrowse(this.browseButton, false);
+            }
+            if (this.dropzone) {
+                this.resumable.assignDrop(this.dropzone);
+                this.dropzone.addEventListener('dragover', this.onDragEnter);
+                this.dropzone.addEventListener('dragenter', this.onDragEnter);
+                this.dropzone.addEventListener('dragleave', this.onDragLeave);
+                this.dropzone.addEventListener('drop', this.onDragLeave);
+            }
+            this.resumable.on('fileAdded', this.onFileAdded);
+            this.resumable.on('fileSuccess', this.onFileSuccess);
+            this.resumable.on('fileError', this.onFileError);
+        }
+        /**
+         * Charge les fichiers depuis une valeur (initialisation)
+         */
+        setFiles(value) {
+            const files = value.split(/\s*,\s*/).filter(v => v.trim() !== '');
+            this.handledFiles = files.map(name => ({
+                name,
+                shortname: name.split(/.*[\/|\\]/).pop(),
+                previewUrl: this.generatePreviewUrl(name),
+                deleteUrl: this.generateDeleteUrl(name)
+            }));
+            this.renderFileList();
+            this.updateHiddenInput();
+        }
+        /**
+         * Remplace tous les fichiers par un seul (mode single)
+         */
+        setFile(name, file = null) {
+            // Supprimer les anciens fichiers temporaires
+            this.handledFiles.forEach(f => {
+                if (f.file && this.resumable) {
+                    this.resumable.removeFile(f.file);
+                }
+                this.deleteFileOnServer(f.name);
+            });
+            this.handledFiles = [{
+                    name,
+                    shortname: name.split(/.*[\/|\\]/).pop(),
+                    previewUrl: this.generatePreviewUrl(name),
+                    deleteUrl: this.generateDeleteUrl(name),
+                    file
+                }];
+            this.renderFileList();
+            this.updateHiddenInput();
+        }
+        /**
+         * Ajoute un fichier (mode multiple)
+         */
+        appendFile(name, file = null) {
+            this.handledFiles.push({
+                name,
+                shortname: name.split(/.*[\/|\\]/).pop(),
+                previewUrl: this.generatePreviewUrl(name),
+                deleteUrl: this.generateDeleteUrl(name),
+                file
+            });
+            this.renderFileList();
+            this.updateHiddenInput();
+        }
+        /**
+         * Supprime un fichier
+         */
+        onRemove(handledFile, evt) {
+            evt.stopPropagation();
+            evt.preventDefault();
+            const index = this.handledFiles.findIndex(f => f.name === handledFile.name);
+            if (index === -1)
+                return;
+            if (handledFile.file && this.resumable) {
+                this.resumable.removeFile(handledFile.file);
+            }
+            this.deleteFileOnServer(handledFile.name);
+            this.handledFiles.splice(index, 1);
+            this.renderFileList();
+            this.updateHiddenInput();
+        }
+        deleteFileOnServer(name) {
+            // Ne supprimer que les fichiers temporaires
+            if (!name || !name.startsWith('@bltmp/'))
+                return;
+            const deleteUrl = this.generateDeleteUrl(name);
+            if (!deleteUrl)
+                return;
+            fetch(deleteUrl, {
+                method: 'DELETE',
+                headers: this.csrfToken ? {
+                    'X-CSRF-Token': this.csrfToken.value
+                } : {}
+            }).catch(e => this.logger.error('Delete failed', e));
+        }
+        generatePreviewUrl(name) {
+            if (!this.previewEndpoint)
+                return '';
+            return this.previewEndpoint.replace('__name__', encodeURIComponent(name));
+        }
+        generateDeleteUrl(name) {
+            if (!this.deleteEndpoint)
+                return '';
+            return this.deleteEndpoint.replace('__name__', encodeURIComponent(name));
+        }
+        updateHiddenInput() {
+            if (!this.hiddenInput)
+                return;
+            this.hiddenInput.value = this.handledFiles.map(f => f.name).join(', ');
+            this.hiddenInput.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+        renderFileList() {
+            if (!this.fileList || !this.previewTemplate)
+                return;
+            this.fileList.innerHTML = '';
+            this.handledFiles.forEach(handledFile => {
+                const fragment = this.previewTemplate.content.cloneNode(true);
+                const item = fragment.firstElementChild;
+                // Preview link
+                const previewLink = item.querySelector('[data-upload=preview-link]');
+                if (previewLink) {
+                    previewLink.href = handledFile.previewUrl ? `${handledFile.previewUrl}&original=1` : '#';
+                }
+                // Preview image et icon
+                const previewImage = item.querySelector('[data-upload=preview-image]');
+                const previewIcon = item.querySelector('[data-upload=preview-icon]');
+                if (handledFile.previewUrl) {
+                    this.loadPreview(previewImage, previewIcon, handledFile);
+                }
+                // Si pas de previewUrl, l'icône reste visible (hidden est sur l'image par défaut)
+                // Nom du fichier
+                const nameEl = item.querySelector('[data-upload=preview-name]');
+                if (nameEl) {
+                    nameEl.textContent = handledFile.shortname || '';
+                }
+                // Bouton supprimer
+                const removeBtn = item.querySelector('[data-upload=preview-remove]');
+                if (removeBtn) {
+                    removeBtn.addEventListener('click', (e) => this.onRemove(handledFile, e));
+                }
+                this.fileList.appendChild(fragment);
+            });
+        }
+        loadPreview(previewImage, previewIcon, handledFile) {
+            const shortname = handledFile.shortname || '';
+            if (shortname.toLowerCase().endsWith('.svg')) {
+                // SVG : fetch et inline dans le container parent (le lien)
+                fetch(handledFile.previewUrl)
+                    .then(response => {
+                    if (!response.ok)
+                        throw new Error('Failed to load SVG');
+                    return response.text();
+                })
+                    .then(svgContent => {
+                    // Cacher l'icône par défaut
+                    previewIcon.classList.add('hidden');
+                    // Insérer le SVG à la place de l'image
+                    previewImage.insertAdjacentHTML('afterend', svgContent);
+                    const svg = previewImage.parentElement?.querySelector('svg:not([data-upload])');
+                    if (svg) {
+                        svg.classList.add('size-full');
+                        svg.removeAttribute('width');
+                        svg.removeAttribute('height');
+                    }
+                })
+                    .catch(() => {
+                    // Garder l'icône visible en cas d'erreur
+                });
+            }
+            else {
+                // Autres fichiers : utiliser l'image du template
+                previewImage.src = handledFile.previewUrl;
+                previewImage.alt = shortname;
+                previewImage.onload = () => {
+                    previewImage.classList.remove('hidden');
+                    previewIcon.classList.add('hidden');
+                };
+                previewImage.onerror = () => {
+                    // Garder l'icône visible en cas d'erreur
+                };
+            }
+        }
+        showErrorToast(message) {
+            this.ea.publish(Channels.Toaster, {
+                action: ToasterAction.Add,
+                toast: {
+                    id: `upload-error-${Date.now()}`,
+                    duration: 5000,
+                    color: UiColor.Danger,
+                    icon: UiToastIcon.Danger,
+                    title: 'Erreur',
+                    content: message
+                }
+            });
+        }
+        // Resumable.js event handlers
+        onDragEnter = (evt) => {
+            evt.preventDefault();
+            const dt = evt.dataTransfer;
+            if (dt && dt.types.indexOf('Files') >= 0) {
+                evt.stopPropagation();
+                dt.dropEffect = 'copy';
+                this.dropzone?.classList.add('border-primary-600', 'bg-primary-50');
+            }
+        };
+        onDragLeave = (evt) => {
+            this.dropzone?.classList.remove('border-primary-600', 'bg-primary-50');
+        };
+        onFileAdded = (file, event) => {
+            this.logger.debug('onFileAdded', file.fileName);
+            this.resumable?.upload();
+        };
+        onFileSuccess = (file, serverMessage) => {
+            this.logger.debug('onFileSuccess', file.fileName, serverMessage);
+            try {
+                const response = JSON.parse(serverMessage);
+                if (!response.finalFilename) {
+                    throw new Error('Missing finalFilename in response');
+                }
+                const finalName = `@bltmp/${response.finalFilename}`;
+                if (!this.multiple) {
+                    this.setFile(finalName, file);
+                }
+                else {
+                    this.appendFile(finalName, file);
+                }
+            }
+            catch (e) {
+                this.logger.error('Failed to parse server response', e);
+                this.showErrorToast('Reponse serveur invalide');
+            }
+        };
+        onFileError = (file, message) => {
+            this.logger.error('onFileError', file.fileName, message);
+            this.showErrorToast(`Echec de l'upload de "${file.fileName}"`);
+        };
+    });
+    return _classThis;
+})();
+
+/**
+ * Generic AJAX trigger attribute for elements.
+ * Placed on the element that triggers the AJAX call.
+ * Looks up parent form with closest() to get URL/verb if not specified.
+ * Sends only the inputs contained within this.element.
+ * Pessimistic UI: state changes only on server response.
+ *
+ * Bindables:
+ *   - url (primary): URL to call. Falls back to closest form.action.
+ *   - verb: HTTP method. Falls back to closest form.method or 'POST'.
+ *   - event: DOM event to listen for (default: 'click')
+ *   - collect: If set, also collects inputs with data-ajaxify="{collect}" from closest form
+ */
+let BleetAjaxifyTriggerCustomAttribute = (() => {
+    let _classDecorators = [customAttribute({ name: 'bleet-ajaxify-trigger', defaultProperty: 'url' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _url_decorators;
+    let _url_initializers = [];
+    let _url_extraInitializers = [];
+    let _verb_decorators;
+    let _verb_initializers = [];
+    let _verb_extraInitializers = [];
+    let _event_decorators;
+    let _event_initializers = [];
+    let _event_extraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _url_decorators = [bindable];
+            _verb_decorators = [bindable()];
+            _event_decorators = [bindable()];
+            _id_decorators = [bindable()];
+            __esDecorate(null, null, _url_decorators, { kind: "field", name: "url", static: false, private: false, access: { has: obj => "url" in obj, get: obj => obj.url, set: (obj, value) => { obj.url = value; } }, metadata: _metadata }, _url_initializers, _url_extraInitializers);
+            __esDecorate(null, null, _verb_decorators, { kind: "field", name: "verb", static: false, private: false, access: { has: obj => "verb" in obj, get: obj => obj.verb, set: (obj, value) => { obj.verb = value; } }, metadata: _metadata }, _verb_initializers, _verb_extraInitializers);
+            __esDecorate(null, null, _event_decorators, { kind: "field", name: "event", static: false, private: false, access: { has: obj => "event" in obj, get: obj => obj.event, set: (obj, value) => { obj.event = value; } }, metadata: _metadata }, _event_initializers, _event_extraInitializers);
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        apiService;
+        url = __runInitializers(this, _url_initializers, '');
+        verb = (__runInitializers(this, _url_extraInitializers), __runInitializers(this, _verb_initializers, ''));
+        event = (__runInitializers(this, _verb_extraInitializers), __runInitializers(this, _event_initializers, 'click'));
+        id = (__runInitializers(this, _event_extraInitializers), __runInitializers(this, _id_initializers, ''));
+        constructor(logger = resolve(ILogger).scopeTo('bleet-ajaxify-trigger'), element = resolve(INode), ea = resolve(IEventAggregator), apiService = resolve(IApiService)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.apiService = apiService;
+            this.logger.trace('constructor');
+        }
+        attached() {
+            this.logger.trace('attached', { url: this.url, verb: this.verb, event: this.event });
+            this.element.addEventListener(this.event, this.onTrigger);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener(this.event, this.onTrigger);
+        }
+        onTrigger = (__runInitializers(this, _id_extraInitializers), (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.logger.trace('onTrigger', event);
+            const form = this.element.closest('form');
+            const url = this.resolveUrl(form);
+            const verb = this.resolveVerb(form);
+            if (!url) {
+                this.logger.warn('No URL found for ajaxify-trigger');
+                return;
+            }
+            this.logger.debug('onTrigger', { url, verb });
+            // Build FormData from inputs INSIDE this.element only
+            const formData = this.buildFormData(event);
+            this.apiService
+                .url(url)
+                .fromMultipart(formData)
+                .request(verb)
+                .then((response) => {
+                this.logger.debug('response', response.body);
+                // Update element from response HTML
+                if (response.body.element) {
+                    this.updateElement(response.body.element);
+                }
+                // Show toast if provided
+                if (response.body.toast) {
+                    this.ea.publish(Channels.Toaster, {
+                        action: ToasterAction.Add,
+                        toast: response.body.toast
+                    });
+                }
+                // Trigger ajaxify refresh if provided
+                if (response.body.ajaxify) {
+                    this.ea.publish(Channels.Ajaxify, response.body.ajaxify);
+                }
+            })
+                .catch((error) => {
+                this.logger.error('AJAX request failed', error);
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: {
+                        color: UiColor.Danger,
+                        title: 'Erreur',
+                        content: 'Une erreur est survenue.',
+                        duration: 5000,
+                    }
+                });
+            });
+        });
+        buildFormData(event) {
+            const formData = new FormData();
+            // Get all inputs inside this.element
+            const inputs = this.element.querySelectorAll('input, select, textarea');
+            this.appendInputsToFormData(formData, inputs);
+            // Capture submitter button name/value (for submit events)
+            if (event instanceof SubmitEvent && event.submitter) {
+                const submitter = event.submitter;
+                if (submitter.name) {
+                    formData.append(submitter.name, submitter.value || '');
+                }
+            }
+            // Also get CSRF token from parent form if exists
+            const form = this.element.closest('form');
+            if (form) {
+                const csrfInput = form.querySelector('input[name="_csrf"]');
+                if (csrfInput) {
+                    formData.append('_csrf', csrfInput.value);
+                }
+                // If id is set, also collect inputs with data-ajaxify="{id}" from the form
+                if (this.id) {
+                    const ajaxifyInputs = form.querySelectorAll(`[data-ajaxify="${this.id}"]`);
+                    this.appendInputsToFormData(formData, ajaxifyInputs);
+                }
+            }
+            return formData;
+        }
+        appendInputsToFormData(formData, inputs) {
+            for (const input of Array.from(inputs)) {
+                if (input instanceof HTMLInputElement) {
+                    if (input.type === 'checkbox' || input.type === 'radio') {
+                        if (input.checked && input.name) {
+                            formData.append(input.name, input.value || 'on');
+                        }
+                    }
+                    else if (input.name) {
+                        formData.append(input.name, input.value);
+                    }
+                }
+                else if (input instanceof HTMLSelectElement && input.name) {
+                    formData.append(input.name, input.value);
+                }
+                else if (input instanceof HTMLTextAreaElement && input.name) {
+                    formData.append(input.name, input.value);
+                }
+            }
+        }
+        resolveUrl(form) {
+            if (this.url) {
+                return this.url;
+            }
+            if (form) {
+                return form.action || '';
+            }
+            return '';
+        }
+        resolveVerb(form) {
+            if (this.verb) {
+                return this.verb;
+            }
+            if (form) {
+                return form.method || 'POST';
+            }
+            return 'POST';
+        }
+        updateElement(html) {
+            const template = document.createElement('template');
+            template.innerHTML = html.trim();
+            const newElement = template.content.firstElementChild;
+            if (newElement) {
+                this.syncElement(this.element, newElement);
+            }
+        }
+        syncElement(current, incoming) {
+            // Sync attributes of current element
+            for (const attr of Array.from(incoming.attributes)) {
+                current.setAttribute(attr.name, attr.value);
+            }
+            // Remove attributes that don't exist in incoming
+            for (const attr of Array.from(current.attributes)) {
+                if (!incoming.hasAttribute(attr.name)) {
+                    current.removeAttribute(attr.name);
+                }
+            }
+            // Sync input values for form elements
+            if (current instanceof HTMLInputElement && incoming instanceof HTMLInputElement) {
+                if (current.type === 'checkbox' || current.type === 'radio') {
+                    current.checked = incoming.checked;
+                }
+                else {
+                    current.value = incoming.value;
+                }
+            }
+            // Sync children recursively
+            const currentChildren = Array.from(current.children);
+            const incomingChildren = Array.from(incoming.children);
+            for (let i = 0; i < incomingChildren.length; i++) {
+                if (i < currentChildren.length) {
+                    this.syncElement(currentChildren[i], incomingChildren[i]);
+                }
+            }
+        }
+    });
+    return _classThis;
+})();
+
+let BleetOverlay = (() => {
+    let _classDecorators = [customElement({
+            name: 'bleet-overlay',
+            template: null,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        platform;
+        transitionService;
+        disposable;
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-overlay>'), element = resolve(INode), ea = resolve(IEventAggregator), platform = resolve(IPlatform), transitionService = resolve(ITransitionService)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.disposable = this.ea.subscribe(Channels.Overlay, this.onOverlayEvent);
+            this.element.addEventListener('click', this.onClickOverlay);
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.element.removeEventListener('click', this.onClickOverlay);
+            this.disposable?.dispose();
+        }
+        dispose() {
+            this.logger.trace('dispose');
+            this.disposable?.dispose();
+        }
+        toggle(fromOverlay = false) {
+            if (this.element.classList.contains('hidden')) {
+                this.open(fromOverlay);
+            }
+            else {
+                this.close(fromOverlay);
+            }
+        }
+        open(fromOverlay = false) {
+            if (this.element.classList.contains('hidden')) {
+                this.logger.trace('open');
+                this.transitionService.run(this.element, (element) => {
+                    if (fromOverlay) {
+                        this.ea.publish(Channels.Overlay, { action: OverlayAction.Open });
+                    }
+                    this.ea.publish(Channels.OverlayStatus, { status: OverlayStatus.Opening });
+                    element.classList.remove('hidden');
+                    this.platform.requestAnimationFrame(() => {
+                        element.classList.remove('opacity-0');
+                        element.classList.add('opacity-100');
+                    });
+                    this.logger.trace('open before()');
+                }, (element) => {
+                    this.ea.publish(Channels.OverlayStatus, { status: OverlayStatus.Opened });
+                    this.logger.trace('open after()');
+                });
+            }
+        }
+        close(fromOverlay = false) {
+            if (!this.element.classList.contains('hidden')) {
+                this.transitionService.run(this.element, (element) => {
+                    if (fromOverlay) {
+                        this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+                    }
+                    this.ea.publish(Channels.OverlayStatus, { status: OverlayStatus.Closing });
+                    element.classList.remove('opacity-100');
+                    element.classList.add('opacity-0');
+                    this.logger.trace('close before()');
+                }, (element) => {
+                    element.classList.add('hidden');
+                    this.logger.trace('close after()');
+                    this.ea.publish(Channels.OverlayStatus, { status: OverlayStatus.Closed });
+                });
+            }
+        }
+        onOverlayEvent = (data) => {
+            if (data.action === OverlayAction.Open) {
+                this.logger.trace('onOverlayEvent', data);
+                this.open();
+            }
+            else if (data.action === OverlayAction.Close) {
+                this.logger.trace('onOverlayEvent', data);
+                this.close();
+            }
+            else if (data.action === OverlayAction.Toggle) {
+                this.logger.trace('onOverlayEvent', data);
+                this.toggle();
+            }
+            else {
+                this.logger.trace('onOverlayEvent unhandled', data);
+            }
+        };
+        onClickOverlay = (event) => {
+            this.logger.trace('onClickOverlay', event);
+            event.preventDefault();
+            this.close(true);
+        };
+    });
+    return _classThis;
+})();
+
+var template$5 = `<template>
+        <div class="rounded-md border-l-4 p-4 shadow-lg"
+             class.bind="'border-'+color+'-300 bg-'+color+'-50'">
+            <div class="flex">
+                <div class="shrink-0">
+                    <svg class="size-5"
+                         class.bind="'text-'+color+'-500'"
+                         xmlns="http://www.w3.org/2000/svg"
+                         viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" data-slot="icon">
+                        <path if.bind="icon == 'information-circle'" fill-rule="evenodd" d="M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm8.706-1.442c1.146-.573 2.437.463 2.126 1.706l-.709 2.836.042-.02a.75.75 0 0 1 .67 1.34l-.04.022c-1.147.573-2.438-.463-2.127-1.706l.71-2.836-.042.02a.75.75 0 1 1-.671-1.34l.041-.022ZM12 9a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z" clip-rule="evenodd"/>
+                        <path if.bind="icon == 'check-circle'" fill-rule="evenodd" d="M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm13.36-1.814a.75.75 0 1 0-1.22-.872l-3.236 4.53L9.53 12.22a.75.75 0 0 0-1.06 1.06l2.25 2.25a.75.75 0 0 0 1.14-.094l3.75-5.25Z" clip-rule="evenodd"/>
+                        <path if.bind="icon == 'exclamation-triangle'" fill-rule="evenodd" d="M9.401 3.003c1.155-2 4.043-2 5.197 0l7.355 12.748c1.154 2-.29 4.5-2.599 4.5H4.645c-2.309 0-3.752-2.5-2.598-4.5L9.4 3.003ZM12 8.25a.75.75 0 0 1 .75.75v3.75a.75.75 0 0 1-1.5 0V9a.75.75 0 0 1 .75-.75Zm0 8.25a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z" clip-rule="evenodd"/>
+                        <path if.bind="icon == 'x-circle'" fill-rule="evenodd" d="M12 2.25c-5.385 0-9.75 4.365-9.75 9.75s4.365 9.75 9.75 9.75 9.75-4.365 9.75-9.75S17.385 2.25 12 2.25Zm-1.72 6.97a.75.75 0 1 0-1.06 1.06L10.94 12l-1.72 1.72a.75.75 0 1 0 1.06 1.06L12 13.06l1.72 1.72a.75.75 0 1 0 1.06-1.06L13.06 12l1.72-1.72a.75.75 0 1 0-1.06-1.06L12 10.94l-1.72-1.72Z" clip-rule="evenodd"/>
+                    </svg>
+                </div>
+                <div class="ml-3 flex-1">
+                    <p class="text-sm font-medium"
+                       if.bind="title"
+                       class.bind="'text-'+color+'-700'">
+                        \${title}
+                    </p>
+                    <div class.bind="title?'mt-2':''">
+                        <p class="text-sm"
+                            class.bind="'text-'+color+'-700'"
+                        innerHTML.bind="content">
+                        </p>
+                    </div>
+                </div>
+                <div class="ml-auto pl-3">
+                    <button type="button"
+                            type="button"
+                            class="inline-flex rounded-md cursor-pointer"
+                            class.bind="'bg-'+color+'-50 text-'+color+'-500 hover:bg-'+color+'-100'"
+                            click.trigger="onClickRemove($event)"
+                            data-toast="close">
+                        <span class="sr-only">Fermer</span>
+                        <svg class="size-5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" data-slot="icon">
+                            <path fill-rule="evenodd" d="M5.47 5.47a.75.75 0 0 1 1.06 0L12 10.94l5.47-5.47a.75.75 0 1 1 1.06 1.06L13.06 12l5.47 5.47a.75.75 0 1 1-1.06 1.06L12 13.06l-5.47 5.47a.75.75 0 0 1-1.06-1.06L10.94 12 5.47 6.53a.75.75 0 0 1 0-1.06Z" clip-rule="evenodd"/>
+                        </svg>
+                    </button>
+                </div>
+            </div>
+        </div>
+</template>`;
+
+let BleetToast = (() => {
+    let _classDecorators = [customElement({
+            name: 'bleet-toast',
+            template: template$5
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    let _icon_decorators;
+    let _icon_initializers = [];
+    let _icon_extraInitializers = [];
+    let _title_decorators;
+    let _title_initializers = [];
+    let _title_extraInitializers = [];
+    let _content_decorators;
+    let _content_initializers = [];
+    let _content_extraInitializers = [];
+    let _duration_decorators;
+    let _duration_initializers = [];
+    let _duration_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable()];
+            _color_decorators = [bindable()];
+            _icon_decorators = [bindable()];
+            _title_decorators = [bindable()];
+            _content_decorators = [bindable()];
+            _duration_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _color_decorators, { kind: "field", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+            __esDecorate(null, null, _icon_decorators, { kind: "field", name: "icon", static: false, private: false, access: { has: obj => "icon" in obj, get: obj => obj.icon, set: (obj, value) => { obj.icon = value; } }, metadata: _metadata }, _icon_initializers, _icon_extraInitializers);
+            __esDecorate(null, null, _title_decorators, { kind: "field", name: "title", static: false, private: false, access: { has: obj => "title" in obj, get: obj => obj.title, set: (obj, value) => { obj.title = value; } }, metadata: _metadata }, _title_initializers, _title_extraInitializers);
+            __esDecorate(null, null, _content_decorators, { kind: "field", name: "content", static: false, private: false, access: { has: obj => "content" in obj, get: obj => obj.content, set: (obj, value) => { obj.content = value; } }, metadata: _metadata }, _content_initializers, _content_extraInitializers);
+            __esDecorate(null, null, _duration_decorators, { kind: "field", name: "duration", static: false, private: false, access: { has: obj => "duration" in obj, get: obj => obj.duration, set: (obj, value) => { obj.duration = value; } }, metadata: _metadata }, _duration_initializers, _duration_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        platform;
+        transitionService;
+        id = __runInitializers(this, _id_initializers, '');
+        color = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _color_initializers, UiColor.Info));
+        icon = (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _icon_initializers, UiToastIcon.Info));
+        title = (__runInitializers(this, _icon_extraInitializers), __runInitializers(this, _title_initializers, ''));
+        content = (__runInitializers(this, _title_extraInitializers), __runInitializers(this, _content_initializers, ''));
+        duration = (__runInitializers(this, _content_extraInitializers), __runInitializers(this, _duration_initializers, 0)); // Duration in milliseconds
+        added = (__runInitializers(this, _duration_extraInitializers), false);
+        closeTimeout;
+        // Classes Tailwind complètes pour éviter le purge
+        colorClasses = {
+            [UiColor.Primary]: {
+                container: 'border-primary-300 bg-primary-50',
+                icon: 'text-primary-700',
+                title: 'text-primary-700',
+                content: 'text-primary-700',
+                button: 'bg-primary-50 text-primary-500 hover:bg-primary-100'
+            },
+            [UiColor.Secondary]: {
+                container: 'border-secondary-300 bg-secondary-50',
+                icon: 'text-secondary-700',
+                title: 'text-secondary-700',
+                content: 'text-secondary-700',
+                button: 'bg-secondary-50 text-secondary-500 hover:bg-secondary-100'
+            },
+            [UiColor.Success]: {
+                container: 'border-success-300 bg-success-50',
+                icon: 'text-success-700',
+                title: 'text-success-700',
+                content: 'text-success-700',
+                button: 'bg-success-50 text-success-500 hover:bg-success-100'
+            },
+            [UiColor.Danger]: {
+                container: 'border-danger-300 bg-danger-50',
+                icon: 'text-danger-700',
+                title: 'text-danger-700',
+                content: 'text-danger-700',
+                button: 'bg-danger-50 text-danger-500 hover:bg-danger-100'
+            },
+            [UiColor.Warning]: {
+                container: 'border-warning-300 bg-warning-50',
+                icon: 'text-warning-700',
+                title: 'text-warning-700',
+                content: 'text-warning-700',
+                button: 'bg-warning-50 text-warning-500 hover:bg-warning-100'
+            },
+            [UiColor.Info]: {
+                container: 'border-info-300 bg-info-50',
+                icon: 'text-info-700',
+                title: 'text-info-700',
+                content: 'text-info-700',
+                button: 'bg-info-50 text-info-500 hover:bg-info-100'
+            },
+            [UiColor.Accent]: {
+                container: 'border-accent-300 bg-accent-50',
+                icon: 'text-accent-700',
+                title: 'text-accent-700',
+                content: 'text-accent-700',
+                button: 'bg-accent-50 text-accent-500 hover:bg-accent-100'
+            },
+        };
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-toast>'), element = resolve(INode), ea = resolve(IEventAggregator), platform = resolve(IPlatform), transitionService = resolve(ITransitionService)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            if (!this.added) {
+                this.added = true;
+                this.logger.debug(`Toast added with ID: ${this.id}`);
+                this.transitionService.run(this.element, (element) => {
+                    if (this.duration > 0) {
+                        this.closeTimeout = this.platform.setTimeout(() => {
+                            this.close();
+                        }, this.duration);
+                    }
+                    element.classList.add('opacity-100', 'translate-x-0');
+                    element.classList.remove('opacity-0', 'translate-x-full');
+                });
+            }
+        }
+        detached() {
+            this.logger.trace('detached');
+        }
+        onClickRemove(evt) {
+            evt.preventDefault();
+            this.logger.trace('onClickRemove');
+            this.close();
+        }
+        close() {
+            if (this.closeTimeout) {
+                this.platform.clearTimeout(this.closeTimeout);
+            }
+            this.transitionService.run(this.element, (element) => {
+                element.classList.add('opacity-0', 'translate-x-full');
+                element.classList.remove('opacity-100', 'translate-x-0');
+            }, (element) => {
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Remove,
+                    toast: { id: this.id }
+                });
+            });
+        }
+    });
+    return _classThis;
+})();
+
+var template$4 = `<template class="fixed top-4 right-0 z-70 pr-4 flex flex-col gap-4 pointer-events-none">
+    <bleet-toast repeat.for="[id, toast] of toasts"
+                class="w-90 max-w-full translate-x-full opacity-0 transition-all duration-500 ease-in-out pointer-events-auto"
+        id.bind="id"
+                 color.bind="toast.color"
+                 icon.bind="toast.icon"
+                 title.bind="toast.title"
+                 content.bind="toast.content"
+                 duration.bind="toast.duration"
+    ></bleet-toast>
+</template>`;
+
+let BleetToaster = (() => {
+    let _classDecorators = [customElement({
+            name: 'bleet-toaster',
+            template: template$4
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        disposable;
+        toasts = new Map();
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-toaster>'), element = resolve(INode), ea = resolve(IEventAggregator)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.disposable = this.ea.subscribe(Channels.Toaster, this.onToasterEvent);
+        }
+        attached() {
+            this.logger.trace('attached');
+        }
+        detached() {
+            this.logger.trace('detached');
+            this.disposable?.dispose();
+        }
+        dispose() {
+            this.logger.trace('dispose');
+            this.disposable?.dispose();
+        }
+        onToasterEvent = (data) => {
+            this.logger.trace('onToasterEvent', data);
+            if (data.action === ToasterAction.Add && data.toast) {
+                const toast = {
+                    id: data.toast.id || crypto.randomUUID(),
+                    color: data.toast.color || UiColor.Info,
+                    icon: data.toast.icon || UiToastIcon.Info,
+                    duration: data.toast.duration || 0,
+                    title: data.toast.title,
+                    content: data.toast.content,
+                };
+                // @ts-ignore
+                if (!this.toasts.has(toast.id)) {
+                    // @ts-ignore
+                    this.toasts.set(toast.id, toast);
+                    this.logger.debug(`Toast added with ID: ${toast.id}`);
+                }
+            }
+            else if (data.action === ToasterAction.Remove && data.toast?.id) {
+                if (this.toasts.has(data.toast.id)) {
+                    this.toasts.delete(data.toast.id);
+                    this.logger.debug(`Toast removed with ID: ${data.toast.id}`);
+                }
+            }
+            // Handle toaster events here
+        };
+    });
+    return _classThis;
+})();
+
+let BleetToasterTrigger = (() => {
+    let _classDecorators = [customElement({
+            name: 'bleet-toaster-trigger',
+            template: null
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    let _icon_decorators;
+    let _icon_initializers = [];
+    let _icon_extraInitializers = [];
+    let _title_decorators;
+    let _title_initializers = [];
+    let _title_extraInitializers = [];
+    let _content_decorators;
+    let _content_initializers = [];
+    let _content_extraInitializers = [];
+    let _duration_decorators;
+    let _duration_initializers = [];
+    let _duration_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable()];
+            _color_decorators = [bindable()];
+            _icon_decorators = [bindable()];
+            _title_decorators = [bindable()];
+            _content_decorators = [bindable()];
+            _duration_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _color_decorators, { kind: "field", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+            __esDecorate(null, null, _icon_decorators, { kind: "field", name: "icon", static: false, private: false, access: { has: obj => "icon" in obj, get: obj => obj.icon, set: (obj, value) => { obj.icon = value; } }, metadata: _metadata }, _icon_initializers, _icon_extraInitializers);
+            __esDecorate(null, null, _title_decorators, { kind: "field", name: "title", static: false, private: false, access: { has: obj => "title" in obj, get: obj => obj.title, set: (obj, value) => { obj.title = value; } }, metadata: _metadata }, _title_initializers, _title_extraInitializers);
+            __esDecorate(null, null, _content_decorators, { kind: "field", name: "content", static: false, private: false, access: { has: obj => "content" in obj, get: obj => obj.content, set: (obj, value) => { obj.content = value; } }, metadata: _metadata }, _content_initializers, _content_extraInitializers);
+            __esDecorate(null, null, _duration_decorators, { kind: "field", name: "duration", static: false, private: false, access: { has: obj => "duration" in obj, get: obj => obj.duration, set: (obj, value) => { obj.duration = value; } }, metadata: _metadata }, _duration_initializers, _duration_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        element;
+        ea;
+        p;
+        id = __runInitializers(this, _id_initializers, '');
+        color = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _color_initializers, UiColor.Info));
+        icon = (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _icon_initializers, UiToastIcon.Info));
+        title = (__runInitializers(this, _icon_extraInitializers), __runInitializers(this, _title_initializers, ''));
+        content = (__runInitializers(this, _title_extraInitializers), __runInitializers(this, _content_initializers, ''));
+        duration = (__runInitializers(this, _content_extraInitializers), __runInitializers(this, _duration_initializers, 0)); // Duration in milliseconds
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-toaster-trigger>'), element = resolve(INode), ea = resolve(IEventAggregator), p = resolve(IPlatform)) {
+            this.logger = logger;
+            this.element = element;
+            this.ea = ea;
+            this.p = p;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+        }
+        attached() {
+            this.logger.trace('attached');
+            this.logger.debug(`Triggering toast with`, this.p.document.readyState);
+            if (this.p.document.readyState === 'loading') {
+                this.p.document.addEventListener('DOMContentLoaded', () => {
+                    this.onAttach();
+                }, { once: true });
+            }
+            else {
+                this.onAttach();
+            }
+        }
+        detached() {
+            this.logger.trace('detached');
+        }
+        onAttach = (__runInitializers(this, _duration_extraInitializers), () => {
+            this.logger.trace('onAttach');
+            queueTask(() => {
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add, toast: {
+                        id: this.id,
+                        duration: this.duration,
+                        color: this.color,
+                        icon: this.icon,
+                        title: this.title,
+                        content: this.content
+                    }
+                });
+            });
+        });
+    });
+    return _classThis;
+})();
+
+var template$3 = `<template>
+    <dialog ref="dialogElement"
+            class="fixed inset-0 z-50 size-auto max-h-none max-w-none overflow-y-auto transition ease-in-out duration-300 bg-transparent backdrop:bg-transparent opacity-0">
+        <div class="flex min-h-full items-end justify-center p-4 text-center sm:items-center sm:p-0">
+            <div class="relative transform overflow-hidden rounded-lg bg-white text-left shadow-xl sm:my-8 sm:w-full sm:max-w-lg">
+
+                <!-- Loader -->
+                <div if.bind="loading" class="flex items-center justify-center py-12">
+                    <svg class="animate-spin size-8 text-primary-600" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                </div>
+
+                <!-- Contenu -->
+                <template else>
+                    <!-- Header -->
+                    <au-compose if.bind="headerView" template.bind="headerView"></au-compose>
+
+                    <!-- Content -->
+                    <au-compose if.bind="contentView" template.bind="contentView"></au-compose>
+
+                    <!-- Footer -->
+                    <au-compose if.bind="footerView" template.bind="footerView"></au-compose>
+                </template>
+
+            </div>
+        </div>
+    </dialog>
+</template>`;
+
+let BleetModal = (() => {
+    let _classDecorators = [customElement({ name: 'bleet-modal', template: template$3 })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    var BleetModal = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BleetModal = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        logger;
+        ea;
+        platform;
+        transitionService;
+        svgService;
+        apiService;
+        id = __runInitializers(this, _id_initializers, '');
+        dialogElement = __runInitializers(this, _id_extraInitializers);
+        disposable;
+        // State
+        loading = false;
+        color = UiColor.Primary;
+        icon = null;
+        headerView = null;
+        contentView = null;
+        footerView = null;
+        // Color classes — no Tailwind interpolation
+        static ICON_BG_CLASSES = {
+            [UiColor.Primary]: 'bg-primary-100',
+            [UiColor.Secondary]: 'bg-secondary-100',
+            [UiColor.Success]: 'bg-success-100',
+            [UiColor.Danger]: 'bg-danger-100',
+            [UiColor.Warning]: 'bg-warning-100',
+            [UiColor.Info]: 'bg-info-100',
+            [UiColor.Accent]: 'bg-accent-100',
+        };
+        static ICON_TEXT_CLASSES = {
+            [UiColor.Primary]: 'text-primary-600',
+            [UiColor.Secondary]: 'text-secondary-600',
+            [UiColor.Success]: 'text-success-600',
+            [UiColor.Danger]: 'text-danger-600',
+            [UiColor.Warning]: 'text-warning-600',
+            [UiColor.Info]: 'text-info-600',
+            [UiColor.Accent]: 'text-accent-600',
+        };
+        static HEADER_BG_CLASSES = {
+            [UiColor.Primary]: 'bg-primary-600',
+            [UiColor.Secondary]: 'bg-secondary-600',
+            [UiColor.Success]: 'bg-success-600',
+            [UiColor.Danger]: 'bg-danger-600',
+            [UiColor.Warning]: 'bg-warning-600',
+            [UiColor.Info]: 'bg-info-600',
+            [UiColor.Accent]: 'bg-accent-600',
+        };
+        static CLOSE_BUTTON_TEXT_CLASSES = {
+            [UiColor.Primary]: 'text-primary-200',
+            [UiColor.Secondary]: 'text-secondary-200',
+            [UiColor.Success]: 'text-success-200',
+            [UiColor.Danger]: 'text-danger-200',
+            [UiColor.Warning]: 'text-warning-200',
+            [UiColor.Info]: 'text-info-200',
+            [UiColor.Accent]: 'text-accent-200',
+        };
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-modal>'), ea = resolve(IEventAggregator), platform = resolve(IPlatform), transitionService = resolve(ITransitionService), svgService = resolve(ISvgService), apiService = resolve(IApiService)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.svgService = svgService;
+            this.apiService = apiService;
+        }
+        // Getters
+        get iconSvg() {
+            if (!this.icon)
+                return null;
+            return this.svgService.get(this.icon);
+        }
+        get iconBgClass() {
+            return BleetModal.ICON_BG_CLASSES[this.color] ?? BleetModal.ICON_BG_CLASSES[UiColor.Primary];
+        }
+        get iconTextClass() {
+            return BleetModal.ICON_TEXT_CLASSES[this.color] ?? BleetModal.ICON_TEXT_CLASSES[UiColor.Primary];
+        }
+        get headerBgClass() {
+            return BleetModal.HEADER_BG_CLASSES[this.color] ?? BleetModal.HEADER_BG_CLASSES[UiColor.Primary];
+        }
+        get closeButtonTextClass() {
+            return BleetModal.CLOSE_BUTTON_TEXT_CLASSES[this.color] ?? BleetModal.CLOSE_BUTTON_TEXT_CLASSES[UiColor.Primary];
+        }
+        // Lifecycle
+        attached() {
+            this.disposable = this.ea.subscribe(Channels.Modal, this.onModalEvent);
+            this.dialogElement.addEventListener('close', this.onCloseEvent);
+            this.dialogElement.addEventListener('cancel', this.onCancelEvent);
+        }
+        detached() {
+            this.dialogElement.removeEventListener('close', this.onCloseEvent);
+            this.dialogElement.removeEventListener('cancel', this.onCancelEvent);
+            this.disposable?.dispose();
+        }
+        bindDialogEvents() {
+            this.dialogElement.addEventListener('submit', this.onFormSubmit);
+            this.dialogElement.addEventListener('click', this.onDialogClick);
+        }
+        unbindDialogEvents() {
+            this.dialogElement.removeEventListener('submit', this.onFormSubmit);
+            this.dialogElement.removeEventListener('click', this.onDialogClick);
+        }
+        // Handlers
+        onModalEvent = (data) => {
+            if (this.id && this.id !== '' && data.id === this.id) {
+                if (data.action === ModalAction.Open && this.dialogElement.open !== true) {
+                    if (data.url) {
+                        this.loadFromUrl(data.url);
+                    }
+                }
+                else if (data.action === ModalAction.Close && this.dialogElement.open === true) {
+                    this.close();
+                }
+                else if (data.action === ModalAction.Toggle) {
+                    if (this.dialogElement.open === true) {
+                        this.close();
+                    }
+                    else if (data.url) {
+                        this.loadFromUrl(data.url);
+                    }
+                }
+            }
+        };
+        onCloseEvent = (event) => {
+            this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+        };
+        onCancelEvent = (event) => {
+            this.close();
+        };
+        onDialogClick = (event) => {
+            const target = event.target;
+            if (target.closest('[data-modal="close"]')) {
+                event.preventDefault();
+                this.close();
+            }
+        };
+        onFormSubmit = (event) => {
+            const form = event.target.closest('form');
+            if (!form)
+                return;
+            event.preventDefault();
+            const formData = new FormData(form);
+            const method = formData.get('_method') || form.getAttribute('method') || 'POST';
+            this.apiService
+                .url(form.action)
+                .fromMultipart(formData)
+                .request(method)
+                .then((response) => {
+                this.applyResponse(response.body);
+            })
+                .catch((error) => {
+                this.logger.error('form submit failed', error);
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: { color: UiColor.Danger, content: 'Erreur lors de l\'envoi' }
+                });
+            });
+        };
+        // AJAX
+        loadFromUrl(url) {
+            this.loading = true;
+            this.open();
+            this.apiService.url(url).get()
+                .then((response) => {
+                this.applyResponse(response.body);
+            })
+                .catch((error) => {
+                this.logger.error('loadFromUrl failed', error);
+                this.close();
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: { color: UiColor.Danger, content: 'Erreur de chargement' }
+                });
+            })
+                .finally(() => {
+                this.loading = false;
+            });
+        }
+        applyResponse(response) {
+            // Style
+            this.color = response.color ?? UiColor.Primary;
+            this.icon = response.icon ?? null;
+            // Content
+            if (response.header)
+                this.headerView = response.header;
+            if (response.content)
+                this.contentView = response.content;
+            if (response.footer)
+                this.footerView = response.footer;
+            // Actions
+            this.executeActions(response);
+        }
+        executeActions(response) {
+            // 1. Primary action
+            if (response.action === DialogAction.Close) {
+                this.close();
+            }
+            // DialogAction.Keep → do nothing, dialog stays open
+            // 2. Secondary actions (combinable)
+            if (response.toast) {
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: response.toast
+                });
+            }
+            if (response.ajaxify) {
+                this.ea.publish(Channels.Ajaxify, response.ajaxify);
+            }
+            else if (response.redirect) {
+                this.platform.window.location.href = response.redirect;
+            }
+            else if (response.refresh) {
+                this.platform.window.location.reload();
+            }
+        }
+        // Open / Close
+        open() {
+            this.bindDialogEvents();
+            this.transitionService.run(this.dialogElement, (element) => {
+                this.ea.publish(Channels.Overlay, { action: OverlayAction.Open });
+                this.ea.publish(Channels.ModalStatus, { status: ModalStatus.Opening, id: this.id });
+                element.showModal();
+                this.platform.requestAnimationFrame(() => {
+                    element.classList.add('opacity-100');
+                    element.classList.remove('opacity-0');
+                });
+            }, () => {
+                this.ea.publish(Channels.ModalStatus, { status: ModalStatus.Opened, id: this.id });
+            });
+        }
+        close() {
+            this.transitionService.run(this.dialogElement, (element) => {
+                this.ea.publish(Channels.ModalStatus, { status: ModalStatus.Closing, id: this.id });
+                this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+                element.classList.add('opacity-0');
+                element.classList.remove('opacity-100');
+            }, (element) => {
+                element.close();
+                this.unbindDialogEvents();
+                // Reset
+                this.headerView = null;
+                this.contentView = null;
+                this.footerView = null;
+                this.icon = null;
+                this.color = UiColor.Primary;
+                this.loading = false;
+                this.ea.publish(Channels.ModalStatus, { status: ModalStatus.Closed, id: this.id });
+            });
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return BleetModal = _classThis;
+})();
+
+var template$2 = `<template>
+    <dialog ref="dialogElement"
+            class="fixed inset-0 z-50 size-auto max-h-none max-w-none overflow-hidden backdrop:bg-transparent bg-transparent transform translate-x-full transition ease-in-out duration-300">
+        <div class="absolute inset-0 pl-10 sm:pl-16 overflow-hidden">
+            <div class="ml-auto flex flex-col h-full w-full sm:w-2/3 sm:min-w-md transform bg-white shadow-xl">
+
+                <!-- Loader -->
+                <div if.bind="loading" class="flex items-center justify-center h-full">
+                    <svg class="animate-spin size-8 text-primary-600" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                </div>
+
+                <!-- Contenu -->
+                <template else>
+                    <!-- Header (fixed) -->
+                    <div class="shrink-0">
+                        <au-compose if.bind="headerView" template.bind="headerView"></au-compose>
+                    </div>
+
+                    <!-- Content (scrollable) -->
+                    <div class="flex-1 overflow-y-auto">
+                        <au-compose if.bind="contentView" template.bind="contentView"></au-compose>
+                    </div>
+
+                    <!-- Footer (fixed) -->
+                    <div class="shrink-0">
+                        <au-compose if.bind="footerView" template.bind="footerView"></au-compose>
+                    </div>
+                </template>
+
+            </div>
+        </div>
+    </dialog>
+</template>`;
+
+let BleetDrawer = (() => {
+    let _classDecorators = [customElement({ name: 'bleet-drawer', template: template$2 })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    var BleetDrawer = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BleetDrawer = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        logger;
+        ea;
+        platform;
+        transitionService;
+        svgService;
+        apiService;
+        id = __runInitializers(this, _id_initializers, '');
+        dialogElement = __runInitializers(this, _id_extraInitializers);
+        disposable;
+        // State
+        loading = false;
+        color = UiColor.Primary;
+        headerView = null;
+        contentView = null;
+        footerView = null;
+        // Color classes for header
+        static HEADER_BG_CLASSES = {
+            [UiColor.Primary]: 'bg-primary-700',
+            [UiColor.Secondary]: 'bg-secondary-700',
+            [UiColor.Success]: 'bg-success-700',
+            [UiColor.Danger]: 'bg-danger-700',
+            [UiColor.Warning]: 'bg-warning-700',
+            [UiColor.Info]: 'bg-info-700',
+            [UiColor.Accent]: 'bg-accent-700',
+        };
+        static CLOSE_BUTTON_TEXT_CLASSES = {
+            [UiColor.Primary]: 'text-primary-200',
+            [UiColor.Secondary]: 'text-secondary-200',
+            [UiColor.Success]: 'text-success-200',
+            [UiColor.Danger]: 'text-danger-200',
+            [UiColor.Warning]: 'text-warning-200',
+            [UiColor.Info]: 'text-info-200',
+            [UiColor.Accent]: 'text-accent-200',
+        };
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-drawer>'), ea = resolve(IEventAggregator), platform = resolve(IPlatform), transitionService = resolve(ITransitionService), svgService = resolve(ISvgService), apiService = resolve(IApiService)) {
+            this.logger = logger;
+            this.ea = ea;
+            this.platform = platform;
+            this.transitionService = transitionService;
+            this.svgService = svgService;
+            this.apiService = apiService;
+        }
+        // Getters
+        get headerBgClass() {
+            return BleetDrawer.HEADER_BG_CLASSES[this.color] ?? BleetDrawer.HEADER_BG_CLASSES[UiColor.Primary];
+        }
+        get closeButtonTextClass() {
+            return BleetDrawer.CLOSE_BUTTON_TEXT_CLASSES[this.color] ?? BleetDrawer.CLOSE_BUTTON_TEXT_CLASSES[UiColor.Primary];
+        }
+        // Lifecycle
+        attached() {
+            this.disposable = this.ea.subscribe(Channels.Drawer, this.onDrawerEvent);
+            this.dialogElement.addEventListener('close', this.onCloseEvent);
+            this.dialogElement.addEventListener('cancel', this.onCancelEvent);
+        }
+        detached() {
+            this.dialogElement.removeEventListener('close', this.onCloseEvent);
+            this.dialogElement.removeEventListener('cancel', this.onCancelEvent);
+            this.disposable?.dispose();
+        }
+        bindDialogEvents() {
+            this.dialogElement.addEventListener('submit', this.onFormSubmit);
+            this.dialogElement.addEventListener('click', this.onDialogClick);
+        }
+        unbindDialogEvents() {
+            this.dialogElement.removeEventListener('submit', this.onFormSubmit);
+            this.dialogElement.removeEventListener('click', this.onDialogClick);
+        }
+        // Handlers
+        onDrawerEvent = (data) => {
+            if (this.id && this.id !== '' && data.id === this.id) {
+                if (data.action === DrawerAction.Open && this.dialogElement.open !== true) {
+                    if (data.url) {
+                        this.loadFromUrl(data.url);
+                    }
+                }
+                else if (data.action === DrawerAction.Close && this.dialogElement.open === true) {
+                    this.close();
+                }
+                else if (data.action === DrawerAction.Toggle) {
+                    if (this.dialogElement.open === true) {
+                        this.close();
+                    }
+                    else if (data.url) {
+                        this.loadFromUrl(data.url);
+                    }
+                }
+            }
+        };
+        onCloseEvent = (event) => {
+            this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+        };
+        onCancelEvent = (event) => {
+            this.close();
+        };
+        onDialogClick = (event) => {
+            const target = event.target;
+            if (target.closest('[data-drawer="close"]')) {
+                event.preventDefault();
+                this.close();
+            }
+        };
+        onFormSubmit = (event) => {
+            const form = event.target.closest('form');
+            if (!form)
+                return;
+            event.preventDefault();
+            const formData = new FormData(form);
+            // Capture submitter button name/value (not included by default in FormData)
+            if (event.submitter instanceof HTMLButtonElement && event.submitter.name) {
+                formData.append(event.submitter.name, event.submitter.value || '');
+            }
+            const method = formData.get('_method') || form.getAttribute('method') || 'POST';
+            this.apiService
+                .url(form.action)
+                .fromMultipart(formData)
+                .request(method)
+                .then((response) => {
+                this.applyResponse(response.body);
+            })
+                .catch((error) => {
+                this.logger.error('form submit failed', error);
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: { color: UiColor.Danger, content: 'Erreur lors de l\'envoi' }
+                });
+            });
+        };
+        loadFromUrl(url) {
+            this.loading = true;
+            this.open();
+            this.apiService.url(url).get()
+                .then((response) => {
+                this.applyResponse(response.body);
+            })
+                .catch((error) => {
+                this.logger.error('loadFromUrl failed', error);
+                this.close();
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: { color: UiColor.Danger, content: 'Erreur de chargement' }
+                });
+            })
+                .finally(() => {
+                this.loading = false;
+            });
+        }
+        applyResponse(response) {
+            this.color = response.color ?? UiColor.Primary;
+            if (response.header)
+                this.headerView = response.header;
+            if (response.content)
+                this.contentView = response.content;
+            if (response.footer)
+                this.footerView = response.footer;
+            this.executeActions(response);
+        }
+        executeActions(response) {
+            // 1. Primary action
+            if (response.action === DialogAction.Close) {
+                this.close();
+            }
+            // 2. Secondary actions (combinable)
+            if (response.toast) {
+                this.ea.publish(Channels.Toaster, {
+                    action: ToasterAction.Add,
+                    toast: response.toast
+                });
+            }
+            if (response.ajaxify) {
+                this.ea.publish(Channels.Ajaxify, response.ajaxify);
+            }
+            else if (response.redirect) {
+                this.platform.window.location.href = response.redirect;
+            }
+            else if (response.refresh) {
+                this.platform.window.location.reload();
+            }
+        }
+        // Open / Close — translate-x
+        open() {
+            this.bindDialogEvents();
+            this.transitionService.run(this.dialogElement, (element) => {
+                this.ea.publish(Channels.Overlay, { action: OverlayAction.Open });
+                this.ea.publish(Channels.DrawerStatus, { status: DrawerStatus.Opening, id: this.id });
+                element.showModal();
+                this.platform.requestAnimationFrame(() => {
+                    element.classList.add('translate-x-0');
+                    element.classList.remove('translate-x-full');
+                });
+            }, () => {
+                this.ea.publish(Channels.DrawerStatus, { status: DrawerStatus.Opened, id: this.id });
+            });
+        }
+        close() {
+            this.transitionService.run(this.dialogElement, (element) => {
+                this.ea.publish(Channels.DrawerStatus, { status: DrawerStatus.Closing, id: this.id });
+                this.ea.publish(Channels.Overlay, { action: OverlayAction.Close });
+                element.classList.add('translate-x-full');
+                element.classList.remove('translate-x-0');
+            }, (element) => {
+                element.close();
+                this.unbindDialogEvents();
+                this.headerView = null;
+                this.contentView = null;
+                this.footerView = null;
+                this.color = UiColor.Primary;
+                this.loading = false;
+                this.ea.publish(Channels.DrawerStatus, { status: DrawerStatus.Closed, id: this.id });
+            });
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return BleetDrawer = _classThis;
+})();
+
+var template$1 = `<template>
+    <au-slot if.bind="!ajaxedView"></au-slot>
+    <au-compose if.bind="ajaxedView" template.bind="ajaxedView"></au-compose>
+</template>`;
+
+class AjaxifyCodec {
+    static codec = {
+        encode: (ctx) => {
+            return Promise.resolve({
+                ...ctx,
+                headers: {
+                    ...ctx.headers,
+                    'X-Requested-For': 'Ajaxify',
+                }
+            });
+        }
+    };
+}
+
+let BleetAjaxify = (() => {
+    let _classDecorators = [customElement({ name: 'bleet-ajaxify', template: template$1 })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _url_decorators;
+    let _url_initializers = [];
+    let _url_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [bindable()];
+            _url_decorators = [bindable()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _url_decorators, { kind: "field", name: "url", static: false, private: false, access: { has: obj => "url" in obj, get: obj => obj.url, set: (obj, value) => { obj.url = value; } }, metadata: _metadata }, _url_initializers, _url_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        ea;
+        logger;
+        apiService;
+        id = __runInitializers(this, _id_initializers, '');
+        url = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _url_initializers, void 0));
+        ajaxedView = (__runInitializers(this, _url_extraInitializers), null);
+        disposable;
+        constructor(ea = resolve(IEventAggregator), logger = resolve(ILogger).scopeTo('<bleet-ajaxify>'), apiService = resolve(IApiService)) {
+            this.ea = ea;
+            this.logger = logger;
+            this.apiService = apiService;
+            this.logger.trace('constructor');
+        }
+        attaching() {
+            this.logger.trace('attaching');
+            this.disposable = this.ea.subscribe(Channels.Ajaxify, this.onEvent);
+        }
+        detaching() {
+            this.logger.trace('detaching');
+            this.disposable?.dispose();
+        }
+        dispose() {
+            this.logger.trace('dispose');
+            this.disposable?.dispose();
+        }
+        onEvent = (data) => {
+            this.logger.trace('onEvent', data);
+            if (data.action === AjaxifyAction.Refresh) {
+                if (data.id && data.id == this.id) {
+                    this.logger.debug(`Refreshing ajaxify id=${this.id} from url=${this.url}`);
+                    const url = data.url ? data.url : this.url;
+                    if (url.length > 1) {
+                        this.apiService
+                            .url(url)
+                            .withInputCodec(AjaxifyCodec.codec)
+                            .toText()
+                            .get()
+                            .then((response) => {
+                            this.logger.debug(`Received for id=${this.id}`);
+                            this.ajaxedView = response.body;
+                        })
+                            .catch((error) => {
+                            this.logger.error(`Error for id=${this.id}: `, error);
+                        });
+                    }
+                }
+            }
+        };
+    });
+    return _classThis;
+})();
+
+var template = `<template>
+    <input type="hidden" ref="hiddenField">
+    <div ref="editorElement"></div>
+</template>`;
+
+const Link = Quill.import('formats/link');
+class BlackcubeLink extends Link {
+    static create(value) {
+        let node = super.create(value);
+        value = this.sanitize(value);
+        node.setAttribute('href', value);
+        if (value.startsWith("https://") || value.startsWith("http://") || value.startsWith("://")) ;
+        else {
+            node.removeAttribute('target');
+        }
+        return node;
+    }
+}
+Quill.register(BlackcubeLink, true);
+let Quilljs = (() => {
+    let _classDecorators = [customElement({ name: 'bleet-quilljs', template })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _fieldId_decorators;
+    let _fieldId_initializers = [];
+    let _fieldId_extraInitializers = [];
+    let _fieldName_decorators;
+    let _fieldName_initializers = [];
+    let _fieldName_extraInitializers = [];
+    let _content_decorators;
+    let _content_initializers = [];
+    let _content_extraInitializers = [];
+    let _options_decorators;
+    let _options_initializers = [];
+    let _options_extraInitializers = [];
+    (class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _fieldId_decorators = [bindable()];
+            _fieldName_decorators = [bindable()];
+            _content_decorators = [bindable()];
+            _options_decorators = [bindable()];
+            __esDecorate(null, null, _fieldId_decorators, { kind: "field", name: "fieldId", static: false, private: false, access: { has: obj => "fieldId" in obj, get: obj => obj.fieldId, set: (obj, value) => { obj.fieldId = value; } }, metadata: _metadata }, _fieldId_initializers, _fieldId_extraInitializers);
+            __esDecorate(null, null, _fieldName_decorators, { kind: "field", name: "fieldName", static: false, private: false, access: { has: obj => "fieldName" in obj, get: obj => obj.fieldName, set: (obj, value) => { obj.fieldName = value; } }, metadata: _metadata }, _fieldName_initializers, _fieldName_extraInitializers);
+            __esDecorate(null, null, _content_decorators, { kind: "field", name: "content", static: false, private: false, access: { has: obj => "content" in obj, get: obj => obj.content, set: (obj, value) => { obj.content = value; } }, metadata: _metadata }, _content_initializers, _content_extraInitializers);
+            __esDecorate(null, null, _options_decorators, { kind: "field", name: "options", static: false, private: false, access: { has: obj => "options" in obj, get: obj => obj.options, set: (obj, value) => { obj.options = value; } }, metadata: _metadata }, _options_initializers, _options_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        logger;
+        platform;
+        element;
+        hiddenField;
+        editorElement;
+        quill;
+        fieldId = __runInitializers(this, _fieldId_initializers, '');
+        fieldName = (__runInitializers(this, _fieldId_extraInitializers), __runInitializers(this, _fieldName_initializers, ''));
+        content = (__runInitializers(this, _fieldName_extraInitializers), __runInitializers(this, _content_initializers, ''));
+        options = (__runInitializers(this, _content_extraInitializers), __runInitializers(this, _options_initializers, {
+            theme: 'snow',
+            modules: {
+                toolbar: [
+                    ['bold', 'italic', 'underline'],
+                    [{ 'list': 'bullet' }],
+                    ['link']
+                ]
+            },
+            formats: ['bold', 'italic', 'link', 'underline', 'list']
+        }));
+        constructor(logger = resolve(ILogger).scopeTo('<bleet-quilljs>'), platform = resolve(IPlatform), element = resolve(INode)) {
+            this.logger = logger;
+            this.platform = platform;
+            this.element = element;
+        }
+        attached() {
+            this.logger.debug('Attached');
+            if (this.fieldId) {
+                this.hiddenField.id = this.fieldId;
+            }
+            if (this.fieldName) {
+                this.hiddenField.name = this.fieldName;
+            }
+            this.hiddenField.value = this.content;
+            this.editorElement.innerHTML = this.content;
+            this.options.theme = 'snow';
+            this.quill = new Quill(this.editorElement, this.options);
+            this.quill.on('text-change', this.onTextChange);
+        }
+        onTextChange = (__runInitializers(this, _options_extraInitializers), () => {
+            this.hiddenField.value = this.editorElement.querySelector('.ql-editor')?.innerHTML ?? '';
+            this.logger.trace(this.hiddenField.value);
+        });
+        detaching() {
+            this.quill.off('text-change', this.onTextChange);
+            this.logger.debug('Detaching');
+        }
+    });
+    return _classThis;
+})();
+
+class RequestCodec {
+    static codec = {
+        encode: (ctx) => {
+            return Promise.resolve({
+                ...ctx,
+                headers: {
+                    ...ctx.headers,
+                    'X-Requested-With': 'XMLHttpRequest',
+                }
+            });
+        }
+    };
+}
+
+const DefaultComponents = [
+    // attributes
+    BleetAlertCustomAttribute,
+    BleetBurgerCustomAttribute,
+    BleetDrawerTriggerCustomAttribute,
+    BleetDropdownCustomAttribute,
+    BleetMenuCustomAttribute,
+    BleetModalTriggerCustomAttribute,
+    BleetPagerCustomAttribute,
+    BleetProfileCustomAttribute,
+    BleetPasswordCustomAttribute,
+    BleetSelectCustomAttribute,
+    BleetBadgeCustomAttribute,
+    BleetTabsCustomAttribute,
+    BleetToasterTriggerCustomAttribute,
+    BleetUploadCustomAttribute,
+    BleetAjaxifyTriggerCustomAttribute,
+    // components
+    BleetOverlay,
+    BleetToast,
+    BleetToaster,
+    BleetToasterTrigger,
+    BleetModal,
+    BleetDrawer,
+    BleetAjaxify,
+    Quilljs
+];
+function createBleetConfiguration(optionsCallback) {
+    return {
+        register(container) {
+            const configClass = container.get(IBleetConfiguration);
+            configClass.setContainer(container);
+            if (optionsCallback) {
+                const options = configClass.getConfig();
+                optionsCallback(options);
+            }
+            // Enregistrer l'interface HTTP (toujours disponible)
+            configClass.registerTransportInterface(Transport.Http, IHttpService);
+            // Socketio sera résolu à la demande dans getTransport()
+            return container.register(...DefaultComponents);
+        },
+        customize(callback) {
+            return createBleetConfiguration(callback);
+        }
+    };
+}
+const BleetConfiguration = createBleetConfiguration();
+
+export { AjaxifyAction, AjaxifyCodec, BadgeAction, BleetAjaxify, BleetAjaxifyTriggerCustomAttribute, BleetAlertCustomAttribute, BleetBadgeCustomAttribute, BleetBurgerCustomAttribute, BleetConfiguration, BleetDrawer, BleetDrawerTriggerCustomAttribute, BleetDropdownCustomAttribute, BleetMenuCustomAttribute, BleetModal, BleetModalTriggerCustomAttribute, BleetOverlay, BleetPagerCustomAttribute, BleetPasswordCustomAttribute, BleetProfileCustomAttribute, Quilljs as BleetQuilljs, BleetSelectCustomAttribute, BleetTabsCustomAttribute, BleetToast, BleetToaster, BleetToasterTrigger, BleetToasterTriggerCustomAttribute, BleetUploadCustomAttribute, Channels, CsrfCodec, DialogAction, DrawerAction, DrawerStatus, IApiService, IHttpService, ISocketioService, IStorageService, ISvgService, ITransitionService, ITrapFocusService, MenuAction, MenuStatus, ModalAction, ModalStatus, OverlayAction, OverlayStatus, ProfileAction, ProfileStatus, RequestCodec, ToasterAction, ToasterStatus, Transport, UiColor, UiIcon, UiToastIcon };
+//# sourceMappingURL=index.es.js.map