@igo2/core 21.0.0-next.2 → 21.0.0-next.21

package/types/igo2-core-message.d.ts

@@ -1,40 +1,121 @@
 import * as i0 from '@angular/core';
-import { ModuleWithProviders, TemplateRef, EnvironmentProviders } from '@angular/core';
-import { IndividualConfig, ActiveToast } from 'ngx-toastr';
+import { OnInit, OnDestroy, EnvironmentProviders } from '@angular/core';
 import { HttpErrorResponse } from '@angular/common/http';
 import { BehaviorSubject } from 'rxjs';
-
-/**
- * @deprecated import the provideMessage directly
- */
-declare class IgoMessageModule {
-    static forRoot(): ModuleWithProviders<IgoMessageModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IgoMessageModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoMessageModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<IgoMessageModule>;
-}
+import { SafeHtml } from '@angular/platform-browser';
 
 declare enum MessageType {
     ERROR = "error",
-    ALERT = "warning",// todo delete (transition to ngx-toastr)
+    ALERT = "warning",
     WARNING = "warning",
     INFO = "info",
     SUCCESS = "success",
     SHOW = "show"
 }
 
+interface ToastConfig {
+    timeOut: number;
+    extendedTimeOut: number;
+    closeButton: boolean;
+    progressBar: boolean;
+    tapToDismiss: boolean;
+    positionClass: string;
+    maxOpened: number;
+    preventDuplicates: boolean;
+    enableHtml: boolean;
+    disableTimeOut: boolean;
+    showIcon: boolean;
+    freezeProgressOnHover: boolean;
+}
+type IndividualToastConfig = Partial<ToastConfig>;
+interface ToastRef {
+    toastId: number;
+    message: string;
+    title: string;
+    type: ToastType;
+    config: ToastConfig;
+}
+type ToastType = 'success' | 'error' | 'info' | 'warning' | 'show';
+declare const DEFAULT_TOAST_CONFIG: ToastConfig;
+
+declare class ToastComponent implements OnInit, OnDestroy {
+    private toastService;
+    private sanitizer;
+    toastId: number;
+    type: ToastType;
+    title: string;
+    config: ToastConfig;
+    enableHtml: boolean;
+    showIcon: boolean;
+    private _message;
+    safeMessage: SafeHtml;
+    get message(): string;
+    set message(value: string);
+    progress: i0.WritableSignal<number>;
+    animationState: i0.WritableSignal<"inactive" | "active" | "removed">;
+    private timeoutId;
+    private progressIntervalId;
+    private startTime;
+    private remainingTime;
+    private totalTimeOut;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onEnter(): void;
+    onLeave(): void;
+    onTap(): void;
+    close(event: Event): void;
+    remove(): void;
+    private startTimer;
+    private clearTimers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "igo-toast", never, {}, {}, never, never, true, never>;
+}
+
+declare class ToastContainerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastContainerComponent, "igo-toast-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface ActiveToast {
+    toastId: number;
+}
+declare class ToastService {
+    private appRef;
+    private document;
+    private toastIdCounter;
+    private toasts;
+    private containerRef;
+    private config;
+    private lastMessage;
+    private lastTitle;
+    configure(config: Partial<ToastConfig>): void;
+    success(message: string, title: string, options?: IndividualToastConfig): ActiveToast;
+    error(message: string, title: string, options?: IndividualToastConfig): ActiveToast;
+    info(message: string, title: string, options?: IndividualToastConfig): ActiveToast;
+    warning(message: string, title: string, options?: IndividualToastConfig): ActiveToast;
+    remove(toastId: number): void;
+    /** Called by ToastComponent when removal animation completes */
+    removeToast(toastId: number): void;
+    getActiveToasts(): ToastRef[];
+    updateToast(toastId: number, message: string, title: string): void;
+    private show;
+    private getOrCreateContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
 interface Message {
     title?: string;
-    text?: string;
-    html?: string | TemplateRef<any>;
-    type?: MessageType;
+    text: string;
+    html?: string;
+    type: MessageType;
     options?: MessageOptions;
     format?: 'text' | 'html';
-    textInterpolateParams?: object;
-    titleInterpolateParams?: object;
+    textInterpolateParams?: Record<string, unknown>;
+    titleInterpolateParams?: Record<string, unknown>;
     showIcon?: boolean;
 }
-interface MessageOptions extends IndividualConfig {
+interface MessageOptions extends IndividualToastConfig {
     template?: string;
     from?: Date | string;
     to?: Date | string;
@@ -42,31 +123,35 @@ interface MessageOptions extends IndividualConfig {
     showOnEachLayerVisibility?: boolean;
 }
 
-declare function provideMessage(): EnvironmentProviders;
+/**
+ * Provides the message service with custom toast configuration.
+ * Since ToastService is providedIn: 'root', this simply configures it.
+ */
+declare function provideMessage(config?: Partial<ToastConfig>): EnvironmentProviders;
 
 declare class MessageService {
-    private injector;
     private configService;
     private languageService;
+    private toastService;
     messages$: BehaviorSubject<Message[]>;
     private options?;
-    private activeMessageTranslations;
     constructor();
-    private get toastr();
-    showError(httpError: HttpErrorResponse): ActiveToast<any>;
+    showError(httpError: HttpErrorResponse): ActiveToast;
     message(message: Message): void;
-    success(text: string, title?: string, options?: Partial<IndividualConfig>, textInterpolateParams?: object, titleInterpolateParams?: object): ActiveToast<any>;
-    error(text: string, title?: string, options?: Partial<IndividualConfig>, textInterpolateParams?: object, titleInterpolateParams?: object): ActiveToast<any>;
-    info(text: string, title?: string, options?: Partial<IndividualConfig>, textInterpolateParams?: object, titleInterpolateParams?: object): ActiveToast<any>;
-    alert(text: string, title?: string, options?: Partial<IndividualConfig>, textInterpolateParams?: object, titleInterpolateParams?: object): ActiveToast<any>;
-    show(text: string, title?: string, options?: Partial<IndividualConfig>, textInterpolateParams?: object, titleInterpolateParams?: object): ActiveToast<any>;
-    private handleNgxToastr;
-    remove(id?: number): void;
+    success(text: string, title?: string, options?: IndividualToastConfig, textInterpolateParams?: Record<string, unknown>, titleInterpolateParams?: Record<string, unknown>): ActiveToast;
+    error(text: string, title?: string, options?: IndividualToastConfig, textInterpolateParams?: Record<string, unknown>, titleInterpolateParams?: Record<string, unknown>): ActiveToast;
+    info(text: string, title?: string, options?: IndividualToastConfig, textInterpolateParams?: Record<string, unknown>, titleInterpolateParams?: Record<string, unknown>): ActiveToast;
+    alert(text: string, title?: string, options?: IndividualToastConfig, textInterpolateParams?: Record<string, unknown>, titleInterpolateParams?: Record<string, unknown>): ActiveToast;
+    show(text: string, title?: string, options?: IndividualToastConfig, textInterpolateParams?: Record<string, unknown>, titleInterpolateParams?: Record<string, unknown>): ActiveToast;
+    private handleToast;
+    private parseDate;
+    private translateInterpolateParams;
+    remove(id: number): void;
     removeAllAreNotError(): void;
     private handleTemplate;
     static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
 }
 
-export { IgoMessageModule, MessageService, MessageType, provideMessage };
-export type { Message, MessageOptions };
+export { DEFAULT_TOAST_CONFIG, MessageService, MessageType, ToastComponent, ToastContainerComponent, ToastService, provideMessage };
+export type { ActiveToast, IndividualToastConfig, Message, MessageOptions, ToastConfig, ToastRef, ToastType };

package/types/igo2-core-monitoring.d.ts

@@ -33,7 +33,7 @@ declare const identifySentryUser: (user: BaseUser | null) => void;
 
 type AnyMonitoringOptions = SentryMonitoringOptions;
 
-declare const MONITORING_OPTIONS: InjectionToken<MonitoringOptions>;
+declare const MONITORING_OPTIONS: InjectionToken<MonitoringOptions | null>;
 
 declare const MOCK_SENTRY_OPTIONS: SentryMonitoringOptions;
 declare const MOCK_MONITORING_OPTIONS: AnyMonitoringOptions;

package/types/igo2-core-network.d.ts

@@ -8,11 +8,10 @@ interface ConnectionState {
 
 declare class NetworkService implements OnDestroy {
     private messageService;
-    private injector;
     private stateChangeEventEmitter;
-    private onlineSubscription;
-    private offlineSubscription;
-    private previousMessageId;
+    private onlineSubscription?;
+    private offlineSubscription?;
+    private previousMessageId?;
     private state;
     constructor();
     private checkNetworkState;

package/types/igo2-core-regex.d.ts

@@ -7,7 +7,7 @@ declare class RegexService {
     protected options: RegexOptions;
     constructor();
     getAll(): RegexOptions;
-    get(key: any): any;
+    get(key: string): any;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegexService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RegexService>;
 }

package/types/igo2-core-storage.d.ts

@@ -25,8 +25,8 @@ declare enum StorageServiceEventEnum {
 
 declare abstract class BaseStorage<T extends StorageOptions = StorageOptions> {
     protected options?: T;
-    storageChange$: BehaviorSubject<StorageServiceEvent>;
-    constructor(config: ConfigService);
+    storageChange$: BehaviorSubject<StorageServiceEvent | undefined>;
+    constructor(config?: ConfigService | null);
     /**
      * Use to get the data found in storage file
      */