eoss-mobiles 0.4.2 → 0.4.3

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.
Files changed (6) hide show
  1. package/lib/eoss-mobile.common.js +966 -883
  2. package/lib/form.js +957 -874
  3. package/lib/index.js +1 -1
  4. package/package.json +1 -1
  5. package/packages/form/src/main.vue +369 -351
  6. package/src/index.js +1 -1
package/lib/eoss-mobile.common.js CHANGED
@@ -27979,8 +27979,8 @@ count_down_src_main.install = function (Vue) {
27979
27979
  };
27980
27980
 
27981
27981
  /* harmony default export */ var count_down = (count_down_src_main);
27982
- // CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/form/src/main.vue?vue&type=template&id=2cd80b57
27983
- var mainvue_type_template_id_2cd80b57_render = function () {
27982
+ // CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/form/src/main.vue?vue&type=template&id=23d3cbdb
27983
+ var mainvue_type_template_id_23d3cbdb_render = function () {
27984
27984
  var _vm = this
27985
27985
  var _h = _vm.$createElement
27986
27986
  var _c = _vm._self._c || _h
@@ -28015,929 +28015,994 @@ var mainvue_type_template_id_2cd80b57_render = function () {
28015
28015
  : "",
28016
28016
  },
28017
28017
  [
28018
- item.type === "tab"
28019
- ? _c(
28020
- "em-tabs",
28021
- _vm._g(
28022
- _vm._b(
28023
- {
28024
- model: {
28025
- value: item.active,
28026
- callback: function ($$v) {
28027
- _vm.$set(item, "active", $$v)
28028
- },
28029
- expression: "item.active",
28030
- },
28031
- },
28032
- "em-tabs",
28033
- Object.assign({}, item, {
28034
- type: item.tabType || "line",
28035
- }),
28036
- false
28037
- ),
28038
- Object.assign({}, item.events)
28039
- ),
28040
- _vm._l(item.contents, function (z, i) {
28041
- return _c(
28042
- "em-tab",
28043
- _vm._b(
28044
- { key: i },
28045
- "em-tab",
28046
- Object.assign({}, z),
28047
- false
28048
- ),
28049
- _vm._l(z.contents, function (x, j) {
28050
- return _c(
28051
- "div",
28052
- { key: j, staticStyle: { height: "100%" } },
28053
- [
28054
- x.type === "text" ||
28055
- x.type === "textarea" ||
28056
- x.type == "number" ||
28057
- x.type == "digit" ||
28058
- x.type == "password" ||
28059
- x.type == "tel"
28060
- ? _c(
28061
- "em-input",
28062
- _vm._g(
28063
- _vm._b(
28064
- {
28065
- ref: "input",
28066
- refInFor: true,
28067
- staticClass: "em-table-input",
28068
- attrs: {
28069
- "label-position":
28070
- x.labelPosition ||
28071
- _vm.labelPosition,
28072
- disabled:
28073
- x.disabled || _vm.disabled,
28074
- readonly:
28075
- x.readonly || _vm.readonly,
28076
- label: x.label.text || x.label,
28077
- },
28078
- on: {
28079
- input: function ($event) {
28080
- _vm.handleChange(
28081
- x.name,
28082
- _vm.model[x.name]
28083
- )
28084
- },
28085
- },
28086
- model: {
28087
- value: _vm.model[x.name],
28088
- callback: function ($$v) {
28089
- _vm.$set(_vm.model, x.name, $$v)
28090
- },
28091
- expression: "model[x.name]",
28092
- },
28093
- },
28094
- "em-input",
28095
- Object.assign({}, _vm.$attrs, x),
28096
- false
28097
- ),
28098
- Object.assign({}, x.events)
28099
- )
28100
- )
28101
- : _vm._e(),
28102
- x.type === "select"
28103
- ? _c(
28104
- "em-picker",
28105
- _vm._g(
28106
- _vm._b(
28107
- {
28108
- ref: "select",
28109
- refInFor: true,
28110
- attrs: {
28111
- "label-position":
28112
- x.labelPosition ||
28113
- _vm.labelPosition,
28114
- disabled:
28115
- x.disabled || _vm.disabled,
28116
- readonly:
28117
- x.readonly || _vm.readonly,
28118
- columns: x.data || [],
28119
- },
28120
- on: {
28121
- confirm: function (value) {
28122
- _vm.handleChange(item.name, value)
28123
- },
28124
- },
28125
- model: {
28126
- value: _vm.model[x.name],
28127
- callback: function ($$v) {
28128
- _vm.$set(_vm.model, x.name, $$v)
28129
- },
28130
- expression: "model[x.name]",
28131
- },
28132
- },
28133
- "em-picker",
28134
- Object.assign({}, _vm.$attrs, x),
28135
- false
28136
- ),
28137
- Object.assign({}, x.events)
28138
- )
28139
- )
28140
- : x.date ||
28141
- x.type == "date" ||
28142
- x.type == "year" ||
28143
- x.type == "year-month" ||
28144
- x.type == "month-day" ||
28145
- x.type == "time" ||
28146
- x.type == "datetimeSecond" ||
28147
- x.type == "datetime" ||
28148
- x.type == "datehour"
28149
- ? _c(
28150
- "em-date",
28151
- _vm._g(
28152
- _vm._b(
28153
- {
28154
- ref: "date",
28155
- refInFor: true,
28156
- attrs: {
28157
- "label-position":
28158
- x.labelPosition ||
28159
- _vm.labelPosition,
28160
- disabled:
28161
- x.disabled || _vm.disabled,
28162
- readonly:
28163
- x.readonly || _vm.readonly,
28164
- joinStr: x.joinStr || "",
28165
- },
28166
- on: {
28167
- confirm: function (
28168
- value,
28169
- timePeriod
28170
- ) {
28171
- _vm.handleChange(
28172
- x.name,
28173
- value,
28174
- timePeriod
28175
- )
28176
- },
28177
- },
28178
- model: {
28179
- value: _vm.model[x.name],
28180
- callback: function ($$v) {
28181
- _vm.$set(_vm.model, x.name, $$v)
28182
- },
28183
- expression: "model[x.name]",
28184
- },
28185
- },
28186
- "em-date",
28187
- Object.assign({}, _vm.$attrs, x),
28188
- false
28189
- ),
28190
- Object.assign({}, x.events)
28191
- )
28192
- )
28193
- : x.type === "radio"
28194
- ? _c(
28195
- "em-input",
28196
- _vm._b(
28197
- {
28198
- ref: "radio",
28199
- refInFor: true,
28200
- attrs: {
28201
- "label-position":
28202
- x.labelPosition ||
28203
- _vm.labelPosition,
28204
- },
28205
- },
28206
- "em-input",
28207
- Object.assign({}, _vm.$attrs, x),
28208
- false
28209
- ),
28210
- [
28211
- _c(
28212
- "template",
28213
- { slot: "input" },
28214
- [
28215
- _c(
28216
- "em-radio-group",
28217
- _vm._g(
28218
- _vm._b(
28219
- {
28220
- attrs: {
28221
- disabled:
28222
- x.disabled ||
28223
- _vm.disabled ||
28224
- x.readonly ||
28225
- _vm.readonly,
28226
- data: x.data,
28227
- },
28228
- on: {
28229
- change: function (value) {
28230
- _vm.handleChange(
28231
- x.name,
28232
- value
28233
- )
28234
- },
28235
- },
28236
- model: {
28237
- value: _vm.model[x.name],
28238
- callback: function ($$v) {
28239
- _vm.$set(
28240
- _vm.model,
28241
- x.name,
28242
- $$v
28243
- )
28244
- },
28245
- expression: "model[x.name]",
28246
- },
28018
+ !item.hide
28019
+ ? [
28020
+ item.type === "tab"
28021
+ ? _c(
28022
+ "em-tabs",
28023
+ _vm._g(
28024
+ _vm._b(
28025
+ {
28026
+ model: {
28027
+ value: item.active,
28028
+ callback: function ($$v) {
28029
+ _vm.$set(item, "active", $$v)
28030
+ },
28031
+ expression: "item.active",
28032
+ },
28033
+ },
28034
+ "em-tabs",
28035
+ Object.assign({}, item, {
28036
+ type: item.tabType || "line",
28037
+ }),
28038
+ false
28039
+ ),
28040
+ Object.assign({}, item.events)
28041
+ ),
28042
+ _vm._l(item.contents, function (z, i) {
28043
+ return _c(
28044
+ "em-tab",
28045
+ _vm._b(
28046
+ { key: i },
28047
+ "em-tab",
28048
+ Object.assign({}, z),
28049
+ false
28050
+ ),
28051
+ _vm._l(z.contents, function (x, j) {
28052
+ return _c(
28053
+ "div",
28054
+ { key: j, staticStyle: { height: "100%" } },
28055
+ [
28056
+ x.type === "text" ||
28057
+ x.type === "textarea" ||
28058
+ x.type == "number" ||
28059
+ x.type == "digit" ||
28060
+ x.type == "password" ||
28061
+ x.type == "tel"
28062
+ ? _c(
28063
+ "em-input",
28064
+ _vm._g(
28065
+ _vm._b(
28066
+ {
28067
+ ref: "input",
28068
+ refInFor: true,
28069
+ staticClass: "em-table-input",
28070
+ attrs: {
28071
+ "label-position":
28072
+ x.labelPosition ||
28073
+ _vm.labelPosition,
28074
+ disabled:
28075
+ x.disabled || _vm.disabled,
28076
+ readonly:
28077
+ x.readonly || _vm.readonly,
28078
+ label:
28079
+ x.label.text || x.label,
28247
28080
  },
28248
- "em-radio-group",
28249
- Object.assign(
28250
- {},
28251
- _vm.$attrs,
28252
- x
28253
- ),
28254
- false
28255
- ),
28256
- Object.assign({}, x.events)
28257
- )
28258
- ),
28259
- ],
28260
- 1
28261
- ),
28262
- ],
28263
- 2
28264
- )
28265
- : x.type === "checkbox"
28266
- ? _c(
28267
- "em-input",
28268
- _vm._b(
28269
- {
28270
- ref: "checkbox",
28271
- refInFor: true,
28272
- attrs: {
28273
- "label-position":
28274
- x.labelPosition ||
28275
- _vm.labelPosition,
28276
- },
28277
- },
28278
- "em-input",
28279
- Object.assign({}, _vm.$attrs, x),
28280
- false
28281
- ),
28282
- [
28283
- _c(
28284
- "template",
28285
- { slot: "input" },
28286
- [
28287
- _c(
28288
- "em-checkbox-group",
28289
- _vm._g(
28290
- _vm._b(
28291
- {
28292
- attrs: {
28293
- disabled:
28294
- x.disabled ||
28295
- _vm.disabled ||
28296
- x.readonly ||
28297
- _vm.readonly,
28081
+ on: {
28082
+ input: function ($event) {
28083
+ _vm.handleChange(
28084
+ x.name,
28085
+ _vm.model[x.name]
28086
+ )
28298
28087
  },
28299
- on: {
28300
- change: function (value) {
28301
- _vm.handleChange(
28302
- x.name,
28303
- value
28304
- )
28305
- },
28088
+ },
28089
+ model: {
28090
+ value: _vm.model[x.name],
28091
+ callback: function ($$v) {
28092
+ _vm.$set(
28093
+ _vm.model,
28094
+ x.name,
28095
+ $$v
28096
+ )
28306
28097
  },
28307
- model: {
28308
- value: _vm.model[x.name],
28309
- callback: function ($$v) {
28310
- _vm.$set(
28311
- _vm.model,
28312
- x.name,
28313
- $$v
28314
- )
28315
- },
28316
- expression: "model[x.name]",
28098
+ expression: "model[x.name]",
28099
+ },
28100
+ },
28101
+ "em-input",
28102
+ Object.assign({}, _vm.$attrs, x),
28103
+ false
28104
+ ),
28105
+ Object.assign({}, x.events)
28106
+ )
28107
+ )
28108
+ : _vm._e(),
28109
+ x.type === "select"
28110
+ ? _c(
28111
+ "em-picker",
28112
+ _vm._g(
28113
+ _vm._b(
28114
+ {
28115
+ ref: "select",
28116
+ refInFor: true,
28117
+ attrs: {
28118
+ "label-position":
28119
+ x.labelPosition ||
28120
+ _vm.labelPosition,
28121
+ disabled:
28122
+ x.disabled || _vm.disabled,
28123
+ readonly:
28124
+ x.readonly || _vm.readonly,
28125
+ columns: x.data || [],
28126
+ },
28127
+ on: {
28128
+ confirm: function (value) {
28129
+ _vm.handleChange(
28130
+ item.name,
28131
+ value
28132
+ )
28317
28133
  },
28318
28134
  },
28319
- "em-checkbox-group",
28320
- Object.assign(
28321
- {},
28322
- _vm.$attrs,
28323
- x
28324
- ),
28325
- false
28326
- ),
28327
- Object.assign({}, x.events)
28328
- )
28329
- ),
28330
- ],
28331
- 1
28332
- ),
28333
- ],
28334
- 2
28335
- )
28336
- : x.type === "switch"
28337
- ? _c(
28338
- "em-input",
28339
- _vm._b(
28340
- {
28341
- ref: "switch",
28342
- refInFor: true,
28343
- attrs: {
28344
- "label-position":
28345
- x.labelPosition ||
28346
- _vm.labelPosition,
28347
- },
28348
- },
28349
- "em-input",
28350
- Object.assign({}, _vm.$attrs, x),
28351
- false
28352
- ),
28353
- [
28354
- _c(
28355
- "template",
28356
- { slot: "input" },
28357
- [
28358
- _c(
28359
- "em-switch",
28360
- _vm._g(
28361
- _vm._b(
28362
- {
28363
- attrs: {
28364
- disabled:
28365
- x.disabled ||
28366
- _vm.disabled ||
28367
- x.readonly ||
28368
- _vm.readonly,
28135
+ model: {
28136
+ value: _vm.model[x.name],
28137
+ callback: function ($$v) {
28138
+ _vm.$set(
28139
+ _vm.model,
28140
+ x.name,
28141
+ $$v
28142
+ )
28369
28143
  },
28370
- on: {
28371
- change: function (value) {
28372
- _vm.handleChange(
28373
- x.name,
28374
- value
28375
- )
28376
- },
28144
+ expression: "model[x.name]",
28145
+ },
28146
+ },
28147
+ "em-picker",
28148
+ Object.assign({}, _vm.$attrs, x),
28149
+ false
28150
+ ),
28151
+ Object.assign({}, x.events)
28152
+ )
28153
+ )
28154
+ : x.date ||
28155
+ x.type == "date" ||
28156
+ x.type == "year" ||
28157
+ x.type == "year-month" ||
28158
+ x.type == "month-day" ||
28159
+ x.type == "time" ||
28160
+ x.type == "datetimeSecond" ||
28161
+ x.type == "datetime" ||
28162
+ x.type == "datehour"
28163
+ ? _c(
28164
+ "em-date",
28165
+ _vm._g(
28166
+ _vm._b(
28167
+ {
28168
+ ref: "date",
28169
+ refInFor: true,
28170
+ attrs: {
28171
+ "label-position":
28172
+ x.labelPosition ||
28173
+ _vm.labelPosition,
28174
+ disabled:
28175
+ x.disabled || _vm.disabled,
28176
+ readonly:
28177
+ x.readonly || _vm.readonly,
28178
+ joinStr: x.joinStr || "",
28179
+ },
28180
+ on: {
28181
+ confirm: function (
28182
+ value,
28183
+ timePeriod
28184
+ ) {
28185
+ _vm.handleChange(
28186
+ x.name,
28187
+ value,
28188
+ timePeriod
28189
+ )
28377
28190
  },
28378
- model: {
28379
- value: _vm.model[x.name],
28380
- callback: function ($$v) {
28381
- _vm.$set(
28382
- _vm.model,
28383
- x.name,
28384
- $$v
28385
- )
28386
- },
28387
- expression: "model[x.name]",
28191
+ },
28192
+ model: {
28193
+ value: _vm.model[x.name],
28194
+ callback: function ($$v) {
28195
+ _vm.$set(
28196
+ _vm.model,
28197
+ x.name,
28198
+ $$v
28199
+ )
28388
28200
  },
28201
+ expression: "model[x.name]",
28389
28202
  },
28390
- "em-switch",
28391
- Object.assign(
28392
- {},
28393
- _vm.$attrs,
28394
- x
28395
- ),
28396
- false
28397
- ),
28398
- Object.assign({}, x.events)
28399
- )
28400
- ),
28401
- ],
28402
- 1
28403
- ),
28404
- ],
28405
- 2
28406
- )
28407
- : x.type == "selector"
28408
- ? _c(
28409
- "em-selector",
28410
- _vm._g(
28411
- _vm._b(
28412
- {
28413
- ref: "selector",
28414
- refInFor: true,
28415
- attrs: {
28416
- label: x.label,
28417
- "label-position":
28418
- x.labelPosition ||
28419
- _vm.labelPosition,
28420
- disabled:
28421
- x.disabled ||
28422
- _vm.disabled ||
28423
- x.readonly ||
28424
- _vm.readonly,
28425
- },
28426
- on: {
28427
- change: function (value) {
28428
- _vm.handleChange(x.name, value)
28203
+ },
28204
+ "em-date",
28205
+ Object.assign({}, _vm.$attrs, x),
28206
+ false
28207
+ ),
28208
+ Object.assign({}, x.events)
28209
+ )
28210
+ )
28211
+ : x.type === "radio"
28212
+ ? _c(
28213
+ "em-input",
28214
+ _vm._b(
28215
+ {
28216
+ ref: "radio",
28217
+ refInFor: true,
28218
+ attrs: {
28219
+ "label-position":
28220
+ x.labelPosition ||
28221
+ _vm.labelPosition,
28222
+ },
28429
28223
  },
28430
- },
28431
- model: {
28432
- value: _vm.model[x.name],
28433
- callback: function ($$v) {
28434
- _vm.$set(_vm.model, x.name, $$v)
28435
- },
28436
- expression: "model[x.name]",
28437
- },
28438
- },
28439
- "em-selector",
28440
- Object.assign({}, _vm.$attrs, x),
28441
- false
28442
- ),
28443
- Object.assign({}, x.events)
28444
- )
28445
- )
28446
- : x.type == "table"
28447
- ? _c(
28448
- "em-table",
28449
- _vm._g(
28450
- _vm._b(
28451
- {
28452
- ref: "emFormTable",
28453
- refInFor: true,
28454
- staticClass: "em-form-table",
28455
- style:
28456
- "margin:" +
28457
- (x.margin || 10) +
28458
- "px 0px",
28459
- attrs: {
28460
- data: _vm.model[x.name],
28461
- thead: x.tHead,
28462
- isForm: "",
28463
- form:
28464
- !x.disabled &&
28465
- !_vm.disabled &&
28466
- !x.readonly &&
28467
- !_vm.readonly &&
28468
- x.form,
28469
- },
28470
- on: {
28471
- "btn-click": _vm.handleBtnClick,
28472
- },
28473
- },
28474
- "em-table",
28475
- Object.assign({}, _vm.$attrs, x),
28476
- false
28477
- ),
28478
- Object.assign({}, x.events)
28479
- )
28480
- )
28481
- : x.type === "component"
28482
- ? _c(
28483
- "van-cell",
28484
- { attrs: { title: x.label, name: x.name } },
28485
- [
28486
- _c(
28487
- x.is || x.tag,
28488
- _vm._g(
28224
+ "em-input",
28225
+ Object.assign({}, _vm.$attrs, x),
28226
+ false
28227
+ ),
28228
+ [
28229
+ _c(
28230
+ "template",
28231
+ { slot: "input" },
28232
+ [
28233
+ _c(
28234
+ "em-radio-group",
28235
+ _vm._g(
28236
+ _vm._b(
28237
+ {
28238
+ attrs: {
28239
+ disabled:
28240
+ x.disabled ||
28241
+ _vm.disabled ||
28242
+ x.readonly ||
28243
+ _vm.readonly,
28244
+ data: x.data,
28245
+ },
28246
+ on: {
28247
+ change: function (
28248
+ value
28249
+ ) {
28250
+ _vm.handleChange(
28251
+ x.name,
28252
+ value
28253
+ )
28254
+ },
28255
+ },
28256
+ model: {
28257
+ value:
28258
+ _vm.model[x.name],
28259
+ callback: function (
28260
+ $$v
28261
+ ) {
28262
+ _vm.$set(
28263
+ _vm.model,
28264
+ x.name,
28265
+ $$v
28266
+ )
28267
+ },
28268
+ expression:
28269
+ "model[x.name]",
28270
+ },
28271
+ },
28272
+ "em-radio-group",
28273
+ Object.assign(
28274
+ {},
28275
+ _vm.$attrs,
28276
+ x
28277
+ ),
28278
+ false
28279
+ ),
28280
+ Object.assign({}, x.events)
28281
+ )
28282
+ ),
28283
+ ],
28284
+ 1
28285
+ ),
28286
+ ],
28287
+ 2
28288
+ )
28289
+ : x.type === "checkbox"
28290
+ ? _c(
28291
+ "em-input",
28489
28292
  _vm._b(
28490
28293
  {
28491
- tag: "component",
28492
- model: {
28493
- value: _vm.model[x.name],
28494
- callback: function ($$v) {
28495
- _vm.$set(
28496
- _vm.model,
28497
- x.name,
28498
- $$v
28294
+ ref: "checkbox",
28295
+ refInFor: true,
28296
+ attrs: {
28297
+ "label-position":
28298
+ x.labelPosition ||
28299
+ _vm.labelPosition,
28300
+ },
28301
+ },
28302
+ "em-input",
28303
+ Object.assign({}, _vm.$attrs, x),
28304
+ false
28305
+ ),
28306
+ [
28307
+ _c(
28308
+ "template",
28309
+ { slot: "input" },
28310
+ [
28311
+ _c(
28312
+ "em-checkbox-group",
28313
+ _vm._g(
28314
+ _vm._b(
28315
+ {
28316
+ attrs: {
28317
+ disabled:
28318
+ x.disabled ||
28319
+ _vm.disabled ||
28320
+ x.readonly ||
28321
+ _vm.readonly,
28322
+ },
28323
+ on: {
28324
+ change: function (
28325
+ value
28326
+ ) {
28327
+ _vm.handleChange(
28328
+ x.name,
28329
+ value
28330
+ )
28331
+ },
28332
+ },
28333
+ model: {
28334
+ value:
28335
+ _vm.model[x.name],
28336
+ callback: function (
28337
+ $$v
28338
+ ) {
28339
+ _vm.$set(
28340
+ _vm.model,
28341
+ x.name,
28342
+ $$v
28343
+ )
28344
+ },
28345
+ expression:
28346
+ "model[x.name]",
28347
+ },
28348
+ },
28349
+ "em-checkbox-group",
28350
+ Object.assign(
28351
+ {},
28352
+ _vm.$attrs,
28353
+ x
28354
+ ),
28355
+ false
28356
+ ),
28357
+ Object.assign({}, x.events)
28499
28358
  )
28500
- },
28501
- expression: "model[x.name]",
28359
+ ),
28360
+ ],
28361
+ 1
28362
+ ),
28363
+ ],
28364
+ 2
28365
+ )
28366
+ : x.type === "switch"
28367
+ ? _c(
28368
+ "em-input",
28369
+ _vm._b(
28370
+ {
28371
+ ref: "switch",
28372
+ refInFor: true,
28373
+ attrs: {
28374
+ "label-position":
28375
+ x.labelPosition ||
28376
+ _vm.labelPosition,
28502
28377
  },
28503
28378
  },
28504
- "component",
28379
+ "em-input",
28505
28380
  Object.assign({}, _vm.$attrs, x),
28506
28381
  false
28507
28382
  ),
28508
- x.events
28383
+ [
28384
+ _c(
28385
+ "template",
28386
+ { slot: "input" },
28387
+ [
28388
+ _c(
28389
+ "em-switch",
28390
+ _vm._g(
28391
+ _vm._b(
28392
+ {
28393
+ attrs: {
28394
+ disabled:
28395
+ x.disabled ||
28396
+ _vm.disabled ||
28397
+ x.readonly ||
28398
+ _vm.readonly,
28399
+ },
28400
+ on: {
28401
+ change: function (
28402
+ value
28403
+ ) {
28404
+ _vm.handleChange(
28405
+ x.name,
28406
+ value
28407
+ )
28408
+ },
28409
+ },
28410
+ model: {
28411
+ value:
28412
+ _vm.model[x.name],
28413
+ callback: function (
28414
+ $$v
28415
+ ) {
28416
+ _vm.$set(
28417
+ _vm.model,
28418
+ x.name,
28419
+ $$v
28420
+ )
28421
+ },
28422
+ expression:
28423
+ "model[x.name]",
28424
+ },
28425
+ },
28426
+ "em-switch",
28427
+ Object.assign(
28428
+ {},
28429
+ _vm.$attrs,
28430
+ x
28431
+ ),
28432
+ false
28433
+ ),
28434
+ Object.assign({}, x.events)
28435
+ )
28436
+ ),
28437
+ ],
28438
+ 1
28439
+ ),
28440
+ ],
28441
+ 2
28509
28442
  )
28510
- ),
28511
- ],
28512
- 1
28513
- )
28514
- : _vm._e(),
28515
- ],
28516
- 1
28517
- )
28518
- }),
28519
- 0
28520
- )
28521
- }),
28522
- 1
28523
- )
28524
- : _vm._e(),
28525
- item.type === "text" ||
28526
- item.type === "textarea" ||
28527
- item.type == "number" ||
28528
- item.type == "digit" ||
28529
- item.type == "password" ||
28530
- item.type == "tel"
28531
- ? _c(
28532
- "em-input",
28533
- _vm._g(
28534
- _vm._b(
28535
- {
28536
- ref: "input",
28537
- refInFor: true,
28538
- staticClass: "em-table-input",
28539
- attrs: {
28540
- "label-position":
28541
- item.labelPosition || _vm.labelPosition,
28542
- disabled: item.disabled || _vm.disabled,
28543
- readonly: item.readonly || _vm.readonly,
28544
- label: item.label.text || item.label,
28545
- },
28546
- on: {
28547
- input: function ($event) {
28548
- _vm.handleChange(item.name, _vm.model[item.name])
28549
- },
28550
- },
28551
- model: {
28552
- value: _vm.model[item.name],
28553
- callback: function ($$v) {
28554
- _vm.$set(_vm.model, item.name, $$v)
28555
- },
28556
- expression: "model[item.name]",
28557
- },
28558
- },
28559
- "em-input",
28560
- Object.assign({}, _vm.$attrs, item),
28561
- false
28562
- ),
28563
- Object.assign({}, item.events)
28564
- )
28565
- )
28566
- : _vm._e(),
28567
- item.type === "select"
28568
- ? _c(
28569
- "em-picker",
28570
- _vm._g(
28571
- _vm._b(
28572
- {
28573
- ref: "select",
28574
- refInFor: true,
28575
- attrs: {
28576
- "label-position":
28577
- item.labelPosition || _vm.labelPosition,
28578
- disabled: item.disabled || _vm.disabled,
28579
- readonly: item.readonly || _vm.readonly,
28580
- columns: item.data || [],
28581
- },
28582
- on: {
28583
- confirm: function (value) {
28584
- _vm.handleChange(item.name, value)
28585
- },
28586
- },
28587
- model: {
28588
- value: _vm.model[item.name],
28589
- callback: function ($$v) {
28590
- _vm.$set(_vm.model, item.name, $$v)
28591
- },
28592
- expression: "model[item.name]",
28593
- },
28594
- },
28595
- "em-picker",
28596
- Object.assign({}, _vm.$attrs, item),
28597
- false
28598
- ),
28599
- Object.assign({}, item.events)
28600
- )
28601
- )
28602
- : item.date ||
28603
- item.type == "date" ||
28604
- item.type == "year" ||
28605
- item.type == "year-month" ||
28606
- item.type == "month-day" ||
28607
- item.type == "time" ||
28608
- item.type == "datetimeSecond" ||
28609
- item.type == "datetime" ||
28610
- item.type == "datehour"
28611
- ? _c(
28612
- "em-date",
28613
- _vm._g(
28614
- _vm._b(
28615
- {
28616
- ref: "date",
28617
- refInFor: true,
28618
- attrs: {
28619
- "label-position":
28620
- item.labelPosition || _vm.labelPosition,
28621
- disabled: item.disabled || _vm.disabled,
28622
- readonly: item.readonly || _vm.readonly,
28623
- joinStr: item.joinStr || "",
28624
- },
28625
- on: {
28626
- confirm: function (value, timePeriod) {
28627
- _vm.handleChange(item.name, value, timePeriod)
28628
- },
28629
- },
28630
- model: {
28631
- value: _vm.model[item.name],
28632
- callback: function ($$v) {
28633
- _vm.$set(_vm.model, item.name, $$v)
28634
- },
28635
- expression: "model[item.name]",
28636
- },
28637
- },
28638
- "em-date",
28639
- Object.assign({}, _vm.$attrs, item),
28640
- false
28641
- ),
28642
- Object.assign({}, item.events)
28643
- )
28644
- )
28645
- : item.type === "radio"
28646
- ? _c(
28647
- "em-input",
28648
- _vm._b(
28649
- {
28650
- ref: "radio",
28651
- refInFor: true,
28652
- attrs: {
28653
- "label-position":
28654
- item.labelPosition || _vm.labelPosition,
28655
- },
28656
- },
28657
- "em-input",
28658
- Object.assign({}, _vm.$attrs, item),
28659
- false
28660
- ),
28661
- [
28662
- _c(
28663
- "template",
28664
- { slot: "input" },
28665
- [
28666
- _c(
28667
- "em-radio-group",
28668
- _vm._g(
28669
- _vm._b(
28670
- {
28671
- attrs: {
28672
- disabled:
28673
- item.disabled ||
28674
- _vm.disabled ||
28675
- item.readonly ||
28676
- _vm.readonly,
28677
- data: item.data,
28678
- },
28679
- on: {
28680
- change: function (value) {
28681
- _vm.handleChange(item.name, value)
28682
- },
28683
- },
28684
- model: {
28685
- value: _vm.model[item.name],
28686
- callback: function ($$v) {
28687
- _vm.$set(_vm.model, item.name, $$v)
28688
- },
28689
- expression: "model[item.name]",
28690
- },
28691
- },
28692
- "em-radio-group",
28693
- Object.assign({}, _vm.$attrs, item),
28694
- false
28695
- ),
28696
- Object.assign({}, item.events)
28697
- )
28698
- ),
28699
- ],
28700
- 1
28701
- ),
28702
- ],
28703
- 2
28704
- )
28705
- : item.type === "checkbox"
28706
- ? _c(
28707
- "em-input",
28708
- _vm._b(
28709
- {
28710
- ref: "checkbox",
28711
- refInFor: true,
28712
- attrs: {
28713
- "label-position":
28714
- item.labelPosition || _vm.labelPosition,
28715
- },
28716
- },
28717
- "em-input",
28718
- Object.assign({}, _vm.$attrs, item),
28719
- false
28720
- ),
28721
- [
28722
- _c(
28723
- "template",
28724
- { slot: "input" },
28725
- [
28726
- _c(
28727
- "em-checkbox-group",
28728
- _vm._g(
28729
- _vm._b(
28730
- {
28731
- attrs: {
28732
- disabled:
28733
- item.disabled ||
28734
- _vm.disabled ||
28735
- item.readonly ||
28736
- _vm.readonly,
28737
- },
28738
- on: {
28739
- change: function (value) {
28740
- _vm.handleChange(item.name, value)
28741
- },
28742
- },
28743
- model: {
28744
- value: _vm.model[item.name],
28745
- callback: function ($$v) {
28746
- _vm.$set(_vm.model, item.name, $$v)
28747
- },
28748
- expression: "model[item.name]",
28749
- },
28750
- },
28751
- "em-checkbox-group",
28752
- Object.assign({}, _vm.$attrs, item),
28753
- false
28754
- ),
28755
- Object.assign({}, item.events)
28443
+ : x.type == "selector"
28444
+ ? _c(
28445
+ "em-selector",
28446
+ _vm._g(
28447
+ _vm._b(
28448
+ {
28449
+ ref: "selector",
28450
+ refInFor: true,
28451
+ attrs: {
28452
+ label: x.label,
28453
+ "label-position":
28454
+ x.labelPosition ||
28455
+ _vm.labelPosition,
28456
+ disabled:
28457
+ x.disabled ||
28458
+ _vm.disabled ||
28459
+ x.readonly ||
28460
+ _vm.readonly,
28461
+ },
28462
+ on: {
28463
+ change: function (value) {
28464
+ _vm.handleChange(
28465
+ x.name,
28466
+ value
28467
+ )
28468
+ },
28469
+ },
28470
+ model: {
28471
+ value: _vm.model[x.name],
28472
+ callback: function ($$v) {
28473
+ _vm.$set(
28474
+ _vm.model,
28475
+ x.name,
28476
+ $$v
28477
+ )
28478
+ },
28479
+ expression: "model[x.name]",
28480
+ },
28481
+ },
28482
+ "em-selector",
28483
+ Object.assign({}, _vm.$attrs, x),
28484
+ false
28485
+ ),
28486
+ Object.assign({}, x.events)
28487
+ )
28488
+ )
28489
+ : x.type == "table"
28490
+ ? _c(
28491
+ "em-table",
28492
+ _vm._g(
28493
+ _vm._b(
28494
+ {
28495
+ ref: "emFormTable",
28496
+ refInFor: true,
28497
+ staticClass: "em-form-table",
28498
+ style:
28499
+ "margin:" +
28500
+ (x.margin || 10) +
28501
+ "px 0px",
28502
+ attrs: {
28503
+ data: _vm.model[x.name],
28504
+ thead: x.tHead,
28505
+ isForm: "",
28506
+ form:
28507
+ !x.disabled &&
28508
+ !_vm.disabled &&
28509
+ !x.readonly &&
28510
+ !_vm.readonly &&
28511
+ x.form,
28512
+ },
28513
+ on: {
28514
+ "btn-click":
28515
+ _vm.handleBtnClick,
28516
+ },
28517
+ },
28518
+ "em-table",
28519
+ Object.assign({}, _vm.$attrs, x),
28520
+ false
28521
+ ),
28522
+ Object.assign({}, x.events)
28523
+ )
28524
+ )
28525
+ : x.type === "component"
28526
+ ? _c(
28527
+ "van-cell",
28528
+ {
28529
+ attrs: {
28530
+ title: x.label,
28531
+ name: x.name,
28532
+ },
28533
+ },
28534
+ [
28535
+ _c(
28536
+ x.is || x.tag,
28537
+ _vm._g(
28538
+ _vm._b(
28539
+ {
28540
+ tag: "component",
28541
+ model: {
28542
+ value: _vm.model[x.name],
28543
+ callback: function ($$v) {
28544
+ _vm.$set(
28545
+ _vm.model,
28546
+ x.name,
28547
+ $$v
28548
+ )
28549
+ },
28550
+ expression:
28551
+ "model[x.name]",
28552
+ },
28553
+ },
28554
+ "component",
28555
+ Object.assign(
28556
+ {},
28557
+ _vm.$attrs,
28558
+ x
28559
+ ),
28560
+ false
28561
+ ),
28562
+ x.events
28563
+ )
28564
+ ),
28565
+ ],
28566
+ 1
28567
+ )
28568
+ : _vm._e(),
28569
+ ],
28570
+ 1
28571
+ )
28572
+ }),
28573
+ 0
28756
28574
  )
28757
- ),
28758
- ],
28759
- 1
28760
- ),
28761
- ],
28762
- 2
28763
- )
28764
- : item.type === "switch"
28765
- ? _c(
28766
- "em-input",
28767
- _vm._b(
28768
- {
28769
- ref: "switch",
28770
- refInFor: true,
28771
- attrs: {
28772
- "label-position":
28773
- item.labelPosition || _vm.labelPosition,
28774
- },
28775
- },
28776
- "em-input",
28777
- Object.assign({}, _vm.$attrs, item),
28778
- false
28779
- ),
28780
- [
28781
- _c(
28782
- "template",
28783
- { slot: "input" },
28784
- [
28785
- _c(
28786
- "em-switch",
28787
- _vm._g(
28788
- _vm._b(
28789
- {
28790
- attrs: {
28791
- disabled:
28792
- item.disabled ||
28793
- _vm.disabled ||
28794
- item.readonly ||
28795
- _vm.readonly,
28796
- },
28797
- on: {
28798
- change: function (value) {
28799
- _vm.handleChange(item.name, value)
28800
- },
28575
+ }),
28576
+ 1
28577
+ )
28578
+ : _vm._e(),
28579
+ item.type === "text" ||
28580
+ item.type === "textarea" ||
28581
+ item.type == "number" ||
28582
+ item.type == "digit" ||
28583
+ item.type == "password" ||
28584
+ item.type == "tel"
28585
+ ? _c(
28586
+ "em-input",
28587
+ _vm._g(
28588
+ _vm._b(
28589
+ {
28590
+ ref: "input",
28591
+ refInFor: true,
28592
+ staticClass: "em-table-input",
28593
+ attrs: {
28594
+ "label-position":
28595
+ item.labelPosition || _vm.labelPosition,
28596
+ disabled: item.disabled || _vm.disabled,
28597
+ readonly: item.readonly || _vm.readonly,
28598
+ label: item.label.text || item.label,
28599
+ },
28600
+ on: {
28601
+ input: function ($event) {
28602
+ _vm.handleChange(
28603
+ item.name,
28604
+ _vm.model[item.name]
28605
+ )
28801
28606
  },
28802
- model: {
28803
- value: _vm.model[item.name],
28804
- callback: function ($$v) {
28805
- _vm.$set(_vm.model, item.name, $$v)
28806
- },
28807
- expression: "model[item.name]",
28607
+ },
28608
+ model: {
28609
+ value: _vm.model[item.name],
28610
+ callback: function ($$v) {
28611
+ _vm.$set(_vm.model, item.name, $$v)
28808
28612
  },
28613
+ expression: "model[item.name]",
28809
28614
  },
28810
- "em-switch",
28811
- Object.assign({}, _vm.$attrs, item),
28812
- false
28813
- ),
28814
- Object.assign({}, item.events)
28815
- )
28816
- ),
28817
- ],
28818
- 1
28819
- ),
28820
- ],
28821
- 2
28822
- )
28823
- : item.type == "selector"
28824
- ? _c(
28825
- "em-selector",
28826
- _vm._g(
28827
- _vm._b(
28828
- {
28829
- ref: "selector",
28830
- refInFor: true,
28831
- attrs: {
28832
- label: item.label,
28833
- "label-position":
28834
- item.labelPosition || _vm.labelPosition,
28835
- disabled:
28836
- item.disabled ||
28837
- _vm.disabled ||
28838
- item.readonly ||
28839
- _vm.readonly,
28840
- },
28841
- on: {
28842
- change: function (value) {
28843
- _vm.handleChange(item.name, value)
28844
- },
28845
- },
28846
- model: {
28847
- value: _vm.model[item.name],
28848
- callback: function ($$v) {
28849
- _vm.$set(_vm.model, item.name, $$v)
28850
- },
28851
- expression: "model[item.name]",
28852
- },
28853
- },
28854
- "em-selector",
28855
- Object.assign({}, _vm.$attrs, item),
28856
- false
28857
- ),
28858
- Object.assign({}, item.events)
28859
- )
28860
- )
28861
- : item.type == "table"
28862
- ? [
28863
- item.presentType && item.presentType == "card"
28615
+ },
28616
+ "em-input",
28617
+ Object.assign({}, _vm.$attrs, item),
28618
+ false
28619
+ ),
28620
+ Object.assign({}, item.events)
28621
+ )
28622
+ )
28623
+ : _vm._e(),
28624
+ item.type === "select"
28864
28625
  ? _c(
28865
- "custom-card",
28866
- _vm._b(
28867
- {
28868
- model: {
28869
- value: _vm.model[item.name],
28870
- callback: function ($$v) {
28871
- _vm.$set(_vm.model, item.name, $$v)
28626
+ "em-picker",
28627
+ _vm._g(
28628
+ _vm._b(
28629
+ {
28630
+ ref: "select",
28631
+ refInFor: true,
28632
+ attrs: {
28633
+ "label-position":
28634
+ item.labelPosition || _vm.labelPosition,
28635
+ disabled: item.disabled || _vm.disabled,
28636
+ readonly: item.readonly || _vm.readonly,
28637
+ columns: item.data || [],
28638
+ },
28639
+ on: {
28640
+ confirm: function (value) {
28641
+ _vm.handleChange(item.name, value)
28642
+ },
28643
+ },
28644
+ model: {
28645
+ value: _vm.model[item.name],
28646
+ callback: function ($$v) {
28647
+ _vm.$set(_vm.model, item.name, $$v)
28648
+ },
28649
+ expression: "model[item.name]",
28872
28650
  },
28873
- expression: "model[item.name]",
28874
28651
  },
28875
- },
28876
- "custom-card",
28877
- Object.assign({}, _vm.$attrs, item),
28878
- false
28652
+ "em-picker",
28653
+ Object.assign({}, _vm.$attrs, item),
28654
+ false
28655
+ ),
28656
+ Object.assign({}, item.events)
28879
28657
  )
28880
28658
  )
28881
- : _c(
28882
- "em-table",
28659
+ : item.date ||
28660
+ item.type == "date" ||
28661
+ item.type == "year" ||
28662
+ item.type == "year-month" ||
28663
+ item.type == "month-day" ||
28664
+ item.type == "time" ||
28665
+ item.type == "datetimeSecond" ||
28666
+ item.type == "datetime" ||
28667
+ item.type == "datehour"
28668
+ ? _c(
28669
+ "em-date",
28883
28670
  _vm._g(
28884
28671
  _vm._b(
28885
28672
  {
28886
- ref: "emFormTable",
28673
+ ref: "date",
28887
28674
  refInFor: true,
28888
- staticClass: "em-form-table",
28889
- style:
28890
- "margin:" + (item.margin || 10) + "px 0px",
28891
28675
  attrs: {
28892
- data: _vm.model[item.name],
28893
- thead: item.tHead,
28894
- isForm: "",
28895
- form:
28896
- !item.disabled &&
28897
- !_vm.disabled &&
28898
- !item.readonly &&
28899
- !_vm.readonly &&
28900
- item.form,
28676
+ "label-position":
28677
+ item.labelPosition || _vm.labelPosition,
28678
+ disabled: item.disabled || _vm.disabled,
28679
+ readonly: item.readonly || _vm.readonly,
28680
+ joinStr: item.joinStr || "",
28681
+ },
28682
+ on: {
28683
+ confirm: function (value, timePeriod) {
28684
+ _vm.handleChange(
28685
+ item.name,
28686
+ value,
28687
+ timePeriod
28688
+ )
28689
+ },
28690
+ },
28691
+ model: {
28692
+ value: _vm.model[item.name],
28693
+ callback: function ($$v) {
28694
+ _vm.$set(_vm.model, item.name, $$v)
28695
+ },
28696
+ expression: "model[item.name]",
28901
28697
  },
28902
- on: { "btn-click": _vm.handleBtnClick },
28903
28698
  },
28904
- "em-table",
28699
+ "em-date",
28905
28700
  Object.assign({}, _vm.$attrs, item),
28906
28701
  false
28907
28702
  ),
28908
28703
  Object.assign({}, item.events)
28909
28704
  )
28910
- ),
28911
- ]
28912
- : item.type === "component"
28913
- ? _c(
28914
- "van-cell",
28915
- { attrs: { title: item.label, name: item.name } },
28916
- [
28917
- _c(
28918
- item.is || item.tag,
28919
- _vm._g(
28705
+ )
28706
+ : item.type === "radio"
28707
+ ? _c(
28708
+ "em-input",
28920
28709
  _vm._b(
28921
28710
  {
28922
- tag: "component",
28923
- model: {
28924
- value: _vm.model[item.name],
28925
- callback: function ($$v) {
28926
- _vm.$set(_vm.model, item.name, $$v)
28927
- },
28928
- expression: "model[item.name]",
28711
+ ref: "radio",
28712
+ refInFor: true,
28713
+ attrs: {
28714
+ "label-position":
28715
+ item.labelPosition || _vm.labelPosition,
28929
28716
  },
28930
28717
  },
28931
- "component",
28718
+ "em-input",
28932
28719
  Object.assign({}, _vm.$attrs, item),
28933
28720
  false
28934
28721
  ),
28935
- item.events
28722
+ [
28723
+ _c(
28724
+ "template",
28725
+ { slot: "input" },
28726
+ [
28727
+ _c(
28728
+ "em-radio-group",
28729
+ _vm._g(
28730
+ _vm._b(
28731
+ {
28732
+ attrs: {
28733
+ disabled:
28734
+ item.disabled ||
28735
+ _vm.disabled ||
28736
+ item.readonly ||
28737
+ _vm.readonly,
28738
+ data: item.data,
28739
+ },
28740
+ on: {
28741
+ change: function (value) {
28742
+ _vm.handleChange(item.name, value)
28743
+ },
28744
+ },
28745
+ model: {
28746
+ value: _vm.model[item.name],
28747
+ callback: function ($$v) {
28748
+ _vm.$set(_vm.model, item.name, $$v)
28749
+ },
28750
+ expression: "model[item.name]",
28751
+ },
28752
+ },
28753
+ "em-radio-group",
28754
+ Object.assign({}, _vm.$attrs, item),
28755
+ false
28756
+ ),
28757
+ Object.assign({}, item.events)
28758
+ )
28759
+ ),
28760
+ ],
28761
+ 1
28762
+ ),
28763
+ ],
28764
+ 2
28936
28765
  )
28937
- ),
28938
- ],
28939
- 1
28940
- )
28766
+ : item.type === "checkbox"
28767
+ ? _c(
28768
+ "em-input",
28769
+ _vm._b(
28770
+ {
28771
+ ref: "checkbox",
28772
+ refInFor: true,
28773
+ attrs: {
28774
+ "label-position":
28775
+ item.labelPosition || _vm.labelPosition,
28776
+ },
28777
+ },
28778
+ "em-input",
28779
+ Object.assign({}, _vm.$attrs, item),
28780
+ false
28781
+ ),
28782
+ [
28783
+ _c(
28784
+ "template",
28785
+ { slot: "input" },
28786
+ [
28787
+ _c(
28788
+ "em-checkbox-group",
28789
+ _vm._g(
28790
+ _vm._b(
28791
+ {
28792
+ attrs: {
28793
+ disabled:
28794
+ item.disabled ||
28795
+ _vm.disabled ||
28796
+ item.readonly ||
28797
+ _vm.readonly,
28798
+ },
28799
+ on: {
28800
+ change: function (value) {
28801
+ _vm.handleChange(item.name, value)
28802
+ },
28803
+ },
28804
+ model: {
28805
+ value: _vm.model[item.name],
28806
+ callback: function ($$v) {
28807
+ _vm.$set(_vm.model, item.name, $$v)
28808
+ },
28809
+ expression: "model[item.name]",
28810
+ },
28811
+ },
28812
+ "em-checkbox-group",
28813
+ Object.assign({}, _vm.$attrs, item),
28814
+ false
28815
+ ),
28816
+ Object.assign({}, item.events)
28817
+ )
28818
+ ),
28819
+ ],
28820
+ 1
28821
+ ),
28822
+ ],
28823
+ 2
28824
+ )
28825
+ : item.type === "switch"
28826
+ ? _c(
28827
+ "em-input",
28828
+ _vm._b(
28829
+ {
28830
+ ref: "switch",
28831
+ refInFor: true,
28832
+ attrs: {
28833
+ "label-position":
28834
+ item.labelPosition || _vm.labelPosition,
28835
+ },
28836
+ },
28837
+ "em-input",
28838
+ Object.assign({}, _vm.$attrs, item),
28839
+ false
28840
+ ),
28841
+ [
28842
+ _c(
28843
+ "template",
28844
+ { slot: "input" },
28845
+ [
28846
+ _c(
28847
+ "em-switch",
28848
+ _vm._g(
28849
+ _vm._b(
28850
+ {
28851
+ attrs: {
28852
+ disabled:
28853
+ item.disabled ||
28854
+ _vm.disabled ||
28855
+ item.readonly ||
28856
+ _vm.readonly,
28857
+ },
28858
+ on: {
28859
+ change: function (value) {
28860
+ _vm.handleChange(item.name, value)
28861
+ },
28862
+ },
28863
+ model: {
28864
+ value: _vm.model[item.name],
28865
+ callback: function ($$v) {
28866
+ _vm.$set(_vm.model, item.name, $$v)
28867
+ },
28868
+ expression: "model[item.name]",
28869
+ },
28870
+ },
28871
+ "em-switch",
28872
+ Object.assign({}, _vm.$attrs, item),
28873
+ false
28874
+ ),
28875
+ Object.assign({}, item.events)
28876
+ )
28877
+ ),
28878
+ ],
28879
+ 1
28880
+ ),
28881
+ ],
28882
+ 2
28883
+ )
28884
+ : item.type == "selector"
28885
+ ? _c(
28886
+ "em-selector",
28887
+ _vm._g(
28888
+ _vm._b(
28889
+ {
28890
+ ref: "selector",
28891
+ refInFor: true,
28892
+ attrs: {
28893
+ label: item.label,
28894
+ "label-position":
28895
+ item.labelPosition || _vm.labelPosition,
28896
+ disabled:
28897
+ item.disabled ||
28898
+ _vm.disabled ||
28899
+ item.readonly ||
28900
+ _vm.readonly,
28901
+ },
28902
+ on: {
28903
+ change: function (value) {
28904
+ _vm.handleChange(item.name, value)
28905
+ },
28906
+ },
28907
+ model: {
28908
+ value: _vm.model[item.name],
28909
+ callback: function ($$v) {
28910
+ _vm.$set(_vm.model, item.name, $$v)
28911
+ },
28912
+ expression: "model[item.name]",
28913
+ },
28914
+ },
28915
+ "em-selector",
28916
+ Object.assign({}, _vm.$attrs, item),
28917
+ false
28918
+ ),
28919
+ Object.assign({}, item.events)
28920
+ )
28921
+ )
28922
+ : item.type == "table"
28923
+ ? [
28924
+ item.presentType && item.presentType == "card"
28925
+ ? _c(
28926
+ "custom-card",
28927
+ _vm._b(
28928
+ {
28929
+ model: {
28930
+ value: _vm.model[item.name],
28931
+ callback: function ($$v) {
28932
+ _vm.$set(_vm.model, item.name, $$v)
28933
+ },
28934
+ expression: "model[item.name]",
28935
+ },
28936
+ },
28937
+ "custom-card",
28938
+ Object.assign({}, _vm.$attrs, item),
28939
+ false
28940
+ )
28941
+ )
28942
+ : _c(
28943
+ "em-table",
28944
+ _vm._g(
28945
+ _vm._b(
28946
+ {
28947
+ ref: "emFormTable",
28948
+ refInFor: true,
28949
+ staticClass: "em-form-table",
28950
+ style:
28951
+ "margin:" +
28952
+ (item.margin || 10) +
28953
+ "px 0px",
28954
+ attrs: {
28955
+ data: _vm.model[item.name],
28956
+ thead: item.tHead,
28957
+ isForm: "",
28958
+ form:
28959
+ !item.disabled &&
28960
+ !_vm.disabled &&
28961
+ !item.readonly &&
28962
+ !_vm.readonly &&
28963
+ item.form,
28964
+ },
28965
+ on: { "btn-click": _vm.handleBtnClick },
28966
+ },
28967
+ "em-table",
28968
+ Object.assign({}, _vm.$attrs, item),
28969
+ false
28970
+ ),
28971
+ Object.assign({}, item.events)
28972
+ )
28973
+ ),
28974
+ ]
28975
+ : item.type === "component"
28976
+ ? _c(
28977
+ "van-cell",
28978
+ { attrs: { title: item.label, name: item.name } },
28979
+ [
28980
+ _c(
28981
+ item.is || item.tag,
28982
+ _vm._g(
28983
+ _vm._b(
28984
+ {
28985
+ tag: "component",
28986
+ model: {
28987
+ value: _vm.model[item.name],
28988
+ callback: function ($$v) {
28989
+ _vm.$set(_vm.model, item.name, $$v)
28990
+ },
28991
+ expression: "model[item.name]",
28992
+ },
28993
+ },
28994
+ "component",
28995
+ Object.assign({}, _vm.$attrs, item),
28996
+ false
28997
+ ),
28998
+ item.events
28999
+ )
29000
+ ),
29001
+ ],
29002
+ 1
29003
+ )
29004
+ : _vm._e(),
29005
+ ]
28941
29006
  : _vm._e(),
28942
29007
  ],
28943
29008
  2
@@ -29003,11 +29068,11 @@ var mainvue_type_template_id_2cd80b57_render = function () {
29003
29068
  ]
29004
29069
  )
29005
29070
  }
29006
- var mainvue_type_template_id_2cd80b57_staticRenderFns = []
29007
- mainvue_type_template_id_2cd80b57_render._withStripped = true
29071
+ var mainvue_type_template_id_23d3cbdb_staticRenderFns = []
29072
+ mainvue_type_template_id_23d3cbdb_render._withStripped = true
29008
29073
 
29009
29074
 
29010
- // CONCATENATED MODULE: ./packages/form/src/main.vue?vue&type=template&id=2cd80b57
29075
+ // CONCATENATED MODULE: ./packages/form/src/main.vue?vue&type=template&id=23d3cbdb
29011
29076
 
29012
29077
  // CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/form/src/CustomCard.vue?vue&type=template&id=a568ae9a
29013
29078
  var CustomCardvue_type_template_id_a568ae9a_render = function () {
@@ -29873,6 +29938,24 @@ var CustomCard_component = normalizeComponent(
29873
29938
  //
29874
29939
  //
29875
29940
  //
29941
+ //
29942
+ //
29943
+ //
29944
+ //
29945
+ //
29946
+ //
29947
+ //
29948
+ //
29949
+ //
29950
+ //
29951
+ //
29952
+ //
29953
+ //
29954
+ //
29955
+ //
29956
+ //
29957
+ //
29958
+ //
29876
29959
 
29877
29960
 
29878
29961
  /* harmony default export */ var form_src_mainvue_type_script_lang_js = ({
@@ -30001,8 +30084,8 @@ var CustomCard_component = normalizeComponent(
30001
30084
 
30002
30085
  var form_src_main_component = normalizeComponent(
30003
30086
  packages_form_src_mainvue_type_script_lang_js,
30004
- mainvue_type_template_id_2cd80b57_render,
30005
- mainvue_type_template_id_2cd80b57_staticRenderFns,
30087
+ mainvue_type_template_id_23d3cbdb_render,
30088
+ mainvue_type_template_id_23d3cbdb_staticRenderFns,
30006
30089
  false,
30007
30090
  null,
30008
30091
  null,
@@ -32022,7 +32105,7 @@ if (typeof window !== 'undefined' && window.Vue) {
32022
32105
  }
32023
32106
 
32024
32107
  /* harmony default export */ var src = __webpack_exports__["default"] = ({
32025
- version: '0.4.2',
32108
+ version: '0.4.3',
32026
32109
  install: install,
32027
32110
  Button: packages_button,
32028
32111
  ButtonGroup: button_group,