gis-common 2.2.19 → 3.1.2

package/src/core/EventDispatcher.js

@@ -0,0 +1,93 @@
+function EventDispatcher() {}
+
+Object.assign(EventDispatcher.prototype, {
+    /**
+     * 添加监听器
+     * @param type{string}
+     * @param listener{function}
+     * @param mutexStatus{boolean}
+     */
+    addEventListener(type, listener, context, mutexStatus = false) {
+        if (this._listeners === undefined) this._listeners = {}
+        this._mutex = this._mutex || {}
+        this._context = context
+        const mutex = this._mutex
+        const listeners = this._listeners
+
+        if (listeners[type] === undefined) {
+            listeners[type] = []
+        }
+
+        if (listeners[type].indexOf(listener) === -1) {
+            // 如果启用功能独占
+            if (mutexStatus) {
+                mutex[type] = listener
+            }
+            listeners[type].push(listener)
+        }
+        return this
+    },
+
+    hasEventListener(type, listener) {
+        if (this._listeners === undefined) return false
+
+        const listeners = this._listeners
+
+        return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1
+    },
+
+    removeEventListener(type, listener) {
+        if (this._listeners === undefined) return
+
+        const listeners = this._listeners
+        const listenerArray = listeners[type]
+
+        // 移除指定的功能独占
+        if (this._mutex[type] === listener) {
+            this._mutex[type] = null
+        }
+
+        if (listenerArray !== undefined) {
+            const index = listenerArray.map((d) => d.toString()).indexOf(listener.toString())
+
+            if (index !== -1) {
+                listenerArray.splice(index, 1)
+            }
+        }
+    },
+
+    /**
+     * 派发事件
+     * @param event{{type: string, message: {}}}
+     */
+    dispatchEvent(event) {
+        if (this._listeners === undefined) return
+
+        const listeners = this._listeners
+        const listenerArray = listeners[event.type]
+
+        if (listenerArray !== undefined) {
+            event.target = this
+
+            // Make a copy, in case listeners are removed while iterating.
+            const array = listenerArray.slice(0)
+            if (this._mutex[event.type]) {
+                const find = array.find((item) => item === this._mutex[event.type])
+                find.call(this._context || this, event)
+                return
+            }
+            for (let i = 0, l = array.length; i < l; i++) {
+                array[i].call(this._context || this, event)
+            }
+        }
+    },
+
+    removeAllListener() {
+        this._mutex = {}
+        for (const key in this._listeners) {
+            this._listeners[key] = []
+        }
+    },
+})
+
+export default EventDispatcher

package/src/core/HashMap.js

@@ -0,0 +1,26 @@
+Object.assign(Map.prototype, {
+    isEmpty() {
+        return this.size === 0
+    },
+    _values() {
+        return Array.from(Map.prototype.values.call(this))
+    },
+    _keys() {
+        return Array.from(Map.prototype.keys.call(this))
+    },
+    _entries() {
+        return Array.from(Map.prototype.entries.call(this))
+    },
+})
+export default function HashMap() {
+    return new Map()
+}
+HashMap.fromEntries = function (array = []) {
+    const hashMap = new HashMap()
+    array.forEach((element) => {
+        if (Array.isArray(element) && element.length === 2) {
+            hashMap.set(element[0], element[1])
+        }
+    })
+    return hashMap
+}

package/src/core/MqttClient.js

