@hellotext/hellotext 2.5.6 → 2.5.7

package/lib/models/push.js

@@ -0,0 +1,412 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import API from '../api';
+import { Configuration } from '../core';
+
+/**
+ * Manages browser Push subscriptions for Hellotext.
+ *
+ * @property {Promise<void>|null} ready - Initialization promise, available after initialize().
+ */
+var Push = /*#__PURE__*/function () {
+  /**
+   * @param {Object} data - Push configuration from the business response.
+   * @param {String} data.public_key - Base64url-encoded VAPID public key.
+   */
+  function Push(data) {
+    _classCallCheck(this, Push);
+    this.publicKey = data.public_key;
+    this.serviceWorkerUrl = Configuration.push.serviceWorkerUrl;
+    this.channelId = Configuration.push.channelId;
+    this.ready = null;
+    this.registrationPromise = null;
+    this.subscribePromise = null;
+    this.unsubscribePromise = null;
+    this.syncPromise = null;
+    this.subscription = null;
+    this.retryTimeout = null;
+    this.retryAttempts = 0;
+    this.disposed = false;
+  }
+
+  /**
+   * Prepares the service worker and restores an existing subscription.
+   *
+   * @returns {Promise<void>}
+   */
+  _createClass(Push, [{
+    key: "initialize",
+    value: function initialize() {
+      this.ready = this.restoreSubscription();
+      return this.ready;
+    }
+
+    /**
+     * Registers an existing Hellotext subscription with the server without prompting.
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "restoreSubscription",
+    value: function () {
+      var _restoreSubscription = _asyncToGenerator(function* () {
+        var registration = yield this.getRegistration();
+        var subscription = yield registration.pushManager.getSubscription();
+        if (this.disposed || this.unsubscribePromise || !subscription || !this.owns(subscription)) {
+          return;
+        }
+        this.subscription = subscription;
+        yield this.sync();
+      });
+      function restoreSubscription() {
+        return _restoreSubscription.apply(this, arguments);
+      }
+      return restoreSubscription;
+    }()
+    /**
+     * Creates or reuses a Push subscription. Call from a user click handler.
+     * Concurrent calls share the same pending request.
+     *
+     * @returns {Promise<import('../api/response').Response|void>} Server registration response,
+     *   or no value when disposed.
+     *   Rejects when permission is denied or a browser or network operation fails.
+     */
+  }, {
+    key: "subscribe",
+    value: function subscribe() {
+      if (this.disposed) return Promise.resolve();
+      if (this.unsubscribePromise) return Promise.reject(new Error('Push unsubscribe is in progress'));
+      if (this.subscribePromise) return this.subscribePromise;
+
+      // Request permission before awaiting worker readiness to retain the click's user activation.
+      var permission = Notification.permission === 'default' ? Notification.requestPermission() : Promise.resolve(Notification.permission);
+      this.subscribePromise = this.createSubscription(permission).finally(() => {
+        this.subscribePromise = null;
+      });
+      return this.subscribePromise;
+    }
+
+    /**
+     * Waits for permission and worker readiness, then subscribes and registers with Hellotext.
+     *
+     * @private
+     * @param {Promise<NotificationPermission>} permission - Pending notification permission result.
+     * @returns {Promise<import('../api/response').Response|void>}
+     */
+  }, {
+    key: "createSubscription",
+    value: function () {
+      var _createSubscription = _asyncToGenerator(function* (permission) {
+        if ((yield permission) !== 'granted') throw new Error('Push permission was not granted');
+        var registration = yield this.getRegistration();
+        if (this.disposed) return;
+        var subscription = yield registration.pushManager.getSubscription();
+        if (this.disposed) return;
+        if (subscription && !this.owns(subscription)) {
+          throw new Error('The existing Push subscription belongs to a different application');
+        }
+        subscription || (subscription = yield registration.pushManager.subscribe({
+          userVisibleOnly: true,
+          applicationServerKey: this.applicationServerKey
+        }));
+        if (this.disposed) return;
+        this.subscription = subscription;
+        return this.sync();
+      });
+      function createSubscription(_x) {
+        return _createSubscription.apply(this, arguments);
+      }
+      return createSubscription;
+    }()
+    /**
+     * Disables the server identity and removes the browser subscription.
+     * Keeps the subscription when the server request fails so the caller can retry.
+     *
+     * @returns {Promise<import('../api/response').Response|null|void>} Server response, null when
+     *   no subscription exists, or no value when disposed. Rejects when a browser or network
+     *   operation fails.
+     */
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe() {
+      if (this.disposed) return Promise.resolve();
+      if (this.unsubscribePromise) return this.unsubscribePromise;
+      this.clearRetryTimeout();
+      this.unsubscribePromise = this.removeSubscription().finally(() => {
+        this.unsubscribePromise = null;
+      });
+      return this.unsubscribePromise;
+    }
+
+    /**
+     * Finishes pending registration before disabling and removing the subscription.
+     *
+     * @private
+     * @returns {Promise<import('../api/response').Response|null|void>}
+     */
+  }, {
+    key: "removeSubscription",
+    value: function () {
+      var _removeSubscription = _asyncToGenerator(function* () {
+        var _this$ready, _this$subscribePromis, _this$syncPromise;
+        yield (_this$ready = this.ready) === null || _this$ready === void 0 ? void 0 : _this$ready.catch(() => {});
+        yield (_this$subscribePromis = this.subscribePromise) === null || _this$subscribePromis === void 0 ? void 0 : _this$subscribePromis.catch(() => {});
+        yield (_this$syncPromise = this.syncPromise) === null || _this$syncPromise === void 0 ? void 0 : _this$syncPromise.catch(() => {});
+        var registration = yield this.getRegistration();
+        var subscription = (yield registration.pushManager.getSubscription()) || this.subscription;
+        if (this.disposed) return;
+        if (!subscription) return null;
+        if (!this.owns(subscription)) {
+          throw new Error('The existing Push subscription belongs to a different application');
+        }
+        this.subscription = subscription;
+        var response = yield API.pushIdentities.destroy({
+          subscription: subscription.toJSON()
+        });
+        if (response.failed) return response;
+        if (this.disposed) return;
+        yield subscription.unsubscribe();
+        this.subscription = null;
+        this.clearRetryTimeout();
+        return response;
+      });
+      function removeSubscription() {
+        return _removeSubscription.apply(this, arguments);
+      }
+      return removeSubscription;
+    }()
+    /**
+     * Registers the current subscription, sharing any request already in progress.
+     *
+     * @private
+     * @returns {Promise<import('../api/response').Response|void>}
+     */
+  }, {
+    key: "sync",
+    value: function sync() {
+      if (this.disposed) return Promise.resolve();
+      if (this.syncPromise) return this.syncPromise;
+      this.clearRetryTimeout();
+      this.syncPromise = this.registerIdentity().finally(() => {
+        this.syncPromise = null;
+      });
+      return this.syncPromise;
+    }
+
+    /**
+     * Sends the subscription to Hellotext and schedules a retry on failure.
+     *
+     * @private
+     * @returns {Promise<import('../api/response').Response>}
+     */
+  }, {
+    key: "registerIdentity",
+    value: function () {
+      var _registerIdentity = _asyncToGenerator(function* () {
+        try {
+          var response = yield API.pushIdentities.create(_objectSpread({
+            subscription: this.subscription.toJSON()
+          }, this.channelId ? {
+            channel_id: this.channelId
+          } : {}));
+          if (response.succeeded) {
+            this.retryAttempts = 0;
+          } else {
+            this.scheduleRetry();
+          }
+          return response;
+        } catch (error) {
+          this.scheduleRetry();
+          throw error;
+        }
+      });
+      function registerIdentity() {
+        return _registerIdentity.apply(this, arguments);
+      }
+      return registerIdentity;
+    }()
+    /**
+     * Schedules up to three registration retries with increasing delays.
+     *
+     * @private
+     * @returns {void}
+     */
+  }, {
+    key: "scheduleRetry",
+    value: function scheduleRetry() {
+      if (this.disposed || this.unsubscribePromise || this.retryTimeout || this.retryAttempts >= 3) return;
+      this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = null;
+        this.sync().catch(() => {});
+      }, 1000 * 2 ** this.retryAttempts);
+      this.retryAttempts += 1;
+    }
+
+    /**
+     * Cancels a pending registration retry.
+     *
+     * @private
+     * @returns {void}
+     */
+  }, {
+    key: "clearRetryTimeout",
+    value: function clearRetryTimeout() {
+      clearTimeout(this.retryTimeout);
+      this.retryTimeout = null;
+    }
+
+    /**
+     * Stops registration retries and prevents further use of this instance.
+     *
+     * @returns {void}
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.disposed = true;
+      this.clearRetryTimeout();
+    }
+
+    /**
+     * Whether this instance has a browser subscription, regardless of server registration.
+     *
+     * @returns {Boolean}
+     */
+  }, {
+    key: "subscribed",
+    get: function get() {
+      return !!this.subscription;
+    }
+
+    /**
+     * Decodes the public key into the bytes expected by PushManager.subscribe().
+     *
+     * @private
+     * @returns {Uint8Array}
+     */
+  }, {
+    key: "applicationServerKey",
+    get: function get() {
+      var base64 = this.publicKey.replace(/-/g, '+').replace(/_/g, '/');
+      return Uint8Array.from(atob(base64.padEnd(Math.ceil(base64.length / 4) * 4, '=')), char => char.charCodeAt(0));
+    }
+
+    /**
+     * Checks whether a subscription uses this instance's public key.
+     *
+     * @private
+     * @param {PushSubscription} subscription - Browser subscription to check.
+     * @returns {Boolean}
+     */
+  }, {
+    key: "owns",
+    value: function owns(subscription) {
+      var _subscription$options;
+      var key = (_subscription$options = subscription.options) === null || _subscription$options === void 0 ? void 0 : _subscription$options.applicationServerKey;
+      if (!key) return false;
+      var actual = new Uint8Array(key);
+      var expected = this.applicationServerKey;
+      return actual.length === expected.length && actual.every((value, index) => value === expected[index]);
+    }
+
+    /**
+     * Gets the worker registration, sharing any pending lookup.
+     * Failed lookups can be retried by a later call.
+     *
+     * @private
+     * @returns {Promise<ServiceWorkerRegistration>}
+     */
+  }, {
+    key: "getRegistration",
+    value: function getRegistration() {
+      if (!this.registrationPromise) {
+        this.registrationPromise = this.loadRegistration().catch(error => {
+          this.registrationPromise = null;
+          throw error;
+        });
+      }
+      return this.registrationPromise;
+    }
+
+    /**
+     * Registers the configured worker or waits for the page's existing registration.
+     *
+     * @private
+     * @returns {Promise<ServiceWorkerRegistration>} An active registration.
+     *   Rejects if registration fails or the worker readiness wait times out.
+     */
+  }, {
+    key: "loadRegistration",
+    value: function () {
+      var _loadRegistration = _asyncToGenerator(function* () {
+        if (this.serviceWorkerUrl) {
+          var registration = yield navigator.serviceWorker.register(this.serviceWorkerUrl);
+          if (registration.active && !registration.installing && !registration.waiting) {
+            // A returning visitor may have an older worker that does not include our Push handlers.
+            // Calling register() with the same URL can return that existing registration without
+            // checking whether the script served at that URL has changed since their last visit.
+            //
+            // If no replacement is already installing or waiting, explicitly check for an update
+            // before treating the active worker as ready. Awaiting update() completes the update
+            // check, but does not wait for a replacement worker to activate. The code below selects
+            // that replacement, if one was found, and waits for its activation before subscribing.
+            yield registration.update();
+          }
+          var worker = registration.installing || registration.waiting || registration.active;
+          if ((worker === null || worker === void 0 ? void 0 : worker.state) === 'activated') return registration;
+          return new Promise((resolve, reject) => {
+            var timeout = setTimeout(() => finish(new Error('Push service worker did not become active')), 10000);
+            var finish = error => {
+              clearTimeout(timeout);
+              worker === null || worker === void 0 ? void 0 : worker.removeEventListener('statechange', changed);
+              error ? reject(error) : resolve(registration);
+            };
+            var changed = () => {
+              if ((worker === null || worker === void 0 ? void 0 : worker.state) === 'activated') finish();
+              if ((worker === null || worker === void 0 ? void 0 : worker.state) === 'redundant') finish(new Error('Push service worker installation failed'));
+            };
+            worker === null || worker === void 0 ? void 0 : worker.addEventListener('statechange', changed);
+            changed();
+          });
+        }
+
+        // Reuse the service worker already registered for this page.
+        return new Promise((resolve, reject) => {
+          var timeout = setTimeout(() => reject(new Error('Push service worker is not available')), 10000);
+          navigator.serviceWorker.ready.then(registration => {
+            clearTimeout(timeout);
+            resolve(registration);
+          }, error => {
+            clearTimeout(timeout);
+            reject(error);
+          });
+        });
+      });
+      function loadRegistration() {
+        return _loadRegistration.apply(this, arguments);
+      }
+      return loadRegistration;
+    }()
+    /**
+     * Whether the current page provides the browser APIs required for Push.
+     *
+     * @returns {Boolean}
+     */
+  }], [{
+    key: "supported",
+    get: function get() {
+      return typeof window !== 'undefined' && window.isSecureContext === true && typeof navigator !== 'undefined' && 'serviceWorker' in navigator && typeof PushManager !== 'undefined' && typeof Notification !== 'undefined';
+    }
+  }]);
+  return Push;
+}();
+export { Push };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellotext/hellotext",
-  "version": "2.5.6",
+  "version": "2.5.7",
   "description": "Hellotext JavaScript Client",
   "source": "src/index.js",
   "main": "lib/index.cjs",
