sh-view 2.1.0 → 2.2.0

package/packages/components/global-components/sh-upload/js/mixin.js

@@ -1,257 +0,0 @@
-// 上传组件通用方法
-
-import ajax from './ajax'
-
-export default {
-	props: {
-		modelValue: {
-			type: Array,
-			default() {
-				return []
-			}
-		},
-		action: {
-			type: String,
-			default: 'fileservice/v2/upload'
-		},
-		headers: {
-			type: Object,
-			default() {
-				return {}
-			}
-		},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		maxSize: {
-			type: Number,
-			default: 1024 * 2 // 文件大小限制，单位 kb
-		},
-		accept: {
-			type: String,
-			default: '.doc,.docx,.xls,.xlsx,.txt,.pdf,.jpg,.jpeg,.png,.txt,.7z,.zip,.rar'
-		},
-		name: {
-			type: String,
-			default: 'file'
-		},
-		beforeUpload: {
-			type: Function
-		},
-		webkitdirectory: {
-			type: Boolean,
-			default: false // 是否开启选择文件夹，部分浏览器适用
-		},
-		withCredentials: {
-			type: Boolean,
-			default: false // 支持发送 cookie 凭证信息
-		},
-		paste: {
-			type: Boolean,
-			default: false // 是否支持粘贴上传文件
-		},
-		format: {
-			type: Array,
-			default() {
-				return []
-			}
-		},
-		onFormatError: {
-			type: Function
-		},
-		onExceededSize: {
-			type: Function
-		},
-		onProgress: {
-			type: Function,
-			default() {}
-		},
-		onSuccess: {
-			type: Function,
-			default() {}
-		},
-		onError: {
-			type: Function,
-			default() {}
-		},
-		onRemove: {
-			type: Function,
-			default() {}
-		},
-		onPreview: {
-			type: Function,
-			default() {}
-		},
-		onDownload: {
-			type: Function,
-			default() {}
-		}
-	},
-	data() {
-		return {
-			tempIndex: 1,
-			dragOver: false,
-			fileList: []
-		}
-	},
-	methods: {
-		progressConfig(file) {
-			return {
-				textInside: true,
-				strokeWidth: 20,
-				percent: parseInt(file.percentage, 10),
-				status: file.status
-			}
-		},
-		handleClick() {
-			if (this.disabled) return
-			this.$refs.input.click()
-		},
-		handleChange(e) {
-			const files = e.target.files
-			if (!files) return
-			this.uploadFiles(files)
-			this.$refs.input.value = null
-		},
-		handleStart(file) {
-			file.uid = Date.now() + this.tempIndex++
-			const _file = {
-				status: 'active',
-				name: file.name,
-				size: file.size,
-				percentage: 0,
-				uid: file.uid,
-				showProgress: true
-			}
-			this.fileList.push(_file)
-		},
-		handlePaste(e) {
-			if (this.disabled) return
-			if (this.paste) {
-				this.uploadFiles(e.clipboardData.files)
-			}
-		},
-		handleProgress(e, file) {
-			const _file = this.getFile(file)
-			this.onProgress(e, _file, this.fileList)
-			_file.percentage = e.percent || 0
-		},
-		handleSuccess(res, file) {
-			const _file = this.getFile(file)
-			if (_file) {
-				_file.status = 'success'
-				_file.response = res
-				this.emitValue()
-				this.onSuccess(res, _file, this.fileList)
-				setTimeout(() => {
-					_file.showProgress = false
-				}, 1000)
-			}
-		},
-		handleError(err, response, file) {
-			const _file = this.getFile(file)
-			const fileList = this.fileList
-			_file.status = 'wrong'
-			fileList.splice(fileList.indexOf(_file), 1)
-			this.onError(err, response, file)
-		},
-		handleRemove(file) {
-			const fileList = this.fileList
-			fileList.splice(fileList.indexOf(file), 1)
-			this.emitValue()
-			this.onRemove(file, fileList)
-		},
-		handlePreview(file) {
-			const fileList = this.fileList
-			fileList.splice(fileList.indexOf(file), 1)
-			this.onRemove(file, fileList)
-		},
-		handleDownload(file) {
-			const fileList = this.fileList
-			fileList.splice(fileList.indexOf(file), 1)
-			this.onDownload(file, fileList)
-		},
-		onDrop(e) {
-			this.dragOver = false
-			if (this.disabled) return
-			this.uploadFiles(e.dataTransfer.files)
-		},
-		uploadFiles(files) {
-			let postFiles = Array.prototype.slice.call(files)
-			if (!this.multiple) postFiles = postFiles.slice(0, 1)
-			if (postFiles.length === 0) return
-			postFiles.forEach(file => {
-				this.upload(file)
-			})
-		},
-		upload(file) {
-			if (!this.beforeUpload) {
-				return this.post(file)
-			}
-			const before = this.beforeUpload(file)
-			if (before && before.then) {
-				before.then(processedFile => {
-					if (Object.prototype.toString.call(processedFile) === '[object File]') {
-						this.post(processedFile)
-					} else {
-						this.post(file)
-					}
-				})
-			} else if (before !== false) {
-				this.post(file)
-			}
-		},
-		async post(file) {
-			let { headers, name, params, action, withCredentials } = this
-			if (this.validateFile) {
-				let valResult = this.validateFile(file)
-				if (!valResult) return
-			}
-			this.handleStart(file)
-			ajax({
-				headers: headers,
-				withCredentials: withCredentials,
-				file: file,
-				data: params,
-				filename: name,
-				action: action,
-				onProgress: e => {
-					this.handleProgress(e, file)
-				},
-				onSuccess: res => {
-					this.handleSuccess(res, file)
-				},
-				onError: (err, response) => {
-					this.handleError(err, response, file)
-				}
-			})
-		},
-		getFile(file) {
-			const fileList = this.fileList
-			let target
-			fileList.every(item => {
-				target = file.uid === item.uid ? item : null
-				return !target
-			})
-			return target
-		},
-		clearFiles() {
-			this.fileList = []
-			this.emitValue()
-		},
-		emitValue() {
-			let list = this.getModelValue ? this.getModelValue() : this.fileList
-			this.$emit('update:modelValue', list)
-		}
-	},
-	watch: {
-		modelValue: {
-			handler(fileList) {
-				this.fileList = fileList
-			},
-			immediate: true,
-			deep: true
-		}
-	}
-}

