@alifd/adaptor-helper/umd/adaptor-helper.js

Next adaptor utils

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = global || self, factory(global.AdaptorHelper = {}));
}(this, function (exports) { 'use strict';

  var STATE_MARK = {
    "-": "disabled",
    // tslint:disable-next-line:object-literal-sort-keys
    "*": "active",
    "~": "hover",
    "": "normal"
  };
  var STATE_PREFIX_MARK = {};
  Object.keys(STATE_MARK).forEach(function (key) {
    STATE_PREFIX_MARK[STATE_MARK[key]] = key;
  });

  (function (NodeType) {
    NodeType["divider"] = "divider";
    NodeType["node"] = "node";
    NodeType["comment"] = "comment";
  })(exports.NodeType || (exports.NodeType = {}));

  (function (ContentType) {
    ContentType["text"] = "text";
    ContentType["icon"] = "icon";
  })(exports.ContentType || (exports.ContentType = {}));

  var getChildren = function getChildren() {
    var template = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";

    if (!template) {
      return [];
    }

    return template.replace(/(\[.*?\])/g, "\n$1\n").split("\n").filter(function (v) {
      return !!v;
    }).map(function (d) {
      switch (true) {
        case /^\[(.*)\]$/.test(d):
          return {
            type: "icon",
            value: RegExp.$1
          };

        default:
          return {
            type: "text",
            value: d
          };
      }
    });
  };

  var parseData = function parseData(text) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
      parseContent: false
    };

    if (!text) {
      return [];
    }

    var root = {
      type: exports.NodeType.node,
      state: "normal",
      value: "",
      children: []
    };
    var stack = [root];
    text.split("\n").filter(function (line) {
      return line.trim();
    }).forEach(function (line) {
      var re = /^(\t*)([#\-~*]?)(.*)$/.exec(line);
      var indent = (re[1] || "").length;
      var prefix = re[2] || "";
      var item = {
        type: exports.NodeType.node,
        state: "normal",
        value: re[3] || "",
        children: []
      };

      if (prefix === "-" && /^-{2,}$/.test(item.value)) {
        item.type = exports.NodeType.divider;
      } else if (prefix === "#") {
        item.type = exports.NodeType.comment;
      } else {
        item.state = STATE_MARK[prefix];
      }

      if (item.type === "node" && options.parseContent) {
        item.value = getChildren(item.value);
      }

      while (indent <= stack.length - 2) {
        stack.pop();
      }

      stack[stack.length - 1].children.push(item);
      stack.push(item);
    });
    return root.children;
  };

  var Types;

  (function (Types) {
    Types["enum"] = "enum";
    Types["string"] = "string";
    Types["number"] = "number";
    Types["bool"] = "bool";
    Types["node"] = "node";
    Types["nodeList"] = "node-list";
  })(Types || (Types = {}));

  var Types$1 = Types;

  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;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
      var ownKeys = Object.keys(source);

      if (typeof Object.getOwnPropertySymbols === 'function') {
        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
        }));
      }

      ownKeys.forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    }

    return target;
  }

  var firstUpperCase = function firstUpperCase(str) {
    if (!str) {
      return "";
    }

    return [str.substring(0, 1).toUpperCase(), str.substring(1)].join("");
  };
  var toLabelWord = function toLabelWord(str) {
    return str.replace(/\B([A-Z])/g, "-$1").split(/[-|_]/).map(function (s) {
      return firstUpperCase(s);
    }).join(" ");
  };

  var normalizeOptions = function normalizeOptions() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    return options.filter(function (v) {
      return !!v;
    }).map(function (item) {
      var value = item.value || item;
      return {
        value: value,
        label: item.label || toLabelWord(value)
      };
    });
  };

  var normalizeProps = function normalizeProps() {
    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    return props.filter(function (v) {
      return !!v;
    }).map(function (prop) {
      return _objectSpread({}, prop, {
        label: prop.label || toLabelWord(prop.name),
        options: normalizeOptions(prop.options)
      });
    });
  };

  var normalizeAdaptor = function normalizeAdaptor(adaptor) {
    if (!adaptor.name) {
      console.error("[error] muse be have name:");
      return adaptor;
    }

    var shape;

    if (!adaptor.shape || !Array.isArray(adaptor.shape) || adaptor.shape.length < 1) {
      shape = [{
        label: adaptor.name,
        value: "normal"
      }];
    } else {
      shape = adaptor.shape.filter(function (v) {
        return !!v;
      }).map(function (item) {
        var value = item.value || item;
        return {
          value: value,
          label: item.label || "".concat(toLabelWord(value), " ").concat(value === "normal" ? "" : adaptor.name)
        };
      });
    }

    var editor = function editor(s) {
      var p = adaptor.editor ? adaptor.editor(s) : {};

      if (!p.props) {
        p.props = [];
      }

      if (!p.nodes) {
        p.nodes = [];
      }

      return _objectSpread({}, p, {
        props: normalizeProps(p.props),
        nodes: normalizeProps(p.nodes)
      });
    };

    var content = function content(s) {
      var p = adaptor.content ? adaptor.content(s) : {};
      return _objectSpread({}, p, {
        options: normalizeProps(p.options)
      });
    };

    return _objectSpread({}, adaptor, {
      shape: shape,
      editor: editor,
      content: content
    });
  };
  var getDefaultProps = function getDefaultProps(adaptor, shape) {
    var p = adaptor.editor(shape);
    var props = {
      shape: shape,
      data: p.data && p.data["default"] || ""
    };
    p.props.forEach(function (item) {
      var defaultValue = item["default"];

      if (defaultValue === undefined || defaultValue === null) {
        switch (item.type) {
          case Types$1.string:
            defaultValue = "";
            break;

          case Types$1.number:
            defaultValue = 0;
            break;

          case Types$1.bool:
            defaultValue = false;
            break;

          case Types$1["enum"]:
            defaultValue = item.options ? item.options[0].value : "";
            break;

          default:
            break;
        }
      }

      props[item.name] = defaultValue;
    });
    p.nodes.forEach(function (_ref) {
      var name = _ref.name,
          defaultValue = _ref["default"];
      props[name] = defaultValue;
    });
    return props;
  };
  var findProp = function findProp(name) {
    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    return props.find(function (item) {
      return item.name === name;
    });
  };
  var findOptionLabel = function findOptionLabel(value, name) {
    var props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
    var prop = findProp(name, props);

    if (prop && prop.type === Types$1["enum"]) {
      var option = (prop.options || []).find(function (item) {
        return item.value === value;
      });
      return option ? option.label : value;
    }

    return "";
  };
  var index = 1;
  var now = new Date().getTime();
  var uuid = function uuid() {
    return (now + index++).toString(16);
  };
  var getStates = function getStates() {
    var dataOption = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
      "default": ""
    };
    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    var stateMap = {
      normal: true,
      hover: !!dataOption.hover,
      active: !!dataOption.active,
      disabled: !!dataOption.disable
    };
    var states = dataOption.generate === false ? null : Object.keys(stateMap).filter(function (key) {
      return stateMap[key];
    });
    var stateProp = findProp("state", props);

    if (stateProp) {
      states = (stateProp.options || []).map(function (_ref2) {
        var value = _ref2.value;
        return value;
      });
    }

    return states || ["normal"];
  };
  var generateDemos = function generateDemos(adaptor) {
    var demos = [];
    adaptor.shape.forEach(function (_ref3) {
      var value = _ref3.value;
      var editor = adaptor.editor(value);
      var sizeProp = findProp("size", editor.props);
      var stateProp = findProp("state", editor.props);
      var levelProp = findProp("level", editor.props);
      var states = getStates(editor.data, editor.props);
      var sizes = sizeProp && sizeProp.options ? sizeProp.options.map(function (_ref4) {
        var v = _ref4.value;
        return v;
      }) : ["medium"];
      var levels = levelProp && levelProp.options ? levelProp.options.map(function (_ref5) {
        var v = _ref5.value;
        return v;
      }) : ["normal"];
      states.forEach(function (state) {
        sizes.forEach(function (size) {
          levels.forEach(function (level) {
            var props = _objectSpread({}, getDefaultProps(adaptor, value));

            if (sizeProp) {
              props.size = size;
            }

            if (levelProp) {
              props.level = level;
            }

            if (states.length > 1) {
              if (stateProp) {
                props.state = state;
              } else {
                if (props.data && STATE_MARK[props.data.substring(0, 1)]) {
                  props.data = props.data.substring(1);
                }

                props.data = STATE_PREFIX_MARK[state] + props.data;
              }
            }

            var demo = {
              id: uuid(),
              node: {
                adaptor: adaptor.name,
                props: props
              }
            };
            demos.push(_objectSpread({}, demo, adaptor.demoOptions && adaptor.demoOptions(demo)));
          });
        });
      });
    });
    return demos;
  };
  var filterDemoState = function filterDemoState(state) {
    return function (_ref6) {
      var node = _ref6.node;
      var _node$props = node.props,
          props = _node$props === void 0 ? {} : _node$props;
      var _props$data = props.data,
          data = _props$data === void 0 ? "" : _props$data;
      var demoState = STATE_MARK[data.substring(0, 1)] || "normal";

      if (props.state) {
        demoState = props.state;
      }

      return demoState === state;
    };
  };

  exports.STATE_MARK = STATE_MARK;
  exports.STATE_PREFIX_MARK = STATE_PREFIX_MARK;
  exports.Types = Types$1;
  exports.filterDemoState = filterDemoState;
  exports.findOptionLabel = findOptionLabel;
  exports.findProp = findProp;
  exports.generateDemos = generateDemos;
  exports.getDefaultProps = getDefaultProps;
  exports.getStates = getStates;
  exports.normalizeAdaptor = normalizeAdaptor;
  exports.parseData = parseData;
  exports.uuid = uuid;

  Object.defineProperty(exports, '__esModule', { value: true });

}));