@liorian/sdk 0.28.0-alpha.56010ca

package/src/domain/typing/auth-oauth.types.ts

@@ -0,0 +1,172 @@
+/**
+ * Contrats de l'authentification OAuth / MFA du backend `liorian-api-core`.
+ *
+ * Ces types reflètent le payload renvoyé dans `RaitonResponses(message, data, status)`
+ * (le champ `data` de l'enveloppe) pour les endpoints `/mfa/*`, `/otp/*` et `/oauth/*`.
+ * Ils sont partagés par le service `AuthApiService` du SDK.
+ */
+
+/** Facteur d'authentification multi-facteurs. */
+export type AuthFactorType =
+    | 'password'
+    | 'totp'
+    | 'webauthn'
+    | 'otp_email'
+    | 'otp_sms'
+    | 'recovery_code';
+
+export interface AuthFactor {
+    id: string;
+    type: AuthFactorType;
+    label: string;
+    enabled: boolean;
+    verifiedAt?: string;
+}
+
+export interface MfaChallengeResponse {
+    mfaRequired: boolean;
+    challenge?: string;
+    factors?: AuthFactor[];
+}
+
+export interface MfaVerifyResponse {
+    mfaVerified: boolean;
+    mfaToken?: string;
+}
+
+export interface EnrollTotpResponse {
+    authenticatorId: string;
+    otpauthUrl: string;
+    secret: string;
+    qrcode?: string;
+}
+
+export interface RecoveryCodesResponse {
+    codes: string[];
+}
+
+export interface WebAuthnOptions {
+    challenge: string | ArrayBuffer;
+    rp?: {id: string; name: string};
+    user?: {id: string | ArrayBuffer | Uint8Array; name: string; displayName: string};
+    timeout?: number;
+    attestation?: string;
+    authenticatorSelection?: Record<string, unknown>;
+    pubKeyCredParams?: Array<{type: string; alg: number}>;
+    [key: string]: unknown;
+}
+
+export interface AuthMethod {
+    id: string;
+    type: AuthFactorType;
+    label: string;
+    verifiedAt?: string;
+    canRemove: boolean;
+}
+
+export interface AuthorizeClient {
+    clientId: string;
+    name: string;
+    logoUrl?: string;
+    policyUrl?: string;
+    termsUrl?: string;
+}
+
+export interface ScopeDescriptor {
+    name: string;
+    label?: string;
+    description?: string;
+    alreadyGranted: boolean;
+}
+
+export interface ConsentResolution {
+    redirectUri: string;
+    mfaRequired?: boolean;
+    code?: string;
+    error?: string;
+    errorDescription?: string;
+    state?: string;
+}
+
+export interface AuthorizePasskeyOptions {
+    passkeyEnabled: boolean;
+    otpEnabled: boolean;
+    hasPasskey: boolean;
+    challenge?: string | ArrayBuffer;
+    rpId?: string;
+    userVerification?: string;
+    timeout?: number;
+}
+
+export interface AuthorizedApplication {
+    consentId: string;
+    clientId: string;
+    name: string;
+    logoUrl?: string;
+    domain?: string;
+    scopes: string[];
+    grantedAt: string;
+    lastUsedAt?: string;
+}
+
+export interface UserInfo {
+    sub: string;
+    name?: string;
+    preferredUsername?: string;
+    email?: string;
+    organizations?: Array<{id: string; slug?: string; name?: string}>;
+}
+
+export interface OtpCreateResponse {
+    id: string;
+    channel: 'EMAIL' | 'SMS';
+}
+
+export type OtpChannel = 'email' | 'sms';
+
+/** Paramètres d'une demande d'autorisation OAuth (PKCE). */
+export interface AuthorizeParams {
+    clientId: string;
+    redirectUri: string;
+    scope?: string;
+    state?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+}
+
+/** Scope pré-enregistré dans le catalogue `OAuthScope`. */
+export interface OAuthScope {
+    id: string;
+    name: string;
+    label?: string;
+    description?: string;
+    isDefault: boolean;
+    status: boolean;
+}
+
+export type OAuthClientStatusValue = 'PENDING' | 'APPROVED' | 'REJECTED' | 'DISABLED' | 'EXPIRED';
+
+/** Application pré-enregistrée autorisée à utiliser liorian-auth. */
+export interface OAuthClient {
+    id: string;
+    clientId: string;
+    name: string;
+    description?: string;
+    logoUri?: string;
+    bannerUri?: string;
+    domain?: string;
+    scopes: string[];
+    redirectUris: string[];
+    status?: OAuthClientStatusValue;
+}
+
+export interface CreateOAuthClientInput {
+    clientId: string;
+    name: string;
+    description?: string;
+    logoUri?: string;
+    bannerUri?: string;
+    domain?: string;
+    redirectUris?: string[];
+    scopes?: string[];
+}