@@ -0,0 +1,108 @@
+import ErrorType from "../constant/ErrorTypeConstant";
+import EventType from "../constant/EventTypeConstant";
+import CommUtils from "../utils/CommUtils";
+import EventDispatcher from "./EventDispatcher";
+import { connect } from "mqtt";
+export default class MqttClient extends EventDispatcher {
+    /**
+     * Creates an instance of MqttClient.
+     * @param {*} config mqtt实例参数
+     */
+    constructor(config = {}) {
+        super();
+        this.context = CommUtils.extend(MqttClient.defaultContext, config);
+        this.options = {
+            connectTimeout: this.context.MQTT_TIMEOUTM,
+            clientId: CommUtils.generateGuid(),
+            username: this.context.MQTT_USERNAME,
+            password: this.context.MQTT_PASSWORD,
+            clean: true,
+        };
+        this.client = connect(this.context.MQTT_SERVICE, this.options);
+        this._onConnect();
+        this._onMessage();
+        MqttClient.instance = this;
+    }
+    _onConnect() {
+        this.client.on("connect", () => {
+            console.log("链接mqtt成功==>" + this.context.MQTT_SERVICE);
+            this.dispatchEvent({ type: EventType.MQTT_CONNECT, message: this });
+        });
+        this.client.on("error", (err) => {
+            console.log("链接mqtt报错", err);
+            this.dispatchEvent({ type: EventType.MQTT_ERROR, message: this });
+            this.client.end();
+            this.client.reconnect();
+        });
+    }
+    _onMessage() {
+        this.client.on("message", (topic, message) => {
+            let dataString = message;
+            let data = "";
+            if (message instanceof Uint8Array) {
+                dataString = message.toString();
+            }
+            try {
+                data = JSON.parse(dataString);
+            } catch (error) {
+                throw new Error(ErrorType.JSON_PARSE_ERROR);
+            }
+            this.dispatchEvent({
+                type: EventType.MQTT_MESSAGE,
+                message: { topic, data },
+            });
+        });
+    }
+    sendMsg(topic, msg) {
+        if (!this.client.connected) {
+            console.error("客户端未连接");
+            return;
+        }
+        this.client.publish(topic, msg, { qos: 1, retain: true });
+    }
+    subscribe(topic) {
+        this.client.subscribe(topic, { qos: 1 }, (error, res) => {
+            if (error instanceof Error || res.length === 0) {
+                console.error(`订阅失败==>${topic}`, error);
+            } else {
+                console.log(`订阅成功==>${topic}`);
+            }
+        });
+        return this;
+    }
+    unsubscribe(topic) {
+        this.client.unsubscribe(topic, { qos: 1 }, (error, res) => {
+            if (error instanceof Error || res.length === 0) {
+                console.error(`取消订阅失败==>${topic}`, error);
+            } else {
+                console.log(`取消订阅成功==>${topic}`);
+            }
+        });
+        return this;
+    }
+    unconnect() {
+        this.client.end();
+        this.client = null;
+        this.dispatchEvent({ type: EventType.MQTT_CLOSE, message: null });
+        console.log("断开mqtt成功==>" + this.context.MQTT_SERVICE);
+    }
+    /**
+     * @description 获取并冻结mqtt实例
+     * @static
+     * @param {*} [config={}]
+     * @returns {MqttClient}
+     */
+    static getInstance(config = {}) {
+        if (MqttClient.instance) {
+            return Object.freeze(MqttClient.instance);
+        } else {
+            return Object.freeze(new MqttClient(config));
+        }
+    }
+}
+MqttClient.defaultContext = {
+    MQTT_TIMEOUTM: 20000,
+    MQTT_USERNAME: "iRVMS-WEB",
+    MQTT_PASSWORD: "novasky888",
+    MQTT_SERVICE: `ws://${window.document.domain}:20007/mqtt`,
+};

package/src/core/WebSocketClient.js

