web-push-notifications 3.44.7 → 3.44.8

package/core/Pushwoosh.d.ts

@@ -0,0 +1,199 @@
+import { type EventHandlerMap, type EventName } from './events.types';
+import { type IInitParams, type PWInput } from './Pushwoosh.types';
+import { Api } from '../modules/Api/Api';
+import { Data } from '../modules/Data/Data';
+import InboxMessagesPublic from '../modules/InboxMessagesPublic';
+import { PlatformChecker } from '../modules/PlatformChecker';
+import { type IPushService } from '../services/PushService/PushService.types';
+export declare class Pushwoosh {
+    ready: boolean;
+    initParams: IInitParams;
+    private readonly eventBus;
+    readonly data: Data;
+    private readonly apiClient;
+    private isCommunicationDisabled?;
+    readonly api: Api;
+    driver: IPushService;
+    platformChecker: PlatformChecker;
+    pwinbox: InboxMessagesPublic;
+    private inboxModel;
+    moduleRegistry: Record<string, any>;
+    constructor();
+    /**
+     * Add Web SDK Event Handler.
+     * Alias to addEventHandler method of EventBus module.
+     *
+     * @public
+     * @readonly
+     *
+     * @param {string} name - name of Web SDK event.
+     * @param {function} handler - handler of Web SDK event.
+     *
+     * @returns {void}
+     */
+    addEventHandler: <Name extends EventName>(name: Name, handler: EventHandlerMap[Name]) => void;
+    /**
+     * Remove Web SDK Event Handler.
+     * Alias to removeEventHandler method of EventBus module.
+     *
+     * @public
+     * @readonly
+     *
+     * @param {string} name - name of Web SDK event.
+     * @param {function} handler - handler of Web SDK event.
+     *
+     * @returns {void}
+     */
+    removeEventHandler: <Name extends EventName>(name: Name, handler: EventHandlerMap[Name]) => void;
+    /**
+     * Dispatch Web SDK Event.
+     * Alias to dispatchEvent method of EventBus module.
+     *
+     * @public
+     * @readonly
+     *
+     * @param {string} name - name of Web SDK event.
+     * @param {object} payload - event payload.
+     *
+     * @returns {string} - event id.
+     */
+    dispatchEvent: <Name extends EventName>(name: Name, payload: Omit<Parameters<EventHandlerMap[Name]>[0], "eventId"> & {
+        eventId?: string;
+    }) => string;
+    /**
+     * Method that puts the stored error/info messages to browser console.
+     * @type {{showLog: (() => Promise<any>); showKeyValues: (() => Promise<any>); showMessages: (() => Promise<any>)}}
+     */
+    debug: {
+        showLog(): Promise<void>;
+        showKeyValues(): Promise<void>;
+        showMessages(): Promise<void>;
+    };
+    /**
+     * Polymorph PW method.
+     * Can get array in format [string, params | callback] or function.
+     *
+     *  // with callback:
+     *  Pushwoosh.push(['onNotificationClick', function(api, payload) {
+     *    // click on the notificationn
+     *  }]);
+     *
+     *  // with function:
+     *  Pushwoosh.push(function(api) {
+     *    // this is a bit easier way to subscribe to onReady
+     *  });
+     *
+     *  // with params:
+     *  // initiates Pushwoosh service and notification subscription
+     *  Pushwoosh.push(['init', {
+     *    applicationCode: 'XXXXX-XXXXX',
+     *    // see more about params in documentation
+     *    // https://docs.pushwoosh.com/docs/web-push-sdk-30#section-integration
+     *  }]);
+     *
+     * @param command
+     */
+    push(command: PWInput): void;
+    /**
+     * Method initializes the permission dialog on the device
+     * and registers through the API in case the device hasn't been registered before.
+     * @returns {Promise<void>}
+     */
+    subscribe(isForceSubscribe?: boolean): Promise<void>;
+    /**
+     * Unsubscribe device.
+     * @returns {Promise<void>}
+     */
+    unsubscribe(): Promise<void>;
+    /**
+     * force subscribe if there was a manual unsubscribe
+     * @returns {Promise<void>}
+     */
+    forceSubscribe(): Promise<void>;
+    /**
+     * Check device's registration status
+     * @returns {boolean}
+     */
+    isDeviceRegistered(): boolean;
+    isDeviceUnregistered(): boolean;
+    /**
+     * Check device's subscription status
+     * @returns {Promise<boolean>}
+     */
+    isSubscribed(): Promise<boolean>;
+    /**
+     * Check current communication state
+     * @returns {Promise<boolean>}
+     */
+    isCommunicationEnabled(): Promise<boolean>;
+    /**
+     * Send "GDPRConsent" postEvent and depends on param "isEnabled"
+     * device will be registered/unregistered from all communication channels.
+     * @param {boolean} isEnabled
+     * @returns {Promise<void>}
+     */
+    setCommunicationEnabled(isEnabled?: boolean): Promise<void>;
+    /**
+     * Send "GDPRDelete" postEvent and remove all device device data from Pushwoosh.
+     * @returns {Promise<void>}
+     */
+    removeAllDeviceData(): Promise<void>;
+    /**
+     * Method returns hardware id.
+     * @returns {Promise<string>}
+     */
+    getHWID(): Promise<string>;
+    /**
+     * Method returns push token.
+     * @returns {Promise<string>}
+     */
+    getPushToken(): Promise<string | undefined>;
+    /**
+     * Method returns userId
+     * @returns {Promise<string | null>}
+     */
+    getUserId(): Promise<string | undefined>;
+    /**
+     * Method returns an object with all params.
+     * @returns {Promise<IPWParams>}
+     */
+    getParams(): Promise<any>;
+    /**
+     * Method returns  true if notifications available.
+     * @returns {boolean}
+     */
+    isAvailableNotifications(): boolean;
+    sendStatisticsVisitedPage(): Promise<void>;
+    private initialize;
+    /**
+     * Default process during PW initialization.
+     * Init API. Subscription to notifications.
+     * Emit delayed events.
+     */
+    private defaultProcess;
+    /**
+     *
+     * @param {MessageEvent} event
+     */
+    private onServiceWorkerMessage;
+    /**
+     * Check device's session and call the appOpen method,
+     * no more than once an hour.
+     * Force need to Safari await subscribe status
+     * @param {boolean} isForce
+     * @returns {Promise<void>}
+     */
+    private open;
+    private onGetConfig;
+    private initPushNotifications;
+    private initDriver;
+    sendPostEventVisitedPage(): void;
+    /**
+     * @private
+     *
+     * @param {string} type - legacy event type
+     * @param {function} handler - legacy handler
+     */
+    private subscribeToLegacyEvents;
+    private emitLegacyEventsFromServiceWorker;
+}

