WebSVN – Moodle – Diff – /lib/amd/src/loglevel.js

 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // Description of import into Moodle:
-// Download from https://github.com/pimterry/loglevel/tree/master/dist
+// Download from https://github.com/pimterry/loglevel/tree/main/dist
-// Copy loglevel.js into lib/amd/src/ in Moodle folder.
+// Copy loglevel.js into lib/amd/src/ in Moodle folder, and use grunt to build the code
 // Add the license as a comment to the file and these instructions.
-/*! loglevel - v1.8.1 - https://github.com/pimterry/loglevel - (c) 2022 Tim Perry - licensed MIT */
+/*! loglevel - v1.9.2 - https://github.com/pimterry/loglevel - (c) 2024 Tim Perry - licensed MIT */
 (function (root, definition) {
     "use strict";
     if (typeof define === 'function' && define.amd) {
         "info",
         "warn",
         "error"
     ];
+    var _loggersByName = {};
+    var defaultLogger = null;
     // Cross-browser bind equivalent that works at least back to IE6
     function bindMethod(obj, methodName) {
         var method = obj[methodName];
         if (typeof method.bind === 'function') {
+        }
+    }
     // These private functions always need `this` to be set properly
+    function replaceLoggingMethods() {
+        /*jshint validthis:true */
+        var level = this.getLevel();
     function replaceLoggingMethods(level, loggerName) {
-        /*jshint validthis:true */
+        // 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.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) {
-        // Define log.log as an alias for log.debug
+            return "No console available for logging";
         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) {
+    function enableLoggingWhenConsoleArrives(methodName) {
         return function () {
             if (typeof console !== undefinedType) {
-                replaceLoggingMethods.call(this, level, loggerName);
+                replaceLoggingMethods.call(this);
                 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) {
+    function defaultMethodFactory(methodName, _level, _loggerName) {
+        /*jshint validthis:true */
-        /*jshint validthis:true */
+        return realMethod(methodName) ||
+               enableLoggingWhenConsoleArrives.apply(this, arguments);
+    }
+    function Logger(name, factory) {
+      // Private instance variables.
+      var self = this;
+      /**
+       * 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}
+       */
-        return realMethod(methodName) ||
+      var inheritedLevel;
+      /**
-               enableLoggingWhenConsoleArrives.apply(this, arguments);
+       * 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
-    function Logger(name, defaultLevel, factory) {
+       * `defaultLevel`.
-      var self = this;
+       * @type {number|null}
           // Fallback to cookies if local storage gives us nothing
           if (typeof storedLevel === undefinedType) {
               try {
                   var cookie = window.document.cookie;
-                  var location = cookie.indexOf(
+                  var cookieName = encodeURIComponent(storageKey);
-                      encodeURIComponent(storageKey) + "=");
+                  var location = cookie.indexOf(cookieName + "=");
                   if (location !== -1) {
+                      storedLevel = /^([^;]+)/.exec(
+                          cookie.slice(location + cookieName.length + 1)
-                      storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+                      )[1];
+                  }
               } catch (ignore) {}
+          }
           if (typeof window === undefinedType || !storageKey) return;
           // Use localStorage if available
           try {
-              window.localStorage.removeItem(storageKey);
-              return;
+              window.localStorage.removeItem(storageKey);
           } catch (ignore) {}
           // Use session cookie as fallback
           try {
               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);
           } catch (ignore) {}
+      }
       /*
+       *
           "ERROR": 4, "SILENT": 5};
       self.methodFactory = factory || defaultMethodFactory;
+      self.getLevel = function () {
+          if (userLevel != null) {
+            return userLevel;
+          } else if (defaultLevel != null) {
+            return defaultLevel;
+          } else {
-      self.getLevel = function () {
+            return inheritedLevel;
           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) {
+      self.setLevel = function (level, persist) {
-              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";
           userLevel = normalizeLevel(level);
+          if (persist !== false) {  // defaults to true
+              persistLevelIfPossible(userLevel);
+          }
           } else {
-              throw "log.setLevel() called with invalid level: " + level;
+          // 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.resetLevel = function () {
+          userLevel = null;
-          self.setLevel(defaultLevel, false);
+          clearPersistedLevel();
-          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);
-      self.enableAll = function(persist) {
+          if (defaultLogger === self) {
+              for (var childName in _loggersByName) {
+                _loggersByName[childName].rebuild();
           self.setLevel(self.levels.TRACE, persist);
-      };
+          }
+      };
       self.disableAll = function(persist) {
-          self.setLevel(self.levels.SILENT, persist);
+      // Initialize all the internal levels.
-      };
+      inheritedLevel = normalizeLevel(
           defaultLogger ? defaultLogger.getLevel() : "WARN"
-      // Initialize with the right level
+      );
       var initialLevel = getPersistedLevel();
-      if (initialLevel == null) {
+      if (initialLevel != null) {
-          initialLevel = defaultLevel;
+          userLevel = normalizeLevel(initialLevel);
       }
-      self.setLevel(initialLevel, false);
       replaceLoggingMethods.call(self);
+    }
-    /*
     /*
      * Top-level API
      * Top-level API
-     */
+     *
+     */
+    defaultLogger = new Logger();
     var defaultLogger = new Logger();
     defaultLogger.getLogger = function getLogger(name) {
-    var _loggersByName = {};
+        if ((typeof name !== "symbol" && typeof name !== "string") || name === "") {
-    defaultLogger.getLogger = function getLogger(name) {
+            throw new TypeError("You must supply a name when creating a logger.");

Proyectos de Subversion Moodle

(root)/lib/amd/src/loglevel.js – Rev 1 → 1441