doway-coms 1.1.49 → 1.1.50

package/node_modules/vxe-table/packages/pulldown/src/pulldown.js

@@ -0,0 +1,258 @@
+import GlobalConfig from '../../v-x-e-table/src/conf'
+import vSize from '../../mixins/size'
+import UtilTools from '../../tools/utils'
+import DomTools from '../../tools/dom'
+import { GlobalEvent } from '../../tools/event'
+
+export default {
+  name: 'VxePulldown',
+  mixins: [vSize],
+  props: {
+    value: Boolean,
+    disabled: Boolean,
+    placement: String,
+    size: { type: String, default: () => GlobalConfig.size },
+    destroyOnClose: Boolean,
+    transfer: Boolean
+  },
+  data () {
+    return {
+      inited: false,
+      panelIndex: 0,
+      panelStyle: null,
+      panelPlacement: null,
+      currentValue: null,
+      visiblePanel: false,
+      animatVisible: false,
+      isActivated: false
+    }
+  },
+  watch: {
+    value (value) {
+      if (value) {
+        this.showPanel()
+      } else {
+        this.hidePanel()
+      }
+    }
+  },
+  created () {
+    GlobalEvent.on(this, 'mousewheel', this.handleGlobalMousewheelEvent)
+    GlobalEvent.on(this, 'mousedown', this.handleGlobalMousedownEvent)
+    GlobalEvent.on(this, 'blur', this.handleGlobalBlurEvent)
+  },
+  beforeDestroy () {
+    const panelElem = this.$refs.panel
+    if (panelElem && panelElem.parentNode) {
+      panelElem.parentNode.removeChild(panelElem)
+    }
+  },
+  destroyed () {
+    GlobalEvent.off(this, 'mousewheel')
+    GlobalEvent.off(this, 'mousedown')
+    GlobalEvent.off(this, 'blur')
+  },
+  render (h) {
+    const { $scopedSlots, inited, vSize, destroyOnClose, transfer, isActivated, disabled, animatVisible, visiblePanel, panelStyle, panelPlacement } = this
+    const defaultSlot = $scopedSlots.default
+    const downSlot = $scopedSlots.dropdown
+    return h('div', {
+      class: ['vxe-pulldown', {
+        [`size--${vSize}`]: vSize,
+        'is--visivle': visiblePanel,
+        'is--disabled': disabled,
+        'is--active': isActivated
+      }]
+    }, [
+      h('div', {
+        ref: 'content',
+        class: 'vxe-pulldown--content'
+      }, defaultSlot ? defaultSlot.call(this, { $pulldown: this }, h) : []),
+      h('div', {
+        ref: 'panel',
+        class: ['vxe-table--ignore-clear vxe-pulldown--panel', {
+          [`size--${vSize}`]: vSize,
+          'is--transfer': transfer,
+          'animat--leave': animatVisible,
+          'animat--enter': visiblePanel
+        }],
+        attrs: {
+          placement: panelPlacement
+        },
+        style: panelStyle
+      }, downSlot ? [
+        h('div', {
+          class: 'vxe-pulldown--wrapper'
+        }, !inited || (destroyOnClose && !visiblePanel && !animatVisible) ? [] : downSlot.call(this, { $pulldown: this }, h))
+      ] : [])
+    ])
+  },
+  methods: {
+    handleGlobalMousewheelEvent (evnt) {
+      const { $refs, disabled, visiblePanel } = this
+      if (!disabled) {
+        if (visiblePanel) {
+          if (DomTools.getEventTargetNode(evnt, $refs.panel).flag) {
+            this.updatePlacement()
+          } else {
+            this.hidePanel()
+            this.$emit('hide-panel', { $event: evnt })
+          }
+        }
+      }
+    },
+    handleGlobalMousedownEvent (evnt) {
+      const { $refs, $el, disabled, visiblePanel } = this
+      if (!disabled) {
+        this.isActivated = DomTools.getEventTargetNode(evnt, $el).flag || DomTools.getEventTargetNode(evnt, $refs.panel).flag
+        if (visiblePanel && !this.isActivated) {
+          this.hidePanel()
+          this.$emit('hide-panel', { $event: evnt })
+        }
+      }
+    },
+    handleGlobalBlurEvent (evnt) {
+      if (this.visiblePanel) {
+        this.isActivated = false
+        this.hidePanel()
+        this.$emit('hide-panel', { $event: evnt })
+      }
+    },
+    updateZindex () {
+      if (this.panelIndex < UtilTools.getLastZIndex()) {
+        this.panelIndex = UtilTools.nextZIndex()
+      }
+    },
+    isPanelVisible () {
+      return this.visiblePanel
+    },
+    /**
+     * 切换下拉面板
+     */
+    togglePanel () {
+      if (this.visiblePanel) {
+        return this.hidePanel()
+      }
+      return this.showPanel()
+    },
+    /**
+     * 显示下拉面板
+     */
+    showPanel () {
+      if (!this.inited) {
+        this.inited = true
+        if (this.transfer) {
+          document.body.appendChild(this.$refs.panel)
+        }
+      }
+      return new Promise(resolve => {
+        if (!this.disabled) {
+          clearTimeout(this.hidePanelTimeout)
+          this.isActivated = true
+          this.animatVisible = true
+          setTimeout(() => {
+            this.visiblePanel = true
+            this.$emit('update:input', true)
+            this.updatePlacement()
+            setTimeout(() => {
+              resolve(this.updatePlacement())
+            }, 40)
+          }, 10)
+          this.updateZindex()
+        } else {
+          resolve(this.$nextTick())
+        }
+      })
+    },
+    /**
+     * 隐藏下拉面板
+     */
+    hidePanel () {
+      this.visiblePanel = false
+      this.$emit('update:input', false)
+      return new Promise(resolve => {
+        if (this.animatVisible) {
+          this.hidePanelTimeout = setTimeout(() => {
+            this.animatVisible = false
+            resolve(this.$nextTick())
+          }, 350)
+        } else {
+          resolve(this.$nextTick())
+        }
+      })
+    },
+    /**
+     * 手动更新位置
+     */
+    updatePlacement () {
+      return this.$nextTick().then(() => {
+        const { $refs, transfer, placement, panelIndex, visiblePanel } = this
+        if (visiblePanel) {
+          const panelElem = $refs.panel
+          const targetElem = $refs.content
+          if (panelElem && targetElem) {
+            const targetHeight = targetElem.offsetHeight
+            const targetWidth = targetElem.offsetWidth
+            const panelHeight = panelElem.offsetHeight
+            const panelWidth = panelElem.offsetWidth
+            const marginSize = 5
+            const panelStyle = {
+              zIndex: panelIndex
+            }
+            const { boundingTop, boundingLeft, visibleHeight, visibleWidth } = DomTools.getAbsolutePos(targetElem)
+            let panelPlacement = 'bottom'
+            if (transfer) {
+              let left = boundingLeft
+              let top = boundingTop + targetHeight
+              if (placement === 'top') {
+                panelPlacement = 'top'
+                top = boundingTop - panelHeight
+              } else if (!placement) {
+                // 如果下面不够放，则向上
+                if (top + panelHeight + marginSize > visibleHeight) {
+                  panelPlacement = 'top'
+                  top = boundingTop - panelHeight
+                }
+                // 如果上面不够放，则向下（优先）
+                if (top < marginSize) {
+                  panelPlacement = 'bottom'
+                  top = boundingTop + targetHeight
+                }
+              }
+              // 如果溢出右边
+              if (left + panelWidth + marginSize > visibleWidth) {
+                left -= left + panelWidth + marginSize - visibleWidth
+              }
+              // 如果溢出左边
+              if (left < marginSize) {
+                left = marginSize
+              }
+              Object.assign(panelStyle, {
+                left: `${left}px`,
+                top: `${top}px`,
+                minWidth: `${targetWidth}px`
+              })
+            } else {
+              if (placement === 'top') {
+                panelPlacement = 'top'
+                panelStyle.bottom = `${targetHeight}px`
+              } else if (!placement) {
+                // 如果下面不够放，则向上
+                if (boundingTop + targetHeight + panelHeight > visibleHeight) {
+                  // 如果上面不够放，则向下（优先）
+                  if (boundingTop - targetHeight - panelHeight > marginSize) {
+                    panelPlacement = 'top'
+                    panelStyle.bottom = `${targetHeight}px`
+                  }
+                }
+              }
+            }
+            this.panelStyle = panelStyle
+            this.panelPlacement = panelPlacement
+          }
+        }
+        return this.$nextTick()
+      })
+    }
+  }
+}

