nornj/lib/helpers/extension.js

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

"use strict";

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.registerExtension = registerExtension;
exports.extensionConfig = exports.extensions = void 0;

var _core = _interopRequireDefault(require("../core"));

var tools = _interopRequireWildcard(require("../utils/tools"));

var tranData = _interopRequireWildcard(require("../transforms/transformData"));

var _interface = require("../interface");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

//Global extension list
var extensions = {
  "if": function _if(value, options) {
    if (value && value._njOpts) {
      options = value;
      value = options.props.condition;
    }

    if (value === 'false') {
      value = false;
    }

    var ret;
    var props = options.props;

    if (value) {
      ret = (props && props.then || options.children)();
    } else if (props) {
      var elseFn = props['else'];

      if (props.elseifs) {
        var l = props.elseifs.length;
        tools.each(props.elseifs, function (elseif, i) {
          if (elseif.value) {
            ret = elseif.fn();
            return false;
          } else if (i === l - 1) {
            if (elseFn) {
              ret = elseFn();
            }
          }
        }, true);
      } else {
        if (elseFn) {
          ret = elseFn();
        }
      }
    }

    if (options.useString && ret == null) {
      return '';
    }

    return ret;
  },
  then: function then(options) {
    return options.tagProps.then = options.children;
  },
  "else": function _else(options) {
    return options.tagProps['else'] = options.children;
  },
  elseif: function elseif(value, options) {
    if (value && value._njOpts) {
      options = value;
      value = options.props.condition || options.props.value;
    }

    var _options = options,
        tagProps = _options.tagProps;

    if (!tagProps.elseifs) {
      tagProps.elseifs = [];
    }

    tagProps.elseifs.push({
      value: value,
      fn: options.children
    });
  },
  "switch": function _switch(value, options) {
    if (value && value._njOpts) {
      options = value;
      value = options.props.value;
    }

    var ret;
    var props = options.props,
        elseifs = props.elseifs || [{}],
        l = elseifs.length;
    tools.each(elseifs, function (elseif, i) {
      if (value === elseif.value) {
        ret = elseif.fn();
        return false;
      } else if (i === l - 1) {
        if (props['else']) {
          ret = props['else']();
        }
      }
    }, true);
    return ret;
  },
  each: function each(list, options) {
    if (list && list._njOpts) {
      options = list;
      list = options.props.of;
    }

    var useString = options.useString,
        props = options.props;
    var ret;

    if (list) {
      if (useString) {
        ret = '';
      } else {
        ret = [];
      }

      var isArrayLike = tools.isArrayLike(list);
      var isArrayLoop = isArrayLike || tools.isSet(list) || tools.isWeakSet(list);
      tools.each(list, function (item, index, len, lenObj) {
        var param = {
          data: [item],
          index: isArrayLoop ? index : len,
          item: item,
          newParent: true
        };

        var _len = isArrayLoop ? len : lenObj;

        var extra = {
          '@first': param.index === 0,
          '@last': param.index === _len - 1
        };

        if (!isArrayLoop) {
          extra['@key'] = index;
        }

        param.data.push(extra);
        var retI = options.children(param);

        if (useString) {
          ret += retI;
        } else {
          ret.push(retI);
        }
      }, isArrayLike); //Return null when not use string and result is empty.

      if (!useString && !ret.length) {
        ret = null;
      }

      if ((!ret || !ret.length) && props && props['else']) {
        ret = props['else']();
      }
    } else {
      if (props && props['else']) {
        ret = props['else']();
      }

      if (useString && ret == null) {
        ret = '';
      }
    }

    return ret;
  },
  //Parameter
  prop: function prop(name, options) {
    var ret = options.value(); //Get parameter value

    var value;

    if (ret !== undefined) {
      value = ret;
    } else {
      //Match to Similar to "checked" or "disabled" attribute.
      value = !options.useString ? true : name;
    }

    options.tagProps[options.outputH ? tranData.fixPropName(name) : name] = value;
  },
  //Spread parameters
  spread: function spread(props, options) {
    var tagProps = options.tagProps;
    tools.each(props, function (v, k) {
      tagProps[k] === undefined && (options.tagProps[k] = v);
    }, false);
  },
  show: function show(options) {
    if (!options.value()) {
      var tagProps = options.tagProps,
          useString = options.useString;

      if (!tagProps.style) {
        tagProps.style = useString ? '' : {};
      }

      if (useString) {
        tagProps.style += (tagProps.style ? ';' : '') + 'display:none';
      } else if (tools.isArray(tagProps.style)) {
        tagProps.style.push({
          display: 'none'
        });
      } else {
        tagProps.style.display = 'none';
      }
    }
  },
  obj: function obj(options) {
    return options.props;
  },
  block: function block(options) {
    return options.children();
  },
  "with": function _with(originalData, options) {
    if (originalData && originalData._njOpts) {
      options = originalData;
      return options.children({
        data: [options.props]
      });
    } else {
      var _options2 = options,
          props = _options2.props;
      return options.children({
        data: [props && props.as ? _defineProperty({}, props.as, originalData) : originalData]
      });
    }
  },
  arg: function arg(options) {
    var tagProps = options.tagProps;

    if (!tagProps.args) {
      tagProps.args = [];
    }

    tagProps.args.push(options.value());
  },
  css: function css(options) {
    return options.props.style;
  }
};
exports.extensions = extensions;

