@mgremy/core 0.19.0 → 0.20.0

package/types/mgremy-core-pipes.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class ArrayFilterPipe<T> implements PipeTransform {
+    transform(value: T[], callback: (x: T) => boolean, mode: 'multiple'): T[];
+    transform(value: T[], callback: (x: T) => boolean, mode: 'single'): T | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFilterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayFilterPipe<any>, "arrayFilter", true>;
+}
+
+declare class LocalizedDatePipe implements PipeTransform {
+    private readonly _translationService;
+    transform(value: any, format?: string, timezone?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedDatePipe, "localizedDate", true>;
+}
+
+declare class EnumKeyValuePairPipe implements PipeTransform {
+    transform(value: object): {
+        key: string;
+        value: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumKeyValuePairPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumKeyValuePairPipe, "enumKeyValuePair", true>;
+}
+
+declare class FirstLetterUpperPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirstLetterUpperPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FirstLetterUpperPipe, "firstLetterUpper", true>;
+}
+
+export { ArrayFilterPipe, EnumKeyValuePairPipe, FirstLetterUpperPipe, LocalizedDatePipe };

package/types/mgremy-core-resolvers.d.ts

@@ -0,0 +1,11 @@
+import { ResolveData } from '@angular/router';
+
+/**
+ * Creates a route resolver that extracts a query parameter value with type safety.
+ * @param key - The query parameter key to extract
+ * @param defaultValue - The default value to use if the parameter is not present
+ * @returns A resolver function for use in Angular route configuration
+ */
+declare const paramResolver: <T extends string | number | boolean>(key: string, defaultValue: T) => ResolveData;
+
+export { paramResolver };

package/types/mgremy-core-types.d.ts

@@ -0,0 +1,14 @@
+import { FormControl, FormArray, FormGroup } from '@angular/forms';
+
+type FlagExcludeType<Base, Type> = {
+    [Key in keyof Base]: Base[Key] extends Type ? never : Key;
+};
+type AllowedNames<Base, Type> = FlagExcludeType<Base, Type>[keyof Base];
+type OmitType<Base, Type> = Pick<Base, AllowedNames<Base, Type>>;
+type ExcludeFuncType<T> = OmitType<T, Function>;
+type FormItems<T> = [T] extends [boolean | number | string | null | undefined | Date] ? FormControl<T> : [T] extends [(infer U)[]] ? FormArray<FormItems<U>> : FormGroup<FormType<T>>;
+type FormType<T> = {
+    [K in keyof ExcludeFuncType<T>]: FormItems<T[K]>;
+};
+
+export type { FormType };

package/types/mgremy-core-utils.d.ts

@@ -0,0 +1,13 @@
+import { PaginationRequest } from '@mgremy/core/models';
+import * as rxjs from 'rxjs';
+import * as z from 'zod';
+
+declare function hasProperty<K extends PropertyKey>(value: unknown, key: K): value is Record<K, unknown>;
+
+type ToURLSearchParamsHandler = (params: URLSearchParams) => void;
+declare function toURLSearchParams(...handlers: ToURLSearchParamsHandler[]): URLSearchParams;
+declare function withPagination<T>(request: PaginationRequest<T>): ToURLSearchParamsHandler;
+
+declare function zParse<T extends z.ZodType>(zObj: T): rxjs.UnaryFunction<rxjs.Observable<unknown>, rxjs.Observable<z.core.output<T>>>;
+
+export { hasProperty, toURLSearchParams, withPagination, zParse };

package/types/mgremy-core.d.ts

@@ -1,7 +1,12 @@
-import { InjectionToken, Signal } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, Type, Provider, EnvironmentProviders, Signal, Injector, ResourceRef } from '@angular/core';
+import { AuthConfig } from 'angular-oauth2-oidc';
+import { Observable } from 'rxjs';
+import { FilterRequest, PaginationResponse, PaginationRequest } from '@mgremy/core/models';
+import { RxResourceOptions } from '@angular/core/rxjs-interop';
 
