156 lines
3.9 KiB
JavaScript
156 lines
3.9 KiB
JavaScript
const { parse, stringify } = JSON
|
|
|
|
export function deepClone (object) {
|
|
return parse(stringify(object))
|
|
}
|
|
|
|
export function deleteArrayAllItems (arrays) {
|
|
arrays.forEach(element => element.splice(0, element.length))
|
|
}
|
|
|
|
export function debounce (delay, callback) {
|
|
let lastTime
|
|
|
|
return function () {
|
|
clearTimeout(lastTime)
|
|
|
|
const [that, args] = [this, arguments]
|
|
|
|
lastTime = setTimeout(() => {
|
|
callback.apply(that, args)
|
|
}, delay)
|
|
}
|
|
}
|
|
|
|
export function randomExtend (minNum, maxNum) {
|
|
if (arguments.length === 1) {
|
|
return parseInt(Math.random() * minNum + 1, 10)
|
|
} else {
|
|
return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10)
|
|
}
|
|
}
|
|
|
|
export function multipleSum (...num) {
|
|
let sum = 0
|
|
|
|
num.forEach(n => (sum += n))
|
|
|
|
return sum
|
|
}
|
|
|
|
export function filterNull (arr) {
|
|
const tmpArr = []
|
|
|
|
arr.forEach(v => ((v || v === 0) && tmpArr.push(v)))
|
|
|
|
return tmpArr
|
|
}
|
|
|
|
export function getPointDistance (pointOne, pointTwo) {
|
|
const minusX = Math.abs(pointOne[0] - pointTwo[0])
|
|
|
|
const minusY = Math.abs(pointOne[1] - pointTwo[1])
|
|
|
|
return Math.sqrt(minusX * minusX + minusY * minusY)
|
|
}
|
|
|
|
export function getPointToLineDistance (point, linePointOne, linePointTwo) {
|
|
const a = getPointDistance(point, linePointOne)
|
|
const b = getPointDistance(point, linePointTwo)
|
|
const c = getPointDistance(linePointOne, linePointTwo)
|
|
|
|
return 0.5 * Math.sqrt((a + b + c) * (a + b - c) * (a + c - b) * (b + c - a)) / c
|
|
}
|
|
|
|
export function getArrayMaxMin (array) {
|
|
if (!array) return false
|
|
|
|
return [getArrayMax(array), getArrayMin(array)]
|
|
}
|
|
|
|
export function getArrayMax (array) {
|
|
if (!array) return false
|
|
|
|
return Math.max(...filterNull(array).map(n =>
|
|
n instanceof Array ? getArrayMax(n) : n))
|
|
}
|
|
|
|
export function getArrayMin (array) {
|
|
if (!array) return false
|
|
|
|
return Math.min(...filterNull(array).map(n =>
|
|
n instanceof Array ? getArrayMin(n) : n))
|
|
}
|
|
|
|
export function getAxisPointsPos ([max, min], values, axisOriginPos, axisWH, tagPos, horizon) {
|
|
let minus = max - min
|
|
|
|
minus === 0 && (minus = 1)
|
|
|
|
return values.map((value, i) => {
|
|
if (!value && value !== 0) return false
|
|
|
|
if (value instanceof Array) {
|
|
return value.map(v =>
|
|
getAxisPointPos([max, min], v, axisOriginPos, axisWH, tagPos[i], horizon))
|
|
}
|
|
|
|
const percent = (value - min) / minus
|
|
|
|
const length = percent * (horizon ? axisWH[0] : axisWH[1])
|
|
|
|
return horizon ? [
|
|
axisOriginPos[0] + length,
|
|
tagPos[i][1]
|
|
] : [
|
|
tagPos[i][0],
|
|
axisOriginPos[1] - length
|
|
]
|
|
})
|
|
}
|
|
|
|
export function getAxisPointPos ([max, min], value, axisOriginPos, axisWH, tagPos, horizon) {
|
|
if (!value && value !== 0) return false
|
|
|
|
const minus = max - min
|
|
|
|
const percent = (value - min) / minus
|
|
|
|
const length = percent * (horizon ? axisWH[0] : axisWH[1])
|
|
|
|
return horizon ? [
|
|
axisOriginPos[0] + length,
|
|
tagPos[1]
|
|
] : [
|
|
tagPos[0],
|
|
axisOriginPos[1] - length
|
|
]
|
|
}
|
|
|
|
export function observerDomResize (dom, callback) {
|
|
const MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver
|
|
|
|
const observer = new MutationObserver(callback)
|
|
|
|
observer.observe(dom, { attributes: true, attributeFilter: ['style'], attributeOldValue: true })
|
|
|
|
return observer
|
|
}
|
|
|
|
export default function (Vue) {
|
|
Vue.prototype.deepClone = deepClone
|
|
Vue.prototype.deleteArrayAllItems = deleteArrayAllItems
|
|
Vue.prototype.debounce = debounce
|
|
Vue.prototype.multipleSum = multipleSum
|
|
Vue.prototype.randomExtend = randomExtend
|
|
Vue.prototype.filterNull = filterNull
|
|
Vue.prototype.getPointDistance = getPointDistance
|
|
Vue.prototype.getPointToLineDistance = getPointToLineDistance
|
|
Vue.prototype.getArrayMaxMin = getArrayMaxMin
|
|
Vue.prototype.getArrayMax = getArrayMax
|
|
Vue.prototype.getArrayMin = getArrayMin
|
|
Vue.prototype.getAxisPointPos = getAxisPointPos
|
|
Vue.prototype.getAxisPointsPos = getAxisPointsPos
|
|
Vue.prototype.observerDomResize = observerDomResize
|
|
}
|