import { flat } from '../utils';
var tagTransformersSymbol = 'COMMON_TAGS_TAG_TRANSFORMERS_SYMBOL';

function isTag(fn) {
  return typeof fn === 'function' && fn[tagTransformersSymbol];
}

function cleanTransformers(transformers) {
  return flat(transformers).reduce(function (transformers, transformer) {
    return isTag(transformer) ? [].concat(transformers, transformer[tagTransformersSymbol]) : [].concat(transformers, [transformer]);
  }, []);
}
/**
 * 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
 */


function getInterimTag(originalTag, extraTag) {
  return function tag() {
    return originalTag(['', ''], extraTag.apply(void 0, arguments));
  };
}

function getTagCallInfo(transformers) {
  return {
    transformers: transformers,
    context: transformers.map(function (transformer) {
      return transformer.getInitialContext ? transformer.getInitialContext() : {};
    })
  };
}
/**
 * Iterate through each transformer, calling the transformer's specified hook.
 * @param {Array<Function>} transformers - The transformer functions
 * @param {String} hookName              - The name of the hook
 * @param {String} initialString         - The input string
 * @return {String}                      - The final results of applying each transformer
 */


function applyHook0(_ref, hookName, initialString) {
  var transformers = _ref.transformers,
      context = _ref.context;
  return transformers.reduce(function (result, transformer, index) {
    return transformer[hookName] ? transformer[hookName](result, context[index]) : result;
  }, initialString);
}
/**
 * Iterate through each transformer, calling the transformer's specified hook.
 * @param {Array<Function>} transformers - The transformer functions
 * @param {String} hookName              - The name of the hook
 * @param {String} initialString         - The input string
 * @param {*} arg1                       - An additional argument passed to the hook
 * @return {String}                      - The final results of applying each transformer
 */


function applyHook1(_ref2, hookName, initialString, arg1) {
  var transformers = _ref2.transformers,
      context = _ref2.context;
  return transformers.reduce(function (result, transformer, index) {
    return transformer[hookName] ? transformer[hookName](result, arg1, context[index]) : result;
  }, initialString);
}
/**
 * Consumes a pipeline of composable transformer plugins and produces a template tag.
 * @param  {...Object} [...rawTransformers] - An array or arguments list of transformers
 * @return {Function}                       - A template tag
 */


export default function createTag() {
  for (var _len = arguments.length, rawTransformers = new Array(_len), _key = 0; _key < _len; _key++) {
    rawTransformers[_key] = arguments[_key];
  }

  var transformers = cleanTransformers(rawTransformers);

  function tag(strings) {
    for (var _len2 = arguments.length, expressions = new 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 getInterimTag(tag, strings);
    }

    if (!Array.isArray(strings)) {
      return tag([strings]);
    }

    var tagCallInfo = getTagCallInfo(transformers); // if the first argument is an array, return a transformed end result of processing the template with our tag

    var processedTemplate = strings.map(function (string) {
      return applyHook0(tagCallInfo, 'onString', string);
    }).reduce(function (result, string, index) {
      return ''.concat(result, applyHook1(tagCallInfo, 'onSubstitution', expressions[index - 1], result), string);
    });
    return applyHook0(tagCallInfo, 'onEndResult', processedTemplate);
  }

  tag[tagTransformersSymbol] = transformers;
  return tag;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/createTag/createTag.js"],"names":["flat","tagTransformersSymbol","isTag","fn","cleanTransformers","transformers","reduce","transformer","getInterimTag","originalTag","extraTag","tag","getTagCallInfo","context","map","getInitialContext","applyHook0","hookName","initialString","result","index","applyHook1","arg1","createTag","rawTransformers","strings","expressions","Array","isArray","tagCallInfo","processedTemplate","string","concat"],"mappings":"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","sourcesContent":["import { flat } from '../utils';\n\nconst tagTransformersSymbol = 'COMMON_TAGS_TAG_TRANSFORMERS_SYMBOL';\n\nfunction isTag(fn) {\n  return typeof fn === 'function' && fn[tagTransformersSymbol];\n}\n\nfunction cleanTransformers(transformers) {\n  return flat(transformers).reduce(\n    (transformers, transformer) =>\n      isTag(transformer)\n        ? [...transformers, ...transformer[tagTransformersSymbol]]\n        : [...transformers, transformer],\n    [],\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 */\nfunction getInterimTag(originalTag, extraTag) {\n  return function tag(...args) {\n    return originalTag(['', ''], extraTag(...args));\n  };\n}\n\nfunction getTagCallInfo(transformers) {\n  return {\n    transformers,\n    context: transformers.map(transformer =>\n      transformer.getInitialContext ? transformer.getInitialContext() : {},\n    ),\n  };\n}\n\n/**\n * Iterate through each transformer, calling the transformer's specified hook.\n * @param {Array<Function>} transformers - The transformer functions\n * @param {String} hookName              - The name of the hook\n * @param {String} initialString         - The input string\n * @return {String}                      - The final results of applying each transformer\n */\nfunction applyHook0({ transformers, context }, hookName, initialString) {\n  return transformers.reduce(\n    (result, transformer, index) =>\n      transformer[hookName]\n        ? transformer[hookName](result, context[index])\n        : result,\n    initialString,\n  );\n}\n\n/**\n * Iterate through each transformer, calling the transformer's specified hook.\n * @param {Array<Function>} transformers - The transformer functions\n * @param {String} hookName              - The name of the hook\n * @param {String} initialString         - The input string\n * @param {*} arg1                       - An additional argument passed to the hook\n * @return {String}                      - The final results of applying each transformer\n */\nfunction applyHook1({ transformers, context }, hookName, initialString, arg1) {\n  return transformers.reduce(\n    (result, transformer, index) =>\n      transformer[hookName]\n        ? transformer[hookName](result, arg1, context[index])\n        : result,\n    initialString,\n  );\n}\n\n/**\n * Consumes a pipeline of composable transformer plugins and produces a template tag.\n * @param  {...Object} [...rawTransformers] - An array or arguments list of transformers\n * @return {Function}                       - A template tag\n */\nexport default function createTag(...rawTransformers) {\n  const transformers = cleanTransformers(rawTransformers);\n\n  function 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 getInterimTag(tag, strings);\n    }\n\n    if (!Array.isArray(strings)) {\n      return tag([strings]);\n    }\n\n    const tagCallInfo = getTagCallInfo(transformers);\n\n    // if the first argument is an array, return a transformed end result of processing the template with our tag\n    const processedTemplate = strings\n      .map(string => applyHook0(tagCallInfo, 'onString', string))\n      .reduce((result, string, index) =>\n        ''.concat(\n          result,\n          applyHook1(\n            tagCallInfo,\n            'onSubstitution',\n            expressions[index - 1],\n            result,\n          ),\n          string,\n        ),\n      );\n\n    return applyHook0(tagCallInfo, 'onEndResult', processedTemplate);\n  }\n\n  tag[tagTransformersSymbol] = transformers;\n\n  return tag;\n}\n"]}