package/core/Pushwoosh.types.d.ts

@@ -0,0 +1,213 @@
+import { type INotificationButton } from '../models/NotificationPayload.types';
+import { type ISubscribePopupConfig } from '../widgets/SubscribePopup/types/subscribe-popup';
+export type PushwooshApiResponse = {
+    status_code: number;
+    status_message: string;
+    response?: any;
+};
+export type TPWPermission = 'denied' | 'granted' | 'default';
+export interface IPWDriverAPIParams {
+    hwid: string;
+    pushToken?: string;
+    publicKey?: string;
+    authToken?: string;
+}
+export interface TPWAPIParams extends IPWDriverAPIParams {
+    applicationCode: string;
+    pushwooshApiUrl?: string;
+    deviceType: number;
+    deviceModel: string;
+    language: string;
+    userId?: string;
+}
+export interface TPWLastOpenMessage {
+    messageHash?: string;
+    expiry: number;
+    url?: string;
+}
+export interface PushManager {
+    permissionState(options: PushSubscriptionOptions): Promise<TPWPermission>;
+}
+export interface PushSubscription {
+    unsubscribe(): Promise<boolean>;
+    subscriptionId: string;
+}
+export interface IPWDriver {
+    initWorker?(): Promise<any>;
+    getPermission(): Promise<TPWPermission>;
+    isSubscribed(): Promise<boolean>;
+    askSubscribe(eventEmitter?: any): Promise<any>;
+    unsubscribe(): Promise<any>;
+    getAPIParams(): Promise<IPWDriverAPIParams>;
+    onApiReady?(api: any): void;
+    isNeedUnsubscribe?(): Promise<boolean>;
+}
+export interface ITooltipText {
+    successSubscribe?: string;
+    needSubscribe?: string;
+    blockSubscribe?: string;
+    alreadySubscribed?: string;
+}
+export interface ISubscribeWidget {
+    enable: boolean;
+    position?: string;
+    bgColor?: string;
+    bellColor?: string;
+    shadow?: string;
+    size?: string;
+    indent?: string;
+    zIndex?: string;
+    tooltipText?: ITooltipText;
+    buttonImage?: string;
+    contentImages?: Record<string, string>;
+}
+export type IWidgetPosition = 'left' | 'right' | 'top' | 'bottom';
+export interface IInboxWidget {
+    enable: boolean;
+    triggerId?: string;
+    position?: IWidgetPosition;
+    appendTo?: string;
+    title?: string;
+    bgColor?: string;
+    textColor?: string;
+    fontFamily?: string;
+    borderRadius?: number;
+    borderColor?: string;
+    badgeBgColor?: string;
+    badgeTextColor?: string;
+    widgetWidth?: number;
+    zIndex?: number;
+    messageTitleColor?: string;
+    timeTextColor?: string;
+    emptyInboxTitle?: string;
+    emptyInboxText?: string;
+    emptyInboxIconUrl?: string;
+    emptyInboxTitleColor?: string;
+    emptyInboxTextColor?: string;
+}
+export interface IInitParams {
+    applicationCode: string;
+    apiToken?: string;
+    serviceWorkerUrl?: string | null;
+    safariWebsitePushID?: string;
+    autoSubscribe?: boolean;
+    pushwooshUrl?: string;
+    pushwooshApiUrl?: string;
+    defaultNotificationImage?: string;
+    defaultNotificationTitle?: string;
+    logLevel?: string;
+    userId?: string;
+    email?: string;
+    scope?: string;
+    tags?: {
+        [key: string]: any;
+    };
+    driversSettings?: {
+        worker?: {
+            serviceWorkerUrl?: string;
+            applicationServerPublicKey?: string;
+        };
+    };
+    subscribeWidget?: ISubscribeWidget;
+    inboxWidget?: IInboxWidget;
+    subscribePopup?: ISubscribePopupConfig;
+}
+export interface IInitParamsWithDefaults extends IInitParams {
+    autoSubscribe: boolean;
+    pushwooshUrl: string;
+    deviceType: number;
+    serviceWorkerUrl: string | null;
+    tags: {
+        Language: string;
+        'Device Model': string;
+        [key: string]: any;
+    };
+    driversSettings: {
+        worker: {
+            serviceWorkerUrl: string;
+            applicationServerPublicKey?: string;
+        };
+    };
+    subscribeWidget: ISubscribeWidget;
+    inboxWidget: IInboxWidget;
+    subscribePopup: ISubscribePopupConfig;
+    hwid: string;
+}
+export interface IPWParams extends IInitParamsWithDefaults {
+    applicationCode: string;
+    apiToken?: string;
+    defaultNotificationImage?: string;
+    defaultNotificationTitle?: string;
+    logLevel?: 'error' | 'info' | 'debug';
+    pushwooshApiUrl?: string;
+    safariWebsitePushID?: string;
+    scope?: string;
+    userId?: string;
+    email?: string;
+    pushwooshUrl: string;
+    authToken?: string;
+    hwid: string;
+    publicKey?: string;
+    pushToken?: string;
+}
+export interface INotificationOptions extends NotificationOptions {
+    title: string;
+    messageHash: string;
+    openUrl: string;
+    url?: string;
+    inboxId: string;
+    image?: string;
+    code?: string;
+    buttons?: INotificationButton[];
+    customData?: {
+        [key: string]: any;
+    };
+    metaData?: {
+        [key: string]: any;
+    };
+    campaignCode?: string;
+}
+export type TPWCanWaitCallback = (f: any) => Promise<any> | any;
+export interface IWorkerPushwooshGlobal {
+    push(listener: ['onPush', TPWCanWaitCallback]): void;
+    getListeners(eventName: string): TPWCanWaitCallback[];
+    eventBus: any;
+    api: any;
+    initApi: any;
+}
+export interface IPWBroadcastClientsParams {
+    type: string;
+    payload: any;
+}
+export type TWriteType = 'error' | 'apirequest' | 'info';
+export interface ILogger {
+    setLevel(level: string): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    write(type: TWriteType, message: any, additional?: any): Promise<void>;
+    isManualLevel(): boolean;
+    [key: string]: any;
+}
+export type ListenerFn = (...args: Array<any>) => void | Promise<any>;
+export type HandlerFn = (api: any, params?: any) => any;
+export type TWorkerDriverParams = {
+    eventEmitter?: any;
+    scope?: string;
+    applicationCode: string;
+    serviceWorkerUrl: string | null;
+    applicationServerPublicKey?: string;
+};
+export type TWorkerSafariDriverParams = {
+    eventEmitter?: any;
+    applicationCode: string;
+    webSitePushID: string;
+    pushwooshUrl: string;
+    pushwooshApiUrl?: string;
+};
+export type TDoPushwooshMethod = (type: string, params: any, url?: string) => Promise<any>;
+export type PWInput = PushOnReadyCallback | PushInitCallback | PushEventCallback;
+export type PushOnReadyCallback = HandlerFn;
+export type PushInitCallback = ['init', IInitParams];
+export type PushEventCallback = [PWEvent, HandlerFn];
+export type PWEvent = 'onLoad' | 'onReady' | 'onSubscribe' | 'onUnsubscribe' | 'onRegister' | 'onSWInitError' | 'onPermissionPrompt' | 'onPermissionDenied' | 'onPermissionGranted' | 'onNotificationClick' | 'onPushDelivery' | 'onNotificationClose' | 'onChangeCommunicationEnabled' | 'onPutNewMessageToInboxStore' | 'onUpdateInboxMessages' | 'onShowNotificationPermissionDialog' | 'onHideNotificationPermissionDialog' | 'onShowSubscriptionWidget' | 'onHideSubscriptionWidget';