@@ -94,7 +94,7 @@
     "@emoji-mart/data": "^1.2.1",
     "@floating-ui/dom": "^1.7.3",
     "@hotwired/stimulus": "^3.0.0",
-    "dompurify": "^3.4.13",
+    "dompurify": "^3.4.14",
     "emoji-mart": "^5.6.0"
   },
   "packageManager": "yarn@1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610",

package/src/api/index.js

@@ -5,6 +5,7 @@ import IdentificationsAPI from './identifications'
 import WebchatsAPI from './webchats'
 import WhatsAppWidgetsAPI from './whatsapp_widgets'
 import AcksAPI from './acks'
+import PushIdentitiesAPI from './push/identities'
 
 // Browsers keep `fetch(..., { keepalive: true })` requests alive during page
 // unload/navigation, which is exactly the failure mode for analytics events
@@ -57,6 +58,10 @@ export default class API {
   static get acks() {
     return AcksAPI
   }
+
+  static get pushIdentities() {
+    return PushIdentitiesAPI
+  }
 }
 
 export { Response } from './response'

package/src/api/push/identities.js

@@ -0,0 +1,42 @@
+import Hellotext from '../../hellotext'
+
+import { Configuration } from '../../core'
+import { Response } from '../response'
+
+class PushIdentitiesAPI {
+  static get endpoint() {
+    return Configuration.endpoint('public/push/identities')
+  }
+
+  static async create(data = {}) {
+    const response = await fetch(this.endpoint, {
+      method: 'POST',
+      keepalive: true,
+      headers: Hellotext.headers,
+      body: JSON.stringify({
+        ...data,
+        session: Hellotext.session,
+        origin: window.location.origin,
+      }),
+    })
+
+    return new Response(response.ok, response)
+  }
+
+  static async destroy(data = {}) {
+    const response = await fetch(this.endpoint, {
+      method: 'DELETE',
+      keepalive: true,
+      headers: Hellotext.headers,
+      body: JSON.stringify({
+        ...data,
+        session: Hellotext.session,
+        origin: window.location.origin,
+      }),
+    })
+
+    return new Response(response.ok, response)
+  }
+}
+
+export default PushIdentitiesAPI

