@das-fed/utils 1.0.0

package/common-info/setInfoFromUrl.js

@@ -0,0 +1,156 @@
+/*! js-cookie v3.0.5 | MIT */
+/* eslint-disable no-var */
+function assign (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target
+}
+/* eslint-enable no-var */
+
+/* eslint-disable no-var */
+var defaultConverter = {
+  read: function (value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent)
+  },
+  write: function (value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    )
+  }
+};
+/* eslint-enable no-var */
+
+/* eslint-disable no-var */
+
+function init (converter, defaultAttributes) {
+  function set (name, value, attributes) {
+    if (typeof document === 'undefined') {
+      return
+    }
+
+    attributes = assign({}, defaultAttributes, attributes);
+
+    if (typeof attributes.expires === 'number') {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+
+    name = encodeURIComponent(name)
+      .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
+      .replace(/[()]/g, escape);
+
+    var stringifiedAttributes = '';
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue
+      }
+
+      stringifiedAttributes += '; ' + attributeName;
+
+      if (attributes[attributeName] === true) {
+        continue
+      }
+
+      // Considers RFC 6265 section 5.2:
+      // ...
+      // 3.  If the remaining unparsed-attributes contains a %x3B (";")
+      //     character:
+      // Consume the characters of the unparsed-attributes up to,
+      // not including, the first %x3B (";") character.
+      // ...
+      stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];
+    }
+
+    return (document.cookie =
+      name + '=' + converter.write(value, name) + stringifiedAttributes)
+  }
+
+  function get (name) {
+    if (typeof document === 'undefined' || (arguments.length && !name)) {
+      return
+    }
+
+    // To prevent the for loop in the first place assign an empty array
+    // in case there are no cookies at all.
+    var cookies = document.cookie ? document.cookie.split('; ') : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split('=');
+      var value = parts.slice(1).join('=');
+
+      try {
+        var found = decodeURIComponent(parts[0]);
+        jar[found] = converter.read(value, found);
+
+        if (name === found) {
+          break
+        }
+      } catch (e) {}
+    }
+
+    return name ? jar[name] : jar
+  }
+
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function (name, attributes) {
+        set(
+          name,
+          '',
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function (attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes))
+      },
+      withConverter: function (converter) {
+        return init(assign({}, this.converter, converter), this.attributes)
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  )
+}
+
+var api = init(defaultConverter, { path: '/' });
+
+const getUrlToken = () => {
+  const search = new URL(location.href).searchParams;
+  const token = search.get("token") || search.get("accessToken") || search.get("accesstoken") || "";
+  if (token) {
+    const tokenInfo = JSON.stringify({ access_token: token });
+    sessionStorage.setItem("accessToken", token);
+    sessionStorage.setItem("tokenInfo", tokenInfo);
+    api.set("accessToken", token);
+    api.set("accessTokenInfo", tokenInfo);
+  }
+};
+const getProjectInfoFromQuery = () => {
+  const preProject = JSON.parse(sessionStorage.getItem("projectInfo") || "{}");
+  const search = new URL(location.href).searchParams;
+  const id = search.get("project") || search.get("projectId") || "";
+  if (!id)
+    return;
+  const parentId = search.get("projectParent") || search.get("projectParentId") || preProject?.parentId || "";
+  const name = search.get("projectName") || preProject?.name || "";
+  sessionStorage.setItem("project", id);
+  sessionStorage.setItem("projectInfo", JSON.stringify({ ...preProject, id, name, parentId }));
+};
+
+export { getProjectInfoFromQuery, getUrlToken };

package/common-tools/arr-tools.js

@@ -0,0 +1,15 @@
+const arrEqual = (a, b, isSort = true) => {
+  if (a.length !== b.length)
+    return false;
+  if (isSort) {
+    return a.sort().toString() === b.sort().toString();
+  } else {
+    return a.toString() === b.toString();
+  }
+};
+const arrUnique = (arr, val) => {
+  const res = /* @__PURE__ */ new Map();
+  return arr.filter((item) => !res.has(item[val]) && res.set(item[val], 1));
+};
+
+export { arrEqual, arrUnique };

