'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); var _taggedTemplateLiteral2 = require('babel-runtime/helpers/taggedTemplateLiteral'); var _taggedTemplateLiteral3 = _interopRequireDefault(_taggedTemplateLiteral2); var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); var _createClass2 = require('babel-runtime/helpers/createClass'); var _createClass3 = _interopRequireDefault(_createClass2); var _templateObject = (0, _taggedTemplateLiteral3.default)(['', ''], ['', '']); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } /** * @class TemplateTag * @classdesc Consumes a pipeline of composable transformer plugins and produces a template tag. */ var TemplateTag = function () { /** * constructs a template tag * @constructs TemplateTag * @param {...Object} [...transformers] - an array or arguments list of transformers * @return {Function} - a template tag */ function TemplateTag() { var _this = this; for (var _len = arguments.length, transformers = Array(_len), _key = 0; _key < _len; _key++) { transformers[_key] = arguments[_key]; } (0, _classCallCheck3.default)(this, TemplateTag); this.tag = function (strings) { for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { expressions[_key2 - 1] = arguments[_key2]; } if (typeof strings === 'function') { // if the first argument passed is a function, assume it is a template tag and return // an intermediary tag that processes the template using the aforementioned tag, passing the // result to our tag return _this.interimTag.bind(_this, strings); } if (typeof strings === 'string') { // if the first argument passed is a string, just transform it return _this.transformEndResult(strings); } // else, return a transformed end result of processing the template with our tag strings = strings.map(_this.transformString.bind(_this)); return _this.transformEndResult(strings.reduce(_this.processSubstitutions.bind(_this, expressions))); }; // if first argument is an array, extrude it as a list of transformers if (transformers.length > 0 && Array.isArray(transformers[0])) { transformers = transformers[0]; } // if any transformers are functions, this means they are not initiated - automatically initiate them this.transformers = transformers.map(function (transformer) { return typeof transformer === 'function' ? transformer() : transformer; }); // return an ES2015 template tag return this.tag; } /** * Applies all transformers to a template literal tagged with this method. * If a function is passed as the first argument, assumes the function is a template tag * and applies it to the template, returning a template tag. * @param {(Function|String|Array<String>)} strings - Either a template tag or an array containing template strings separated by identifier * @param {...*} ...expressions - Optional list of substitution values. * @return {(String|Function)} - Either an intermediary tag function or the results of processing the template. */ (0, _createClass3.default)(TemplateTag, [{ key: 'interimTag', /** * An intermediary template tag that receives a template tag and passes the result of calling the template with the received * template tag to our own template tag. * @param {Function} nextTag - the received template tag * @param {Array<String>} template - the template to process * @param {...*} ...substitutions - `substitutions` is an array of all substitutions in the template * @return {*} - the final processed value */ value: function interimTag(previousTag, template) { for (var _len3 = arguments.length, substitutions = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { substitutions[_key3 - 2] = arguments[_key3]; } return this.tag(_templateObject, previousTag.apply(undefined, [template].concat(substitutions))); } /** * Performs bulk processing on the tagged template, transforming each substitution and then * concatenating the resulting values into a string. * @param {Array<*>} substitutions - an array of all remaining substitutions present in this template * @param {String} resultSoFar - this iteration's result string so far * @param {String} remainingPart - the template chunk after the current substitution * @return {String} - the result of joining this iteration's processed substitution with the result */ }, { key: 'processSubstitutions', value: function processSubstitutions(substitutions, resultSoFar, remainingPart) { var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar); return resultSoFar + substitution + remainingPart; } /** * Iterate through each transformer, applying the transformer's `onString` method to the template * strings before all substitutions are processed. * @param {String} str - The input string * @return {String} - The final results of processing each transformer */ }, { key: 'transformString', value: function transformString(str) { var cb = function cb(res, transform) { return transform.onString ? transform.onString(res) : res; }; return this.transformers.reduce(cb, str); } /** * When a substitution is encountered, iterates through each transformer and applies the transformer's * `onSubstitution` method to the substitution. * @param {*} substitution - The current substitution * @param {String} resultSoFar - The result up to and excluding this substitution. * @return {*} - The final result of applying all substitution transformations. */ }, { key: 'transformSubstitution', value: function transformSubstitution(substitution, resultSoFar) { var cb = function cb(res, transform) { return transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res; }; return this.transformers.reduce(cb, substitution); } /** * Iterates through each transformer, applying the transformer's `onEndResult` method to the * template literal after all substitutions have finished processing. * @param {String} endResult - The processed template, just before it is returned from the tag * @return {String} - The final results of processing each transformer */ }, { key: 'transformEndResult', value: function transformEndResult(endResult) { var cb = function cb(res, transform) { return transform.onEndResult ? transform.onEndResult(res) : res; }; return this.transformers.reduce(cb, endResult); } }]); return TemplateTag; }(); exports.default = TemplateTag; module.exports = exports['default']; //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/TemplateTag/TemplateTag.js"],"names":["TemplateTag","transformers","tag","strings","expressions","interimTag","bind","transformEndResult","map","transformString","reduce","processSubstitutions","length","Array","isArray","transformer","previousTag","template","substitutions","resultSoFar","remainingPart","substitution","transformSubstitution","shift","str","cb","res","transform","onString","onSubstitution","endResult","onEndResult"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;IAIqBA,W;AACnB;;;;;;AAMA,yBAA6B;AAAA;;AAAA,sCAAdC,YAAc;AAAdA,kBAAc;AAAA;;AAAA;;AAAA,SAuB7BC,GAvB6B,GAuBvB,UAACC,OAAD,EAA6B;AAAA,yCAAhBC,WAAgB;AAAhBA,mBAAgB;AAAA;;AACjC,UAAI,OAAOD,OAAP,KAAmB,UAAvB,EAAmC;AACjC;AACA;AACA;AACA,eAAO,MAAKE,UAAL,CAAgBC,IAAhB,QAA2BH,OAA3B,CAAP;AACD;;AAED,UAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;AAC/B;AACA,eAAO,MAAKI,kBAAL,CAAwBJ,OAAxB,CAAP;AACD;;AAED;AACAA,gBAAUA,QAAQK,GAAR,CAAY,MAAKC,eAAL,CAAqBH,IAArB,OAAZ,CAAV;AACA,aAAO,MAAKC,kBAAL,CACLJ,QAAQO,MAAR,CAAe,MAAKC,oBAAL,CAA0BL,IAA1B,QAAqCF,WAArC,CAAf,CADK,CAAP;AAGD,KAzC4B;;AAC3B;AACA,QAAIH,aAAaW,MAAb,GAAsB,CAAtB,IAA2BC,MAAMC,OAAN,CAAcb,aAAa,CAAb,CAAd,CAA/B,EAA+D;AAC7DA,qBAAeA,aAAa,CAAb,CAAf;AACD;;AAED;AACA,SAAKA,YAAL,GAAoBA,aAAaO,GAAb,CAAiB,uBAAe;AAClD,aAAO,OAAOO,WAAP,KAAuB,UAAvB,GAAoCA,aAApC,GAAoDA,WAA3D;AACD,KAFmB,CAApB;;AAIA;AACA,WAAO,KAAKb,GAAZ;AACD;;AAED;;;;;;;;;;;;;;AA4BA;;;;;;;;+BAQWc,W,EAAaC,Q,EAA4B;AAAA,yCAAfC,aAAe;AAAfA,qBAAe;AAAA;;AAClD,aAAO,KAAKhB,GAAZ,kBAAkBc,8BAAYC,QAAZ,SAAyBC,aAAzB,EAAlB;AACD;;AAED;;;;;;;;;;;yCAQqBA,a,EAAeC,W,EAAaC,a,EAAe;AAC9D,UAAMC,eAAe,KAAKC,qBAAL,CACnBJ,cAAcK,KAAd,EADmB,EAEnBJ,WAFmB,CAArB;AAIA,aAAOA,cAAcE,YAAd,GAA6BD,aAApC;AACD;;AAED;;;;;;;;;oCAMgBI,G,EAAK;AACnB,UAAMC,KAAK,SAALA,EAAK,CAACC,GAAD,EAAMC,SAAN;AAAA,eACTA,UAAUC,QAAV,GAAqBD,UAAUC,QAAV,CAAmBF,GAAnB,CAArB,GAA+CA,GADtC;AAAA,OAAX;AAEA,aAAO,KAAKzB,YAAL,CAAkBS,MAAlB,CAAyBe,EAAzB,EAA6BD,GAA7B,CAAP;AACD;;AAED;;;;;;;;;;0CAOsBH,Y,EAAcF,W,EAAa;AAC/C,UAAMM,KAAK,SAALA,EAAK,CAACC,GAAD,EAAMC,SAAN;AAAA,eACTA,UAAUE,cAAV,GACIF,UAAUE,cAAV,CAAyBH,GAAzB,EAA8BP,WAA9B,CADJ,GAEIO,GAHK;AAAA,OAAX;AAIA,aAAO,KAAKzB,YAAL,CAAkBS,MAAlB,CAAyBe,EAAzB,EAA6BJ,YAA7B,CAAP;AACD;;AAED;;;;;;;;;uCAMmBS,S,EAAW;AAC5B,UAAML,KAAK,SAALA,EAAK,CAACC,GAAD,EAAMC,SAAN;AAAA,eACTA,UAAUI,WAAV,GAAwBJ,UAAUI,WAAV,CAAsBL,GAAtB,CAAxB,GAAqDA,GAD5C;AAAA,OAAX;AAEA,aAAO,KAAKzB,YAAL,CAAkBS,MAAlB,CAAyBe,EAAzB,EAA6BK,SAA7B,CAAP;AACD;;;;;kBAnHkB9B,W","file":"TemplateTag.js","sourcesContent":["/**\n * @class TemplateTag\n * @classdesc Consumes a pipeline of composable transformer plugins and produces a template tag.\n */\nexport default class TemplateTag {\n  /**\n   * constructs a template tag\n   * @constructs TemplateTag\n   * @param  {...Object} [...transformers] - an array or arguments list of transformers\n   * @return {Function}                    - a template tag\n   */\n  constructor(...transformers) {\n    // if first argument is an array, extrude it as a list of transformers\n    if (transformers.length > 0 && Array.isArray(transformers[0])) {\n      transformers = transformers[0];\n    }\n\n    // if any transformers are functions, this means they are not initiated - automatically initiate them\n    this.transformers = transformers.map(transformer => {\n      return typeof transformer === 'function' ? transformer() : transformer;\n    });\n\n    // return an ES2015 template tag\n    return this.tag;\n  }\n\n  /**\n   * Applies all transformers to a template literal tagged with this method.\n   * If a function is passed as the first argument, assumes the function is a template tag\n   * and applies it to the template, returning a template tag.\n   * @param  {(Function|String|Array<String>)} strings        - Either a template tag or an array containing template strings separated by identifier\n   * @param  {...*}                            ...expressions - Optional list of substitution values.\n   * @return {(String|Function)}                              - Either an intermediary tag function or the results of processing the template.\n   */\n  tag = (strings, ...expressions) => {\n    if (typeof strings === 'function') {\n      // if the first argument passed is a function, assume it is a template tag and return\n      // an intermediary tag that processes the template using the aforementioned tag, passing the\n      // result to our tag\n      return this.interimTag.bind(this, strings);\n    }\n\n    if (typeof strings === 'string') {\n      // if the first argument passed is a string, just transform it\n      return this.transformEndResult(strings);\n    }\n\n    // else, return a transformed end result of processing the template with our tag\n    strings = strings.map(this.transformString.bind(this));\n    return this.transformEndResult(\n      strings.reduce(this.processSubstitutions.bind(this, expressions)),\n    );\n  };\n\n  /**\n   * An intermediary template tag that receives a template tag and passes the result of calling the template with the received\n   * template tag to our own template tag.\n   * @param  {Function}        nextTag          - the received template tag\n   * @param  {Array<String>}   template         - the template to process\n   * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template\n   * @return {*}                                - the final processed value\n   */\n  interimTag(previousTag, template, ...substitutions) {\n    return this.tag`${previousTag(template, ...substitutions)}`;\n  }\n\n  /**\n   * Performs bulk processing on the tagged template, transforming each substitution and then\n   * concatenating the resulting values into a string.\n   * @param  {Array<*>} substitutions - an array of all remaining substitutions present in this template\n   * @param  {String}   resultSoFar   - this iteration's result string so far\n   * @param  {String}   remainingPart - the template chunk after the current substitution\n   * @return {String}                 - the result of joining this iteration's processed substitution with the result\n   */\n  processSubstitutions(substitutions, resultSoFar, remainingPart) {\n    const substitution = this.transformSubstitution(\n      substitutions.shift(),\n      resultSoFar,\n    );\n    return resultSoFar + substitution + remainingPart;\n  }\n\n  /**\n   * Iterate through each transformer, applying the transformer's `onString` method to the template\n   * strings before all substitutions are processed.\n   * @param {String}  str - The input string\n   * @return {String}     - The final results of processing each transformer\n   */\n  transformString(str) {\n    const cb = (res, transform) =>\n      transform.onString ? transform.onString(res) : res;\n    return this.transformers.reduce(cb, str);\n  }\n\n  /**\n   * When a substitution is encountered, iterates through each transformer and applies the transformer's\n   * `onSubstitution` method to the substitution.\n   * @param  {*}      substitution - The current substitution\n   * @param  {String} resultSoFar  - The result up to and excluding this substitution.\n   * @return {*}                   - The final result of applying all substitution transformations.\n   */\n  transformSubstitution(substitution, resultSoFar) {\n    const cb = (res, transform) =>\n      transform.onSubstitution\n        ? transform.onSubstitution(res, resultSoFar)\n        : res;\n    return this.transformers.reduce(cb, substitution);\n  }\n\n  /**\n   * Iterates through each transformer, applying the transformer's `onEndResult` method to the\n   * template literal after all substitutions have finished processing.\n   * @param  {String} endResult - The processed template, just before it is returned from the tag\n   * @return {String}           - The final results of processing each transformer\n   */\n  transformEndResult(endResult) {\n    const cb = (res, transform) =>\n      transform.onEndResult ? transform.onEndResult(res) : res;\n    return this.transformers.reduce(cb, endResult);\n  }\n}\n"]}