From e13367edf304cb78f978e321f1679299a66b3a23 Mon Sep 17 00:00:00 2001
From: quanyawei <401863037@qq.com>
Date: Wed, 10 Jan 2024 16:08:18 +0800
Subject: [PATCH] fix:地图
---
uni_modules/uview-ui/libs/function/index.js | 731 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 731 insertions(+), 0 deletions(-)
diff --git a/uni_modules/uview-ui/libs/function/index.js b/uni_modules/uview-ui/libs/function/index.js
new file mode 100644
index 0000000..bd80ee7
--- /dev/null
+++ b/uni_modules/uview-ui/libs/function/index.js
@@ -0,0 +1,731 @@
+import test from './test.js'
+import { round } from './digit.js'
+/**
+ * @description ������value������min������min���������value������max������max
+ * @param {number} min
+ * @param {number} max
+ * @param {number} value
+ */
+function range(min = 0, max = 0, value = 0) {
+ return Math.max(min, Math.min(max, Number(value)))
+}
+
+/**
+ * @description ������������������������������px��� ���������������������"xxpx"������"xxrpx"������������������������������������"xxxrpx"���������������uni.upx2px������������
+ * @param {number|string} value ������������������px���
+ * @param {boolean} unit
+ * @returns {number|string}
+ */
+function getPx(value, unit = false) {
+ if (test.number(value)) {
+ return unit ? `${value}px` : Number(value)
+ }
+ // ������������rpx���������������������������������������px���
+ if (/(rpx|upx)$/.test(value)) {
+ return unit ? `${uni.upx2px(parseInt(value))}px` : Number(uni.upx2px(parseInt(value)))
+ }
+ return unit ? `${parseInt(value)}px` : parseInt(value)
+}
+
+/**
+ * @description ��������������������������������������������������� ������: await uni.$u.sleep(20)������������20ms
+ * @param {number} value ������������ ������ms ������
+ * @returns {Promise} ������promise
+ */
+function sleep(value = 30) {
+ return new Promise((resolve) => {
+ setTimeout(() => {
+ resolve()
+ }, value)
+ })
+}
+/**
+ * @description ���������������������
+ * @returns {string} ������������������(������)
+ * @link ��������������������� https://uniapp.dcloud.io/frame?id=������������
+ */
+function os() {
+ return uni.getSystemInfoSync().platform.toLowerCase()
+}
+/**
+ * @description ������������������������������
+ * @link ������������������������������ https://uniapp.dcloud.io/api/system/info?id=getsysteminfosync
+ */
+function sys() {
+ return uni.getSystemInfoSync()
+}
+
+/**
+ * @description ������������������
+ * @param {Number} min ���������
+ * @param {Number} max ���������
+ */
+function random(min, max) {
+ if (min >= 0 && max > 0 && max >= min) {
+ const gab = max - min + 1
+ return Math.floor(Math.random() * gab + min)
+ }
+ return 0
+}
+
+/**
+ * @param {Number} len uuid���������
+ * @param {Boolean} firstU ���������������������������"u"
+ * @param {Nubmer} radix ������uuid���������(���������������������������������������������),2-���������,8-���������,10-���������,16-������������
+ */
+function guid(len = 32, firstU = true, radix = null) {
+ const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
+ const uuid = []
+ radix = radix || chars.length
+
+ if (len) {
+ // ������������uuid������,������������������������,0|x������������,���������x������������,���������������
+ for (let i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix]
+ } else {
+ let r
+ // rfc4122���������������������uuid���,���������������������������
+ uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-'
+ uuid[14] = '4'
+
+ for (let i = 0; i < 36; i++) {
+ if (!uuid[i]) {
+ r = 0 | Math.random() * 16
+ uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r]
+ }
+ }
+ }
+ // ���������������������,������u������,���������������������������������,���guuid������������id������class
+ if (firstU) {
+ uuid.shift()
+ return `u${uuid.join('')}`
+ }
+ return uuid.join('')
+}
+
+/**
+* @description ������������������������������������������������������������provide/inject���������
+ this.$parent������H5������������������������������������������������H5������������������this.$parent.$parent.xxx
+ ���������������������undefined���������������������������������������(������)���$parent������undefined������������������name
+ ���(���������undefined)���������������������������$parent
+* @param {string|undefined} name ���������������������
+*/
+function $parent(name = undefined) {
+ let parent = this.$parent
+ // ������while������������������������������H5���������������������������
+ while (parent) {
+ // ���������
+ if (parent.$options && parent.$options.name !== name) {
+ // ���������������name���������������������������������
+ parent = parent.$parent
+ } else {
+ return parent
+ }
+ }
+ return false
+}
+
+/**
+ * @description ������������
+ * ���������������������������������������������
+ * @param {object | string} customStyle ���������������������
+ * @param {String} target ������������������object-���������������string-���������������
+ * @returns {object|string}
+ */
+function addStyle(customStyle, target = 'object') {
+ // ������������������������������������������������������������
+ if (test.empty(customStyle) || typeof(customStyle) === 'object' && target === 'object' || target === 'string' &&
+ typeof(customStyle) === 'string') {
+ return customStyle
+ }
+ // ������������������
+ if (target === 'object') {
+ // ���������������������������������������(������������������������������������padding: 20px 0������������������������)���������������������
+ customStyle = trim(customStyle)
+ // ������";"������������������������������
+ const styleArray = customStyle.split(';')
+ const style = {}
+ // ������������������������������
+ for (let i = 0; i < styleArray.length; i++) {
+ // 'font-size:20px;color:red;'���������������������������";"������������������styleArray������������������������������������������������������
+ if (styleArray[i]) {
+ const item = styleArray[i].split(':')
+ style[trim(item[0])] = trim(item[1])
+ }
+ }
+ return style
+ }
+ // ���������������������������������
+ let string = ''
+ for (const i in customStyle) {
+ // ���������������������������������������css������������������������������������������������
+ const key = i.replace(/([A-Z])/g, '-$1').toLowerCase()
+ string += `${key}:${customStyle[i]};`
+ }
+ // ������������������
+ return trim(string)
+}
+
+/**
+ * @description ������������������������rpx���upx���%���px���������������������������auto������������������������������px������������
+ * @param {string|number} value ������������������������
+ * @param {string} unit ������������������ ������px
+ */
+function addUnit(value = 'auto', unit = uni?.$u?.config?.unit ?? 'px') {
+ value = String(value)
+ // ���uView������������������������number���������������������
+ return test.number(value) ? `${value}${unit}` : value
+}
+
+/**
+ * @description ������������
+ * @param {object} obj ���������������������������
+ * @param cache ������
+ * @returns {*} ������������������������������������������������
+ */
+function deepClone(obj, cache = new WeakMap()) {
+ if (obj === null || typeof obj !== 'object') return obj;
+ if (cache.has(obj)) return cache.get(obj);
+ let clone;
+ if (obj instanceof Date) {
+ clone = new Date(obj.getTime());
+ } else if (obj instanceof RegExp) {
+ clone = new RegExp(obj);
+ } else if (obj instanceof Map) {
+ clone = new Map(Array.from(obj, ([key, value]) => [key, deepClone(value, cache)]));
+ } else if (obj instanceof Set) {
+ clone = new Set(Array.from(obj, value => deepClone(value, cache)));
+ } else if (Array.isArray(obj)) {
+ clone = obj.map(value => deepClone(value, cache));
+ } else if (Object.prototype.toString.call(obj) === '[object Object]') {
+ clone = Object.create(Object.getPrototypeOf(obj));
+ cache.set(obj, clone);
+ for (const [key, value] of Object.entries(obj)) {
+ clone[key] = deepClone(value, cache);
+ }
+ } else {
+ clone = Object.assign({}, obj);
+ }
+ cache.set(obj, clone);
+ return clone;
+}
+
+/**
+ * @description JS������������������
+ * @param {object} target ���������������������
+ * @param {object} source ���������������������
+ * @returns {object|boolean} ������������������������������false���������������������������
+ */
+function deepMerge(target = {}, source = {}) {
+ target = deepClone(target)
+ if (typeof target !== 'object' || target === null || typeof source !== 'object' || source === null) return target;
+ const merged = Array.isArray(target) ? target.slice() : Object.assign({}, target);
+ for (const prop in source) {
+ if (!source.hasOwnProperty(prop)) continue;
+ const sourceValue = source[prop];
+ const targetValue = merged[prop];
+ if (sourceValue instanceof Date) {
+ merged[prop] = new Date(sourceValue);
+ } else if (sourceValue instanceof RegExp) {
+ merged[prop] = new RegExp(sourceValue);
+ } else if (sourceValue instanceof Map) {
+ merged[prop] = new Map(sourceValue);
+ } else if (sourceValue instanceof Set) {
+ merged[prop] = new Set(sourceValue);
+ } else if (typeof sourceValue === 'object' && sourceValue !== null) {
+ merged[prop] = deepMerge(targetValue, sourceValue);
+ } else {
+ merged[prop] = sourceValue;
+ }
+ }
+ return merged;
+}
+
+/**
+ * @description error������
+ * @param {*} err ������������
+ */
+function error(err) {
+ // ������������������������������������������������
+ if (process.env.NODE_ENV === 'development') {
+ console.error(`uView���������${err}`)
+ }
+}
+
+/**
+ * @description ������������
+ * @param {array} array ���������������������
+ * @returns {array} ������������������
+ */
+function randomArray(array = []) {
+ // ���������sort������,Math.random()������0<= x < 1������������,���������x-0.05������������������0
+ return array.sort(() => Math.random() - 0.5)
+}
+
+// padStart ��� polyfill������������������������������������������������es7���padStart������������������������������������
+// ���������������������������polyfill���������������
+if (!String.prototype.padStart) {
+ // ������������������������ fillString ������ES6 ���������������������������������
+ String.prototype.padStart = function(maxLength, fillString = ' ') {
+ if (Object.prototype.toString.call(fillString) !== '[object String]') {
+ throw new TypeError(
+ 'fillString must be String'
+ )
+ }
+ const str = this
+ // ������ String(str) ������������������������������������������������������������������������������������
+ if (str.length >= maxLength) return String(str)
+
+ const fillLength = maxLength - str.length
+ let times = Math.ceil(fillLength / fillString.length)
+ while (times >>= 1) {
+ fillString += fillString
+ if (times === 1) {
+ fillString += fillString
+ }
+ }
+ return fillString.slice(0, fillLength) + str
+ }
+}
+
+/**
+ * @description ���������������
+ * @param {String|Number} dateTime ���������������������������
+ * @param {String} fmt ��������������� yyyy:mm:dd|yyyy:mm|yyyy���mm���dd���|yyyy���mm���dd��� hh���MM������,������������������ ������yyyy-mm-dd
+ * @returns {string} ������������������������������
+ */
+ function timeFormat(dateTime = null, formatStr = 'yyyy-mm-dd') {
+ let date
+ // ���������������������������������������������
+ if (!dateTime) {
+ date = new Date()
+ }
+ // ������unix������������������������������������������������������������������������������������������������������
+ else if (/^\d{10}$/.test(dateTime?.toString().trim())) {
+ date = new Date(dateTime * 1000)
+ }
+ // ������������������������������������������new Date���������������������������
+ else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.trim())) {
+ date = new Date(Number(dateTime))
+ }
+ // ���������������������������Safari/Webkit������new Date���������/���������������������������������
+ // ������ '2022-07-10 01:02:03'��������� '2022-07-10T01:02:03'
+ else if (typeof dateTime === 'string' && dateTime.includes('-') && !dateTime.includes('T')) {
+ date = new Date(dateTime.replace(/-/g, '/'))
+ }
+ // ��������������������� RFC 2822 ������
+ else {
+ date = new Date(dateTime)
+ }
+
+ const timeSource = {
+ 'y': date.getFullYear().toString(), // ���
+ 'm': (date.getMonth() + 1).toString().padStart(2, '0'), // ���
+ 'd': date.getDate().toString().padStart(2, '0'), // ���
+ 'h': date.getHours().toString().padStart(2, '0'), // ���
+ 'M': date.getMinutes().toString().padStart(2, '0'), // ���
+ 's': date.getSeconds().toString().padStart(2, '0') // ���
+ // ���������������������������������������������������������������������������
+ }
+
+ for (const key in timeSource) {
+ const [ret] = new RegExp(`${key}+`).exec(formatStr) || []
+ if (ret) {
+ // ���������������������������
+ const beginIndex = key === 'y' && ret.length === 2 ? 2 : 0
+ formatStr = formatStr.replace(ret, timeSource[key].slice(beginIndex))
+ }
+ }
+
+ return formatStr
+}
+
+/**
+ * @description ���������������������������
+ * @param {String|Number} timestamp ���������
+ * @param {String|Boolean} format
+ * ���������������������������������������������������������������������������������������������������������
+ * ������������������false������������������������������������������������������
+ * @returns {string} ������������������
+ */
+function timeFrom(timestamp = null, format = 'yyyy-mm-dd') {
+ if (timestamp == null) timestamp = Number(new Date())
+ timestamp = parseInt(timestamp)
+ // ������������������������������������������������,������������js���������������������������(13���),������������������������(10���)
+ if (timestamp.toString().length == 10) timestamp *= 1000
+ let timer = (new Date()).getTime() - timestamp
+ timer = parseInt(timer / 1000)
+ // ������������5������,���������"������",������������������
+ let tips = ''
+ switch (true) {
+ case timer < 300:
+ tips = '������'
+ break
+ case timer >= 300 && timer < 3600:
+ tips = `${parseInt(timer / 60)}���������`
+ break
+ case timer >= 3600 && timer < 86400:
+ tips = `${parseInt(timer / 3600)}���������`
+ break
+ case timer >= 86400 && timer < 2592000:
+ tips = `${parseInt(timer / 86400)}������`
+ break
+ default:
+ // ������format���false���������������������������������������xx������
+ if (format === false) {
+ if (timer >= 2592000 && timer < 365 * 86400) {
+ tips = `${parseInt(timer / (86400 * 30))}���������`
+ } else {
+ tips = `${parseInt(timer / (86400 * 365))}������`
+ }
+ } else {
+ tips = timeFormat(timestamp, format)
+ }
+ }
+ return tips
+}
+
+/**
+ * @description ������������
+ * @param String str ������������������������������
+ * @param String pos both(������)|left|right|all ������both
+ */
+function trim(str, pos = 'both') {
+ str = String(str)
+ if (pos == 'both') {
+ return str.replace(/^\s+|\s+$/g, '')
+ }
+ if (pos == 'left') {
+ return str.replace(/^\s*/, '')
+ }
+ if (pos == 'right') {
+ return str.replace(/(\s*$)/g, '')
+ }
+ if (pos == 'all') {
+ return str.replace(/\s+/g, '')
+ }
+ return str
+}
+
+/**
+ * @description ���������url������
+ * @param {object} data,������
+ * @param {Boolean} isPrefix,������������������"?"
+ * @param {string} arrayFormat ������ indices|brackets|repeat|comma
+ */
+function queryParams(data = {}, isPrefix = true, arrayFormat = 'brackets') {
+ const prefix = isPrefix ? '?' : ''
+ const _result = []
+ if (['indices', 'brackets', 'repeat', 'comma'].indexOf(arrayFormat) == -1) arrayFormat = 'brackets'
+ for (const key in data) {
+ const value = data[key]
+ // ���������������������
+ if (['', undefined, null].indexOf(value) >= 0) {
+ continue
+ }
+ // ���������������������������������
+ if (value.constructor === Array) {
+ // e.g. {ids: [1, 2, 3]}
+ switch (arrayFormat) {
+ case 'indices':
+ // ������: ids[0]=1&ids[1]=2&ids[2]=3
+ for (let i = 0; i < value.length; i++) {
+ _result.push(`${key}[${i}]=${value[i]}`)
+ }
+ break
+ case 'brackets':
+ // ������: ids[]=1&ids[]=2&ids[]=3
+ value.forEach((_value) => {
+ _result.push(`${key}[]=${_value}`)
+ })
+ break
+ case 'repeat':
+ // ������: ids=1&ids=2&ids=3
+ value.forEach((_value) => {
+ _result.push(`${key}=${_value}`)
+ })
+ break
+ case 'comma':
+ // ������: ids=1,2,3
+ let commaStr = ''
+ value.forEach((_value) => {
+ commaStr += (commaStr ? ',' : '') + _value
+ })
+ _result.push(`${key}=${commaStr}`)
+ break
+ default:
+ value.forEach((_value) => {
+ _result.push(`${key}[]=${_value}`)
+ })
+ }
+ } else {
+ _result.push(`${key}=${value}`)
+ }
+ }
+ return _result.length ? prefix + _result.join('&') : ''
+}
+
+/**
+ * ���������������������
+ * @param {String} title ��������������������������� icon ���������������
+ * @param {Number} duration ������������������������������������������������2000
+ */
+function toast(title, duration = 2000) {
+ uni.showToast({
+ title: String(title),
+ icon: 'none',
+ duration
+ })
+}
+
+/**
+ * @description ������������type���,���������������������
+ * @param {String} type ������������,primary|info|error|warning|success
+ * @param {boolean} fill ������������fill���������������������
+ */
+function type2icon(type = 'success', fill = false) {
+ // ������������������,���������success
+ if (['primary', 'info', 'error', 'warning', 'success'].indexOf(type) == -1) type = 'success'
+ let iconName = ''
+ // ������(2019-12-12),info���primary���������������������
+ switch (type) {
+ case 'primary':
+ iconName = 'info-circle'
+ break
+ case 'info':
+ iconName = 'info-circle'
+ break
+ case 'error':
+ iconName = 'close-circle'
+ break
+ case 'warning':
+ iconName = 'error-circle'
+ break
+ case 'success':
+ iconName = 'checkmark-circle'
+ break
+ default:
+ iconName = 'checkmark-circle'
+ }
+ // ���������������������,������-fill,���icon������������,���������������������������-fill���
+ if (fill) iconName += '-fill'
+ return iconName
+}
+
+/**
+ * @description ���������������
+ * @param {number|string} number ���������������������
+ * @param {number} decimals ������������������
+ * @param {string} decimalPoint ���������������
+ * @param {string} thousandsSeparator ���������������
+ * @returns {string} ���������������������
+ */
+function priceFormat(number, decimals = 0, decimalPoint = '.', thousandsSeparator = ',') {
+ number = (`${number}`).replace(/[^0-9+-Ee.]/g, '')
+ const n = !isFinite(+number) ? 0 : +number
+ const prec = !isFinite(+decimals) ? 0 : Math.abs(decimals)
+ const sep = (typeof thousandsSeparator === 'undefined') ? ',' : thousandsSeparator
+ const dec = (typeof decimalPoint === 'undefined') ? '.' : decimalPoint
+ let s = ''
+
+ s = (prec ? round(n, prec) + '' : `${Math.round(n)}`).split('.')
+ const re = /(-?\d+)(\d{3})/
+ while (re.test(s[0])) {
+ s[0] = s[0].replace(re, `$1${sep}$2`)
+ }
+
+ if ((s[1] || '').length < prec) {
+ s[1] = s[1] || ''
+ s[1] += new Array(prec - s[1].length + 1).join('0')
+ }
+ return s.join(dec)
+}
+
+/**
+ * @description ������duration���
+ * ������������ms������s������������������������������������������������ms������������������������������������s������
+ * ���������30������������������300������30������������������������������������300ms������������������300s���������������������
+ * @param {String|number} value ������: "1s"|"100ms"|1|100
+ * @param {boolean} unit ������: ���������false ������������number
+ * @return {string|number}
+ */
+function getDuration(value, unit = true) {
+ const valueNum = parseInt(value)
+ if (unit) {
+ if (/s$/.test(value)) return value
+ return value > 30 ? `${value}ms` : `${value}s`
+ }
+ if (/ms$/.test(value)) return valueNum
+ if (/s$/.test(value)) return valueNum > 30 ? valueNum : valueNum * 1000
+ return valueNum
+}
+
+/**
+ * @description ������������������������������
+ * @param {String} value ������������������
+ */
+function padZero(value) {
+ return `00${value}`.slice(-2)
+}
+
+/**
+ * @description ���u-form���������������������������������������������������������������������u-form������������������
+ * @param {*} instance
+ * @param {*} event
+ */
+function formValidate(instance, event) {
+ const formItem = uni.$u.$parent.call(instance, 'u-form-item')
+ const form = uni.$u.$parent.call(instance, 'u-form')
+ // ���������������������input������textarea������������������������u-form-item������u-form���������������form���validate������
+ // ���������form-item���pros���������form���������������������������������
+ if (formItem && form) {
+ form.validateField(formItem.prop, () => {}, event)
+ }
+}
+
+/**
+ * @description ���������������������������������������������������'a.b.c'���������������������������������������������������
+ * @param {object} obj ������
+ * @param {string} key ���������������������������
+ * @returns {*}
+ */
+function getProperty(obj, key) {
+ if (!obj) {
+ return
+ }
+ if (typeof key !== 'string' || key === '') {
+ return ''
+ }
+ if (key.indexOf('.') !== -1) {
+ const keys = key.split('.')
+ let firstObj = obj[keys[0]] || {}
+
+ for (let i = 1; i < keys.length; i++) {
+ if (firstObj) {
+ firstObj = firstObj[keys[i]]
+ }
+ }
+ return firstObj
+ }
+ return obj[key]
+}
+
+/**
+ * @description ���������������������������������'a.b.c'���������������������
+ * @param {object} obj ������
+ * @param {string} key ���������������������
+ * @param {string} value ������������
+ */
+function setProperty(obj, key, value) {
+ if (!obj) {
+ return
+ }
+ // ������������
+ const inFn = function(_obj, keys, v) {
+ // ������������������key
+ if (keys.length === 1) {
+ _obj[keys[0]] = v
+ return
+ }
+ // 0~length-1���key
+ while (keys.length > 1) {
+ const k = keys[0]
+ if (!_obj[k] || (typeof _obj[k] !== 'object')) {
+ _obj[k] = {}
+ }
+ const key = keys.shift()
+ // ������������������������������������������������������������������
+ inFn(_obj[k], keys, v)
+ }
+ }
+
+ if (typeof key !== 'string' || key === '') {
+
+ } else if (key.indexOf('.') !== -1) { // ���������������������������
+ const keys = key.split('.')
+ inFn(obj, keys, value)
+ } else {
+ obj[key] = value
+ }
+}
+
+/**
+ * @description ������������������������
+ */
+function page() {
+ const pages = getCurrentPages()
+ // ���������������������(������������������redirectTo������������������)���pages������������������
+ return `/${pages[pages.length - 1]?.route ?? ''}`
+}
+
+/**
+ * @description ���������������������������������
+ */
+function pages() {
+ const pages = getCurrentPages()
+ return pages
+}
+
+/**
+ * ������������������������������������
+ * @param back {number} [0] - 0���������������������������������������������������0���������������������������������-1 ������������������������������������������0���
+ */
+function getHistoryPage(back = 0) {
+ const pages = getCurrentPages()
+ const len = pages.length
+ return pages[len - 1 + back]
+}
+
+/**
+ * @description ������uView���������������
+ * @param {object} props ������������props������
+ * @param {object} config ������������config������
+ * @param {object} color ������������color������
+ * @param {object} zIndex ������������zIndex������
+ */
+function setConfig({
+ props = {},
+ config = {},
+ color = {},
+ zIndex = {}
+}) {
+ const {
+ deepMerge,
+ } = uni.$u
+ uni.$u.config = deepMerge(uni.$u.config, config)
+ uni.$u.props = deepMerge(uni.$u.props, props)
+ uni.$u.color = deepMerge(uni.$u.color, color)
+ uni.$u.zIndex = deepMerge(uni.$u.zIndex, zIndex)
+}
+
+export default {
+ range,
+ getPx,
+ sleep,
+ os,
+ sys,
+ random,
+ guid,
+ $parent,
+ addStyle,
+ addUnit,
+ deepClone,
+ deepMerge,
+ error,
+ randomArray,
+ timeFormat,
+ timeFrom,
+ trim,
+ queryParams,
+ toast,
+ type2icon,
+ priceFormat,
+ getDuration,
+ padZero,
+ formValidate,
+ getProperty,
+ setProperty,
+ page,
+ pages,
+ getHistoryPage,
+ setConfig
+}
--
Gitblit v1.8.0