@nativescript/core
Version:
A JavaScript library providing an easy to use api for interacting with iOS and Android platform APIs.
255 lines • 8.59 kB
JavaScript
let enabled = false;
let _categories = {};
const _writers = [];
const _eventListeners = [];
let _errorHandler;
export var Trace;
(function (Trace) {
/**
* Enables the trace module.
*/
function enable() {
enabled = true;
}
Trace.enable = enable;
/**
* Disables the trace module.
*/
function disable() {
enabled = false;
}
Trace.disable = disable;
/**
* A function that returns whether the tracer is enabled and there is a point in writing messages.
* Check this to avoid writing complex string templates.
* Send error messages even if tracing is disabled.
*/
function isEnabled() {
return enabled;
}
Trace.isEnabled = isEnabled;
/**
* Adds a TraceWriter instance to the trace module.
* @param writer The TraceWriter instance to add.
*/
function addWriter(writer) {
_writers.push(writer);
}
Trace.addWriter = addWriter;
/**
* Removes a TraceWriter instance from the trace module.
* @param writer The TraceWriter instance to remove.
*/
function removeWriter(writer) {
const index = _writers.indexOf(writer);
if (index >= 0) {
_writers.splice(index, 1);
}
}
Trace.removeWriter = removeWriter;
/**
* Clears all the writers from the trace module.
*/
function clearWriters() {
if (_writers.length > 0) {
_writers.splice(0, _writers.length);
}
}
Trace.clearWriters = clearWriters;
/**
* Sets the categories the module will trace.
* @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
*/
function setCategories(categories) {
_categories = {};
addCategories(categories);
}
Trace.setCategories = setCategories;
/**
* Adds categories to existing categories the module will trace.
* @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
*/
function addCategories(categories) {
const split = categories.split(',');
for (let i = 0; i < split.length; i++) {
_categories[split[i].trim()] = true;
}
}
Trace.addCategories = addCategories;
/**
* Check if category is already set in trace module.
* @param category The category to check.
*/
function isCategorySet(category) {
return category in _categories;
}
Trace.isCategorySet = isCategorySet;
/**
* Writes a message using the available writers.
* @param message The message to be written.
* @param category The category of the message.
* @param type Optional, the type of the message - info, warning, error.
*/
function write(message, category, type) {
// print error no matter what
let i;
if (type === messageType.error) {
for (i = 0; i < _writers.length; i++) {
_writers[i].write(message, category, type);
}
return;
}
if (!enabled) {
return;
}
if (!(category in _categories)) {
return;
}
for (i = 0; i < _writers.length; i++) {
_writers[i].write(message, category, type);
}
}
Trace.write = write;
/**
* Notifies all the attached listeners for an event that has occurred in the sender object.
* @param object The Object instance that raised the event.
* @param name The name of the raised event.
* @param data An optional parameter that passes the data associated with the event.
*/
function notifyEvent(object, name, data) {
if (!enabled) {
return;
}
let i, listener, filters;
for (i = 0; i < _eventListeners.length; i++) {
listener = _eventListeners[i];
if (listener.filter) {
filters = listener.filter.split(',');
filters.forEach((value) => {
if (value.trim() === name) {
listener.on(object, name, data);
}
});
}
else {
listener.on(object, name, data);
}
}
}
Trace.notifyEvent = notifyEvent;
function addEventListener(listener) {
_eventListeners.push(listener);
}
Trace.addEventListener = addEventListener;
function removeEventListener(listener) {
const index = _eventListeners.indexOf(listener);
if (index >= 0) {
_eventListeners.splice(index, 1);
}
}
Trace.removeEventListener = removeEventListener;
let messageType;
(function (messageType) {
messageType.log = 0;
messageType.info = 1;
messageType.warn = 2;
messageType.error = 3;
})(messageType = Trace.messageType || (Trace.messageType = {}));
/**
* all predefined categories.
*/
let categories;
(function (categories) {
categories.Accessibility = 'Accessibility';
categories.VisualTreeEvents = 'VisualTreeEvents';
categories.Layout = 'Layout';
categories.Style = 'Style';
categories.ViewHierarchy = 'ViewHierarchy';
categories.NativeLifecycle = 'NativeLifecycle';
categories.Debug = 'Debug';
categories.Navigation = 'Navigation';
categories.Test = 'Test';
categories.Binding = 'Binding';
categories.BindingError = 'BindingError';
categories.Error = 'Error';
categories.Animation = 'Animation';
categories.Transition = 'Transition';
categories.Livesync = 'Livesync';
categories.ModuleNameResolver = 'ModuleNameResolver';
categories.MediaQuery = 'MediaQuery';
categories.separator = ',';
categories.All = [categories.VisualTreeEvents, categories.Layout, categories.Style, categories.ViewHierarchy, categories.NativeLifecycle, categories.Debug, categories.Navigation, categories.Test, categories.Binding, categories.Error, categories.Animation, categories.Transition, categories.Livesync, categories.ModuleNameResolver, categories.MediaQuery].join(categories.separator);
function concat(...args) {
let result;
for (let i = 0; i < args.length; i++) {
if (!result) {
result = args[i];
continue;
}
result = result.concat(categories.separator, args[i]);
}
return result;
}
categories.concat = concat;
})(categories = Trace.categories || (Trace.categories = {}));
class ConsoleWriter {
write(message, category, type) {
if (!console) {
return;
}
let msgType;
if (type === undefined) {
msgType = messageType.log;
}
else {
msgType = type;
}
switch (msgType) {
case messageType.log:
console.log(category + ': ' + message);
break;
case messageType.info:
console.info(category + ': ' + message);
break;
case messageType.warn:
console.warn(category + ': ' + message);
break;
case messageType.error:
console.error(category + ': ' + message);
break;
}
}
}
// register a ConsoleWriter by default
addWriter(new ConsoleWriter());
class DefaultErrorHandler {
handlerError(error) {
throw error;
}
}
Trace.DefaultErrorHandler = DefaultErrorHandler;
setErrorHandler(new DefaultErrorHandler());
function getErrorHandler() {
return _errorHandler;
}
Trace.getErrorHandler = getErrorHandler;
function setErrorHandler(handler) {
_errorHandler = handler;
}
Trace.setErrorHandler = setErrorHandler;
/**
* Passes an error to the registered ErrorHandler
* @param error The error to be handled.
*/
function error(error) {
if (!_errorHandler) {
return;
}
if (typeof error === 'string') {
error = new Error(error);
}
_errorHandler.handlerError(error);
}
Trace.error = error;
})(Trace || (Trace = {}));
//# sourceMappingURL=index.js.map