@opentiny/vue-renderless 3.11.7 → 3.12.0

package/cascader-view/index.js

@@ -0,0 +1,363 @@
+import "../chunk-G2ADBYYC.js";
+import TreeStore from "../common/deps/tree-model/tree-store";
+const close = ({ state, emit }) => () => {
+  state.search.show = false;
+  emit("update:visible", false);
+  emit("close", false);
+};
+const syncCheckStatus = ({ state, api }) => (value) => {
+  value && state.store.setDefaultCheckedKey(value);
+  state.checkList = api.getCheckedNodes();
+};
+const watchModelValue = ({ props, state, emit }) => () => {
+  const { textSplit } = props;
+  emit("update:text", state.checkLabels.join(textSplit));
+};
+const watchVisible = ({ emit, state, props, api }) => (visible) => {
+  const { modelValue } = props;
+  if (visible) {
+    api.watchModelValue(modelValue);
+    api.initTreeStore();
+    api.searchBoxToggle(false);
+  }
+  emit("update:visible", visible);
+  setTimeout(() => {
+    state.toggle = visible;
+  }, 0);
+};
+const hasChildren = (option) => option && !option.isLeaf;
+const selectOption = ({ emit, state, api }) => (option, deep = true) => {
+  const isAdd = !option.checked || option.indeterminate;
+  if (option.disabled) {
+    return;
+  }
+  state.store.setChecked(option, isAdd, deep);
+  state.checkList = api.getCheckedNodes();
+  emit("click", option, isAdd);
+};
+const nodeExpand = ({ emit, state, props, api }) => (option) => {
+  if (option.isLeaf) {
+    return;
+  }
+  const { valueField } = props;
+  const { lazy, load } = api.getNodeConfig();
+  const { navList, level, waitLoadCheckList } = state;
+  const len = navList.length;
+  const appendNavList = () => {
+    const isSame = level < len && navList[level] === option;
+    if (hasChildren(option)) {
+      state.level += 1;
+      if (!isSame) {
+        state.navList = [...navList.slice(0, level), option];
+      }
+    }
+    option.expand();
+    emit("node-expand", option);
+  };
+  if (load && lazy && (option.selfWaitLoad || !option.loaded && !option.isLeaf)) {
+    state.loading = true;
+    option.loading = true;
+    load(option, (nodes) => {
+      let index, node;
+      state.loading = false;
+      option.loading = false;
+      option.loaded = true;
+      nodes.map((data) => {
+        index = -1;
+        state.store.append(data, option.data);
+        waitLoadCheckList.some((item, i) => {
+          if (item.data[valueField] === data[valueField]) {
+            index = i;
+            return true;
+          }
+          return false;
+        });
+        node = state.store.getNode(data);
+        if (index !== -1 && node) {
+          state.waitLoadCheckList.splice(index, 1);
+        }
+      });
+      option.checked && !state.store.checkStrictly && option.setChecked(true, !state.store.checkStrictly);
+      state.checkList = api.getCheckedNodes();
+      appendNavList();
+    });
+  } else {
+    appendNavList();
+  }
+};
+const confirm = ({ emit, state, props }) => () => {
+  const { emitPath, valueField } = props;
+  let value;
+  let data = [];
+  state.computedCheckList.forEach((node) => {
+    if (node.waitLoad) {
+      value = emitPath ? node.rawValue : node.data[valueField];
+    } else {
+      value = emitPath ? node.getPathData(valueField) : node.data[valueField];
+    }
+    data.push(value);
+  });
+  state.search.show = false;
+  emit("confirm", state);
+  emit("update:visible", false);
+  emit("update:modelValue", data);
+};
+const loopSearchOption = ({ state, props, api }) => (param) => {
+  const { options, prefixText = "", textSplit = "/", checkStrictly } = param || {};
+  const { valueField, textField, childrenField } = props;
+  const { input } = state.search;
+  const list = [];
+  options.forEach((item) => {
+    const text = item[textField];
+    const textNavStr = prefixText ? prefixText + textSplit + text : text;
+    const value = item[valueField];
+    const childNodes = item[childrenField];
+    const len = childNodes && childNodes.length;
+    if ((checkStrictly || !checkStrictly && !len) && text.includes(input)) {
+      list.push({
+        [valueField]: value,
+        [textField]: textNavStr
+      });
+    }
+    if (len) {
+      const arr = api.loopSearchOption({
+        options: childNodes,
+        prefixText: textNavStr,
+        textSplit,
+        checkStrictly
+      });
+      list.push(...arr);
+    }
+  });
+  return list;
+};
+const filterOptionsHandler = ({ state, props }) => (list) => {
+  const { valueField } = props;
+  state.search.loaded = true;
+  state.search.filterOptions = list.map((item) => {
+    return {
+      data: item,
+      node: state.store.getNode(item[valueField])
+    };
+  });
+};
+const searchMethod = ({ state, props, api }) => () => {
+  const { searchConfig } = props;
+  const { input, options } = state.search;
+  let list = [];
+  const { checkStrictly } = api.getNodeConfig();
+  if (searchConfig && searchConfig.searchMethod) {
+    list = searchConfig.searchMethod({ input, options, state }) || [];
+  } else if (input) {
+    list = api.loopSearchOption({ options, checkStrictly });
+  }
+  if (typeof list.then === "function") {
+    list.then((data) => api.filterOptionsHandler(data));
+  } else {
+    api.filterOptionsHandler(list);
+  }
+};
+const searchBoxToggle = ({ state, props, api }) => (bool) => {
+  const { searchConfig = {} } = props;
+  const { lazy } = api.getNodeConfig();
+  state.search.show = bool;
+  state.search.loaded = false;
+  if (bool) {
+    state.search.options = !lazy && searchConfig.options && searchConfig.options.length ? searchConfig.options : state.store.getAllData();
+  } else {
+    state.search.input = "";
+    state.search.filterOptions = [];
+  }
+};
+const isSelected = ({ state }) => (option) => {
+  const { navList } = state;
+  return navList.includes(option);
+};
+const created = ({ api }) => () => {
+  api.initTreeStore();
+};
+const setLevel = ({ state, api }) => (level, option) => {
+  if (!api.disabledNavOption(level, option)) {
+    state.level = level;
+  }
+};
+const searchSelectHandler = ({ emit, api }) => (option) => {
+  api.selectOption(option);
+  emit("search-click", option);
+};
+const renderSearchOption = ({ state }) => (text) => {
+  return (text || "").split(state.search.input);
+};
+const loadData = ({ props, state }) => (data) => {
+  props.visible && state.store.setData(data);
+};
+const computedNavListHandler = ({ state, props, t }) => () => {
+  const { textField } = props;
+  return [{ data: { [textField]: t("ui.base.all") } }, ...state.navList];
+};
+const disabledNavOption = ({ state }) => (level, option) => {
+  const node = state.navList[level];
+  return option.selfWaitLoad && (!node || !node.childNodes.length);
+};
+const getNodeConfig = ({ constants, props }) => () => {
+  const { nodeConfig, valueField, childrenField } = props;
+  return Object.assign({ nodeKey: valueField, children: childrenField }, constants.defaultNodeConfig, nodeConfig);
+};
+const initTreeStore = ({ props, state, api }) => () => {
+  const { data, valueField, textField, visible, modelValue } = props;
+  const {
+    lazy,
+    nodeKey,
+    load,
+    children,
+    afterLoad,
+    isLeaf,
+    currentNodeKey,
+    checkStrictly,
+    checkDescendants,
+    defaultExpandedKeys,
+    defaultCheckedKeys,
+    defaultExpandAll,
+    autoExpandParent,
+    filterNodeMethod
+  } = api.getNodeConfig();
+  if (!visible) {
+    return;
+  }
+  const defaultValue = (defaultCheckedKeys || modelValue).map((data2) => {
+    if (Array.isArray(data2)) {
+      data2 = data2[data2.length - 1];
+    }
+    return data2;
+  });
+  if (state.store) {
+    api.syncCheckStatus(defaultValue);
+    return;
+  }
+  state.store = new TreeStore({
+    data,
+    lazy,
+    load,
+    key: nodeKey,
+    props: {
+      label: textField,
+      children,
+      isLeaf
+    },
+    afterLoad: () => {
+      state.rootData = state.root.childNodes || [];
+      api.syncCheckStatus();
+      afterLoad && afterLoad();
+    },
+    checkStrictly,
+    currentNodeKey,
+    checkDescendants,
+    defaultExpandedKeys,
+    defaultCheckedKeys: defaultValue,
+    defaultExpandAll,
+    autoExpandParent,
+    filterNodeMethod
+  });
+  state.root = state.store.root;
+  if (!lazy) {
+    state.rootData = state.root.childNodes || [];
+    api.syncCheckStatus();
+  } else {
+    state.waitLoadCheckList = defaultValue.map((item, index) => {
+      return {
+        data: {
+          [textField]: item,
+          [valueField]: item
+        },
+        rawValue: (defaultCheckedKeys || modelValue)[index],
+        waitLoad: true
+      };
+    });
+  }
+};
+const clean = ({ state }) => () => {
+  const { options, waitLoadList } = state.selected;
+  state.selected.removeList = [...waitLoadList, ...options];
+  state.selected.options = [];
+  state.selected.waitLoadList = [];
+};
+const getCheckedNodes = ({ state }) => () => {
+  return state.store.getCheckedNodes(!state.store.checkStrictly, false, true);
+};
+const toggleCheckList = ({ state, props, api }) => (show) => {
+  const { valueField } = props;
+  if (!state.computedCheckList.length) {
+    return;
+  }
+  state.selected.show = show;
+  if (show) {
+    state.selected.options = state.checkList.slice();
+    state.selected.waitLoadList = state.waitLoadCheckList.slice();
+  } else {
+    let index;
+    state.selected.removeList.forEach((option) => {
+      if (option.waitLoad) {
+        index = state.store.defaultCheckedKeys.indexOf(option.data[valueField]);
+        if (index !== -1) {
+          state.store.defaultCheckedKeys.splice(index, 1);
+        }
+      } else {
+        state.store.setChecked(option, false, false);
+      }
+    });
+    state.checkList = api.getCheckedNodes();
+    state.selected.removeList = [];
+    state.waitLoadCheckList = state.selected.waitLoadList.slice();
+  }
+};
+const removeOption = ({ state }) => (option) => {
+  const { options, waitLoadList } = state.selected;
+  let index;
+  if ((index = options.indexOf(option)) > -1) {
+    state.selected.options.splice(index, 1);
+    state.selected.removeList.push(option);
+  } else if ((index = waitLoadList.indexOf(option)) > -1) {
+    state.selected.waitLoadList.splice(index, 1);
+    state.selected.removeList.push(option);
+  }
+};
+const computedSelectedListHandler = ({ state }) => () => {
+  const { options, waitLoadList } = state.selected;
+  return [...waitLoadList, ...options];
+};
+const inputKeyword = ({ state, api }) => () => {
+  const { search } = state;
+  const show = !!search.input;
+  if (search.show !== show) {
+    api.searchBoxToggle(show);
+  }
+};
+export {
+  clean,
+  close,
+  computedNavListHandler,
+  computedSelectedListHandler,
+  confirm,
+  created,
+  disabledNavOption,
+  filterOptionsHandler,
+  getCheckedNodes,
+  getNodeConfig,
+  initTreeStore,
+  inputKeyword,
+  isSelected,
+  loadData,
+  loopSearchOption,
+  nodeExpand,
+  removeOption,
+  renderSearchOption,
+  searchBoxToggle,
+  searchMethod,
+  searchSelectHandler,
+  selectOption,
+  setLevel,
+  syncCheckStatus,
+  toggleCheckList,
+  watchModelValue,
+  watchVisible
+};

