dykj-outsource-12123/uni_modules/uni-ui/components/uni-field/uni-field.vue

<template>
	<view class="uni-field" :class="{ 'uni-border-top': borderTop, 'uni-border-bottom': borderBottom }" :style="[fieldStyle]">
		<view class="uni-field-inner" :class="[type == 'textarea' ? 'uni-textarea-inner' : '', 'uni-label-postion-' + labelPos]">
			<view :class="errorTop ? 'uni-error-in-label' : ''">
				<view class="uni-field-label" :class="[required ? 'uni-required' : '']" :style="{
						justifyContent: justifyContent,
						width: labelWid + 'px',
						marginBottom: labelMarginBottom
					}">
					<view class="uni-icon-wrap" v-if="leftIcon">
						<uni-icons size="16" :type="leftIcon" :color="iconColor" />
					</view>
					<slot name="leftIcon"></slot>
					<text class="uni-label-text" :class="[leftIcon ? 'uni-label-left-gap' : '']">{{ label }}</text>
				</view>
				<view v-if="errorTop" class="uni-error-message" :style="{ paddingLeft: '4px' }">{{ msg }}</view>
			</view>
			<view class="fild-body" :class="[inputBorder ? 'uni-input-border' : '']" :style="[borderEixstTextareaStyle]">
				<view class="uni-flex-1 uni-flex" :style="[inputWrapStyle]">
					<textarea v-if="type == 'textarea'" class="uni-flex-1 uni-textarea-class" :name="name" :value="value" :placeholder="placeholder"
					 :placeholderStyle="placeholderStyle" :disabled="disabled" :maxlength="inputMaxlength" :focus="focus" :autoHeight="autoHeight"
					 @input="onInput" @blur="onBlur" @focus="onFocus" @confirm="onConfirm" @tap="fieldClick" />
					<input
						v-else
						:type="type"
						class="uni-flex-1 uni-field__input-wrap"
						:name="name"
						:value="value"
						:password="password || this.type === 'password'"
						:placeholder="placeholder"
						:placeholderStyle="placeholderStyle"
						:disabled="disabled"
						:maxlength="inputMaxlength"
						:focus="focus"
						:confirmType="confirmType"
						@focus="onFocus"
						@blur="onBlur"
						@input="onInput"
						@confirm="onConfirm"
						@tap="fieldClick"
					/>
					<uni-icons :size="clearSize" v-if="clearable && value != ''" type="clear" color="#c0c4cc" @click="onClear" class="uni-clear-icon" />
				</view>
				<view class="uni-button-wrap"><slot name="right" /></view>
				<uni-icons v-if="rightIcon" size="16" @click="rightIconClick" :type="rightIcon" color="#c0c4cc" :style="[rightIconStyle]" />
			</view>
		</view>
		<view
			v-if="errorBottom"
			class="uni-error-message"
			:style="{
				paddingLeft: Number(labelWid) + 4 + 'px'
			}"
		>
			{{ msg }}
		</view>
	</view>
</template>

<script>
/**
 * Field 输入框
 * @description 此组件可以实现表单的输入与校验，包括 "text" 和 "textarea" 类型。
 * @tutorial https://ext.dcloud.net.cn/plugin?id=21001
 * @property {String } 	type 				输入框的类型（默认text）
 * @property {Boolean} 	required 			是否必填，左边您显示红色"*"号（默认false）
 * @property {String } 	leftIcon 			label左边的图标，限uni-ui的图标名称
 * @property {String } 	iconColor 			左边通过icon配置的图标的颜色（默认#606266）
 * @property {Boolean} 	rightIcon 			输入框右边的图标名称，限uni-ui的图标名称（默认false）
 * @property {String } 	label 				输入框左边的文字提示
 * @property {Number } 	labelWidth 			label的宽度，单位px（默认65）
 * @property {String } 	labelAlign 			label的文字对齐方式（默认left）
 * @property {String } 	labelPosition 		label的文字的位置（默认left）
 * @property {Boolean} 	clearable 			是否显示右侧清空内容的图标控件(输入框有内容，且获得焦点时才显示)，点击可清空输入框内容（默认true）
 * @property {String } 	placeholder 		输入框的提示文字
 * @property {String } 	placeholderStyle 	placeholder的样式(内联样式，字符串)，如"color: #ddd"
 * @property {Boolean} 	password 			是否密码输入方式(用点替换文字)，type为text时有效（默认false）
 * @property {Boolean} 	focus 				是否自动获得焦点（默认false）
 * @property {Boolean} 	disabled 			是否不可输入（默认false）
 * @property {Number } 	maxlength 			最大输入长度，设置为 -1 的时候不限制最大长度（默认140）
 * @property {String } 	confirmType 		设置键盘右下角按钮的文字，仅在type="text"时生效（默认done）
 * @property {String } 	errorMessage 		显示的错误提示内容，如果为空字符串或者false，则不显示错误信息
 * @property {Number } 	clearSize 			清除图标的大小，单位px（默认15）
 * @property {Boolean} 	trim 				是否自动去除两端的空格
 * @property {String } 	name 				表单域的属性名，在使用校验规则时必填
 * @property {Array  }  rules 				单行表单验证规则，接受一个数组
 * @property {Boolean} 	inputBorder 		是否显示input输入框的边框（默认false）
 * @property {Boolean} 	border-bottom 		是否显示field的下边框（默认true）
 * @property {Boolean} 	border-top 			是否显示field的上边框（默认false）
 * @property {Boolean} 	auto-height 		是否自动增高输入区域，type为textarea时有效（默认true）
 * @event {Function} 	input 				输入框内容发生变化时触发
 * @event {Function} 	focus 				输入框获得焦点时触发
 * @event {Function} 	blur 				输入框失去焦点时触发
 * @event {Function} 	confirm 			点击完成按钮时触发
 * @event {Function} 	right-icon-click 	通过right-icon生成的图标被点击时触发
 * @event {Function} 	click 				输入框被点击或者通过right-icon生成的图标被点击时触发，这样设计是考虑到传递右边的图标，一般都为需要弹出"picker"等操作时的场景，点击倒三角图标，理应发出此事件，见上方说明
 * @example <uni-field v-model="mobile" label="手机号" required :error-message="errorMessage"></uni-field>
 */
export default {
	name: 'uni-field',
	props: {
		// rules:{
		// 	type:Array,
		// 	default(){
		// 		return []
		// 	}
		// },
		trigger: {
			type: String,
			default: ''
		},
		leftIcon: String,
		rightIcon: String,
		required: Boolean,
		label: String,
		password: Boolean,
		clearable: {
			type: Boolean,
			default: true
		},
		// 左边标题的宽度单位px
		labelWidth: {
			type: [Number, String],
			default: ''
		},
		// 对齐方式，left|center|right
		labelAlign: {
			type: String,
			default: ''
		},
		iconColor: {
			type: String,
			default: '#606266'
		},
		autoHeight: {
			type: Boolean,
			default: true
		},
		errorMessage: {
			type: [String, Boolean],
			default: ''
		},
		placeholder: String,
		placeholderStyle: String,
		focus: Boolean,
		name: String,
		value: [Number, String],
		type: {
			type: String,
			default: 'text'
		},
		disabled: {
			type: Boolean,
			default: false
		},
		maxlength: {
			type: [Number, String],
			default: 140
		},
		confirmType: {
			type: String,
			default: 'done'
		},
		// lable的位置，可选为 left-左边，top-上边
		labelPosition: {
			type: String,
			default: ''
		},
		// 清除按钮的大小
		clearSize: {
			type: [Number, String],
			default: 15
		},
		// 是否显示 input 边框
		inputBorder: {
			type: Boolean,
			default: false
		},
		// 是否显示上边框
		borderTop: {
			type: Boolean,
			default: false
		},
		// 是否显示下边框
		borderBottom: {
			type: Boolean,
			default: true
		},
		// 是否自动去除两端的空格
		trim: {
			type: Boolean,
			default: true
		}
	},
	data() {
		return {
			focused: false,
			itemIndex: 0,
			errorTop: false,
			errorBottom: false,
			labelMarginBottom: '',
			errorWidth: '',
			errMsg: '',
			errorBorderColor: false,
			val: '',
			labelPos: '',
			labelWid: '',
			labelAli: ''
		};
	},
	computed: {
		msg() {
			return this.errorMessage || this.errMsg;
		},
		fieldStyle() {
			let style = {};
			if (this.labelPos === 'top') {
				style.padding = '10px 14px';
				this.labelMarginBottom = '6px';
			}
			if (this.labelPos === 'left' && this.msg !== false && this.msg !== '') {
				style.paddingBottom = '0px';
				this.errorBottom = true;
				this.errorTop = false;
			} else if (this.labelPos === 'top' && this.msg !== false && this.msg !== '') {
				this.errorBottom = false;
				this.errorTop = true;
			} else {
				// style.paddingBottom = ''
				this.errorTop = false;
				this.errorBottom = false;
			}
			return style;
		},

		borderEixstTextareaStyle() {
			let style = {};
			if (this.inputBorder) {
				if (this.type === 'textarea') {
					style.minHeight = '60px';
				}
				if (this.msg !== false && this.msg != '') {
					style.borderColor = '#dd524d';
				}
			}
			return style;
		},

		inputWrapStyle() {
			let style = {};
			// 判断lable的位置，如果是left的话，让input左边两边有间隙
			if (this.labelPos == 'left') {
				style.margin = `0 4px`;
			} else {
				// 如果lable是top的，input的左边就没必要有间隙了
				style.marginRight = `4px`;
				// this.fieldStyle.style.padding = '10px 14px'
			}
			return style;
		},
		rightIconStyle() {
			let style = {};
			if (this.arrowDirection == 'top') style.transform = 'roate(-90deg)';
			if (this.arrowDirection == 'bottom') style.transform = 'roate(90deg)';
			else style.transform = 'roate(0deg)';
			return style;
		},
		labelStyle() {
			let style = {};
			if (this.labelAli == 'left') style.justifyContent = 'flext-start';
			if (this.labelAli == 'center') style.justifyContent = 'center';
			if (this.labelAli == 'right') style.justifyContent = 'flext-end';
			return style;
		},
		// uni不支持在computed中写style.justifyContent = 'center'的形式，故用此方法
		justifyContent() {
			if (this.labelAli == 'left') return 'flex-start';
			if (this.labelAli == 'center') return 'center';
			if (this.labelAli == 'right') return 'flex-end';
		},
		// 因为uniapp的input组件的maxlength组件必须要数值，这里转为数值，给用户可以传入字符串数值
		inputMaxlength() {
			return Number(this.maxlength);
		},
		// label的位置
		fieldInnerStyle() {
			let style = {};
			if (this.labelPos == 'left') {
				style.flexDirection = 'row';
			} else {
				style.flexDirection = 'column';
			}

			return style;
		}
	},
	watch: {
		trigger(trigger) {
			this.formTrigger = trigger;
		}
	},
	created() {
		this.form = this.getForm();
		this.formRules = [];
		this.formTrigger = this.trigger;
		this.init();
	},
	methods: {
		/**
		 * 初始化变量值
		 */
		init() {
			if (this.form) {
				this.form.childrens.push(this);
				this.labelPos = this.labelPosition ? this.labelPosition : this.form.labelPosition;
				this.labelWid = this.labelWidth ? this.labelWidth : this.form.labelWidth;
				this.labelAli = this.labelAlign ? this.labelAlign : this.form.labelAlign;

				if (this.form.formRules) {
					this.formRules = this.form.formRules[this.name];
				}
				this.validator = this.form.validator;
				if(this.name){
					this.form.formData[this.name] = this.value || '';
				}
			} else {
				this.labelPos = this.labelPosition || 'left';
				this.labelWid = this.labelWidth || 65;
				this.labelAli = this.labelAlign || 'left';
			}
		},
		/**
		 * 获取父元素实例
		 */
		getForm() {
			let parent = this.$parent;
			let parentName = parent.$options.name;
			while (parentName !== 'uniForms') {
				parent = parent.$parent;
				if (!parent) return false;
				parentName = parent.$options.name;
			}
			return parent;
		},

		/**
		 * 移除该表单项的校验结果
		 */
		clearValidate() {
			this.errMsg = '';
		},
		/**
		 * 父组件处理函数
		 * @param {Object} callback
		 */
		parentVal(callback) {
			if (this.type === 'number') {
				this.val = this.val === '' ? this.val : Number(this.val);
			}
			typeof callback === 'function' &&
				callback(
					{
						[this.name]: this.val
					},
					this.name
				);
		},
		/**
		 * 触发校验
		 * @param {Object} trigger
		 * @param {Object} value
		 */
		triggerValidator(trigger, value) {
			let isValid = false;
			// 如果 name 不存在，则不开启校验
			this.formRules &&
				this.formRules.rules &&
				this.formRules.rules.forEach(item => {
					item.trigger = this.isTrigger(this.form.formTrigger, this.formTrigger, item.trigger);
					if (item.trigger !== trigger || item.trigger === 'submit') return;
					isValid = true;
				});

			isValid && this.triggerCheck(value);
		},
		/**
		 * 校验规则
		 * @param {Object} value
		 */
		triggerCheck(value, item) {
			// 输入值为 number
			if (this.type === 'number') {
				value = value === '' ? value : Number(value);
			}
			const result = this.validator.validateUpdate({
				[this.name]: value
			});
			this.errMsg = !result ? '' : result.errorMessage;
			this.form.validateCheck(result);
		},
		/**
		 * 触发时机
		 * @param {Object} event
		 */
		isTrigger(parentRule, itemRlue, rule) {
			let rl = 'none';
			if (rule) {
				rl = rule;
			} else if (itemRlue) {
				rl = itemRlue;
			} else if (parentRule) {
				rl = parentRule;
			} else {
				rl = 'blur';
			}
			return rl;
		},

		onInput(event) {
			let value = event.detail.value;
			// 判断是否去除空格
			if (this.trim) value = this.trimStr(value);
			this.form.formData[this.name] = value || '';
			this.val = value;
			this.$emit('input', value);
			// 校验输入
			this.triggerValidator('change', value);
		},

		onFocus(event) {
			this.focused = true;
			this.$emit('focus', event);
		},
		onBlur(event) {
			let value = event.detail.value;
			// 最开始使用的是监听图标@touchstart事件，自从hx2.8.4后，此方法在微信小程序出错
			// 这里改为监听点击事件，手点击清除图标时，同时也发生了@blur事件，导致图标消失而无法点击，这里做一个延时
			setTimeout(() => {
				this.focused = false;
			}, 100);
			this.$emit('blur', event);

			// 校验输入
			this.triggerValidator('blur', value);
		},
		onConfirm(e) {
			this.$emit('confirm', e.detail.value);
		},
		onClear(event) {
			this.val = '';
			this.$emit('input', '');
			this.clearValidate();
		},
		rightIconClick() {
			this.$emit('right-icon-click');
			this.$emit('click');
		},
		fieldClick() {
			this.$emit('click');
		},
		trimStr(str, pos = 'both') {
			if (pos == 'both') {
				return str.replace(/^\s+|\s+$/g, '');
			} else if (pos == 'left') {
				return str.replace(/^\s*/, '');
			} else if (pos == 'right') {
				return str.replace(/(\s*$)/g, '');
			} else if (pos == 'all') {
				return str.replace(/\s+/g, '');
			} else {
				return str;
			}
		}
	}
};
</script>

<style lang="scss" scoped>
.uni-field {
	padding: 16px 14px;
	text-align: left;
	color: #333;
	font-size: 14px;
	background-color: #fff;
}

.uni-field-inner {
	display: flex;
	align-items: center;
}

.uni-textarea-inner {
	align-items: flex-start;
}

.uni-textarea-class {
	min-height: 48px;
	width: auto;
	font-size: 14px;
}

.fild-body {
	width: 100%;
	display: flex;
	flex: 1;
	align-items: center;
}

.uni-arror-right {
	margin-left: 4px;
}

.uni-label-text {
	display: inline-block;
}

.uni-label-left-gap {
	margin-left: 3px;
}

.uni-label-postion-top {
	flex-direction: column;
	align-items: flex-start;
	flex: 1;
}

.uni-field-label {
	width: 65px;
	flex: 1 1 65px;
	text-align: left;
	position: relative;
	display: flex;
	align-items: center;
}

.uni-required::before {
	content: '*';
	position: absolute;
	left: -8px;
	font-size: 14px;
	color: $uni-color-error;
	height: 9px;
	line-height: 1;
}

.uni-field__input-wrap {
	position: relative;
	overflow: hidden;
	font-size: 14px;
	height: 24px;
	flex: 1;
	width: auto;
}

.uni-clear-icon {
	display: flex;
	align-items: center;
}

.uni-error-message {
	line-height: 12px;
	padding-top: 2px;
	padding-bottom: 2px;
	color: $uni-color-error;
	font-size: 12px;
	text-align: left;
}

.uni-input-error-border {
	border-color: $uni-color-error;
}

.placeholder-style {
	color: rgb(150, 151, 153);
}

.uni-input-class {
	font-size: 14px;
}

.uni-button-wrap {
	margin-left: 4px;
}

/* start--Retina 屏幕下的 1px 边框--start */
.uni-border,
.uni-border-bottom,
.uni-border-left,
.uni-border-right,
.uni-border-top,
.uni-border-top-bottom {
	position: relative;
}

.uni-border-bottom:after,
.uni-border-left:after,
.uni-border-right:after,
.uni-border-top-bottom:after,
.uni-border-top:after,
.uni-border:after {
	/* #ifndef APP-NVUE */
	content: ' ';
	/* #endif */
	position: absolute;
	left: 0;
	top: 0;
	pointer-events: none;
	box-sizing: border-box;
	-webkit-transform-origin: 0 0;
	transform-origin: 0 0;
	// 多加0.1%，能解决有时候边框缺失的问题
	width: 199.8%;
	height: 199.7%;
	transform: scale(0.5, 0.5);
	border: 0 solid $uni-border-color;
	z-index: 2;
}

.uni-input-border {
	min-height: 34px;
	padding-left: 4px;
	border: 1px solid $uni-border-color;
	border-radius: 6px;
	box-sizing: border-box;
}

.uni-border-top:after {
	border-top-width: 1px;
}

.uni-border-left:after {
	border-left-width: 1px;
}

.uni-border-right:after {
	border-right-width: 1px;
}

.uni-border-bottom:after {
	border-bottom-width: 1px;
}

.uni-border-top-bottom:after {
	border-width: 1px 0;
}

.uni-border:after {
	border-width: 1px;
}
/* end--Retina 屏幕下的 1px 边框--end */

.uni-icon-wrap {
	padding-left: 3px;
	padding-right: 3px;
	display: flex;
	align-items: center;
	justify-content: center;
}

.uni-button-wrap {
	display: flex;
	align-items: right;
	justify-content: center;
}
.uni-clear-icon {
	display: flex;
	align-items: center;
	margin-left: 4px;
}

.uni-flex {
	/* #ifndef APP-NVUE */
	display: flex;
	/* #endif */
	flex-direction: row;
	align-items: center;
}

.uni-flex-1 {
	flex: 1;
}
.uni-error-in-label {
	display: flex;
	flex-direction: row;
}
</style>