package/src/domain/typing/devise.ts

@@ -0,0 +1,2 @@
+
+export type DeviseType = string;

package/src/domain/typing/index.ts

@@ -0,0 +1,10 @@
+// @liorian/sdk/domain/typing — shared typing utilities & contracts.
+export * from "./auth-caches";
+export * from "./auth-oauth.types";
+export * from "./devise";
+export * from "./response";
+export * from "./routine.types";
+export * from "./session.interface";
+export * from "./statisticals";
+export * from "./user-media-upload";
+export * from "./values";

package/src/domain/typing/response.ts

@@ -0,0 +1,30 @@
+export interface FetchResponseInterface<T> {
+    data: T;
+    error?: boolean;
+    message?: string;
+    statusCode?: number;
+    errorCode?: number | string;
+}
+
+export interface FetchResponseMetaProps {
+    total?: number;
+    page?: number;
+    limit?: number;
+    totalPages?: number;
+}
+
+export interface FetchResponseWithMetaInterface<T> extends FetchResponseInterface<T> {
+    meta?: FetchResponseMetaProps
+}
+
+export interface PaginationOptions {
+    page?: number;
+    limit?: number;
+}
+
+export interface SearchOptions {
+    search?: string;
+}
+
+export interface PaginationWithSearchOptions extends PaginationOptions, SearchOptions {
+}

package/src/domain/typing/routine.types.ts

@@ -0,0 +1,113 @@
+import {DatasetInstanceType} from "../../infrastructure/stores/dataset.store";
+import {RoutineInstanceStatusEnum, RoutineStatusEnum} from "../enums/routine.enum";
+import {IconKey} from "../../presentation/icons/types";
+import {FC} from "react";
+
+export interface RoutineFindOptionsInterface {
+    id: string;
+    status: RoutineStatusEnum;
+    persist: boolean;
+}
+
+export interface RoutineProps<T extends Object> extends Omit<RoutineInterface<T>, 'dataset' | 'status'> {
+    id: string;
+}
+
+export interface RoutineInterfaceOptions {
+    status?: RoutineStatusEnum;
+    persist?: boolean;
+    icon?: IconKey;
+    name?: string;
+}
+
+export interface RoutineLifeCircle {
+    onJob?(): void;
+
+    onStart?(): void;
+
+    onPause?(): void;
+
+    onStop?(): void;
+
+    onResume?(): void;
+
+    onJobEnd?(): void;
+
+    onJobStart?(): void;
+
+    onRemove?(): void;
+
+    onFail?(error: Error): void;
+}
+
+export interface RoutineUiInterface {
+    icon?: IconKey;
+    name: string | undefined;
+
+    setIcon(icon: IconKey): this;
+}
+
+export interface RoutineInterface<T extends Object> extends RoutineLifeCircle, RoutineUiInterface {
+    readonly id: string;
+
+    readonly dataset: DatasetInstanceType<T>;
+
+    /**
+     Fonctionnalité optionnelle : composant de popover affiché dans le header
+     global au clic (rendu par <HeaderRoutines/> tant que la routine est
+     enregistrée). À surcharger dans une routine concrète ; l'accès paresseux
+     (méthode) évite les problèmes d'ordre d'évaluation des modules.
+
+     Rôles : le SYSTÈME fournit l'icône déclencheur (PopoverTrigger, construit
+     autour de `icon`) et le conteneur <PopoverContent> ; la routine fournit
+     uniquement le CONTENU rendu dans ce conteneur.
+     */
+    popover?(): FC<T>
+
+    /**
+     Fonctionnalité optionnelle : valeur numérique affichée en badge sur
+     l'icône déclencheur du popover (recalculée à chaque cycle de routine).
+     */
+    badge?(): number
+
+    status: RoutineStatusEnum;
+
+    persist: boolean;
+
+    setOption<K extends keyof RoutineInterfaceOptions>(key: K, value: RoutineInterfaceOptions[K]): this;
+
+    getOption<K extends keyof RoutineInterfaceOptions>(key: K): RoutineInterfaceOptions[K] | undefined;
+
+    job(): Promise<T | undefined>;
+}
+
+export interface RoutineInstanceInterface {
+    readonly entries: Set<RoutineInterface<any>>;
+
+    status: RoutineInstanceStatusEnum;
+
+    timeout: number;
+
+    find(options: Partial<RoutineFindOptionsInterface>): RoutineInterface<any>[]
+
+    enqueue<T extends Object>(routine: RoutineInterface<T>): this;
+
+    exists<T extends Object>(id: string): RoutineInterface<T> | undefined;
+
+    run(id?: string): Promise<this>;
+
+    remove(id: string): this;
+
+    clear(force?: boolean): this;
+
+    work(id?: string): this;
+
+    start(id?: string): this;
+
+    pause(id?: string): this;
+
+    stop(id?: string): this;
+
+    resume(id?: string): this;
+
+}