package/cascader-view/vue.js

@@ -0,0 +1,130 @@
+import "../chunk-G2ADBYYC.js";
+import {
+  close,
+  confirm,
+  watchVisible,
+  selectOption,
+  searchMethod,
+  searchSelectHandler,
+  loopSearchOption,
+  searchBoxToggle,
+  filterOptionsHandler,
+  watchModelValue,
+  setLevel,
+  created,
+  clean,
+  loadData,
+  isSelected,
+  getNodeConfig,
+  initTreeStore,
+  disabledNavOption,
+  renderSearchOption,
+  computedNavListHandler,
+  computedSelectedListHandler,
+  nodeExpand,
+  inputKeyword,
+  removeOption,
+  getCheckedNodes,
+  toggleCheckList,
+  syncCheckStatus
+} from "./index";
+const api = [
+  "state",
+  "close",
+  "clean",
+  "confirm",
+  "setLevel",
+  "loadData",
+  "nodeExpand",
+  "selectOption",
+  "searchMethod",
+  "searchBoxToggle",
+  "searchSelectHandler",
+  "renderSearchOption",
+  "disabledNavOption",
+  "toggleCheckList",
+  "inputKeyword",
+  "removeOption",
+  "getCheckedNodes",
+  "isSelected"
+];
+const renderless = (props, { computed, reactive, watch }, { t, emit, constants }) => {
+  const api2 = {};
+  const state = reactive({
+    toggle: false,
+    loading: false,
+    root: null,
+    store: null,
+    checkList: [],
+    level: 0,
+    rootData: [],
+    navList: [],
+    waitLoadCheckList: [],
+    search: {
+      loaded: false,
+      show: false,
+      input: "",
+      filterOptions: [],
+      options: []
+    },
+    selected: {
+      removeList: [],
+      options: [],
+      show: false,
+      waitLoadList: []
+    },
+    options: computed(() => {
+      let data;
+      let list = [state.rootData];
+      state.navList.map((option) => {
+        data = option.childNodes;
+        data && data.length && list.push(data);
+      });
+      return list;
+    }),
+    computedNavList: computed(() => api2.computedNavListHandler()),
+    computedCheckList: computed(() => [...state.waitLoadCheckList, ...state.checkList]),
+    computedSelectedList: computed(() => api2.computedSelectedListHandler()),
+    checkIds: computed(() => state.computedSelectedList.map((option) => option.data[props.valueField])),
+    checkLabels: computed(() => state.computedSelectedList.map((option) => option.data[props.textField]))
+  });
+  Object.assign(api2, {
+    state,
+    created: created({ api: api2 }),
+    close: close({ state, emit }),
+    clean: clean({ state, props }),
+    setLevel: setLevel({ state, api: api2 }),
+    loadData: loadData({ state, props }),
+    confirm: confirm({ state, emit, props, api: api2 }),
+    selectOption: selectOption({ emit, state, api: api2 }),
+    searchMethod: searchMethod({ state, props, api: api2 }),
+    initTreeStore: initTreeStore({ props, state, api: api2 }),
+    searchBoxToggle: searchBoxToggle({ state, props, api: api2 }),
+    syncCheckStatus: syncCheckStatus({ state, props, api: api2 }),
+    getNodeConfig: getNodeConfig({ state, constants, props }),
+    watchVisible: watchVisible({ emit, state, props, api: api2 }),
+    watchModelValue: watchModelValue({ props, state, emit }),
+    loopSearchOption: loopSearchOption({ state, api: api2, props }),
+    filterOptionsHandler: filterOptionsHandler({ state, props }),
+    searchSelectHandler: searchSelectHandler({ state, emit, api: api2, props }),
+    renderSearchOption: renderSearchOption({ props, state, api: api2 }),
+    computedNavListHandler: computedNavListHandler({ props, state, api: api2, t }),
+    computedSelectedListHandler: computedSelectedListHandler({ state }),
+    disabledNavOption: disabledNavOption({ state }),
+    inputKeyword: inputKeyword({ state, api: api2 }),
+    removeOption: removeOption({ state, api: api2 }),
+    isSelected: isSelected({ state, api: api2, props }),
+    nodeExpand: nodeExpand({ emit, state, props, api: api2 }),
+    toggleCheckList: toggleCheckList({ state, props, api: api2 }),
+    getCheckedNodes: getCheckedNodes({ state, api: api2 })
+  });
+  api2.created();
+  watch(() => props.data, api2.loadData, { deep: true });
+  watch(() => props.modelValue, api2.watchModelValue, { immediate: true, deep: true });
+  watch(() => props.visible, api2.watchVisible);
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/chart-core/deps/constants.js

@@ -42,6 +42,31 @@ const SAAS_DEFAULT_COLORS_18 = [
   "#daa61b",
   "#efb9e3"
 ];
+const _SAAS_DEFAULT_COLORS1 = ["#2070F3", "#55CCD9", "#715AF8", "#8AC8F3", "#EB74DF", "#87C859", "#D19F00"];
+const _SAAS_DEFAULT_COLORS2 = ["#36C18D", "#CB8EFB", "#ED448A", "#F7C45C", "#E7434A", "#2A8290", "#EE8DDB"];
+const _SAAS_DEFAULT_COLORS3 = ["#278661", "#4FA700", "#5CACFF", "#9185F0", "#B62BF7", "#26616B", "#F46465"];
+const _SAAS_DEFAULT_COLORS4 = ["#5531EB", "#FCDBAA", "#112857", "#E61866", "#B98C1D", "#D41DBC", "#87D5E5"];
+const SAAS_DEFAULT_COLORS = _SAAS_DEFAULT_COLORS1.concat(_SAAS_DEFAULT_COLORS2).concat(_SAAS_DEFAULT_COLORS3).concat(_SAAS_DEFAULT_COLORS4);
+const SAAS_DEFAULT_SAME_COLORS = {
+  blue: [
+    { color: "#2E94FF", idx: 3 },
+    { color: "#8BC3FF", idx: 5 },
+    { color: "#1F55B5", idx: 1 },
+    { color: "#2070F3", idx: 2 },
+    { color: "#5CACFF", idx: 4 },
+    { color: "#B9DBFF", idx: 6 },
+    { color: "#1B3F86", idx: 0 }
+  ],
+  green: [
+    { color: "#00A874", idx: 3 },
+    { color: "#82DBB1", idx: 5 },
+    { color: "#236549", idx: 1 },
+    { color: "#278661", idx: 2 },
+    { color: "#50C291", idx: 4 },
+    { color: "#AFEDCE", idx: 6 },
+    { color: "#1D4A37", idx: 0 }
+  ]
+};
 const DEFAULT_CONFIG = {
   tooltip: {
     backgroundColor: "#fff",
@@ -95,8 +120,10 @@ export {
   ECHARTS_SETTINGS,
   HEAT_BMAP_COLOR,
   HEAT_MAP_COLOR,
+  SAAS_DEFAULT_COLORS,
   SAAS_DEFAULT_COLORS_10,
   SAAS_DEFAULT_COLORS_18,
+  SAAS_DEFAULT_SAME_COLORS,
   STATIC_PROPS,
   itemContent,
   itemLabel,

package/chart-core/deps/numerify.js

@@ -4,8 +4,6 @@ let abbrLabel = { th: "k", mi: "m", bi: "b", tr: "t" };
 let DEFAULT_OPTIONS = { zeroFormat: null, nullFormat: null, defaultFormat: "0,0", scalePercentBy100: true, abbrLabel };
 let [TRILLION, BILLION, MILLION, THOUSAND] = [1e12, 1e9, 1e6, 1e3];
 const numIsNaN = (value) => typeof value === "number" && isNaN(value);
-let options = {};
-let formats = {};
 function getBoundedPrecision(value, maxDecimals, optionals) {
   let splitValue = value.toString().split("e-");
   let exponent = splitValue.length === 2 ? Number(splitValue[1]) : 0;
@@ -38,13 +36,13 @@ function judgForFunc(num, abs, abbrForce) {
   return flag;
 }
 const negativeSigned = function({ format: format3, value }) {
-  return ~format3.indexOf("+") ? format3.indexOf("+") : value < 0 ? format3.indexOf("-") : -1;
+  return format3.includes("+") ? format3.indexOf("+") : value < 0 ? format3.indexOf("-") : -1;
 };
 const updateAbbrV = function(params) {
   let { abbr, abbrForce, format: format3, value, abs } = params;
   abbrForce = format3.match(/a(k|m|b|t)?/);
   abbrForce = abbrForce ? abbrForce[1] : false;
-  if (~format3.indexOf(" a")) {
+  if (format3.includes(" a")) {
     abbr = " ";
   }
   format3 = format3.replace(new RegExp(abbr + "a[kmbt]?"), "");
@@ -68,7 +66,7 @@ const handlePrecision = function(params) {
   let number = value.toString().split(".")[0];
   let precision = format3.split(".")[1];
   if (precision) {
-    if (~precision.indexOf("[")) {
+    if (precision.includes("[")) {
       precision = precision.replace("]", "");
       precision = precision.split("[");
       params.decimal = toFixed(value, precision[0].length + precision[1].length, roundingFunction, precision[1].length);
@@ -76,7 +74,7 @@ const handlePrecision = function(params) {
       params.decimal = toFixed(value, precision.length, roundingFunction);
     }
     number = params.decimal.split(".")[0];
-    params.decimal = ~params.decimal.indexOf(".") ? "." + params.decimal.split(".")[1] : "";
+    params.decimal = params.decimal.includes(".") ? "." + params.decimal.split(".")[1] : "";
     if (params.optDec && Number(params.decimal.slice(1)) === 0) {
       params.decimal = "";
     }
@@ -93,7 +91,7 @@ function formatNumber(params) {
     number = String(Number(number) / 1e3);
     params.abbr = ABBR.million;
   }
-  if (~number.indexOf("-")) {
+  if (number.includes("-")) {
     number = number.slice(1);
     params.neg = true;
   }
@@ -138,17 +136,17 @@ function numberToFormat(options2, value, format3, roundingFunction) {
     value: value || 0,
     roundingFunction
   };
-  if (~format3.indexOf("(")) {
+  if (format3.includes("(")) {
     params.negFlag = true;
     params.format = format3.replace(/[(|)]/g, "");
-  } else if (~params.format.indexOf("+") || ~params.format.indexOf("-")) {
+  } else if (params.format.includes("+") || params.format.includes("-")) {
     params.signed = negativeSigned(params);
     params.format = format3.replace(/[+|-]/g, "");
   }
-  if (~params.format.indexOf("a")) {
+  if (params.format.includes("a")) {
     updateAbbrV(params);
   }
-  if (~params.format.indexOf("[.]")) {
+  if (params.format.includes("[.]")) {
     params.optDec = true;
     params.format = format3.replace("[.]", ".");
   }
@@ -163,14 +161,14 @@ function extend(target, sub) {
 let numerifyPercent = {
   regexp: /%/,
   format: function format(value, formatType, roundingFunction, numerify2) {
-    let space = ~formatType.indexOf(" %") ? " " : "";
+    let space = formatType.includes(" %") ? " " : "";
     let outStr = void 0;
     if (numerify2.options.scalePercentBy100) {
       value = value * 100;
     }
     formatType = formatType.replace(/\s?%/, "");
     outStr = numerify2._numberToFormat(value, formatType, roundingFunction);
-    if (~outStr.indexOf(")")) {
+    if (outStr.includes(")")) {
       outStr = outStr.split("");
       outStr.splice(-1, 0, space + "%");
       outStr = outStr.join("");
@@ -180,8 +178,9 @@ let numerifyPercent = {
     return outStr;
   }
 };
+let options = {};
+let formats = {};
 extend(options, DEFAULT_OPTIONS);
-let numerify;
 function format2(value, formatType, roundingFunc) {
   let { zeroFormat, nullFormat, defaultFormat } = options;
   formatType = formatType || defaultFormat;
@@ -203,7 +202,19 @@ function format2(value, formatType, roundingFunc) {
   }
   return output;
 }
-numerify = function(input, formatType, roundingFunc) {
+const _register = (name, format3) => {
+  formats[name] = format3;
+};
+const _unregister = (name) => {
+  formats[name] = null;
+};
+const _setOptions = (opts) => {
+  extend(options, opts);
+};
+const _reset = () => {
+  extend(options, DEFAULT_OPTIONS);
+};
+function numerify(input, formatType, roundingFunc) {
   let { zeroFormat, nullFormat } = options;
   let value = Number(input) || null;
   if (typeof input === "undefined" || input === 0) {
@@ -219,19 +230,7 @@ numerify = function(input, formatType, roundingFunc) {
     }
   }
   return format2(value, formatType, roundingFunc);
-};
-const _register = (name, format3) => {
-  formats[name] = format3;
-};
-const _unregister = (name) => {
-  formats[name] = null;
-};
-const _setOptions = (opts) => {
-  extend(options, opts);
-};
-const _reset = () => {
-  extend(options, DEFAULT_OPTIONS);
-};
+}
 numerify.options = options;
 numerify._numberToFormat = numberToFormat.bind(null, options);
 numerify.register = _register;