vue-super-crud 1.7.1

package/src/utils/bem.js

@@ -0,0 +1,49 @@
+/**
+ * bem helper
+ * b() // 'button'
+ * b('text') // 'button__text'
+ * b({ disabled }) // 'button button--disabled'
+ * b('text', { disabled }) // 'button__text button__text--disabled'
+ * b(['disabled', 'primary']) // 'button button--disabled button--primary'
+ */
+
+const ELEMENT = "__";
+const MODS = "--";
+
+const join = (name, el, symbol) => (el ? name + symbol + el : name);
+
+const prefix = (name, mods) => {
+  if (typeof mods === "string") {
+    return join(name, mods, MODS);
+  }
+
+  if (Array.isArray(mods)) {
+    return mods.map((item) => prefix(name, item));
+  }
+
+  const ret = {};
+  Object.keys(mods || {}).forEach((key) => {
+    ret[name + MODS + key] = mods[key];
+  });
+  return ret;
+};
+
+export const bem = (name, el, mods, onlyPrefix) => {
+  if (el && typeof el !== "string") {
+    mods = el;
+    el = "";
+  }
+  el = join(name, el, ELEMENT);
+  if (onlyPrefix && mods) {
+    return prefix(el, mods);
+  }
+  return mods ? [el, prefix(el, mods)] : el;
+};
+
+export default {
+  methods: {
+    b(el, mods, onlyPrefix) {
+      return bem(this.$options.name, el, mods, onlyPrefix);
+    },
+  },
+};

package/src/utils/cache.js

@@ -0,0 +1,77 @@
+const sessionCache = {
+  set (key, value) {
+    if (!sessionStorage) {
+      return
+    }
+    if (key != null && value != null) {
+      sessionStorage.setItem(key, value)
+    }
+  },
+  get (key) {
+    if (!sessionStorage) {
+      return null
+    }
+    if (key == null) {
+      return null
+    }
+    return sessionStorage.getItem(key)
+  },
+  setJSON (key, jsonValue) {
+    if (jsonValue != null) {
+      this.set(key, JSON.stringify(jsonValue))
+    }
+  },
+  getJSON (key) {
+    const value = this.get(key)
+    if (value != null) {
+      return JSON.parse(value)
+    }
+  },
+  remove (key) {
+    sessionStorage.removeItem(key);
+  }
+}
+const localCache = {
+  set (key, value) {
+    if (!localStorage) {
+      return
+    }
+    if (key != null && value != null) {
+      localStorage.setItem(key, value)
+    }
+  },
+  get (key) {
+    if (!localStorage) {
+      return null
+    }
+    if (key == null) {
+      return null
+    }
+    return localStorage.getItem(key)
+  },
+  setJSON (key, jsonValue) {
+    if (jsonValue != null) {
+      this.set(key, JSON.stringify(jsonValue))
+    }
+  },
+  getJSON (key) {
+    const value = this.get(key)
+    if (value != null) {
+      return JSON.parse(value)
+    }
+  },
+  remove (key) {
+    localStorage.removeItem(key);
+  }
+}
+
+export default {
+  /**
+   * 会话级缓存
+   */
+  session: sessionCache,
+  /**
+   * 本地缓存
+   */
+  local: localCache
+}

package/src/utils/getType.js

@@ -0,0 +1,34 @@
+export function isDom(obj) {
+  return typeof HTMLElement === "object"
+    ? (function () {
+        return obj instanceof HTMLElement;
+      })()
+    : (function () {
+        return (
+          obj &&
+          typeof obj === "object" &&
+          obj.nodeType === 1 &&
+          typeof obj.nodeName === "string"
+        );
+      })();
+}
+export function isVNode(element) {
+  return (
+    element &&
+    typeof element === "object" &&
+    "componentOptions" in element &&
+    "context" in element &&
+    element.tag !== undefined
+  );
+}
+export function isComponent(options) {
+  return (
+    options &&
+    (typeof options.template === "string" ||
+      typeof options.render === "function")
+  );
+}
+export function getObjectType(obj) {
+  let type = Object.prototype.toString.call(obj).match(/\s([a-zA-Z]+)/)[1];
+  return type;
+}

package/src/utils/index.js

@@ -0,0 +1,212 @@
+import { isDom, isVNode, isComponent, getObjectType } from "./getType";
+import { debounce, isFunction, omit } from "lodash-es";
+import toTreeArray from "xe-utils/toTreeArray";
+import findTree from "xe-utils/findTree";
+import { mergeTemp, batchMerge, singleMerge } from "./mergeTemp";
+
+export {
+  isDom,
+  isVNode,
+  isComponent,
+  getObjectType,
+  toTreeArray,
+  findTree,
+  mergeTemp,
+  batchMerge,
+  singleMerge,
+};
+
+/**
+ * 判断是否为空
+ */
+export function isEmptyData(val) {
+  if (
+    val instanceof Date ||
+    typeof val === "boolean" ||
+    typeof val === "number"
+  )
+    return false;
+  if (val instanceof Array) {
+    if (val.length === 0) return true;
+    return val.every((item) => isEmptyData(item));
+  } else if (val instanceof Object) {
+    for (var o in val) {
+      return false;
+    }
+    return true;
+  } else {
+    if (
+      val === "null" ||
+      val == null ||
+      val === "undefined" ||
+      val === undefined ||
+      val === ""
+    ) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+
+export function flatLastChildren(array) {
+  let result = [];
+  array.forEach((item) => {
+    if (item.children && item.children.length > 0) {
+      result.push(...flatLastChildren(item.children));
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+}
+
+// 将cell-class-name转为驼峰
+export function toCamelCase(str) {
+  if (str.indexOf("-") < 0) {
+    return str;
+  } else {
+    return str
+      .split("-")
+      .map((word, index) => {
+        if (index === 0) {
+          return word;
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1);
+      })
+      .join("");
+  }
+}
+
+export function executeFunctionByObject(obj = {}, param, omitKeys) {
+  Object.keys(omitKeys ? omit(obj, omitKeys) : obj).forEach((key) => {
+    if (isFunction(obj[key])) {
+      obj[key] = obj[key](param);
+    }
+  });
+  return obj;
+}
+
+export function executeFunction(func, param) {
+  if (!func) return false;
+  if (isFunction(func)) return func(param);
+  return func;
+}
+
+export function filterColumns(columns, scope) {
+  if (!Array.isArray(columns)) return columns;
+  return columns
+    .map((item) => {
+      if (item.children) {
+        item.children = filterColumns(item.children, scope);
+      }
+      return item;
+    })
+    .filter((item) => {
+      return checkVisibility(item, scope, true);
+    });
+}
+
+export const setPxSaveSource = (value) => {
+  if (!value && value !== 0) return "0";
+  // 如果是数字类型
+  if (typeof value === "number") {
+    return value === 0 ? "0" : `${value}px`;
+  }
+  // 如果已经是px结尾
+  if (typeof value === "string" && value.endsWith("px")) {
+    return value;
+  }
+  // 判断是否为纯数字字符串
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return `${value}px`;
+  }
+  // 其他情况直接返回原值
+  return value;
+};
+
+export const setPx = (value) => {
+  if (!value && value !== 0) return "0";
+  if (typeof value === "string" && value.endsWith("px")) {
+    return value;
+  }
+  const num = parseFloat(value);
+  return num === 0 ? "0" : `${num}px`;
+};
+
+export const isPx = (value) => {
+  if (typeof value === "string" && value.endsWith("px")) {
+    return true;
+  }
+  if (typeof value === "number") {
+    return true;
+  }
+  return false;
+};
+
+export function checkVisibility(item, scope, defaultShow) {
+  const checkVisibility = (prop, invert = false) => {
+    const value =
+      typeof item[prop] === "function" ? item[prop](scope) : item[prop];
+    return invert ? !value : value;
+  };
+  const result = [];
+  if (item.hidden !== undefined) result.push(checkVisibility("hidden", true));
+  if (item.innerHide !== undefined)
+    result.push(checkVisibility("innerHide", true));
+  if (item.show !== undefined) result.push(checkVisibility("show"));
+  return result.length > 0 ? result.every((item) => item) : defaultShow;
+}
+
+export function resolveRender(render, h, scope, ...args) {
+  if (!render) return null;
+  const VNode = isFunction(render) ? render(h, scope, ...args) : render;
+  if (VNode) {
+    return isVNode(VNode) ? VNode : <span>{VNode}</span>;
+  }
+}
+
+export function filterButtons(
+  buttons,
+  options = {},
+  scope = null,
+  position = ""
+) {
+  if (!Array.isArray(buttons)) return [];
+
+  return buttons
+    .map((button) => {
+      // 检查显示/隐藏条件
+      if (!checkVisibility(button, scope, true)) return null;
+
+      // 检查权限
+      const permission =
+        button.per ||
+        button.hasPermi ||
+        (button.key && options.permission?.[button.key]);
+
+      if (
+        permission &&
+        options.checkPermission &&
+        !options.checkPermission(permission)
+      ) {
+        return null;
+      }
+
+      // 处理子按钮
+      if (button.children?.length) {
+        const children = filterButtons(
+          button.children,
+          options,
+          scope,
+          position
+        );
+        if (children.length === 0) return null;
+        button = { ...button, children };
+      }
+
+      // 应用自定义控制
+      return options.controlButton?.(position, button, scope) || button;
+    })
+    .filter(Boolean);
+}

package/src/utils/mergeTemp.js

@@ -0,0 +1,124 @@
+import resolveTemp from "src/template";
+import {
+  merge,
+  isEmpty,
+  get,
+  isPlainObject,
+  isFunction,
+  isArray,
+  cloneDeep,
+} from "lodash-es";
+
+// swapMerge 是否交换合并顺序
+export function mergeTemp(
+  prefix,
+  key,
+  item,
+  scope,
+  templates = {},
+  swapMerge = false
+) {
+  if (key) {
+    let mergeItem;
+    delete item.presetType;
+    if (typeof key === "string") {
+      templates = Object.assign(templates, get(resolveTemp, prefix));
+      mergeItem = templates && templates[key];
+      if (mergeItem) {
+        if (isFunction(mergeItem)) {
+          mergeItem = mergeItem(item, scope);
+        } else {
+          mergeItem = cloneDeep(mergeItem);
+        }
+        const raw = cloneDeep(mergeItem);
+        mergeItem.key = typeof key === "string" ? key : "";
+        item = swapMerge ? merge(item, mergeItem) : merge(mergeItem, item);
+        if (item.raw) {
+          item.raw = merge(item.raw, raw);
+        } else {
+          item.raw = raw;
+        }
+        if (item.presetType) {
+          item = mergeTemp(
+            prefix,
+            item.presetType,
+            item,
+            scope,
+            templates,
+            swapMerge
+          );
+        }
+      }
+    } else {
+      mergeItem = key;
+    }
+  }
+  if (Array.isArray(item.children) && item.children.length) {
+    item.children = batchMerge(
+      prefix,
+      item.children,
+      scope,
+      templates,
+      swapMerge
+    );
+  }
+  return item;
+}
+
+export function batchMerge(prefix, item, scope, templates, swapMerge) {
+  const items = [];
+  if (isPlainObject(item)) {
+    Object.keys(item).forEach((key) => {
+      if (key === "handles") {
+        items.push(...batchMerge(prefix, item[key], scope, templates));
+      } else if (isPlainObject(item[key]) || item[key] === true) {
+        if (item[key] === true) item[key] = {};
+        const mergeItem = mergeTemp(
+          prefix,
+          key,
+          item[key],
+          scope,
+          templates,
+          swapMerge
+        );
+        if (!isEmpty(mergeItem)) items.push(mergeItem);
+      }
+    });
+  }
+  if (isArray(item)) {
+    item.forEach((i) => {
+      if (isPlainObject(i)) {
+        const mergeItem = mergeTemp(
+          prefix,
+          i.presetType,
+          i,
+          scope,
+          templates,
+          swapMerge
+        );
+        if (!isEmpty(mergeItem)) items.push(mergeItem);
+      } else if (typeof i === "string") {
+        const mergeItem = mergeTemp(prefix, i, {}, scope, templates, swapMerge);
+        if (!isEmpty(mergeItem)) items.push(mergeItem);
+        else items.push(i);
+      } else {
+        if (!isEmpty(i)) items.push(i);
+      }
+    });
+  }
+  return items.sort((a, b) => (a.order || 0) - (b.order || 0));
+}
+
+export function singleMerge(prefix, key, item) {
+  if (typeof key === "string") {
+    let temp = get(resolveTemp, prefix);
+    temp = temp && temp[key];
+    if (temp) {
+      if (isFunction(temp)) {
+        temp = temp(item);
+      }
+      return temp;
+    }
+  }
+  return key;
+}

package/styles/button.scss

@@ -0,0 +1,3 @@
+.sc-button + .sc-button {
+  margin-left: 10px;
+}