package/src/domain/typing/session.interface.ts

@@ -0,0 +1,28 @@
+
+export interface CreateUserSessionInterface {
+    username?: string;
+    email?: string;
+    phone?: string;
+    password: string;
+    prefix?: string;
+}
+
+export interface CreateUserAccountInterface {
+    username?: string;
+    email: string;
+    password: string;
+    password_confirmation: string;
+    first_names?: string;
+    last_name?: string;
+    phone?: string;
+    otp?: string;
+    country?: string;
+    city?: string;
+    address?: string;
+    gender?: string;
+    birth_date?: string;
+    organization?: string;
+    idRecto?: any;
+    idVerso?: any;
+    selfie?: any;
+}

package/src/domain/typing/statisticals.ts

@@ -0,0 +1,11 @@
+import {DeviseType} from "./devise";
+
+export interface StatisticalProps{
+    label?: string;
+    amount: number;
+    devise?: DeviseType;
+    trend?: number;
+    description?: string;
+    color?: string;
+    fill?: string;
+}

package/src/domain/typing/user-media-upload.ts

@@ -0,0 +1,9 @@
+
+export type UserMediaFieldKey = 'avatar' | 'idRecto' | 'idVerso' | 'selfie';
+
+export interface UserMediaFieldConfig {
+    key: UserMediaFieldKey;
+    label: string;
+    description: string;
+    type: string;
+}

package/src/domain/typing/values.ts

@@ -0,0 +1,6 @@
+export type IStringable = string | number | boolean;
+export type IStringableExtended = IStringable | object;
+export type IStringablePartialExtended = IStringableExtended | null | undefined;
+
+export type UUID = string;
+export type ISODateString = string;

package/src/index.tsx