package/core/Safari.types.d.ts

@@ -0,0 +1,17 @@
+interface IPushServiceSafariRequestPayload {
+    application: string;
+    hwid: string;
+}
+interface IPushServiceSafariInfo {
+    permission: NotificationPermission;
+    deviceToken?: string;
+}
+interface Window {
+    safari: {
+        pushNotification: {
+            permission(siteId: string): IPushServiceSafariInfo;
+            requestPermission(url: string, id: string, payload: IPushServiceSafariRequestPayload, cb: (permission: IPushServiceSafariInfo) => void): void;
+        };
+    };
+}
+declare const safari: typeof window.safari;

package/core/constants.d.ts

@@ -0,0 +1,41 @@
+export declare const DEFAULT_SERVICE_WORKER_URL = "/pushwoosh-service-worker.js";
+export declare const DEFAULT_API_URL = "https://cp.pushwoosh.com/json/1.3/";
+export declare const PERIOD_SEND_APP_OPEN = 3600000;
+export declare const PERIOD_GOAL_EVENT = 86400000;
+export declare const DEFAULT_NOTIFICATION_TITLE = "Pushwoosh notification";
+export declare const DEFAULT_NOTIFICATION_IMAGE = "https://cp.pushwoosh.com/img/logo-medium.png";
+export declare const KEY_SHOW_SUBSCRIBE_WIDGET = "WIDGET_SHOWED";
+export declare const KEY_CLICK_SUBSCRIBE_WIDGET = "WIDGET_CLICKED";
+export declare const KEY_DEVICE_REGISTRATION_STATUS: string;
+export declare const KEY_SAFARI_PREVIOUS_PERMISSION = "safariPreviousPermission";
+export declare const MANUAL_SET_LOGGER_LEVEL = "PW_SET_LOGGER_LEVEL";
+export declare const DEVICE_REGISTRATION_STATUS_REGISTERED: string;
+export declare const DEVICE_REGISTRATION_STATUS_UNREGISTERED: string;
+export declare const PERMISSION_DENIED = "denied";
+export declare const PERMISSION_GRANTED = "granted";
+export declare const PERMISSION_PROMPT = "default";
+export declare const LEGACY_EVENT_ON_LOAD = "onLoad";
+export declare const LEGACY_EVENT_ON_READY = "onReady";
+export declare const LEGACY_EVENT_ON_SUBSCRIBE = "onSubscribe";
+export declare const LEGACY_EVENT_ON_UNSUBSCRIBE = "onUnsubscribe";
+export declare const LEGACY_EVENT_ON_REGISTER = "onRegister";
+export declare const LEGACY_EVENT_ON_PERMISSION_PROMPT = "onPermissionPrompt";
+export declare const LEGACY_EVENT_ON_PERMISSION_DENIED = "onPermissionDenied";
+export declare const LEGACY_EVENT_ON_PERMISSION_GRANTED = "onPermissionGranted";
+export declare const LEGACY_EVENT_ON_SW_INIT_ERROR = "onSWInitError";
+export declare const LEGACY_EVENT_ON_PUSH_DELIVERY = "onPushDelivery";
+export declare const LEGACY_EVENT_ON_NOTIFICATION_CLICK = "onNotificationClick";
+export declare const LEGACY_EVENT_ON_NOTIFICATION_CLOSE = "onNotificationClose";
+export declare const LEGACY_EVENT_ON_CHANGE_COMMUNICATION_ENABLED = "onChangeCommunicationEnabled";
+export declare const LEGACY_EVENT_ON_PUT_NEW_MESSAGE_TO_INBOX_STORE = "onPutNewMessageToInboxStore";
+export declare const LEGACY_EVENT_ON_UPDATE_INBOX_MESSAGES = "onUpdateInboxMessages";
+export declare const LEGACY_EVENT_ON_SHOW_NOTIFICATION_PERMISSION_DIALOG = "onShowNotificationPermissionDialog";
+export declare const LEGACY_EVENT_ON_HIDE_NOTIFICATION_PERMISSION_DIALOG = "onHideNotificationPermissionDialog";
+export declare const LEGACY_EVENT_ON_SHOW_SUBSCRIPTION_WIDGET = "onShowSubscriptionWidget";
+export declare const LEGACY_EVENT_ON_HIDE_SUBSCRIPTION_WIDGET = "onHideSubscriptionWidget";
+export declare const EVENT_SHOW_SUBSCRIBE_BUTTON = "showSubscribeButton";
+export declare const EVENT_CLICK_SUBSCRIBE_BUTTON = "clickSubscribeButton";
+export declare const EVENT_GDPR_CONSENT = "GDPRConsent";
+export declare const EVENT_GDPR_DELETE = "GDPRDelete";
+export declare const EVENT_PW_SITE_OPENED = "PW_SiteOpened";
+export declare const PAGE_VISITED_URL = "PAGE_VISITED_URL";

