Your IP : 216.73.216.86
/* eslint-disable */
this.BX = this.BX || {};
this.BX.UI = this.BX.UI || {};
(function (exports,ui_bbcode_parser,main_core,ui_bbcode_model) {
'use strict';
const nameSymbol = Symbol('name');
const groupSymbol = Symbol('group');
const validateSymbol = Symbol('validate');
const beforeSymbol = Symbol('before');
const convertSymbol = Symbol('convert');
const forChildSymbol = Symbol('forChild');
const afterSymbol = Symbol('after');
const formatterSymbol = Symbol('formatter');
const defaultValidator = () => true;
const defaultNodeConverter = ({
node
}) => node;
const defaultElementConverter = ({
element
}) => element;
class NodeFormatter {
constructor(options = {}) {
this[nameSymbol] = 'unknown';
this[groupSymbol] = null;
this[beforeSymbol] = null;
this[convertSymbol] = null;
this[forChildSymbol] = null;
this[afterSymbol] = null;
if (main_core.Type.isArray(options.name)) {
this[groupSymbol] = [...options.name];
} else {
this.setName(options.name);
}
if (!main_core.Type.isNil(options.formatter)) {
this.setFormatter(options.formatter);
}
this.setValidate(options.validate);
this.setBefore(options.before);
this.setConvert(options.convert);
this.setForChild(options.forChild);
this.setAfter(options.after);
}
setName(name) {
if (!main_core.Type.isStringFilled(name)) {
throw new TypeError('Name is not a string');
}
this[nameSymbol] = name;
}
getName() {
return this[nameSymbol];
}
setValidate(callback) {
if (main_core.Type.isFunction(callback)) {
this[validateSymbol] = callback;
} else {
this[validateSymbol] = defaultValidator;
}
}
validate(options) {
const result = this[validateSymbol](options);
if (main_core.Type.isBoolean(result)) {
return result;
}
throw new TypeError(`Validate callback for "${this.getName()}" returned not boolean`);
}
setBefore(callback) {
if (main_core.Type.isFunction(callback)) {
this[beforeSymbol] = callback;
} else {
this[beforeSymbol] = defaultNodeConverter;
}
}
runBefore(options) {
return this[beforeSymbol](options);
}
setConvert(callback) {
if (!main_core.Type.isFunction(callback)) {
throw new TypeError('Convert is not a function');
}
this[convertSymbol] = callback;
}
runConvert(options) {
return this[convertSymbol](options);
}
setForChild(callback) {
if (main_core.Type.isFunction(callback)) {
this[forChildSymbol] = callback;
} else {
this[forChildSymbol] = defaultElementConverter;
}
}
runForChild(options) {
return this[forChildSymbol](options);
}
setAfter(callback) {
if (main_core.Type.isFunction(callback)) {
this[afterSymbol] = callback;
} else {
this[afterSymbol] = defaultElementConverter;
}
}
runAfter(options) {
return this[afterSymbol](options);
}
setFormatter(formatter) {
this[formatterSymbol] = formatter;
}
getFormatter() {
return this[formatterSymbol];
}
}
const formattersSymbol = Symbol('formatters');
const onUnknownSymbol = Symbol('onUnknown');
const dataSymbol = Symbol('data');
/**
* @memberOf BX.UI.BBCode
*/
class Formatter {
constructor(options = {}) {
this[formattersSymbol] = new Map();
this[onUnknownSymbol] = null;
this[dataSymbol] = null;
this.setNodeFormatters(options.formatters);
if (main_core.Type.isNil(options.onUnknown)) {
this.setOnUnknown(this.getDefaultUnknownNodeCallback());
} else {
this.setOnUnknown(options.onUnknown);
}
}
isElement(source) {
return main_core.Type.isObject(source) && main_core.Type.isFunction(source.appendChild);
}
static prepareSourceNode(source) {
if (source instanceof ui_bbcode_model.BBCodeNode) {
return source;
}
if (main_core.Type.isString(source)) {
return new ui_bbcode_parser.BBCodeParser().parse(source);
}
return null;
}
setData(data) {
this[dataSymbol] = data;
}
getData() {
return this[dataSymbol];
}
setNodeFormatters(formatters) {
if (main_core.Type.isArrayFilled(formatters)) {
formatters.forEach(formatter => {
this.setNodeFormatter(formatter);
});
}
}
setNodeFormatter(formatter) {
if (formatter instanceof NodeFormatter) {
this[formattersSymbol].set(formatter.getName(), formatter);
} else {
throw new TypeError('formatter is not a NodeFormatter instance.');
}
}
getDefaultUnknownNodeCallback() {
throw new TypeError('Must be implemented in subclass');
}
setOnUnknown(callback) {
if (main_core.Type.isFunction(callback)) {
this[onUnknownSymbol] = callback;
} else {
throw new TypeError('OnUnknown callback is not a function.');
}
}
runOnUnknown(options) {
const result = this[onUnknownSymbol](options);
if (result instanceof NodeFormatter || main_core.Type.isNull(result)) {
return result;
}
throw new TypeError('OnUnknown callback returned not NodeFormatter instance or null.');
}
getNodeFormatter(node) {
const formatter = this[formattersSymbol].get(node.getName());
if (formatter instanceof NodeFormatter) {
return formatter;
}
return this.runOnUnknown({
node,
formatter: this
});
}
getNodeFormatters() {
return this[formattersSymbol];
}
format(options) {
if (!main_core.Type.isPlainObject(options)) {
throw new TypeError('options is not a object');
}
const {
source,
data = {}
} = options;
if (!main_core.Type.isUndefined(data) && !main_core.Type.isPlainObject(data)) {
throw new TypeError('options.data is not a object');
}
this.setData(data);
const sourceNode = Formatter.prepareSourceNode(source);
if (main_core.Type.isNull(sourceNode)) {
throw new TypeError('options.source is not a BBCodeNode or string');
}
const nodeFormatter = this.getNodeFormatter(sourceNode);
const isValidNode = nodeFormatter.validate({
node: sourceNode,
formatter: this,
data
});
if (!isValidNode) {
return null;
}
const preparedNode = nodeFormatter.runBefore({
node: sourceNode,
formatter: this,
data
});
if (main_core.Type.isNull(preparedNode)) {
return null;
}
const convertedElement = nodeFormatter.runConvert({
node: preparedNode,
formatter: this,
data
});
if (main_core.Type.isNull(convertedElement)) {
return null;
}
preparedNode.getChildren().forEach(childNode => {
const childElement = this.format({
source: childNode,
data
});
if (childElement !== null) {
const convertedChildElement = nodeFormatter.runForChild({
node: childNode,
element: childElement,
formatter: this,
data
});
if (convertedChildElement !== null && this.isElement(convertedElement)) {
convertedElement.appendChild(convertedChildElement);
}
}
});
return nodeFormatter.runAfter({
node: preparedNode,
element: convertedElement,
formatter: this,
data
});
}
}
exports.Formatter = Formatter;
exports.NodeFormatter = NodeFormatter;
}((this.BX.UI.BBCode = this.BX.UI.BBCode || {}),BX.UI.BBCode,BX,BX.UI.BBCode));
//# sourceMappingURL=formatter.bundle.js.map