@@ -0,0 +1,168 @@
+// @liorian/sdk — convenience entry point.
+// Prefer targeted imports: subpaths (`@liorian/sdk/presentation/ui/button`) or
+// folder barrels (`@liorian/sdk/domain/entities`, `@liorian/sdk/infrastructure/hooks`, …).
+
+// ---------------------------------------------------------------------------
+// Domain
+// ---------------------------------------------------------------------------
+export { UserProfileEnum, USER_PROFILE_META } from "./domain/index";
+export type { UserProfileInterface, UserProfiledInterface } from "./domain/index";
+
+// ---------------------------------------------------------------------------
+// Utilities & services
+// ---------------------------------------------------------------------------
+export {
+  cn,
+  CommonClassName,
+  isTauri,
+  requestPushPermission,
+  ACTIVITY_LOCK_PREFERENCE_LABEL,
+  ActivityLockService,
+  FormSnapshotService,
+  ACTIVITY_LOCK_EVENT,
+  ACTIVITY_UNLOCK_EVENT,
+  ACTIVITY_LOCK_FORM_DRAFT_KEY,
+  camelCase,
+  capitalize,
+  capitalizeFirstLetter,
+  kebabToPascalCase,
+  toTitleCase,
+  unCamelCase,
+} from "./infrastructure";
+export type {
+  PushPermissionState,
+  ActivityLockState,
+  ActivityLockOptions,
+  ActivityLockFormField,
+  ActivityLockFormSnapshot,
+} from "./infrastructure";
+
+// ---------------------------------------------------------------------------
+// Hooks
+// ---------------------------------------------------------------------------
+export {
+  useIsMobile,
+  useIsDesktop,
+  useIsTauri,
+  useActivityLockDraft,
+  DESKTOP_BREAKPOINT,
+} from "./infrastructure";
+
+// ---------------------------------------------------------------------------
+// Auth providers
+// ---------------------------------------------------------------------------
+export { AuthProvider, AuthGuard } from "./infrastructure";
+export type { AuthProviderProps } from "./infrastructure";
+
+// ---------------------------------------------------------------------------
+// Components
+// ---------------------------------------------------------------------------
+export {
+  LocalTime,
+  AuthLockScreen,
+  AuthSessionView,
+  SsoSignInView,
+  SsoCallbackView,
+  SsoDisconnectView,
+  Activity,
+} from "./presentation";
+export type {
+  LocalTimeProps,
+  AuthLockScreenProps,
+  SsoSignInViewProps,
+  SsoCallbackViewProps,
+  SsoDisconnectViewProps,
+  ActivityContainerProps,
+  ActivityLoaderProps,
+} from "./presentation";
+
+// ---------------------------------------------------------------------------
+// Theme
+// ---------------------------------------------------------------------------
+export {
+  PreferColorSchemeEnum,
+  ThemePreferColorSchemeProvider,
+  SwitchColorScheme,
+  ThemeSwitcherButton,
+  useThemePreferColorSchemeStore,
+} from "./presentation";
+export type { ThemeCacheInterface } from "./presentation";
+
+// ---------------------------------------------------------------------------
+// Katon theme & dashboard
+// ---------------------------------------------------------------------------
+export {
+  View,
+  ViewWrapper,
+  ViewHelmet,
+  ViewFrame,
+  ViewStatus,
+  DashboardLayout,
+} from "./presentation";
+export type {
+  ScreenViewProps,
+  ViewWrapperProps,
+  ViewHelmetProps,
+  ViewFrameProps,
+  ViewStatusProps,
+  DashboardLayoutProps,
+  DashboardHeaderProps,
+  DashboardHeaderTopProps,
+  DashboardHeaderStartProps,
+  DashboardIconProps,
+  DashboardTitleProps,
+  DashboardDescriptionProps,
+  DashboardActionsProps,
+  DashboardMetricsProps,
+  DashboardMetricCardProps,
+  DashboardBodyProps,
+  DashboardGridProps,
+  DashboardColProps,
+  DashboardSectionProps,
+  DashboardSectionHeaderProps,
+  DashboardSectionTitleProps,
+  DashboardSectionDescriptionProps,
+  DashboardSectionActionsProps,
+  DashboardSectionContentProps,
+  DashboardCardProps,
+  DashboardCardHeaderProps,
+  DashboardCardTitleProps,
+  DashboardCardDescriptionProps,
+  DashboardCardContentProps,
+  DashboardCardFooterProps,
+  DashboardStatGridProps,
+  DashboardItemCardProps,
+  DashboardActionPillProps,
+  DashboardTableProps,
+  DashboardTableHeaderProps,
+  DashboardTableBodyProps,
+  DashboardTableRowProps,
+  DashboardTableHeadProps,
+  DashboardTableCellProps,
+  DashboardBottomBarProps,
+} from "./presentation";
+
+// ---------------------------------------------------------------------------
+// Data
+// ---------------------------------------------------------------------------
+export { UserGenderEnum, countriesConstant } from "./infrastructure";
+export type { CountryInterface } from "./infrastructure";
+
+// ---------------------------------------------------------------------------
+// Design tokens & motion
+// ---------------------------------------------------------------------------
+export { getToken, tokens } from "./infrastructure/library";
+export type { DesignSystemTokens } from "./infrastructure/library";
+export {
+  elasticChild,
+  elasticContainer,
+  elasticEnter,
+  elasticExit,
+  elasticPulse,
+  elasticScaleEnter,
+  elasticSlideInLeft,
+  elasticSlideInRight,
+  elasticSlideUp,
+  staggeredSpringList,
+} from "./infrastructure/library";
+export type { EnterAnimation } from "./infrastructure/library";

package/src/infrastructure/capabilities/cache-storage/capability.ts