package/core/events.types.d.ts

@@ -0,0 +1,55 @@
+export type EventPayload<Parameters extends Record<string, unknown>> = Parameters & Record<'eventId', string>;
+export type EventHandler<Payload extends EventPayload<Record<string, unknown>>> = (payload: Payload) => void | Promise<void>;
+export interface EventHandlerMap {
+    ready: EventHandler<EventPayload<Record<string, never>>>;
+    'change-enabled-communication': EventHandler<EventPayload<{
+        isEnabled: boolean;
+    }>>;
+    register: EventHandler<EventPayload<Record<string, never>>>;
+    unregister: EventHandler<EventPayload<Record<string, never>>>;
+    'show-subscription-widget': EventHandler<EventPayload<Record<string, never>>>;
+    'hide-subscription-widget': EventHandler<EventPayload<Record<string, never>>>;
+    'show-notification-permission-dialog': EventHandler<EventPayload<Record<string, never>>>;
+    'hide-notification-permission-dialog': EventHandler<EventPayload<{
+        permission: NotificationPermission;
+    }>>;
+    'permission-default': EventHandler<EventPayload<Record<string, never>>>;
+    'permission-denied': EventHandler<EventPayload<Record<string, never>>>;
+    'permission-granted': EventHandler<EventPayload<Record<string, never>>>;
+    'change-permission': EventHandler<EventPayload<{
+        permission: NotificationPermission;
+    }>>;
+    'initialize-service-worker': EventHandler<EventPayload<Record<string, never>>>;
+    'initialize-service-worker-error': EventHandler<EventPayload<{
+        error: Error;
+    }>>;
+    subscribe: EventHandler<EventPayload<Record<string, never>>>;
+    unsubscribe: EventHandler<EventPayload<Record<string, never>>>;
+    'receive-push': EventHandler<EventPayload<{
+        notification: unknown;
+    }>>;
+    'show-notification': EventHandler<EventPayload<{
+        notification: unknown;
+    }>>;
+    'open-notification': EventHandler<EventPayload<{
+        notification: unknown;
+    }>>;
+    'hide-notification': EventHandler<EventPayload<{
+        notification: unknown;
+    }>>;
+    'receive-inbox-message': EventHandler<EventPayload<{
+        message: unknown;
+    }>>;
+    'update-inbox-messages': EventHandler<EventPayload<{
+        messages: unknown;
+    }>>;
+    'receive-in-app-code': EventHandler<EventPayload<{
+        code: string;
+    }>>;
+    'subscribe-popup-ready': EventHandler<EventPayload<Record<string, never>>>;
+    'subscribe-popup-show': EventHandler<EventPayload<Record<string, never>>>;
+    'subscribe-popup-hide': EventHandler<EventPayload<Record<string, never>>>;
+    'subscribe-popup-decline': EventHandler<EventPayload<Record<string, never>>>;
+    'subscribe-popup-accept': EventHandler<EventPayload<Record<string, never>>>;
+}
+export type EventName = keyof EventHandlerMap;