@@ -0,0 +1,104 @@
+import EventType from '../constant/EventTypeConstant'
+import EventDispatcher from './EventDispatcher'
+export default class WebSocketClient extends EventDispatcher {
+    constructor(url = 'ws://127.0.0.1:10088') {
+        super()
+        this.maxCheckTimes = 10
+        this.url = url
+        this.checkTimes = 0
+        this.connectStatus = false
+        this.connect()
+        this.connCheckStatus(this.maxCheckTimes)
+        // this.heartbeat()
+        WebSocketClient.instance = this
+    }
+    connect() {
+        this.disconnect()
+        if (this.url) {
+            try {
+                console.info('创建ws连接>>>' + this.url)
+                this.client = new WebSocket(this.url)
+                if (this.client) {
+                    const self = this
+                    this.client.onopen = function (message) {
+                        self.dispatchEvent({
+                            type: EventType.WEB_SOCKET_CONNECT,
+                            message,
+                        })
+                    }
+                    this.client.onmessage = function (message) {
+                        self.connectStatus = true
+                        self.dispatchEvent({
+                            type: EventType.WEB_SOCKET_MESSAGE,
+                            message,
+                        })
+                    }
+                    this.client.onclose = function (message) {
+                        self.dispatchEvent({
+                            type: EventType.WEB_SOCKET_CLOSE,
+                            message,
+                        })
+                    }
+                    if (this.checkTimes === this.maxCheckTimes) {
+                        this.client.onerror = function (message) {
+                            self.dispatchEvent({
+                                type: EventType.WEB_SOCKET_ERROR,
+                                message,
+                            })
+                        }
+                    }
+                }
+            } catch (ex) {
+                console.error('创建ws连接失败' + this.url + ':' + ex)
+            }
+        }
+    }
+    disconnect() {
+        if (this.client) {
+            try {
+                console.log('ws断开连接' + this.url)
+                this.client.close()
+                this.client = null
+            } catch (ex) {
+                this.client = null
+            }
+        }
+    }
+    connCheckStatus(times) {
+        if (this.checkTimes > times) return
+        setTimeout(() => {
+            this.checkTimes++
+            if (this.client && this.client.readyState !== 0 && this.client.readyState !== 1) {
+                this.connect()
+            }
+            this.connCheckStatus(times)
+        }, 2000)
+    }
+    send(message) {
+        if (this.client && this.client.readyState === 1) {
+            this.client.send(message)
+            return true
+        }
+        console.error(this.url + '消息发送失败：' + message)
+        return false
+    }
+    heartbeat() {
+        setTimeout(() => {
+            if (this.client && this.client.readyState === 1) {
+                this.send('HeartBeat')
+            }
+            console.log('HeartBeat,' + this.url)
+            setTimeout(this.heartbeat, 30000)
+        }, 1000)
+    }
+    static getInstance() {
+        if (WebSocketClient.instance) {
+            return WebSocketClient.instance
+        } else {
+            return Object.freeze(new WebSocketClient())
+        }
+    }
+    static get _instance() {
+        return this.getInstance()
+    }
+}

package/src/core/WebStorage.js

@@ -0,0 +1,73 @@
+import ErrorType from "../constant/ErrorTypeConstant";
+export default class WebStorage {
+    constructor(type = 1) {
+        this.cacheType = type;
+        if (type === 1) {
+            this.storage = window.localStorage;
+        } else if (type === 2) {
+            this.storage = window.sessionStorage;
+        } else {
+            throw new Error(ErrorType.PARAMETER_ERROR);
+        }
+    }
+
+    /**
+     * 设置带过期时间的LocalStorage
+     * @param key       缓存关键字
+     * @param value     缓存对象，可以是任意类型
+     * @param expired   以秒为单位，默认为1小时
+     * @returns {Object}
+     */
+    setItem(key, value, expired) {
+        const tempObj = { key, value };
+        if (this.cacheType === 1) {
+            const currTime = Date.now();
+            if (expired) {
+                tempObj.expired = currTime + expired * 1000;
+            }
+        }
+        this.storage[key] = JSON.stringify(tempObj);
+        return tempObj;
+    }
+
+    /***
+     * 获取带过期时间的缓存
+     * @param key
+     * @returns {null|*}
+     */
+    getItem(key) {
+        const storageData = this.storage.getItem(key) || null;
+        const tempObj = JSON.parse(storageData) || {};
+        if (this.cacheType === 1) {
+            const expired = tempObj.expired || Date.now();
+            if (Date.now() > expired) {
+                this.remove(key);
+                return null;
+            }
+        }
+        return tempObj.value;
+    }
+
+    /**
+     * 移除指定缓存
+     * @param keys
+     */
+    remove(keys) {
+        if (keys) {
+            if (keys.indexOf(",") > -1) {
+                keys.split(",").forEach(key => {
+                    this.storage.removeItem(key);
+                });
+            } else {
+                this.storage.removeItem(keys);
+            }
+        }
+    }
+
+    /**
+     * 移出全部缓存
+     */
+    clear() {
+        this.storage.clear();
+    }
+}

package/src/index.js

@@ -0,0 +1,10 @@
+export * from './utils'
+export * from './constant'
+export { default as AudioPlayer } from './core/AudioPlayer'
+export { default as CanvasDrawer } from './core/CanvasDrawer'
+// export { default as ElQuery } from './core/ElQuery'
+export { default as EventDispatcher } from './core/EventDispatcher'
+export { default as HashMap } from './core/HashMap'
+export { default as WebSocketClient } from './core/WebSocketClient'
+export { default as WebStorage } from './core/WebStorage'
+export { default as DevicePixelRatio } from './core/DevicePixelRatio'

package/src/utils/AnimateUtils.js