package/packages/components/other-components/sh-cron-modal/mixin/cron-box.js

@@ -1,169 +0,0 @@
-const TypeEnum = {
-	unset: 'UNSET',
-	every: 'EVERY',
-	range: 'RANGE',
-	loop: 'LOOP',
-	work: 'WORK',
-	last: 'LAST',
-	specify: 'SPECIFY'
-}
-
-export default {
-	props: {
-		modelValue: {
-			type: String,
-			default: '*'
-		},
-		disabled: {
-			type: Boolean
-		}
-	},
-	emits: ['update:modelValue', 'change'],
-	data() {
-		return {
-			TypeEnum: TypeEnum,
-			type: TypeEnum.every,
-			valueList: [],
-			valueWork: ''
-		}
-	},
-	computed: {
-		beforeRadioAttrs() {
-			return {
-				class: ['choice'],
-				disabled: this.disabled
-			}
-		},
-		inputNumberAttrs() {
-			return {
-				class: ['cron-item-input'],
-				type: 'integer',
-				size: 'mini'
-			}
-		},
-		typeRangeAttrs() {
-			return {
-				...this.inputNumberAttrs,
-				disabled: this.type !== TypeEnum.range || this.disabled
-			}
-		},
-		typeLoopAttrs() {
-			return {
-				...this.inputNumberAttrs,
-				disabled: this.type !== TypeEnum.loop || this.disabled
-			}
-		},
-		typeSpecifyAttrs() {
-			return {
-				class: ['list-check-item'],
-				disabled: this.type !== TypeEnum.specify || this.disabled
-			}
-		},
-		specifyRange() {
-			const { minValue, maxValue } = this
-			let range = []
-			if (maxValue != null) {
-				for (let i = minValue; i <= maxValue; i++) {
-					range.push(i)
-				}
-			}
-			return range
-		},
-		// 根据不同的类型计算出的value
-		computeValue() {
-			let { defaultValue, type, valueRange, valueLoop, valueWork, valueList, minValue } = this
-			let valueArray = []
-			switch (type) {
-				case TypeEnum.unset:
-					valueArray.push('?')
-					break
-				case TypeEnum.every:
-					valueArray.push('*')
-					break
-				case TypeEnum.range:
-					valueArray.push(`${valueRange.start}-${valueRange.end}`)
-					break
-				case TypeEnum.loop:
-					valueArray.push(`${valueLoop.start}/${valueLoop.interval}`)
-					break
-				case TypeEnum.work:
-					valueArray.push(`${valueWork}W`)
-					break
-				case TypeEnum.last:
-					valueArray.push('L')
-					break
-				case TypeEnum.specify:
-					if (valueList.length === 0) {
-						valueList.push(minValue)
-					}
-					valueArray.push(valueList.join(','))
-					break
-				default:
-					valueArray.push(defaultValue)
-					break
-			}
-			return valueArray.length > 0 ? valueArray.join('') : defaultValue
-		}
-	},
-	methods: {
-		parseValue(value) {
-			let { computeValue, defaultValue } = this
-			if (value === computeValue) {
-				return
-			}
-			try {
-				if (!value || value === defaultValue) {
-					this.type = TypeEnum.every
-				} else if (value.indexOf('?') >= 0) {
-					this.type = TypeEnum.unset
-				} else if (value.indexOf('-') >= 0) {
-					this.type = TypeEnum.range
-					const values = value.split('-')
-					if (values.length >= 2) {
-						this.valueRange.start = parseInt(values[0])
-						this.valueRange.end = parseInt(values[1])
-					}
-				} else if (value.indexOf('/') >= 0) {
-					this.type = TypeEnum.loop
-					const values = value.split('/')
-					if (values.length >= 2) {
-						this.valueLoop.start = value[0] === '*' ? 0 : parseInt(values[0])
-						this.valueLoop.interval = parseInt(values[1])
-					}
-				} else if (value.indexOf('W') >= 0) {
-					this.type = TypeEnum.work
-					const values = value.split('W')
-					if (!values[0] && !isNaN(values[0])) {
-						this.valueWork = parseInt(values[0])
-					}
-				} else if (value.indexOf('L') >= 0) {
-					this.type = TypeEnum.last
-				} else if (value.indexOf(',') >= 0 || !isNaN(value)) {
-					this.type = TypeEnum.specify
-					this.valueList = value.split(',').map(item => parseInt(item))
-				} else {
-					this.type = TypeEnum.every
-				}
-			} catch (e) {
-				this.type = TypeEnum.every
-			}
-		},
-		updateValue(value) {
-			this.$emit('change', value)
-			this.$emit('update:modelValue', value)
-		}
-	},
-	watch: {
-		modelValue: {
-			handler(val) {
-				if (val !== this.computeValue) {
-					this.parseValue(val)
-				}
-			},
-			immediate: true
-		},
-		computeValue(v) {
-			this.updateValue(v)
-		}
-	}
-}

