nornj/es/utils/createTmplRule.js

A powerful template engine that can works with React, JSX enhancement or alternative tools.

import nj from '../core';
import * as tools from './tools';

function _createRegExp(reg, mode) {
  return new RegExp(reg, mode);
} //Clear the repeated characters


function _clearRepeat(str) {
  let ret = '',
      i = 0,
      char;
  const l = str.length;

  for (; i < l; i++) {
    char = str[i];

    if (ret.indexOf(char) < 0) {
      ret += char;
    }
  }

  return ret;
}

function _replace$(str) {
  return str.replace(/\$/g, '\\$');
}

function _replaceMinus(str) {
  return str.replace(/-/g, '\\-');
}

function _replaceMulti(str) {
  return str.replace(/\*/g, '\\*');
}

export function createTmplRule(rules = {}, isGlobal) {
  let {
    startRule = '{{',
    endRule = '}}',
    extensionRule = 'n-',
    propRule = 'p-',
    strPropRule = 's',
    templateRule = 'template',
    tagSpRule = '#$@',
    commentRule = '-'
  } = nj.tmplRule;
  const {
    start,
    end,
    extension,
    prop,
    strProp,
    template,
    tagSp,
    comment,
    rawStart,
    rawEnd
  } = rules;

  if (start) {
    startRule = start;
  }

  if (end) {
    endRule = end;
  }

  if (extension) {
    extensionRule = extension;
  }

  if (prop) {
    propRule = prop;
  }

  if (strProp) {
    strPropRule = strProp;
  }

  if (template) {
    templateRule = template;
  }

  if (tagSp) {
    tagSpRule = tagSp;
  }

  if (comment != null) {
    commentRule = comment;
  }

  const firstChar = rawStart != null ? rawStart : startRule[0],
        lastChar = rawEnd != null ? rawEnd : endRule[endRule.length - 1],
        allRules = firstChar + lastChar,
        extensionRules = _replaceMinus(_clearRepeat(extensionRule + propRule + strPropRule + tagSpRule)),
        escapeExtensionRule = _replace$(extensionRule),
        escapePropRule = _replace$(propRule),
        escapeStrPropRule = _replace$(strPropRule),
        startRuleR = firstChar + startRule,
        endRuleR = endRule + lastChar,
        varContent = '[\\s\\S]+?',
        varContentS = '\\.\\.\\.' + varContent,
        braceParamStr = _replaceMulti(startRuleR + varContent + endRuleR + '|' + startRule + varContent + endRule),
        escapeStartRule = _replaceMulti(startRule),
        escapeEndRule = _replaceMulti(endRule),
        escapeStartRuleR = _replaceMulti(startRuleR),
        escapeEndRuleR = _replaceMulti(endRuleR);

  const tmplRules = {
    startRule,
    endRule,
    extensionRule,
    propRule,
    strPropRule,
    templateRule,
    tagSpRule,
    commentRule,
    firstChar,
    lastChar,
    braceParamStr,
    xmlOpenTag: _createRegExp('^<([a-z' + firstChar + extensionRules + '][^\\s>]*)[^>]*>$', 'i'),
    openTagParams: _createRegExp('[\\s]+(((' + escapeStartRuleR + '(' + varContent + ')' + escapeEndRuleR + ')|(' + escapeStartRule + '(' + varContent + ')' + escapeEndRule + '))|[^\\s=>]+)(=((\'[^\']+\')|("[^"]+")|([^"\'\\s]+)))?', 'g'),
    directives: _createRegExp('[\\s]+(((' + escapeStartRuleR + '(' + varContent + ')' + escapeEndRuleR + ')|(' + escapeStartRule + '(' + varContent + ')' + escapeEndRule + '))|((:?)(' + escapeExtensionRule + ')?([^\\s=>]+)))(=((\'[^\']+\')|("[^"]+")|([^"\'\\s>]+)))?', 'g'),
    braceParam: _createRegExp(braceParamStr, 'i'),
    braceParamG: _createRegExp(braceParamStr, 'ig'),
    spreadProp: _createRegExp('[\\s]+(' + escapeStartRuleR + '[\\s]*(' + varContentS + ')' + escapeEndRuleR + ')|(' + escapeStartRule + '[\\s]*(' + varContentS + ')' + escapeEndRule + ')', 'g'),
    replaceSplit: _createRegExp(braceParamStr),
    replaceParam: _createRegExp('((' + escapeStartRuleR + ')(' + varContent + ')' + escapeEndRuleR + ')|((' + escapeStartRule + ')(' + varContent + ')' + escapeEndRule + ')', 'g'),
    checkElem: _createRegExp('([^<>]+)|(<([a-z/!' + firstChar + extensionRules + '][^\\s<>]*)([^<>]*)>|<)([^<]*)', 'ig'),
    extension: _createRegExp('^' + escapeExtensionRule + '([^\\s]+)', 'i'),
    exAll: _createRegExp('^([/]?)(' + escapeExtensionRule + '|' + escapeStrPropRule + escapePropRule + '|' + escapePropRule + ')([^\\s]+)', 'i'),
    include: _createRegExp('<' + escapeExtensionRule + 'include([^>]*)>', 'ig'),
    incompleteStart: _createRegExp(startRule + '((?!' + escapeEndRule + ')[\\s\\S])*$'),
    incompleteStartR: _createRegExp(escapeStartRuleR + '((?!' + escapeEndRuleR + ')[\\s\\S])*$'),
    incompleteEnd: _createRegExp('^[\\s\\S]*?' + escapeEndRule),
    incompleteEndR: _createRegExp('^[\\s\\S]*?' + escapeEndRuleR)
  };

  if (isGlobal) {
    //Reset the regexs to global list
    tools.assign(nj.tmplRule, tmplRules);
  } else {
    return tmplRules;
  }
} //Set global template rules

createTmplRule({}, true);
tools.assign(nj, {
  createTmplRule
});