.config/coc/extensions/node_modules/coc-prettier/node_modules/common-tags/lib/TemplateTag/TemplateTag.js

   1 'use strict';
   2
   3 Object.defineProperty(exports, "__esModule", {
   4   value: true
   5 });
   6
   7 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
   8
   9 var _templateObject = _taggedTemplateLiteral(['', ''], ['', '']);
  10
  11 function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
  12
  13 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  14
  15 /**
  16  * @class TemplateTag
  17  * @classdesc Consumes a pipeline of composable transformer plugins and produces a template tag.
  18  */
  19 var TemplateTag = function () {
  20   /**
  21    * constructs a template tag
  22    * @constructs TemplateTag
  23    * @param  {...Object} [...transformers] - an array or arguments list of transformers
  24    * @return {Function}                    - a template tag
  25    */
  26   function TemplateTag() {
  27     var _this = this;
  28
  29     for (var _len = arguments.length, transformers = Array(_len), _key = 0; _key < _len; _key++) {
  30       transformers[_key] = arguments[_key];
  31     }
  32
  33     _classCallCheck(this, TemplateTag);
  34
  35     this.tag = function (strings) {
  36       for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
  37         expressions[_key2 - 1] = arguments[_key2];
  38       }
  39
  40       if (typeof strings === 'function') {
  41         // if the first argument passed is a function, assume it is a template tag and return
  42         // an intermediary tag that processes the template using the aforementioned tag, passing the
  43         // result to our tag
  44         return _this.interimTag.bind(_this, strings);
  45       }
  46
  47       if (typeof strings === 'string') {
  48         // if the first argument passed is a string, just transform it
  49         return _this.transformEndResult(strings);
  50       }
  51
  52       // else, return a transformed end result of processing the template with our tag
  53       strings = strings.map(_this.transformString.bind(_this));
  54       return _this.transformEndResult(strings.reduce(_this.processSubstitutions.bind(_this, expressions)));
  55     };
  56
  57     // if first argument is an array, extrude it as a list of transformers
  58     if (transformers.length > 0 && Array.isArray(transformers[0])) {
  59       transformers = transformers[0];
  60     }
  61
  62     // if any transformers are functions, this means they are not initiated - automatically initiate them
  63     this.transformers = transformers.map(function (transformer) {
  64       return typeof transformer === 'function' ? transformer() : transformer;
  65     });
  66
  67     // return an ES2015 template tag
  68     return this.tag;
  69   }
  70
  71   /**
  72    * Applies all transformers to a template literal tagged with this method.
  73    * If a function is passed as the first argument, assumes the function is a template tag
  74    * and applies it to the template, returning a template tag.
  75    * @param  {(Function|String|Array<String>)} strings        - Either a template tag or an array containing template strings separated by identifier
  76    * @param  {...*}                            ...expressions - Optional list of substitution values.
  77    * @return {(String|Function)}                              - Either an intermediary tag function or the results of processing the template.
  78    */
  79
  80
  81   _createClass(TemplateTag, [{
  82     key: 'interimTag',
  83
  84
  85     /**
  86      * An intermediary template tag that receives a template tag and passes the result of calling the template with the received
  87      * template tag to our own template tag.
  88      * @param  {Function}        nextTag          - the received template tag
  89      * @param  {Array<String>}   template         - the template to process
  90      * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template
  91      * @return {*}                                - the final processed value
  92      */
  93     value: function interimTag(previousTag, template) {
  94       for (var _len3 = arguments.length, substitutions = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
  95         substitutions[_key3 - 2] = arguments[_key3];
  96       }
  97
  98       return this.tag(_templateObject, previousTag.apply(undefined, [template].concat(substitutions)));
  99     }
 100
 101     /**
 102      * Performs bulk processing on the tagged template, transforming each substitution and then
 103      * concatenating the resulting values into a string.
 104      * @param  {Array<*>} substitutions - an array of all remaining substitutions present in this template
 105      * @param  {String}   resultSoFar   - this iteration's result string so far
 106      * @param  {String}   remainingPart - the template chunk after the current substitution
 107      * @return {String}                 - the result of joining this iteration's processed substitution with the result
 108      */
 109
 110   }, {
 111     key: 'processSubstitutions',
 112     value: function processSubstitutions(substitutions, resultSoFar, remainingPart) {
 113       var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
 114       return ''.concat(resultSoFar, substitution, remainingPart);
 115     }
 116
 117     /**
 118      * Iterate through each transformer, applying the transformer's `onString` method to the template
 119      * strings before all substitutions are processed.
 120      * @param {String}  str - The input string
 121      * @return {String}     - The final results of processing each transformer
 122      */
 123
 124   }, {
 125     key: 'transformString',
 126     value: function transformString(str) {
 127       var cb = function cb(res, transform) {
 128         return transform.onString ? transform.onString(res) : res;
 129       };
 130       return this.transformers.reduce(cb, str);
 131     }
 132
 133     /**
 134      * When a substitution is encountered, iterates through each transformer and applies the transformer's
 135      * `onSubstitution` method to the substitution.
 136      * @param  {*}      substitution - The current substitution
 137      * @param  {String} resultSoFar  - The result up to and excluding this substitution.
 138      * @return {*}                   - The final result of applying all substitution transformations.
 139      */
 140
 141   }, {
 142     key: 'transformSubstitution',
 143     value: function transformSubstitution(substitution, resultSoFar) {
 144       var cb = function cb(res, transform) {
 145         return transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res;
 146       };
 147       return this.transformers.reduce(cb, substitution);
 148     }
 149
 150     /**
 151      * Iterates through each transformer, applying the transformer's `onEndResult` method to the
 152      * template literal after all substitutions have finished processing.
 153      * @param  {String} endResult - The processed template, just before it is returned from the tag
 154      * @return {String}           - The final results of processing each transformer
 155      */
 156
 157   }, {
 158     key: 'transformEndResult',
 159     value: function transformEndResult(endResult) {
 160       var cb = function cb(res, transform) {
 161         return transform.onEndResult ? transform.onEndResult(res) : res;
 162       };
 163       return this.transformers.reduce(cb, endResult);
 164     }
 165   }]);
 166
 167   return TemplateTag;
 168 }();
 169
 170 exports.default = TemplateTag;
 171 module.exports = exports['default'];
 172 //# 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","concat","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,CAAqB,KAArB,EAA2BH,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,CAA0B,KAA1B,CAAZ,CAAV;AACA,aAAO,MAAKC,kBAAL,CACLJ,QAAQO,MAAR,CAAe,MAAKC,oBAAL,CAA0BL,IAA1B,CAA+B,KAA/B,EAAqCF,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,aAAO,GAAGK,MAAH,CAAUL,WAAV,EAAuBE,YAAvB,EAAqCD,aAArC,CAAP;AACD;;AAED;;;;;;;;;oCAMgBK,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,KAAK1B,YAAL,CAAkBS,MAAlB,CAAyBgB,EAAzB,EAA6BD,GAA7B,CAAP;AACD;;AAED;;;;;;;;;;0CAOsBJ,Y,EAAcF,W,EAAa;AAC/C,UAAMO,KAAK,SAALA,EAAK,CAACC,GAAD,EAAMC,SAAN;AAAA,eACTA,UAAUE,cAAV,GACIF,UAAUE,cAAV,CAAyBH,GAAzB,EAA8BR,WAA9B,CADJ,GAEIQ,GAHK;AAAA,OAAX;AAIA,aAAO,KAAK1B,YAAL,CAAkBS,MAAlB,CAAyBgB,EAAzB,EAA6BL,YAA7B,CAAP;AACD;;AAED;;;;;;;;;uCAMmBU,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,KAAK1B,YAAL,CAAkBS,MAAlB,CAAyBgB,EAAzB,EAA6BK,SAA7B,CAAP;AACD;;;;;;kBAnHkB/B,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 ''.concat(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"]}