@arkxos/arkos-system 0.1.0

package/src/utils/tool.js

@@ -0,0 +1,431 @@
+export const uuid = () => {
+  const timeStr = fillLength(new Date().getTime().toString(16), 12, '0');
+  const s = [];
+  const hexDigits = '0123456789abcdef';
+  for (let i = 0; i < 20 - timeStr.length; i++) {
+    s[i] = hexDigits.charAt(Math.floor(Math.random() * 0x10));
+  }
+  return timeStr + s.join('');
+};
+
+export const uuids = () => {
+  const timeStr = fillLength(new Date().getTime().toString(16), 12, '0');
+  const s = [];
+  const hexDigits = '0123456789abcdef';
+  for (let i = 0; i < 20 - timeStr.length; i++) {
+    s[i] = hexDigits.charAt(Math.floor(Math.random() * 0x10));
+  }
+  return 's_' + timeStr + s.join('');
+};
+
+export const uuid36 = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+};
+
+export const fillLength = (str, len, fillStr) => {
+  if (typeof str === 'undefined' || str == null) {
+    str = '';
+  }
+  if (typeof fillStr === 'undefined' || fillStr == null || fillStr === '') {
+    fillStr = '0';
+  }
+
+  const fillLen = ((len || 0) - str.length) / fillStr.length;
+  if (fillLen > 0) {
+    for (let i = 0; i < fillLen; i++) {
+      str = fillStr + str;
+    }
+  }
+
+  return str;
+};
+
+export const groupBy = (array, groupByFn, sortFn) => {
+  const groups = {};
+  array.forEach(function (item) {
+    const group = JSON.stringify(groupByFn(item));
+    groups[group] = groups[group] || [];
+    groups[group].push(item);
+  });
+
+  const result = [];
+  Object.keys(groups).map(function(group) {
+    if (sortFn) {
+      groups[group].sort(sortFn);
+    }
+    result.push(groups[group]);
+  });
+
+  return result;
+};
+
+export const deepClone = (obj, filterFn = undefined) => {
+  const _toString = Object.prototype.toString;
+
+  if (!obj || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (obj.nodeType && 'cloneNode' in obj) {
+    return obj.cloneNode(true);
+  }
+
+  if (_toString.call(obj) === '[object Date]') {
+    return new Date(obj.getTime());
+  }
+
+  if (_toString.call(obj) === '[object RegExp]') {
+    const flags = [];
+    if (obj.global) { flags.push('g') }
+    if (obj.multiline) { flags.push('m') }
+    if (obj.ignoreCase) { flags.push('i') }
+
+    return new RegExp(obj.source, flags.join(''));
+  }
+
+  const result = Array.isArray(obj) ? [] : obj.constructor ? new obj.constructor() : {};
+
+  for (const key in obj) {
+    if (typeof filterFn === 'undefined' || filterFn(key, obj)) {
+      result[key] = deepClone(obj[key], filterFn);
+    }
+  }
+
+  return result;
+};
+
+export const walkProp = (obj, walkFn) => {
+  const _toString = Object.prototype.toString;
+
+  if (!obj || typeof obj !== 'object') {
+    return;
+  }
+
+  if (_toString.call(obj) === '[object Date]') {
+    return;
+  }
+
+  if (_toString.call(obj) === '[object RegExp]') {
+    return;
+  }
+
+  for (const key in obj) {
+    walkFn(key, obj);
+    walkProp(obj[key], walkFn);
+  }
+};
+
+export const formatNumber = (number, pattern, prmNullValue) => {
+  if (number == null || number === '') return prmNullValue || '';
+  if (pattern == null || pattern === '') return number;
+
+  if (!isNaN(pattern)) {
+    const length = parseInt(pattern);
+    if (length > 0) {
+      pattern = '0.' + fillLength('', parseInt(pattern), '0') + '#';
+    } else {
+      pattern = '0.#';
+    }
+  }
+
+  number = (number + '').replace(/,/g, '');
+  if (isNaN(number)) return number;
+
+  const patternLen = pattern.length;
+  let pointIndex = pattern.indexOf('.');
+  const groupIndex = pattern.indexOf(',');
+  const pointLen = (pointIndex === -1 ? 0 : patternLen - pointIndex - 1);
+  let result = parseFloat(number).toFixed(pointLen) + '';
+  if (groupIndex !== -1) {
+    if (pointIndex === -1) pointIndex = patternLen;
+    const len = pointIndex - groupIndex - 1;
+    const reg = new RegExp('(-?\\d+)(\\d{' + len + '})');
+    while (reg.test(result)) {
+      result = result.replace(reg, '$1,$2');
+    }
+  }
+
+  if (pointLen > 0) {
+    for (let i = pattern.length; i--; i > pattern.indexOf('.')) {
+      if (pattern.charAt(i) === '0' ||
+          !(result.charAt(result.length - 1) === '0' ||
+              result.charAt(result.length - 1) === '.')) {
+        break;
+      }
+      result = result.substring(0, result.length - 1);
+      if (pattern.charAt(i) === '.') {
+        break;
+      }
+    }
+  }
+  return result;
+};
+
+export const formatNumberWithCommas = (number) => {
+  const parts = number.toString().split('.');
+  const integerPart = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+  if (parts.length > 1) {
+    return integerPart + '.' + parts[1];
+  } else {
+    return integerPart;
+  }
+};
+
+export const formatMoney = (number, precision) => {
+  const fixedAmount = Number(number).toFixed(precision || 0);
+  const [integerPart, decimalPart] = fixedAmount.split('.');
+  const integerWithCommas = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+  return decimalPart ? `${integerWithCommas}.${decimalPart}` : `${integerWithCommas}`;
+};
+
+export const isDeepEqual = (obj1, obj2) => {
+  if (obj1 === obj2) {
+    return true;
+  }
+
+  if (typeof obj1 !== typeof obj2) {
+    return false;
+  }
+
+  if (Array.isArray(obj1) !== Array.isArray(obj2)) {
+    return false;
+  }
+
+  if (typeof obj1 === 'object' && obj1 !== null && obj2 !== null) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+
+    for (const key of keys1) {
+      if (!Object.prototype.hasOwnProperty.call(obj2, key)) {
+        return false;
+      }
+
+      if (!isDeepEqual(obj1[key], obj2[key])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return obj1 === obj2;
+};
+
+const getFunArgs = (func) => {
+  return func.toString()
+    .match(/function\s.*?\(([^)]*)\)/)[1]
+    .split(',')
+    .map(arg => arg.replace(/\/\*.*\*\//, '').trim())
+    .filter(args => args);
+};
+
+/**
+ * 遍历所有树节点
+ * @param tree
+ * @param walkFn
+ */
+const walkTree = (tree, walkFn) => {
+  for (const node of tree.children || []) {
+    walkFn && walkFn(node);
+    walkTree(node, walkFn);
+  }
+}
+
+/**
+ * 遍历所有树节点
+ * @param tree
+ * @param walkFn
+ */
+const asyncWalkTree = async(tree, walkFn) => {
+  for (const node of tree.children || []) {
+    walkFn && await walkFn(node);
+    await asyncWalkTree(node, walkFn);
+  }
+}
+
+const formatTime = (milliseconds) => {
+  if (!milliseconds) return '';
+  if (milliseconds < 1000) return milliseconds.toFixed(0) + ' 毫秒';
+  const dayMilliseconds = 24 * 60 * 60 * 1000;
+  const hourMilliseconds = 60 * 60 * 1000;
+  const minuteMilliseconds = 60 * 1000;
+
+  const days = parseInt(milliseconds / dayMilliseconds);
+  const hours = parseInt(milliseconds % dayMilliseconds / hourMilliseconds);
+  const minutes = parseInt(milliseconds % hourMilliseconds / minuteMilliseconds);
+  const seconds = parseInt(milliseconds % minuteMilliseconds / 1000);
+
+  const result = [];
+  if (days) result.push(days + ' 天 ');
+  if (hours || days) result.push(hours + ' 小时 ');
+  if (minutes || hours || days) result.push(minutes + ' 分 ');
+  if (seconds || minutes || hours || days) result.push(seconds + ' 秒');
+  return result.join('');
+};
+
+const randomString = (length) => {
+  const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters[randomIndex];
+  }
+  return result;
+};
+
+const getContextPath = () => {
+  const url = window.location.pathname;
+  const paths = url.split('/');
+  let contextPath = '/';
+  for (const path of paths) {
+    if (!path || path.indexOf('.html') > 0) continue;
+    contextPath += path + '/';
+  }
+  return contextPath;
+};
+
+const escapeHtml = (str) => {
+  if (!str) return '';
+  return str.replaceAll(/</ig, '&lt;').replaceAll(/>/ig, '&gt;')
+};
+
+const findNode = (id, children) => {
+  if (children === undefined || children == null || id === undefined || id == null) {
+    return null;
+  }
+
+  for (let i = 0; i < children.length; i++) {
+    if (children[i].id !== '0' && children[i].id === id) {
+      return children[i];
+    }
+
+    if (children[i].children !== undefined && children[i].children != null) {
+      const node = findNode(id, children[i].children);
+      if (node) {
+        return node;
+      }
+    }
+  }
+
+  return null;
+};
+
+const getParentNodes = (tree, targetId) => {
+  const result = [];
+
+  function traverse(node, path) {
+    if (!node) return false;
+
+    if (node.id === targetId) {
+      return true;
+    }
+
+    for (const child of (node.children || [])) {
+      path.push(node);
+      if (traverse(child, path)) {
+        return true;
+      }
+      path.pop();
+    }
+
+    return false;
+  }
+
+  traverse(tree, result);
+  return result;
+};
+
+const findNodeById = (tree, targetId) => {
+  function traverse(node) {
+    if (!node) return null;
+
+    if (node.id === targetId) {
+      return node;
+    }
+
+    for (const child of node.children) {
+      const foundNode = traverse(child);
+      if (foundNode) {
+        return foundNode;
+      }
+    }
+
+    return null;
+  }
+
+  return traverse(tree);
+};
+
+const getMoneyInt = (money) => {
+  money = parseFloat(money || '0').toFixed(2);
+  return money.split('.')[0];
+};
+
+const getMoneyScale = (money) => {
+  money = parseFloat(money || '0').toFixed(2);
+  return money.split('.')[1];
+};
+
+const debounce = (fn, delay = 100) => {
+  let timer = null;
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), delay);
+  };
+};
+
+const throttle = (func, limit) => {
+  let lastFunc;
+  let lastRan;
+  return function() {
+    const context = this;
+    const args = arguments;
+    if (!lastRan) {
+      func.apply(context, args);
+      lastRan = Date.now();
+    } else {
+      clearTimeout(lastFunc);
+      lastFunc = setTimeout(function() {
+        if ((Date.now() - lastRan) >= limit) {
+          func.apply(context, args);
+          lastRan = Date.now();
+        }
+      }, limit - (Date.now() - lastRan));
+    }
+  }
+};
+
+export default {
+  uuid,
+  uuid36,
+  uuids,
+  groupBy,
+  deepClone,
+  walkProp,
+  walkTree,
+  asyncWalkTree,
+  formatMoney,
+  formatNumber,
+  formatNumberWithCommas,
+  isDeepEqual,
+  getFunArgs,
+  formatTime,
+  randomString,
+  getContextPath,
+  escapeHtml,
+  findNode,
+  getParentNodes,
+  findNodeById,
+  getMoneyInt,
+  getMoneyScale,
+  debounce,
+  throttle
+};

