LCOV - code coverage report
Current view: top level - modules/esm - console.js (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 84.1 % 239 201
Test Date: 2024-04-29 05:18:28 Functions: 63.2 % 38 24
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 67.7 % 192 130

             Branch data     Line data    Source code
       1                 :         235 : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       2                 :             : // SPDX-FileCopyrightText: 2021 Evan Welsh <contact@evanwelsh.com>
       3                 :             : 
       4                 :          47 : const DEFAULT_LOG_DOMAIN = 'Gjs-Console';
       5                 :             : 
       6                 :             : // A line-by-line implementation of https://console.spec.whatwg.org/.
       7                 :             : 
       8                 :             : // 2.2.1. Formatting specifiers
       9                 :             : // https://console.spec.whatwg.org/#formatting-specifiers
      10                 :             : //
      11                 :             : // %s - string
      12                 :             : // %d or %i - integer
      13                 :             : // %f - float
      14                 :             : // %o - "optimal" object formatting
      15                 :             : // %O - "generic" object formatting
      16                 :             : // %c - "CSS" formatting (unimplemented by GJS)
      17                 :             : 
      18                 :             : /**
      19                 :             :  * A simple regex to capture formatting specifiers
      20                 :             :  */
      21                 :          47 : const specifierTest = /%(d|i|s|f|o|O|c)/;
      22                 :             : 
      23                 :             : /**
      24                 :             :  * @param {string} str a string to check for format specifiers like %s or %i
      25                 :             :  * @returns {boolean}
      26                 :             :  */
      27                 :         100 : function hasFormatSpecifiers(str) {
      28                 :         100 :     return specifierTest.test(str);
      29                 :             : }
      30                 :             : 
      31                 :             : /**
      32                 :             :  * @param {any} item an item to format
      33                 :             :  */
      34                 :           5 : function formatGenerically(item) {
      35                 :           5 :     return JSON.stringify(item, null, 4);
      36                 :             : }
      37                 :             : 
      38                 :             : /**
      39                 :             :  * @param {any} item an item to format
      40                 :             :  * @returns {string}
      41                 :             :  */
      42                 :          11 : function formatOptimally(item) {
      43                 :          11 :     const GLib = imports.gi.GLib;
      44                 :             :     // Handle optimal error formatting.
      45 [ +  + ][ +  + ]:          11 :     if (item instanceof Error || item instanceof GLib.Error) {
      46 [ -  + ][ -  + ]:           5 :         return `${item.toString()}${item.stack ? '\n' : ''}${item.stack
      47                 :           5 :             ?.split('\n')
      48                 :             :             // Pad each stacktrace line.
      49                 :          55 :             .map(line => line.padStart(2, ' '))
      50                 :           5 :             .join('\n')}`;
      51                 :             :     }
      52                 :             : 
      53                 :             :     // TODO: Enhance 'optimal' formatting.
      54                 :             :     // There is a current work on a better object formatter for GJS in
      55                 :             :     // https://gitlab.gnome.org/GNOME/gjs/-/merge_requests/587
      56 [ -  + ][ -  + ]:           6 :     if (typeof item === 'object' && item !== null) {
      57 [ +  + ][ +  + ]:           6 :         if (item.constructor?.name !== 'Object')
      58         [ +  + ]:           3 :             return `${item.constructor?.name} ${JSON.stringify(item, null, 4)}`;
      59         [ +  + ]:           3 :         else if (item[Symbol.toStringTag] === 'GIRepositoryNamespace')
      60                 :           1 :             return `[${item[Symbol.toStringTag]} ${item.__name__}]`;
      61                 :             :     }
      62                 :           2 :     return JSON.stringify(item, null, 4);
      63                 :          11 : }
      64                 :             : 
      65                 :             : /**
      66                 :             :  * Implementation of the WHATWG Console object.
      67                 :             :  */
      68                 :          94 : class Console {
      69                 :          47 :     #groupIndentation = '';
      70                 :          47 :     #countLabels = {};
      71                 :          47 :     #timeLabels = {};
      72                 :          47 :     #logDomain = DEFAULT_LOG_DOMAIN;
      73                 :             : 
      74                 :          47 :     get [Symbol.toStringTag]() {
      75                 :           0 :         return 'Console';
      76                 :             :     }
      77                 :             : 
      78                 :             :     // 1.1 Logging functions
      79                 :             :     // https://console.spec.whatwg.org/#logging
      80                 :             : 
      81                 :             :     /**
      82                 :             :      * Logs a critical message if the condition is not truthy.
      83                 :             :      * {@see console.error()} for additional information.
      84                 :             :      *
      85                 :             :      * @param {boolean} condition a boolean condition which, if false, causes
      86                 :             :      *   the log to print
      87                 :             :      * @param  {...any} data formatting substitutions, if applicable
      88                 :             :      * @returns {void}
      89                 :             :      */
      90                 :          50 :     assert(condition, ...data) {
      91         [ +  + ]:           3 :         if (condition)
      92                 :           1 :             return;
      93                 :             : 
      94                 :           2 :         const message = 'Assertion failed';
      95                 :             : 
      96         [ +  + ]:           2 :         if (data.length === 0)
      97                 :           1 :             data.push(message);
      98                 :             : 
      99         [ +  - ]:           2 :         if (typeof data[0] !== 'string') {
     100                 :           0 :             data.unshift(message);
     101                 :           2 :         } else {
     102                 :           2 :             const first = data.shift();
     103                 :           2 :             data.unshift(`${message}: ${first}`);
     104                 :             :         }
     105                 :           2 :         this.#logger('assert', data);
     106                 :           1 :     }
     107                 :             : 
     108                 :             :     /**
     109                 :             :      * Resets grouping and clears the terminal on systems supporting ANSI
     110                 :             :      * terminal control sequences.
     111                 :             :      *
     112                 :             :      * In file-based stdout or systems which do not support clearing,
     113                 :             :      * console.clear() has no visual effect.
     114                 :             :      *
     115                 :             :      * @returns {void}
     116                 :             :      */
     117                 :          47 :     clear() {
     118                 :           2 :         this.#groupIndentation = '';
     119                 :           2 :         imports.gi.GjsPrivate.clear_terminal();
     120                 :             :     }
     121                 :             : 
     122                 :             :     /**
     123                 :             :      * Logs a message with severity equal to {@see GLib.LogLevelFlags.DEBUG}.
     124                 :             :      *
     125                 :             :      * @param  {...any} data formatting substitutions, if applicable
     126                 :             :      */
     127                 :          47 :     debug(...data) {
     128                 :           0 :         this.#logger('debug', data);
     129                 :             :     }
     130                 :             : 
     131                 :             :     /**
     132                 :             :      * Logs a message with severity equal to {@see GLib.LogLevelFlags.CRITICAL}.
     133                 :             :      * Does not use {@see GLib.LogLevelFlags.ERROR} to avoid asserting and
     134                 :             :      * forcibly shutting down the application.
     135                 :             :      *
     136                 :             :      * @param  {...any} data formatting substitutions, if applicable
     137                 :             :      */
     138                 :          57 :     error(...data) {
     139                 :          10 :         this.#logger('error', data);
     140                 :             :     }
     141                 :             : 
     142                 :             :     /**
     143                 :             :      * Logs a message with severity equal to {@see GLib.LogLevelFlags.INFO}.
     144                 :             :      *
     145                 :             :      * @param  {...any} data formatting substitutions, if applicable
     146                 :             :      */
     147                 :          58 :     info(...data) {
     148                 :          11 :         this.#logger('info', data);
     149                 :             :     }
     150                 :             : 
     151                 :             :     /**
     152                 :             :      * Logs a message with severity equal to {@see GLib.LogLevelFlags.MESSAGE}.
     153                 :             :      *
     154                 :             :      * @param  {...any} data formatting substitutions, if applicable
     155                 :             :      */
     156                 :          66 :     log(...data) {
     157                 :          19 :         this.#logger('log', data);
     158                 :             :     }
     159                 :             : 
     160                 :             :     // 1.1.7 table(tabularData, properties)
     161                 :          47 :     table(tabularData, _properties) {
     162                 :           1 :         this.log(tabularData);
     163                 :             :     }
     164                 :             : 
     165                 :             :     /**
     166                 :             :      * @param  {...any} data formatting substitutions, if applicable
     167                 :             :      * @returns {void}
     168                 :             :      */
     169                 :          59 :     trace(...data) {
     170         [ +  + ]:          12 :         if (data.length === 0)
     171                 :           1 :             data = ['Trace'];
     172                 :             : 
     173                 :          12 :         this.#logger('trace', data);
     174                 :             :     }
     175                 :             : 
     176                 :             :     /**
     177                 :             :      * Logs a message with severity equal to {@see GLib.LogLevelFlags.WARNING}.
     178                 :             :      *
     179                 :             :      * @param  {...any} data formatting substitutions, if applicable
     180                 :             :      * @returns {void}
     181                 :             :      */
     182                 :          58 :     warn(...data) {
     183                 :          11 :         this.#logger('warn', data);
     184                 :             :     }
     185                 :             : 
     186                 :             :     /**
     187                 :             :      * @param {object} item an item to format generically
     188                 :             :      * @param {never} [options] any additional options for the formatter. Unused
     189                 :             :      *   in our implementation.
     190                 :             :      */
     191                 :          47 :     dir(item, options) {
     192                 :           0 :         const object = formatGenerically(item);
     193                 :           0 :         this.#printer('dir', [object], options);
     194                 :             :     }
     195                 :             : 
     196                 :             :     /**
     197                 :             :      * @param  {...any} data formatting substitutions, if applicable
     198                 :             :      * @returns {void}
     199                 :             :      */
     200                 :          47 :     dirxml(...data) {
     201 [ #  # ][ #  # ]:           0 :         this.log(...data);
     202                 :             :     }
     203                 :             : 
     204                 :             :     // 1.2 Counting functions
     205                 :             :     // https://console.spec.whatwg.org/#counting
     206                 :             : 
     207                 :             :     /**
     208                 :             :      * Logs how many times console.count(label) has been called with a given
     209                 :             :      * label.
     210                 :             :      * {@see console.countReset()} for resetting a count.
     211                 :             :      *
     212                 :             :      * @param  {string} label unique identifier for this action
     213                 :             :      * @returns {void}
     214                 :             :      */
     215                 :          47 :     count(label) {
     216         [ #  # ]:           0 :         this.#countLabels[label] ??= 0;
     217                 :           0 :         const count = ++this.#countLabels[label];
     218                 :           0 :         const concat = `${label}: ${count}`;
     219                 :             : 
     220                 :           0 :         this.#logger('count', [concat]);
     221                 :             :     }
     222                 :             : 
     223                 :             :     /**
     224                 :             :      * @param  {string} label the unique label to reset the count for
     225                 :             :      * @returns {void}
     226                 :             :      */
     227                 :          47 :     countReset(label) {
     228                 :           0 :         const count = this.#countLabels[label];
     229         [ #  # ]:           0 :         if (typeof count !== 'number')
     230                 :           0 :             this.#printer('reportWarning', [`No count found for label: '${label}'.`]);
     231                 :             :         else
     232                 :           0 :             this.#countLabels[label] = 0;
     233                 :             :     }
     234                 :             : 
     235                 :             :     // 1.3 Grouping functions
     236                 :             :     // https://console.spec.whatwg.org/#grouping
     237                 :             : 
     238                 :             :     /**
     239                 :             :      * @param  {...any} data formatting substitutions, if applicable
     240                 :             :      * @returns {void}
     241                 :             :      */
     242                 :          48 :     group(...data) {
     243                 :           1 :         this.#logger('group', data);
     244                 :           1 :         this.#groupIndentation += '  ';
     245                 :             :     }
     246                 :             : 
     247                 :             :     /**
     248                 :             :      * Alias for console.group()
     249                 :             :      *
     250                 :             :      * @param  {...any} data formatting substitutions, if applicable
     251                 :             :      * @returns {void}
     252                 :             :      */
     253                 :          47 :     groupCollapsed(...data) {
     254                 :             :         // We can't 'collapse' output in a terminal, so we alias to
     255                 :             :         // group()
     256 [ #  # ][ #  # ]:           0 :         this.group(...data);
     257                 :             :     }
     258                 :             : 
     259                 :             :     /**
     260                 :             :      * @returns {void}
     261                 :             :      */
     262                 :          47 :     groupEnd() {
     263                 :           0 :         this.#groupIndentation = this.#groupIndentation.slice(0, -2);
     264                 :             :     }
     265                 :             : 
     266                 :             :     // 1.4 Timing functions
     267                 :             :     // https://console.spec.whatwg.org/#timing
     268                 :             : 
     269                 :             :     /**
     270                 :             :      * @param {string} label unique identifier for this action, pass to
     271                 :             :      *   console.timeEnd() to complete
     272                 :             :      * @returns {void}
     273                 :             :      */
     274                 :          47 :     time(label) {
     275                 :           2 :         this.#timeLabels[label] = imports.gi.GLib.get_monotonic_time();
     276                 :             :     }
     277                 :             : 
     278                 :             :     /**
     279                 :             :      * Logs the time since the last call to console.time(label) where label is
     280                 :             :      * the same.
     281                 :             :      *
     282                 :             :      * @param {string} label unique identifier for this action, pass to
     283                 :             :      *   console.timeEnd() to complete
     284                 :             :      * @param {...any} data string substitutions, if applicable
     285                 :             :      * @returns {void}
     286                 :             :      */
     287                 :          49 :     timeLog(label, ...data) {
     288                 :           2 :         const startTime = this.#timeLabels[label];
     289                 :             : 
     290         [ +  + ]:           2 :         if (typeof startTime !== 'number') {
     291                 :           2 :             this.#printer('reportWarning', [
     292                 :           1 :                 `No time log found for label: '${label}'.`,
     293                 :             :             ]);
     294                 :           1 :         } else {
     295                 :           1 :             const durationMs = (imports.gi.GLib.get_monotonic_time() - startTime) / 1000;
     296                 :           1 :             const concat = `${label}: ${durationMs.toFixed(3)} ms`;
     297                 :           1 :             data.unshift(concat);
     298                 :             : 
     299                 :           1 :             this.#printer('timeLog', data);
     300                 :             :         }
     301                 :             :     }
     302                 :             : 
     303                 :             :     /**
     304                 :             :      * Logs the time since the last call to console.time(label) and completes
     305                 :             :      * the action.
     306                 :             :      * Call console.time(label) again to re-measure.
     307                 :             :      *
     308                 :             :      * @param {string} label unique identifier for this action
     309                 :             :      * @returns {void}
     310                 :             :      */
     311                 :          49 :     timeEnd(label) {
     312                 :           2 :         const startTime = this.#timeLabels[label];
     313                 :             : 
     314         [ +  - ]:           2 :         if (typeof startTime !== 'number') {
     315                 :           0 :             this.#printer('reportWarning', [
     316                 :           0 :                 `No time log found for label: '${label}'.`,
     317                 :             :             ]);
     318                 :           2 :         } else {
     319                 :           2 :             delete this.#timeLabels[label];
     320                 :             : 
     321                 :           2 :             const durationMs = (imports.gi.GLib.get_monotonic_time() - startTime) / 1000;
     322                 :           2 :             const concat = `${label}: ${durationMs.toFixed(3)} ms`;
     323                 :             : 
     324                 :           2 :             this.#printer('timeEnd', [concat]);
     325                 :             :         }
     326                 :             :     }
     327                 :             : 
     328                 :             :     // Non-standard functions which are de-facto standards.
     329                 :             :     // Similar to Node, we define these as no-ops for now.
     330                 :             : 
     331                 :             :     /**
     332                 :             :      * @deprecated Not implemented in GJS
     333                 :             :      *
     334                 :             :      * @param {string} _label unique identifier for this action, pass to
     335                 :             :      *   console.profileEnd to complete
     336                 :             :      * @returns {void}
     337                 :             :      */
     338                 :          47 :     profile(_label) {}
     339                 :             : 
     340                 :             :     /**
     341                 :             :      * @deprecated Not implemented in GJS
     342                 :             :      *
     343                 :             :      * @param {string} _label unique identifier for this action
     344                 :             :      * @returns {void}
     345                 :             :      */
     346                 :          47 :     profileEnd(_label) {}
     347                 :             : 
     348                 :             :     /**
     349                 :             :      * @deprecated Not implemented in GJS
     350                 :             :      *
     351                 :             :      * @param {string} _label unique identifier for this action
     352                 :             :      * @returns {void}
     353                 :             :      */
     354                 :          47 :     timeStamp(_label) {}
     355                 :             : 
     356                 :             :     // GJS-specific extensions for integrating with GLib structured logging
     357                 :             : 
     358                 :             :     /**
     359                 :             :      * @param {string} logDomain the GLib log domain this Console should print
     360                 :             :      *   with. Defaults to 'Gjs-Console'.
     361                 :             :      * @returns {void}
     362                 :             :      */
     363                 :          47 :     setLogDomain(logDomain) {
     364                 :           0 :         this.#logDomain = String(logDomain);
     365                 :             :     }
     366                 :             : 
     367                 :             :     /**
     368                 :             :      * @returns {string}
     369                 :             :      */
     370                 :          47 :     get logDomain() {
     371                 :           0 :         return this.#logDomain;
     372                 :             :     }
     373                 :             : 
     374                 :             :     // 2. Supporting abstract operations
     375                 :             :     // https://console.spec.whatwg.org/#supporting-ops
     376                 :             : 
     377                 :             :     /**
     378                 :             :      * 2.1. Logger
     379                 :             :      * https://console.spec.whatwg.org/#logger
     380                 :             :      *
     381                 :             :      * Conditionally applies formatting based on the inputted arguments,
     382                 :             :      * and prints at the provided severity (logLevel)
     383                 :             :      *
     384                 :             :      * @param {string} logLevel the severity (log level) the args should be
     385                 :             :      *   emitted with
     386                 :             :      * @param {unknown[]} args the arguments to pass to the printer
     387                 :             :      * @returns {void}
     388                 :             :      */
     389                 :          66 :     #logger(logLevel, args) {
     390         [ +  - ]:          66 :         if (args.length === 0)
     391                 :           0 :             return;
     392                 :             : 
     393 [ +  - ][ +  - ]:          66 :         const [first, ...rest] = args;
         [ +  + ][ -  + ]
     394                 :             : 
     395         [ +  + ]:          66 :         if (rest.length === 0) {
     396                 :          21 :             this.#printer(logLevel, [first]);
     397                 :          21 :             return undefined;
     398                 :             :         }
     399                 :             : 
     400                 :             :         // If first does not contain any format specifiers, don't call Formatter
     401 [ -  + ][ +  - ]:          45 :         if (typeof first !== 'string' || !hasFormatSpecifiers(first)) {
     402                 :           0 :             this.#printer(logLevel, args);
     403                 :           0 :             return undefined;
     404                 :             :         }
     405                 :             : 
     406                 :             :         // Otherwise, perform print the result of Formatter.
     407         [ +  + ]:          45 :         this.#printer(logLevel, this.#formatter([first, ...rest]));
     408                 :             : 
     409                 :          45 :         return undefined;
     410                 :          66 :     }
     411                 :             : 
     412                 :             :     /**
     413                 :             :      * 2.2. Formatter
     414                 :             :      * https://console.spec.whatwg.org/#formatter
     415                 :             :      *
     416                 :             :      * @param {[string, ...any[]]} args an array of format strings followed by
     417                 :             :      *   their arguments
     418                 :             :      */
     419                 :          55 :     #formatter(args) {
     420                 :             :         // The initial formatting string is the first arg
     421                 :          55 :         let target = args[0];
     422                 :             : 
     423         [ +  - ]:          55 :         if (args.length === 1)
     424                 :           0 :             return target;
     425                 :             : 
     426                 :          55 :         const current = args[1];
     427                 :             : 
     428                 :             :         // Find the index of the first format specifier.
     429                 :          55 :         const specifierIndex = specifierTest.exec(target).index;
     430                 :          55 :         const specifier = target.slice(specifierIndex, specifierIndex + 2);
     431                 :          55 :         let converted = null;
     432 [ +  + ][ +  + ]:          55 :         switch (specifier) {
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
                 [ +  - ]
     433                 :             :         case '%s':
     434                 :          10 :             converted = String(current);
     435                 :             :             break;
     436                 :             :         case '%d':
     437                 :             :         case '%i':
     438         [ +  - ]:          20 :             if (typeof current === 'symbol')
     439                 :           0 :                 converted = Number.NaN;
     440                 :             :             else
     441                 :          20 :                 converted = parseInt(current, 10);
     442                 :             :             break;
     443                 :             :         case '%f':
     444         [ +  - ]:          10 :             if (typeof current === 'symbol')
     445                 :           0 :                 converted = Number.NaN;
     446                 :             :             else
     447                 :          10 :                 converted = parseFloat(current);
     448                 :             :             break;
     449                 :             :         case '%o':
     450                 :           5 :             converted = formatOptimally(current);
     451                 :             :             break;
     452                 :             :         case '%O':
     453                 :           5 :             converted = formatGenerically(current);
     454                 :             :             break;
     455                 :             :         case '%c':
     456                 :           5 :             converted = '';
     457                 :             :             break;
     458                 :             :         }
     459                 :             :         // If any of the previous steps set converted, replace the specifier in
     460                 :             :         // target with the converted value.
     461         [ -  + ]:          55 :         if (converted !== null) {
     462                 :             :             target =
     463                 :          55 :                 target.slice(0, specifierIndex) +
     464                 :          55 :                 converted +
     465                 :          55 :                 target.slice(specifierIndex + 2);
     466                 :             :         }
     467                 :             : 
     468                 :             :         /**
     469                 :             :          * Create the next format input...
     470                 :             :          *
     471                 :             :          * @type {[string, ...any[]]}
     472                 :             :          */
     473         [ +  + ]:          55 :         const result = [target, ...args.slice(2)];
     474                 :             : 
     475         [ +  + ]:          55 :         if (!hasFormatSpecifiers(target))
     476                 :          45 :             return result;
     477                 :             : 
     478         [ +  - ]:          10 :         if (result.length === 1)
     479                 :           0 :             return result;
     480                 :             : 
     481                 :          10 :         return this.#formatter(result);
     482                 :          55 :     }
     483                 :             : 
     484                 :             :     /**
     485                 :             :      * @typedef {object} PrinterOptions
     486                 :             :      * @param {Array.<string[]>} [stackTrace] an error stacktrace to append
     487                 :             :      * @param {Record<string, any>} [fields] fields to include in the structured
     488                 :             :      *   logging call
     489                 :             :      */
     490                 :             : 
     491                 :             :     /**
     492                 :             :      * 2.3. Printer
     493                 :             :      * https://console.spec.whatwg.org/#printer
     494                 :             :      *
     495                 :             :      * This implementation of Printer maps WHATWG log severity to
     496                 :             :      * {@see GLib.LogLevelFlags} and outputs using GLib structured logging.
     497                 :             :      *
     498                 :             :      * @param {string} logLevel the log level (log tag) the args should be
     499                 :             :      *   emitted with
     500                 :             :      * @param {unknown[]} args the arguments to print, either a format string
     501                 :             :      *   with replacement args or multiple strings
     502                 :             :      * @param {PrinterOptions} [options] additional options for the
     503                 :             :      *   printer
     504                 :             :      * @returns {void}
     505                 :             :      */
     506                 :          70 :     #printer(logLevel, args, options) {
     507                 :          70 :         const GLib = imports.gi.GLib;
     508                 :          70 :         let severity;
     509                 :             : 
     510 [ +  + ][ -  + ]:          70 :         switch (logLevel) {
         [ -  + ][ +  + ]
         [ +  + ][ -  + ]
         [ +  + ][ +  + ]
         [ -  + ][ -  + ]
         [ +  + ][ +  + ]
         [ -  + ][ +  + ]
         [ +  + ][ +  - ]
     511                 :             :         case 'log':
     512                 :             :         case 'dir':
     513                 :             :         case 'dirxml':
     514                 :             :         case 'trace':
     515                 :             :         case 'group':
     516                 :             :         case 'groupCollapsed':
     517                 :             :         case 'timeLog':
     518                 :             :         case 'timeEnd':
     519                 :          35 :             severity = GLib.LogLevelFlags.LEVEL_MESSAGE;
     520                 :             :             break;
     521                 :             :         case 'debug':
     522                 :           0 :             severity = GLib.LogLevelFlags.LEVEL_DEBUG;
     523                 :             :             break;
     524                 :             :         case 'count':
     525                 :             :         case 'info':
     526                 :          11 :             severity = GLib.LogLevelFlags.LEVEL_INFO;
     527                 :             :             break;
     528                 :             :         case 'warn':
     529                 :             :         case 'countReset':
     530                 :             :         case 'reportWarning':
     531                 :          12 :             severity = GLib.LogLevelFlags.LEVEL_WARNING;
     532                 :             :             break;
     533                 :             :         case 'error':
     534                 :             :         case 'assert':
     535                 :          12 :             severity = GLib.LogLevelFlags.LEVEL_CRITICAL;
     536                 :             :             break;
     537                 :             :         default:
     538                 :           0 :             severity = GLib.LogLevelFlags.LEVEL_MESSAGE;
     539                 :             :         }
     540                 :             : 
     541                 :          70 :         const output = args
     542                 :          70 :             .map(a => {
     543         [ +  - ]:          70 :                 if (a === null)
     544                 :           0 :                     return 'null';
     545         [ +  + ]:          70 :                 else if (typeof a === 'object')
     546                 :           6 :                     return formatOptimally(a);
     547         [ +  - ]:          64 :                 else if (typeof a === 'function')
     548                 :           0 :                     return a.toString();
     549         [ +  - ]:          64 :                 else if (typeof a === 'undefined')
     550                 :           0 :                     return 'undefined';
     551         [ +  - ]:          64 :                 else if (typeof a === 'bigint')
     552                 :           0 :                     return `${a}n`;
     553                 :             :                 else
     554                 :          64 :                     return String(a);
     555                 :             :             })
     556                 :          70 :             .join(' ');
     557                 :             : 
     558                 :          70 :         let formattedOutput = this.#groupIndentation + output;
     559                 :          70 :         const extraFields = {};
     560                 :             : 
     561         [ +  - ]:          70 :         let stackTrace = options?.stackTrace;
     562         [ -  + ]:          70 :         if (!stackTrace &&
     563 [ +  + ][ +  + ]:          70 :             (logLevel === 'trace' || severity <= GLib.LogLevelFlags.LEVEL_WARNING)) {
     564                 :          36 :             stackTrace = new Error().stack;
     565         [ -  + ]:          36 :             const currentFile = stackTrace.match(/^[^@]*@(.*):\d+:\d+$/m)?.at(1);
     566                 :          36 :             const index = stackTrace.lastIndexOf(currentFile) + currentFile.length;
     567                 :             : 
     568                 :          36 :             stackTrace = stackTrace.substring(index).split('\n');
     569                 :             :             // Remove the remainder of the first line
     570                 :          36 :             stackTrace.shift();
     571                 :             :         }
     572                 :             : 
     573         [ +  + ]:          70 :         if (logLevel === 'trace') {
     574 [ -  + ][ -  + ]:          12 :             if (stackTrace?.length) {
     575                 :          12 :                 formattedOutput += `\n${stackTrace.map(s =>
     576                 :         132 :                     `${this.#groupIndentation}${s}`).join('\n')}`;
     577                 :             :             } else {
     578                 :           0 :                 formattedOutput +=
     579                 :           0 :                     `\n${this.#groupIndentation}No trace available`;
     580                 :             :             }
     581                 :             :         }
     582                 :             : 
     583 [ +  + ][ +  + ]:          70 :         if (stackTrace?.length) {
     584 [ +  - ][ +  - ]:          36 :             const [stackLine] = stackTrace;
     585                 :          36 :             const match = stackLine.match(/^([^@]*)@(.*):(\d+):\d+$/);
     586                 :             : 
     587         [ -  + ]:          36 :             if (match) {
     588 [ +  - ][ +  - ]:          36 :                 const [_, func, file, line] = match;
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     589                 :             : 
     590         [ +  - ]:          36 :                 if (func)
     591                 :           0 :                     extraFields.CODE_FUNC = func;
     592         [ -  + ]:          36 :                 if (file)
     593                 :          36 :                     extraFields.CODE_FILE = file;
     594         [ -  + ]:          36 :                 if (line)
     595                 :          36 :                     extraFields.CODE_LINE = line;
     596                 :             :             }
     597                 :             :         }
     598                 :             : 
     599                 :         140 :         GLib.log_structured(this.#logDomain, severity, {
     600                 :          70 :             MESSAGE: formattedOutput,
     601                 :          70 :             ...extraFields,
     602 [ +  - ][ -  + ]:          70 :             ...options?.fields ?? {},
     603                 :             :         });
     604                 :             :     }
     605                 :             : }
     606                 :             : 
     607                 :          47 : const console = new Console();
     608                 :             : 
     609                 :             : /**
     610                 :             :  * @param {string} domain set the GLib log domain for the global console object.
     611                 :             :  */
     612                 :           0 : function setConsoleLogDomain(domain) {
     613                 :           0 :     console.setLogDomain(domain);
     614                 :             : }
     615                 :             : 
     616                 :             : /**
     617                 :             :  * @returns {string}
     618                 :             :  */
     619                 :           0 : function getConsoleLogDomain() {
     620                 :           0 :     return console.logDomain;
     621                 :             : }
     622                 :             : 
     623                 :             : /**
     624                 :             :  * For historical web-compatibility reasons, the namespace object for
     625                 :             :  * console must have {} as its [[Prototype]].
     626                 :             :  *
     627                 :             :  * @type {Omit<Console, 'setLogDomain' | 'logDomain'>}
     628                 :             :  */
     629                 :          47 : const globalConsole = Object.create({});
     630                 :             : 
     631                 :             : const propertyNames =
     632                 :             :     /** @type {['constructor', ...Array<string & keyof Console>]} */
     633                 :             :     // eslint-disable-next-line no-extra-parens
     634                 :          47 :     (Object.getOwnPropertyNames(Console.prototype));
     635                 :          47 : const propertyDescriptors = Object.getOwnPropertyDescriptors(Console.prototype);
     636         [ +  + ]:        1222 : for (const key of propertyNames) {
     637         [ +  + ]:        1175 :     if (key === 'constructor')
     638                 :          47 :         continue;
     639                 :             : 
     640                 :             :     // This non-standard function shouldn't be included.
     641         [ +  + ]:        1128 :     if (key === 'setLogDomain')
     642                 :          47 :         continue;
     643                 :             : 
     644                 :        1081 :     const descriptor = propertyDescriptors[key];
     645         [ +  + ]:        1081 :     if (typeof descriptor.value !== 'function')
     646                 :          47 :         continue;
     647                 :             : 
     648                 :        2068 :     Object.defineProperty(globalConsole, key, {
     649                 :        1034 :         ...descriptor,
     650                 :        1034 :         value: descriptor.value.bind(console),
     651                 :             :     });
     652                 :             : }
     653                 :          94 : Object.defineProperties(globalConsole, {
     654                 :          47 :     [Symbol.toStringTag]: {
     655                 :          47 :         configurable: false,
     656                 :          47 :         enumerable: true,
     657                 :          47 :         get() {
     658                 :           1 :             return 'console';
     659                 :             :         },
     660                 :             :     },
     661                 :             : });
     662                 :          47 : Object.freeze(globalConsole);
     663                 :             : 
     664                 :          94 : Object.defineProperty(globalThis, 'console', {
     665                 :          47 :     configurable: false,
     666                 :          47 :     enumerable: true,
     667                 :          47 :     writable: false,
     668                 :          47 :     value: globalConsole,
     669                 :             : });
     670                 :             : 
     671                 :             : export {
     672                 :             :     getConsoleLogDomain,
     673                 :             :     setConsoleLogDomain,
     674                 :             :     DEFAULT_LOG_DOMAIN
     675                 :             : };
     676                 :             : 
     677                 :          47 : export default {
     678                 :          47 :     getConsoleLogDomain,
     679                 :          47 :     setConsoleLogDomain,
     680                 :          47 :     DEFAULT_LOG_DOMAIN,
     681                 :             : };
        

Generated by: LCOV version 2.0-1