package/node_modules/vxe-table/packages/radio/index.d.ts

@@ -0,0 +1,4 @@
+import { Radio } from '../../types/radio'
+
+export * from '../../types/radio'
+export default Radio

package/node_modules/vxe-table/packages/radio/index.js

@@ -0,0 +1,9 @@
+import VxeRadio from './src/radio'
+
+export const Radio = Object.assign(VxeRadio, {
+  install (Vue) {
+    Vue.component(VxeRadio.name, VxeRadio)
+  }
+})
+
+export default Radio

package/node_modules/vxe-table/packages/radio/src/button.js

@@ -0,0 +1,92 @@
+import { getFuncText } from '../../tools/utils'
+import GlobalConfig from '../../v-x-e-table/src/conf'
+
+export default {
+  name: 'VxeRadioButton',
+  props: {
+    value: [String, Number, Boolean],
+    label: [String, Number, Boolean],
+    title: [String, Number],
+    content: [String, Number],
+    disabled: Boolean,
+    strict: { type: Boolean, default: () => GlobalConfig.radioButton.strict },
+    size: { type: String, default: () => GlobalConfig.radioButton.size || GlobalConfig.size }
+  },
+  inject: {
+    $xeradiogroup: {
+      default: null
+    }
+  },
+  computed: {
+    vSize () {
+      return this.size || this.$parent.size || this.$parent.vSize
+    },
+    isDisabled () {
+      const { $xeradiogroup } = this
+      return this.disabled || ($xeradiogroup && $xeradiogroup.disabled)
+    },
+    isStrict () {
+      const { $xeradiogroup } = this
+      return $xeradiogroup ? $xeradiogroup.strict : this.strict
+    }
+  },
+  render (h) {
+    const { $scopedSlots, $xeradiogroup, isDisabled, title, vSize, value, label, content } = this
+    const attrs = {}
+    if (title) {
+      attrs.title = title
+    }
+    return h('label', {
+      class: ['vxe-radio', 'vxe-radio-button', {
+        [`size--${vSize}`]: vSize,
+        'is--disabled': isDisabled
+      }],
+      attrs
+    }, [
+      h('input', {
+        class: 'vxe-radio--input',
+        attrs: {
+          type: 'radio',
+          name: $xeradiogroup ? $xeradiogroup.name : null,
+          disabled: isDisabled
+        },
+        domProps: {
+          checked: $xeradiogroup ? $xeradiogroup.value === label : value === label
+        },
+        on: {
+          change: this.changeEvent,
+          click: this.clickEvent
+        }
+      }),
+      h('span', {
+        class: 'vxe-radio--label'
+      }, $scopedSlots.default ? $scopedSlots.default.call(this, {}) : [getFuncText(content)])
+    ])
+  },
+  methods: {
+    handleValue (label, evnt) {
+      const { $xeradiogroup } = this
+      const params = { label, $event: evnt }
+      if ($xeradiogroup) {
+        $xeradiogroup.handleChecked(params)
+      } else {
+        this.$emit('input', label)
+        this.$emit('change', params)
+      }
+    },
+    changeEvent (evnt) {
+      const { isDisabled } = this
+      if (!isDisabled) {
+        this.handleValue(this.label, evnt)
+      }
+    },
+    clickEvent (evnt) {
+      const { $xeradiogroup, isDisabled, isStrict } = this
+      if (!isDisabled && !isStrict) {
+        if (this.label === ($xeradiogroup ? $xeradiogroup.value : this.value)) {
+          this.handleValue(null, evnt)
+        }
+      }
+    }
+  }
+}