package/packages/vxeTable/render/mixin/cell-mixin.js

@@ -1,195 +0,0 @@
-export default {
-	props: {
-		redit: { type: Boolean },
-		rkey: { type: String },
-		rname: { type: String },
-		rdata: {
-			type: Object,
-			default() {
-				return {}
-			}
-		},
-		rprops: {
-			type: Object,
-			default() {
-				return {}
-			}
-		},
-		rparams: {
-			type: Object,
-			default() {
-				return {}
-			}
-		}
-	},
-	data() {
-		return {
-			renderValue: null
-		}
-	},
-	computed: {
-		rsize() {
-			return this.rprops.size || this.rparams.$table?.props?.size || this.rparams.$form?.props?.size
-		},
-		rform() {
-			return this.rparams.$form
-		},
-		reditmode() {
-			return this.rparams.$table?.props?.editConfig?.mode
-		},
-		isEditAll() {
-			return !this.rform && this.reditmode === 'all'
-		},
-		moneyUnitText() {
-			let moneyUnitConstants = [
-				{ value: 1, label: '元' },
-				{ value: 1000, label: '千元' },
-				{ value: 10000, label: '万元' }
-			]
-			let moneyConstant = moneyUnitConstants.find(item => item.value === this.rprops.moneyUnit)
-			return moneyConstant && moneyConstant.label
-		},
-		billGroups() {
-			let { billStart = '分', billEnd = '亿' } = this.rprops
-			let cnGroups = [
-				{ shortText: '兆', fullText: '兆', value: '' },
-				{ shortText: '千', fullText: '千亿', value: '' },
-				{ shortText: '百', fullText: '百亿', value: '' },
-				{ shortText: '十', fullText: '十亿', value: '' },
-				{ shortText: '亿', fullText: '亿', value: '' },
-				{ shortText: '千', fullText: '千万', value: '' },
-				{ shortText: '百', fullText: '百万', value: '' },
-				{ shortText: '十', fullText: '十万', value: '' },
-				{ shortText: '万', fullText: '万', value: '' },
-				{ shortText: '千', fullText: '千', value: '' },
-				{ shortText: '百', fullText: '百', value: '' },
-				{ shortText: '十', fullText: '十', value: '' },
-				{ shortText: '元', fullText: '元', value: '' },
-				{ shortText: '角', fullText: '角', value: '' },
-				{ shortText: '分', fullText: '分', value: '' },
-				{ shortText: '毫', fullText: '毫', value: '' },
-				{ shortText: '厘', fullText: '厘', value: '' }
-			]
-			let startIndex = cnGroups.findIndex(cn => cn.fullText === billEnd)
-			let endIndex = cnGroups.findIndex(cn => cn.fullText === billStart)
-			return cnGroups.slice(startIndex, endIndex)
-		},
-		getBillClass() {
-			return bil => {
-				return {
-					basic: bil.fullText === '元',
-					commafy: ['千', '百万', '十亿', '兆'].includes(bil.fullText)
-				}
-			}
-		},
-		renderText() {
-			let keyValue = this.$vUtils.get(this.rdata, this.rkey)
-			let { rtext } = this.formatValueFun(keyValue)
-			return rtext
-		}
-	},
-	methods: {
-		// 输入框变化
-		async vxeInputChange({ value, $event }) {
-			if (!this.rform) {
-				this.setTableValue(value)
-			}
-		},
-		// 输入框变化回调
-		async vxeChangeCallBack({ value, $event }) {
-			if (this.rform) {
-				this.setFormValue(value)
-			} else {
-				this.setTableValue(value)
-			}
-		},
-		// radio 变化回调
-		async vxeRadioCallBack({ label, $event }) {
-			if (this.rform) {
-				this.setFormValue(label)
-			} else {
-				this.setTableValue(label)
-			}
-		},
-		// check变化回调
-		async vxeCheckCallBack({ checklist, checked, label, $event }) {
-			if (this.rform) {
-				this.setFormValue(checklist)
-			} else {
-				this.setTableValue(checklist)
-			}
-		},
-		// 输入框失去焦点回调
-		async vxeBlurCallback({ value, $event }) {
-			if (this.rform) {
-				this.setFormValue(value)
-			} else {
-				this.setTableValue(value)
-			}
-		},
-		// form回调赋值
-		setFormValue(value) {
-			if (['$vMoney'].includes(this.rname) && value !== '') value = this.$vUtils.multiply(value, this.rprops.moneyUnit || 1)
-			let { rvalue } = this.formatValueFun(value, true)
-			let { data, $form } = this.rparams
-			this.$vUtils.set(data, this.rkey, rvalue)
-			$form.context.emit('edit-closed', this.rparams, this)
-		},
-		// table回调赋值
-		setTableValue(value) {
-			if (['$vMoney'].includes(this.rname) && value !== '') value = this.$vUtils.multiply(value, this.rprops.moneyUnit || 1)
-			const { row, column } = this.rparams
-			const { model } = column
-			model.change = true
-			model.value = value
-		},
-		// 格式化值formatValue
-		formatValueFun(value, editable) {
-			let rObj = this.$vUtils.formatRender(value, this.rkey, this.rdata, this.rname, this.rprops, this, editable)
-			this.renderValue = ['$vMoney'].includes(this.rname) ? rObj.rtext : rObj.rvalue
-			return rObj
-		},
-		// 格式化底部值
-		getFooterData(qianfen = true) {
-			let { $table, items, itemIndex, column } = this.rparams
-			let tableData = $table.reactData.tableData
-			let { rname, rprops, rfooter, property } = column
-			let { digits, moneyUnit, commafy, type, calculate } = rprops
-			let footerValue = items[itemIndex]
-			if (rfooter) {
-				let caculateObj = rfooter[items[rfooter.index || 0]]
-				if (caculateObj && (rname === '$vMoney' || (['number', 'float', 'integer'].includes(type) && calculate))) {
-					let tableColumnData = this.$vUtils.mapTree(tableData, row => row[property])
-					let { computeType, result, typeObj } = caculateObj
-					switch (computeType) {
-						case 'subTotal':
-							footerValue = this.$vUtils.sum(tableColumnData)
-							break
-						case 'allTotal':
-							footerValue = typeObj[property] || result
-							break
-						case 'mean':
-							footerValue = this.$vUtils.mean(tableColumnData)
-							break
-						default:
-							footerValue = result
-							break
-					}
-					if (rname === '$vMoney') footerValue = this.$vUtils.truncate(this.$vUtils.divide(footerValue, moneyUnit), digits)
-					if (qianfen && commafy) footerValue = this.$vUtils.commafy(footerValue, { digits })
-				}
-			}
-			return footerValue
-		},
-		// 获取单据值
-		getBillValue(index, total = false) {
-			let value = total ? this.getFooterData(false) : this.renderValue
-			if (!value) return ''
-			let fullValue = this.$vUtils.formatMoneyPad(value)
-			let fullList = fullValue.replace('.', '').split('')
-			return fullList[index]
-		}
-	},
-	created() {},
-	activated() {}
-}