package/src/utils/websocket.js

@@ -0,0 +1,124 @@
+import emitter from '@/utils/bus';
+
+let lock = false;
+let socket = null;
+let isConnect = false;
+const intervalTime = 20 * 1000;
+let intervalObject = null;
+const subscribeTopics = [];
+let connectTimes = 0;
+
+const connect = () => {
+  if (connectTimes > 10) return;
+
+  connectTimes++;
+  if ('WebSocket' in window) {
+    const ip = window.location.hostname;
+    const port = window.location.port || '80';
+    const context = '/';
+    const protocol = window.location.protocol;
+    let wsUrl;
+    if (protocol.startsWith('https')) {
+      wsUrl = 'wss://' + ip + context + '/websocket';
+    } else {
+      wsUrl = 'ws://' + ip + (port === '80' ? '' : (':' + port)) + context + '/websocket';
+    }
+    socket = new WebSocket(wsUrl);
+    socket.onopen = onOpen;
+    socket.onmessage = onMessage;
+    socket.onclose = onClose;
+    socket.onerror = onError;
+  } else {
+    console.log('浏览器不支持 WebSocket ！')
+  }
+};
+
+const onOpen = () => {
+  connectTimes = 0;
+  isConnect = true;
+  startMonitor();
+  subscribeTopics.forEach(topic => send({ type: topic }));
+};
+
+const onMessage = (res) => {
+  try {
+    const data = JSON.parse(res.data);
+    if (data.topic === 'heartbeat') {
+      // 心跳，不用处理
+    } else if (data.topic === 'model.data.change') {
+      emitter.emit(data.topic + '.' + data.message);
+    } else {
+      emitter.emit(data.topic, data.message || '');
+    }
+  } catch (e) {
+    console.log('websocket 消息处理失败！', e);
+  }
+};
+
+const onClose = (res) => {
+  console.log('websocket 连接关闭！', res);
+  isConnect = false;
+  reconnect();
+};
+
+const onError = (res) => {
+  console.log('websocket 出错！', res);
+};
+
+const startMonitor = () => {
+  if (intervalObject != null) {
+    clearInterval(intervalObject);
+    intervalObject = null;
+  }
+
+  intervalObject = setInterval(() => {
+    if (socket.readyState !== 1) {
+      try {
+        socket.close();
+      } catch (e) {
+        console.log('websocket 异常时关闭出错！', e);
+      }
+      clearInterval(intervalObject);
+      reconnect();
+    } else {
+      sendHeartbeat();
+    }
+  }, intervalTime);
+};
+
+const reconnect = () => {
+  if (lock) return;
+
+  lock = true;
+  setTimeout(() => {
+    connect();
+    lock = false;
+  }, 5 * 1000);
+};
+
+const addTopics = (topics) => {
+  topics.forEach(topic => {
+    if (!subscribeTopics.includes(topic)) {
+      subscribeTopics.push(topic);
+      if (isConnect) {
+        send({ type: topic });
+      }
+    }
+  });
+};
+
+const sendHeartbeat = () => {
+  send({ type: 'heartbeat', message: 'ping' });
+};
+
+const send = (data) => {
+  if (!data) return;
+  socket.send(JSON.stringify(data));
+};
+
+const close = () => {
+  isConnect = false;
+  socket.close();
+};
+
+export default { connect, addTopics, send, close };