@elasticias/core 0.0.16 → 1.0.0

package/fesm2022/elasticias-core.mjs

@@ -1,13 +1,17 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, signal, PLATFORM_ID, computed, effect } from '@angular/core';
+import { Injectable, inject, Injector, signal, PLATFORM_ID, computed, effect, InjectionToken, DestroyRef } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
 import { StorageUtils } from '@elasticias/utils';
+import { TranslateService } from '@ngx-translate/core';
 import { MessageService, ConfirmationService } from 'primeng/api';
-import { Router } from '@angular/router';
-import { PermissionsEnum } from '@elasticias/types';
+import { Router, NavigationEnd } from '@angular/router';
+import { Permissions } from '@elasticias/types';
 import { DOCUMENT, isPlatformBrowser } from '@angular/common';
-import { definePreset } from '@primeng/themes';
+import { palette, updatePrimaryPalette, definePreset } from '@primeng/themes';
 import Aura from '@primeng/themes/aura';
+import Lara from '@primeng/themes/lara';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter } from 'rxjs/operators';
 
 class LoaderService {
     loadingSubject = new BehaviorSubject(false);
@@ -90,26 +94,148 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
-class ToastService {
-    static DEFAULT_DELAY = 3000;
-    static DEFAULT_DELAY_INFO = 5000;
-    messageService = inject(MessageService);
-    showInfo(message, title = 'Information', delay = ToastService.DEFAULT_DELAY_INFO) {
-        this.messageService.add({ severity: 'info', summary: title, detail: message, life: delay });
+/**
+ * Comptoir toast service — V2 successor to the legacy `ToastService`.
+ *
+ * Owns a signal-based queue (`toasts`) consumed by
+ * `<ef-toast-region>`, AND forwards every toast to PrimeNG's
+ * `MessageService` for back-compat with `<p-toast>` (still used by
+ * ClientApp v1). Either renderer picks the toasts up; both work.
+ *
+ * Default i18n keys (override per-call via `titleKey` / `textKey`):
+ * - `ef_toast_info_title`, `ef_toast_info_default`
+ * - `ef_toast_success_title`, `ef_toast_success_default`
+ * - `ef_toast_warn_title`, `ef_toast_warn_default`
+ * - `ef_toast_error_title`, `ef_toast_error_default`
+ *
+ * Default lifespans: info 5s, success 4s, warn 6s, error 8s.
+ */
+class EfToastService {
+    static LIFE_INFO = 5000;
+    static LIFE_SUCCESS = 4000;
+    static LIFE_WARN = 6000;
+    static LIFE_ERROR = 8000;
+    /**
+     * Lazy holders. Resolving TranslateService eagerly at construction
+     * time pulls in HttpClient → HTTP_INTERCEPTORS → AuthorizeInterceptor
+     * → AuthorizeService → ToastService → cycle. We defer to the first
+     * actual translate / message-publish call.
+     */
+    injector = inject(Injector);
+    _translate;
+    _messageService;
+    _messageServiceResolved = false;
+    nextId = 1;
+    /** Live queue — `<ef-toast-region>` renders this. */
+    toasts = signal([], ...(ngDevMode ? [{ debugName: "toasts" }] : /* istanbul ignore next */ []));
+    /* ── Convenience methods (back-compat with the legacy
+         ToastService signature: `(message?, title?, life?)`). ── */
+    showInfo(message, title, life = EfToastService.LIFE_INFO) {
+        this.show({
+            severity: 'info',
+            title: title ?? this.t('ef_toast_info_title'),
+            text: message ?? this.t('ef_toast_info_default'),
+            life,
+        });
+    }
+    showSuccess(message, title, life = EfToastService.LIFE_SUCCESS) {
+        this.show({
+            severity: 'success',
+            title: title ?? this.t('ef_toast_success_title'),
+            text: message ?? this.t('ef_toast_success_default'),
+            life,
+        });
+    }
+    showWarn(message, title, life = EfToastService.LIFE_WARN) {
+        this.show({
+            severity: 'warn',
+            title: title ?? this.t('ef_toast_warn_title'),
+            text: message ?? this.t('ef_toast_warn_default'),
+            life,
+        });
     }
-    showSuccess(message = 'Opération effectuée avec succès !', title = 'Succès', delay = ToastService.DEFAULT_DELAY) {
-        this.messageService.add({ severity: 'success', summary: title, detail: message, life: delay });
+    showError(message, title, life = EfToastService.LIFE_ERROR) {
+        this.show({
+            severity: 'error',
+            title: title ?? this.t('ef_toast_error_title'),
+            text: message ?? this.t('ef_toast_error_default'),
+            life,
+        });
+    }
+    /** Generic show — opts can mix `title`/`titleKey`, `text`/`textKey`. */
+    show(opts) {
+        const severity = opts.severity ?? 'info';
+        const toast = {
+            id: this.nextId++,
+            severity,
+            title: this.resolve(opts.title, opts.titleKey, this.defaultTitleKey(severity)),
+            text: this.resolve(opts.text, opts.textKey, undefined),
+            life: opts.life ?? this.defaultLife(severity),
+            actions: opts.actions,
+        };
+        this.toasts.update(list => [...list, toast]);
+        // Forward to PrimeNG MessageService so v1's <p-toast> still
+        // catches the toast. Sticky in PrimeNG is `life: 0`.
+        this.messageService?.add({
+            severity: toast.severity,
+            summary: toast.title,
+            detail: toast.text,
+            life: toast.life || undefined,
+            sticky: toast.life === 0,
+        });
+        return toast;
+    }
+    get messageService() {
+        if (!this._messageServiceResolved) {
+            this._messageServiceResolved = true;
+            this._messageService = this.injector.get(MessageService, null, { optional: true });
+        }
+        return this._messageService ?? null;
     }
-    showWarn(message, title = 'Avertissement', delay = ToastService.DEFAULT_DELAY) {
-        this.messageService.add({ severity: 'warn', summary: title, detail: message, life: delay });
+    dismiss(id) {
+        this.toasts.update(list => list.filter(t => t.id !== id));
+    }
+    clear() {
+        this.toasts.set([]);
+        this.messageService?.clear();
+    }
+    /* (messageService getter is defined just below `show` to keep it
+        close to where it's consumed.) */
+    /* ── Internals ─────────────────────────────────────────────── */
+    resolve(literal, key, fallbackKey) {
+        if (literal != null)
+            return literal;
+        if (key)
+            return this.t(key);
+        if (fallbackKey)
+            return this.t(fallbackKey);
+        return '';
+    }
+    t(key) {
+        // Lazy-resolve TranslateService — see the field comment above
+        // for the AuthorizeService cycle this avoids.
+        this._translate ??= this.injector.get(TranslateService);
+        const value = this._translate.instant(key);
+        // `instant()` returns the key when no translation is loaded;
+        // fall through to empty string so untranslated toasts don't
+        // surface internal keys to end users.
+        return value === key ? '' : value;
+    }
+    defaultLife(severity) {
+        switch (severity) {
+            case 'info': return EfToastService.LIFE_INFO;
+            case 'success': return EfToastService.LIFE_SUCCESS;
+            case 'warn': return EfToastService.LIFE_WARN;
+            case 'error': return EfToastService.LIFE_ERROR;
+        }
     }
-    showError(message = "Une erreur s'est produite lors du traitement de votre opération.", title = 'Erreur', delay = ToastService.DEFAULT_DELAY) {
-        this.messageService.add({ severity: 'error', summary: title, detail: message, life: delay });
+    defaultTitleKey(severity) {
+        return `ef_toast_${severity}_title`;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: ToastService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfToastService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: ToastService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfToastService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -168,7 +294,7 @@ function screenGuard(config) {
         const router = inject(Router);
         const grantsKey = config?.grantsStorageKey ?? 'CURRENT_USER_GRANTS';
         const deniedRedirect = config?.deniedRedirect ?? '/';
-        const requiredPermission = config?.requiredPermission ?? PermissionsEnum.Read;
+        const requiredPermission = config?.requiredPermission ?? Permissions.Read;
         const storageType = config?.storageType ?? 'local';
         const screenCode = getScreenCode(route);
         // If no screenCode found on this route or any parent, allow access
@@ -243,35 +369,35 @@ class EfThemeConfigService {
     platformId = inject(PLATFORM_ID);
     theme = computed(() => (this.appState()?.darkTheme ? 'dark' : 'light'), ...(ngDevMode ? [{ debugName: "theme" }] : /* istanbul ignore next */ []));
     transitionComplete = signal(false, ...(ngDevMode ? [{ debugName: "transitionComplete" }] : /* istanbul ignore next */ []));
-    initialized = false;
     constructor() {
         const initialState = this.loadAppState();
         this.appState.set({ ...initialState });
+        // Apply preset class + RTL synchronously so the first paint has
+        // the right theme — the effect below picks up subsequent changes
+        // (including any subclass `appState.update()` issued before its
+        // first run).
         this.updatePresetClass(initialState);
+        if (isPlatformBrowser(this.platformId) && initialState?.RTL) {
+            this.document.documentElement.setAttribute('dir', 'rtl');
+        }
         effect(() => {
             const state = this.appState();
-            if (!this.initialized || !state) {
-                this.initialized = true;
+            if (!state)
                 return;
-            }
             this.saveAppState(state);
             this.updatePresetClass(state);
             this.handleDarkModeTransition(state);
             this.applyRTL(state);
         });
-        // Apply RTL on initial load
-        if (isPlatformBrowser(this.platformId)) {
-            if (initialState?.RTL) {
-                this.document.documentElement.setAttribute('dir', 'rtl');
-            }
-        }
     }
     static PRESET_CLASS_MAP = {
         Aura: 'theme-compact',
         Lara: 'theme-modern',
         Material: 'theme-material',
         Nora: 'theme-classic',
+        Comptoir: 'theme-comptoir',
     };
+    static TENANT_RAMP_STOPS = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
     static ALL_THEME_CLASSES = Object.values(EfThemeConfigService.PRESET_CLASS_MAP);
     updatePresetClass(state) {
         if (isPlatformBrowser(this.platformId)) {
@@ -387,6 +513,35 @@ class EfThemeConfigService {
             StorageUtils.setLocal(this.STORAGE_KEY, state);
         }
     }
+    /**
+     * Applies a tenant's brand color across both PrimeNG's primary palette
+     * and the Comptoir `--tenant-*` CSS variables.
+     *
+     * Generates a 50–950 ramp from the input hex via PrimeNG's `palette()`
+     * helper, hands the full ramp to `updatePrimaryPalette()`, and writes
+     * stops 50–900 onto `documentElement.style` so the SCSS layer's
+     * `var(--tenant-*)` references resolve to the tenant's color.
+     *
+     * Call this whenever the active tenant changes (e.g., from an effect
+     * watching `tenantService.storeConfig().primaryColor`).
+     */
+    setTenantAccent(hex) {
+        if (!hex)
+            return;
+        const ramp = palette(hex);
+        if (!ramp)
+            return;
+        updatePrimaryPalette(ramp);
+        if (isPlatformBrowser(this.platformId)) {
+            const root = this.document.documentElement;
+            for (const stop of EfThemeConfigService.TENANT_RAMP_STOPS) {
+                const value = ramp[String(stop)];
+                if (value) {
+                    root.style.setProperty(`--tenant-${stop}`, value);
+                }
+            }
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfThemeConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfThemeConfigService, providedIn: 'root' });
 }
@@ -397,6 +552,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+/* ──────────────────────────────────────────────────────────────────
+ * LEGACY: Noir preset (Aura base, monochrome surface palette).
+ * Kept for backward-compat with apps that haven't migrated to
+ * Comptoir. Phase 5 of the design-system plan retrofits consumers
+ * to EfComptoirTheme; once that lands, Noir + EfTheme can be
+ * deleted.
+ * ────────────────────────────────────────────────────────────── */
 const Noir = definePreset(Aura, {
     semantic: {
         primary: {
@@ -448,13 +610,140 @@ const Noir = definePreset(Aura, {
  * Default Elasticias theme configuration for PrimeNG.
  * Uses the Noir preset (surface-based primary colors) with dark mode support.
  *
+ * @deprecated Migrate to {@link EfComptoirTheme} as part of Phase 5 of the
+ * design-system plan. Will be removed once all consumers have moved.
+ */
+const EfTheme = {
+    preset: Noir,
+    options: {
+        darkModeSelector: '.p-dark',
+    }
+};
+/* ──────────────────────────────────────────────────────────────────
+ * COMPTOIR: ink surface + tenant primary (Lara base).
+ * Surface palette is the ink ramp from libs/tokens/colors.json.
+ * Primary palette defaults to the parfumerie sample tenant; it is
+ * runtime-replaced by EfThemeConfigService.setTenantAccent(hex)
+ * via PrimeNG's updatePrimaryPalette() API.
+ * ────────────────────────────────────────────────────────────── */
+const ComptoirPreset = definePreset(Lara, {
+    semantic: {
+        primary: {
+            50: '#f7f0f4',
+            100: '#ecdce5',
+            200: '#d8b4c5',
+            300: '#b87a99',
+            400: '#934e74',
+            500: '#6f3257',
+            600: '#54243f',
+            700: '#401a30',
+            800: '#2c1221',
+            900: '#1a0913',
+            950: '#0d040a'
+        },
+        /* ──────────────────────────────────────────────────────────────
+         * Control sizing (ADR-009). The native "comptoir" variant is the
+         * default render path and is pinned to --hit-base (40px) in CSS;
+         * these tokens align the OPT-IN PrimeNG variant (p-select filter,
+         * p-multiselect, p-inputnumber stepper, etc.) to the same canonical
+         * heights so the two paths agree:
+         *   base  → 40px (--hit-base)   sm → 32px (--hit)   lg → 48px (--hit-touch, POS/mobile)
+         * Lara form-field height ≈ paddingY*2 + lineHeight(1.5)*fontSize(14px) + 2px border.
+         *   base: 8px*2 + 21 + 2 ≈ 40px · sm: 5px*2 + ~18 + 2 ≈ 32px · lg: 12px*2 + 21 + 2 ≈ 48px
+         * NOTE: exact pixel height depends on the app's root font-size; the
+         * native default path is the verified one — confirm the PrimeNG
+         * opt-in controls visually in the running app and nudge paddingY if
+         * they read 1-2px off. Border radius matches --r-md (12px). */
+        formField: {
+            paddingX: '0.75rem',
+            paddingY: '0.5rem',
+            borderRadius: '12px',
+            sm: {
+                fontSize: '0.78rem',
+                paddingX: '0.625rem',
+                paddingY: '0.3125rem'
+            },
+            lg: {
+                fontSize: '0.9375rem',
+                paddingX: '0.875rem',
+                paddingY: '0.75rem'
+            }
+        },
+        colorScheme: {
+            light: {
+                primary: {
+                    color: '{primary.500}',
+                    contrastColor: '#ffffff',
+                    hoverColor: '{primary.600}',
+                    activeColor: '{primary.700}'
+                },
+                surface: {
+                    0: '#ffffff',
+                    50: '#f8f9fb',
+                    100: '#f1f3f6',
+                    200: '#e4e8ee',
+                    300: '#cdd3dd',
+                    400: '#9ca5b3',
+                    500: '#6c7280',
+                    600: '#4a4f5a',
+                    700: '#2f3239',
+                    800: '#1d1f24',
+                    900: '#0f1115',
+                    950: '#06070a'
+                },
+                highlight: {
+                    background: '{primary.500}',
+                    focusBackground: '{primary.600}',
+                    color: '#ffffff',
+                    focusColor: '#ffffff'
+                }
+            },
+            dark: {
+                primary: {
+                    color: '{primary.400}',
+                    contrastColor: '{primary.950}',
+                    hoverColor: '{primary.300}',
+                    activeColor: '{primary.200}'
+                },
+                surface: {
+                    0: '#000000',
+                    50: '#06070a',
+                    100: '#0f1115',
+                    200: '#1d1f24',
+                    300: '#2f3239',
+                    400: '#4a4f5a',
+                    500: '#6c7280',
+                    600: '#9ca5b3',
+                    700: '#cdd3dd',
+                    800: '#e4e8ee',
+                    900: '#f1f3f6',
+                    950: '#f8f9fb'
+                },
+                highlight: {
+                    background: '{primary.400}',
+                    focusBackground: '{primary.300}',
+                    color: '{primary.950}',
+                    focusColor: '{primary.950}'
+                }
+            }
+        }
+    }
+});
+/**
+ * Comptoir theme configuration for PrimeNG (Phase 1 / design-system v0.2).
+ * Surface palette = ink ramp; primary palette = tenant accent
+ * (runtime-driven via `EfThemeConfigService.setTenantAccent(hex)`).
+ *
  * Usage with providePrimeNG:
  * ```ts
- * providePrimeNG({ theme: EfTheme, ripple: true })
+ * providePrimeNG({ theme: EfComptoirTheme, ripple: true })
  * ```
+ *
+ * Pair with `state.preset = 'Comptoir'` so the body class becomes
+ * `theme-comptoir` (avoids legacy `theme-modern` radius overrides).
  */
-const EfTheme = {
-    preset: Noir,
+const EfComptoirTheme = {
+    preset: ComptoirPreset,
     options: {
         darkModeSelector: '.p-dark',
     }
@@ -847,9 +1136,336 @@ const PRIMENG_AR_LOCALE = {
     },
 };
 
+/**
+ * Default skeleton for the eight ERP modules. Apps either consume this
+ * directly via `EF_MODULES_TOKEN` or extend it with their own `navSections`.
+ *
+ * Phase 1 ships the metadata only — `ef-module-rail` (Phase 2) uses
+ * `id` / `labelKey` / `icon` / `accent` / `defaultRoute`. `navSections`
+ * are populated per-app as each module's screens land in Phase 4-5.
+ */
+const EF_MODULES = [
+    {
+        id: 'sales',
+        labelKey: 'modules.sales',
+        icon: 'pi pi-shopping-bag',
+        accent: 'm-sales',
+        defaultRoute: '/operations/sales',
+        navSections: [],
+        group: 'operations',
+    },
+    {
+        id: 'purchase',
+        labelKey: 'modules.purchase',
+        icon: 'pi pi-truck',
+        accent: 'm-purchase',
+        defaultRoute: '/operations/purchase',
+        navSections: [],
+        group: 'operations',
+    },
+    {
+        id: 'stock',
+        labelKey: 'modules.stock',
+        icon: 'pi pi-warehouse',
+        accent: 'm-stock',
+        defaultRoute: '/operations/stock',
+        navSections: [],
+        group: 'operations',
+    },
+    {
+        id: 'pos',
+        labelKey: 'modules.pos',
+        icon: 'pi pi-shop',
+        accent: 'm-pos',
+        defaultRoute: '/pos',
+        navSections: [],
+        group: 'operations',
+    },
+    {
+        id: 'marketing',
+        labelKey: 'modules.marketing',
+        icon: 'pi pi-megaphone',
+        accent: 'm-marketing',
+        defaultRoute: '/marketing',
+        navSections: [],
+        group: 'commerce',
+    },
+    {
+        id: 'store',
+        labelKey: 'modules.store',
+        icon: 'pi pi-globe',
+        accent: 'm-store',
+        defaultRoute: '/store',
+        navSections: [],
+        group: 'commerce',
+    },
+    {
+        id: 'finance',
+        labelKey: 'modules.finance',
+        icon: 'pi pi-chart-line',
+        accent: 'm-finance',
+        defaultRoute: '/finance',
+        navSections: [],
+        group: 'commerce',
+    },
+    {
+        id: 'admin',
+        labelKey: 'modules.admin',
+        icon: 'pi pi-shield',
+        accent: 'm-admin',
+        defaultRoute: '/admin',
+        navSections: [],
+        group: 'admin',
+    },
+];
+/**
+ * DI token that the shell components (`ef-module-rail`, `ef-module-side`)
+ * read from. Apps provide their own definition (typically extending
+ * `EF_MODULES` with populated `navSections`):
+ *
+ * ```ts
+ * providers: [
+ *   { provide: EF_MODULES_TOKEN, useValue: APP_MODULES }
+ * ]
+ * ```
+ */
+const EF_MODULES_TOKEN = new InjectionToken('EF_MODULES', { providedIn: 'root', factory: () => EF_MODULES });
+
+/**
+ * Single source of truth for "which ERP module is active right now."
+ *
+ * Watches the Router and matches the current URL against each module's
+ * `defaultRoute`. The longest matching prefix wins, so `/operations/sales`
+ * resolves to `sales` even though `/operations` could in theory match
+ * something shorter.
+ *
+ * Consumers — `ef-module-rail`, `ef-module-side`, `ef-app-main`,
+ * `ef-page-head` — read `activeModule()` and derive their state from it.
+ *
+ * Apps that navigate programmatically without a URL change (rare) can
+ * call `setActiveModule(id)` to override.
+ */
+class EfActiveModuleService {
+    router = inject(Router);
+    modules = inject(EF_MODULES_TOKEN);
+    destroyRef = inject(DestroyRef);
+    _activeModule = signal(null, ...(ngDevMode ? [{ debugName: "_activeModule" }] : /* istanbul ignore next */ []));
+    _activeNavItem = signal(null, ...(ngDevMode ? [{ debugName: "_activeNavItem" }] : /* istanbul ignore next */ []));
+    activeModule = this._activeModule.asReadonly();
+    activeModuleId = computed(() => this._activeModule()?.id ?? null, ...(ngDevMode ? [{ debugName: "activeModuleId" }] : /* istanbul ignore next */ []));
+    activeNavItem = this._activeNavItem.asReadonly();
+    constructor() {
+        this.resolveFromUrl(this.router.url);
+        this.router.events
+            .pipe(filter((e) => e instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe(e => this.resolveFromUrl(e.urlAfterRedirects));
+    }
+    /**
+     * Force the active module. Most apps don't need this — the router
+     * subscription keeps `activeModule()` in sync automatically.
+     */
+    setActiveModule(id) {
+        if (id === null) {
+            this._activeModule.set(null);
+            return;
+        }
+        const match = this.modules.find(m => m.id === id);
+        if (match)
+            this._activeModule.set(match);
+    }
+    resolveFromUrl(url) {
+        const path = url.split('?')[0].split('#')[0];
+        let bestModule = null;
+        let bestNavItem = null;
+        let bestLen = 0;
+        for (const m of this.modules) {
+            for (const route of this.routesFor(m)) {
+                if (path === route || path.startsWith(route + '/')) {
+                    if (route.length > bestLen) {
+                        bestModule = m;
+                        bestNavItem = this.findNavItem(m, route);
+                        bestLen = route.length;
+                    }
+                }
+            }
+        }
+        this._activeModule.set(bestModule);
+        this._activeNavItem.set(bestNavItem);
+    }
+    findNavItem(m, route) {
+        for (const section of m.navSections) {
+            for (const item of section.items) {
+                if (item.route === route)
+                    return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * Every URL prefix that should resolve back to this module: the
+     * `defaultRoute` plus every nav item route. Modules whose nav items
+     * span multiple URL prefixes (e.g. sales spread across `/operations/sales`
+     * and `/parameters/sales`) need this to stay active across all of them.
+     */
+    routesFor(m) {
+        const routes = [m.defaultRoute];
+        for (const section of m.navSections) {
+            for (const item of section.items) {
+                routes.push(item.route);
+            }
+        }
+        return routes;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfActiveModuleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfActiveModuleService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfActiveModuleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+const QUERIES = [
+    { viewport: 'mobile', query: '(max-width: 767px)' },
+    { viewport: 'tablet', query: '(min-width: 768px) and (max-width: 1279px)' },
+    { viewport: 'desktop', query: '(min-width: 1280px)' },
+];
+/**
+ * Emits the current viewport tier based on `window.matchMedia` breakpoints.
+ *
+ * Breakpoints come from `libs/tokens/targets.json`:
+ *   - mobile:  ≤ 767px
+ *   - tablet:  768 – 1279px
+ *   - desktop: ≥ 1280px
+ *
+ * SSR-safe: returns `'desktop'` when `window` is unavailable.
+ *
+ * Usage:
+ * ```ts
+ * private viewport = inject(EfViewportService);
+ *
+ * isMobile = computed(() => this.viewport.current() === 'mobile');
+ * ```
+ */
+class EfViewportService {
+    document = inject(DOCUMENT);
+    platformId = inject(PLATFORM_ID);
+    destroyRef = inject(DestroyRef);
+    _current = signal('desktop', ...(ngDevMode ? [{ debugName: "_current" }] : /* istanbul ignore next */ []));
+    current = this._current.asReadonly();
+    isMobile = computed(() => this._current() === 'mobile', ...(ngDevMode ? [{ debugName: "isMobile" }] : /* istanbul ignore next */ []));
+    isTablet = computed(() => this._current() === 'tablet', ...(ngDevMode ? [{ debugName: "isTablet" }] : /* istanbul ignore next */ []));
+    isDesktop = computed(() => this._current() === 'desktop', ...(ngDevMode ? [{ debugName: "isDesktop" }] : /* istanbul ignore next */ []));
+    constructor() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        const win = this.document.defaultView;
+        if (!win || typeof win.matchMedia !== 'function')
+            return;
+        const lists = QUERIES.map(({ viewport, query }) => {
+            const mql = win.matchMedia(query);
+            const handler = (e) => {
+                if (e.matches)
+                    this._current.set(viewport);
+            };
+            handler(mql);
+            mql.addEventListener('change', handler);
+            return { mql, handler };
+        });
+        this.destroyRef.onDestroy(() => {
+            for (const { mql, handler } of lists) {
+                mql.removeEventListener('change', handler);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfViewportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfViewportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfViewportService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+const LEVEL_ORDER = {
+    none: 0,
+    read: 1,
+    write: 2,
+    admin: 3,
+};
+const ACTION_REQUIRED = {
+    read: 'read',
+    write: 'write',
+    admin: 'admin',
+};
+/**
+ * Module-scoped permission service.
+ *
+ * Apps populate it from their auth bootstrap once the user's profile is
+ * loaded — typically via `setPermissions()` or by providing a custom
+ * source signal:
+ *
+ * ```ts
+ * // bootstrap.ts
+ * const perms = inject(EfPermissionService);
+ * perms.setPermissions(profile.permissions);
+ * ```
+ *
+ * The service is the single source of truth for shell components
+ * (`ef-module-rail`, `ef-module-side`, `*efCan` directive) and routing
+ * defaults. Once the screens/menus → Mongo migration lands, the
+ * permissions list will be served denormalized on the user/profile
+ * document and consumed here without a join.
+ */
+class EfPermissionService {
+    modules = inject(EF_MODULES_TOKEN);
+    _permissions = signal([], ...(ngDevMode ? [{ debugName: "_permissions" }] : /* istanbul ignore next */ []));
+    permissions = this._permissions.asReadonly();
+    /**
+     * Replace the current permission set. Pass `[]` to clear (e.g., on logout).
+     */
+    setPermissions(perms) {
+        this._permissions.set(perms);
+    }
+    /**
+     * The level granted to the current user for a given module.
+     * Returns `'none'` if the module is not in the permission set.
+     */
+    level(module) {
+        return this._permissions().find(p => p.module === module)?.level ?? 'none';
+    }
+    /**
+     * Whether the current user can perform `action` on `module`.
+     * Levels are hierarchical: `admin` > `write` > `read` > `none`.
+     */
+    can(module, action = 'read') {
+        return LEVEL_ORDER[this.level(module)] >= LEVEL_ORDER[ACTION_REQUIRED[action]];
+    }
+    /**
+     * The list of modules the user can read, in registry order.
+     * Used by `ef-module-rail` to decide which icons render.
+     */
+    visibleModules = computed(() => {
+        const perms = this._permissions();
+        const granted = new Set(perms.filter(p => p.level !== 'none').map(p => p.module));
+        return this.modules.filter(m => granted.has(m.id));
+    }, ...(ngDevMode ? [{ debugName: "visibleModules" }] : /* istanbul ignore next */ []));
+    /**
+     * The first visible module — the default landing module after login.
+     * Returns `null` when the user has no modules.
+     */
+    defaultModule = computed(() => {
+        return this.visibleModules()[0] ?? null;
+    }, ...(ngDevMode ? [{ debugName: "defaultModule" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfPermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfPermissionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: EfPermissionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { CacheService, ConfirmDialogService, DEFAULT_APP_STATE, EfTheme, EfThemeConfigService, LoaderService, PRIMENG_AR_LOCALE, PRIMENG_EN_LOCALE, PRIMENG_FR_LOCALE, ToastService, hasScreenPermission, screenGuard };
+export { CacheService, ConfirmDialogService, DEFAULT_APP_STATE, EF_MODULES, EF_MODULES_TOKEN, EfActiveModuleService, EfComptoirTheme, EfPermissionService, EfTheme, EfThemeConfigService, EfToastService, EfViewportService, LoaderService, PRIMENG_AR_LOCALE, PRIMENG_EN_LOCALE, PRIMENG_FR_LOCALE, EfToastService as ToastService, hasScreenPermission, screenGuard };
 //# sourceMappingURL=elasticias-core.mjs.map