@elasticias/core 0.0.16 → 1.0.0

package/types/elasticias-core.d.ts

@@ -1,7 +1,9 @@
 import * as rxjs from 'rxjs';
 import * as i0 from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
 import { CanActivateFn } from '@angular/router';
-import { PermissionsEnum } from '@elasticias/types';
+import { Permissions } from '@elasticias/types';
+import * as _primeuix_themes_lara_base from '@primeuix/themes/lara/base';
 import * as _primeuix_themes_types from '@primeuix/themes/types';
 import * as _primeuix_themes_aura_base from '@primeuix/themes/aura/base';
 import { Translation } from 'primeng/api';
@@ -29,16 +31,99 @@ declare class CacheService {
     static ɵprov: i0.ɵɵInjectableDeclaration<CacheService>;
 }
 
-declare class ToastService {
-    private static readonly DEFAULT_DELAY;
-    private static readonly DEFAULT_DELAY_INFO;
-    private readonly messageService;
-    showInfo(message: string, title?: string, delay?: number): void;
-    showSuccess(message?: string, title?: string, delay?: number): void;
-    showWarn(message: string, title?: string, delay?: number): void;
-    showError(message?: string, title?: string, delay?: number): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+/**
+ * Toast severities — mapped 1:1 to the Comptoir status spectrum:
+ * `info` → processing, `success` → delivered, `warn` → pending,
+ * `error` → cancelled.
+ */
+type EfToastSeverity = 'info' | 'success' | 'warn' | 'error';
+/** Optional inline action button rendered at the end of a toast. */
+interface EfToastAction {
+    /** Translation key for the button label — preferred. */
+    labelKey?: string;
+    /** Direct label fallback when `labelKey` is empty. */
+    label?: string;
+    /** Visual tone — `'ghost'` (default) or `'primary'` for the
+     *  destructive / confirm action. */
+    severity?: 'ghost' | 'primary';
+    /** Click handler. */
+    command?: () => void;
+    /** Auto-close the toast after the click runs (default `true`). */
+    dismissOnClick?: boolean;
+}
+/**
+ * Toast options accepted by `EfToastService.show()`. Either a literal
+ * `title` / `text` or their `*Key` translation variants — keys win
+ * unless empty.
+ */
+interface EfToastOptions {
+    severity?: EfToastSeverity;
+    title?: string;
+    titleKey?: string;
+    text?: string;
+    textKey?: string;
+    /** Auto-dismiss in ms; `0` = sticky (no auto-dismiss). */
+    life?: number;
+    actions?: EfToastAction[];
+}
+/** Active toast — instance held in `EfToastService.toasts`. */
+interface EfToast {
+    id: number;
+    severity: EfToastSeverity;
+    title: string;
+    text: string;
+    life: number;
+    actions?: EfToastAction[];
+}
+/**
+ * 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.
+ */
+declare class EfToastService {
+    private static readonly LIFE_INFO;
+    private static readonly LIFE_SUCCESS;
+    private static readonly LIFE_WARN;
+    private static readonly LIFE_ERROR;
+    /**
+     * 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.
+     */
+    private readonly injector;
+    private _translate?;
+    private _messageService?;
+    private _messageServiceResolved;
+    private nextId;
+    /** Live queue — `<ef-toast-region>` renders this. */
+    readonly toasts: i0.WritableSignal<readonly EfToast[]>;
+    showInfo(message?: string, title?: string, life?: number): void;
+    showSuccess(message?: string, title?: string, life?: number): void;
+    showWarn(message?: string, title?: string, life?: number): void;
+    showError(message?: string, title?: string, life?: number): void;
+    /** Generic show — opts can mix `title`/`titleKey`, `text`/`textKey`. */
+    show(opts: EfToastOptions): EfToast;
+    private get messageService();
+    dismiss(id: number): void;
+    clear(): void;
+    private resolve;
+    private t;
+    private defaultLife;
+    private defaultTitleKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EfToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EfToastService>;
 }
 
 declare class ConfirmDialogService {
@@ -56,8 +141,8 @@ interface ScreenGuardConfig {
     grantsStorageKey?: string;
     /** Route to redirect to when access is denied (default: '/') */
     deniedRedirect?: string;
-    /** Minimum required permission to access the screen (default: PermissionsEnum.Read) */
-    requiredPermission?: PermissionsEnum;
+    /** Minimum required permission to access the screen (default: Permissions.Read) */
+    requiredPermission?: Permissions;
     /** Storage type to read grants from (default: 'session') */
     storageType?: 'local' | 'session';
 }
@@ -85,7 +170,7 @@ declare function screenGuard(config?: ScreenGuardConfig): CanActivateFn;
  * Utility function to check if the current user has a specific permission on a screen.
  * Can be used in components/services outside of route guards.
  */
-declare function hasScreenPermission(screenCode: string, permission: PermissionsEnum, grantsStorageKey?: string, storageType?: 'local' | 'session'): boolean;
+declare function hasScreenPermission(screenCode: string, permission: Permissions, grantsStorageKey?: string, storageType?: 'local' | 'session'): boolean;
 
 interface AppState {
     preset?: string;
@@ -114,9 +199,9 @@ declare class EfThemeConfigService {
     platformId: Object;
     theme: i0.Signal<"dark" | "light">;
     transitionComplete: i0.WritableSignal<boolean>;
-    private initialized;
     constructor();
     private static readonly PRESET_CLASS_MAP;
+    private static readonly TENANT_RAMP_STOPS;
     private static readonly ALL_THEME_CLASSES;
     private updatePresetClass;
     private handleDarkModeTransition;
@@ -135,6 +220,19 @@ declare class EfThemeConfigService {
     hideDesigner(): void;
     private loadAppState;
     private saveAppState;
+    /**
+     * 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: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<EfThemeConfigService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EfThemeConfigService>;
 }
@@ -143,13 +241,31 @@ declare class EfThemeConfigService {
  * 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.
+ */
+declare const EfTheme: {
+    preset: _primeuix_themes_types.Preset<_primeuix_themes_aura_base.AuraBaseDesignTokens>;
+    options: {
+        darkModeSelector: string;
+    };
+};
+
+/**
+ * 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).
  */
-declare const EfTheme: {
-    preset: _primeuix_themes_types.Preset<_primeuix_themes_aura_base.AuraBaseDesignTokens>;
+declare const EfComptoirTheme: {
+    preset: _primeuix_themes_types.Preset<_primeuix_themes_lara_base.LaraBaseDesignTokens>;
     options: {
         darkModeSelector: string;
     };
@@ -188,5 +304,205 @@ declare const PRIMENG_FR_LOCALE: Translation;
  */
 declare const PRIMENG_AR_LOCALE: Translation;
 
-export { CacheService, ConfirmDialogService, DEFAULT_APP_STATE, EfTheme, EfThemeConfigService, LoaderService, PRIMENG_AR_LOCALE, PRIMENG_EN_LOCALE, PRIMENG_FR_LOCALE, ToastService, hasScreenPermission, screenGuard };
-export type { AppState, ScreenGuardConfig };
+/**
+ * The eight ERP modules surfaced by Comptoir. New modules require
+ * a matching `--m-{id}` token in the SCSS layer (libs/ui/src/lib/_comptoir.scss)
+ * and a labelKey in the consuming app's i18n bundles.
+ */
+type EfModuleId = 'sales' | 'purchase' | 'stock' | 'pos' | 'marketing' | 'store' | 'finance' | 'admin';
+type EfNavAction = 'read' | 'write' | 'admin';
+interface EfNavItem {
+    /** Stable identifier — usually matches the screen code (e.g. `Users`, `SalesOrders`). */
+    id: string;
+    labelKey: string;
+    icon?: string;
+    route: string;
+    /** Minimum permission level required to render this item. Defaults to `read`. */
+    requiredAction?: EfNavAction;
+    /**
+     * Optional count chip rendered after the label (e.g. `Commandes ⟨14⟩`).
+     * Apps typically derive this from a service signal and patch the
+     * registry — it can be number, string, or anything stringifiable.
+     */
+    badge?: string | number;
+}
+interface EfNavSection {
+    id: string;
+    labelKey?: string;
+    items: EfNavItem[];
+}
+interface EfModule {
+    id: EfModuleId;
+    labelKey: string;
+    /** PrimeNG icon class used by `ef-module-rail`, e.g. `pi pi-shopping-bag`. */
+    icon: string;
+    /**
+     * CSS custom-property name (without the leading `--`) that the rail
+     * applies to the module-current accent. Always `m-{id}` and resolves
+     * via the SCSS layer's `[data-module]` selectors at runtime.
+     */
+    accent: `m-${EfModuleId}`;
+    defaultRoute: string;
+    navSections: EfNavSection[];
+    /**
+     * Logical grouping for rail divider placement. `ef-module-rail` renders
+     * a 1px divider between two consecutive visible modules whose `group`
+     * differs. Free string — `'operations' | 'commerce' | 'admin'` is the
+     * conventional set but apps can use anything stable.
+     */
+    group?: string;
+}
+/**
+ * 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.
+ */
+declare const EF_MODULES: ReadonlyArray<EfModule>;
+/**
+ * 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 }
+ * ]
+ * ```
+ */
+declare const EF_MODULES_TOKEN: InjectionToken<readonly EfModule[]>;
+
+/**
+ * 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.
+ */
+declare class EfActiveModuleService {
+    private readonly router;
+    private readonly modules;
+    private readonly destroyRef;
+    private readonly _activeModule;
+    private readonly _activeNavItem;
+    readonly activeModule: i0.Signal<EfModule | null>;
+    readonly activeModuleId: i0.Signal<EfModuleId | null>;
+    readonly activeNavItem: i0.Signal<EfNavItem | null>;
+    constructor();
+    /**
+     * Force the active module. Most apps don't need this — the router
+     * subscription keeps `activeModule()` in sync automatically.
+     */
+    setActiveModule(id: EfModuleId | null): void;
+    private resolveFromUrl;
+    private findNavItem;
+    /**
+     * 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.
+     */
+    private routesFor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EfActiveModuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EfActiveModuleService>;
+}
+
+type EfViewport = 'mobile' | 'tablet' | 'desktop';
+/**
+ * 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');
+ * ```
+ */
+declare class EfViewportService {
+    private readonly document;
+    private readonly platformId;
+    private readonly destroyRef;
+    private readonly _current;
+    readonly current: i0.Signal<EfViewport>;
+    readonly isMobile: i0.Signal<boolean>;
+    readonly isTablet: i0.Signal<boolean>;
+    readonly isDesktop: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EfViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EfViewportService>;
+}
+
+type EfPermissionLevel = 'none' | 'read' | 'write' | 'admin';
+interface EfModulePermission {
+    module: EfModuleId;
+    level: EfPermissionLevel;
+}
+/**
+ * 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.
+ */
+declare class EfPermissionService {
+    private readonly modules;
+    private readonly _permissions;
+    readonly permissions: Signal<readonly EfModulePermission[]>;
+    /**
+     * Replace the current permission set. Pass `[]` to clear (e.g., on logout).
+     */
+    setPermissions(perms: ReadonlyArray<EfModulePermission>): void;
+    /**
+     * The level granted to the current user for a given module.
+     * Returns `'none'` if the module is not in the permission set.
+     */
+    level(module: EfModuleId): EfPermissionLevel;
+    /**
+     * Whether the current user can perform `action` on `module`.
+     * Levels are hierarchical: `admin` > `write` > `read` > `none`.
+     */
+    can(module: EfModuleId, action?: Exclude<EfPermissionLevel, 'none'>): boolean;
+    /**
+     * The list of modules the user can read, in registry order.
+     * Used by `ef-module-rail` to decide which icons render.
+     */
+    readonly visibleModules: Signal<ReadonlyArray<EfModule>>;
+    /**
+     * The first visible module — the default landing module after login.
+     * Returns `null` when the user has no modules.
+     */
+    readonly defaultModule: Signal<EfModule | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EfPermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EfPermissionService>;
+}
+
+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 };
+export type { AppState, EfModule, EfModuleId, EfModulePermission, EfNavAction, EfNavItem, EfNavSection, EfPermissionLevel, EfToast, EfToastAction, EfToastOptions, EfToastSeverity, EfViewport, ScreenGuardConfig };