@haiilo/catalyst 0.11.0 → 0.14.0

package/dist/cjs/{cat-notification-c2859ed7.js → cat-notification-6a438ad1.js}

@@ -1,6 +1,320 @@
 'use strict';
 
-const loglevel = require('./loglevel-b5d158ad.js');
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+var loglevel = createCommonjsModule(function (module) {
+/*
+* loglevel - https://github.com/pimterry/loglevel
+*
+* Copyright (c) 2013 Tim Perry
+* Licensed under the MIT license.
+*/
+(function (root, definition) {
+    if (module.exports) {
+        module.exports = definition();
+    } else {
+        root.log = definition();
+    }
+}(commonjsGlobal, function () {
+
+    // Slightly dubious tricks to cut down minimized file size
+    var noop = function() {};
+    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"
+    ];
+
+    // Cross-browser bind equivalent that works at least back to IE6
+    function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === 'function') {
+            return method.bind(obj);
+        } else {
+            try {
+                return Function.prototype.bind.call(method, obj);
+            } catch (e) {
+                // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+                return function() {
+                    return Function.prototype.apply.apply(method, [obj, arguments]);
+                };
+            }
+        }
+    }
+
+    // Trace() doesn't print the message in IE, so for that case we need to wrap it
+    function traceForIE() {
+        if (console.log) {
+            if (console.log.apply) {
+                console.log.apply(console, arguments);
+            } else {
+                // In old IE, native console methods themselves don't have apply().
+                Function.prototype.apply.apply(console.log, [console, arguments]);
+            }
+        }
+        if (console.trace) console.trace();
+    }
+
+    // Build the best logging method possible for this env
+    // Wherever possible we want to bind, not wrap, to preserve stack traces
+    function realMethod(methodName) {
+        if (methodName === 'debug') {
+            methodName = 'log';
+        }
+
+        if (typeof console === undefinedType) {
+            return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
+        } else if (methodName === 'trace' && isIE) {
+            return traceForIE;
+        } else if (console[methodName] !== undefined) {
+            return bindMethod(console, methodName);
+        } else if (console.log !== undefined) {
+            return bindMethod(console, 'log');
+        } else {
+            return noop;
+        }
+    }
+
+    // These private functions always need `this` to be set properly
+
+    function replaceLoggingMethods(level, loggerName) {
+        /*jshint validthis:true */
+        for (var i = 0; i < logMethods.length; i++) {
+            var methodName = logMethods[i];
+            this[methodName] = (i < level) ?
+                noop :
+                this.methodFactory(methodName, level, loggerName);
+        }
+
+        // Define log.log as an alias for log.debug
+        this.log = this.debug;
+    }
+
+    // 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) {
+        return function () {
+            if (typeof console !== undefinedType) {
+                replaceLoggingMethods.call(this, level, loggerName);
+                this[methodName].apply(this, arguments);
+            }
+        };
+    }
+
+    // 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) {
+        /*jshint validthis:true */
+        return realMethod(methodName) ||
+               enableLoggingWhenConsoleArrives.apply(this, arguments);
+    }
+
+    function Logger(name, defaultLevel, factory) {
+      var self = this;
+      var currentLevel;
+      defaultLevel = defaultLevel == null ? "WARN" : defaultLevel;
+
+      var storageKey = "loglevel";
+      if (typeof name === "string") {
+        storageKey += ":" + name;
+      } else if (typeof name === "symbol") {
+        storageKey = undefined;
+      }
+
+      function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+
+          if (typeof window === undefinedType || !storageKey) return;
+
+          // Use localStorage if available
+          try {
+              window.localStorage[storageKey] = levelName;
+              return;
+          } catch (ignore) {}
+
+          // Use session cookie as fallback
+          try {
+              window.document.cookie =
+                encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {}
+      }
+
+      function getPersistedLevel() {
+          var storedLevel;
+
+          if (typeof window === undefinedType || !storageKey) return;
+
+          try {
+              storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {}
+
+          // Fallback to cookies if local storage gives us nothing
+          if (typeof storedLevel === undefinedType) {
+              try {
+                  var cookie = window.document.cookie;
+                  var location = cookie.indexOf(
+                      encodeURIComponent(storageKey) + "=");
+                  if (location !== -1) {
+                      storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+                  }
+              } catch (ignore) {}
+          }
+
+          // If the stored level is not valid, treat it as if nothing was stored.
+          if (self.levels[storedLevel] === undefined) {
+              storedLevel = undefined;
+          }
+
+          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
+       *
+       */
+
+      self.name = name;
+
+      self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
+          "ERROR": 4, "SILENT": 5};
+
+      self.methodFactory = factory || defaultMethodFactory;
+
+      self.getLevel = function () {
+          return currentLevel;
+      };
+
+      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;
+          }
+      };
+
+      self.setDefaultLevel = function (level) {
+          defaultLevel = level;
+          if (!getPersistedLevel()) {
+              self.setLevel(level, false);
+          }
+      };
+
+      self.resetLevel = function () {
+          self.setLevel(defaultLevel, false);
+          clearPersistedLevel();
+      };
+
+      self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+      };
+
+      self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+      };
+
+      // Initialize with the right level
+      var initialLevel = getPersistedLevel();
+      if (initialLevel == null) {
+          initialLevel = defaultLevel;
+      }
+      self.setLevel(initialLevel, false);
+    }
+
+    /*
+     *
+     * Top-level API
+     *
+     */
+
+    var defaultLogger = new Logger();
+
+    var _loggersByName = {};
+    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);
+        }
+        return logger;
+    };
+
+    // Grab the current global log variable in case of overwrite
+    var _log = (typeof window !== undefinedType) ? window.log : undefined;
+    defaultLogger.noConflict = function() {
+        if (typeof window !== undefinedType &&
+               window.log === defaultLogger) {
+            window.log = _log;
+        }
+
+        return defaultLogger;
+    };
+
+    defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
+    };
+
+    // ES6 default export, for compatibility
+    defaultLogger['default'] = defaultLogger;
+
+    return defaultLogger;
+}));
+});
 
 class CatI18nRegistry {
   constructor() {
@@ -17,7 +331,7 @@ class CatI18nRegistry {
   locale(locale) {
     if (locale) {
       this._locale = locale;
-      loglevel.loglevel.info(`[CatI18nRegistry] Locale set to ${locale}`);
+      loglevel.info(`[CatI18nRegistry] Locale set to ${locale}`);
       window.dispatchEvent(this.buildEvent('cat-i18n-locale', { locale }));
     }
     return this._locale;
@@ -25,18 +339,18 @@ class CatI18nRegistry {
   register(locale, i18n) {
     const dict = this.getDict(locale);
     Object.entries(i18n).forEach(([key, message]) => dict.set(key, message));
-    loglevel.loglevel.info(`[CatI18nRegistry] Registered messages for ${locale}`, i18n);
+    loglevel.info(`[CatI18nRegistry] Registered messages for ${locale}`, i18n);
     window.dispatchEvent(this.buildEvent('cat-i18n-register', { i18n }));
   }
   clear(locale) {
     if (locale) {
       this.getDict(locale).clear();
-      loglevel.loglevel.info(`[CatI18nRegistry] Cleared messages for ${locale}`);
+      loglevel.info(`[CatI18nRegistry] Cleared messages for ${locale}`);
       window.dispatchEvent(this.buildEvent('cat-i18n-clear', { locale }));
     }
     else {
       this._dicts.clear();
-      loglevel.loglevel.info(`[CatI18nRegistry] Cleared messages`);
+      loglevel.info(`[CatI18nRegistry] Cleared messages`);
       window.dispatchEvent(this.buildEvent('cat-i18n-clear'));
     }
   }
@@ -44,7 +358,7 @@ class CatI18nRegistry {
     var _a;
     const message = (_a = this._dicts.get(this._locale)) === null || _a === void 0 ? void 0 : _a.get(key);
     if (message === undefined) {
-      loglevel.loglevel.error(`[CatI18nRegistry] Unknown message for ${this._locale}: ${key}`);
+      loglevel.error(`[CatI18nRegistry] Unknown message for ${this._locale}: ${key}`);
       return '';
     }
     return message.replace(/{{\s*([-a-zA-Z._]+)\s*}}/g, (_match, key) => { var _a; return `${(_a = params === null || params === void 0 ? void 0 : params[key]) !== null && _a !== void 0 ? _a : ''}`; });
@@ -80,31 +394,31 @@ class CatIconRegistry {
   getIcon(name, setName) {
     const icon = this.icons.get(this.buildName(name, setName));
     if (!icon) {
-      loglevel.loglevel.error(`[CatIconRegistry] Unknown icon${setName ? ` in set ${setName}` : ''}: ${name}`);
+      loglevel.error(`[CatIconRegistry] Unknown icon${setName ? ` in set ${setName}` : ''}: ${name}`);
     }
     return icon;
   }
   addIcon(name, data, setName) {
     this.icons.set(this.buildName(name, setName), data);
-    loglevel.loglevel.info(`[CatIconRegistry] Added icon${setName ? ` to set ${setName}` : ''}: ${name}`);
+    loglevel.info(`[CatIconRegistry] Added icon${setName ? ` to set ${setName}` : ''}: ${name}`);
     window.dispatchEvent(this.buildEvent('cat-icon-added', { name, setName }));
     return this;
   }
   addIcons(icons, setName) {
     Object.entries(icons).forEach(([name, data]) => this.icons.set(this.buildName(name, setName), data));
-    loglevel.loglevel.info(`[CatIconRegistry] Added icons${setName ? ` to set ${setName}` : ''}: ${Object.keys(icons).concat(', ')}`);
+    loglevel.info(`[CatIconRegistry] Added icons${setName ? ` to set ${setName}` : ''}: ${Object.keys(icons).concat(', ')}`);
     window.dispatchEvent(this.buildEvent('cat-icons-added', { names: Object.keys(icons), setName }));
     return this;
   }
   removeIcon(name, setName) {
     this.icons.delete(this.buildName(name, setName));
-    loglevel.loglevel.info(`[CatIconRegistry] Removed icon${setName ? ` from set ${setName}` : ''}: ${name}`);
+    loglevel.info(`[CatIconRegistry] Removed icon${setName ? ` from set ${setName}` : ''}: ${name}`);
     window.dispatchEvent(this.buildEvent('cat-icon-removed', { name, setName }));
     return this;
   }
   removeIcons(names, setName) {
     names.forEach(name => this.icons.delete(this.buildName(name, setName)));
-    loglevel.loglevel.info(`[CatIconRegistry] Removed icons${setName ? ` from set ${setName}` : ''}: ${names.concat(', ')}`);
+    loglevel.info(`[CatIconRegistry] Removed icons${setName ? ` from set ${setName}` : ''}: ${names.concat(', ')}`);
     window.dispatchEvent(this.buildEvent('cat-icons-removed', { names, setName }));
     return this;
   }
@@ -120,7 +434,7 @@ class CatIconRegistry {
   }
 }
 
-var toastify = loglevel.createCommonjsModule(function (module) {
+var toastify = createCommonjsModule(function (module) {
 /*!
  * Toastify js 1.11.2
  * https://github.com/apvarun/toastify-js
@@ -134,7 +448,7 @@ var toastify = loglevel.createCommonjsModule(function (module) {
   } else {
     root.Toastify = factory();
   }
-})(loglevel.commonjsGlobal, function(global) {
+})(commonjsGlobal, function(global) {
   // Object initialization
   var Toastify = function(options) {
       // Returning a new init object
@@ -563,8 +877,10 @@ var toastify = loglevel.createCommonjsModule(function (module) {
 var TypeIcons;
 (function (TypeIcons) {
   TypeIcons["success"] = "check-circle-filled";
-  TypeIcons["error"] = "sparkle-filled";
-  TypeIcons["info"] = "sparkle-filled";
+  TypeIcons["error"] = "cross-circle-filled";
+  TypeIcons["info"] = "danger-filled";
+  TypeIcons["primary"] = "star-circle-filled";
+  TypeIcons["secondary"] = "info-circle-filled";
 })(TypeIcons || (TypeIcons = {}));
 const ToastPositions = {
   'top-left': {
@@ -593,16 +909,36 @@ const ToastPositions = {
   }
 };
 class CatNotificationService {
+  error(title, message = ' ', options) {
+    const toastOptions = this.extractOptions(title, message, options);
+    toastify(toastOptions).showToast();
+  }
+  success(title, message = ' ', options) {
+    const toastOptions = this.extractOptions(title, message, options);
+    toastify(toastOptions).showToast();
+  }
+  info(title, message = ' ', options) {
+    const toastOptions = this.extractOptions(title, message, options);
+    toastify(toastOptions).showToast();
+  }
+  primary(title, message = ' ', options) {
+    const toastOptions = this.extractOptions(title, message, options);
+    toastify(toastOptions).showToast();
+  }
+  secondary(title, message = ' ', options) {
+    const toastOptions = this.extractOptions(title, message, options);
+    toastify(toastOptions).showToast();
+  }
   toastHTMLTemplate(title, message = ' ', options) {
     var _a;
     const template = document.createElement('template');
-    const typeIcon = (options === null || options === void 0 ? void 0 : options.type) ? TypeIcons[options.type] : TypeIcons.info;
+    const typeIcon = (options === null || options === void 0 ? void 0 : options.type) ? TypeIcons[options.type] : TypeIcons.secondary;
     title = title.trim();
     message = message.trim();
     const hasMessage = message && message !== '';
     const hasMessageClass = hasMessage ? 'has-message' : '';
     template.innerHTML = `<div class="cat-toastify-wrapper">
-        <div class="cat-toastify-icon-wrapper ${(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'info'}">
+        <div class="cat-toastify-icon-wrapper ${(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'secondary'}">
              <cat-icon icon="${typeIcon}"></cat-icon>
         </div>
         <div class="cat-toastify-title-wrapper ${hasMessageClass}">
@@ -611,62 +947,42 @@ class CatNotificationService {
       </div>`;
     return template.content.firstChild;
   }
-  error(title, message = ' ', options) {
-    const position = this.getPosition(options);
-    const toastOptions = {
-      node: (options === null || options === void 0 ? void 0 : options.content) ? options.content : this.toastHTMLTemplate(title, message, options),
-      duration: CatNotificationService.DURATION,
-      close: true,
-      className: 'cat-toastify',
-      gravity: position.gravity,
-      position: position.position,
-      stopOnFocus: true
-    };
-    toastify(toastOptions).showToast();
-  }
-  success(title, message = ' ', options) {
-    const position = this.getPosition(options);
-    const toastOptions = {
-      node: (options === null || options === void 0 ? void 0 : options.content) ? options.content : this.toastHTMLTemplate(title, message, options),
-      duration: CatNotificationService.DURATION,
-      close: true,
-      className: 'cat-toastify',
-      gravity: position.gravity,
-      position: position.position,
-      stopOnFocus: true
+  getPosition(options) {
+    const position = {
+      gravity: 'bottom',
+      position: 'left'
     };
-    toastify(toastOptions).showToast();
+    if ((options === null || options === void 0 ? void 0 : options.position) && ToastPositions[options.position]) {
+      position.position = ToastPositions[options.position].position;
+      position.gravity = ToastPositions[options.position].gravity;
+    }
+    return position;
   }
-  info(title, message = ' ', options) {
+  extractOptions(title, message = ' ', options) {
     const position = this.getPosition(options);
-    const toastOptions = {
+    return {
       node: (options === null || options === void 0 ? void 0 : options.content) ? options.content : this.toastHTMLTemplate(title, message, options),
       duration: CatNotificationService.DURATION,
       close: true,
       className: 'cat-toastify',
       gravity: position.gravity,
       position: position.position,
-      stopOnFocus: true
-    };
-    toastify(toastOptions).showToast();
-  }
-  getPosition(options) {
-    const position = {
-      gravity: 'bottom',
-      position: 'right'
+      stopOnFocus: true,
+      offset: {
+        x: '1.5rem',
+        y: '1.5rem'
+      }
     };
-    if ((options === null || options === void 0 ? void 0 : options.position) && ToastPositions[options.position]) {
-      position.position = ToastPositions[options.position].position;
-      position.gravity = ToastPositions[options.position].gravity;
-    }
-    return position;
   }
 }
-CatNotificationService.DURATION = 8000;
+CatNotificationService.DURATION = 80000;
 const NotificationsService = new CatNotificationService();
 
 exports.CatI18nRegistry = CatI18nRegistry;
 exports.CatIconRegistry = CatIconRegistry;
 exports.NotificationsService = NotificationsService;
+exports.createCommonjsModule = createCommonjsModule;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
+exports.loglevel = loglevel;
 
-//# sourceMappingURL=cat-notification-c2859ed7.js.map
+//# sourceMappingURL=cat-notification-6a438ad1.js.map