@novu/js 3.11.0 → 3.11.1

package/dist/cjs/index.d.ts

@@ -1,7 +1,6 @@
-import { N as Notification } from './novu-ThMWeiRt.js';
-export { E as EventHandler, a as Events, F as FiltersCountResponse, L as ListNotificationsResponse, b as Novu, P as Preference, c as Schedule, S as SocketEventNames } from './novu-ThMWeiRt.js';
-import { S as SeverityLevelEnum, N as NotificationFilter } from './types-BM_9Xx5Z.js';
-export { C as ChannelPreference, a as ChannelType, b as Context, D as DaySchedule, c as DefaultSchedule, I as InboxNotification, d as NotificationStatus, e as NovuError, f as NovuOptions, P as PreferenceLevel, g as PreferencesResponse, h as StandardNovuOptions, i as Subscriber, T as TimeRange, U as UnreadCount, W as WebSocketEvent, j as WeeklySchedule, k as WorkflowCriticalityEnum } from './types-BM_9Xx5Z.js';
+import { S as SeverityLevelEnum, N as NotificationFilter, a as Notification } from './novu-event-emitter-C7GZ7-r1.js';
+export { C as ChannelPreference, d as ChannelType, e as Context, D as DaySchedule, f as DefaultSchedule, E as EventHandler, b as Events, F as FiltersCountResponse, I as InboxNotification, L as ListNotificationsResponse, g as NotificationStatus, h as NovuError, i as NovuOptions, P as Preference, j as PreferenceLevel, k as PreferencesResponse, l as Schedule, c as SocketEventNames, m as StandardNovuOptions, n as Subscriber, T as TimeRange, U as UnreadCount, W as WebSocketEvent, o as WeeklySchedule, p as WorkflowCriticalityEnum } from './novu-event-emitter-C7GZ7-r1.js';
+export { N as Novu } from './novu-CKWESYFZ.js';
 
 declare const areTagsEqual: (tags1?: string[], tags2?: string[]) => boolean;
 declare const areSeveritiesEqual: (el1?: SeverityLevelEnum | SeverityLevelEnum[], el2?: SeverityLevelEnum | SeverityLevelEnum[]) => boolean;

package/dist/cjs/index.js

@@ -1,56 +1,56 @@
 'use strict';
 
-var chunkQQNKEWGC_js = require('./chunk-QQNKEWGC.js');
-require('./chunk-VWSQDNZX.js');
+var chunkMKYWGA37_js = require('./chunk-MKYWGA37.js');
+var chunkWFVHYVDM_js = require('./chunk-WFVHYVDM.js');
 require('./chunk-7B52C2XE.js');
 
 
 
-Object.defineProperty(exports, "ChannelType", {
+Object.defineProperty(exports, "Novu", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.ChannelType; }
+  get: function () { return chunkMKYWGA37_js.Novu; }
 });
-Object.defineProperty(exports, "NotificationStatus", {
+Object.defineProperty(exports, "areSeveritiesEqual", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.NotificationStatus; }
+  get: function () { return chunkMKYWGA37_js.areSeveritiesEqual; }
 });
-Object.defineProperty(exports, "Novu", {
+Object.defineProperty(exports, "areTagsEqual", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.Novu; }
+  get: function () { return chunkMKYWGA37_js.areTagsEqual; }
 });
