@staffbase/plugins-client-sdk 2.0.2 → 3.0.0

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

@@ -2,7 +2,7 @@
  * 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.1
+ * @version 3.0.0-alpha.2
  *
  * @author Stefan Staude <stefan.staude@staffbase.com>
  * @author Daniel Große <daniel.grosse@staffbase.com>
@@ -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,35 +248,34 @@
 	      };
 	      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);
@@ -243,13 +283,25 @@
 	      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);
 	    }
 
 	    /*
@@ -258,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;
 	    };
@@ -352,7 +403,8 @@
 	  nativeShare: 'nativeShareDialog',
 	  langInfos: 'getLanguageInfos',
 	  branchDefaultLang: 'getBranchDefaultLanguage',
-	  prefContentLang: 'getPreferredContentLocale'
+	  prefContentLang: 'getPreferredContentLocale',
+	  userContentLocale: 'getUserContentLocale'
 	};
 
 	/**
@@ -941,6 +993,16 @@
 	  }
 	};
 
+	/**
+	 * 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;
 
@@ -951,7 +1013,7 @@
 	 * after the time specified in fallbackKickIn runs out.
 	 * @return {Promise<function>} An appropriate send function
 	 */
-	var fallback = (() => {
+	var fallback = () => {
 	  if (connection$1) {
 	    return connection$1;
 	  }
@@ -961,7 +1023,7 @@
 	    }, fallbackKickIn);
 	  });
 	  return connection$1;
-	});
+	};
 
 	/**
 	 * Send a SDK command to the Staffbase App.
@@ -995,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();
@@ -1017,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',
@@ -1453,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`.
@@ -1659,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
 	 *
@@ -1683,6 +1762,7 @@
 	exports.getBranchLanguages = getBranchLanguages;
 	exports.getContentLanguages = getContentLanguages;
 	exports.getPreferredContentLocale = getPreferredContentLocale;
+	exports.getUserContentLocale = getUserContentLocale;
 	exports.isAndroidDevice = isAndroidDevice;
 	exports.isIosDevice = isIosDevice;
 	exports.isMobileApp = isMobileApp;