function _config(params, extra) {
  var ret = {
    onlyGlobal: false,
    useString: false,
    newContext: true,
    isSubTag: false,
    isDirective: false,
    isBindable: false,
    useExpressionInProps: false,
    hasName: true,
    noTagName: false,
    hasTagProps: true,
    hasTmplCtx: true,
    hasOutputH: false
  };

  if (params) {
    ret = tools.assign(ret, params);
  }

  if (extra) {
    ret = tools.assign(ret, extra);
  }

  return ret;
}

var _defaultCfg = {
  onlyGlobal: true,
  newContext: false,
  hasName: false,
  hasTagProps: false,
  hasTmplCtx: false
};

var _defaultCfgExpInProps = _config(_defaultCfg, {
  useExpressionInProps: true
}); //Extension default config


var extensionConfig = {
  "if": _config(_defaultCfgExpInProps),
  "else": _config(_defaultCfgExpInProps, {
    isSubTag: true,
    hasTagProps: true
  }),
  "switch": _config(_defaultCfgExpInProps, {
    needPrefix: _interface.ExtensionPrefixConfig.onlyLowerCase
  }),
  each: _config(_defaultCfgExpInProps, {
    newContext: {
      item: 'item',
      index: 'index',
      data: {
        first: ['@first', 'first'],
        last: ['@last', 'last'],
        $key: ['@key', 'key']
      }
    }
  }),
  prop: _config(_defaultCfg, {
    isDirective: true,
    needPrefix: true,
    hasTagProps: true
  }),
  obj: _config(_defaultCfg, {
    needPrefix: true
  }),
  "with": _config(_defaultCfg, {
    newContext: {
      getDataFromProps: true
    }
  }),
  style: {
    needPrefix: true
  }
};
exports.extensionConfig = extensionConfig;
extensionConfig.then = _config(extensionConfig['else']);
extensionConfig.elseif = _config(extensionConfig['else']);
extensionConfig.spread = _config(extensionConfig.prop);
extensionConfig.block = _config(extensionConfig.obj);
extensionConfig.arg = _config(extensionConfig.prop);
extensionConfig.show = _config(extensionConfig.prop, {
  useExpressionInProps: true,
  noTagName: true,
  hasOutputH: true
});
extensionConfig.css = _config(extensionConfig.obj); //Extension alias

extensions['for'] = extensions.each;
extensionConfig['for'] = _config(extensionConfig.each);
extensions['case'] = extensions.elseif;
extensionConfig['case'] = _config(extensionConfig.elseif);
extensions.empty = extensions['default'] = extensions['else'];
extensionConfig.empty = _config(extensionConfig['else']);
extensionConfig['default'] = _config(extensionConfig['else']);
extensions.strProp = extensions.prop;
extensionConfig.strProp = _config(extensionConfig.prop, {
  useString: true
});
extensions.strArg = extensions.arg;
extensionConfig.strArg = _config(extensionConfig.strProp);
extensions.pre = extensions.block;
extensionConfig.pre = _config(extensionConfig.block);

function registerExtension(name, extension, options, mergeConfig) {
  var params = name;

  if (!tools.isObject(name)) {
    params = {};
    params[name] = {
      extension: extension,
      options: options
    };
  }

  tools.each(params, function (v, name) {
    if (v) {
      var _extension = v.extension,
          _options3 = v.options;

      if (_extension) {
        extensions[name] = _extension;
      } else if (!mergeConfig) {
        extensions[name] = v;
      }

      if (mergeConfig) {
        if (!extensionConfig[name]) {
          extensionConfig[name] = _config();
        }

        if (tools.isObject(_options3)) {
          tools.assign(extensionConfig[name], _options3);
        } else {
          extensionConfig[name] = _config();
        }
      } else {
        extensionConfig[name] = _config(_options3);
      }
    }
  }, false);
}

tools.assign(_core["default"], {
  extensions: extensions,
  extensionConfig: extensionConfig,
  registerExtension: registerExtension
});