logic-helper/src/utils/util.js

This template should help get you started developing with Vue 3 in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.

import WsEventBus from 'ws-event-bus';
import {
    markRaw
} from 'vue';
import Immutable  from 'immutable';
import { ElMessage } from 'element-plus'
export const getObjType = (obj) => {
    var toString = Object.prototype.toString;
    var map = {
        '[object Boolean]': 'boolean',
        '[object Number]': 'number',
        '[object String]': 'string',
        '[object Function]': 'function',
        '[object Array]': 'array',
        '[object Date]': 'date',
        '[object RegExp]': 'regExp',
        '[object Undefined]': 'undefined',
        '[object Null]': 'null',
        '[object Object]': 'object',
        '[object Symbol]': 'symbol',
        '[object AsyncFunction]': 'function'
    };
    return map[toString.call(obj)];
};
export function deepMerge(obj={}, other) {
    if (typeof obj !== 'object' || typeof other !== 'object') {
        return other;
    }
    if (obj === other) {
        return obj;
    }
    for (let k in other) {
        if (other.hasOwnProperty(k)) {
            if (Array.isArray(other[k])&&Array.isArray(obj[k])) {
                let map ={}
                for(let v of obj[k]){
                    if(v?.id){
                        map[v.id] = v;
                    }
                }
                let val = null;
                for(let key in other[k]){
                    val = other[k][key];
                    if(typeof val == 'object'){
                        if(val.id&&map[val.id]){
                            let tmp = deepMerge(map[val.id],val)
                            other[k][key] = deepMerge(val, tmp)
                        }else {
                            obj[k][key] = deepMerge(obj[k][key],val);
                            other[k][key] = deepMerge(other[k][key],obj[k][key])
                        }
                    }else{
                        obj[k][key] = val
                    }
                }
                obj[k] = other[k];
            } else if (getObjType(other[k]) === 'object') {
                obj[k] = deepMerge(obj[k], other[k]);
            } else {
                obj[k] = other[k];
            }
        }
    }
    return obj;
}
/**
 * 对象深拷贝
 */
export const deepClone = (data) => {
    var type = getObjType(data);
    var obj;
    if (type === 'array') {
        obj = [];
    } else if (type === 'object') {
        obj = {};
    } else {
        // 不再具有下一层次
        return data;
    }
    if (type === 'array') {
        for (var i = 0, len = data.length; i < len; i++) {
            obj.push(deepClone(data[i]));
        }
    } else if (type === 'object') {
        for (var key in data) {
            obj[key] = deepClone(data[key]);
        }
    }
    return obj;
};
export const shallowClone = (data) => {
    var type = getObjType(data);
    if (type === 'array') {
        return [...data]
    } else if (type === 'object') {
        return {...data};
    } else {
        // 不再具有下一层次
        return data;
    }
}
/**
 * 判断路由是否相等
 */
export const diff = (obj1, obj2) => {
    if(obj1 === obj2){
        return true
    }
    let imObj1 = Immutable.fromJS(obj1);
    let imObj2 = Immutable.fromJS(obj2);
    return Immutable.is(imObj1, imObj2);
};

export function split(connect) {
    let connection = [];
    let original = [];

    for (let i = 0; i < connect.length; i++) {
        if (typeof connect[i] === 'string') {
            connection = connect[i].split('>').map((str) => str.trim());
        } else if (Array.isArray(connect[i])) {
            connection = connect[i];
        } else {
            throw new Error('connect must be string or array');
        }
        if (connection.length > 2) {
            connection.reduce((from, to) => {
                if (from && to) {
                    original.push([from, to]);
                }
                return to;
            });
        } else {
            original.push(connection);
        }
    }
    return original;
}

function traverseEdge(arr) {
    arr = arr.map((item) => [...item]);
    let tmp = [];
    let last = null;
    let list = null;
    let stop = true;
    arr.forEach(([from, ...to], index) => {
        last = null;
        for (let i = 0; i < tmp.length; i++) {
            list = tmp[i];
            if (list[list.length - 1] === from) {
                last = list[list.length - 1];
                stop = false;
                break;
            }
        }
        if (last !== null) {
            list.push(...to);
        } else {
            tmp.push(arr[index]);
        }
    });
    arr = tmp;
    if (!stop) {
        return traverseEdge(arr);
    }
    return arr;
}

function assemble(edges) {
    edges = traverseEdge(edges);
    edges = traverseEdge(edges.reverse()).reverse();
    return edges;
}

export function parseEdge(connect) {
    let fromMap = {},
        toMap = {};
    let points = {};
    connect = split(connect);
    for (let i = 0; i < connect.length; i++) {
        let [from, to] = connect[i];
        points[from] = 1;
        if (!fromMap[from]) {
            fromMap[from] = [];
        }
        fromMap[from].push(to);
        points[to] = 1;
        if (!toMap[to]) {
            toMap[to] = [];
        }
        toMap[to].push(from);
    }
    let starts = {
            ...points
        },
        ends = {
            ...points
        };
    let tos = {};
    let froms = {};
    for (let k in fromMap) {
        tos[k] = fromMap[k].map((val) => {
            delete starts[val];
            return val;
        });
    }
    for (let k in toMap) {
        froms[k] = toMap[k].map((val) => {
            delete ends[val];
            return val;
        });
    }
    return {
        nodes: Object.keys(points),
        inlets: froms,
        outlets: tos,
        starts: Object.keys(starts),
        ends: Object.keys(ends),
        split: connect,
        assemble: assemble(connect).map((val) => val.join('>'))
    };
}
const cacheEventBus = {};
export const getWsEventBus = (id) => {
    if (cacheEventBus[id]) {
        return cacheEventBus[id];
    }

    cacheEventBus[id] = new WsEventBus({
        id,
        url: process.env.NODE_ENV === 'production'?`ws://${location.host}`:'ws://localhost:9503'
    });
    return cacheEventBus[id];
};


function copyProperties(target, source) {
    for (let key of Reflect.ownKeys(source)) {
        if (key !== "constructor" && key !== "prototype" && key !== "name") {
            let desc = Object.getOwnPropertyDescriptor(source, key)
            Object.defineProperty(target, key, desc)
        }
    }
}
export function mixin (...mixins) {

    // 定义一个混合类
    class Mix {
        constructor() {
            for (let _class of mixins) {
                // this 指向子类Benz实例
                copyProperties(this, new _class()); // 拷贝实例属性
            }
        }
    }
    for (let mixin of mixins) {
        copyProperties(Mix, mixin)
        copyProperties(Mix.prototype, mixin.prototype)
    }
    return Mix;

}
export const getDiffOption = (oldTree,newTree,diffObj={}) =>{
    if(oldTree===newTree){
        return {}
    }
    for(let k in newTree){
        if(!diff(oldTree[k],newTree[k])){
            if(Array.isArray(newTree[k])){
                diffObj[k]=[];
                let map ={}
                if(Array.isArray(oldTree[k])){
                    for(let v of oldTree[k]){
                        if(v?.id){
                            map[v.id] = v;
                        }
                    }
                }
                newTree[k].forEach(item=>{
                    if(item?.id&&map[item.id]){
                        let obj = deepMerge(map[item.id],item);
                        diffObj[k].push(obj);
                    }else{
                        diffObj[k].push(item);
                    }
                })

            }else if (typeof oldTree[k]=="object"){
                diffObj[k] = getDiffOption(oldTree[k],newTree[k],diffObj[k])
            }else{
                diffObj[k] = newTree[k]
            }
        }
    }
    return diffObj
}
export const showToast = (data)=>{
    if(typeof data != 'object'){
        return ElMessage({
            message: data,
            type: 'success',
        })
    }
    ElMessage(data)
}
export const propsMap = {
    Step: 'steps',
    steps: 'Step',
    Conditional: 'conditionals',
    conditionals: 'Conditional',
    Start: 'start',
    start: 'Start',
    End: 'end',
    end: 'End',
    inputs: 'Input',
    Input: 'inputs',
    subroutines: 'Subroutine',
    Subroutine: 'subroutines',
    Repeat: 'repeats',
    repeats: 'Repeat',
}