-declare const APP_CONFIG_SERVICE: InjectionToken<IAppConfigService>;
-interface IAppConfigService {
+declare const CONFIG_SERVICE: InjectionToken<IConfigService>;
+interface IConfigService {
     get appUrl(): string;
     get appBaseHref(): string;
     get apiUrl(): string;
@@ -10,9 +15,96 @@ interface IAppConfigService {
     get authRealm(): string;
     get authClientId(): string;
 }
+declare class ConfigService implements IConfigService {
+    private readonly _environment;
+    private readonly _windowKey;
+    private isValidValue;
+    private getValue;
+    get appUrl(): string;
+    get appBaseHref(): string;
+    get apiUrl(): string;
+    get defaultLanguage(): string;
+    get authUrl(): string;
+    get authRealm(): string;
+    get authClientId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+declare function provideConfig(options?: {
+    service?: Type<IConfigService>;
+}): (Provider | EnvironmentProviders)[];
 
-declare const APP_ENVIRONMENT_SERVICE: InjectionToken<Environment>;
-interface Environment {
+declare const AUTH_SERVICE: InjectionToken<IAuthService>;
+interface IdToken {
+    sub: string;
+    iss: string;
+    aud: string | string[];
+    exp: number;
+    iat: number;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    email?: string;
+    email_verified?: boolean;
+    preferred_username?: string;
+    [key: string]: unknown;
+}
+interface AccessToken {
+    exp: number;
+    iat: number;
+    jti: string | undefined;
+    iss: string;
+    aud: string;
+    sub: string;
+    typ: string | undefined;
+    azp: string | undefined;
+    sid: string | undefined;
+    acr: string | undefined;
+    'allowed-origins': string[] | undefined;
+    realm_access: Record<string, string[]> | undefined;
+    scope: string | undefined;
+    email_verified: boolean | undefined;
+    roles: string[] | undefined;
+    name: string | undefined;
+    preferred_username: string | undefined;
+    given_name: string | undefined;
+    family_name: string | undefined;
+    email: string | undefined;
+}
+interface IAuthService {
+    isAuthenticated: Signal<boolean>;
+    init(): Observable<void>;
+    getIdToken(): IdToken;
+    getAccessToken(): string;
+    getDecodedAccessToken(): AccessToken | undefined;
+    hasRoles(roles: string): boolean;
+    hasRoles(roles: string[], mode: 'any' | 'all'): boolean;
+    login(): void;
+    logout(): void;
+}
+declare class AuthService implements IAuthService {
+    private readonly _authService;
+    private readonly _isAuthenticated;
+    readonly isAuthenticated: Signal<boolean>;
+    constructor();
+    init(): Observable<void>;
+    getIdToken(): IdToken;
+    getAccessToken(): string;
+    getDecodedAccessToken(): AccessToken | undefined;
+    hasRoles(roles: string): boolean;
+    hasRoles(roles: string[], mode: 'any' | 'all'): boolean;
+    login(): void;
+    logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+declare function provideAuthConfig(options?: {
+    service?: Type<IAuthService>;
+    authConfig?: AuthConfig;
+}): (Provider | EnvironmentProviders)[];
+
+declare const ENVIRONMENT_VALUE: InjectionToken<IEnvironment>;
+interface IEnvironment {
     production: boolean;
     appUrl: string;
     appBaseHref: string;
@@ -22,23 +114,51 @@ interface Environment {
     authRealm: string;
     authClientId: string;
 }
+declare function provideEnvironmentConfig(options: {
+    value: IEnvironment;
+}): (Provider | EnvironmentProviders)[];
 
-declare const APP_STORAGE_SERVICE: InjectionToken<IStorageService>;
+declare const STORAGE_SERVICE: InjectionToken<IStorageService>;
 interface IStorageService {
     getItem(key: string): string | undefined;
     setItem(key: string, value: string): void;
     removeItem(key: string): void;
     clear(): void;
 }
+declare class StorageService implements IStorageService {
+    getItem(key: string): string | undefined;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}
+declare function provideStorageConfig(options?: {
+    service?: Type<IStorageService>;
+}): (Provider | EnvironmentProviders)[];
 
-declare const APP_THEME_SERVICE: InjectionToken<IAppThemeService>;
-type AppTheme = 'light' | 'dark';
-interface IAppThemeService {
-    getTheme(): AppTheme;
-    setTheme(value: AppTheme): void;
+declare const THEME_SERVICE: InjectionToken<IThemeService>;
+type Theme = 'light' | 'dark';
+interface IThemeService {
+    getTheme(): Theme;
+    setTheme(value: Theme): void;
+}
+declare class ThemeService implements IThemeService {
+    private readonly _storageService;
+    protected readonly _storageKeys: {
+        theme: string;
+    };
+    constructor();
+    getTheme(): Theme;
+    setTheme(key: Theme): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
 }
+declare function provideThemeConfig(options?: {
+    service?: Type<IThemeService>;
+}): (Provider | EnvironmentProviders)[];
 
-declare const APP_TRANSLATION_SERVICE: InjectionToken<ITranslationService>;
+declare const TRANSLATION_SERVICE: InjectionToken<ITranslationService>;
 interface ITranslationService {
     currentLanguage: Signal<string>;
     init(): void;
@@ -47,6 +167,62 @@ interface ITranslationService {
     instant(key: string[], params?: Record<string, string>): string[];
     instant(key: string | string[], params?: Record<string, string>): string | string[];
 }
+declare class TranslationService implements ITranslationService {
+    private readonly _storageService;
+    private readonly _appConfigService;
+    private readonly _translationService;
+    protected readonly _storageKeys: {
+        lang: string;
+    };
+    protected readonly _currentLanguage: i0.WritableSignal<string>;
+    readonly currentLanguage: Signal<string>;
+    init(): void;
+    setLanguage(code: string): void;
+    instant(key: string, params?: Record<string, string>): string;
+    instant(key: string[], params?: Record<string, string>): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationService>;
+}
+declare function provideTranslationConfig(options?: {
+    service?: Type<ITranslationService>;
+}): (Provider | EnvironmentProviders)[];
+
+declare abstract class BaseComponent {
+    protected readonly _injector: Injector;
+}
+
+/**
+ * Wrapper around PaginationRequest/PaginationResponses and RxResources used side by side with API.
+ * It supports AutoRefreshing data.
+ */
+declare class PaginationContainer<TResult> {
+    /**
+     * Value is computed each time pageNumber | pageSize | sortRequest (if not undefined) is updated.
+     */
+    private readonly _paginationRequest;
+    readonly pageNumber: i0.WritableSignal<number>;
+    readonly pageSize: i0.WritableSignal<number>;
+    readonly sortRequest: i0.WritableSignal<Record<keyof TResult, boolean | undefined>>;
+    readonly filterRequest: i0.WritableSignal<FilterRequest<TResult>[]>;
+    readonly resource: ResourceRef<PaginationResponse<TResult> | undefined>;
+    constructor(resourceOpts: Omit<RxResourceOptions<PaginationResponse<TResult>, PaginationRequest<TResult> | undefined>, 'params'>);
+    /**
+     * Update the sort status on property from TResult.
+     *
+     * It goes undefined -> false -> true.
+     * In terms of usage, it goes undefined -> ASC -> DESC.
+     * @param propertyName The name of the property from TResult on which we want to update the sort status
+     */
+    onSortChange(propertyName: keyof TResult): void;
+}
+declare function paginationContainer<TResult>(resourceOpts: Omit<RxResourceOptions<PaginationResponse<TResult>, PaginationRequest<TResult> | undefined>, 'params'>): PaginationContainer<TResult>;
+
+/**
+ * Generate a unique id for an element
+ * @param prefix - The prefix to use for the id
+ * @returns The generated id
+ */
+declare function uniqueId(prefix: string): string;
 
-export { APP_CONFIG_SERVICE, APP_ENVIRONMENT_SERVICE, APP_STORAGE_SERVICE, APP_THEME_SERVICE, APP_TRANSLATION_SERVICE };
-export type { AppTheme, Environment, IAppConfigService, IAppThemeService, IStorageService, ITranslationService };
+export { AUTH_SERVICE, AuthService, BaseComponent, CONFIG_SERVICE, ConfigService, ENVIRONMENT_VALUE, PaginationContainer, STORAGE_SERVICE, StorageService, THEME_SERVICE, TRANSLATION_SERVICE, ThemeService, TranslationService, paginationContainer, provideAuthConfig, provideConfig, provideEnvironmentConfig, provideStorageConfig, provideThemeConfig, provideTranslationConfig, uniqueId };
+export type { AccessToken, IAuthService, IConfigService, IEnvironment, IStorageService, IThemeService, ITranslationService, IdToken, Theme };

package/utils/README.md

@@ -0,0 +1,3 @@
+# @mgremy/core/src/lib/utils
+
+Secondary entry point of `@mgremy/core`. It can be used by importing from `@mgremy/core/utils`.