@@ -0,0 +1,78 @@
+export default {
+    /**
+     *  多属性的动画函数
+     * @param {*} ele 需要运动的节点
+     * @param {*} attr_options 传入的是一个需要运动的属性包括运动的目标值，操作的节点属性
+     * @param {*} timefn 运动的形式，默认是缓冲运动
+     * @param {*} speed  运动的速度
+     */
+    animate(ele, attr_options, callback, timefn = "swing", speed = 5) {
+        for (var attr in attr_options) {
+            attr_options[attr] = {
+                target:
+                    attr === "opacity"
+                        ? parseInt(attr_options[attr] * 100)
+                        : attr_options[attr],
+                // 需要计算得到
+                iNow:
+                    attr === "opacity"
+                        ? parseInt(getComputedStyle(ele)[attr] * 100)
+                        : parseInt(getComputedStyle(ele)[attr])
+            };
+        }
+
+        // 判断是不是匀速运动
+        if (timefn === "liner") {
+            speed =
+                attr_options[attr].iNow < attr_options[attr].target
+                    ? Math.abs(speed)
+                    : -Math.abs(speed);
+        }
+        //    为了防止每个节点的定时器冲突，每次进入的时候我们需要先清理下节点的定时器
+        clearInterval(ele.timer);
+        //    然后再去设置定时器
+        ele.timer = setInterval(function() {
+            // 因为是多属性运动，我们首先循环遍历每一个属性
+            for (var attr in attr_options) {
+                var target = attr_options[attr].target;
+
+                var iNow = attr_options[attr].iNow;
+
+                // 计算speed 判断是不是缓冲运动
+                if (timefn === "swing") {
+                    speed = (target - iNow) / 20;
+                    // 为了防止速度无法达到一个整数
+                    speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
+                }
+
+                // 运动之中条件的判断
+                if (Math.abs(target - iNow) <= Math.abs(speed)) {
+                    if (attr === "opacity") {
+                        ele.style[attr] = target / 100;
+                    } else {
+                        ele.style[attr] = target + "px";
+                    }
+
+                    // 每次一个属性运动完成之后我们就直接将它删除
+                    delete attr_options[attr];
+
+                    // 每次都去循环看一下还有没有属性需要操作
+                    for (var num in attr_options) {
+                        return false;
+                    }
+                    // 清理定时器 因为我们是一个定时器绑定多个属性操作所以我们需要保证所有的属性都完成之后我们才可以将定时器清除
+                    clearInterval(ele.timer);
+                    // 等结束之后我们需要判断这个回到函数是函数我们就回调
+                    typeof callback === "function" ? callback() : "";
+                } else {
+                    attr_options[attr].iNow += speed;
+                    if (attr === "opacity") {
+                        ele.style[attr] = attr_options[attr].iNow / 100;
+                    } else {
+                        ele.style[attr] = attr_options[attr].iNow + "px";
+                    }
+                }
+            }
+        }, 30);
+    }
+};

package/src/utils/ArrayUtils.js

@@ -0,0 +1,82 @@
+import CommUtils from './CommUtils'
+/**
+ * 分组函数，暂时无法进行多层分组。如有需要可以使用groupBy+map+flat方法打平
+ * @param {*} f
+ */
+Array.prototype.groupBy = function (f) {
+    var groups = {}
+    this.forEach(function (o) {
+        var group = JSON.stringify(f(o))
+        groups[group] = groups[group] || []
+        groups[group].push(o)
+    })
+    return Object.keys(groups).map((group) => groups[group])
+}
+/**
+ * 用于数组对象去重
+ * 单纯数组可用[...new Set(arr)]
+ * @param {*} f
+ */
+Array.prototype.distinct = function (f = (d) => d) {
+    const arr = [],
+        obj = {}
+    this.forEach((item) => {
+        const val = f(item)
+        !obj[val] && (obj[val] = arr.push(item))
+    })
+    return arr
+}
+Array.prototype.max = function () {
+    return Math.max.apply({}, this)
+}
+Array.prototype.min = function () {
+    return Math.min.apply({}, this)
+}
+Array.prototype.sum = function () {
+    return this.length > 0 ? this.reduce((prev = 0, curr = 0) => prev + curr) : 0
+}
+Array.prototype.avg = function () {
+    return this.length ? this.sum() / this.length : 0
+}
+Array.prototype.desc = function (f = (d) => d) {
+    return this.sort((n1, n2) => f(n2) - f(n1))
+}
+Array.prototype.asc = function (f = (d) => d) {
+    return this.sort((n1, n2) => f(n1) - f(n2))
+}
+Array.prototype.clear = function () {
+    this.length = 0
+    return this
+}
+export default {
+    asArray(obj) {
+        return CommUtils.isEmpty(obj) ? [] : Array.isArray(obj) ? obj : [obj]
+    },
+    generateArray(length) {
+        return [...new Array(length).keys()]
+    },
+    union(...args) {
+        let res = []
+        args.forEach((arg) => {
+            if (Array.isArray(arg)) {
+                res = res.concat(arg.filter((v) => !res.includes(v)))
+            }
+        })
+        return res
+    },
+    intersection(...args) {
+        let res = args[0] || []
+        args.forEach((arg) => {
+            if (Array.isArray(arg)) {
+                res = res.filter((v) => arg.includes(v))
+            }
+        })
+        return res
+    },
+    unionAll(...args) {
+        return [...args].flat().filter((d) => !!d)
+    },
+    difference(...args) {
+        return this.union(...args).filter((d) => !this.intersection(...args).includes(d))
+    },
+}