package/common-tools/date-format.js

@@ -0,0 +1,22 @@
+const dateFormat = (value, fmt = "yyyy-MM-dd HH:mm:ss") => {
+  let date = value ? new Date(value) : /* @__PURE__ */ new Date();
+  var o = {
+    "M+": date.getMonth() + 1,
+    "d+": date.getDate(),
+    "H+": date.getHours(),
+    "m+": date.getMinutes(),
+    "s+": date.getSeconds(),
+    "q+": Math.floor((date.getMonth() + 3) / 3),
+    S: date.getMilliseconds()
+  };
+  var year = date.getFullYear().toString();
+  year = year.length >= 4 ? year : "0000".substr(0, 4 - year.length) + year;
+  if (/(y+)/.test(fmt))
+    fmt = fmt.replace(RegExp.$1, (year + "").substr(4 - RegExp.$1.length));
+  for (var k in o)
+    if (new RegExp("(" + k + ")").test(fmt))
+      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
+  return fmt;
+};
+
+export { dateFormat };

package/common-tools/get-url-params.js

@@ -0,0 +1,92 @@
+const getUrlParams = (allUrl, name) => {
+  let search = window.location.search || "";
+  if (allUrl && allUrl !== location.href) {
+    const index = allUrl.indexOf("?");
+    if (index !== -1) {
+      search = allUrl.slice(index);
+    } else {
+      search = "";
+    }
+  }
+  const params = new URLSearchParams(search);
+  if (name) {
+    return params.get(name);
+  } else {
+    let allParams = {};
+    for (let [key, value] of params.entries()) {
+      allParams[key] = value;
+    }
+    return allParams;
+  }
+};
+const getFullPath = (url, params = {}) => {
+  let result = "";
+  let query = "";
+  const keys = Object.keys(params);
+  if (keys && keys.length) {
+    keys.forEach((key, index) => {
+      if (index === keys.length - 1) {
+        query += `${key}=${params[key]}`;
+      } else {
+        query += `${key}=${params[key]}&`;
+      }
+    });
+  }
+  if (query) {
+    result = location.origin + url + `?${query}`;
+  } else {
+    result = location.origin + url;
+  }
+  return result;
+};
+const funcUrlDel = (names, url) => {
+  const preUrl = url ? url : location.href;
+  const params = getUrlParams(preUrl);
+  const keys = Object.keys(params) || [];
+  if (!keys || !keys.length)
+    return preUrl.includes("?") ? preUrl.split("?")[0] : preUrl.split("&")[0];
+  let paramsResult = keys.filter((item) => !names.includes(item));
+  if (!paramsResult || !paramsResult.length)
+    return preUrl.includes("?") ? preUrl.split("?")[0] : preUrl.split("&")[0];
+  let query = "";
+  paramsResult.forEach((key, index) => {
+    if (index === keys.length - 1) {
+      query += `${key}=${params[key]}`;
+    } else {
+      query += `${key}=${params[key]}&`;
+    }
+  });
+  return preUrl.includes("?") ? preUrl.split("?")[0] + `?${query}` : preUrl.split("&")[0] + `?${query}`;
+};
+const urlParamsToObject = (url) => {
+  const searchParams = new URLSearchParams(url.split("?")[1]);
+  const params = {};
+  for (const [key, value] of searchParams) {
+    if (params.hasOwnProperty(key)) {
+      if (Array.isArray(params[key])) {
+        params[key].push(value);
+      } else {
+        params[key] = [params[key], value];
+      }
+    } else {
+      params[key] = value;
+    }
+  }
+  return params;
+};
+const objectToUrlparams = (params) => {
+  let query = "";
+  const keys = Object.keys(params);
+  if (keys && keys.length) {
+    keys.forEach((key, index) => {
+      if (index === keys.length - 1) {
+        query += `${key}=${params[key]}`;
+      } else {
+        query += `${key}=${params[key]}&`;
+      }
+    });
+  }
+  return query;
+};
+
+export { funcUrlDel, getFullPath, getUrlParams, objectToUrlparams, urlParamsToObject };

package/common-tools/handle-data.js

@@ -0,0 +1,5 @@
+const isEmpty = (value) => {
+  return !!(value === null || typeof value === "undefined" || value === "");
+};
+
+export { isEmpty };

package/common-tools/index.js

@@ -0,0 +1,213 @@
+const dateFormat = (value, fmt = "yyyy-MM-dd HH:mm:ss") => {
+  let date = value ? new Date(value) : /* @__PURE__ */ new Date();
+  var o = {
+    "M+": date.getMonth() + 1,
+    "d+": date.getDate(),
+    "H+": date.getHours(),
+    "m+": date.getMinutes(),
+    "s+": date.getSeconds(),
+    "q+": Math.floor((date.getMonth() + 3) / 3),
+    S: date.getMilliseconds()
+  };
+  var year = date.getFullYear().toString();
+  year = year.length >= 4 ? year : "0000".substr(0, 4 - year.length) + year;
+  if (/(y+)/.test(fmt))
+    fmt = fmt.replace(RegExp.$1, (year + "").substr(4 - RegExp.$1.length));
+  for (var k in o)
+    if (new RegExp("(" + k + ")").test(fmt))
+      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
+  return fmt;
+};
+
+const getUrlParams = (allUrl, name) => {
+  let search = window.location.search || "";
+  if (allUrl && allUrl !== location.href) {
+    const index = allUrl.indexOf("?");
+    if (index !== -1) {
+      search = allUrl.slice(index);
+    } else {
+      search = "";
+    }
+  }
+  const params = new URLSearchParams(search);
+  if (name) {
+    return params.get(name);
+  } else {
+    let allParams = {};
+    for (let [key, value] of params.entries()) {
+      allParams[key] = value;
+    }
+    return allParams;
+  }
+};
+const getFullPath = (url, params = {}) => {
+  let result = "";
+  let query = "";
+  const keys = Object.keys(params);
+  if (keys && keys.length) {
+    keys.forEach((key, index) => {
+      if (index === keys.length - 1) {
+        query += `${key}=${params[key]}`;
+      } else {
+        query += `${key}=${params[key]}&`;
+      }
+    });
+  }
+  if (query) {
+    result = location.origin + url + `?${query}`;
+  } else {
+    result = location.origin + url;
+  }
+  return result;
+};
+const funcUrlDel = (names, url) => {
+  const preUrl = url ? url : location.href;
+  const params = getUrlParams(preUrl);
+  const keys = Object.keys(params) || [];
+  if (!keys || !keys.length)
+    return preUrl.includes("?") ? preUrl.split("?")[0] : preUrl.split("&")[0];
+  let paramsResult = keys.filter((item) => !names.includes(item));
+  if (!paramsResult || !paramsResult.length)
+    return preUrl.includes("?") ? preUrl.split("?")[0] : preUrl.split("&")[0];
+  let query = "";
+  paramsResult.forEach((key, index) => {
+    if (index === keys.length - 1) {
+      query += `${key}=${params[key]}`;
+    } else {
+      query += `${key}=${params[key]}&`;
+    }
+  });
+  return preUrl.includes("?") ? preUrl.split("?")[0] + `?${query}` : preUrl.split("&")[0] + `?${query}`;
+};
+const urlParamsToObject = (url) => {
+  const searchParams = new URLSearchParams(url.split("?")[1]);
+  const params = {};
+  for (const [key, value] of searchParams) {
+    if (params.hasOwnProperty(key)) {
+      if (Array.isArray(params[key])) {
+        params[key].push(value);
+      } else {
+        params[key] = [params[key], value];
+      }
+    } else {
+      params[key] = value;
+    }
+  }
+  return params;
+};
+const objectToUrlparams = (params) => {
+  let query = "";
+  const keys = Object.keys(params);
+  if (keys && keys.length) {
+    keys.forEach((key, index) => {
+      if (index === keys.length - 1) {
+        query += `${key}=${params[key]}`;
+      } else {
+        query += `${key}=${params[key]}&`;
+      }
+    });
+  }
+  return query;
+};
+
+const findNonEmptyChildrenItems = (arr, children = "children") => {
+  let result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i][children] && arr[i][children].length > 0) {
+      result.push(arr[i]);
+      result = result.concat(findNonEmptyChildrenItems(arr[i][children]));
+    }
+  }
+  return result;
+};
+const flatTree = (list, child = "children", deleteChild = true) => {
+  if (Array.isArray(list) && list.length) {
+    return list.reduce((ls, item) => {
+      let children = item[child];
+      let res = { ...item };
+      if (deleteChild) {
+        delete res[child];
+      }
+      if (children && children.length) {
+        return ls.concat(res, flatTree(children, child, deleteChild));
+      } else {
+        return ls.concat(res);
+      }
+    }, []);
+  } else {
+    return [];
+  }
+};
+const filterTreeArray = (tree, predicate, children = "children") => {
+  return tree.filter((item) => {
+    return predicate(item);
+  }).map((item) => {
+    item = Object.assign({}, item);
+    if (item[children]) {
+      item[children] = filterTreeArray(item[children], predicate);
+    }
+    return item;
+  });
+};
+const treeFind = (tree, func) => {
+  for (const data of tree) {
+    if (func(data))
+      return data;
+    if (data?.children && data.children.length) {
+      const res = treeFind(data.children, func);
+      if (res)
+        return res;
+    }
+  }
+  return null;
+};
+
+const objEqual = (a, b) => {
+  if (!a || !b)
+    return false;
+  if (Object.keys(a).length !== Object.keys(b).length)
+    return false;
+  for (let key in a) {
+    if (b[key] === void 0)
+      return false;
+    if (typeof b[key] === "function" || typeof a[key] === "function")
+      throw new Error("type error");
+    if (typeof b[key] != typeof a[key])
+      return false;
+    if (typeof a[key] === "object")
+      return objEqual(a[key], b[key]);
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
+};
+
+const arrEqual = (a, b, isSort = true) => {
+  if (a.length !== b.length)
+    return false;
+  if (isSort) {
+    return a.sort().toString() === b.sort().toString();
+  } else {
+    return a.toString() === b.toString();
+  }
+};
+const arrUnique = (arr, val) => {
+  const res = /* @__PURE__ */ new Map();
+  return arr.filter((item) => !res.has(item[val]) && res.set(item[val], 1));
+};
+
+const isEmpty = (value) => {
+  return !!(value === null || typeof value === "undefined" || value === "");
+};
+
+const setHtmlMinWH = (layout) => {
+  let minWidth = "", minHeight = "";
+  if (layout?.minWidth)
+    minWidth = layout.minWidth;
+  if (layout?.minHeight)
+    minHeight = layout.minHeight;
+  document.documentElement.style.minWidth = minWidth;
+  document.documentElement.style.minHeight = minHeight;
+};
+
+export { arrEqual, arrUnique, dateFormat, filterTreeArray, findNonEmptyChildrenItems, flatTree, funcUrlDel, getFullPath, getUrlParams, isEmpty, objEqual, objectToUrlparams, setHtmlMinWH, treeFind, urlParamsToObject };

package/common-tools/nest-tree-format.js

@@ -0,0 +1,53 @@
+const findNonEmptyChildrenItems = (arr, children = "children") => {
+  let result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i][children] && arr[i][children].length > 0) {
+      result.push(arr[i]);
+      result = result.concat(findNonEmptyChildrenItems(arr[i][children]));
+    }
+  }
+  return result;
+};
+const flatTree = (list, child = "children", deleteChild = true) => {
+  if (Array.isArray(list) && list.length) {
+    return list.reduce((ls, item) => {
+      let children = item[child];
+      let res = { ...item };
+      if (deleteChild) {
+        delete res[child];
+      }
+      if (children && children.length) {
+        return ls.concat(res, flatTree(children, child, deleteChild));
+      } else {
+        return ls.concat(res);
+      }
+    }, []);
+  } else {
+    return [];
+  }
+};
+const filterTreeArray = (tree, predicate, children = "children") => {
+  return tree.filter((item) => {
+    return predicate(item);
+  }).map((item) => {
+    item = Object.assign({}, item);
+    if (item[children]) {
+      item[children] = filterTreeArray(item[children], predicate);
+    }
+    return item;
+  });
+};
+const treeFind = (tree, func) => {
+  for (const data of tree) {
+    if (func(data))
+      return data;
+    if (data?.children && data.children.length) {
+      const res = treeFind(data.children, func);
+      if (res)
+        return res;
+    }
+  }
+  return null;
+};
+
+export { filterTreeArray, findNonEmptyChildrenItems, flatTree, treeFind };

package/common-tools/obj-tools.js

@@ -0,0 +1,21 @@
+const objEqual = (a, b) => {
+  if (!a || !b)
+    return false;
+  if (Object.keys(a).length !== Object.keys(b).length)
+    return false;
+  for (let key in a) {
+    if (b[key] === void 0)
+      return false;
+    if (typeof b[key] === "function" || typeof a[key] === "function")
+      throw new Error("type error");
+    if (typeof b[key] != typeof a[key])
+      return false;
+    if (typeof a[key] === "object")
+      return objEqual(a[key], b[key]);
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
+};
+
+export { objEqual };

package/common-tools/setHtmlMinWH.js

@@ -0,0 +1,11 @@
+const setHtmlMinWH = (layout) => {
+  let minWidth = "", minHeight = "";
+  if (layout?.minWidth)
+    minWidth = layout.minWidth;
+  if (layout?.minHeight)
+    minHeight = layout.minHeight;
+  document.documentElement.style.minWidth = minWidth;
+  document.documentElement.style.minHeight = minHeight;
+};
+
+export { setHtmlMinWH };

package/common-tools/throttled.js

@@ -0,0 +1,19 @@
+function throttled(fn, delay = 300) {
+  let timer = null;
+  let starttime = Date.now();
+  return function() {
+    let curTime = Date.now();
+    let remaining = delay - (curTime - starttime);
+    let context = this;
+    let args = arguments;
+    clearTimeout(timer);
+    if (remaining <= 0) {
+      fn.apply(context, args);
+      starttime = Date.now();
+    } else {
+      timer = setTimeout(fn, remaining);
+    }
+  };
+}
+
+export { throttled };

package/config/index.js

@@ -0,0 +1,26 @@
+const getConfig = () => {
+  let windowConfig = window?.config || {};
+  let config = { ...windowConfig };
+  if (!config.rootContainer)
+    config.rootContainer = "#app";
+  if (!config.baseURL)
+    config.baseURL = location.origin;
+  if (!config.ossBaseURL)
+    config.ossBaseURL = "/oss";
+  if (config.ossBaseURL.startsWith("/"))
+    config.ossBaseURL = `${config.baseURL}/oss`;
+  if (!config.ssoBaseURL)
+    config.ssoBaseURL = config.baseURL;
+  let { microAppName, publicPath, mainAppName } = config;
+  const isPro = import.meta.env.PROD;
+  if (microAppName && isPro && !publicPath)
+    publicPath = `/${microAppName}/`.replace(/\/\//g, "/");
+  if (!publicPath)
+    publicPath = "/";
+  config.publicPath = publicPath;
+  if (!config.autoOssBucket)
+    config.autoOssBucket = mainAppName || microAppName;
+  return config;
+};
+
+export { getConfig };