@@ -0,0 +1,129 @@
+"use client"
+
+import {ICacheStorageCapability} from "./types";
+import {CacheStorageType} from "./enum";
+import {StackableCapability} from "../stackable/capability";
+import {StackableEntityType} from "../stackable/types";
+import {EncryptionService} from "../../utilities/encryption.service";
+
+
+export class CacheStorageCapability<T extends StackableEntityType>
+    extends StackableCapability<T>
+    implements ICacheStorageCapability<T> {
+
+    private _ready: Promise<T> | null = null;
+
+    constructor(
+        public readonly key: string,
+        public readonly type: CacheStorageType = CacheStorageType.LOCAL,
+        protected readonly encrypted: boolean = true
+    ) {
+        super();
+        this._init();
+    }
+
+    private _init() {
+        if (typeof window !== 'undefined') {
+            this._ready = this.load();
+        }
+    }
+
+    /** Résout une fois le cache chargé depuis le stockage local (décryptage inclus). */
+    async ready(): Promise<T> {
+        if (!this._ready) {
+            this._ready = this.load();
+        }
+        return this._ready;
+    }
+
+    private _getCookies(): Record<string, string> {
+        if (typeof document === 'undefined') return {};
+        return document.cookie.split(';').reduce((acc, cookie) => {
+            const [key, value] = cookie.trim().split('=');
+            if (key && value) acc[key] = decodeURIComponent(value);
+            return acc;
+        }, {} as Record<string, string>);
+    }
+
+    private _setCookie(name: string, value: string, days = 7) {
+        if (typeof document === 'undefined') return;
+        const date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        const expires = "; expires=" + date.toUTCString();
+        document.cookie = name + "=" + encodeURIComponent(value) + expires + "; path=/; SameSite=Strict";
+    }
+
+    async load(): Promise<T> {
+        try {
+            let stack: string | null = null;
+
+            if (typeof window !== 'undefined') {
+                if (this.type === CacheStorageType.LOCAL) {
+                    stack = localStorage.getItem(this.key);
+                } else if (this.type === CacheStorageType.SESSION) {
+                    stack = sessionStorage.getItem(this.key);
+                } else if (this.type === CacheStorageType.COOKIE) {
+                    stack = this._getCookies()[this.key] || null;
+                }
+            } else if (this.type === CacheStorageType.COOKIE) {
+                // Server-side: we might be able to get cookies if we had access to headers,
+                // but in a generic capability we might not have them injected.
+                // For now, return empty or handle via a specialized server-side provider if needed.
+            }
+
+            if (stack && this.encrypted) {
+                try {
+                    const decrypted = await EncryptionService.decrypt(stack);
+                    return this.fromString(decrypted);
+                } catch (e) {
+                    console.error("Decryption error, falling back to raw data:", e);
+                    return this.fromString(stack);
+                }
+            }
+
+            return this.fromString(stack || "{}");
+
+        } catch (e) {
+            console.error(e);
+        }
+
+        return {} as T;
+    }
+
+    async save(): Promise<boolean> {
+        try {
+            const data = this.toJson();
+
+            if (this.encrypted) {
+                const encryptedData = await EncryptionService.encrypt(data);
+                return this._persist(encryptedData);
+            }
+
+            return this._persist(data);
+        } catch (e) {
+            console.error(e);
+        }
+        return false;
+    }
+
+    private _persist(data: string): boolean {
+        if (typeof window === 'undefined') {
+            // Server-side: Cannot persist to localStorage/sessionStorage.
+            // For cookies, we would need to set headers, which usually happens in Middleware or Server Actions.
+            return false;
+        }
+
+        if (this.type === CacheStorageType.LOCAL) {
+            localStorage.setItem(this.key, data);
+        } else if (this.type === CacheStorageType.SESSION) {
+            sessionStorage.setItem(this.key, data);
+        } else if (this.type === CacheStorageType.COOKIE) {
+            this._setCookie(this.key, data);
+        }
+        return true;
+    }
+
+}
+
+
+

package/src/infrastructure/capabilities/cache-storage/enum.ts

@@ -0,0 +1,5 @@
+export enum CacheStorageType {
+    LOCAL = "local",
+    SESSION = "session",
+    COOKIE = "cookie",
+}

package/src/infrastructure/capabilities/cache-storage/index.ts

@@ -0,0 +1,4 @@
+// @liorian/sdk/infrastructure/capabilities/cache-storage
+export * from "./capability";
+export * from "./enum";
+export * from "./types";