@staffbase/plugins-client-sdk 2.0.1 → 3.0.0-beta.4

package/dist/plugins-client-sdk.umd.js

@@ -2,12 +2,12 @@
  * Bundle of @staffbase/plugins-client-sdk
  * @file Staffbase plugins client SDK for JavaScript
  * @see https://github.com/Staffbase/plugins-client-sdk#readme
- * @version 2.0.0
+ * @version 3.0.0-alpha.2
  *
  * @author Stefan Staude <stefan.staude@staffbase.com>
  * @author Daniel Große <daniel.grosse@staffbase.com>
  *
- * @copyright  2023
+ * @copyright  2024
  * @license Apache-2.0
  */
 
@@ -46,6 +46,8 @@
 	    var undefinedType = "undefined";
 	    var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
 	    var logMethods = ["trace", "debug", "info", "warn", "error"];
+	    var _loggersByName = {};
+	    var defaultLogger = null;
 
 	    // Cross-browser bind equivalent that works at least back to IE6
 	    function bindMethod(obj, methodName) {
@@ -98,23 +100,31 @@
 
 	    // These private functions always need `this` to be set properly
 
-	    function replaceLoggingMethods(level, loggerName) {
+	    function replaceLoggingMethods() {
 	      /*jshint validthis:true */
+	      var level = this.getLevel();
+
+	      // Replace the actual methods.
 	      for (var i = 0; i < logMethods.length; i++) {
 	        var methodName = logMethods[i];
-	        this[methodName] = i < level ? noop : this.methodFactory(methodName, level, loggerName);
+	        this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
 	      }
 
 	      // Define log.log as an alias for log.debug
 	      this.log = this.debug;
+
+	      // Return any important warnings.
+	      if (typeof console === undefinedType && level < this.levels.SILENT) {
+	        return "No console available for logging";
+	      }
 	    }
 
 	    // In old IE versions, the console isn't present until you first open it.
 	    // We build realMethod() replacements here that regenerate logging methods
-	    function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
+	    function enableLoggingWhenConsoleArrives(methodName) {
 	      return function () {
 	        if (typeof console !== undefinedType) {
-	          replaceLoggingMethods.call(this, level, loggerName);
+	          replaceLoggingMethods.call(this);
 	          this[methodName].apply(this, arguments);
 	        }
 	      };
@@ -122,14 +132,34 @@
 
 	    // By default, we use closely bound real methods wherever possible, and
 	    // otherwise we wait for a console to appear, and then try again.
-	    function defaultMethodFactory(methodName, level, loggerName) {
+	    function defaultMethodFactory(methodName, _level, _loggerName) {
 	      /*jshint validthis:true */
 	      return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
 	    }
-	    function Logger(name, defaultLevel, factory) {
+	    function Logger(name, factory) {
+	      // Private instance variables.
 	      var self = this;
-	      var currentLevel;
-	      defaultLevel = defaultLevel == null ? "WARN" : defaultLevel;
+	      /**
+	       * The level inherited from a parent logger (or a global default). We
+	       * cache this here rather than delegating to the parent so that it stays
+	       * in sync with the actual logging methods that we have installed (the
+	       * parent could change levels but we might not have rebuilt the loggers
+	       * in this child yet).
+	       * @type {number}
+	       */
+	      var inheritedLevel;
+	      /**
+	       * The default level for this logger, if any. If set, this overrides
+	       * `inheritedLevel`.
+	       * @type {number|null}
+	       */
+	      var defaultLevel;
+	      /**
+	       * A user-specific level for this logger. If set, this overrides
+	       * `defaultLevel`.
+	       * @type {number|null}
+	       */
+	      var userLevel;
 	      var storageKey = "loglevel";
 	      if (typeof name === "string") {
 	        storageKey += ":" + name;
@@ -162,9 +192,10 @@
 	        if (typeof storedLevel === undefinedType) {
 	          try {
 	            var cookie = window.document.cookie;
-	            var location = cookie.indexOf(encodeURIComponent(storageKey) + "=");
+	            var cookieName = encodeURIComponent(storageKey);
+	            var location = cookie.indexOf(cookieName + "=");
 	            if (location !== -1) {
-	              storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+	              storedLevel = /^([^;]+)/.exec(cookie.slice(location + cookieName.length + 1))[1];
 	            }
 	          } catch (ignore) {}
 	        }
@@ -181,7 +212,6 @@
 	        // Use localStorage if available
 	        try {
 	          window.localStorage.removeItem(storageKey);
-	          return;
 	        } catch (ignore) {}
 
 	        // Use session cookie as fallback
@@ -189,6 +219,17 @@
 	          window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
 	        } catch (ignore) {}
 	      }
+	      function normalizeLevel(input) {
+	        var level = input;
+	        if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+	          level = self.levels[level.toUpperCase()];
+	        }
+	        if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+	          return level;
+	        } else {
+	          throw new TypeError("log.setLevel() called with invalid level: " + input);
+	        }
+	      }
 
 	      /*
 	       *
@@ -207,46 +248,60 @@
 	      };
 	      self.methodFactory = factory || defaultMethodFactory;
 	      self.getLevel = function () {
-	        return currentLevel;
+	        if (userLevel != null) {
+	          return userLevel;
+	        } else if (defaultLevel != null) {
+	          return defaultLevel;
+	        } else {
+	          return inheritedLevel;
+	        }
 	      };
 	      self.setLevel = function (level, persist) {
-	        if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
-	          level = self.levels[level.toUpperCase()];
-	        }
-	        if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
-	          currentLevel = level;
-	          if (persist !== false) {
-	            // defaults to true
-	            persistLevelIfPossible(level);
-	          }
-	          replaceLoggingMethods.call(self, level, name);
-	          if (typeof console === undefinedType && level < self.levels.SILENT) {
-	            return "No console available for logging";
-	          }
-	        } else {
-	          throw "log.setLevel() called with invalid level: " + level;
+	        userLevel = normalizeLevel(level);
+	        if (persist !== false) {
+	          // defaults to true
+	          persistLevelIfPossible(userLevel);
 	        }
+
+	        // NOTE: in v2, this should call rebuild(), which updates children.
+	        return replaceLoggingMethods.call(self);
 	      };
 	      self.setDefaultLevel = function (level) {
-	        defaultLevel = level;
+	        defaultLevel = normalizeLevel(level);
 	        if (!getPersistedLevel()) {
 	          self.setLevel(level, false);
 	        }
 	      };
 	      self.resetLevel = function () {
-	        self.setLevel(defaultLevel, false);
+	        userLevel = null;
 	        clearPersistedLevel();
+	        replaceLoggingMethods.call(self);
+	      };
+	      self.enableAll = function (persist) {
+	        self.setLevel(self.levels.TRACE, persist);
 	      };
 	      self.disableAll = function (persist) {
 	        self.setLevel(self.levels.SILENT, persist);
 	      };
+	      self.rebuild = function () {
+	        if (defaultLogger !== self) {
+	          inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+	        }
+	        replaceLoggingMethods.call(self);
+	        if (defaultLogger === self) {
+	          for (var childName in _loggersByName) {
+	            _loggersByName[childName].rebuild();
+	          }
+	        }
+	      };
 
-	      // Initialize with the right level
+	      // Initialize all the internal levels.
+	      inheritedLevel = normalizeLevel(defaultLogger ? defaultLogger.getLevel() : "WARN");
 	      var initialLevel = getPersistedLevel();
-	      if (initialLevel == null) {
-	        initialLevel = defaultLevel;
+	      if (initialLevel != null) {
+	        userLevel = normalizeLevel(initialLevel);
 	      }
-	      self.setLevel(initialLevel, false);
+	      replaceLoggingMethods.call(self);
 	    }
 
 	    /*
@@ -255,15 +310,14 @@
 	     *
 	     */
 
-	    var defaultLogger = new Logger();
-	    var _loggersByName = {};
+	    defaultLogger = new Logger();
 	    defaultLogger.getLogger = function getLogger(name) {
 	      if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
 	        throw new TypeError("You must supply a name when creating a logger.");
 	      }
 	      var logger = _loggersByName[name];
 	      if (!logger) {
-	        logger = _loggersByName[name] = new Logger(name, defaultLogger.getLevel(), defaultLogger.methodFactory);
+	        logger = _loggersByName[name] = new Logger(name, defaultLogger.methodFactory);
 	      }
 	      return logger;
 	    };
@@ -349,7 +403,8 @@
 	  nativeShare: 'nativeShareDialog',
 	  langInfos: 'getLanguageInfos',
 	  branchDefaultLang: 'getBranchDefaultLanguage',
-	  prefContentLang: 'getPreferredContentLocale'
+	  prefContentLang: 'getPreferredContentLocale',
+	  userContentLocale: 'getUserContentLocale'
 	};
 
 	/**
@@ -938,7 +993,17 @@
 	  }
 	};
 
-	let connection$2 = null;
+	/**
+	 * Get the current user's content locale, fallback to branch default locale
+	 *
+	 * @return {String} the user's content locale
+	 */
+	const getUserContentLocale$2 = () => {
+	  const locale = getBranchDefaultLanguage$2().locale;
+	  return locale;
+	};
+
+	let connection$1 = null;
 	const fallbackKickIn = 500;
 
 	/**
@@ -949,15 +1014,15 @@
 	 * @return {Promise<function>} An appropriate send function
 	 */
 	var fallback = (() => {
-	  if (connection$2) {
-	    return connection$2;
+	  if (connection$1) {
+	    return connection$1;
 	  }
-	  connection$2 = new Promise(resolve => {
+	  connection$1 = new Promise(resolve => {
 	    setTimeout(function () {
-	      resolve(sendMessage$3);
+	      resolve(sendMessage$2);
 	    }, fallbackKickIn);
 	  });
-	  return connection$2;
+	  return connection$1;
 	});
 
 	/**
@@ -969,7 +1034,7 @@
 	 * @return {Promise<any>} which awaits the response of the Staffbase App
 	 * @throws {Error} on commands not supported by protocol
 	 */
-	const sendMessage$3 = async function (cmd) {
+	const sendMessage$2 = async function (cmd) {
 	  for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 	    payload[_key - 1] = arguments[_key];
 	  }
@@ -992,6 +1057,8 @@
 	      return getBranchDefaultLanguage$2();
 	    case commands.prefContentLang:
 	      return getPreferredContentLocale$2.apply(null, payload);
+	    case commands.userContentLocale:
+	      return getUserContentLocale$2();
 	    case commands.nativeUpload:
 	    case commands.nativeShare:
 	      return unSupported();
@@ -1014,7 +1081,6 @@
 	  // send this to call a function in the frontend
 	  ERROR: 'ERROR' // receive this when something goes wrong
 	};
-
 	const invocationMapping = {
 	  [commands.openLink]: 'openLink',
 	  [commands.nativeUpload]: 'nativeFileUpload',
@@ -1077,11 +1143,9 @@
 	 *
 	 * @param {string} id of the promise
 	 * @param {any} msg the message which will will be passed to resolve
-	 *
-	 * @throws {Error} on unknown id
 	 */
 	const resolve = (id, msg) => {
-	  if (!(id in promiseMap)) throw new Error('Tried to resolve an unknown [' + id + '] promise.');
+	  if (!(id in promiseMap)) return;
 	  promiseMap[id].resolve(msg);
 	  delete promiseMap[id];
 	};
@@ -1091,10 +1155,9 @@
 	 *
 	 * @param {string} id of the promise
 	 * @param {any} err the error which will will be passed to reject
-	 * @throws {Error} on unknown id
 	 */
 	const reject = (id, err) => {
-	  if (!(id in promiseMap)) throw new Error('Tried to reject an unknown [' + id + '] promise.');
+	  if (!(id in promiseMap)) return;
 	  promiseMap[id].reject(err);
 	  delete promiseMap[id];
 	};
@@ -1129,7 +1192,7 @@
 	 * @static
 	 * @return {StaticValueStore}
 	 */
-	const dataStore$1 = _ref => {
+	const dataStore = _ref => {
 	  let {
 	    platform,
 	    language
@@ -1144,26 +1207,53 @@
 	    branchDefaultLanguage: language.branchDefaultLanguage
 	  };
 	};
-	let connection$1 = null;
+	let connection = null;
 	const targetOrigin = '*';
 
 	/**
 	 * Connect to the Staffbase App.
 	 *
-	 * Create a connection to a Staffbase app 3.6
-	 * @return {Promise<function>} An appropriate send function
+	 * Create a connection to a Staffbase app
+	 * Tries to reconnect until an answer is received
+	 *
+	 * @return {Promise<Function>} An appropriate send function
 	 */
-	const connect$2 = () => {
-	  if (connection$1) {
-	    return connection$1;
+	const connect$1 = () => {
+	  if (connection) {
+	    return connection;
 	  }
 	  const connectId = create();
-	  connection$1 = get(connectId).then(function (payload) {
-	    return sendMessage$2(dataStore$1(payload));
+	  let timeout;
+	  const delayFactor = 1.2;
+	  connection = get(connectId).then(payload => {
+	    window.clearTimeout(timeout);
+	    return sendMessage$1(dataStore(payload));
 	  });
 	  window.addEventListener('message', receiveMessage);
-	  window.parent.postMessage([protocol.HELLO, connectId, []], targetOrigin);
-	  return connection$1;
+	  const recurringConnect = function () {
+	    let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 500;
+	    timeout = window.setTimeout(() => {
+	      if (delay < 1200) {
+	        recurringConnect(delay * delayFactor);
+	      } else {
+	        reject(connectId, 'No answer from Staffbase App');
+	        disconnect();
+	      }
+	    }, delay);
+	    window.parent.postMessage([protocol.HELLO, connectId, []], targetOrigin);
+	  };
+	  recurringConnect();
+	  return connection;
+	};
+
+	/**
+	 * Disconnect from the Staffbase App
+	 *
+	 * Only useful for tests.
+	 */
+	const disconnect = () => {
+	  window.removeEventListener('message', receiveMessage);
+	  connection = null;
 	};
 
 	/**
@@ -1215,7 +1305,7 @@
 	 * @return {Promise<any>} which awaits the response of the Staffbase App
 	 * @throws {Error} on commands not supported by protocol
 	 */
-	const sendMessage$2 = store => async function (cmd) {
+	const sendMessage$1 = store => async function (cmd) {
 	  switch (cmd) {
 	    case commands.version:
 	    case commands.native:
@@ -1232,7 +1322,7 @@
 	      for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 	        payload[_key - 1] = arguments[_key];
 	      }
-	      return sendInvocationCall$1(create())(invocationMapping[cmd], payload);
+	      return sendInvocationCall(create())(invocationMapping[cmd], payload);
 	    default:
 	      throw new Error('Command ' + cmd + ' not supported by driver');
 	  }
@@ -1247,164 +1337,16 @@
 	 *
 	 * @return {Promise}
 	 */
-	const sendInvocationCall$1 = promiseID => (process, args) => {
+	const sendInvocationCall = promiseID => (process, args) => {
 	  window.parent.postMessage([protocol.INVOCATION, promiseID, process, args], targetOrigin);
 	  return get(promiseID);
 	};
 
-	let connection = null;
-	let outMsgQueue = [];
-
-	/**
-	 * Simple store solution to make the initial data available
-	 * as static values
-	 *
-	 * @param {InitialValues} initial the initial data from the frontend
-	 * @static
-	 * @return {StaticValueStore}
-	 */
-	const dataStore = _ref => {
-	  let {
-	    platform,
-	    language
-	  } = _ref;
-	  return {
-	    mobile: platform.mobile,
-	    version: platform.version,
-	    native: platform.native,
-	    ios: platform.native === 'ios',
-	    android: platform.native === 'android',
-	    langInfos: language,
-	    branchDefaultLang: language.branchDefaultLanguage
-	  };
-	};
-	window.Staffbase = window.Staffbase || {};
-	window.Staffbase.plugins = {
-	  getMessages: multiMessageProvider,
-	  putMessage: singleMessageReceiver
-	};
-
-	/**
-	 * Connect to the Staffbase App.
-	 *
-	 * Create a connection to a Staffbase app 3.6 from a native tab
-	 * @return {Promise<function>} An appropriate send function
-	 */
-	const connect$1 = () => {
-	  if (connection) {
-	    return connection;
-	  }
-	  const connectId = create();
-	  connection = get(connectId).then(function (payload) {
-	    return sendMessage$1(dataStore(payload));
-	  });
-	  outMsgQueue.push([protocol.HELLO, connectId, []]);
-	  return connection;
-	};
-
-	/**
-	 * A function which returns an array of messages
-	 *
-	 * The return value holds all messages in the order the were
-	 * received over time by sendMessage
-	 *
-	 * @return {Array} ordered list of messages
-	 */
-	function multiMessageProvider() {
-	  const queueRef = outMsgQueue;
-	  if (queueRef.length) ;
-	  outMsgQueue = [];
-	  return queueRef;
-	}
-
-	/**
-	 * A function which can receive a single message.
-	 *
-	 * Can be attached to window.onPostMessage
-	 * @param {Array} msg Staffbase 3.6 message
-	 */
-	function singleMessageReceiver(msg) {
-	  let type;
-	  let id;
-	  let payload;
-
-	  // safe destructure
-	  try {
-	    [type, id, payload] = msg;
-	    switch (type) {
-	      case protocol.SUCCESS:
-	        resolve(id, payload);
-	        break;
-	      case protocol.ERROR:
-	        reject(id, payload);
-	        break;
-	      default:
-	        // even thought catch-ignore is a bad style
-	        // there may be other participants listening
-	        // to messages in a different format so we
-	        // silently ignore here
-	        return;
-	    }
-	  } catch (e) {
-	    // even thought catch-ignore is a bad style
-	    // there may be other participants listening
-	    // to messages in a different format so we
-	    // silently ignore here
-	    return;
-	  }
-	}
-
-	/**
-	 * Send a SDK command to the Staffbase App.
-	 *
-	 * Translates SDK commands into protocol native commands.
-	 * @param {StaticValueStore} store the store object
-	 * @param {String} cmd an SDK command
-	 * @param {array} payload for the command
-	 * @return {Promise<any>} which awaits the response of the Staffbase App
-	 * @throws {Error} on commands not supported by protocol
-	 */
-	const sendMessage$1 = store => async function (cmd) {
-	  switch (cmd) {
-	    case commands.version:
-	    case commands.native:
-	    case commands.mobile:
-	    case commands.ios:
-	    case commands.android:
-	    case commands.langInfos:
-	    case commands.branchDefaultLang:
-	      return store[reversedCommands[cmd]];
-	    case commands.openLink:
-	    case commands.prefContentLang:
-	      for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	        payload[_key - 1] = arguments[_key];
-	      }
-	      return sendInvocationCall(invocationMapping[cmd], payload);
-	    default:
-	      throw new Error('Command ' + cmd + ' not supported by driver');
-	  }
-	};
-
-	/**
-	 * Create a promise and send an invocation call to the frontend
-	 *
-	 * @param {string} process the name of the process to call
-	 * @param {array} args an array of arguments
-	 *
-	 * @return {Promise}
-	 */
-	const sendInvocationCall = (process, args) => {
-	  const promiseID = create();
-	  outMsgQueue.push([protocol.INVOCATION, promiseID, process, args]);
-	  return get(promiseID);
-	};
-
 	let connector;
 	const connect = async () => {
-	  const putMessageConnection = connect$1();
-	  const postMessageConnection = connect$2();
+	  const postMessageConnection = connect$1();
 	  const fallbackConnection = fallback();
-	  const realConnectionBucket = [putMessageConnection, postMessageConnection];
+	  const realConnectionBucket = [postMessageConnection];
 	  const fallbackConnectionBucket = realConnectionBucket.concat(fallbackConnection);
 
 	  // Wait on the real communication and replace the connector with
@@ -1574,6 +1516,15 @@
 	  return sendMessage(commands.prefContentLang, content);
 	};
 
+	/**
+	 * Get the default content language configured for the branch.
+	 *
+	 * @return {Promise<Object>}
+	 */
+	const getUserContentLocale$1 = async () => {
+	  return sendMessage(commands.langInfos).then(res => res.userContentLocale);
+	};
+
 	/**
 	 * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
 	 * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
@@ -1673,6 +1624,7 @@
 	 * Interface exports
 	 */
 
+
 	/**
 	 * Check if device is able to perform a download.
 	 * @function
@@ -1779,6 +1731,13 @@
 	 */
 	const getPreferredContentLocale = async content => getPreferredContentLocale$1(content);
 
+	/**
+	 * Get the current user's content locale, fallback to branch default locale
+	 * @function
+	 * @return {Promise<any>}
+	 */
+	const getUserContentLocale = async () => getUserContentLocale$1();
+
 	/**
 	 * Open a share dialog on native devices
 	 *
@@ -1803,6 +1762,7 @@
 	exports.getBranchLanguages = getBranchLanguages;
 	exports.getContentLanguages = getContentLanguages;
 	exports.getPreferredContentLocale = getPreferredContentLocale;
+	exports.getUserContentLocale = getUserContentLocale;
 	exports.isAndroidDevice = isAndroidDevice;
 	exports.isIosDevice = isIosDevice;
 	exports.isMobileApp = isMobileApp;