@staffbase/plugins-client-sdk 1.2.0 → 1.2.1

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

@@ -2,20 +2,20 @@
  * Bundle of @staffbase/plugins-client-sdk
  * @file Staffbase plugins client SDK for JavaScript
  * @see https://github.com/Staffbase/plugins-client-sdk#readme
- * @version 1.1.2
+ * @version 1.2.0
  *
  * @author Stefan Staude <stefan.staude@staffbase.com>
  * @author Daniel Große <daniel.grosse@staffbase.com>
  *
- * @copyright  2021
+ * @copyright  2022
  * @license Apache-2.0
  */
 
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
 	typeof define === 'function' && define.amd ? define(['exports'], factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['plugins-client-sdk'] = {}));
-}(this, (function (exports) { 'use strict';
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["plugins-client-sdk"] = {}));
+})(this, (function (exports) { 'use strict';
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -128,6 +128,7 @@
 	    function Logger(name, defaultLevel, factory) {
 	      var self = this;
 	      var currentLevel;
+	      defaultLevel = defaultLevel == null ? "WARN" : defaultLevel;
 	      var storageKey = "loglevel";
 
 	      if (typeof name === "string") {
@@ -178,6 +179,20 @@
 
 	        return storedLevel;
 	      }
+
+	      function clearPersistedLevel() {
+	        if (typeof window === undefinedType || !storageKey) return; // Use localStorage if available
+
+	        try {
+	          window.localStorage.removeItem(storageKey);
+	          return;
+	        } catch (ignore) {} // Use session cookie as fallback
+
+
+	        try {
+	          window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+	        } catch (ignore) {}
+	      }
 	      /*
 	       *
 	       * Public logger API - see https://github.com/pimterry/loglevel for details
@@ -224,11 +239,18 @@
 	      };
 
 	      self.setDefaultLevel = function (level) {
+	        defaultLevel = level;
+
 	        if (!getPersistedLevel()) {
 	          self.setLevel(level, false);
 	        }
 	      };
 
+	      self.resetLevel = function () {
+	        self.setLevel(defaultLevel, false);
+	        clearPersistedLevel();
+	      };
+
 	      self.disableAll = function (persist) {
 	        self.setLevel(self.levels.SILENT, persist);
 	      }; // Initialize with the right level
@@ -237,7 +259,7 @@
 	      var initialLevel = getPersistedLevel();
 
 	      if (initialLevel == null) {
-	        initialLevel = defaultLevel == null ? "WARN" : defaultLevel;
+	        initialLevel = defaultLevel;
 	      }
 
 	      self.setLevel(initialLevel, false);
@@ -311,7 +333,7 @@
 	}
 
 	function _iterableToArrayLimit(arr, i) {
-	  var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
+	  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
 
 	  if (_i == null) return;
 	  var _arr = [];
@@ -1535,113 +1557,117 @@
 	  });
 	};
 
-	var compareVersions$1 = {exports: {}};
+	function compareVersions(v1, v2) {
+	  // validate input and split into segments
+	  const n1 = validateAndParse(v1);
+	  const n2 = validateAndParse(v2); // pop off the patch
 
-	/* global define */
+	  const p1 = n1.pop();
+	  const p2 = n2.pop(); // validate numbers
 
-	(function (module, exports) {
-	  (function (root, factory) {
-	    /* istanbul ignore next */
-	    {
-	      module.exports = factory();
-	    }
-	  })(commonjsGlobal, function () {
-	    var semver = /^v?(?:\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+))?(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+	  const r = compareSegments(n1, n2);
+	  if (r !== 0) return r; // validate pre-release
 
-	    function indexOrEnd(str, q) {
-	      return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
-	    }
+	  if (p1 && p2) {
+	    return compareSegments(p1.split('.'), p2.split('.'));
+	  } else if (p1 || p2) {
+	    return p1 ? -1 : 1;
+	  }
 
-	    function split(v) {
-	      var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-	      var patchIndex = indexOrEnd(c, '-');
-	      var arr = c.substring(0, patchIndex).split('.');
-	      arr.push(c.substring(patchIndex + 1));
-	      return arr;
-	    }
+	  return 0;
+	}
+	const validate = v => typeof v === 'string' && /^[v\d]/.test(v) && semver.test(v);
+	const compare = (v1, v2, operator) => {
+	  // validate input operator
+	  assertValidOperator(operator); // since result of compareVersions can only be -1 or 0 or 1
+	  // a simple map can be used to replace switch
 
-	    function tryParse(v) {
-	      return isNaN(Number(v)) ? v : Number(v);
-	    }
+	  const res = compareVersions(v1, v2);
+	  return operatorResMap[operator].includes(res);
+	};
+	const satisfies = (v, r) => {
+	  // if no range operator then "="
+	  const m = r.match(/^([<>=~^]+)/);
+	  const op = m ? m[1] : '='; // if gt/lt/eq then operator compare
 
-	    function validate(version) {
-	      if (typeof version !== 'string') {
-	        throw new TypeError('Invalid argument expected string');
-	      }
+	  if (op !== '^' && op !== '~') return compare(v, r, op); // else range of either "~" or "^" is assumed
 
-	      if (!semver.test(version)) {
-	        throw new Error('Invalid argument not valid semver (\'' + version + '\' received)');
-	      }
-	    }
+	  const [v1, v2, v3] = validateAndParse(v);
+	  const [r1, r2, r3] = validateAndParse(r);
+	  if (compareStrings(v1, r1) !== 0) return false;
 
-	    function compareVersions(v1, v2) {
-	      [v1, v2].forEach(validate);
-	      var s1 = split(v1);
-	      var s2 = split(v2);
+	  if (op === '^') {
+	    return compareSegments([v2, v3], [r2, r3]) >= 0;
+	  }
 
-	      for (var i = 0; i < Math.max(s1.length - 1, s2.length - 1); i++) {
-	        var n1 = parseInt(s1[i] || 0, 10);
-	        var n2 = parseInt(s2[i] || 0, 10);
-	        if (n1 > n2) return 1;
-	        if (n2 > n1) return -1;
-	      }
+	  if (compareStrings(v2, r2) !== 0) return false;
+	  return compareStrings(v3, r3) >= 0;
+	}; // export CJS style for parity
 
-	      var sp1 = s1[s1.length - 1];
-	      var sp2 = s2[s2.length - 1];
+	compareVersions.validate = validate;
+	compareVersions.compare = compare;
+	compareVersions.sastisfies = satisfies;
+	const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
 
-	      if (sp1 && sp2) {
-	        var p1 = sp1.split('.').map(tryParse);
-	        var p2 = sp2.split('.').map(tryParse);
+	const validateAndParse = v => {
+	  if (typeof v !== 'string') {
+	    throw new TypeError('Invalid argument expected string');
+	  }
 
-	        for (i = 0; i < Math.max(p1.length, p2.length); i++) {
-	          if (p1[i] === undefined || typeof p2[i] === 'string' && typeof p1[i] === 'number') return -1;
-	          if (p2[i] === undefined || typeof p1[i] === 'string' && typeof p2[i] === 'number') return 1;
-	          if (p1[i] > p2[i]) return 1;
-	          if (p2[i] > p1[i]) return -1;
-	        }
-	      } else if (sp1 || sp2) {
-	        return sp1 ? -1 : 1;
-	      }
+	  const match = v.match(semver);
 
-	      return 0;
-	    }
-	    var allowedOperators = ['>', '>=', '=', '<', '<='];
-	    var operatorResMap = {
-	      '>': [1],
-	      '>=': [0, 1],
-	      '=': [0],
-	      '<=': [-1, 0],
-	      '<': [-1]
-	    };
+	  if (!match) {
+	    throw new Error(`Invalid argument not valid semver ('${v}' received)`);
+	  }
 
-	    function validateOperator(op) {
-	      if (typeof op !== 'string') {
-	        throw new TypeError('Invalid operator type, expected string but got ' + typeof op);
-	      }
+	  match.shift();
+	  return match;
+	};
 
-	      if (allowedOperators.indexOf(op) === -1) {
-	        throw new TypeError('Invalid operator, expected one of ' + allowedOperators.join('|'));
-	      }
-	    }
+	const isWildcard = s => s === '*' || s === 'x' || s === 'X';
 
-	    compareVersions.validate = function (version) {
-	      return typeof version === 'string' && semver.test(version);
-	    };
+	const tryParse = v => {
+	  const n = parseInt(v, 10);
+	  return isNaN(n) ? v : n;
+	};
 
-	    compareVersions.compare = function (v1, v2, operator) {
-	      // Validate operator
-	      validateOperator(operator); // since result of compareVersions can only be -1 or 0 or 1
-	      // a simple map can be used to replace switch
+	const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
 
-	      var res = compareVersions(v1, v2);
-	      return operatorResMap[operator].indexOf(res) > -1;
-	    };
+	const compareStrings = (a, b) => {
+	  if (isWildcard(a) || isWildcard(b)) return 0;
+	  const [ap, bp] = forceType(tryParse(a), tryParse(b));
+	  if (ap > bp) return 1;
+	  if (ap < bp) return -1;
+	  return 0;
+	};
 
-	    return compareVersions;
-	  });
-	})(compareVersions$1);
+	const compareSegments = (a, b) => {
+	  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+	    const r = compareStrings(a[i] || 0, b[i] || 0);
+	    if (r !== 0) return r;
+	  }
+
+	  return 0;
+	};
 
-	var compareVersions = compareVersions$1.exports;
+	const operatorResMap = {
+	  '>': [1],
+	  '>=': [0, 1],
+	  '=': [0],
+	  '<=': [-1, 0],
+	  '<': [-1]
+	};
+	const allowedOperators = Object.keys(operatorResMap);
+
+	const assertValidOperator = op => {
+	  if (typeof op !== 'string') {
+	    throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
+	  }
+
+	  if (allowedOperators.indexOf(op) === -1) {
+	    throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);
+	  }
+	};
 
 	/**
 	 * Check if device is using ios.
@@ -1893,5 +1919,5 @@
 
 	Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=plugins-client-sdk.umd.js.map