package/node_modules/vxe-table/packages/radio/src/group.js

@@ -0,0 +1,39 @@
+import XEUtils from 'xe-utils'
+import GlobalConfig from '../../v-x-e-table/src/conf'
+
+export default {
+  name: 'VxeRadioGroup',
+  props: {
+    value: [String, Number, Boolean],
+    disabled: Boolean,
+    strict: { type: Boolean, default: () => GlobalConfig.radioGroup.strict },
+    size: { type: String, default: () => GlobalConfig.radioGroup.size || GlobalConfig.size }
+  },
+  provide () {
+    return {
+      $xeradiogroup: this
+    }
+  },
+  computed: {
+    vSize () {
+      return this.size || this.$parent.size || this.$parent.vSize
+    }
+  },
+  data () {
+    return {
+      name: XEUtils.uniqueId('xegroup_')
+    }
+  },
+  render (h) {
+    const { $scopedSlots } = this
+    return h('div', {
+      class: 'vxe-radio-group'
+    }, $scopedSlots.default ? $scopedSlots.default.call(this, {}) : [])
+  },
+  methods: {
+    handleChecked (params) {
+      this.$emit('input', params.label)
+      this.$emit('change', params)
+    }
+  }
+}

package/node_modules/vxe-table/packages/radio/src/radio.js

@@ -0,0 +1,95 @@
+import { getFuncText } from '../../tools/utils'
+import GlobalConfig from '../../v-x-e-table/src/conf'
+import vSize from '../../mixins/size'
+
+export default {
+  name: 'VxeRadio',
+  mixins: [vSize],
+  props: {
+    value: [String, Number, Boolean],
+    label: [String, Number, Boolean],
+    title: [String, Number],
+    content: [String, Number],
+    disabled: Boolean,
+    name: String,
+    strict: { type: Boolean, default: () => GlobalConfig.radio.strict },
+    size: { type: String, default: () => GlobalConfig.radio.size || GlobalConfig.size }
+  },
+  inject: {
+    $xeradiogroup: {
+      default: null
+    }
+  },
+  computed: {
+    isDisabled () {
+      const { $xeradiogroup } = this
+      return this.disabled || ($xeradiogroup && $xeradiogroup.disabled)
+    },
+    isStrict () {
+      const { $xeradiogroup } = this
+      return $xeradiogroup ? $xeradiogroup.strict : this.strict
+    }
+  },
+  render (h) {
+    const { $scopedSlots, $xeradiogroup, isDisabled, title, vSize, value, label, name, content } = this
+    const attrs = {}
+    if (title) {
+      attrs.title = title
+    }
+    return h('label', {
+      class: ['vxe-radio', {
+        [`size--${vSize}`]: vSize,
+        'is--disabled': isDisabled
+      }],
+      attrs
+    }, [
+      h('input', {
+        class: 'vxe-radio--input',
+        attrs: {
+          type: 'radio',
+          name: $xeradiogroup ? $xeradiogroup.name : name,
+          disabled: isDisabled
+        },
+        domProps: {
+          checked: $xeradiogroup ? $xeradiogroup.value === label : value === label
+        },
+        on: {
+          change: this.changeEvent,
+          click: this.clickEvent
+        }
+      }),
+      h('span', {
+        class: 'vxe-radio--icon'
+      }),
+      h('span', {
+        class: 'vxe-radio--label'
+      }, $scopedSlots.default ? $scopedSlots.default.call(this, {}) : [getFuncText(content)])
+    ])
+  },
+  methods: {
+    handleValue (label, evnt) {
+      const { $xeradiogroup } = this
+      const params = { label, $event: evnt }
+      if ($xeradiogroup) {
+        $xeradiogroup.handleChecked(params)
+      } else {
+        this.$emit('input', label)
+        this.$emit('change', params)
+      }
+    },
+    changeEvent (evnt) {
+      const { isDisabled } = this
+      if (!isDisabled) {
+        this.handleValue(this.label, evnt)
+      }
+    },
+    clickEvent (evnt) {
+      const { $xeradiogroup, isDisabled, isStrict } = this
+      if (!isDisabled && !isStrict) {
+        if (this.label === ($xeradiogroup ? $xeradiogroup.value : this.value)) {
+          this.handleValue(null, evnt)
+        }
+      }
+    }
+  }
+}

package/node_modules/vxe-table/packages/radio-button/index.d.ts

@@ -0,0 +1,4 @@
+import { RadioButton } from '../../types/radio-button'
+
+export * from '../../types/radio-button'
+export default RadioButton

package/node_modules/vxe-table/packages/radio-button/index.js

@@ -0,0 +1,9 @@
+import VxeRadioButton from '../radio/src/button'
+
+export const RadioButton = Object.assign(VxeRadioButton, {
+  install (Vue) {
+    Vue.component(VxeRadioButton.name, VxeRadioButton)
+  }
+})
+
+export default RadioButton

package/node_modules/vxe-table/packages/radio-group/index.d.ts

@@ -0,0 +1,4 @@
+import { RadioGroup } from '../../types/radio-group'
+
+export * from '../../types/radio-group'
+export default RadioGroup

package/node_modules/vxe-table/packages/radio-group/index.js

@@ -0,0 +1,9 @@
+import VxeRadioGroup from '../radio/src/group'
+
+export const RadioGroup = Object.assign(VxeRadioGroup, {
+  install (Vue) {
+    Vue.component(VxeRadioGroup.name, VxeRadioGroup)
+  }
+})
+
+export default RadioGroup

package/node_modules/vxe-table/packages/select/index.d.ts

@@ -0,0 +1,4 @@
+import { Select } from '../../types/select'
+
+export * from '../../types/select'
+export default Select

package/node_modules/vxe-table/packages/select/index.js

@@ -0,0 +1,15 @@
+import VxeSelect from './src/select'
+import VxeOption from './src/option'
+import VxeOptgroup from './src/optgroup'
+
+export const Select = Object.assign(VxeSelect, {
+  Option: VxeOption,
+  Optgroup: VxeOptgroup,
+  install (Vue) {
+    Vue.component(VxeSelect.name, VxeSelect)
+    Vue.component(VxeOption.name, VxeOption)
+    Vue.component(VxeOptgroup.name, VxeOptgroup)
+  }
+})
+
+export default Select

package/node_modules/vxe-table/packages/select/src/optgroup.js

@@ -0,0 +1,48 @@
+import { createOption, destroyOption, assemOption } from './util'
+
+const props = {
+  label: { type: [String, Number, Boolean], default: '' },
+  visible: { type: Boolean, default: null },
+  className: [String, Function],
+  disabled: Boolean
+}
+
+const watch = {}
+Object.keys(props).forEach(name => {
+  watch[name] = function (value) {
+    this.optionConfig.update(name, value)
+  }
+})
+
+export default {
+  name: 'VxeOptgroup',
+  props,
+  provide () {
+    return {
+      $xeoptgroup: this
+    }
+  },
+  inject: {
+    $xeselect: {
+      default: null
+    }
+  },
+  computed: {
+    vSize () {
+      return this.size || this.$parent.size || this.$parent.vSize
+    }
+  },
+  watch,
+  mounted () {
+    assemOption(this)
+  },
+  created () {
+    this.optionConfig = createOption(this.$xeselect, this)
+  },
+  destroyed () {
+    destroyOption(this)
+  },
+  render (h) {
+    return h('div', this.$slots.default)
+  }
+}

package/node_modules/vxe-table/packages/select/src/option.js

@@ -0,0 +1,42 @@
+import { createOption, destroyOption, assemOption } from './util'
+
+const props = {
+  value: null,
+  label: { type: [String, Number, Boolean], default: '' },
+  visible: { type: Boolean, default: null },
+  className: [String, Function],
+  disabled: Boolean
+}
+
+const watch = {}
+Object.keys(props).forEach(name => {
+  watch[name] = function (value) {
+    this.optionConfig.update(name, value)
+  }
+})
+
+export default {
+  name: 'VxeOption',
+  props,
+  inject: {
+    $xeselect: {
+      default: null
+    },
+    $xeoptgroup: {
+      default: null
+    }
+  },
+  watch,
+  mounted () {
+    assemOption(this)
+  },
+  created () {
+    this.optionConfig = createOption(this.$xeselect, this)
+  },
+  destroyed () {
+    destroyOption(this)
+  },
+  render (h) {
+    return h('div')
+  }
+}