package/core/functions.d.ts

@@ -0,0 +1,5 @@
+export declare function getGlobal(): typeof globalThis;
+export declare function getVersion(): string;
+export declare function parseSerializedNotificationParams(param: any, defaultValue?: any): any;
+export declare function v4(): `${string}-${string}-${string}-${string}-${string}`;
+export declare const isFunction: (value: any) => value is ((...args: any[]) => any);

package/core/legacyEventsMap.d.ts

@@ -0,0 +1,5 @@
+import type { EventName } from './events.types';
+export declare const legacyEventsMap: Record<string, {
+    name: EventName;
+    prop?: string;
+}>;

package/core/logger.d.ts

@@ -0,0 +1,14 @@
+type TWriteType = 'error' | 'apirequest' | 'info';
+interface ILogger {
+    setLevel(level: string): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    write(type: TWriteType, message: any, additional?: any): Promise<void>;
+    isManualLevel(): boolean;
+    [key: string]: any;
+}
+declare const Logger: ILogger;
+export declare function logAndThrowError(error: string): void;
+export declare function logAndRejectError(error: string, reject: (e: any) => void): void;
+export { Logger };

package/core/modules/EventBus/EventBus.d.ts

@@ -0,0 +1,10 @@
+import { type EventHandlerMap, type EventName } from '../../events.types';
+export declare class EventBus {
+    private readonly handlers;
+    constructor();
+    addEventHandler: <Name extends EventName = EventName>(name: Name, handler: EventHandlerMap[Name]) => void;
+    removeEventHandler: <Name extends EventName = EventName>(name: Name, handler: EventHandlerMap[Name]) => void;
+    dispatchEvent: <Name extends EventName = EventName>(name: Name, payload: Omit<Parameters<EventHandlerMap[Name]>[0], "eventId"> & {
+        eventId?: string;
+    }) => string;
+}