package/src/utils/AssertUtils.js

@@ -0,0 +1,112 @@
+import GeoUtils from './GeoUtils'
+import CommUtils from './CommUtils'
+import ErrorType from '../constant/ErrorTypeConstant'
+import StringUtils from './StringUtils'
+export default {
+    notNull(data) {
+        if (CommUtils.isEmpty(data)) {
+            throw Error('不能为空:>>>' + data)
+        }
+    },
+    legalLnglat(lng, lat) {
+        if (!GeoUtils.isLnglat(lng, lat)) {
+            throw Error(ErrorType.COORDINATE_ERROR)
+        }
+    },
+    contain(str, ...args) {
+        let res = false
+        const len = args.length || 0
+        for (let i = 0, l = len; i < l; i++) {
+            res = str.indexOf(args[i]) >= 0
+        }
+        if (res) {
+            throw Error(ErrorType.STRING_CHECK_LOSS)
+        }
+    },
+    verify: {
+        array(data) {
+            if (CommUtils.getDataType(data) !== 'Array') {
+                throw Error(ErrorType.PARAMETER_ERROR_ARRAY + ':>>>' + data)
+            }
+        },
+        function(data) {
+            if (CommUtils.getDataType(data) !== 'Function') {
+                throw Error(ErrorType.PARAMETER_ERROR_FUNCTION + ':>>>' + data)
+            }
+        },
+        object(data) {
+            if (CommUtils.getDataType(data) !== 'Object') {
+                throw Error(ErrorType.PARAMETER_ERROR_OBJECT + ':>>>' + data)
+            }
+        },
+    },
+    legalJSON(data) {
+        try {
+            JSON.parse(data)
+        } catch (err) {
+            throw Error(ErrorType.JSON_PARSE_ERROR + ':>>>' + data)
+        }
+    },
+    legalData(data, type) {
+        const bool = StringUtils.checkStr(data, type)
+        let typename = ''
+        switch (type) {
+            case 'phone':
+                typename = '电话'
+                break
+            case 'tel':
+                typename = '座机'
+                break
+            case 'card':
+                typename = '身份证'
+                break
+            case 'pwd':
+                typename = '密码'
+                break
+            case 'postal':
+                typename = '邮政编码'
+                break
+            case 'QQ':
+                typename = 'QQ'
+                break
+            case 'email':
+                typename = '邮箱'
+                break
+            case 'money':
+                typename = '金额'
+                break
+            case 'URL':
+                typename = '网址'
+                break
+            case 'IP':
+                typename = 'IP'
+                break
+            case 'date':
+                typename = '日期时间'
+                break
+            case 'number':
+                typename = '数字'
+                break
+            case 'english':
+                typename = '英文'
+                break
+            case 'chinese':
+                typename = '中文'
+                break
+            case 'lower':
+                typename = '小写'
+                break
+            case 'upper':
+                typename = '大写'
+                break
+            case 'HTML':
+                typename = 'HTML标记'
+                break
+            default:
+                break
+        }
+        if (!bool) {
+            throw Error(ErrorType.PARAMETER_ERROR + ':>>>不是' + typename)
+        }
+    },
+}