@esfaenza/extensions 20.3.7 → 20.3.8

package/index.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
-import { PipeTransform, ModuleWithProviders, Injector, EventEmitter, Type, InjectionToken } from '@angular/core';
+import { PipeTransform, ViewContainerRef, Injector, ComponentRef, NgZone, OnDestroy, ApplicationRef, ModuleWithProviders, EventEmitter, Type, InjectionToken } from '@angular/core';
 import * as i2 from '@esfaenza/localizations';
 import { BaseLocalization, LocalizationService } from '@esfaenza/localizations';
-import { ReplaySubject, Subject, Observable } from 'rxjs';
+import { ReplaySubject, Observable, Subscription, Subject } from 'rxjs';
 import { Location } from '@angular/common';
 import { Router, ActivatedRoute } from '@angular/router';
 import { NgForm } from '@angular/forms';
@@ -140,10 +140,414 @@ declare class LocDatePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<LocDatePipe, "loc_date", false>;
 }
 
+type ComponentType<T> = new (...args: unknown[]) => T;
+/**
+ * A `ComponentPortal` is a portal that instantiates some Component upon attachment.
+ */
+declare class ComponentPortal<T> {
+    private _attachedHost?;
+    /** The type of the component that will be instantiated for attachment. */
+    component: ComponentType<T>;
+    /**
+     * [Optional] Where the attached component should live in Angular's *logical* component tree.
+     * This is different from where the component *renders*, which is determined by the PortalHost.
+     * The origin necessary when the host is outside of the Angular application context.
+     */
+    viewContainerRef: ViewContainerRef;
+    /** Injector used for the instantiation of the component. */
+    injector: Injector;
+    constructor(component: ComponentType<T>, injector: Injector);
+    /** Attach this portal to a host. */
+    attach(host: BasePortalHost, newestOnTop: boolean): ComponentRef<unknown>;
+    /** Detach this portal from its host */
+    detach(): void;
+    /** Whether this portal is attached to a host. */
+    get isAttached(): boolean;
+    /**
+     * Sets the PortalHost reference without performing `attach()`. This is used directly by
+     * the PortalHost when it is performing an `attach()` or `detach()`.
+     */
+    setAttachedHost(host?: BasePortalHost): void;
+}
+/**
+ * Partial implementation of PortalHost that only deals with attaching a
+ * ComponentPortal
+ */
+declare abstract class BasePortalHost {
+    /** The portal currently attached to the host. */
+    private _attachedPortal?;
+    /** A function that will permanently dispose this host. */
+    private _disposeFn?;
+    attach(portal: ComponentPortal<unknown>, newestOnTop: boolean): ComponentRef<unknown>;
+    abstract attachComponentPortal<T>(portal: ComponentPortal<T>, newestOnTop: boolean): ComponentRef<T>;
+    detach(): void;
+    setDisposeFn(fn: () => void): void;
+}
+
+/**
+ * Reference to an overlay that has been created with the Overlay service.
+ * Used to manipulate or dispose of said overlay.
+ */
+declare class OverlayRef {
+    private _portalHost;
+    constructor(_portalHost: BasePortalHost);
+    attach(portal: ComponentPortal<unknown>, newestOnTop?: boolean): ComponentRef<unknown>;
+    /**
+     * Detaches an overlay from a portal.
+     * @returns Resolves when the overlay has been detached.
+     */
+    detach(): void;
+}
+
+/**
+ * Reference to a toast opened via the Toastr service.
+ */
+declare class ToastRef<T> {
+    private _overlayRef;
+    /** The instance of component opened into the toast. */
+    componentInstance: T;
+    /** Count of duplicates of this toast */
+    private duplicatesCount;
+    /** Subject for notifying the user that the toast has finished closing. */
+    private _afterClosed;
+    /** triggered when toast is activated */
+    private _activate;
+    /** notifies the toast that it should close before the timeout */
+    private _manualClose;
+    /** notifies the toast that it should reset the timeouts */
+    private _resetTimeout;
+    /** notifies the toast that it should count a duplicate toast */
+    private _countDuplicate;
+    constructor(_overlayRef: OverlayRef);
+    manualClose(): void;
+    manualClosed(): Observable<unknown>;
+    timeoutReset(): Observable<unknown>;
+    countDuplicate(): Observable<number>;
+    /**
+     * Close the toast.
+     */
+    close(): void;
+    /** Gets an observable that is notified when the toast is finished closing. */
+    afterClosed(): Observable<void>;
+    isInactive(): boolean;
+    activate(): void;
+    /** Gets an observable that is notified when the toast has started opening. */
+    afterActivate(): Observable<void>;
+    /** Reset the toast timouts and count duplicates */
+    onDuplicate(resetTimeout: boolean, countDuplicate: boolean): void;
+}
+
+type ProgressAnimationType = 'increasing' | 'decreasing';
+type DisableTimoutType = boolean | 'timeOut' | 'extendedTimeOut';
+/**
+ * Configuration for an individual toast.
+ */
+interface IndividualConfig<ConfigPayload = unknown> {
+    /**
+     * disable both timeOut and extendedTimeOut
+     * default: false
+     */
+    disableTimeOut: DisableTimoutType;
+    /**
+     * toast time to live in milliseconds
+     * default: 5000
+     */
+    timeOut: number;
+    /**
+     * toast show close button
+     * default: false
+     */
+    closeButton: boolean;
+    /**
+     * time to close after a user hovers over toast
+     * default: 1000
+     */
+    extendedTimeOut: number;
+    /**
+     * show toast progress bar
+     * default: false
+     */
+    progressBar: boolean;
+    /**
+     * changes toast progress bar animation
+     * default: decreasing
+     */
+    progressAnimation: ProgressAnimationType;
+    /**
+     * render html in toast message (possibly unsafe)
+     * default: false
+     */
+    enableHtml: boolean;
+    /**
+     * css class on toast component
+     * default: ngx-toastr
+     */
+    toastClass: string;
+    /**
+     * css class on toast container
+     * default: toast-top-right
+     */
+    positionClass: string;
+    /**
+     * css class on toast title
+     * default: toast-title
+     */
+    titleClass: string;
+    /**
+     * css class on toast message
+     * default: toast-message
+     */
+    messageClass: string;
+    /**
+     * animation easing on toast
+     * default: ease-in
+     */
+    easing: string;
+    /**
+     * animation ease time on toast
+     * default: 300
+     */
+    easeTime: string | number;
+    /**
+     * clicking on toast dismisses it
+     * default: true
+     */
+    tapToDismiss: boolean;
+    /**
+     * Angular toast component to be shown
+     * default: Toast
+     */
+    toastComponent?: ComponentType<unknown>;
+    /**
+     * Helps show toast from a websocket or from event outside Angular
+     * default: false
+     */
+    onActivateTick: boolean;
+    /**
+     * New toast placement
+     * default: true
+     */
+    newestOnTop: boolean;
+    /**
+     * Payload to pass to the toast component
+     */
+    payload?: ConfigPayload;
+}
+interface ToastrIconClasses {
+    error: string;
+    info: string;
+    success: string;
+    warning: string;
+    [key: string]: string;
+}
+/**
+ * Global Toast configuration
+ * Includes all IndividualConfig
+ */
+interface GlobalConfig<C = unknown> extends IndividualConfig<C> {
+    /**
+     * max toasts opened. Toasts will be queued
+     * Zero is unlimited
+     * default: 0
+     */
+    maxOpened: number;
+    /**
+     * dismiss current toast when max is reached
+     * default: false
+     */
+    autoDismiss: boolean;
+    iconClasses: Partial<ToastrIconClasses>;
+    /**
+     * block duplicate messages
+     * default: false
+     */
+    preventDuplicates: boolean;
+    /**
+     * display the number of duplicate messages
+     * default: false
+     */
+    countDuplicates: boolean;
+    /**
+     * Reset toast timeout when there's a duplicate (preventDuplicates needs to be set to true)
+     * default: false
+     */
+    resetTimeoutOnDuplicate: boolean;
+    /**
+     * consider the title of a toast when checking if duplicate
+     * default: false
+     */
+    includeTitleDuplicates: boolean;
+}
+/**
+ * Everything a toast needs to launch
+ */
+declare class ToastPackage<ConfigPayload = unknown> {
+    toastId: number;
+    config: IndividualConfig<ConfigPayload>;
+    message: string | null | undefined;
+    title: string | undefined;
+    toastType: string;
+    toastRef: ToastRef<unknown>;
+    private _onTap;
+    private _onAction;
+    constructor(toastId: number, config: IndividualConfig<ConfigPayload>, message: string | null | undefined, title: string | undefined, toastType: string, toastRef: ToastRef<unknown>);
+    /** Fired on click */
+    triggerTap(): void;
+    onTap(): Observable<void>;
+    /** available for use in custom toast */
+    triggerAction(action?: unknown): void;
+    onAction(): Observable<unknown>;
+}
+
+declare class ToastContainerDirective {
+    private el;
+    getContainerElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToastContainerDirective, "[toastContainer]", ["toastContainer"], {}, {}, never, never, true, never>;
+}
+
+interface ActiveToast<C> {
+    /** Your Toast ID. Use this to close it individually */
+    toastId: number;
+    /** the title of your toast. Stored to prevent duplicates */
+    title: string;
+    /** the message of your toast. Stored to prevent duplicates */
+    message: string;
+    /** a reference to the component see portal.ts */
+    portal: ComponentRef<C>;
+    /** a reference to your toast */
+    toastRef: ToastRef<C>;
+    /** triggered when toast is active */
+    onShown: Observable<void>;
+    /** triggered when toast is destroyed */
+    onHidden: Observable<void>;
+    /** triggered on toast click */
+    onTap: Observable<void>;
+    /** available for your use in custom toast */
+    onAction: Observable<unknown>;
+}
+declare class ToastrService {
+    private overlay;
+    private _injector;
+    private sanitizer;
+    private ngZone;
+    toastrConfig: GlobalConfig;
+    currentlyActive: number;
+    toasts: ActiveToast<unknown>[];
+    overlayContainer?: ToastContainerDirective;
+    previousToastMessage: string | undefined;
+    private index;
+    constructor();
+    /** show toast */
+    show<C extends ToastBase = ToastBase, ConfigPayload = unknown>(message?: string, title?: string, override?: Partial<IndividualConfig<ConfigPayload>>, type?: string): ActiveToast<C> | null;
+    /** show successful toast */
+    success<ConfigPayload = unknown>(message?: string, title?: string, override?: Partial<IndividualConfig<ConfigPayload>>): ActiveToast<unknown>;
+    /** show error toast */
+    error<ConfigPayload = unknown>(message?: string, title?: string, override?: Partial<IndividualConfig<ConfigPayload>>): ActiveToast<unknown>;
+    /** show info toast */
+    info<ConfigPayload = unknown>(message?: string, title?: string, override?: Partial<IndividualConfig<ConfigPayload>>): ActiveToast<unknown>;
+    /** show warning toast */
+    warning<ConfigPayload = unknown>(message?: string, title?: string, override?: Partial<IndividualConfig<ConfigPayload>>): ActiveToast<unknown>;
+    /**
+     * Remove all or a single toast by id
+     */
+    clear(toastId?: number): void;
+    /**
+     * Remove and destroy a single toast by id
+     */
+    remove(toastId: number): boolean;
+    /**
+     * Determines if toast message is already shown
+     */
+    findDuplicate(title: string, message: string, resetOnDuplicate: boolean, countDuplicates: boolean): ActiveToast<unknown>;
+    /** create a clone of global config and apply individual settings */
+    private applyConfig;
+    /**
+     * Find toast object by id
+     */
+    private _findToast;
+    /**
+     * Determines the need to run inside angular's zone then builds the toast
+     */
+    private _preBuildNotification;
+    /**
+     * Creates and attaches toast data to component
+     * returns the active toast, or in case preventDuplicates is enabled the original/non-duplicate active toast.
+     */
+    private _buildNotification;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastrService>;
+}
+
+declare class TimeoutsService {
+    protected ngZone?: NgZone;
+    setInterval(func: () => unknown, timeout: number): number;
+    setTimeout(func: () => unknown, timeout?: number): number;
+    protected runInsideAngular(func: () => unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeoutsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimeoutsService>;
+}
+
+declare class ToastBase<ConfigPayload = unknown> implements OnDestroy {
+    toastPackage: ToastPackage<any>;
+    protected toastrService: ToastrService;
+    protected appRef: ApplicationRef;
+    protected timeoutsService: TimeoutsService;
+    duplicatesCount: number;
+    protected hideTime: number;
+    /** width of progress bar */
+    readonly width: i0.WritableSignal<number>;
+    readonly state: i0.WritableSignal<"inactive" | "active" | "removed">;
+    /** hides component when waiting to be displayed */
+    readonly displayStyle: i0.Signal<string>;
+    readonly message: i0.Signal<string>;
+    readonly title: i0.Signal<string>;
+    readonly options: i0.WritableSignal<IndividualConfig<ConfigPayload>>;
+    readonly originalTimeout: i0.Signal<number>;
+    readonly toastClasses: i0.Signal<string>;
+    protected timeout: number | undefined;
+    protected intervalId: number | undefined;
+    protected afterActivateSubscription: Subscription;
+    protected manualClosedSubscription: Subscription;
+    protected timeoutResetSubscription: Subscription;
+    protected countDuplicateSubscription: Subscription;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * activates toast and sets timeout
+     */
+    activateToast(): void;
+    /**
+     * updates progress bar width
+     */
+    updateProgress(): void;
+    resetTimeout(): void;
+    /**
+     * tells toastrService to remove this toast after animation time
+     */
+    remove(): void;
+    tapToast(): void;
+    stickAround(): void;
+    delayedHideToast(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastBase<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastBase<any>, "[toast-component]", never, {}, {}, never, never, true, never>;
+}
+
+declare class Toast<ConfigPayload = unknown> extends ToastBase<ConfigPayload> {
+    readonly params: {
+        easeTime: string | number;
+        easing: string;
+    };
+    private elementRef;
+    remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Toast<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Toast<any>, "[toast-component]", never, {}, {}, never, never, true, never>;
+}
+
 declare class ExtensionsModule {
     static forRoot(config?: ExtensionsModuleConfig): ModuleWithProviders<ExtensionsModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensionsModule, [typeof LocDatePipe], [typeof i2.LocalizationModule], [typeof LocDatePipe]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensionsModule, [typeof LocDatePipe], [typeof i2.LocalizationModule, typeof Toast], [typeof LocDatePipe]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ExtensionsModule>;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esfaenza/extensions",
-  "version": "20.3.7",
+  "version": "20.3.8",
   "dependencies": {
     "tslib": "^2.0.0"
   },
@@ -9,7 +9,6 @@
     "@angular/core": "^20.3.24",
     "@esfaenza/localizations": "^20.3.6",
     "sweetalert2": "11.26.25",
-    "ngx-toastr": "20.0.5",
     "dayjs": "1.11.21",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },