sadais-piui 1.2.7-beta13 → 1.2.7-beta14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/components/pi-circle-progress/index.vue +142 -75
- package/components/pi-collapse/index.vue +114 -0
- package/components/pi-collapse-item/index.vue +347 -0
- package/components/pi-form-item/index.vue +0 -1
- package/components/pi-tag/index.vue +488 -0
- package/config/circleProgress.js +4 -1
- package/config/collapse.js +7 -0
- package/config/collapseItem.js +11 -0
- package/config/tag.js +21 -0
- package/package.json +1 -1
|
@@ -12,7 +12,7 @@
|
|
|
12
12
|
:style="{
|
|
13
13
|
width: widthPx + 'px',
|
|
14
14
|
height: widthPx + 'px',
|
|
15
|
-
backgroundColor: bgColor
|
|
15
|
+
backgroundColor: bgColor,
|
|
16
16
|
}"
|
|
17
17
|
>
|
|
18
18
|
<canvas
|
|
@@ -21,7 +21,7 @@
|
|
|
21
21
|
class="pi-canvas-bg"
|
|
22
22
|
:style="{
|
|
23
23
|
width: widthPx + 'px',
|
|
24
|
-
height: widthPx + 'px'
|
|
24
|
+
height: widthPx + 'px',
|
|
25
25
|
}"
|
|
26
26
|
/>
|
|
27
27
|
<canvas
|
|
@@ -30,78 +30,82 @@
|
|
|
30
30
|
class="pi-canvas"
|
|
31
31
|
:style="{
|
|
32
32
|
width: widthPx + 'px',
|
|
33
|
-
height: widthPx + 'px'
|
|
33
|
+
height: widthPx + 'px',
|
|
34
34
|
}"
|
|
35
35
|
/>
|
|
36
36
|
</view>
|
|
37
37
|
</template>
|
|
38
38
|
<script>
|
|
39
|
-
import { getConfig } from
|
|
40
|
-
const { circleProgress } = getConfig()
|
|
39
|
+
import { getConfig } from "../../config";
|
|
40
|
+
const { circleProgress } = getConfig();
|
|
41
41
|
|
|
42
42
|
export default {
|
|
43
|
-
name:
|
|
43
|
+
name: "PiCircleProgress",
|
|
44
44
|
props: {
|
|
45
45
|
// 圆环进度百分比值
|
|
46
46
|
percent: {
|
|
47
47
|
type: Number,
|
|
48
48
|
default: circleProgress.percent,
|
|
49
49
|
// 限制值在0到100之间
|
|
50
|
-
validator: val => {
|
|
51
|
-
return val >= 0 && val <= 100
|
|
52
|
-
}
|
|
50
|
+
validator: (val) => {
|
|
51
|
+
return val >= 0 && val <= 100;
|
|
52
|
+
},
|
|
53
53
|
},
|
|
54
54
|
// 整个圆环进度区域的背景色
|
|
55
55
|
bgColor: {
|
|
56
56
|
type: String,
|
|
57
|
-
default: circleProgress.bgColor
|
|
57
|
+
default: circleProgress.bgColor,
|
|
58
58
|
},
|
|
59
59
|
// 底部圆环的颜色(灰色的圆环)
|
|
60
60
|
inactiveColor: {
|
|
61
61
|
type: String,
|
|
62
|
-
default: circleProgress.inactiveColor
|
|
62
|
+
default: circleProgress.inactiveColor,
|
|
63
63
|
},
|
|
64
64
|
// 圆环激活部分的颜色
|
|
65
65
|
activeColor: {
|
|
66
66
|
type: String,
|
|
67
|
-
default: circleProgress.activeColor
|
|
67
|
+
default: circleProgress.activeColor,
|
|
68
68
|
},
|
|
69
69
|
// 圆环线条的宽度,单位rpx
|
|
70
70
|
borderWidth: {
|
|
71
71
|
type: [Number, String],
|
|
72
|
-
default: circleProgress.borderWidth
|
|
72
|
+
default: circleProgress.borderWidth,
|
|
73
73
|
},
|
|
74
74
|
// 整个圆形的宽度,单位rpx
|
|
75
75
|
width: {
|
|
76
76
|
type: [Number, String],
|
|
77
|
-
default: circleProgress.width
|
|
77
|
+
default: circleProgress.width,
|
|
78
78
|
},
|
|
79
79
|
// 整个圆环执行一圈的时间,单位ms
|
|
80
80
|
duration: {
|
|
81
81
|
type: [Number, String],
|
|
82
|
-
default: circleProgress.duration
|
|
82
|
+
default: circleProgress.duration,
|
|
83
83
|
},
|
|
84
84
|
// 主题类型
|
|
85
85
|
type: {
|
|
86
86
|
type: String,
|
|
87
|
-
default: circleProgress.type
|
|
87
|
+
default: circleProgress.type,
|
|
88
88
|
},
|
|
89
89
|
|
|
90
90
|
// 字体大小
|
|
91
91
|
fontSize: {
|
|
92
92
|
type: String,
|
|
93
|
-
default: circleProgress.fontSize
|
|
93
|
+
default: circleProgress.fontSize,
|
|
94
94
|
},
|
|
95
95
|
// 显示的文字 默认为空
|
|
96
96
|
text: {
|
|
97
97
|
type: String,
|
|
98
|
-
default: circleProgress.text
|
|
99
|
-
}
|
|
98
|
+
default: circleProgress.text,
|
|
99
|
+
},
|
|
100
|
+
linearGradient: {
|
|
101
|
+
type: Object,
|
|
102
|
+
default: circleProgress.linearGradient,
|
|
103
|
+
},
|
|
100
104
|
},
|
|
101
105
|
data() {
|
|
102
106
|
return {
|
|
103
|
-
elBgId:
|
|
104
|
-
elId:
|
|
107
|
+
elBgId: "pCircleProgressBgId", // 微信小程序中不能使用this.$pi形式动态生成id值,否则会报错
|
|
108
|
+
elId: "pCircleProgressElId",
|
|
105
109
|
elBgId: this.$pi.guid(), // 支付宝等小程序 动态生产ID
|
|
106
110
|
elId: this.$pi.guid(),
|
|
107
111
|
progressContext: null,
|
|
@@ -110,103 +114,166 @@ export default {
|
|
|
110
114
|
borderWidthPx: uni.upx2px(this.borderWidth), // 转成px后的圆环的宽度
|
|
111
115
|
startAngle: -Math.PI / 2, // canvas画圆的起始角度,默认为3点钟方向,定位到12点钟方向
|
|
112
116
|
newPercent: 0, // 当动态修改进度值的时候,保存进度值的变化前后值,用于比较用
|
|
113
|
-
oldPercent: 0 // 当动态修改进度值的时候,保存进度值的变化前后值,用于比较用
|
|
114
|
-
}
|
|
117
|
+
oldPercent: 0, // 当动态修改进度值的时候,保存进度值的变化前后值,用于比较用
|
|
118
|
+
};
|
|
115
119
|
},
|
|
116
120
|
computed: {
|
|
117
121
|
// 有type主题时,优先起作用
|
|
118
122
|
circleColor() {
|
|
119
|
-
if (
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
+
if (
|
|
124
|
+
["success", "error", "info", "primary", "warning"].indexOf(this.type) >=
|
|
125
|
+
0
|
|
126
|
+
)
|
|
127
|
+
return this.$u.color[this.type];
|
|
128
|
+
else return this.activeColor;
|
|
129
|
+
},
|
|
123
130
|
},
|
|
124
131
|
watch: {
|
|
125
132
|
// 深度监听进度
|
|
126
133
|
percent(nVal, oVal = 0) {
|
|
127
|
-
if (nVal > 100) nVal = 100
|
|
128
|
-
if (nVal < 0) oVal = 0
|
|
134
|
+
if (nVal > 100) nVal = 100;
|
|
135
|
+
if (nVal < 0) oVal = 0;
|
|
129
136
|
// 此值其实等于this.percent,命名一个新值
|
|
130
|
-
this.newPercent = nVal
|
|
131
|
-
this.oldPercent = oVal
|
|
137
|
+
this.newPercent = nVal;
|
|
138
|
+
this.oldPercent = oVal;
|
|
132
139
|
setTimeout(() => {
|
|
133
140
|
// 无论是百分比值增加还是减少,需要操作还是原来的旧的百分比值
|
|
134
141
|
// 将此值减少或者新增到新的百分比值
|
|
135
|
-
this.drawCircleByProgress(oVal)
|
|
136
|
-
}, 50)
|
|
137
|
-
}
|
|
142
|
+
this.drawCircleByProgress(oVal);
|
|
143
|
+
}, 50);
|
|
144
|
+
},
|
|
138
145
|
},
|
|
139
146
|
mounted() {
|
|
140
147
|
// 背景圆
|
|
141
|
-
this.drawProgressBg()
|
|
148
|
+
this.drawProgressBg();
|
|
142
149
|
setTimeout(() => {
|
|
143
150
|
// 进度圆
|
|
144
|
-
this.drawCircleByProgress(this.percent)
|
|
145
|
-
}, 500)
|
|
151
|
+
this.drawCircleByProgress(this.percent);
|
|
152
|
+
}, 500);
|
|
146
153
|
},
|
|
147
154
|
created() {
|
|
148
|
-
this.newPercent = this.percent
|
|
149
|
-
this.oldPercent = 0
|
|
155
|
+
this.newPercent = this.percent;
|
|
156
|
+
this.oldPercent = 0;
|
|
150
157
|
},
|
|
151
158
|
methods: {
|
|
152
159
|
drawProgressBg() {
|
|
153
|
-
console.log(this)
|
|
154
|
-
let ctx = uni.createCanvasContext(this.elBgId, this)
|
|
155
|
-
ctx.setLineWidth(this.borderWidthPx) // 设置圆环宽度
|
|
156
|
-
ctx.setStrokeStyle(this.inactiveColor) // 线条颜色
|
|
157
|
-
ctx.beginPath() // 开描绘路径
|
|
160
|
+
console.log(this);
|
|
161
|
+
let ctx = uni.createCanvasContext(this.elBgId, this);
|
|
162
|
+
ctx.setLineWidth(this.borderWidthPx); // 设置圆环宽度
|
|
163
|
+
ctx.setStrokeStyle(this.inactiveColor); // 线条颜色
|
|
164
|
+
ctx.beginPath(); // 开描绘路径
|
|
158
165
|
// 设置一个原点(110,110),半径为100的圆的路径到当前路径
|
|
159
|
-
let radius = this.widthPx / 2
|
|
166
|
+
let radius = this.widthPx / 2;
|
|
160
167
|
// 用于绘制圆弧context.arc(x坐标,y坐标,半径,起始角度,终止角度,顺时针/逆时针)
|
|
161
|
-
ctx.arc(
|
|
162
|
-
|
|
163
|
-
|
|
168
|
+
ctx.arc(
|
|
169
|
+
radius,
|
|
170
|
+
radius,
|
|
171
|
+
radius - this.borderWidthPx,
|
|
172
|
+
0,
|
|
173
|
+
2 * Math.PI,
|
|
174
|
+
false
|
|
175
|
+
);
|
|
176
|
+
ctx.stroke(); // 对路径进行描绘
|
|
177
|
+
ctx.draw();
|
|
164
178
|
},
|
|
165
179
|
// 激活部分
|
|
166
180
|
drawCircleByProgress(progress) {
|
|
167
181
|
// 第一次操作进度环时将上下文保存到了this.data中,直接使用即可
|
|
168
|
-
let ctx = this.progressContext
|
|
182
|
+
let ctx = this.progressContext;
|
|
169
183
|
if (!ctx) {
|
|
170
|
-
ctx = uni.createCanvasContext(this.elId, this)
|
|
171
|
-
this.progressContext = ctx
|
|
184
|
+
ctx = uni.createCanvasContext(this.elId, this);
|
|
185
|
+
this.progressContext = ctx;
|
|
172
186
|
}
|
|
173
187
|
// 表示进度的两端为圆形
|
|
174
|
-
ctx.setLineCap(
|
|
188
|
+
ctx.setLineCap("round");
|
|
175
189
|
// 设置线条的宽度和颜色
|
|
176
|
-
ctx.setLineWidth(this.borderWidthPx)
|
|
177
|
-
|
|
190
|
+
ctx.setLineWidth(this.borderWidthPx);
|
|
191
|
+
if (
|
|
192
|
+
this.linearGradient &&
|
|
193
|
+
this.linearGradient.show &&
|
|
194
|
+
this.linearGradient.colorStop.length >= 2
|
|
195
|
+
) {
|
|
196
|
+
// this.imageData.slice(pos * 4, pos * 4 + 4);
|
|
197
|
+
let colorData = this.createColorData()
|
|
198
|
+
for(let i = 0;i < progress;i++){
|
|
199
|
+
const index= Math.round(i*255/progress)
|
|
200
|
+
const color = colorData.slice(index * 4,index * 4 + 4)
|
|
201
|
+
ctx.beginPath()
|
|
202
|
+
ctx.setStrokeStyle(color);
|
|
203
|
+
let endAngle = ((2 * Math.PI) / 100) * i + this.startAngle;
|
|
204
|
+
let startAngle = this.startAngle + ((2 * Math.PI) / 100)*( i - 1);
|
|
205
|
+
let radius = this.widthPx / 2;
|
|
206
|
+
ctx.arc(
|
|
207
|
+
radius,
|
|
208
|
+
radius,
|
|
209
|
+
radius - this.borderWidthPx,
|
|
210
|
+
startAngle,
|
|
211
|
+
endAngle,
|
|
212
|
+
false
|
|
213
|
+
);
|
|
214
|
+
ctx.stroke();
|
|
215
|
+
}
|
|
216
|
+
} else {
|
|
217
|
+
ctx.setStrokeStyle(this.circleColor);
|
|
218
|
+
// 结束角的计算依据为:将2π分为100份,乘以当前的进度值,得出终止点的弧度值,加起始角,为整个圆从默认的
|
|
219
|
+
// 3点钟方向开始画图,转为更好理解的12点钟方向开始作图,这需要起始角和终止角同时加上this.startAngle值
|
|
220
|
+
let endAngle = ((2 * Math.PI) / 100) * progress + this.startAngle;
|
|
221
|
+
ctx.beginPath();
|
|
222
|
+
// 半径为整个canvas宽度的一半
|
|
223
|
+
let radius = this.widthPx / 2;
|
|
224
|
+
ctx.arc(
|
|
225
|
+
radius,
|
|
226
|
+
radius,
|
|
227
|
+
radius - this.borderWidthPx,
|
|
228
|
+
this.startAngle,
|
|
229
|
+
endAngle,
|
|
230
|
+
false
|
|
231
|
+
);
|
|
232
|
+
ctx.stroke();
|
|
233
|
+
}
|
|
234
|
+
ctx.textAlign = "center";
|
|
235
|
+
ctx.font = this.fontSize + " Arial";
|
|
236
|
+
ctx.fillText(this.text, radius, radius);
|
|
237
|
+
ctx.stroke();
|
|
178
238
|
// 将总过渡时间除以100,得出每修改百分之一进度所需的时间
|
|
179
|
-
let time = Math.floor(this.duration / 100)
|
|
180
|
-
|
|
181
|
-
// 3点钟方向开始画图,转为更好理解的12点钟方向开始作图,这需要起始角和终止角同时加上this.startAngle值
|
|
182
|
-
let endAngle = ((2 * Math.PI) / 100) * progress + this.startAngle
|
|
183
|
-
ctx.beginPath()
|
|
184
|
-
// 半径为整个canvas宽度的一半
|
|
185
|
-
let radius = this.widthPx / 2
|
|
186
|
-
ctx.arc(radius, radius, radius - this.borderWidthPx, this.startAngle, endAngle, false)
|
|
187
|
-
ctx.textAlign = 'center'
|
|
188
|
-
ctx.font = this.fontSize + ' Arial'
|
|
189
|
-
ctx.fillText(this.text, radius, radius)
|
|
190
|
-
ctx.stroke()
|
|
191
|
-
ctx.draw()
|
|
239
|
+
let time = Math.floor(this.duration / 100);
|
|
240
|
+
ctx.draw();
|
|
192
241
|
// 如果变更后新值大于旧值,意味着增大了百分比
|
|
193
242
|
if (this.newPercent > this.oldPercent) {
|
|
194
243
|
// 每次递增百分之一
|
|
195
|
-
progress
|
|
244
|
+
progress++;
|
|
196
245
|
// 如果新增后的值,大于需要设置的值百分比值,停止继续增加
|
|
197
|
-
if (progress > this.newPercent) return
|
|
246
|
+
if (progress > this.newPercent) return;
|
|
198
247
|
} else {
|
|
199
248
|
// 同理于上面
|
|
200
|
-
progress
|
|
201
|
-
if (progress < this.newPercent) return
|
|
249
|
+
progress--;
|
|
250
|
+
if (progress < this.newPercent) return;
|
|
202
251
|
}
|
|
203
252
|
setTimeout(() => {
|
|
204
253
|
// 定时器,每次操作间隔为time值,为了让进度条有动画效果
|
|
205
|
-
this.drawCircleByProgress(progress)
|
|
206
|
-
}, time)
|
|
254
|
+
this.drawCircleByProgress(progress);
|
|
255
|
+
}, time);
|
|
256
|
+
},
|
|
257
|
+
createColorData(){
|
|
258
|
+
// #ifndef MP-WEIXIN
|
|
259
|
+
let canvas = document.createElement('canvas')
|
|
260
|
+
canvas.width = 256
|
|
261
|
+
canvas.height = 1
|
|
262
|
+
let ctx = canvas.getContext('2d');
|
|
263
|
+
// #endif
|
|
264
|
+
//ifdef MP-WEIXIN
|
|
265
|
+
let canvas = uni.createOffscreenCanvas({type: '2d', width: 256, height: 1})
|
|
266
|
+
// #endif
|
|
267
|
+
const linearGradient = ctx.createLinearGradient(0, 0, 256, 1)
|
|
268
|
+
this.linearGradient.colorStop.forEach(color => {
|
|
269
|
+
linearGradient.addColorStop(color.percent,color.value)
|
|
270
|
+
})
|
|
271
|
+
ctx.fillStyle = linearGradient
|
|
272
|
+
ctx.fillRect(0,0,256,1)
|
|
273
|
+
return ctx.getImageData(0,0,256,1).data
|
|
207
274
|
}
|
|
208
|
-
}
|
|
209
|
-
}
|
|
275
|
+
},
|
|
276
|
+
};
|
|
210
277
|
</script>
|
|
211
278
|
<style scoped lang="scss">
|
|
212
279
|
.circle-progress {
|
|
@@ -0,0 +1,114 @@
|
|
|
1
|
+
<template>
|
|
2
|
+
<view class="pi-collapse" :class="[customClass]" :style="[customStyle]">
|
|
3
|
+
<pi-divider v-if="border" />
|
|
4
|
+
<slot />
|
|
5
|
+
</view>
|
|
6
|
+
</template>
|
|
7
|
+
|
|
8
|
+
<script>
|
|
9
|
+
import { getConfig } from '../../config'
|
|
10
|
+
const { collapse } = getConfig()
|
|
11
|
+
/**
|
|
12
|
+
* collapse 折叠面板
|
|
13
|
+
* @description 通过折叠面板收纳内容区域
|
|
14
|
+
* @tutorial http://piui.sadais.com/docs/components/collapse.html
|
|
15
|
+
* @event {Function} change 当前激活面板展开时触发(如果是手风琴模式,参数activeNames类型为String,否则为Array)
|
|
16
|
+
* @example <pi-collapse />
|
|
17
|
+
*/
|
|
18
|
+
export default {
|
|
19
|
+
name: 'PiCollapse',
|
|
20
|
+
props: {
|
|
21
|
+
// 当前展开面板的name,非手风琴模式:[<string | number>],手风琴模式:string | number
|
|
22
|
+
value: {
|
|
23
|
+
type: [String, Number, Array],
|
|
24
|
+
default: collapse.value
|
|
25
|
+
},
|
|
26
|
+
// 是否手风琴模式
|
|
27
|
+
accordion: {
|
|
28
|
+
type: Boolean,
|
|
29
|
+
// false
|
|
30
|
+
default: collapse.accordion
|
|
31
|
+
},
|
|
32
|
+
// 是否显示外边框
|
|
33
|
+
border: {
|
|
34
|
+
type: Boolean,
|
|
35
|
+
// true
|
|
36
|
+
default: collapse.border
|
|
37
|
+
},
|
|
38
|
+
// 自定义折叠面板的样式类名
|
|
39
|
+
customClass: {
|
|
40
|
+
type: String,
|
|
41
|
+
default: collapse.customClass
|
|
42
|
+
},
|
|
43
|
+
// 自定义折叠面板的样式
|
|
44
|
+
customStyle: {
|
|
45
|
+
type: Object,
|
|
46
|
+
default: () => {
|
|
47
|
+
return collapse.customStyle
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
},
|
|
51
|
+
computed: {
|
|
52
|
+
needInit() {
|
|
53
|
+
// 通过computed,同时监听accordion和value值的变化
|
|
54
|
+
// 再通过watch去执行init()方法,进行再一次的初始化
|
|
55
|
+
return [this.accordion, this.value]
|
|
56
|
+
}
|
|
57
|
+
},
|
|
58
|
+
watch: {
|
|
59
|
+
needInit() {
|
|
60
|
+
this.init()
|
|
61
|
+
},
|
|
62
|
+
// 当父组件需要子组件需要共享的参数发生了变化,手动通知子组件
|
|
63
|
+
parentData() {
|
|
64
|
+
if (this.children.length) {
|
|
65
|
+
this.children.map(child => {
|
|
66
|
+
// 判断子组件(pi-collapse-item)如果有updateParentData方法的话,就就执行(执行的结果是子组件重新从父组件拉取了最新的值)
|
|
67
|
+
typeof child.updateParentData === 'function' && child.updateParentData()
|
|
68
|
+
})
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
},
|
|
72
|
+
created() {
|
|
73
|
+
this.children = []
|
|
74
|
+
},
|
|
75
|
+
methods: {
|
|
76
|
+
// 重新初始化一次内部的所有子元素
|
|
77
|
+
init() {
|
|
78
|
+
this.children.map(child => {
|
|
79
|
+
child.init()
|
|
80
|
+
})
|
|
81
|
+
},
|
|
82
|
+
/**
|
|
83
|
+
* collapse-item被点击时触发,由collapse统一处理各子组件的状态
|
|
84
|
+
* @param {Object} target 被操作的面板的实例
|
|
85
|
+
*/
|
|
86
|
+
onChange(target) {
|
|
87
|
+
let changeArr = []
|
|
88
|
+
this.children.map((child, index) => {
|
|
89
|
+
// 如果是手风琴模式,将其他的折叠面板收起来
|
|
90
|
+
if (this.accordion) {
|
|
91
|
+
child.expanded = child === target ? !target.expanded : false
|
|
92
|
+
child.setContentAnimate()
|
|
93
|
+
} else {
|
|
94
|
+
if (child === target) {
|
|
95
|
+
child.expanded = !child.expanded
|
|
96
|
+
child.setContentAnimate()
|
|
97
|
+
}
|
|
98
|
+
}
|
|
99
|
+
// 拼接change事件中,数组元素的状态
|
|
100
|
+
changeArr.push({
|
|
101
|
+
// 如果没有定义name属性,则默认返回组件的index索引
|
|
102
|
+
name: child.name || index,
|
|
103
|
+
status: child.expanded ? 'open' : 'close'
|
|
104
|
+
})
|
|
105
|
+
})
|
|
106
|
+
// 触发change事件
|
|
107
|
+
this.$emit('change', changeArr)
|
|
108
|
+
this.$emit(target.expanded ? 'open' : 'close', target.name)
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
</script>
|
|
113
|
+
|
|
114
|
+
<style lang="scss" scoped></style>
|
|
@@ -0,0 +1,347 @@
|
|
|
1
|
+
<template>
|
|
2
|
+
<view
|
|
3
|
+
class="pi-collapse-item"
|
|
4
|
+
:class="[customClass]"
|
|
5
|
+
:style="[customStyle]"
|
|
6
|
+
@click="clickHandler"
|
|
7
|
+
>
|
|
8
|
+
<!-- 标题 -->
|
|
9
|
+
<view
|
|
10
|
+
class="pi-collapse-item__title pi-justify-between pi-align-center"
|
|
11
|
+
:class="{ disabled: disabled, border: border }"
|
|
12
|
+
>
|
|
13
|
+
<!-- 左侧 -->
|
|
14
|
+
<view class="pi-flex-column pi-lh-44">
|
|
15
|
+
<!-- 一级标题 -->
|
|
16
|
+
<slot name="title">
|
|
17
|
+
<text v-if="title" class="text">{{ title }}</text>
|
|
18
|
+
</slot>
|
|
19
|
+
<!-- 二级标题 -->
|
|
20
|
+
<text v-if="checkDesc" class="desc">{{ desc }}</text>
|
|
21
|
+
</view>
|
|
22
|
+
<!-- 右侧 -->
|
|
23
|
+
<view class="pi-align-center pi-lh-44">
|
|
24
|
+
<!-- 自定义内容 -->
|
|
25
|
+
<slot name="value">
|
|
26
|
+
<text v-if="checkValue" class="value">{{ value }}</text>
|
|
27
|
+
</slot>
|
|
28
|
+
<!-- 图标 -->
|
|
29
|
+
<view class="icon pi-mg-left-8" :class="getIconClass">
|
|
30
|
+
<pi-icon name="right" />
|
|
31
|
+
</view>
|
|
32
|
+
</view>
|
|
33
|
+
</view>
|
|
34
|
+
<!-- 内容 -->
|
|
35
|
+
<view ref="animation" class="pi-collapse-item__content" :animation="animationData">
|
|
36
|
+
<view :id="elId" :ref="elId" class="pi-collapse-item__content__text content-class">
|
|
37
|
+
<slot />
|
|
38
|
+
</view>
|
|
39
|
+
</view>
|
|
40
|
+
<pi-divider v-if="expanded && border" />
|
|
41
|
+
</view>
|
|
42
|
+
</template>
|
|
43
|
+
|
|
44
|
+
<script>
|
|
45
|
+
// #ifdef APP-NVUE
|
|
46
|
+
const animation = uni.requireNativePlugin('animation')
|
|
47
|
+
const dom = uni.requireNativePlugin('dom')
|
|
48
|
+
// #endif
|
|
49
|
+
import { getConfig } from '../../config'
|
|
50
|
+
const { collapseItem } = getConfig()
|
|
51
|
+
|
|
52
|
+
/**
|
|
53
|
+
* collapseItem 折叠面板Item
|
|
54
|
+
* @description 通过折叠面板收纳内容区域(搭配pi-collapse使用)
|
|
55
|
+
* @tutorial http://piui.sadais.com/docs/components/collapse.html
|
|
56
|
+
* @event {Function} change 某个item被打开或者收起时触发
|
|
57
|
+
* @example <pi-collapse-item :title="item.head" v-for="(item, index) in itemList" :key="index">{{item.body}}</pi-collapse-item>
|
|
58
|
+
*/
|
|
59
|
+
export default {
|
|
60
|
+
name: 'PiCollapseItem',
|
|
61
|
+
props: {
|
|
62
|
+
// 标题
|
|
63
|
+
title: {
|
|
64
|
+
type: String,
|
|
65
|
+
default: collapseItem.title
|
|
66
|
+
},
|
|
67
|
+
// 自定义内容
|
|
68
|
+
value: {
|
|
69
|
+
type: String,
|
|
70
|
+
default: collapseItem.value
|
|
71
|
+
},
|
|
72
|
+
// 唯一标识
|
|
73
|
+
name: {
|
|
74
|
+
type: [Number, String],
|
|
75
|
+
default: collapseItem.name
|
|
76
|
+
},
|
|
77
|
+
// 描述
|
|
78
|
+
desc: {
|
|
79
|
+
type: String,
|
|
80
|
+
default: collapseItem.desc
|
|
81
|
+
},
|
|
82
|
+
// 是否禁用折叠面板
|
|
83
|
+
disabled: {
|
|
84
|
+
type: Boolean,
|
|
85
|
+
default: collapseItem.disabled
|
|
86
|
+
},
|
|
87
|
+
// 是否显示内边框
|
|
88
|
+
border: {
|
|
89
|
+
type: Boolean,
|
|
90
|
+
default: collapseItem.border
|
|
91
|
+
},
|
|
92
|
+
// 面板展开收起的过渡时间,单位ms
|
|
93
|
+
duration: {
|
|
94
|
+
type: Number,
|
|
95
|
+
default: collapseItem.duration
|
|
96
|
+
},
|
|
97
|
+
// 自定义折叠面板列表的样式类名
|
|
98
|
+
customClass: {
|
|
99
|
+
type: String,
|
|
100
|
+
default: collapseItem.customClass
|
|
101
|
+
},
|
|
102
|
+
// 自定义折叠面板列表的样式
|
|
103
|
+
customStyle: {
|
|
104
|
+
type: Object,
|
|
105
|
+
default: () => {
|
|
106
|
+
return collapseItem.customStyle
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
},
|
|
110
|
+
data() {
|
|
111
|
+
return {
|
|
112
|
+
elId: this.$pi.guid(), // 全局唯一标识符
|
|
113
|
+
// uni.createAnimation的导出数据
|
|
114
|
+
animationData: {},
|
|
115
|
+
// 是否展开状态
|
|
116
|
+
expanded: false,
|
|
117
|
+
// 根据expanded确定是否显示border,为了控制展开时,cell的下划线更好的显示效果,进行一定时间的延时
|
|
118
|
+
showBorder: false,
|
|
119
|
+
// 是否动画中,如果是则不允许继续触发点击
|
|
120
|
+
animating: false,
|
|
121
|
+
// 父组件pi-collapse的参数
|
|
122
|
+
parentData: {
|
|
123
|
+
accordion: false,
|
|
124
|
+
border: false
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
},
|
|
128
|
+
computed: {
|
|
129
|
+
// 动态改变折叠面板的展开收起状态
|
|
130
|
+
getIconClass() {
|
|
131
|
+
return this.expanded ? 'up' : 'down'
|
|
132
|
+
},
|
|
133
|
+
// 检查自定义内容是否为空
|
|
134
|
+
checkValue() {
|
|
135
|
+
return !this.$pi.lang.isEmpty(this.value)
|
|
136
|
+
},
|
|
137
|
+
// 检查自定义描述是否为空
|
|
138
|
+
checkDesc() {
|
|
139
|
+
return !this.$pi.lang.isEmpty(this.desc)
|
|
140
|
+
}
|
|
141
|
+
},
|
|
142
|
+
watch: {
|
|
143
|
+
expanded(n) {
|
|
144
|
+
clearTimeout(this.timer)
|
|
145
|
+
this.timer = null
|
|
146
|
+
// 这里根据expanded的值来进行一定的延时,是为了cell的下划线更好的显示效果
|
|
147
|
+
this.timer = setTimeout(
|
|
148
|
+
() => {
|
|
149
|
+
this.showBorder = n
|
|
150
|
+
},
|
|
151
|
+
n ? 10 : 290
|
|
152
|
+
)
|
|
153
|
+
}
|
|
154
|
+
},
|
|
155
|
+
mounted() {
|
|
156
|
+
this.init()
|
|
157
|
+
},
|
|
158
|
+
methods: {
|
|
159
|
+
// 异步获取内容,或者动态修改了内容时,需要重新初始化
|
|
160
|
+
init() {
|
|
161
|
+
// 初始化数据
|
|
162
|
+
this.updateParentData()
|
|
163
|
+
if (!this.parent) {
|
|
164
|
+
return console.error('pi-collapse-item必须要搭配pi-collapse组件使用')
|
|
165
|
+
}
|
|
166
|
+
const { value, accordion } = this.parent
|
|
167
|
+
if (accordion) {
|
|
168
|
+
if (this.$pi.lang.isArray(value)) {
|
|
169
|
+
return console.error('手风琴模式下,pi-collapse组件的value参数不能为数组')
|
|
170
|
+
}
|
|
171
|
+
this.expanded = this.name == value
|
|
172
|
+
} else {
|
|
173
|
+
if (!this.$pi.lang.isArray(value) && value !== null) {
|
|
174
|
+
return console.error('非手风琴模式下,pi-collapse组件的value参数必须为数组')
|
|
175
|
+
}
|
|
176
|
+
this.expanded = (value || []).some(item => item == this.name)
|
|
177
|
+
}
|
|
178
|
+
// 设置组件的展开或收起状态
|
|
179
|
+
this.$nextTick(function () {
|
|
180
|
+
this.setContentAnimate()
|
|
181
|
+
})
|
|
182
|
+
},
|
|
183
|
+
updateParentData() {
|
|
184
|
+
// 传组件Name给父组件,用于组件展开或收起时,改变父组件的值
|
|
185
|
+
this.getParentData('PiCollapse')
|
|
186
|
+
},
|
|
187
|
+
async setContentAnimate() {
|
|
188
|
+
// 每次面板打开或者收起时,都查询元素尺寸
|
|
189
|
+
// 好处是,父组件从服务端获取内容后,变更折叠面板后可以获得最新的高度
|
|
190
|
+
const rect = await this.queryRect()
|
|
191
|
+
const height = this.expanded ? rect.height : 0
|
|
192
|
+
this.animating = true
|
|
193
|
+
// #ifdef APP-NVUE
|
|
194
|
+
const ref = this.$refs['animation'].ref
|
|
195
|
+
animation.transition(
|
|
196
|
+
ref,
|
|
197
|
+
{
|
|
198
|
+
styles: {
|
|
199
|
+
height: height + 'px'
|
|
200
|
+
},
|
|
201
|
+
duration: this.duration,
|
|
202
|
+
// 必须设置为true,否则会到面板收起或展开时,页面其他元素不会随之调整它们的布局
|
|
203
|
+
needLayout: true,
|
|
204
|
+
timingFunction: 'ease-in-out'
|
|
205
|
+
},
|
|
206
|
+
() => {
|
|
207
|
+
this.animating = false
|
|
208
|
+
}
|
|
209
|
+
)
|
|
210
|
+
// #endif
|
|
211
|
+
|
|
212
|
+
// #ifndef APP-NVUE
|
|
213
|
+
const animation = uni.createAnimation({
|
|
214
|
+
timingFunction: 'ease-in-out'
|
|
215
|
+
})
|
|
216
|
+
animation
|
|
217
|
+
.height(height)
|
|
218
|
+
.step({
|
|
219
|
+
duration: this.duration
|
|
220
|
+
})
|
|
221
|
+
.step()
|
|
222
|
+
// 导出动画数据给面板的animationData值
|
|
223
|
+
this.animationData = animation.export()
|
|
224
|
+
// 标识动画结束
|
|
225
|
+
this.sleep(this.duration).then(() => {
|
|
226
|
+
this.animating = false
|
|
227
|
+
})
|
|
228
|
+
// #endif
|
|
229
|
+
},
|
|
230
|
+
// 点击collapsehead头部
|
|
231
|
+
clickHandler() {
|
|
232
|
+
if (this.disabled || this.animating) return
|
|
233
|
+
// 设置本组件为相反的状态
|
|
234
|
+
this.parent && this.parent.onChange(this)
|
|
235
|
+
},
|
|
236
|
+
/**
|
|
237
|
+
* @description 进行延时,以达到可以简写代码的目的
|
|
238
|
+
* @param {number} value 堵塞时间 单位ms 毫秒
|
|
239
|
+
* @returns {Promise} 返回promise
|
|
240
|
+
*/
|
|
241
|
+
sleep(value) {
|
|
242
|
+
return new Promise(resolve => {
|
|
243
|
+
setTimeout(() => {
|
|
244
|
+
resolve()
|
|
245
|
+
}, value)
|
|
246
|
+
})
|
|
247
|
+
},
|
|
248
|
+
// 查询内容高度
|
|
249
|
+
queryRect() {
|
|
250
|
+
return new Promise(resolve => {
|
|
251
|
+
// #ifndef APP-NVUE
|
|
252
|
+
this.$pi.common.queryRect(this, `#${this.elId}`).then(size => {
|
|
253
|
+
resolve(size)
|
|
254
|
+
})
|
|
255
|
+
// #endif
|
|
256
|
+
|
|
257
|
+
// #ifdef APP-NVUE
|
|
258
|
+
// nvue下,使用dom模块查询元素高度
|
|
259
|
+
// 返回一个promise,让调用此方法的主体能使用then回调
|
|
260
|
+
dom.getComponentRect(this.$refs[this.elId], res => {
|
|
261
|
+
resolve(res.size)
|
|
262
|
+
})
|
|
263
|
+
// #endif
|
|
264
|
+
})
|
|
265
|
+
},
|
|
266
|
+
getParentData(parentName = '') {
|
|
267
|
+
// 避免在created中去定义parent变量
|
|
268
|
+
if (!this.parent) this.parent = {}
|
|
269
|
+
this.parent = this.$pi.parent(this, parentName)
|
|
270
|
+
if (this.parent.children) {
|
|
271
|
+
// 如果父组件的children不存在本组件的实例,才将本实例添加到父组件的children中
|
|
272
|
+
this.parent.children.indexOf(this) === -1 && this.parent.children.push(this)
|
|
273
|
+
}
|
|
274
|
+
if (this.parent && this.parentData) {
|
|
275
|
+
// 历遍parentData中的属性,将parent中的同名属性赋值给parentData
|
|
276
|
+
Object.keys(this.parentData).map(key => {
|
|
277
|
+
this.parentData[key] = this.parent[key]
|
|
278
|
+
})
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
}
|
|
283
|
+
</script>
|
|
284
|
+
|
|
285
|
+
<style lang="scss" scoped>
|
|
286
|
+
.pi-collapse-item {
|
|
287
|
+
&__title {
|
|
288
|
+
padding: 15px;
|
|
289
|
+
// 边框
|
|
290
|
+
&.border {
|
|
291
|
+
position: relative;
|
|
292
|
+
&:after {
|
|
293
|
+
content: ' ';
|
|
294
|
+
position: absolute;
|
|
295
|
+
left: 0;
|
|
296
|
+
bottom: 0;
|
|
297
|
+
right: 0;
|
|
298
|
+
height: 1px;
|
|
299
|
+
border-bottom: 1px solid rgb(214, 228, 239);
|
|
300
|
+
color: rgb(214, 228, 239);
|
|
301
|
+
-webkit-transform-origin: 0 0;
|
|
302
|
+
transform-origin: 0 0;
|
|
303
|
+
-webkit-transform: scaleY(0.5);
|
|
304
|
+
transform: scaleY(0.5);
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
&:active {
|
|
308
|
+
background-color: #f3f4f6;
|
|
309
|
+
}
|
|
310
|
+
.text {
|
|
311
|
+
color: #303133;
|
|
312
|
+
}
|
|
313
|
+
.desc {
|
|
314
|
+
font-size: 24rpx;
|
|
315
|
+
color: #8c8c8c;
|
|
316
|
+
}
|
|
317
|
+
.icon {
|
|
318
|
+
color: #909399;
|
|
319
|
+
transition: transform 0.3s;
|
|
320
|
+
&.up {
|
|
321
|
+
transform: rotate(-90deg);
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
&.down {
|
|
325
|
+
transform: rotate(90deg);
|
|
326
|
+
}
|
|
327
|
+
}
|
|
328
|
+
&.disabled {
|
|
329
|
+
cursor: not-allowed;
|
|
330
|
+
.text,
|
|
331
|
+
.icon {
|
|
332
|
+
color: #cccccc;
|
|
333
|
+
}
|
|
334
|
+
}
|
|
335
|
+
}
|
|
336
|
+
&__content {
|
|
337
|
+
overflow: hidden;
|
|
338
|
+
height: 0;
|
|
339
|
+
|
|
340
|
+
&__text {
|
|
341
|
+
padding: 24rpx 30rpx;
|
|
342
|
+
color: #606266;
|
|
343
|
+
line-height: 36rpx;
|
|
344
|
+
}
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
</style>
|
|
@@ -0,0 +1,488 @@
|
|
|
1
|
+
<template>
|
|
2
|
+
<view
|
|
3
|
+
v-show="show"
|
|
4
|
+
class="pi-tag-wrapper pi-rela pi-inline-block"
|
|
5
|
+
:class="[tagWrapperClass]"
|
|
6
|
+
:style="[tagWrapperStyle]"
|
|
7
|
+
>
|
|
8
|
+
<view
|
|
9
|
+
class="pi-tag pi-align-center pi-justify-center"
|
|
10
|
+
:class="[customClass, tagClass]"
|
|
11
|
+
:style="[customStyle, tagStyle]"
|
|
12
|
+
@tap="handleClickTag"
|
|
13
|
+
>
|
|
14
|
+
<slot name="icon">
|
|
15
|
+
<view v-if="icon" class="pi-tag__icon pi-align-center">
|
|
16
|
+
<image v-if="isImg(icon)" :src="icon" :style="[imgStyle]" />
|
|
17
|
+
<pi-icon v-else :custom-class="piIconClass" :name="icon" :size="iconSize" />
|
|
18
|
+
</view>
|
|
19
|
+
</slot>
|
|
20
|
+
<text class="pi-tag__text" :style="[textColor]" :class="[textClass]">
|
|
21
|
+
{{ text }}
|
|
22
|
+
</text>
|
|
23
|
+
</view>
|
|
24
|
+
<view
|
|
25
|
+
v-if="closable"
|
|
26
|
+
class="pi-tag__close"
|
|
27
|
+
:class="[`pi-tag__close--${size}`]"
|
|
28
|
+
:style="{ backgroundColor: closeColor }"
|
|
29
|
+
@tap="handleCloseTag"
|
|
30
|
+
>
|
|
31
|
+
<pi-icon name="close" :size="closeSize" color="#ffffff" />
|
|
32
|
+
</view>
|
|
33
|
+
</view>
|
|
34
|
+
</template>
|
|
35
|
+
|
|
36
|
+
<script>
|
|
37
|
+
import { getConfig } from '../../config'
|
|
38
|
+
const { tag } = getConfig()
|
|
39
|
+
/**
|
|
40
|
+
* Tag 标签
|
|
41
|
+
* @description tag组件一般用于标记和选择,我们提供了更加丰富的表现形式,能够较全面的涵盖您的使用场景
|
|
42
|
+
* @tutorial http://piui.sadais.com/docs/components/tag.html
|
|
43
|
+
* @event {Function(index)} click 点击标签时触发 index: 传递的index参数值
|
|
44
|
+
* @event {Function(index)} close closable为true时,点击标签关闭按钮触发 index: 传递的index参数值
|
|
45
|
+
* @example <pi-tag text="标签" type="error" plain plainFill />
|
|
46
|
+
*/
|
|
47
|
+
export default {
|
|
48
|
+
name: 'PiTag',
|
|
49
|
+
props: {
|
|
50
|
+
// 自定义样式,对象形式
|
|
51
|
+
tagWrapperStyle: {
|
|
52
|
+
type: Object,
|
|
53
|
+
// `{}`
|
|
54
|
+
default() {
|
|
55
|
+
return tag.tagWrapperStyle
|
|
56
|
+
}
|
|
57
|
+
},
|
|
58
|
+
// 自定义样式类,字符串形式
|
|
59
|
+
tagWrapperClass: {
|
|
60
|
+
type: String,
|
|
61
|
+
// ''
|
|
62
|
+
default() {
|
|
63
|
+
return tag.tagWrapperClass
|
|
64
|
+
}
|
|
65
|
+
},
|
|
66
|
+
// 自定义样式,对象形式
|
|
67
|
+
customStyle: {
|
|
68
|
+
type: Object,
|
|
69
|
+
// `{}`
|
|
70
|
+
default() {
|
|
71
|
+
return tag.customStyle
|
|
72
|
+
}
|
|
73
|
+
},
|
|
74
|
+
// 自定义样式类,字符串形式
|
|
75
|
+
customClass: {
|
|
76
|
+
type: String,
|
|
77
|
+
// ''
|
|
78
|
+
default() {
|
|
79
|
+
return tag.customClass
|
|
80
|
+
}
|
|
81
|
+
},
|
|
82
|
+
// 标签尺寸
|
|
83
|
+
size: {
|
|
84
|
+
// `'large'` `'medium'` `'mini'`
|
|
85
|
+
type: String,
|
|
86
|
+
// 'medium'
|
|
87
|
+
default: tag.size,
|
|
88
|
+
validator: function (value) {
|
|
89
|
+
return ['large', 'medium', 'mini'].includes(value)
|
|
90
|
+
}
|
|
91
|
+
},
|
|
92
|
+
// 标签的预置样式
|
|
93
|
+
type: {
|
|
94
|
+
// `'primary'` `'success'` `'info'` `'warning'` `'error'`
|
|
95
|
+
type: String,
|
|
96
|
+
// 'default'
|
|
97
|
+
default: tag.type,
|
|
98
|
+
validator: function (value) {
|
|
99
|
+
return ['primary', 'success', 'info', 'warning', 'error'].includes(value)
|
|
100
|
+
}
|
|
101
|
+
},
|
|
102
|
+
// 是否禁用
|
|
103
|
+
disabled: {
|
|
104
|
+
type: [Boolean, String],
|
|
105
|
+
// false
|
|
106
|
+
default() {
|
|
107
|
+
return tag.disabled
|
|
108
|
+
}
|
|
109
|
+
},
|
|
110
|
+
// tag的形状
|
|
111
|
+
shape: {
|
|
112
|
+
type: String,
|
|
113
|
+
// 'square'
|
|
114
|
+
default() {
|
|
115
|
+
return tag.shape
|
|
116
|
+
}
|
|
117
|
+
},
|
|
118
|
+
// 标签的文字内容
|
|
119
|
+
text: {
|
|
120
|
+
type: [String, Number],
|
|
121
|
+
// ''
|
|
122
|
+
default() {
|
|
123
|
+
return tag.text
|
|
124
|
+
}
|
|
125
|
+
},
|
|
126
|
+
// 背景颜色
|
|
127
|
+
bgColor: {
|
|
128
|
+
type: String,
|
|
129
|
+
// ''
|
|
130
|
+
default() {
|
|
131
|
+
return tag.bgColor
|
|
132
|
+
}
|
|
133
|
+
},
|
|
134
|
+
// 标签字体颜色
|
|
135
|
+
color: {
|
|
136
|
+
type: String,
|
|
137
|
+
// ''
|
|
138
|
+
default() {
|
|
139
|
+
return tag.color
|
|
140
|
+
}
|
|
141
|
+
},
|
|
142
|
+
// 镂空形式标签的边框颜色
|
|
143
|
+
borderColor: {
|
|
144
|
+
type: String,
|
|
145
|
+
// ''
|
|
146
|
+
default() {
|
|
147
|
+
return tag.borderColor
|
|
148
|
+
}
|
|
149
|
+
},
|
|
150
|
+
// 关闭按钮图标的颜色
|
|
151
|
+
closeColor: {
|
|
152
|
+
type: String,
|
|
153
|
+
// '#C6C7CB'
|
|
154
|
+
default() {
|
|
155
|
+
return tag.closeColor
|
|
156
|
+
}
|
|
157
|
+
},
|
|
158
|
+
// 点击时返回的索引值
|
|
159
|
+
name: {
|
|
160
|
+
type: [String, Number],
|
|
161
|
+
// ''
|
|
162
|
+
default() {
|
|
163
|
+
return tag.name
|
|
164
|
+
}
|
|
165
|
+
},
|
|
166
|
+
// 镂空时是否填充背景色
|
|
167
|
+
plainFill: {
|
|
168
|
+
type: Boolean,
|
|
169
|
+
// false
|
|
170
|
+
default() {
|
|
171
|
+
return tag.plainFill
|
|
172
|
+
}
|
|
173
|
+
},
|
|
174
|
+
// 是否镂空
|
|
175
|
+
plain: {
|
|
176
|
+
type: Boolean,
|
|
177
|
+
// false
|
|
178
|
+
default() {
|
|
179
|
+
return tag.plain
|
|
180
|
+
}
|
|
181
|
+
},
|
|
182
|
+
// 是否可关闭
|
|
183
|
+
closable: {
|
|
184
|
+
type: Boolean,
|
|
185
|
+
// false
|
|
186
|
+
default() {
|
|
187
|
+
return tag.closable
|
|
188
|
+
}
|
|
189
|
+
},
|
|
190
|
+
// 是否显示 默认true
|
|
191
|
+
show: {
|
|
192
|
+
type: Boolean,
|
|
193
|
+
// true
|
|
194
|
+
default() {
|
|
195
|
+
return tag.show
|
|
196
|
+
}
|
|
197
|
+
},
|
|
198
|
+
// 内置图标
|
|
199
|
+
icon: {
|
|
200
|
+
type: String,
|
|
201
|
+
// ''
|
|
202
|
+
default() {
|
|
203
|
+
return tag.icon
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
},
|
|
207
|
+
computed: {
|
|
208
|
+
// 标签动态class
|
|
209
|
+
tagClass() {
|
|
210
|
+
let className = `pi-tag--${this.shape}`
|
|
211
|
+
if (this.plain) {
|
|
212
|
+
className += ` pi-tag--${this.type}--plain`
|
|
213
|
+
} else {
|
|
214
|
+
className += ` pi-tag--${this.type}`
|
|
215
|
+
}
|
|
216
|
+
className += ` pi-tag--${this.size}`
|
|
217
|
+
if (this.plain && this.plainFill) {
|
|
218
|
+
className += ` pi-tag--${this.type}--plain--fill`
|
|
219
|
+
}
|
|
220
|
+
return className
|
|
221
|
+
},
|
|
222
|
+
// 标签动态style
|
|
223
|
+
tagStyle() {
|
|
224
|
+
const style = {}
|
|
225
|
+
if (this.bgColor) {
|
|
226
|
+
style.backgroundColor = this.bgColor
|
|
227
|
+
}
|
|
228
|
+
if (this.color) {
|
|
229
|
+
style.color = this.color
|
|
230
|
+
}
|
|
231
|
+
if (this.borderColor) {
|
|
232
|
+
style.borderColor = this.borderColor
|
|
233
|
+
}
|
|
234
|
+
return style
|
|
235
|
+
},
|
|
236
|
+
// 标签文本样式
|
|
237
|
+
textClass() {
|
|
238
|
+
let className = `pi-tag__text--${this.type}`
|
|
239
|
+
if (this.plain) {
|
|
240
|
+
className += ` pi-tag__text--${this.type}--plain`
|
|
241
|
+
}
|
|
242
|
+
className += ` pi-tag__text--${this.size}`
|
|
243
|
+
return className
|
|
244
|
+
},
|
|
245
|
+
// nvue下,文本颜色无法继承父元素
|
|
246
|
+
textColor() {
|
|
247
|
+
const style = {}
|
|
248
|
+
if (this.color) {
|
|
249
|
+
style.color = this.color
|
|
250
|
+
}
|
|
251
|
+
return style
|
|
252
|
+
},
|
|
253
|
+
// 标签图标style
|
|
254
|
+
imgStyle() {
|
|
255
|
+
const width = this.size === 'large' ? '34rpx' : this.size === 'medium' ? '30rpx' : '26rpx'
|
|
256
|
+
return {
|
|
257
|
+
width,
|
|
258
|
+
height: width
|
|
259
|
+
}
|
|
260
|
+
},
|
|
261
|
+
// 关闭图标的样式 单位rpx
|
|
262
|
+
closeSize() {
|
|
263
|
+
const size = this.size === 'large' ? 30 : this.size === 'medium' ? 26 : 24
|
|
264
|
+
return size
|
|
265
|
+
},
|
|
266
|
+
// 图标大小 单位rpx
|
|
267
|
+
iconSize() {
|
|
268
|
+
const size = this.size === 'large' ? 42 : this.size === 'medium' ? 38 : 32
|
|
269
|
+
return size
|
|
270
|
+
},
|
|
271
|
+
// 图标类名
|
|
272
|
+
piIconClass() {
|
|
273
|
+
return this.plain ? `pi-${this.type}` : 'pi-white'
|
|
274
|
+
},
|
|
275
|
+
// 判断是否是图片
|
|
276
|
+
isImg() {
|
|
277
|
+
return value => {
|
|
278
|
+
const newValue = value.split('?')[0]
|
|
279
|
+
const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i
|
|
280
|
+
return IMAGE_REGEXP.test(newValue)
|
|
281
|
+
}
|
|
282
|
+
}
|
|
283
|
+
},
|
|
284
|
+
methods: {
|
|
285
|
+
// 关闭标签
|
|
286
|
+
handleCloseTag() {
|
|
287
|
+
this.$emit('close', this.name, this.text)
|
|
288
|
+
},
|
|
289
|
+
// 点击标签
|
|
290
|
+
handleClickTag() {
|
|
291
|
+
this.$emit('click', this.name, this.text)
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
</script>
|
|
296
|
+
|
|
297
|
+
<style lang="scss" scoped>
|
|
298
|
+
$pi-error-color: #fa3534;
|
|
299
|
+
$pi-warning-color: #ff9900;
|
|
300
|
+
$pi-info-color: #909399;
|
|
301
|
+
|
|
302
|
+
.pi-tag {
|
|
303
|
+
border-style: solid;
|
|
304
|
+
&--circle {
|
|
305
|
+
border-radius: 200rpx;
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
&--square {
|
|
309
|
+
border-radius: 6rpx;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
&__icon {
|
|
313
|
+
margin-right: 8rpx;
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
&__text {
|
|
317
|
+
&--mini {
|
|
318
|
+
font-size: 24rpx;
|
|
319
|
+
line-height: 24rpx;
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
&--medium {
|
|
323
|
+
font-size: 26rpx;
|
|
324
|
+
line-height: 26rpx;
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
&--large {
|
|
328
|
+
font-size: 30rpx;
|
|
329
|
+
line-height: 30rpx;
|
|
330
|
+
}
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
&--mini {
|
|
334
|
+
height: 44rpx;
|
|
335
|
+
line-height: 44rpx;
|
|
336
|
+
padding: 0 10rpx;
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
&--medium {
|
|
340
|
+
height: 52rpx;
|
|
341
|
+
line-height: 44rpx;
|
|
342
|
+
padding: 0 20rpx;
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
&--large {
|
|
346
|
+
height: 64rpx;
|
|
347
|
+
line-height: 64rpx;
|
|
348
|
+
padding: 0 30rpx;
|
|
349
|
+
}
|
|
350
|
+
&__text--primary,
|
|
351
|
+
&__text--error,
|
|
352
|
+
&__text--warning,
|
|
353
|
+
&__text--success,
|
|
354
|
+
&__text--info {
|
|
355
|
+
color: #ffffff;
|
|
356
|
+
}
|
|
357
|
+
&--primary,
|
|
358
|
+
&--error,
|
|
359
|
+
&--warning,
|
|
360
|
+
&--success,
|
|
361
|
+
&--info,
|
|
362
|
+
&--primary--plain,
|
|
363
|
+
&--error--plain,
|
|
364
|
+
&--warning--plain,
|
|
365
|
+
&--success--plain,
|
|
366
|
+
&--info--plain {
|
|
367
|
+
border-width: 2rpx;
|
|
368
|
+
}
|
|
369
|
+
|
|
370
|
+
&--primary {
|
|
371
|
+
background-color: $pi-primary-color;
|
|
372
|
+
border-color: $pi-primary-color;
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
&--primary--plain {
|
|
376
|
+
border-color: $pi-primary-color;
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
&--primary--plain--fill {
|
|
380
|
+
background-color: #ecf5ff;
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
&__text--primary--plain {
|
|
384
|
+
color: $pi-primary-color;
|
|
385
|
+
}
|
|
386
|
+
|
|
387
|
+
&--error {
|
|
388
|
+
background-color: $pi-error-color;
|
|
389
|
+
border-color: $pi-error-color;
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
&--error--plain {
|
|
393
|
+
border-color: $pi-error-color;
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
&--error--plain--fill {
|
|
397
|
+
background-color: #fef0f0;
|
|
398
|
+
}
|
|
399
|
+
|
|
400
|
+
&__text--error--plain {
|
|
401
|
+
color: $pi-error-color;
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
&--warning {
|
|
405
|
+
background-color: $pi-warning-color;
|
|
406
|
+
border-color: $pi-warning-color;
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
&--warning--plain {
|
|
410
|
+
border-color: $pi-warning-color;
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
&--warning--plain--fill {
|
|
414
|
+
background-color: #fdf6ec;
|
|
415
|
+
}
|
|
416
|
+
|
|
417
|
+
&__text--warning--plain {
|
|
418
|
+
color: $pi-warning-color;
|
|
419
|
+
}
|
|
420
|
+
|
|
421
|
+
&--success {
|
|
422
|
+
background-color: $pi-fourth-color;
|
|
423
|
+
border-color: $pi-fourth-color;
|
|
424
|
+
}
|
|
425
|
+
|
|
426
|
+
&--success--plain {
|
|
427
|
+
border-color: $pi-fourth-color;
|
|
428
|
+
}
|
|
429
|
+
|
|
430
|
+
&--success--plain--fill {
|
|
431
|
+
background-color: #f5fff0;
|
|
432
|
+
}
|
|
433
|
+
|
|
434
|
+
&__text--success--plain {
|
|
435
|
+
color: $pi-fourth-color;
|
|
436
|
+
}
|
|
437
|
+
|
|
438
|
+
&--info {
|
|
439
|
+
background-color: $pi-info-color;
|
|
440
|
+
border-color: $pi-info-color;
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
&--info--plain {
|
|
444
|
+
border-color: $pi-info-color;
|
|
445
|
+
}
|
|
446
|
+
|
|
447
|
+
&--info--plain--fill {
|
|
448
|
+
background-color: #f4f4f5;
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
&__text--info--plain {
|
|
452
|
+
color: $pi-info-color;
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
&__close {
|
|
456
|
+
position: absolute;
|
|
457
|
+
z-index: 999;
|
|
458
|
+
top: 0;
|
|
459
|
+
right: 0;
|
|
460
|
+
border-radius: 200rpx;
|
|
461
|
+
background-color: #c6c7cb;
|
|
462
|
+
display: flex;
|
|
463
|
+
align-items: center;
|
|
464
|
+
justify-content: center;
|
|
465
|
+
/* #ifndef APP-NVUE */
|
|
466
|
+
transform: scale(0.6) translate(80%, -80%);
|
|
467
|
+
/* #endif */
|
|
468
|
+
/* #ifdef APP-NVUE */
|
|
469
|
+
transform: scale(0.6) translate(50%, -50%);
|
|
470
|
+
/* #endif */
|
|
471
|
+
|
|
472
|
+
&--mini {
|
|
473
|
+
width: 36rpx;
|
|
474
|
+
height: 36rpx;
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
&--medium {
|
|
478
|
+
width: 44rpx;
|
|
479
|
+
height: 44rpx;
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
&--large {
|
|
483
|
+
width: 50rpx;
|
|
484
|
+
height: 50rpx;
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
}
|
|
488
|
+
</style>
|
package/config/circleProgress.js
CHANGED
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
export default {
|
|
2
|
+
title: '', // 标题
|
|
3
|
+
value: '', // 自定义内容
|
|
4
|
+
name: '', // 唯一标识
|
|
5
|
+
desc: '', // 描述
|
|
6
|
+
disabled: false, // 是否禁用折叠面板
|
|
7
|
+
border: true, // 是否显示边框,默认true
|
|
8
|
+
duration: 300, // 面板展开收起的过渡时间,单位ms
|
|
9
|
+
customClass: '', // 自定义样式类,字符串形式('')
|
|
10
|
+
customStyle: {} // 自定义样式,对象形式(默认值:{})
|
|
11
|
+
}
|
package/config/tag.js
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
export default {
|
|
2
|
+
type: 'primary', // 标签类型info、primary、success、warning、error (默认 'primary' )
|
|
3
|
+
disabled: false, // {Boolean | String} 不可用(默认 false )
|
|
4
|
+
size: 'medium', // 标签的大小,large,medium,mini (默认 'medium' )
|
|
5
|
+
shape: 'square', // tag的形状,circle(两边半圆形), square(方形,带圆角)(默认 'square' )
|
|
6
|
+
text: '', // {String | Number} 标签的文字内容
|
|
7
|
+
bgColor: '', // 背景颜色,默认为空字符串,即不处理
|
|
8
|
+
color: '', // 标签字体颜色,默认为空字符串,即不处理
|
|
9
|
+
borderColor: '', // 镂空形式标签的边框颜色
|
|
10
|
+
closeColor: '#C6C7CB', // 关闭按钮图标的颜色(默认 #C6C7CB)
|
|
11
|
+
name: '', // {String | Number} 点击时返回的索引值,用于区分遍历的数组哪个元素被点击了
|
|
12
|
+
plainFill: false, // 镂空时是否填充背景色(默认 false )
|
|
13
|
+
plain: false, // 是否镂空(默认 false )
|
|
14
|
+
closable: false, // 是否可关闭,设置为true,文字右边会出现一个关闭图标(默认 false )
|
|
15
|
+
show: true, // 是否显示,设置为true
|
|
16
|
+
icon: '', // 内置图标,或绝对路径的图片
|
|
17
|
+
customClass: '', // 自定义样式类,字符串形式('')
|
|
18
|
+
customStyle: {}, // 自定义样式,对象形式(默认值:{})
|
|
19
|
+
tagWrapperClass: '', // 标签容器 自定义样式类,字符串形式('')
|
|
20
|
+
tagWrapperStyle: {} // 标签容器 自定义样式,对象形式(默认值:{})
|
|
21
|
+
}
|