dev testing
This commit is contained in:
266
functions/node_modules/@firebase/logger/dist/esm/index.esm5.js
generated
vendored
Normal file
266
functions/node_modules/@firebase/logger/dist/esm/index.esm5.js
generated
vendored
Normal file
@@ -0,0 +1,266 @@
|
||||
import { __spreadArray } from 'tslib';
|
||||
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2017 Google LLC
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
var _a;
|
||||
/**
|
||||
* A container for all of the Logger instances
|
||||
*/
|
||||
var instances = [];
|
||||
/**
|
||||
* The JS SDK supports 5 log levels and also allows a user the ability to
|
||||
* silence the logs altogether.
|
||||
*
|
||||
* The order is a follows:
|
||||
* DEBUG < VERBOSE < INFO < WARN < ERROR
|
||||
*
|
||||
* All of the log types above the current log level will be captured (i.e. if
|
||||
* you set the log level to `INFO`, errors will still be logged, but `DEBUG` and
|
||||
* `VERBOSE` logs will not)
|
||||
*/
|
||||
var LogLevel;
|
||||
(function (LogLevel) {
|
||||
LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
|
||||
LogLevel[LogLevel["VERBOSE"] = 1] = "VERBOSE";
|
||||
LogLevel[LogLevel["INFO"] = 2] = "INFO";
|
||||
LogLevel[LogLevel["WARN"] = 3] = "WARN";
|
||||
LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
|
||||
LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
|
||||
})(LogLevel || (LogLevel = {}));
|
||||
var levelStringToEnum = {
|
||||
'debug': LogLevel.DEBUG,
|
||||
'verbose': LogLevel.VERBOSE,
|
||||
'info': LogLevel.INFO,
|
||||
'warn': LogLevel.WARN,
|
||||
'error': LogLevel.ERROR,
|
||||
'silent': LogLevel.SILENT
|
||||
};
|
||||
/**
|
||||
* The default log level
|
||||
*/
|
||||
var defaultLogLevel = LogLevel.INFO;
|
||||
/**
|
||||
* By default, `console.debug` is not displayed in the developer console (in
|
||||
* chrome). To avoid forcing users to have to opt-in to these logs twice
|
||||
* (i.e. once for firebase, and once in the console), we are sending `DEBUG`
|
||||
* logs to the `console.log` function.
|
||||
*/
|
||||
var ConsoleMethod = (_a = {},
|
||||
_a[LogLevel.DEBUG] = 'log',
|
||||
_a[LogLevel.VERBOSE] = 'log',
|
||||
_a[LogLevel.INFO] = 'info',
|
||||
_a[LogLevel.WARN] = 'warn',
|
||||
_a[LogLevel.ERROR] = 'error',
|
||||
_a);
|
||||
/**
|
||||
* The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
|
||||
* messages on to their corresponding console counterparts (if the log method
|
||||
* is supported by the current log level)
|
||||
*/
|
||||
var defaultLogHandler = function (instance, logType) {
|
||||
var args = [];
|
||||
for (var _i = 2; _i < arguments.length; _i++) {
|
||||
args[_i - 2] = arguments[_i];
|
||||
}
|
||||
if (logType < instance.logLevel) {
|
||||
return;
|
||||
}
|
||||
var now = new Date().toISOString();
|
||||
var method = ConsoleMethod[logType];
|
||||
if (method) {
|
||||
console[method].apply(console, __spreadArray(["[".concat(now, "] ").concat(instance.name, ":")], args, false));
|
||||
}
|
||||
else {
|
||||
throw new Error("Attempted to log a message with an invalid logType (value: ".concat(logType, ")"));
|
||||
}
|
||||
};
|
||||
var Logger = /** @class */ (function () {
|
||||
/**
|
||||
* Gives you an instance of a Logger to capture messages according to
|
||||
* Firebase's logging scheme.
|
||||
*
|
||||
* @param name The name that the logs will be associated with
|
||||
*/
|
||||
function Logger(name) {
|
||||
this.name = name;
|
||||
/**
|
||||
* The log level of the given Logger instance.
|
||||
*/
|
||||
this._logLevel = defaultLogLevel;
|
||||
/**
|
||||
* The main (internal) log handler for the Logger instance.
|
||||
* Can be set to a new function in internal package code but not by user.
|
||||
*/
|
||||
this._logHandler = defaultLogHandler;
|
||||
/**
|
||||
* The optional, additional, user-defined log handler for the Logger instance.
|
||||
*/
|
||||
this._userLogHandler = null;
|
||||
/**
|
||||
* Capture the current instance for later use
|
||||
*/
|
||||
instances.push(this);
|
||||
}
|
||||
Object.defineProperty(Logger.prototype, "logLevel", {
|
||||
get: function () {
|
||||
return this._logLevel;
|
||||
},
|
||||
set: function (val) {
|
||||
if (!(val in LogLevel)) {
|
||||
throw new TypeError("Invalid value \"".concat(val, "\" assigned to `logLevel`"));
|
||||
}
|
||||
this._logLevel = val;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
// Workaround for setter/getter having to be the same type.
|
||||
Logger.prototype.setLogLevel = function (val) {
|
||||
this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;
|
||||
};
|
||||
Object.defineProperty(Logger.prototype, "logHandler", {
|
||||
get: function () {
|
||||
return this._logHandler;
|
||||
},
|
||||
set: function (val) {
|
||||
if (typeof val !== 'function') {
|
||||
throw new TypeError('Value assigned to `logHandler` must be a function');
|
||||
}
|
||||
this._logHandler = val;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Logger.prototype, "userLogHandler", {
|
||||
get: function () {
|
||||
return this._userLogHandler;
|
||||
},
|
||||
set: function (val) {
|
||||
this._userLogHandler = val;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
/**
|
||||
* The functions below are all based on the `console` interface
|
||||
*/
|
||||
Logger.prototype.debug = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.DEBUG], args, false));
|
||||
this._logHandler.apply(this, __spreadArray([this, LogLevel.DEBUG], args, false));
|
||||
};
|
||||
Logger.prototype.log = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.VERBOSE], args, false));
|
||||
this._logHandler.apply(this, __spreadArray([this, LogLevel.VERBOSE], args, false));
|
||||
};
|
||||
Logger.prototype.info = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.INFO], args, false));
|
||||
this._logHandler.apply(this, __spreadArray([this, LogLevel.INFO], args, false));
|
||||
};
|
||||
Logger.prototype.warn = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.WARN], args, false));
|
||||
this._logHandler.apply(this, __spreadArray([this, LogLevel.WARN], args, false));
|
||||
};
|
||||
Logger.prototype.error = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.ERROR], args, false));
|
||||
this._logHandler.apply(this, __spreadArray([this, LogLevel.ERROR], args, false));
|
||||
};
|
||||
return Logger;
|
||||
}());
|
||||
function setLogLevel(level) {
|
||||
instances.forEach(function (inst) {
|
||||
inst.setLogLevel(level);
|
||||
});
|
||||
}
|
||||
function setUserLogHandler(logCallback, options) {
|
||||
var _loop_1 = function (instance) {
|
||||
var customLogLevel = null;
|
||||
if (options && options.level) {
|
||||
customLogLevel = levelStringToEnum[options.level];
|
||||
}
|
||||
if (logCallback === null) {
|
||||
instance.userLogHandler = null;
|
||||
}
|
||||
else {
|
||||
instance.userLogHandler = function (instance, level) {
|
||||
var args = [];
|
||||
for (var _i = 2; _i < arguments.length; _i++) {
|
||||
args[_i - 2] = arguments[_i];
|
||||
}
|
||||
var message = args
|
||||
.map(function (arg) {
|
||||
if (arg == null) {
|
||||
return null;
|
||||
}
|
||||
else if (typeof arg === 'string') {
|
||||
return arg;
|
||||
}
|
||||
else if (typeof arg === 'number' || typeof arg === 'boolean') {
|
||||
return arg.toString();
|
||||
}
|
||||
else if (arg instanceof Error) {
|
||||
return arg.message;
|
||||
}
|
||||
else {
|
||||
try {
|
||||
return JSON.stringify(arg);
|
||||
}
|
||||
catch (ignored) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
})
|
||||
.filter(function (arg) { return arg; })
|
||||
.join(' ');
|
||||
if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) {
|
||||
logCallback({
|
||||
level: LogLevel[level].toLowerCase(),
|
||||
message: message,
|
||||
args: args,
|
||||
type: instance.name
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
for (var _i = 0, instances_1 = instances; _i < instances_1.length; _i++) {
|
||||
var instance = instances_1[_i];
|
||||
_loop_1(instance);
|
||||
}
|
||||
}
|
||||
|
||||
export { LogLevel, Logger, setLogLevel, setUserLogHandler };
|
||||
//# sourceMappingURL=index.esm5.js.map
|
||||
Reference in New Issue
Block a user