package/core/storage.d.ts

@@ -0,0 +1,27 @@
+export declare function getInstance(): Promise<IDBDatabase>;
+export declare abstract class LogBase {
+    protected abstract name: string;
+    protected abstract maxItems: number;
+    _add(obj: any): any;
+    delete(key: any): any;
+    getAll(): any;
+}
+export declare class LogLog extends LogBase {
+    protected name: "log";
+    protected maxItems: number;
+    protected environment: string;
+    add(type: string, message: any, additional?: any): any;
+}
+export declare class LogMessage extends LogBase {
+    protected name: "messages";
+    protected maxItems: number;
+    add(log: any): any;
+}
+export declare const keyValue: {
+    get<K extends string, D>(key: K, defaultValue?: D): any;
+    getAll(): any;
+    extend(key: string, value: any): Promise<void>;
+    set<K, D>(key: K, value: D): any;
+};
+export declare const log: LogLog;
+export declare const message: LogMessage;

package/helpers/logger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from './pwlogger';
+type TLogMessage = {
+    message: string;
+    code: string;
+    error: any;
+    [key: string]: any;
+};
+declare const logger: Logger;
+declare function sendFatalLogToRemoteServer(params: TLogMessage): Promise<void>;
+declare function sendErrorLogToRemoteServer(params: TLogMessage): Promise<void>;
+export { logger, sendFatalLogToRemoteServer, sendErrorLogToRemoteServer, };