-Object.defineProperty(exports, "PreferenceLevel", {
+Object.defineProperty(exports, "checkNotificationDataFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.PreferenceLevel; }
+  get: function () { return chunkMKYWGA37_js.checkNotificationDataFilter; }
 });
-Object.defineProperty(exports, "SeverityLevelEnum", {
+Object.defineProperty(exports, "checkNotificationMatchesFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.SeverityLevelEnum; }
+  get: function () { return chunkMKYWGA37_js.checkNotificationMatchesFilter; }
 });
-Object.defineProperty(exports, "WebSocketEvent", {
+Object.defineProperty(exports, "isSameFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.WebSocketEvent; }
+  get: function () { return chunkMKYWGA37_js.isSameFilter; }
 });
-Object.defineProperty(exports, "WorkflowCriticalityEnum", {
+Object.defineProperty(exports, "ChannelType", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.WorkflowCriticalityEnum; }
+  get: function () { return chunkWFVHYVDM_js.ChannelType; }
 });
-Object.defineProperty(exports, "areSeveritiesEqual", {
+Object.defineProperty(exports, "NotificationStatus", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.areSeveritiesEqual; }
+  get: function () { return chunkWFVHYVDM_js.NotificationStatus; }
 });
-Object.defineProperty(exports, "areTagsEqual", {
+Object.defineProperty(exports, "PreferenceLevel", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.areTagsEqual; }
+  get: function () { return chunkWFVHYVDM_js.PreferenceLevel; }
 });
-Object.defineProperty(exports, "checkNotificationDataFilter", {
+Object.defineProperty(exports, "SeverityLevelEnum", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.checkNotificationDataFilter; }
+  get: function () { return chunkWFVHYVDM_js.SeverityLevelEnum; }
 });
-Object.defineProperty(exports, "checkNotificationMatchesFilter", {
+Object.defineProperty(exports, "WebSocketEvent", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.checkNotificationMatchesFilter; }
+  get: function () { return chunkWFVHYVDM_js.WebSocketEvent; }
 });
-Object.defineProperty(exports, "isSameFilter", {
+Object.defineProperty(exports, "WorkflowCriticalityEnum", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.isSameFilter; }
+  get: function () { return chunkWFVHYVDM_js.WorkflowCriticalityEnum; }
 });

package/dist/cjs/internal/index.d.ts

@@ -1,4 +1,4 @@
-import { b as Context, i as Subscriber } from '../types-BM_9Xx5Z.js';
+import { e as Context, n as Subscriber, r as NovuEventEmitter, q as InboxService, I as InboxNotification, a as Notification } from '../novu-event-emitter-C7GZ7-r1.js';
 
 /**
  * Builds a compact, stable string key from context objects by extracting only type:id pairs.
@@ -19,10 +19,16 @@ declare function buildSubscriber({ subscriberId, subscriber, }: {
     subscriber: Subscriber | string | undefined;
 }): Subscriber;
 
+declare function createNotification({ emitter, inboxService, notification, }: {
+    emitter: NovuEventEmitter;
+    inboxService: InboxService;
+    notification: InboxNotification;
+}): Notification;
+
 interface Token {
     type: 'bold' | 'text';
     content: string;
 }
 declare const parseMarkdownIntoTokens: (text: string) => Token[];
 
-export { type Token, buildContextKey, buildSubscriber, parseMarkdownIntoTokens };
+export { type Token, buildContextKey, buildSubscriber, createNotification, parseMarkdownIntoTokens };

package/dist/cjs/internal/index.js

@@ -1,19 +1,23 @@
 'use strict';
 
-var chunkVWSQDNZX_js = require('../chunk-VWSQDNZX.js');
+var chunkWFVHYVDM_js = require('../chunk-WFVHYVDM.js');
 require('../chunk-7B52C2XE.js');
 
 
 
 Object.defineProperty(exports, "buildContextKey", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.buildContextKey; }
+  get: function () { return chunkWFVHYVDM_js.buildContextKey; }
 });
 Object.defineProperty(exports, "buildSubscriber", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.buildSubscriber; }
+  get: function () { return chunkWFVHYVDM_js.buildSubscriber; }
+});
+Object.defineProperty(exports, "createNotification", {
+  enumerable: true,
+  get: function () { return chunkWFVHYVDM_js.createNotification; }
 });
 Object.defineProperty(exports, "parseMarkdownIntoTokens", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.parseMarkdownIntoTokens; }
+  get: function () { return chunkWFVHYVDM_js.parseMarkdownIntoTokens; }
 });

package/dist/cjs/novu-CKWESYFZ.d.ts

@@ -0,0 +1,165 @@
+import { q as InboxService, r as NovuEventEmitter, s as Session, R as Result, t as ScheduleCache, l as Schedule, u as UpdateScheduleArgs, v as PreferencesCache, w as ListPreferencesArgs, P as Preference, B as BasePreferenceArgs, x as InstancePreferenceArgs, y as ListNotificationsArgs, L as ListNotificationsResponse, I as InboxNotification, a as Notification, N as NotificationFilter, z as FilterCountArgs, A as FilterCountResponse, G as FiltersCountArgs, F as FiltersCountResponse, H as BaseArgs, J as InstanceArgs, K as SnoozeArgs, c as SocketEventNames, M as EventNames, E as EventHandler, b as Events, O as ContextValue, i as NovuOptions, n as Subscriber, e as Context } from './novu-event-emitter-C7GZ7-r1.js';
+
+declare class BaseModule {
+    #private;
+    _inboxService: InboxService;
+    _emitter: NovuEventEmitter;
+    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    protected onSessionSuccess(_: Session): void;
+    protected onSessionError(_: unknown): void;
+    callWithSession<T>(fn: () => Result<T>): Result<T>;
+}
+
+declare class PreferenceSchedule extends BaseModule {
+    #private;
+    readonly cache: ScheduleCache;
+    constructor({ cache, useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        cache: ScheduleCache;
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    get(): Result<Schedule>;
+    update(args: UpdateScheduleArgs): Result<Schedule>;
+}
+
+declare class Preferences extends BaseModule {
+    #private;
+    readonly cache: PreferencesCache;
+    readonly scheduleCache: ScheduleCache;
+    readonly schedule: PreferenceSchedule;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    list(args?: ListPreferencesArgs): Result<Preference[]>;
+    update(args: BasePreferenceArgs): Result<Preference>;
+    update(args: InstancePreferenceArgs): Result<Preference>;
+    bulkUpdate(args: Array<BasePreferenceArgs>): Result<Preference[]>;
+    bulkUpdate(args: Array<InstancePreferenceArgs>): Result<Preference[]>;
+}
+
+declare class NotificationsCache {
+    #private;
+    constructor({ emitter, inboxService }: {
+        emitter: NovuEventEmitter;
+        inboxService: InboxService;
+    });
+    private updateNotification;
+    private removeNotification;
+    private handleNotificationEvent;
+    private getAggregated;
+    get(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    has(args: ListNotificationsArgs): boolean;
+    set(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    unshift(args: ListNotificationsArgs, notification: InboxNotification): void;
+    update(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    getAll(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    /**
+     * Get unique notifications based on specified filter fields.
+     * The same tags and data can be applied to multiple filters which means that the same notification can be duplicated.
+     */
+    getUniqueNotifications({ tags, read, data, }: Pick<ListNotificationsArgs, 'tags' | 'read' | 'data'>): Array<Notification>;
+    clear(filter: NotificationFilter): void;
+    clearAll(): void;
+}
+
+declare class Notifications extends BaseModule {
+    #private;
+    readonly cache: NotificationsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    list({ limit, ...restOptions }?: ListNotificationsArgs): Result<ListNotificationsResponse>;
+    count(args?: FilterCountArgs): Result<FilterCountResponse>;
+    count(args?: FiltersCountArgs): Result<FiltersCountResponse>;
+    read(args: BaseArgs): Result<Notification>;
+    read(args: InstanceArgs): Result<Notification>;
+    unread(args: BaseArgs): Result<Notification>;
+    unread(args: InstanceArgs): Result<Notification>;
+    seen(args: BaseArgs): Result<Notification>;
+    seen(args: InstanceArgs): Result<Notification>;
+    archive(args: BaseArgs): Result<Notification>;
+    archive(args: InstanceArgs): Result<Notification>;
+    unarchive(args: BaseArgs): Result<Notification>;
+    unarchive(args: InstanceArgs): Result<Notification>;
+    delete(args: BaseArgs): Result<void>;
+    delete(args: InstanceArgs): Result<void>;
+    snooze(args: SnoozeArgs): Result<Notification>;
+    unsnooze(args: BaseArgs): Result<Notification>;
+    unsnooze(args: InstanceArgs): Result<Notification>;
+    completePrimary(args: BaseArgs): Result<Notification>;
+    completePrimary(args: InstanceArgs): Result<Notification>;
+    completeSecondary(args: BaseArgs): Result<Notification>;
+    completeSecondary(args: InstanceArgs): Result<Notification>;
+    revertPrimary(args: BaseArgs): Result<Notification>;
+    revertPrimary(args: InstanceArgs): Result<Notification>;
+    revertSecondary(args: BaseArgs): Result<Notification>;
+    revertSecondary(args: InstanceArgs): Result<Notification>;
+    readAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    seenAll(args?: {
+        notificationIds: string[];
+    } | {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    } | {}): Result<void>;
+    archiveAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    archiveAllRead({ tags, data }?: {
+        tags?: string[];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    deleteAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    clearCache({ filter }?: {
+        filter?: NotificationFilter;
+    }): void;
+    triggerHelloWorldEvent(): Promise<any>;
+}
+
+interface BaseSocketInterface {
+    isSocketEvent(eventName: string): eventName is SocketEventNames;
+    connect(): Result<void>;
+    disconnect(): Result<void>;
+}
+
+declare class Novu implements Pick<NovuEventEmitter, 'on'> {
+    #private;
+    readonly notifications: Notifications;
+    readonly preferences: Preferences;
+    readonly socket: BaseSocketInterface;
+    on: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => () => void;
+    /**
+     * @deprecated
+     * Use the cleanup function returned by the "on" method instead.
+     */
+    off: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => void;
+    get applicationIdentifier(): string | undefined;
+    get subscriberId(): string | undefined;
+    get context(): Partial<Record<string, ContextValue>> | undefined;
+    get contextKey(): string;
+    constructor(options: NovuOptions);
+    changeSubscriber(options: {
+        subscriber: Subscriber;
+        subscriberHash?: string;
+    }): Promise<void>;
+    changeContext(options: {
+        context: Context;
+        contextHash?: string;
+    }): Promise<void>;
+}
+
+export { Novu as N };