planning

node_modules/react-toastify/dist/core/eventManager.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { Id, ToastContent, ClearWaitingQueueParams, NotValidatedToastProps, ToastItem } from '../types';
+import { ContainerInstance } from '../hooks';
+export declare const enum Event {
+    Show = 0,
+    Clear = 1,
+    DidMount = 2,
+    WillUnmount = 3,
+    Change = 4,
+    ClearWaitingQueue = 5
+}
+type OnShowCallback = (content: ToastContent, options: NotValidatedToastProps) => void;
+type OnClearCallback = (id?: Id) => void;
+type OnClearWaitingQueue = (params: ClearWaitingQueueParams) => void;
+type OnDidMountCallback = (containerInstance: ContainerInstance) => void;
+type OnWillUnmountCallback = OnDidMountCallback;
+export type OnChangeCallback = (toast: ToastItem) => void;
+type Callback = OnShowCallback | OnClearCallback | OnClearWaitingQueue | OnDidMountCallback | OnWillUnmountCallback | OnChangeCallback;
+type TimeoutId = ReturnType<typeof setTimeout>;
+export interface EventManager {
+    list: Map<Event, Callback[]>;
+    emitQueue: Map<Event, TimeoutId[]>;
+    on(event: Event.Show, callback: OnShowCallback): EventManager;
+    on(event: Event.Clear, callback: OnClearCallback): EventManager;
+    on(event: Event.ClearWaitingQueue, callback: OnClearWaitingQueue): EventManager;
+    on(event: Event.DidMount, callback: OnDidMountCallback): EventManager;
+    on(event: Event.WillUnmount, callback: OnWillUnmountCallback): EventManager;
+    on(event: Event.Change, callback: OnChangeCallback): EventManager;
+    off(event: Event, callback?: Callback): EventManager;
+    cancelEmit(event: Event): EventManager;
+    emit<TData>(event: Event.Show, content: React.ReactNode | ToastContent<TData>, options: NotValidatedToastProps): void;
+    emit(event: Event.Clear, id?: string | number): void;
+    emit(event: Event.ClearWaitingQueue, params: ClearWaitingQueueParams): void;
+    emit(event: Event.DidMount, containerInstance: ContainerInstance): void;
+    emit(event: Event.WillUnmount, containerInstance: ContainerInstance): void;
+    emit(event: Event.Change, data: ToastItem): void;
+}
+export declare const eventManager: EventManager;
+export {};

node_modules/react-toastify/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './eventManager';
+export * from './toast';

node_modules/react-toastify/dist/core/toast.d.ts

@@ -0,0 +1,41 @@
+import { OnChangeCallback } from './eventManager';
+import { ToastContent, ToastOptions, Id, UpdateOptions, ClearWaitingQueueParams, TypeOptions } from '../types';
+declare function toast<TData = unknown>(content: ToastContent<TData>, options?: ToastOptions): Id;
+declare namespace toast {
+    var loading: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var promise: typeof handlePromise;
+    var success: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var info: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var error: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var warning: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var warn: <TData = unknown>(content: ToastContent<TData>, options?: ToastOptions<{}> | undefined) => Id;
+    var dark: (content: ToastContent, options?: ToastOptions<{}> | undefined) => Id;
+    var dismiss: (id?: Id | undefined) => void;
+    var clearWaitingQueue: (params?: ClearWaitingQueueParams) => void;
+    var isActive: (id: Id) => boolean;
+    var update: <TData = unknown>(toastId: Id, options?: UpdateOptions<TData>) => void;
+    var done: (id: Id) => void;
+    var onChange: (callback: OnChangeCallback) => () => void;
+    var POSITION: {
+        TOP_LEFT: import("../types").ToastPosition;
+        TOP_RIGHT: import("../types").ToastPosition;
+        TOP_CENTER: import("../types").ToastPosition;
+        BOTTOM_LEFT: import("../types").ToastPosition;
+        BOTTOM_RIGHT: import("../types").ToastPosition;
+        BOTTOM_CENTER: import("../types").ToastPosition;
+    };
+    var TYPE: {
+        INFO: TypeOptions;
+        SUCCESS: TypeOptions;
+        WARNING: TypeOptions;
+        ERROR: TypeOptions;
+        DEFAULT: TypeOptions;
+    };
+}
+export interface ToastPromiseParams<TData = unknown, TError = unknown, TPending = unknown> {
+    pending?: string | UpdateOptions<TPending>;
+    success?: string | UpdateOptions<TData>;
+    error?: string | UpdateOptions<TError>;
+}
+declare function handlePromise<TData = unknown, TError = unknown, TPending = unknown>(promise: Promise<TData> | (() => Promise<TData>), { pending, error, success }: ToastPromiseParams<TData, TError, TPending>, options?: ToastOptions): Promise<TData>;
+export { toast };