package/helpers/pwlogger/Logger.constants.d.ts

@@ -0,0 +1,21 @@
+import { type TLoggerLevelSilent, type TLoggerLevelFatal, type TLoggerLevelError, type TLoggerLevelWarn, type TLoggerLevelInfo, type TLoggerLevelDebug } from './Logger.types';
+export declare const LOGGER_LEVEL_SILENT: TLoggerLevelSilent;
+export declare const LOGGER_LEVEL_FATAL: TLoggerLevelFatal;
+export declare const LOGGER_LEVEL_ERROR: TLoggerLevelError;
+export declare const LOGGER_LEVEL_WARN: TLoggerLevelWarn;
+export declare const LOGGER_LEVEL_INFO: TLoggerLevelInfo;
+export declare const LOGGER_LEVEL_DEBUG: TLoggerLevelDebug;
+export declare const LOGGER_LEVEL_VALUE_SILENT = 0;
+export declare const LOGGER_LEVEL_VALUE_FATAL = 10;
+export declare const LOGGER_LEVEL_VALUE_ERROR = 20;
+export declare const LOGGER_LEVEL_VALUE_WARN = 30;
+export declare const LOGGER_LEVEL_VALUE_INFO = 40;
+export declare const LOGGER_LEVEL_VALUE_DEBUG = 50;
+export declare const loggerRelationsMap: {
+    silent: number;
+    fatal: number;
+    error: number;
+    warn: number;
+    info: number;
+    debug: number;
+};

package/helpers/pwlogger/Logger.d.ts

@@ -0,0 +1,37 @@
+import { loggerRelationsMap } from './Logger.constants';
+import { type ILoggerConfig, type TLoggerLevels, type TLoggerApplicationType, type ILoggerLogOptions, type ILoggerLogParams, type TLoggerHandler, type ILoggerSubscriber, type TLoggerOutputLevels, type TReject } from './Logger.types';
+export * from './Logger.types';
+export * from './Logger.constants';
+export declare class Logger {
+    readonly relations: typeof loggerRelationsMap;
+    applicationType: TLoggerApplicationType;
+    level: TLoggerLevels;
+    readonly subscribers: ILoggerSubscriber[];
+    applicationCode: string | undefined;
+    domain: string | undefined;
+    deviceInfo: {
+        [key: string]: any;
+    } | undefined;
+    constructor(config?: ILoggerConfig);
+    updateLogLevel(level: TLoggerLevels): void;
+    updateApplicationType(applicationType: TLoggerApplicationType): void;
+    updateApplicationCode(applicationCode: string): void;
+    updateDomain(domain: string): void;
+    updateDeviceInfo(deviceInfo: {
+        [key: string]: any;
+    }): void;
+    subscribe(level: TLoggerOutputLevels, handler: TLoggerHandler): void;
+    log(params: ILoggerLogParams): Promise<void>;
+    debug(text: string, options?: ILoggerLogOptions): Promise<void>;
+    info(text: string, options?: ILoggerLogOptions): Promise<void>;
+    warn(text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    error(text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    fatal(text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    errorAndThrow(text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    errorAndReject(cb: TReject, text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    fatalAndThrow(text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    fatalAndReject(cb: TReject, text: string, code?: string, options?: ILoggerLogOptions): Promise<void>;
+    private logAndThrow;
+    private logAndReject;
+    private getMessage;
+}