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

   1 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; }; }();
   2
   3 var _templateObject = _taggedTemplateLiteral(['', ''], ['', '']);
   4
   5 function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
   6
   7 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
   8
   9 /**
  10  * @class TemplateTag
  11  * @classdesc Consumes a pipeline of composable transformer plugins and produces a template tag.
  12  */
  13 var TemplateTag = function () {
  14   /**
  15    * constructs a template tag
  16    * @constructs TemplateTag
  17    * @param  {...Object} [...transformers] - an array or arguments list of transformers
  18    * @return {Function}                    - a template tag
  19    */
  20   function TemplateTag() {
  21     var _this = this;
  22
  23     for (var _len = arguments.length, transformers = Array(_len), _key = 0; _key < _len; _key++) {
  24       transformers[_key] = arguments[_key];
  25     }
  26
  27     _classCallCheck(this, TemplateTag);
  28
  29     this.tag = function (strings) {
  30       for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
  31         expressions[_key2 - 1] = arguments[_key2];
  32       }
  33
  34       if (typeof strings === 'function') {
  35         // if the first argument passed is a function, assume it is a template tag and return
  36         // an intermediary tag that processes the template using the aforementioned tag, passing the
  37         // result to our tag
  38         return _this.interimTag.bind(_this, strings);
  39       }
  40
  41       if (typeof strings === 'string') {
  42         // if the first argument passed is a string, just transform it
  43         return _this.transformEndResult(strings);
  44       }
  45
  46       // else, return a transformed end result of processing the template with our tag
  47       strings = strings.map(_this.transformString.bind(_this));
  48       return _this.transformEndResult(strings.reduce(_this.processSubstitutions.bind(_this, expressions)));
  49     };
  50
  51     // if first argument is an array, extrude it as a list of transformers
  52     if (transformers.length > 0 && Array.isArray(transformers[0])) {
  53       transformers = transformers[0];
  54     }
  55
  56     // if any transformers are functions, this means they are not initiated - automatically initiate them
  57     this.transformers = transformers.map(function (transformer) {
  58       return typeof transformer === 'function' ? transformer() : transformer;
  59     });
  60
  61     // return an ES2015 template tag
  62     return this.tag;
  63   }
  64
  65   /**
  66    * Applies all transformers to a template literal tagged with this method.
  67    * If a function is passed as the first argument, assumes the function is a template tag
  68    * and applies it to the template, returning a template tag.
  69    * @param  {(Function|String|Array<String>)} strings        - Either a template tag or an array containing template strings separated by identifier
  70    * @param  {...*}                            ...expressions - Optional list of substitution values.
  71    * @return {(String|Function)}                              - Either an intermediary tag function or the results of processing the template.
  72    */
  73
  74
  75   _createClass(TemplateTag, [{
  76     key: 'interimTag',
  77
  78
  79     /**
  80      * An intermediary template tag that receives a template tag and passes the result of calling the template with the received
  81      * template tag to our own template tag.
  82      * @param  {Function}        nextTag          - the received template tag
  83      * @param  {Array<String>}   template         - the template to process
  84      * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template
  85      * @return {*}                                - the final processed value
  86      */
  87     value: function interimTag(previousTag, template) {
  88       for (var _len3 = arguments.length, substitutions = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
  89         substitutions[_key3 - 2] = arguments[_key3];
  90       }
  91
  92       return this.tag(_templateObject, previousTag.apply(undefined, [template].concat(substitutions)));
  93     }
  94
  95     /**
  96      * Performs bulk processing on the tagged template, transforming each substitution and then
  97      * concatenating the resulting values into a string.
  98      * @param  {Array<*>} substitutions - an array of all remaining substitutions present in this template
  99      * @param  {String}   resultSoFar   - this iteration's result string so far
 100      * @param  {String}   remainingPart - the template chunk after the current substitution
 101      * @return {String}                 - the result of joining this iteration's processed substitution with the result
 102      */
 103
 104   }, {
 105     key: 'processSubstitutions',
 106     value: function processSubstitutions(substitutions, resultSoFar, remainingPart) {
 107       var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
 108       return ''.concat(resultSoFar, substitution, remainingPart);
 109     }
 110
 111     /**
 112      * Iterate through each transformer, applying the transformer's `onString` method to the template
 113      * strings before all substitutions are processed.
 114      * @param {String}  str - The input string
 115      * @return {String}     - The final results of processing each transformer
 116      */
 117
 118   }, {
 119     key: 'transformString',
 120     value: function transformString(str) {
 121       var cb = function cb(res, transform) {
 122         return transform.onString ? transform.onString(res) : res;
 123       };
 124       return this.transformers.reduce(cb, str);
 125     }
 126
 127     /**
 128      * When a substitution is encountered, iterates through each transformer and applies the transformer's
 129      * `onSubstitution` method to the substitution.
 130      * @param  {*}      substitution - The current substitution
 131      * @param  {String} resultSoFar  - The result up to and excluding this substitution.
 132      * @return {*}                   - The final result of applying all substitution transformations.
 133      */
 134
 135   }, {
 136     key: 'transformSubstitution',
 137     value: function transformSubstitution(substitution, resultSoFar) {
 138       var cb = function cb(res, transform) {
 139         return transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res;
 140       };
 141       return this.transformers.reduce(cb, substitution);
 142     }
 143
 144     /**
 145      * Iterates through each transformer, applying the transformer's `onEndResult` method to the
 146      * template literal after all substitutions have finished processing.
 147      * @param  {String} endResult - The processed template, just before it is returned from the tag
 148      * @return {String}           - The final results of processing each transformer
 149      */
 150
 151   }, {
 152     key: 'transformEndResult',
 153     value: function transformEndResult(endResult) {
 154       var cb = function cb(res, transform) {
 155         return transform.onEndResult ? transform.onEndResult(res) : res;
 156       };
 157       return this.transformers.reduce(cb, endResult);
 158     }
 159   }]);
 160
 161   return TemplateTag;
 162 }();
 163
 164 export default TemplateTag;
 165 //# 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;;;;;;eAnHkB/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"]}