package/src/core/configuration/push.js

@@ -0,0 +1,12 @@
+class Push {
+  static serviceWorkerUrl = null
+  static channelId = null
+
+  static assign(props) {
+    this.serviceWorkerUrl = props?.serviceWorkerUrl || null
+    this.channelId = props?.channelId || null
+    return this
+  }
+}
+
+export { Push }

package/src/core/configuration.js

@@ -2,6 +2,7 @@ import { Forms } from './configuration/forms'
 import { Locale } from './configuration/locale'
 import { Webchat } from './configuration/webchat'
 import { WhatsApp } from './configuration/whatsapp'
+import { Push } from './configuration/push'
 
 /**
  * @class Configuration
@@ -12,6 +13,7 @@ import { WhatsApp } from './configuration/whatsapp'
  * @property {Forms} [forms] - form configuration
  * @property {Webchat} [webchat] - webchat configuration
  * @property {WhatsApp} [whatsappWidget] - WhatsApp widget configuration
+ * @property {Push} [push] - push subscription configuration
  * @property {Locale} [locale] - locale configuration
  */
 class Configuration {
@@ -24,6 +26,7 @@ class Configuration {
   static forms = Forms
   static webchat = Webchat
   static whatsapp = WhatsApp
+  static push = Push
 
   /**
    *
@@ -47,6 +50,8 @@ class Configuration {
           this.webchat = Webchat.assign(value)
         } else if (key === 'whatsappWidget') {
           this.whatsapp = WhatsApp.assign(value)
+        } else if (key === 'push') {
+          this.push = Push.assign(value)
         } else {
           this[key] = value
         }

package/src/hellotext.js

@@ -6,6 +6,7 @@ import {
   Fingerprint,
   FormCollection,
   Page,
+  Push,
   Query,
   Session,
   User,
@@ -21,6 +22,7 @@ class Hellotext {
   static business
   static webchat
   static whatsapp
+  static push
 
   /**
    * initialize the module.
@@ -28,10 +30,13 @@ class Hellotext {
    * @param { Configuration } config
    */
   static async initialize(business, config = {}) {
+    this.push?.dispose()
+    this.push = null
+
     this.business = new Business(business)
     this.page = new Page()
 
-    Configuration.assign(config)
+    Configuration.assign({ push: {}, ...config })
     Session.initialize(this.page)
 
     this.forms = new FormCollection()
@@ -39,6 +44,15 @@ class Hellotext {
     this.query = new Query()
 
     const businessData = await this.business.hydrate()
+
+    if (config.push !== false && businessData?.push?.public_key && Push.supported) {
+      this.push = new Push(businessData.push)
+
+      this.push.initialize().catch(error => {
+        console.warn('Hellotext Push initialization failed:', error)
+      })
+    }
+
     const webchatConfig =
       config.webchat === false
         ? false

package/src/models/business.js

@@ -27,6 +27,7 @@ const stylesheetLoadTimeout = 10000
  * @property {String} [locale] - Default dashboard locale for the business.
  * @property {String} [style_url] - Stylesheet URL to inject for dashboard-managed surfaces.
  * @property {BusinessWebchat|null} [webchat] - Dashboard webchat defaults.
+ * @property {{public_key: String}|null} [push] - Public VAPID key for push subscriptions.
  * @property {String|Array<String>} [whitelist] - Domain whitelist configuration.
  * @property {String} [subscription] - Current business subscription tier.
  */

package/src/models/index.js

@@ -4,6 +4,7 @@ export { Fingerprint } from './fingerprint'
 export { Form } from './form'
 export { FormCollection } from './form_collection'
 export { Page } from './page'
+export { Push } from './push'
 export { Query } from './query'
 export { Session } from './session'
 export { User } from './user'