zpt
Version:
Zenon Page Templates - JS (ZPT-JS)
1,182 lines (1,181 loc) • 537 kB
JavaScript
// lib/log4javascript-esm.js
var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var require_log4javascript = __commonJS({
"node_modules/log4javascript/log4javascript.js"(exports, module) {
(function(factory, root) {
if (typeof define == "function" && define.amd) {
define(factory);
} else if (typeof module != "undefined" && typeof exports == "object") {
module.exports = factory();
} else {
root.log4javascript = factory();
}
})(function() {
if (!Array.prototype.push) {
Array.prototype.push = function() {
for (var i2 = 0, len2 = arguments.length; i2 < len2; i2++) {
this[this.length] = arguments[i2];
}
return this.length;
};
}
if (!Array.prototype.shift) {
Array.prototype.shift = function() {
if (this.length > 0) {
var firstItem = this[0];
for (var i2 = 0, len2 = this.length - 1; i2 < len2; i2++) {
this[i2] = this[i2 + 1];
}
this.length = this.length - 1;
return firstItem;
}
};
}
if (!Array.prototype.splice) {
Array.prototype.splice = function(startIndex, deleteCount) {
var itemsAfterDeleted = this.slice(startIndex + deleteCount);
var itemsDeleted = this.slice(startIndex, startIndex + deleteCount);
this.length = startIndex;
var argumentsArray = [];
for (var i2 = 0, len2 = arguments.length; i2 < len2; i2++) {
argumentsArray[i2] = arguments[i2];
}
var itemsToAppend = argumentsArray.length > 2 ? itemsAfterDeleted = argumentsArray.slice(2).concat(itemsAfterDeleted) : itemsAfterDeleted;
for (i2 = 0, len2 = itemsToAppend.length; i2 < len2; i2++) {
this.push(itemsToAppend[i2]);
}
return itemsDeleted;
};
}
function isUndefined(obj2) {
return typeof obj2 == "undefined";
}
function EventSupport() {
}
EventSupport.prototype = { eventTypes: [], eventListeners: {}, setEventTypes: function(eventTypesParam) {
if (eventTypesParam instanceof Array) {
this.eventTypes = eventTypesParam;
this.eventListeners = {};
for (var i2 = 0, len2 = this.eventTypes.length; i2 < len2; i2++) {
this.eventListeners[this.eventTypes[i2]] = [];
}
} else {
handleError("log4javascript.EventSupport [" + this + "]: setEventTypes: eventTypes parameter must be an Array");
}
}, addEventListener: function(eventType, listener) {
if (typeof listener == "function") {
if (!array_contains(this.eventTypes, eventType)) {
handleError("log4javascript.EventSupport [" + this + "]: addEventListener: no event called '" + eventType + "'");
}
this.eventListeners[eventType].push(listener);
} else {
handleError("log4javascript.EventSupport [" + this + "]: addEventListener: listener must be a function");
}
}, removeEventListener: function(eventType, listener) {
if (typeof listener == "function") {
if (!array_contains(this.eventTypes, eventType)) {
handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: no event called '" + eventType + "'");
}
array_remove(this.eventListeners[eventType], listener);
} else {
handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: listener must be a function");
}
}, dispatchEvent: function(eventType, eventArgs) {
if (array_contains(this.eventTypes, eventType)) {
var listeners = this.eventListeners[eventType];
for (var i2 = 0, len2 = listeners.length; i2 < len2; i2++) {
listeners[i2](this, eventType, eventArgs);
}
} else {
handleError("log4javascript.EventSupport [" + this + "]: dispatchEvent: no event called '" + eventType + "'");
}
} };
var applicationStartDate = /* @__PURE__ */ new Date();
var uniqueId = "log4javascript_" + applicationStartDate.getTime() + "_" + Math.floor(Math.random() * 1e8);
var emptyFunction = function() {
};
var newLine = "\r\n";
var pageLoaded = false;
function Log4JavaScript() {
}
Log4JavaScript.prototype = new EventSupport();
var log4javascript = new Log4JavaScript();
log4javascript.version = "1.4.13";
log4javascript.edition = "log4javascript";
function toStr(obj2) {
if (obj2 && obj2.toString) {
return obj2.toString();
} else {
return String(obj2);
}
}
function getExceptionMessage(ex) {
if (ex.message) {
return ex.message;
} else if (ex.description) {
return ex.description;
} else {
return toStr(ex);
}
}
function getUrlFileName(url) {
var lastSlashIndex = Math.max(url.lastIndexOf("/"), url.lastIndexOf("\\"));
return url.substr(lastSlashIndex + 1);
}
function getExceptionStringRep(ex) {
if (ex) {
var exStr = "Exception: " + getExceptionMessage(ex);
try {
if (ex.lineNumber) {
exStr += " on line number " + ex.lineNumber;
}
if (ex.fileName) {
exStr += " in file " + getUrlFileName(ex.fileName);
}
} catch (localEx) {
logLog.warn("Unable to obtain file and line information for error");
}
if (showStackTraces && ex.stack) {
exStr += newLine + "Stack trace:" + newLine + ex.stack;
}
return exStr;
}
return null;
}
function bool(obj2) {
return Boolean(obj2);
}
function trim(str) {
return str.replace(/^\s+/, "").replace(/\s+$/, "");
}
function splitIntoLines(text) {
var text2 = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
return text2.split("\n");
}
var urlEncode = typeof window.encodeURIComponent != "undefined" ? function(str) {
return encodeURIComponent(str);
} : function(str) {
return escape(str).replace(/\+/g, "%2B").replace(/"/g, "%22").replace(/'/g, "%27").replace(/\//g, "%2F").replace(/=/g, "%3D");
};
function array_remove(arr, val) {
var index = -1;
for (var i2 = 0, len2 = arr.length; i2 < len2; i2++) {
if (arr[i2] === val) {
index = i2;
break;
}
}
if (index >= 0) {
arr.splice(index, 1);
return true;
} else {
return false;
}
}
function array_contains(arr, val) {
for (var i2 = 0, len2 = arr.length; i2 < len2; i2++) {
if (arr[i2] == val) {
return true;
}
}
return false;
}
function extractBooleanFromParam(param, defaultValue) {
if (isUndefined(param)) {
return defaultValue;
} else {
return bool(param);
}
}
function extractStringFromParam(param, defaultValue) {
if (isUndefined(param)) {
return defaultValue;
} else {
return String(param);
}
}
function extractIntFromParam(param, defaultValue) {
if (isUndefined(param)) {
return defaultValue;
} else {
try {
var value = parseInt(param, 10);
return isNaN(value) ? defaultValue : value;
} catch (ex) {
logLog.warn("Invalid int param " + param, ex);
return defaultValue;
}
}
}
function extractFunctionFromParam(param, defaultValue) {
if (typeof param == "function") {
return param;
} else {
return defaultValue;
}
}
function isError(err) {
return err instanceof Error;
}
if (!Function.prototype.apply) {
Function.prototype.apply = function(obj, args) {
var methodName = "__apply__";
if (typeof obj[methodName] != "undefined") {
methodName += String(Math.random()).substr(2);
}
obj[methodName] = this;
var argsStrings = [];
for (var i = 0, len = args.length; i < len; i++) {
argsStrings[i] = "args[" + i + "]";
}
var script = "obj." + methodName + "(" + argsStrings.join(",") + ")";
var returnValue = eval(script);
delete obj[methodName];
return returnValue;
};
}
if (!Function.prototype.call) {
Function.prototype.call = function(obj2) {
var args2 = [];
for (var i2 = 1, len2 = arguments.length; i2 < len2; i2++) {
args2[i2 - 1] = arguments[i2];
}
return this.apply(obj2, args2);
};
}
var logLog = { quietMode: false, debugMessages: [], setQuietMode: function(quietMode) {
this.quietMode = bool(quietMode);
}, numberOfErrors: 0, alertAllErrors: false, setAlertAllErrors: function(alertAllErrors) {
this.alertAllErrors = alertAllErrors;
}, debug: function(message) {
this.debugMessages.push(message);
}, displayDebug: function() {
alert(this.debugMessages.join(newLine));
}, warn: function(message, exception) {
}, error: function(message, exception) {
if (++this.numberOfErrors == 1 || this.alertAllErrors) {
if (!this.quietMode) {
var alertMessage = "log4javascript error: " + message;
if (exception) {
alertMessage += newLine + newLine + "Original error: " + getExceptionStringRep(exception);
}
alert(alertMessage);
}
}
} };
log4javascript.logLog = logLog;
log4javascript.setEventTypes(["load", "error"]);
function handleError(message, exception) {
logLog.error(message, exception);
log4javascript.dispatchEvent("error", { "message": message, "exception": exception });
}
log4javascript.handleError = handleError;
var enabled = !(typeof log4javascript_disabled != "undefined" && log4javascript_disabled);
log4javascript.setEnabled = function(enable) {
enabled = bool(enable);
};
log4javascript.isEnabled = function() {
return enabled;
};
var useTimeStampsInMilliseconds = true;
log4javascript.setTimeStampsInMilliseconds = function(timeStampsInMilliseconds) {
useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
};
log4javascript.isTimeStampsInMilliseconds = function() {
return useTimeStampsInMilliseconds;
};
log4javascript.evalInScope = function(expr) {
return eval(expr);
};
var showStackTraces = false;
log4javascript.setShowStackTraces = function(show) {
showStackTraces = bool(show);
};
var Level = function(level, name) {
this.level = level;
this.name = name;
};
Level.prototype = { toString: function() {
return this.name;
}, equals: function(level) {
return this.level == level.level;
}, isGreaterOrEqual: function(level) {
return this.level >= level.level;
} };
Level.ALL = new Level(Number.MIN_VALUE, "ALL");
Level.TRACE = new Level(1e4, "TRACE");
Level.DEBUG = new Level(2e4, "DEBUG");
Level.INFO = new Level(3e4, "INFO");
Level.WARN = new Level(4e4, "WARN");
Level.ERROR = new Level(5e4, "ERROR");
Level.FATAL = new Level(6e4, "FATAL");
Level.OFF = new Level(Number.MAX_VALUE, "OFF");
log4javascript.Level = Level;
function Timer(name, level) {
this.name = name;
this.level = isUndefined(level) ? Level.INFO : level;
this.start = /* @__PURE__ */ new Date();
}
Timer.prototype.getElapsedTime = function() {
return (/* @__PURE__ */ new Date()).getTime() - this.start.getTime();
};
var anonymousLoggerName = "[anonymous]";
var defaultLoggerName = "[default]";
var nullLoggerName = "[null]";
var rootLoggerName = "root";
function Logger(name) {
this.name = name;
this.parent = null;
this.children = [];
var appenders = [];
var loggerLevel = null;
var isRoot = this.name === rootLoggerName;
var isNull = this.name === nullLoggerName;
var appenderCache = null;
var appenderCacheInvalidated = false;
this.addChild = function(childLogger) {
this.children.push(childLogger);
childLogger.parent = this;
childLogger.invalidateAppenderCache();
};
var additive = true;
this.getAdditivity = function() {
return additive;
};
this.setAdditivity = function(additivity) {
var valueChanged = additive != additivity;
additive = additivity;
if (valueChanged) {
this.invalidateAppenderCache();
}
};
this.addAppender = function(appender) {
if (isNull) {
handleError("Logger.addAppender: you may not add an appender to the null logger");
} else {
if (appender instanceof log4javascript.Appender) {
if (!array_contains(appenders, appender)) {
appenders.push(appender);
appender.setAddedToLogger(this);
this.invalidateAppenderCache();
}
} else {
handleError("Logger.addAppender: appender supplied ('" + toStr(appender) + "') is not a subclass of Appender");
}
}
};
this.removeAppender = function(appender) {
array_remove(appenders, appender);
appender.setRemovedFromLogger(this);
this.invalidateAppenderCache();
};
this.removeAllAppenders = function() {
var appenderCount = appenders.length;
if (appenderCount > 0) {
for (var i2 = 0; i2 < appenderCount; i2++) {
appenders[i2].setRemovedFromLogger(this);
}
appenders.length = 0;
this.invalidateAppenderCache();
}
};
this.getEffectiveAppenders = function() {
if (appenderCache === null || appenderCacheInvalidated) {
var parentEffectiveAppenders = isRoot || !this.getAdditivity() ? [] : this.parent.getEffectiveAppenders();
appenderCache = parentEffectiveAppenders.concat(appenders);
appenderCacheInvalidated = false;
}
return appenderCache;
};
this.invalidateAppenderCache = function() {
appenderCacheInvalidated = true;
for (var i2 = 0, len2 = this.children.length; i2 < len2; i2++) {
this.children[i2].invalidateAppenderCache();
}
};
this.log = function(level, params) {
if (enabled && level.isGreaterOrEqual(this.getEffectiveLevel())) {
var exception;
var finalParamIndex = params.length - 1;
var lastParam = params[finalParamIndex];
if (params.length > 1 && isError(lastParam)) {
exception = lastParam;
finalParamIndex--;
}
var messages = [];
for (var i2 = 0; i2 <= finalParamIndex; i2++) {
messages[i2] = params[i2];
}
var loggingEvent = new LoggingEvent(this, /* @__PURE__ */ new Date(), level, messages, exception);
this.callAppenders(loggingEvent);
}
};
this.callAppenders = function(loggingEvent) {
var effectiveAppenders = this.getEffectiveAppenders();
for (var i2 = 0, len2 = effectiveAppenders.length; i2 < len2; i2++) {
effectiveAppenders[i2].doAppend(loggingEvent);
}
};
this.setLevel = function(level) {
if (isRoot && level === null) {
handleError("Logger.setLevel: you cannot set the level of the root logger to null");
} else if (level instanceof Level) {
loggerLevel = level;
} else {
handleError("Logger.setLevel: level supplied to logger " + this.name + " is not an instance of log4javascript.Level");
}
};
this.getLevel = function() {
return loggerLevel;
};
this.getEffectiveLevel = function() {
for (var logger = this; logger !== null; logger = logger.parent) {
var level = logger.getLevel();
if (level !== null) {
return level;
}
}
};
this.group = function(name2, initiallyExpanded) {
if (enabled) {
var effectiveAppenders = this.getEffectiveAppenders();
for (var i2 = 0, len2 = effectiveAppenders.length; i2 < len2; i2++) {
effectiveAppenders[i2].group(name2, initiallyExpanded);
}
}
};
this.groupEnd = function() {
if (enabled) {
var effectiveAppenders = this.getEffectiveAppenders();
for (var i2 = 0, len2 = effectiveAppenders.length; i2 < len2; i2++) {
effectiveAppenders[i2].groupEnd();
}
}
};
var timers = {};
this.time = function(name2, level) {
if (enabled) {
if (isUndefined(name2)) {
handleError("Logger.time: a name for the timer must be supplied");
} else if (level && !(level instanceof Level)) {
handleError("Logger.time: level supplied to timer " + name2 + " is not an instance of log4javascript.Level");
} else {
timers[name2] = new Timer(name2, level);
}
}
};
this.timeEnd = function(name2) {
if (enabled) {
if (isUndefined(name2)) {
handleError("Logger.timeEnd: a name for the timer must be supplied");
} else if (timers[name2]) {
var timer = timers[name2];
var milliseconds = timer.getElapsedTime();
this.log(timer.level, ["Timer " + toStr(name2) + " completed in " + milliseconds + "ms"]);
delete timers[name2];
} else {
logLog.warn("Logger.timeEnd: no timer found with name " + name2);
}
}
};
this.assert = function(expr2) {
if (enabled && !expr2) {
var args2 = [];
for (var i2 = 1, len2 = arguments.length; i2 < len2; i2++) {
args2.push(arguments[i2]);
}
args2 = args2.length > 0 ? args2 : ["Assertion Failure"];
args2.push(newLine);
args2.push(expr2);
this.log(Level.ERROR, args2);
}
};
this.toString = function() {
return "Logger[" + this.name + "]";
};
}
Logger.prototype = { trace: function() {
this.log(Level.TRACE, arguments);
}, debug: function() {
this.log(Level.DEBUG, arguments);
}, info: function() {
this.log(Level.INFO, arguments);
}, warn: function() {
this.log(Level.WARN, arguments);
}, error: function() {
this.log(Level.ERROR, arguments);
}, fatal: function() {
this.log(Level.FATAL, arguments);
}, isEnabledFor: function(level) {
return level.isGreaterOrEqual(this.getEffectiveLevel());
}, isTraceEnabled: function() {
return this.isEnabledFor(Level.TRACE);
}, isDebugEnabled: function() {
return this.isEnabledFor(Level.DEBUG);
}, isInfoEnabled: function() {
return this.isEnabledFor(Level.INFO);
}, isWarnEnabled: function() {
return this.isEnabledFor(Level.WARN);
}, isErrorEnabled: function() {
return this.isEnabledFor(Level.ERROR);
}, isFatalEnabled: function() {
return this.isEnabledFor(Level.FATAL);
} };
Logger.prototype.trace.isEntryPoint = true;
Logger.prototype.debug.isEntryPoint = true;
Logger.prototype.info.isEntryPoint = true;
Logger.prototype.warn.isEntryPoint = true;
Logger.prototype.error.isEntryPoint = true;
Logger.prototype.fatal.isEntryPoint = true;
var loggers = {};
var loggerNames = [];
var ROOT_LOGGER_DEFAULT_LEVEL = Level.DEBUG;
var rootLogger = new Logger(rootLoggerName);
rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
log4javascript.getRootLogger = function() {
return rootLogger;
};
log4javascript.getLogger = function(loggerName) {
if (typeof loggerName != "string") {
loggerName = anonymousLoggerName;
logLog.warn("log4javascript.getLogger: non-string logger name " + toStr(loggerName) + " supplied, returning anonymous logger");
}
if (loggerName == rootLoggerName) {
handleError("log4javascript.getLogger: root logger may not be obtained by name");
}
if (!loggers[loggerName]) {
var logger = new Logger(loggerName);
loggers[loggerName] = logger;
loggerNames.push(loggerName);
var lastDotIndex = loggerName.lastIndexOf(".");
var parentLogger;
if (lastDotIndex > -1) {
var parentLoggerName = loggerName.substring(0, lastDotIndex);
parentLogger = log4javascript.getLogger(parentLoggerName);
} else {
parentLogger = rootLogger;
}
parentLogger.addChild(logger);
}
return loggers[loggerName];
};
var defaultLogger = null;
log4javascript.getDefaultLogger = function() {
if (!defaultLogger) {
defaultLogger = createDefaultLogger();
}
return defaultLogger;
};
var nullLogger = null;
log4javascript.getNullLogger = function() {
if (!nullLogger) {
nullLogger = new Logger(nullLoggerName);
nullLogger.setLevel(Level.OFF);
}
return nullLogger;
};
log4javascript.resetConfiguration = function() {
rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
loggers = {};
};
var LoggingEvent = function(logger, timeStamp, level, messages, exception) {
this.logger = logger;
this.timeStamp = timeStamp;
this.timeStampInMilliseconds = timeStamp.getTime();
this.timeStampInSeconds = Math.floor(this.timeStampInMilliseconds / 1e3);
this.milliseconds = this.timeStamp.getMilliseconds();
this.level = level;
this.messages = messages;
this.exception = exception;
};
LoggingEvent.prototype = { getThrowableStrRep: function() {
return this.exception ? getExceptionStringRep(this.exception) : "";
}, getCombinedMessages: function() {
return this.messages.length == 1 ? this.messages[0] : this.messages.join(newLine);
}, toString: function() {
return "LoggingEvent[" + this.level + "]";
} };
log4javascript.LoggingEvent = LoggingEvent;
var Layout = function() {
};
Layout.prototype = { defaults: { loggerKey: "logger", timeStampKey: "timestamp", millisecondsKey: "milliseconds", levelKey: "level", messageKey: "message", exceptionKey: "exception", urlKey: "url" }, loggerKey: "logger", timeStampKey: "timestamp", millisecondsKey: "milliseconds", levelKey: "level", messageKey: "message", exceptionKey: "exception", urlKey: "url", batchHeader: "", batchFooter: "", batchSeparator: "", returnsPostData: false, overrideTimeStampsSetting: false, useTimeStampsInMilliseconds: null, format: function() {
handleError("Layout.format: layout supplied has no format() method");
}, ignoresThrowable: function() {
handleError("Layout.ignoresThrowable: layout supplied has no ignoresThrowable() method");
}, getContentType: function() {
return "text/plain";
}, allowBatching: function() {
return true;
}, setTimeStampsInMilliseconds: function(timeStampsInMilliseconds) {
this.overrideTimeStampsSetting = true;
this.useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
}, isTimeStampsInMilliseconds: function() {
return this.overrideTimeStampsSetting ? this.useTimeStampsInMilliseconds : useTimeStampsInMilliseconds;
}, getTimeStampValue: function(loggingEvent) {
return this.isTimeStampsInMilliseconds() ? loggingEvent.timeStampInMilliseconds : loggingEvent.timeStampInSeconds;
}, getDataValues: function(loggingEvent, combineMessages) {
var dataValues = [[this.loggerKey, loggingEvent.logger.name], [this.timeStampKey, this.getTimeStampValue(loggingEvent)], [this.levelKey, loggingEvent.level.name], [this.urlKey, window.location.href], [this.messageKey, combineMessages ? loggingEvent.getCombinedMessages() : loggingEvent.messages]];
if (!this.isTimeStampsInMilliseconds()) {
dataValues.push([this.millisecondsKey, loggingEvent.milliseconds]);
}
if (loggingEvent.exception) {
dataValues.push([this.exceptionKey, getExceptionStringRep(loggingEvent.exception)]);
}
if (this.hasCustomFields()) {
for (var i2 = 0, len2 = this.customFields.length; i2 < len2; i2++) {
var val = this.customFields[i2].value;
if (typeof val === "function") {
val = val(this, loggingEvent);
}
dataValues.push([this.customFields[i2].name, val]);
}
}
return dataValues;
}, setKeys: function(loggerKey, timeStampKey, levelKey, messageKey, exceptionKey, urlKey, millisecondsKey) {
this.loggerKey = extractStringFromParam(loggerKey, this.defaults.loggerKey);
this.timeStampKey = extractStringFromParam(timeStampKey, this.defaults.timeStampKey);
this.levelKey = extractStringFromParam(levelKey, this.defaults.levelKey);
this.messageKey = extractStringFromParam(messageKey, this.defaults.messageKey);
this.exceptionKey = extractStringFromParam(exceptionKey, this.defaults.exceptionKey);
this.urlKey = extractStringFromParam(urlKey, this.defaults.urlKey);
this.millisecondsKey = extractStringFromParam(millisecondsKey, this.defaults.millisecondsKey);
}, setCustomField: function(name, value) {
var fieldUpdated = false;
for (var i2 = 0, len2 = this.customFields.length; i2 < len2; i2++) {
if (this.customFields[i2].name === name) {
this.customFields[i2].value = value;
fieldUpdated = true;
}
}
if (!fieldUpdated) {
this.customFields.push({ "name": name, "value": value });
}
}, hasCustomFields: function() {
return this.customFields.length > 0;
}, formatWithException: function(loggingEvent) {
var formatted = this.format(loggingEvent);
if (loggingEvent.exception && this.ignoresThrowable()) {
formatted += loggingEvent.getThrowableStrRep();
}
return formatted;
}, toString: function() {
handleError("Layout.toString: all layouts must override this method");
} };
log4javascript.Layout = Layout;
var Appender = function() {
};
Appender.prototype = new EventSupport();
Appender.prototype.layout = new PatternLayout();
Appender.prototype.threshold = Level.ALL;
Appender.prototype.loggers = [];
Appender.prototype.doAppend = function(loggingEvent) {
if (enabled && loggingEvent.level.level >= this.threshold.level) {
this.append(loggingEvent);
}
};
Appender.prototype.append = function(loggingEvent) {
};
Appender.prototype.setLayout = function(layout) {
if (layout instanceof Layout) {
this.layout = layout;
} else {
handleError("Appender.setLayout: layout supplied to " + this.toString() + " is not a subclass of Layout");
}
};
Appender.prototype.getLayout = function() {
return this.layout;
};
Appender.prototype.setThreshold = function(threshold) {
if (threshold instanceof Level) {
this.threshold = threshold;
} else {
handleError("Appender.setThreshold: threshold supplied to " + this.toString() + " is not a subclass of Level");
}
};
Appender.prototype.getThreshold = function() {
return this.threshold;
};
Appender.prototype.setAddedToLogger = function(logger) {
this.loggers.push(logger);
};
Appender.prototype.setRemovedFromLogger = function(logger) {
array_remove(this.loggers, logger);
};
Appender.prototype.group = emptyFunction;
Appender.prototype.groupEnd = emptyFunction;
Appender.prototype.toString = function() {
handleError("Appender.toString: all appenders must override this method");
};
log4javascript.Appender = Appender;
function SimpleLayout() {
this.customFields = [];
}
SimpleLayout.prototype = new Layout();
SimpleLayout.prototype.format = function(loggingEvent) {
return loggingEvent.level.name + " - " + loggingEvent.getCombinedMessages();
};
SimpleLayout.prototype.ignoresThrowable = function() {
return true;
};
SimpleLayout.prototype.toString = function() {
return "SimpleLayout";
};
log4javascript.SimpleLayout = SimpleLayout;
function NullLayout() {
this.customFields = [];
}
NullLayout.prototype = new Layout();
NullLayout.prototype.format = function(loggingEvent) {
return loggingEvent.messages;
};
NullLayout.prototype.ignoresThrowable = function() {
return true;
};
NullLayout.prototype.formatWithException = function(loggingEvent) {
var messages = loggingEvent.messages, ex = loggingEvent.exception;
return ex ? messages.concat([ex]) : messages;
};
NullLayout.prototype.toString = function() {
return "NullLayout";
};
log4javascript.NullLayout = NullLayout;
function XmlLayout(combineMessages) {
this.combineMessages = extractBooleanFromParam(combineMessages, true);
this.customFields = [];
}
XmlLayout.prototype = new Layout();
XmlLayout.prototype.isCombinedMessages = function() {
return this.combineMessages;
};
XmlLayout.prototype.getContentType = function() {
return "text/xml";
};
XmlLayout.prototype.escapeCdata = function(str) {
return str.replace(/\]\]>/, "]]>]]><![CDATA[");
};
XmlLayout.prototype.format = function(loggingEvent) {
var layout = this;
var i2, len2;
function formatMessage(message) {
message = typeof message === "string" ? message : toStr(message);
return "<log4javascript:message><![CDATA[" + layout.escapeCdata(message) + "]]></log4javascript:message>";
}
var str = '<log4javascript:event logger="' + loggingEvent.logger.name + '" timestamp="' + this.getTimeStampValue(loggingEvent) + '"';
if (!this.isTimeStampsInMilliseconds()) {
str += ' milliseconds="' + loggingEvent.milliseconds + '"';
}
str += ' level="' + loggingEvent.level.name + '">' + newLine;
if (this.combineMessages) {
str += formatMessage(loggingEvent.getCombinedMessages());
} else {
str += "<log4javascript:messages>" + newLine;
for (i2 = 0, len2 = loggingEvent.messages.length; i2 < len2; i2++) {
str += formatMessage(loggingEvent.messages[i2]) + newLine;
}
str += "</log4javascript:messages>" + newLine;
}
if (this.hasCustomFields()) {
for (i2 = 0, len2 = this.customFields.length; i2 < len2; i2++) {
str += '<log4javascript:customfield name="' + this.customFields[i2].name + '"><![CDATA[' + this.customFields[i2].value.toString() + "]]></log4javascript:customfield>" + newLine;
}
}
if (loggingEvent.exception) {
str += "<log4javascript:exception><![CDATA[" + getExceptionStringRep(loggingEvent.exception) + "]]></log4javascript:exception>" + newLine;
}
str += "</log4javascript:event>" + newLine + newLine;
return str;
};
XmlLayout.prototype.ignoresThrowable = function() {
return false;
};
XmlLayout.prototype.toString = function() {
return "XmlLayout";
};
log4javascript.XmlLayout = XmlLayout;
function escapeNewLines(str) {
return str.replace(/\r\n|\r|\n/g, "\\r\\n");
}
function JsonLayout(readable, combineMessages) {
this.readable = extractBooleanFromParam(readable, false);
this.combineMessages = extractBooleanFromParam(combineMessages, true);
this.batchHeader = this.readable ? "[" + newLine : "[";
this.batchFooter = this.readable ? "]" + newLine : "]";
this.batchSeparator = this.readable ? "," + newLine : ",";
this.setKeys();
this.colon = this.readable ? ": " : ":";
this.tab = this.readable ? " " : "";
this.lineBreak = this.readable ? newLine : "";
this.customFields = [];
}
JsonLayout.prototype = new Layout();
JsonLayout.prototype.isReadable = function() {
return this.readable;
};
JsonLayout.prototype.isCombinedMessages = function() {
return this.combineMessages;
};
JsonLayout.prototype.format = function(loggingEvent) {
var layout = this;
var dataValues = this.getDataValues(loggingEvent, this.combineMessages);
var str = "{" + this.lineBreak;
var i2, len2;
function formatValue(val, prefix, expand) {
var formattedValue;
var valType = typeof val;
if (val instanceof Date) {
formattedValue = String(val.getTime());
} else if (expand && val instanceof Array) {
formattedValue = "[" + layout.lineBreak;
for (var i3 = 0, len3 = val.length; i3 < len3; i3++) {
var childPrefix = prefix + layout.tab;
formattedValue += childPrefix + formatValue(val[i3], childPrefix, false);
if (i3 < val.length - 1) {
formattedValue += ",";
}
formattedValue += layout.lineBreak;
}
formattedValue += prefix + "]";
} else if (valType !== "number" && valType !== "boolean") {
formattedValue = '"' + escapeNewLines(toStr(val).replace(/\"/g, '\\"')) + '"';
} else {
formattedValue = val;
}
return formattedValue;
}
for (i2 = 0, len2 = dataValues.length - 1; i2 <= len2; i2++) {
str += this.tab + '"' + dataValues[i2][0] + '"' + this.colon + formatValue(dataValues[i2][1], this.tab, true);
if (i2 < len2) {
str += ",";
}
str += this.lineBreak;
}
str += "}" + this.lineBreak;
return str;
};
JsonLayout.prototype.ignoresThrowable = function() {
return false;
};
JsonLayout.prototype.toString = function() {
return "JsonLayout";
};
JsonLayout.prototype.getContentType = function() {
return "application/json";
};
log4javascript.JsonLayout = JsonLayout;
function HttpPostDataLayout() {
this.setKeys();
this.customFields = [];
this.returnsPostData = true;
}
HttpPostDataLayout.prototype = new Layout();
HttpPostDataLayout.prototype.allowBatching = function() {
return false;
};
HttpPostDataLayout.prototype.format = function(loggingEvent) {
var dataValues = this.getDataValues(loggingEvent);
var queryBits = [];
for (var i2 = 0, len2 = dataValues.length; i2 < len2; i2++) {
var val = dataValues[i2][1] instanceof Date ? String(dataValues[i2][1].getTime()) : dataValues[i2][1];
queryBits.push(urlEncode(dataValues[i2][0]) + "=" + urlEncode(val));
}
return queryBits.join("&");
};
HttpPostDataLayout.prototype.ignoresThrowable = function(loggingEvent) {
return false;
};
HttpPostDataLayout.prototype.toString = function() {
return "HttpPostDataLayout";
};
log4javascript.HttpPostDataLayout = HttpPostDataLayout;
function formatObjectExpansion(obj2, depth, indentation) {
var objectsExpanded = [];
function doFormat(obj3, depth2, indentation2) {
var i2, len2, childDepth, childIndentation, childLines, expansion, childExpansion;
if (!indentation2) {
indentation2 = "";
}
function formatString(text) {
var lines = splitIntoLines(text);
for (var j = 1, jLen = lines.length; j < jLen; j++) {
lines[j] = indentation2 + lines[j];
}
return lines.join(newLine);
}
if (obj3 === null) {
return "null";
} else if (typeof obj3 == "undefined") {
return "undefined";
} else if (typeof obj3 == "string") {
return formatString(obj3);
} else if (typeof obj3 == "object" && array_contains(objectsExpanded, obj3)) {
try {
expansion = toStr(obj3);
} catch (ex) {
expansion = "Error formatting property. Details: " + getExceptionStringRep(ex);
}
return expansion + " [already expanded]";
} else if (obj3 instanceof Array && depth2 > 0) {
objectsExpanded.push(obj3);
expansion = "[" + newLine;
childDepth = depth2 - 1;
childIndentation = indentation2 + " ";
childLines = [];
for (i2 = 0, len2 = obj3.length; i2 < len2; i2++) {
try {
childExpansion = doFormat(obj3[i2], childDepth, childIndentation);
childLines.push(childIndentation + childExpansion);
} catch (ex) {
childLines.push(childIndentation + "Error formatting array member. Details: " + getExceptionStringRep(ex));
}
}
expansion += childLines.join("," + newLine) + newLine + indentation2 + "]";
return expansion;
} else if (Object.prototype.toString.call(obj3) == "[object Date]") {
return obj3.toString();
} else if (typeof obj3 == "object" && depth2 > 0) {
objectsExpanded.push(obj3);
expansion = "{" + newLine;
childDepth = depth2 - 1;
childIndentation = indentation2 + " ";
childLines = [];
for (i2 in obj3) {
try {
childExpansion = doFormat(obj3[i2], childDepth, childIndentation);
childLines.push(childIndentation + i2 + ": " + childExpansion);
} catch (ex) {
childLines.push(childIndentation + i2 + ": Error formatting property. Details: " + getExceptionStringRep(ex));
}
}
expansion += childLines.join("," + newLine) + newLine + indentation2 + "}";
return expansion;
} else {
return formatString(toStr(obj3));
}
}
return doFormat(obj2, depth, indentation);
}
var SimpleDateFormat;
(function() {
var regex = /('[^']*')|(G+|y+|M+|w+|W+|D+|d+|F+|E+|a+|H+|k+|K+|h+|m+|s+|S+|Z+)|([a-zA-Z]+)|([^a-zA-Z']+)/;
var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
var dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
var TEXT2 = 0, TEXT3 = 1, NUMBER = 2, YEAR = 3, MONTH = 4, TIMEZONE = 5;
var types = { G: TEXT2, y: YEAR, M: MONTH, w: NUMBER, W: NUMBER, D: NUMBER, d: NUMBER, F: NUMBER, E: TEXT3, a: TEXT2, H: NUMBER, k: NUMBER, K: NUMBER, h: NUMBER, m: NUMBER, s: NUMBER, S: NUMBER, Z: TIMEZONE };
var ONE_DAY = 24 * 60 * 60 * 1e3;
var ONE_WEEK = 7 * ONE_DAY;
var DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK = 1;
var newDateAtMidnight = function(year, month, day) {
var d = new Date(year, month, day, 0, 0, 0);
d.setMilliseconds(0);
return d;
};
Date.prototype.getDifference = function(date) {
return this.getTime() - date.getTime();
};
Date.prototype.isBefore = function(d) {
return this.getTime() < d.getTime();
};
Date.prototype.getUTCTime = function() {
return Date.UTC(this.getFullYear(), this.getMonth(), this.getDate(), this.getHours(), this.getMinutes(), this.getSeconds(), this.getMilliseconds());
};
Date.prototype.getTimeSince = function(d) {
return this.getUTCTime() - d.getUTCTime();
};
Date.prototype.getPreviousSunday = function() {
var midday = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 12, 0, 0);
var previousSunday = new Date(midday.getTime() - this.getDay() * ONE_DAY);
return newDateAtMidnight(previousSunday.getFullYear(), previousSunday.getMonth(), previousSunday.getDate());
};
Date.prototype.getWeekInYear = function(minimalDaysInFirstWeek) {
if (isUndefined(this.minimalDaysInFirstWeek)) {
minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
}
var previousSunday = this.getPreviousSunday();
var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
var numberOfSundays = previousSunday.isBefore(startOfYear) ? 0 : 1 + Math.floor(previousSunday.getTimeSince(startOfYear) / ONE_WEEK);
var numberOfDaysInFirstWeek = 7 - startOfYear.getDay();
var weekInYear = numberOfSundays;
if (numberOfDaysInFirstWeek < minimalDaysInFirstWeek) {
weekInYear--;
}
return weekInYear;
};
Date.prototype.getWeekInMonth = function(minimalDaysInFirstWeek) {
if (isUndefined(this.minimalDaysInFirstWeek)) {
minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
}
var previousSunday = this.getPreviousSunday();
var startOfMonth = newDateAtMidnight(this.getFullYear(), this.getMonth(), 1);
var numberOfSundays = previousSunday.isBefore(startOfMonth) ? 0 : 1 + Math.floor(previousSunday.getTimeSince(startOfMonth) / ONE_WEEK);
var numberOfDaysInFirstWeek = 7 - startOfMonth.getDay();
var weekInMonth = numberOfSundays;
if (numberOfDaysInFirstWeek >= minimalDaysInFirstWeek) {
weekInMonth++;
}
return weekInMonth;
};
Date.prototype.getDayInYear = function() {
var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
return 1 + Math.floor(this.getTimeSince(startOfYear) / ONE_DAY);
};
SimpleDateFormat = function(formatString) {
this.formatString = formatString;
};
SimpleDateFormat.prototype.setMinimalDaysInFirstWeek = function(days) {
this.minimalDaysInFirstWeek = days;
};
SimpleDateFormat.prototype.getMinimalDaysInFirstWeek = function() {
return isUndefined(this.minimalDaysInFirstWeek) ? DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK : this.minimalDaysInFirstWeek;
};
var padWithZeroes = function(str, len2) {
while (str.length < len2) {
str = "0" + str;
}
return str;
};
var formatText = function(data, numberOfLetters, minLength) {
return numberOfLetters >= 4 ? data : data.substr(0, Math.max(minLength, numberOfLetters));
};
var formatNumber = function(data, numberOfLetters) {
var dataString = "" + data;
return padWithZeroes(dataString, numberOfLetters);
};
SimpleDateFormat.prototype.format = function(date) {
var formattedString = "";
var result;
var searchString = this.formatString;
while (result = regex.exec(searchString)) {
var quotedString = result[1];
var patternLetters = result[2];
var otherLetters = result[3];
var otherCharacters = result[4];
if (quotedString) {
if (quotedString == "''") {
formattedString += "'";
} else {
formattedString += quotedString.substring(1, quotedString.length - 1);
}
} else if (otherLetters) {
} else if (otherCharacters) {
formattedString += otherCharacters;
} else if (patternLetters) {
var patternLetter = patternLetters.charAt(0);
var numberOfLetters = patternLetters.length;
var rawData = "";
switch (patternLetter) {
case "G":
rawData = "AD";
break;
case "y":
rawData = date.getFullYear();
break;
case "M":
rawData = date.getMonth();
break;
case "w":
rawData = date.getWeekInYear(this.getMinimalDaysInFirstWeek());
break;
case "W":
rawData = date.getWeekInMonth(this.getMinimalDaysInFirstWeek());
break;
case "D":
rawData = date.getDayInYear();
break;
case "d":
rawData = date.getDate();
break;
case "F":
rawData = 1 + Math.floor((date.getDate() - 1) / 7);
break;
case "E":
rawData = dayNames[date.getDay()];
break;
case "a":
rawData = date.getHours() >= 12 ? "PM" : "AM";
break;
case "H":
rawData = date.getHours();
break;
case "k":
rawData = date.getHours() || 24;
break;
case "K":
rawData = date.getHours() % 12;
break;
case "h":
rawData = date.getHours() % 12 || 12;
break;
case "m":
rawData = date.getMinutes();
break;
case "s":
rawData = date.getSeconds();
break;
case "S":
rawData = date.getMilliseconds();
break;
case "Z":
rawData = date.getTimezoneOffset();
break;
}
switch (types[patternLetter]) {
case TEXT2:
formattedString += formatText(rawData, numberOfLetters, 2);
break;
case TEXT3:
formattedString += formatText(rawData, numberOfLetters, 3);
break;
case NUMBER:
formattedString += formatNumber(rawData, numberOfLetters);
break;
case YEAR:
if (numberOfLetters <= 3) {
var dataString = "" + rawData;
formattedString += dataString.substr(2, 2);
} else {
formattedString += formatNumber(rawData, numberOfLetters);
}
break;
case MONTH:
if (numberOfLetters >= 3) {
formattedString += formatText(monthNames[rawData], numberOfLetters, numberOfLetters);
} else {
formattedString += formatNumber(rawData + 1, numberOfLetters);
}
break;
case TIMEZONE:
var isPositive = rawData > 0;
var prefix = isPositive ? "-" : "+";
var absData = Math.abs(rawData);
var hours = "" + Math.floor(absData / 60);
hours = padWithZeroes(hours, 2);
var minutes = "" + absData % 60;
minutes = padWithZeroes(minutes, 2);
formattedString += prefix + hours + minutes;
break;
}
}
searchString = searchString.substr(result.index + result[0].length);
}
return formattedString;
};
})();
log4javascript.SimpleDateFormat = SimpleDateFormat;
function PatternLayout(pattern) {
if (pattern) {
this.pattern = pattern;
} else {
this.pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
}
this.customFields = [];
}
PatternLayout.TTCC_CONVERSION_PATTERN = "%r %p %c - %m%n";
PatternLayout.DEFAULT_CONVERSION_PATTERN = "%m%n";
PatternLayout.ISO8601_DATEFORMAT = "yyyy-MM-dd HH:mm:ss,SSS";
PatternLayout.DATETIME_DATEFORMAT = "dd MMM yyyy HH:mm:ss,SSS";
PatternLayout.ABSOLUTETIME_DATEFORMAT = "HH:mm:ss,SSS";
PatternLayout.prototype = new Layout();
PatternLayout.prototype.format = function(loggingEvent) {