concatenater/index.js

Concatenate string

'use strict';

const concatenater = (...params) => {

	let _concatenater;

	const source = {
		default: ''
	};


	let target = 'default';
	let dataSources

	const handleParams = _handleParams.bind(_concatenater)
	const getValue = () => source[target]

	_concatenater = {
		set(value) {
			if (dataSources) {
				value = replaceFromObject(value, dataSources.default)
			}
			source[target] = value;
			return this;
		},
		append(...params) {
			const valueHandler = value => this.set(getValue() + value);
			handleParams(params, valueHandler)
			return this;
		},
		prepend(value) {
			this.set(value + getValue());
			return this;
		},
		surround(valueBefore, valueAfter) {
			this.set(valueBefore + getValue() + valueAfter);
			return this;
		},
		frame(value, match = '...') {
			this.set(value.replace(match, getValue()));
			return this;
		},
		replace(...params) {
			switch (params.length) {
				case 1:
					this.set(replaceFromObject(getValue(), params[0]));
					break;
				case 2:
					this.set(replaceKeyValue(getValue(), params[0], params[1]));
					break;
			}
			return this
		},
		clone() {
			return concatenater(this.toString());
		},
		toString() {
			return getValue();
		},
		source(sourceMap) {
			if (!dataSources) {
				dataSources = {
					default: {}
				}
			}
			Object.keys(sourceMap).forEach(key => {
				dataSources.default[`{${key}}`] = sourceMap[key];
			})
			return this
		},

		appendFormat(value, ...params) {
			params.forEach((param, index) => {
				value = replaceKeyValue(value, `\\[${index}\\]`, param, {
					regExpParams: 'gi'
				})
			})
			this.append(value)
			return this
		},

		n(times) {
			Array(times).fill().forEach((_, index) => {
				this.append('\n')
			})
			return this
		}
	};

	_concatenater.append(...params)

	return _concatenater
};

const replaceFromObject = (string, object, options = {}) => {
	Object.keys(object).forEach(key =>
		string = replaceKeyValue(string, key, object[key]), options)
	return string
}

const replaceKeyValue = (string, key, value, options = {}) => {
	string = string.replace(
		new RegExp(key, options.regExpParams),
		value)
	return string
}


concatenater.replaceFromObject = replaceFromObject
concatenater.replaceKeyValue = replaceKeyValue

concatenater.default = {
	replaceFromObject,
	replaceKeyValue
}

module.exports = concatenater

const _handleParams = (params, valueHandler) => {
	for (let i = 0; i < params.length; i++) {
		let value = params[i];

		if (value === false) break;
		if (value === true) continue;

		let type = typeof value

		if (type == 'string' || type == 'number') {
			valueHandler(value)
		}
		if (type == 'function') {
			let result = value(this)
			if (value === false) break;
			if (value === true) continue;
			valueHandler(result)
		}
	}
}