web-push-notifications 3.40.3 → 3.44.2

package/src/modules/storage/Store.ts

@@ -0,0 +1,104 @@
+import { type IIDBGetTransactionEventTargetWithResult, type TIDBKeyType, type TIDBQueryValue, type TSdkStoreName } from './Storage.types';
+
+export default class Store {
+  private readonly name: TSdkStoreName;
+  private store: IDBObjectStore;
+  private _index: IDBIndex;
+
+  constructor(
+    db: IDBDatabase,
+    name: TSdkStoreName,
+  ) {
+    this.name = name;
+    this.store = db.transaction(this.name, 'readwrite').objectStore(this.name);
+  }
+
+  set index(index: string) {
+    const indexNames = this.store.indexNames;
+    if (indexNames.contains(index)) {
+      this._index = this.store.index(index);
+    } else {
+      console.warn(`Index "${index}" in `);
+    }
+  }
+
+  private writeRequestPromise<T>(request: IDBRequest, result?: T): Promise<T> {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        // @ts-ignore
+        resolve(result);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  private readRequestPromise<Response, D>(request: IDBRequest, defaultValue?: D): Promise<Response | D> {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = (event) => {
+        const target: IIDBGetTransactionEventTargetWithResult = <IIDBGetTransactionEventTargetWithResult>event.target;
+        // @ts-ignore
+        resolve(<Response>target.result || defaultValue);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  put(data: any, key?: TIDBKeyType): Promise<TIDBKeyType> {
+    const request = this.store.put(data, key);
+    return this.writeRequestPromise<TIDBKeyType>(request, key);
+  }
+
+  /**
+   * Fallback for old interface
+   * @param data
+   * @param key
+   */
+  add(data: any, key?: string): Promise<TIDBKeyType> {
+    return this.put(data, key);
+  }
+
+  delete(key: TIDBKeyType): Promise<void> {
+    const request = this.store.delete(key);
+    return this.writeRequestPromise(request);
+  }
+
+  get<Response, D>(key: TIDBKeyType, defaultValue?: D) {
+    const request = this.store.get(key);
+    return this.readRequestPromise<Response, D>(request, defaultValue);
+  }
+
+  getAll<Response>(): Promise<Array<Response>> {
+    const cursor = this.store.openCursor();
+    const result: Array<Response> = [];
+
+    return new Promise((resolve, reject) => {
+      cursor.onsuccess = (event) => {
+        const target: IIDBGetTransactionEventTargetWithResult = <IIDBGetTransactionEventTargetWithResult>event.target;
+        const cursorResult = target.result;
+        if (cursorResult) {
+          result.push(cursorResult.value);
+          cursorResult.continue();
+        } else {
+          resolve(result);
+        }
+      };
+      cursor.onerror = () => {
+        reject(cursor.error);
+      };
+    });
+  }
+
+  count(query?: IDBKeyRange): Promise<number> {
+    const request = this.store.count(query);
+    return this.readRequestPromise<number, number>(request, 0);
+  }
+
+  countByIndex(key?: TIDBQueryValue) {
+    const request = this._index.count(key);
+    return this.readRequestPromise<number, number>(request, 0);
+  }
+}

package/src/modules/storage/migrations/26-11-2018.ts

@@ -0,0 +1,25 @@
+import {
+  STORE_NAME_INBOX_MESSAGES,
+} from './constants';
+import { storeCreatorDecorator } from './helpers';
+import {
+  type TInboxMessagesIDBKeyPath,
+  type TInboxMessagesIDBRemovalTimeIndex,
+  type TInboxMessagesIDBStatusIndex,
+} from '../../../models/InboxMessages.types';
+
+function createInboxMessagesStore(database: IDBDatabase) {
+  const keyPath: TInboxMessagesIDBKeyPath = 'inbox_id';
+  const statusIndex: TInboxMessagesIDBStatusIndex = 'status';
+  const removalTimeIndex: TInboxMessagesIDBRemovalTimeIndex = 'rt';
+
+  const store = database.createObjectStore(STORE_NAME_INBOX_MESSAGES,
+    { keyPath, autoIncrement: false },
+  );
+  store.createIndex(statusIndex, statusIndex, { unique: false, multiEntry: true });
+  store.createIndex(removalTimeIndex, removalTimeIndex, { unique: false, multiEntry: true });
+}
+
+export default [
+  storeCreatorDecorator(STORE_NAME_INBOX_MESSAGES, createInboxMessagesStore),
+];

package/src/modules/storage/migrations/MigrationExecutor.ts

@@ -0,0 +1,31 @@
+import Migrations from './Migrations';
+import { type TMigrationType } from '../Storage.types';
+
+export default class MigrationExecutor {
+  db: IDBDatabase;
+  migrationsBuilder: Migrations;
+
+  constructor(
+    db: IDBDatabase,
+    migrationsBuilder: Migrations = new Migrations(),
+  ) {
+    this.db = db;
+    this.migrationsBuilder = migrationsBuilder;
+  }
+
+  applyMigrations() {
+    // apply initial migrations
+    this.applyMigrationsPack(this.migrationsBuilder.initial);
+
+    // apply migrations, sorted by date
+    this.migrationsBuilder.dateSorted.forEach((migrationsPack) => {
+      this.applyMigrationsPack(migrationsPack);
+    });
+  }
+
+  applyMigrationsPack(migrationsPack: Array<TMigrationType>) {
+    migrationsPack.forEach((migration) => {
+      migration(this.db);
+    });
+  }
+}

package/src/modules/storage/migrations/Migrations.ts

@@ -0,0 +1,41 @@
+import { default as migrations26_11_2018 } from './26-11-2018';
+import { default as migrationsInitial } from './initial';
+import DateModule from '../../DateModule';
+import { type TMigrationsObjectType, type TMigrationType } from '../Storage.types';
+
+export default class Migrations {
+  migrations: TMigrationsObjectType;
+  dateModule: DateModule;
+
+  constructor(dateModule: DateModule = new DateModule()) {
+    this.migrations = {
+      // initial migrations
+      initial: migrationsInitial,
+
+      // migrations for 2018-11-26
+      '2018/11/26': migrations26_11_2018,
+    };
+    this.dateModule = dateModule;
+  }
+
+  /**
+   * Initial migration pack
+   */
+  get initial(): Array<TMigrationType> {
+    return this.migrations.initial;
+  }
+
+  /**
+   * Return array of migrations packs sorted by date
+   */
+  get dateSorted(): Array<Array<TMigrationType>> {
+    return Object.keys(this.migrations)
+      .filter((key) => key !== 'initial') // remove initial migrations
+      .sort((a, b) => { // sort migrations by date YYYY/MM/DD
+        const dateA = new DateModule(new Date(a));
+        const dateB = new DateModule(new Date(b));
+        return dateA.getTimestamp() - dateB.getTimestamp();
+      })
+      .map((key) => this.migrations[key]); // Array of migrations packs, sorted by date
+  }
+}

package/src/modules/storage/migrations/constants.ts

@@ -0,0 +1,8 @@
+import { type TInboxMessagesStoreName, type TKeyValueStoreName, type TMainLogStoreName, type TMessageLogStoreName } from '../Storage.types';
+
+export const STORE_NAME_KEY_VALUE: TKeyValueStoreName = 'keyValue';
+export const STORE_NAME_MESSAGE_LOG: TMessageLogStoreName = 'messages';
+export const STORE_NAME_MAIN_LOG: TMainLogStoreName = 'log';
+export const STORE_NAME_INBOX_MESSAGES: TInboxMessagesStoreName = 'inboxMessages';
+
+export const KEY_PATH_BASE_INCREMENT = 'id';

package/src/modules/storage/migrations/helpers.ts

@@ -0,0 +1,16 @@
+import { type TMigrationType, type TSdkStoreName } from '../Storage.types';
+
+/**
+ * Check existed store, before create
+ * @param name
+ * @param storeCreator
+ */
+export function storeCreatorDecorator(name: TSdkStoreName, storeCreator: TMigrationType): TMigrationType {
+  return function (database: IDBDatabase) {
+    if (database.objectStoreNames.contains(name)) {
+      return;
+    }
+
+    storeCreator(database);
+  };
+}

package/src/modules/storage/migrations/initial.ts

@@ -0,0 +1,47 @@
+import {
+  STORE_NAME_KEY_VALUE,
+  STORE_NAME_MAIN_LOG,
+  STORE_NAME_MESSAGE_LOG,
+  KEY_PATH_BASE_INCREMENT,
+} from './constants';
+import { storeCreatorDecorator } from './helpers';
+
+/**
+ * Create keyValue store migration
+ * @param database
+ */
+function createKeyValueStore(database: IDBDatabase) {
+  database.createObjectStore(STORE_NAME_KEY_VALUE, { keyPath: 'key' });
+}
+
+/**
+ * Create log store migration
+ * @param database
+ */
+function createLogStore(database: IDBDatabase) {
+  const logStore = database.createObjectStore(
+    STORE_NAME_MAIN_LOG,
+    { keyPath: KEY_PATH_BASE_INCREMENT, autoIncrement: true },
+  );
+  logStore.createIndex('environment', 'environment', { unique: false });
+  logStore.createIndex('date', 'date', { unique: false });
+  logStore.createIndex('type', 'type', { unique: false });
+}
+
+/**
+ * Create message log store migration
+ * @param database
+ */
+function createMessageLogStore(database: IDBDatabase) {
+  const messagesStore = database.createObjectStore(
+    STORE_NAME_MESSAGE_LOG,
+    { keyPath: KEY_PATH_BASE_INCREMENT, autoIncrement: true },
+  );
+  messagesStore.createIndex('date', 'date', { unique: false });
+}
+
+export default [
+  storeCreatorDecorator(STORE_NAME_KEY_VALUE, createKeyValueStore),
+  storeCreatorDecorator(STORE_NAME_MAIN_LOG, createLogStore),
+  storeCreatorDecorator(STORE_NAME_MESSAGE_LOG, createMessageLogStore),
+];

package/src/modules/storage/version.ts

@@ -0,0 +1,2 @@
+// indexed DB version
+export default 7;

package/src/npm.ts

@@ -0,0 +1 @@
+export { Pushwoosh } from './core/Pushwoosh';

package/src/pushwoosh-web-notifications.ts

@@ -0,0 +1,47 @@
+import { getGlobal } from './core/functions';
+import { Pushwoosh } from './core/Pushwoosh';
+
+declare const __SDK_PATH__: string;
+function addWidget(widgetName: string) {
+  const src = `${__SDK_PATH__}pushwoosh-widget-${widgetName}${process.env.NODE_ENV === 'development' ? '.uncompress' : ''}.js`;
+  const script = document.createElement('script');
+  script.src = src;
+  script.async = true;
+  script.type = 'text/javascript';
+  document.head.appendChild(script);
+}
+
+function main() {
+  const global: any = getGlobal();
+  const PW = new Pushwoosh();
+  const commands = Array.isArray(global.Pushwoosh) ? global.Pushwoosh as any[] : [];
+
+  global.Pushwoosh = PW;
+  commands.forEach((command) => PW.push(command));
+
+  PW.push(() => {
+    const { initParams } = PW;
+
+    if (PW.driver.checkIsPermissionDefault()) {
+      addWidget('subscription-prompt');
+    }
+
+    if (initParams.subscribeWidget?.enable) {
+      addWidget('subscription-button');
+    }
+
+    if (initParams.subscribePopup?.enable) {
+      addWidget('subscribe-popup');
+    }
+
+    if (initParams.inboxWidget?.enable) {
+      addWidget('inbox');
+    }
+  });
+}
+
+if (document.readyState === 'complete') {
+  main();
+} else {
+  window.addEventListener('load', main);
+}

package/src/pushwoosh-widget-inbox.ts

@@ -0,0 +1,8 @@
+import { type Pushwoosh } from './core/Pushwoosh';
+import { PWInboxWidget } from './widgets/Inbox';
+
+const globalPW: Pushwoosh = (globalThis as any).Pushwoosh;
+
+globalPW.push(() => {
+  new PWInboxWidget(globalPW);
+});

package/src/pushwoosh-widget-subscribe-popup.ts

@@ -0,0 +1,9 @@
+import { type Pushwoosh } from './core/Pushwoosh';
+import { PWSubscribePopupWidget } from './widgets/SubscribePopup';
+
+const globalPW: Pushwoosh = (globalThis as any).Pushwoosh;
+
+globalPW.push(() => {
+  const popup = new PWSubscribePopupWidget(globalPW);
+  popup.initPopup();
+});

package/src/pushwoosh-widget-subscription-button.ts

@@ -0,0 +1,8 @@
+import { type Pushwoosh } from './core/Pushwoosh';
+import { PWSubscriptionButtonWidget } from './widgets/SubscriptionButton';
+
+const globalPW: Pushwoosh = (globalThis as any).Pushwoosh;
+
+globalPW.push(() => {
+  new PWSubscriptionButtonWidget(globalPW);
+});

package/src/pushwoosh-widget-subscription-prompt.ts

@@ -0,0 +1,6 @@
+import { type Pushwoosh } from './core/Pushwoosh';
+import { createWidget } from './widget-subscription-prompt';
+
+const globalPW: Pushwoosh = (globalThis as any).Pushwoosh;
+
+globalPW.push(() => createWidget(globalPW));