{}}
+ />
+ )
+ },
+
+ renderRows (renderRows, rows, record, index, indent, fixed, parentKey, ancestorKeys) {
+ const { expandedRowClassName, expandedRowRender, childrenColumnName } = this
+ const childrenData = record[childrenColumnName]
+ const nextAncestorKeys = [...ancestorKeys, parentKey]
+ const nextIndent = indent + 1
+
+ if (expandedRowRender) {
+ rows.push(
+ this.renderExpandedRow(
+ record,
+ index,
+ expandedRowRender,
+ expandedRowClassName(record, index, indent),
+ nextAncestorKeys,
+ nextIndent,
+ fixed,
+ ),
+ )
+ }
+
+ if (childrenData) {
+ rows.push(
+ ...renderRows(
+ childrenData,
+ nextIndent,
+ nextAncestorKeys,
+ )
+ )
+ }
+ },
+ },
+
+ render () {
+ const { data, childrenColumnName, $scopedSlots, $listeners } = this
+ const props = getOptionProps(this)
+ const needIndentSpaced = data.some(record => record[childrenColumnName])
+
+ return $scopedSlots.default && $scopedSlots.default({
+ props,
+ on: $listeners,
+ needIndentSpaced,
+ renderRows: this.renderRows,
+ handleExpandChange: this.handleExpandChange,
+ renderExpandIndentCell: this.renderExpandIndentCell,
+ })
+ },
+}
+
+export default connect()(ExpandableTable)
diff --git a/components/vc-table/src/HeadTable.jsx b/components/vc-table/src/HeadTable.jsx
new file mode 100644
index 000000000..99c6468f0
--- /dev/null
+++ b/components/vc-table/src/HeadTable.jsx
@@ -0,0 +1,59 @@
+import PropTypes from '../../_util/vue-types'
+import { measureScrollbar } from './utils'
+import BaseTable from './BaseTable'
+
+export default {
+ name: 'HeadTable',
+ props: {
+ fixed: PropTypes.oneOfType([
+ PropTypes.string,
+ PropTypes.bool,
+ ]),
+ columns: PropTypes.array.isRequired,
+ tableClassName: PropTypes.string.isRequired,
+ handleBodyScrollLeft: PropTypes.func.isRequired,
+ expander: PropTypes.object.isRequired,
+ },
+ inject: {
+ table: { default: {}},
+ },
+ render () {
+ const { columns, fixed, tableClassName, handleBodyScrollLeft, expander, table } = this
+ const { prefixCls, scroll, showHeader } = table
+ let { useFixedHeader } = table
+ const headStyle = {}
+
+ if (scroll.y) {
+ useFixedHeader = true
+ // Add negative margin bottom for scroll bar overflow bug
+ const scrollbarWidth = measureScrollbar('horizontal')
+ if (scrollbarWidth > 0 && !fixed) {
+ headStyle.marginBottom = `-${scrollbarWidth}px`
+ headStyle.paddingBottom = '0px'
+ }
+ }
+
+ if (!useFixedHeader || !showHeader) {
+ return null
+ }
+ return (
+
+ )
+ },
+
+}
diff --git a/components/vc-table/src/Table.jsx b/components/vc-table/src/Table.jsx
new file mode 100644
index 000000000..84217873a
--- /dev/null
+++ b/components/vc-table/src/Table.jsx
@@ -0,0 +1,507 @@
+
+import PropTypes from '../../_util/vue-types'
+import { debounce, warningOnce } from './utils'
+import shallowequal from 'shallowequal'
+import addEventListener from '../../_util/Dom/addEventListener'
+import { Provider, create } from '../../_util/store'
+import merge from 'lodash/merge'
+import ColumnManager from './ColumnManager'
+import classes from 'component-classes'
+import HeadTable from './HeadTable'
+import BodyTable from './BodyTable'
+import ExpandableTable from './ExpandableTable'
+import { initDefaultProps, getOptionProps } from '../../_util/props-util'
+import BaseMixin from '../../_util/BaseMixin'
+
+export default {
+ name: 'Table',
+ mixins: [BaseMixin],
+ props: initDefaultProps({
+ data: PropTypes.array,
+ useFixedHeader: PropTypes.bool,
+ columns: PropTypes.array,
+ prefixCls: PropTypes.string,
+ bodyStyle: PropTypes.object,
+ rowKey: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+ rowClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+ // onRow: PropTypes.func,
+ // onHeaderRow: PropTypes.func,
+ // onRowClick: PropTypes.func,
+ // onRowDoubleClick: PropTypes.func,
+ // onRowContextMenu: PropTypes.func,
+ // onRowMouseEnter: PropTypes.func,
+ // onRowMouseLeave: PropTypes.func,
+ showHeader: PropTypes.bool,
+ title: PropTypes.func,
+ id: PropTypes.string,
+ footer: PropTypes.func,
+ emptyText: PropTypes.any,
+ scroll: PropTypes.object,
+ rowRef: PropTypes.func,
+ getBodyWrapper: PropTypes.func,
+ components: PropTypes.shape({
+ table: PropTypes.any,
+ header: PropTypes.shape({
+ wrapper: PropTypes.any,
+ row: PropTypes.any,
+ cell: PropTypes.any,
+ }),
+ body: PropTypes.shape({
+ wrapper: PropTypes.any,
+ row: PropTypes.any,
+ cell: PropTypes.any,
+ }),
+ }),
+ expandIconAsCell: PropTypes.bool,
+ expandedRowKeys: PropTypes.array,
+ expandedRowClassName: PropTypes.func,
+ defaultExpandAllRows: PropTypes.bool,
+ defaultExpandedRowKeys: PropTypes.array,
+ expandIconColumnIndex: PropTypes.number,
+ expandedRowRender: PropTypes.func,
+ childrenColumnName: PropTypes.string,
+ indentSize: PropTypes.number,
+ }, {
+ data: [],
+ useFixedHeader: false,
+ rowKey: 'key',
+ rowClassName: () => '',
+ prefixCls: 'rc-table',
+ bodyStyle: {},
+ showHeader: true,
+ scroll: {},
+ rowRef: () => null,
+ emptyText: () => 'No Data',
+ }),
+
+ // static childContextTypes = {
+ // table: PropTypes.any,
+ // components: PropTypes.any,
+ // },
+
+ created () {
+ [
+ 'rowClick',
+ 'rowDoubleclick',
+ 'rowContextmenu',
+ 'rowMouseenter',
+ 'rowMouseleave',
+ ].forEach(name => {
+ warningOnce(
+ this.$listeners[name] === undefined,
+ `${name} is deprecated, please use onRow instead.`,
+ )
+ })
+
+ warningOnce(
+ this.getBodyWrapper === undefined,
+ 'getBodyWrapper is deprecated, please use custom components instead.',
+ )
+
+ // this.columnManager = new ColumnManager(this.columns, this.$slots.default)
+
+ this.store = create({
+ currentHoverKey: null,
+ fixedColumnsHeadRowsHeight: [],
+ fixedColumnsBodyRowsHeight: [],
+ })
+
+ this.setScrollPosition('left')
+
+ this.debouncedWindowResize = debounce(this.handleWindowResize, 150)
+ },
+ data () {
+ this.preData = [...this.data]
+ return {
+ columnManager: new ColumnManager(this.columns, this.$slots.default),
+ sComponents: merge({
+ table: 'table',
+ header: {
+ wrapper: 'thead',
+ row: 'tr',
+ cell: 'th',
+ },
+ body: {
+ wrapper: 'tbody',
+ row: 'tr',
+ cell: 'td',
+ },
+ }, this.components),
+ }
+ },
+ provide () {
+ return {
+ table: this,
+ }
+ },
+ watch: {
+ components (val) {
+ this._components = merge({
+ table: 'table',
+ header: {
+ wrapper: 'thead',
+ row: 'tr',
+ cell: 'th',
+ },
+ body: {
+ wrapper: 'tbody',
+ row: 'tr',
+ cell: 'td',
+ },
+ }, this.components)
+ },
+ columns (val) {
+ if (val) {
+ this.columnManager.reset(val)
+ }
+ },
+ data (val) {
+ if (val.length === 0 && this.hasScrollX()) {
+ this.$nextTick(() => {
+ this.resetScrollX()
+ })
+ }
+ },
+ },
+
+ mounted () {
+ this.$nextTick(() => {
+ if (this.columnManager.isAnyColumnsFixed()) {
+ this.handleWindowResize()
+ this.resizeEvent = addEventListener(
+ window, 'resize', this.debouncedWindowResize
+ )
+ }
+ })
+ },
+
+ componentWillReceiveProps (nextProps) {
+ if (nextProps.columns && nextProps.columns !== this.props.columns) {
+ this.columnManager.reset(nextProps.columns)
+ } else if (nextProps.children !== this.props.children) {
+ this.columnManager.reset(null, nextProps.children)
+ }
+ },
+
+ updated (prevProps) {
+ if (this.columnManager.isAnyColumnsFixed()) {
+ this.handleWindowResize()
+ if (!this.resizeEvent) {
+ this.resizeEvent = addEventListener(
+ window, 'resize', this.debouncedWindowResize
+ )
+ }
+ }
+ },
+
+ beforeDestroy () {
+ if (this.resizeEvent) {
+ this.resizeEvent.remove()
+ }
+ if (this.debouncedWindowResize) {
+ this.debouncedWindowResize.cancel()
+ }
+ },
+ methods: {
+ getRowKey (record, index) {
+ const rowKey = this.rowKey
+ const key = (typeof rowKey === 'function')
+ ? rowKey(record, index) : record[rowKey]
+ warningOnce(
+ key !== undefined,
+ 'Each record in table should have a unique `key` prop,' +
+ 'or set `rowKey` to an unique primary key.'
+ )
+ return key === undefined ? index : key
+ },
+
+ setScrollPosition (position) {
+ this.scrollPosition = position
+ if (this.tableNode) {
+ const { prefixCls } = this
+ if (position === 'both') {
+ classes(this.tableNode)
+ .remove(new RegExp(`^${prefixCls}-scroll-position-.+$`))
+ .add(`${prefixCls}-scroll-position-left`)
+ .add(`${prefixCls}-scroll-position-right`)
+ } else {
+ classes(this.tableNode)
+ .remove(new RegExp(`^${prefixCls}-scroll-position-.+$`))
+ .add(`${prefixCls}-scroll-position-${position}`)
+ }
+ }
+ },
+
+ setScrollPositionClassName () {
+ const node = this.bodyTable
+ const scrollToLeft = node.scrollLeft === 0
+ const scrollToRight = node.scrollLeft + 1 >=
+ node.children[0].getBoundingClientRect().width -
+ node.getBoundingClientRect().width
+ if (scrollToLeft && scrollToRight) {
+ this.setScrollPosition('both')
+ } else if (scrollToLeft) {
+ this.setScrollPosition('left')
+ } else if (scrollToRight) {
+ this.setScrollPosition('right')
+ } else if (this.scrollPosition !== 'middle') {
+ this.setScrollPosition('middle')
+ }
+ },
+
+ handleWindowResize () {
+ this.syncFixedTableRowHeight()
+ this.setScrollPositionClassName()
+ },
+
+ syncFixedTableRowHeight () {
+ const tableRect = this.tableNode.getBoundingClientRect()
+ // If tableNode's height less than 0, suppose it is hidden and don't recalculate rowHeight.
+ // see: https://github.com/ant-design/ant-design/issues/4836
+ if (tableRect.height !== undefined && tableRect.height <= 0) {
+ return
+ }
+ const { prefixCls } = this.props
+ const headRows = this.headTable
+ ? this.headTable.querySelectorAll('thead')
+ : this.bodyTable.querySelectorAll('thead')
+ const bodyRows = this.bodyTable.querySelectorAll(`.${prefixCls}-row`) || []
+ const fixedColumnsHeadRowsHeight = [].map.call(
+ headRows, row => row.getBoundingClientRect().height || 'auto'
+ )
+ const fixedColumnsBodyRowsHeight = [].map.call(
+ bodyRows, row => row.getBoundingClientRect().height || 'auto'
+ )
+ const state = this.store.getState()
+ if (shallowequal(state.fixedColumnsHeadRowsHeight, fixedColumnsHeadRowsHeight) &&
+ shallowequal(state.fixedColumnsBodyRowsHeight, fixedColumnsBodyRowsHeight)) {
+ return
+ }
+
+ this.store.setState({
+ fixedColumnsHeadRowsHeight,
+ fixedColumnsBodyRowsHeight,
+ })
+ },
+
+ resetScrollX () {
+ if (this.headTable) {
+ this.headTable.scrollLeft = 0
+ }
+ if (this.bodyTable) {
+ this.bodyTable.scrollLeft = 0
+ }
+ },
+
+ hasScrollX () {
+ const { scroll = {}} = this
+ return 'x' in scroll
+ },
+
+ handleBodyScrollLeft (e) {
+ // Fix https://github.com/ant-design/ant-design/issues/7635
+ if (e.currentTarget !== e.target) {
+ return
+ }
+ const target = e.target
+ const { scroll = {}} = this
+ const { headTable, bodyTable } = this
+ if (target.scrollLeft !== this.lastScrollLeft && scroll.x) {
+ if (target === bodyTable && headTable) {
+ headTable.scrollLeft = target.scrollLeft
+ } else if (target === headTable && bodyTable) {
+ bodyTable.scrollLeft = target.scrollLeft
+ }
+ this.setScrollPositionClassName()
+ }
+ // Remember last scrollLeft for scroll direction detecting.
+ this.lastScrollLeft = target.scrollLeft
+ },
+
+ handleBodyScrollTop (e) {
+ const target = e.target
+ const { scroll = {}} = this
+ const { headTable, bodyTable, fixedColumnsBodyLeft, fixedColumnsBodyRight } = this
+ if (target.scrollTop !== this.lastScrollTop && scroll.y && target !== headTable) {
+ const scrollTop = target.scrollTop
+ if (fixedColumnsBodyLeft && target !== fixedColumnsBodyLeft) {
+ fixedColumnsBodyLeft.scrollTop = scrollTop
+ }
+ if (fixedColumnsBodyRight && target !== fixedColumnsBodyRight) {
+ fixedColumnsBodyRight.scrollTop = scrollTop
+ }
+ if (bodyTable && target !== bodyTable) {
+ bodyTable.scrollTop = scrollTop
+ }
+ }
+ // Remember last scrollTop for scroll direction detecting.
+ this.lastScrollTop = target.scrollTop
+ },
+
+ handleBodyScroll (e) {
+ this.handleBodyScrollLeft(e)
+ this.handleBodyScrollTop(e)
+ },
+
+ renderMainTable () {
+ const { scroll, prefixCls } = this
+ const isAnyColumnsFixed = this.columnManager.isAnyColumnsFixed()
+ const scrollable = isAnyColumnsFixed || scroll.x || scroll.y
+
+ const table = [
+ this.renderTable({
+ columns: this.columnManager.groupedColumns(),
+ isAnyColumnsFixed,
+ }),
+ this.renderEmptyText(),
+ this.renderFooter(),
+ ]
+
+ return scrollable ? (
+ {table}
+ ) : table
+ },
+
+ renderLeftFixedTable () {
+ const { prefixCls } = this
+
+ return (
+
+ {this.renderTable({
+ columns: this.columnManager.leftColumns(),
+ fixed: 'left',
+ })}
+
+ )
+ },
+ renderRightFixedTable () {
+ const { prefixCls } = this
+
+ return (
+
+ {this.renderTable({
+ columns: this.columnManager.rightColumns(),
+ fixed: 'right',
+ })}
+
+ )
+ },
+
+ renderTable (options) {
+ const { columns, fixed, isAnyColumnsFixed } = options
+ const { prefixCls, scroll = {}} = this
+ const tableClassName = (scroll.x || fixed) ? `${prefixCls}-fixed` : ''
+
+ const headTable = (
+
+ )
+
+ const bodyTable = (
+
+ )
+
+ return [headTable, bodyTable]
+ },
+
+ renderTitle () {
+ const { title, prefixCls } = this
+ return title ? (
+
+ {title(this.props.data)}
+
+ ) : null
+ },
+
+ renderFooter () {
+ const { footer, prefixCls } = this
+ return footer ? (
+
+ ) : null
+ },
+
+ renderEmptyText () {
+ const { emptyText, prefixCls, data } = this
+ if (data.length) {
+ return null
+ }
+ const emptyClassName = `${prefixCls}-placeholder`
+ return (
+
+ {(typeof emptyText === 'function') ? emptyText() : emptyText}
+
+ )
+ },
+ },
+
+ render () {
+ const props = getOptionProps(this)
+ const { $listeners, columnManager, getRowKey } = this
+ const prefixCls = props.prefixCls
+
+ let className = props.prefixCls
+ if (props.useFixedHeader || (props.scroll && props.scroll.y)) {
+ className += ` ${prefixCls}-fixed-header`
+ }
+ if (this.scrollPosition === 'both') {
+ className += ` ${prefixCls}-scroll-position-left ${prefixCls}-scroll-position-right`
+ } else {
+ className += ` ${prefixCls}-scroll-position-${this.scrollPosition}`
+ }
+ const hasLeftFixed = columnManager.isAnyColumnsLeftFixed()
+ const hasRightFixed = columnManager.isAnyColumnsRightFixed()
+
+ const expandableTableProps = {
+ props: {
+ ...props,
+ columnManager,
+ getRowKey,
+ },
+ on: { ...$listeners },
+ scopedSlots: {
+ default: (expander) => {
+ this.expander = expander
+ return (
+
+ {this.renderTitle()}
+
+ {this.renderMainTable()}
+ {hasLeftFixed && this.renderLeftFixedTable()}
+ {hasRightFixed && this.renderRightFixedTable()}
+
+
+
simple
+ {/*
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ */}
+
+ Check on Click TreeNode
+
+
+
+
+
+
+
+ {this.showMore ?
+
+
+ : null}
+
+
+ )
+ },
+}
+
diff --git a/components/vc-tree/demo/basic.less b/components/vc-tree/demo/basic.less
new file mode 100644
index 000000000..cca0a1860
--- /dev/null
+++ b/components/vc-tree/demo/basic.less
@@ -0,0 +1,6 @@
+.rc-tree li a.rc-tree-node-selected{
+ .cus-label {
+ background-color: white;
+ border: none;
+ }
+}
diff --git a/components/vc-tree/index.js b/components/vc-tree/index.js
new file mode 100644
index 000000000..8f31b413f
--- /dev/null
+++ b/components/vc-tree/index.js
@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./src/')
diff --git a/components/vc-tree/src/Tree.jsx b/components/vc-tree/src/Tree.jsx
new file mode 100644
index 000000000..6c042a530
--- /dev/null
+++ b/components/vc-tree/src/Tree.jsx
@@ -0,0 +1,602 @@
+import PropTypes from '../../_util/vue-types'
+import classNames from 'classnames'
+import warning from 'warning'
+import { initDefaultProps, getOptionProps } from '../../_util/props-util'
+import { cloneElement } from '../../_util/vnode'
+import BaseMixin from '../../_util/BaseMixin'
+import {
+ traverseTreeNodes, getStrictlyValue,
+ getFullKeyList, getPosition, getDragNodesKeys,
+ calcExpandedKeys, calcSelectedKeys,
+ calcCheckedKeys, calcDropPosition,
+ arrAdd, arrDel, posToArr,
+} from './util'
+
+/**
+ * Thought we still use `cloneElement` to pass `key`,
+ * other props can pass with context for future refactor.
+ */
+export const contextTypes = {
+ rcTree: PropTypes.shape({
+ root: PropTypes.object,
+
+ prefixCls: PropTypes.string,
+ selectable: PropTypes.bool,
+ showIcon: PropTypes.bool,
+ draggable: PropTypes.bool,
+ checkable: PropTypes.oneOfType([
+ PropTypes.bool,
+ PropTypes.object,
+ ]),
+ checkStrictly: PropTypes.bool,
+ disabled: PropTypes.bool,
+ openTransitionName: PropTypes.string,
+ openAnimation: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
+
+ loadData: PropTypes.func,
+ filterTreeNode: PropTypes.func,
+ renderTreeNode: PropTypes.func,
+
+ isKeyChecked: PropTypes.func,
+
+ // onNodeExpand: PropTypes.func,
+ // onNodeSelect: PropTypes.func,
+ // onNodeMouseEnter: PropTypes.func,
+ // onNodeMouseLeave: PropTypes.func,
+ // onNodeContextMenu: PropTypes.func,
+ // onNodeDragStart: PropTypes.func,
+ // onNodeDragEnter: PropTypes.func,
+ // onNodeDragOver: PropTypes.func,
+ // onNodeDragLeave: PropTypes.func,
+ // onNodeDragEnd: PropTypes.func,
+ // onNodeDrop: PropTypes.func,
+ // onBatchNodeCheck: PropTypes.func,
+ // onCheckConductFinished: PropTypes.func,
+ }),
+}
+
+const Tree = {
+ name: 'Tree',
+ mixins: [BaseMixin],
+ props: initDefaultProps({
+ prefixCls: PropTypes.string,
+ showLine: PropTypes.bool,
+ showIcon: PropTypes.bool,
+ focusable: PropTypes.bool,
+ selectable: PropTypes.bool,
+ disabled: PropTypes.bool,
+ multiple: PropTypes.bool,
+ checkable: PropTypes.oneOfType([
+ PropTypes.bool,
+ PropTypes.node,
+ ]),
+ checkStrictly: PropTypes.bool,
+ draggable: PropTypes.bool,
+ autoExpandParent: PropTypes.bool,
+ defaultExpandAll: PropTypes.bool,
+ defaultExpandedKeys: PropTypes.arrayOf(PropTypes.string),
+ expandedKeys: PropTypes.arrayOf(PropTypes.string),
+ defaultCheckedKeys: PropTypes.arrayOf(PropTypes.string),
+ checkedKeys: PropTypes.oneOfType([
+ PropTypes.arrayOf(PropTypes.string),
+ PropTypes.object,
+ ]),
+ defaultSelectedKeys: PropTypes.arrayOf(PropTypes.string),
+ selectedKeys: PropTypes.arrayOf(PropTypes.string),
+ // onExpand: PropTypes.func,
+ // onCheck: PropTypes.func,
+ // onSelect: PropTypes.func,
+ loadData: PropTypes.func,
+ // onMouseEnter: PropTypes.func,
+ // onMouseLeave: PropTypes.func,
+ // onRightClick: PropTypes.func,
+ // onDragStart: PropTypes.func,
+ // onDragEnter: PropTypes.func,
+ // onDragOver: PropTypes.func,
+ // onDragLeave: PropTypes.func,
+ // onDragEnd: PropTypes.func,
+ // onDrop: PropTypes.func,
+ filterTreeNode: PropTypes.func,
+ openTransitionName: PropTypes.string,
+ openAnimation: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
+ children: PropTypes.any,
+ }, {
+ prefixCls: 'rc-tree',
+ showLine: false,
+ showIcon: true,
+ selectable: true,
+ multiple: false,
+ checkable: false,
+ disabled: false,
+ checkStrictly: false,
+ draggable: false,
+ autoExpandParent: true,
+ defaultExpandAll: false,
+ defaultExpandedKeys: [],
+ defaultCheckedKeys: [],
+ defaultSelectedKeys: [],
+ }),
+
+ // static childContextTypes = contextTypes;
+
+ data () {
+ const props = getOptionProps(this)
+ const {
+ defaultExpandAll,
+ defaultExpandedKeys,
+ defaultCheckedKeys,
+ defaultSelectedKeys,
+ } = props
+ const children = this.$slots.default
+ // Sync state with props
+ const { checkedKeys = [], halfCheckedKeys = [] } =
+ calcCheckedKeys(defaultCheckedKeys, props, children) || {}
+
+ // Cache for check status to optimize
+ this.checkedBatch = null
+ this.propsToStateMap = {
+ expandedKeys: 'sExpandedKeys',
+ selectedKeys: 'sSelectedKeys',
+ checkedKeys: 'sCheckedKeys',
+ halfCheckedKeys: 'sHalfCheckedKeys',
+ }
+ return {
+ sExpandedKeys: defaultExpandAll
+ ? getFullKeyList(children)
+ : calcExpandedKeys(defaultExpandedKeys, props, children),
+ sSelectedKeys: calcSelectedKeys(defaultSelectedKeys, props, children),
+ sCheckedKeys: checkedKeys,
+ sHalfCheckedKeys: halfCheckedKeys,
+
+ ...(this.getSyncProps(props) || {}),
+ dragOverNodeKey: '',
+ dropPosition: null,
+ }
+ },
+ provide () {
+ return {
+ vcTree: this,
+ }
+ },
+
+ watch: {
+ children (val) {
+ const { checkedKeys = [], halfCheckedKeys = [] } = calcCheckedKeys(this.checkedKeys || this.sCheckedKeys, this.$props, this.$slots.default) || {}
+ this.sCheckedKeys = checkedKeys
+ this.sHalfCheckedKeys = halfCheckedKeys
+ },
+ expandedKeys (val) {
+ this.sExpandedKeys = calcExpandedKeys(this.expandedKeys, this.$props, this.$slots.default)
+ },
+ selectedKeys (val) {
+ this.sSelectedKeys = calcSelectedKeys(this.selectedKeys, this.$props, this.$slots.default)
+ },
+ checkedKeys (val) {
+ const { checkedKeys = [], halfCheckedKeys = [] } = calcCheckedKeys(this.checkedKeys, this.$props, this.$slots.default) || {}
+ this.sCheckedKeys = checkedKeys
+ this.sHalfCheckedKeys = halfCheckedKeys
+ },
+ },
+
+ // componentWillReceiveProps (nextProps) {
+ // // React 16 will not trigger update if new state is null
+ // this.setState(this.getSyncProps(nextProps, this.props))
+ // },
+
+ methods: {
+ onNodeDragStart (event, node) {
+ const { sExpandedKeys } = this
+ const { eventKey, children } = node.props
+
+ this.dragNode = node
+
+ this.setState({
+ dragNodesKeys: getDragNodesKeys(children, node),
+ sExpandedKeys: arrDel(sExpandedKeys, eventKey),
+ })
+ this.__emit('dragstart', { event, node })
+ },
+
+ /**
+ * [Legacy] Select handler is less small than node,
+ * so that this will trigger when drag enter node or select handler.
+ * This is a little tricky if customize css without padding.
+ * Better for use mouse move event to refresh drag state.
+ * But let's just keep it to avoid event trigger logic change.
+ */
+ onNodeDragEnter (event, node) {
+ const { sExpandedKeys } = this
+ const { pos, eventKey } = node.props
+
+ const dropPosition = calcDropPosition(event, node)
+
+ // Skip if drag node is self
+ if (
+ this.dragNode.props.eventKey === eventKey &&
+ dropPosition === 0
+ ) {
+ this.setState({
+ dragOverNodeKey: '',
+ dropPosition: null,
+ })
+ return
+ }
+
+ // Ref: https://github.com/react-component/tree/issues/132
+ // Add timeout to let onDragLevel fire before onDragEnter,
+ // so that we can clean drag props for onDragLeave node.
+ // Macro task for this:
+ // https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script
+ setTimeout(() => {
+ // Update drag over node
+ this.setState({
+ dragOverNodeKey: eventKey,
+ dropPosition,
+ })
+
+ // Side effect for delay drag
+ if (!this.delayedDragEnterLogic) {
+ this.delayedDragEnterLogic = {}
+ }
+ Object.keys(this.delayedDragEnterLogic).forEach((key) => {
+ clearTimeout(this.delayedDragEnterLogic[key])
+ })
+ this.delayedDragEnterLogic[pos] = setTimeout(() => {
+ const newExpandedKeys = arrAdd(sExpandedKeys, eventKey)
+ this.setState({
+ sExpandedKeys: newExpandedKeys,
+ })
+ this.__emit('dragenter', { event, node, expandedKeys: newExpandedKeys })
+ }, 400)
+ }, 0)
+ },
+ onNodeDragOver (event, node) {
+ this.__emit('dragover', { event, node })
+ },
+ onNodeDragLeave (event, node) {
+ this.setState({
+ dragOverNodeKey: '',
+ })
+ this.__emit('dragleave', { event, node })
+ },
+ onNodeDragEnd (event, node) {
+ this.setState({
+ dragOverNodeKey: '',
+ })
+ this.__emit('dragend', { event, node })
+ },
+ onNodeDrop (event, node) {
+ const { dragNodesKeys, dropPosition } = this
+
+ const { eventKey, pos } = node.props
+
+ this.setState({
+ dragOverNodeKey: '',
+ dropNodeKey: eventKey,
+ })
+
+ if (dragNodesKeys.indexOf(eventKey) !== -1) {
+ warning(false, 'Can not drop to dragNode(include it\'s children node)')
+ return
+ }
+
+ const posArr = posToArr(pos)
+
+ const dropResult = {
+ event,
+ node,
+ dragNode: this.dragNode,
+ dragNodesKeys: dragNodesKeys.slice(),
+ dropPosition: dropPosition + Number(posArr[posArr.length - 1]),
+ }
+
+ if (dropPosition !== 0) {
+ dropResult.dropToGap = true
+ }
+ this.__emit('drop', dropResult)
+ },
+
+ onNodeSelect (e, treeNode) {
+ const { sSelectedKeys, multiple, $slots: { default: children }} = this
+ const { selected, eventKey } = getOptionProps(treeNode)
+ const targetSelected = !selected
+ let selectedKeys = sSelectedKeys
+ // Update selected keys
+ if (!targetSelected) {
+ selectedKeys = arrDel(selectedKeys, eventKey)
+ } else if (!multiple) {
+ selectedKeys = [eventKey]
+ } else {
+ selectedKeys = arrAdd(selectedKeys, eventKey)
+ }
+
+ // [Legacy] Not found related usage in doc or upper libs
+ // [Legacy] TODO: add optimize prop to skip node process
+ const selectedNodes = []
+ if (selectedKeys.length) {
+ traverseTreeNodes(children, ({ node, key }) => {
+ if (selectedKeys.indexOf(key) !== -1) {
+ selectedNodes.push(node)
+ }
+ })
+ }
+
+ this.setUncontrolledState({ selectedKeys })
+
+ const eventObj = {
+ event: 'select',
+ selected: targetSelected,
+ node: treeNode,
+ selectedNodes,
+ }
+ this.__emit('select', selectedKeys, eventObj)
+ },
+
+ /**
+ * This will cache node check status to optimize update process.
+ * When Tree get trigger `onCheckConductFinished` will flush all the update.
+ */
+ onBatchNodeCheck (key, checked, halfChecked, startNode) {
+ if (startNode) {
+ this.checkedBatch = {
+ treeNode: startNode,
+ checked,
+ list: [],
+ }
+ }
+
+ // This code should never called
+ if (!this.checkedBatch) {
+ this.checkedBatch = {
+ list: [],
+ }
+ warning(
+ false,
+ 'Checked batch not init. This should be a bug. Please fire a issue.'
+ )
+ }
+
+ this.checkedBatch.list.push({ key, checked, halfChecked })
+ },
+
+ /**
+ * When top `onCheckConductFinished` called, will execute all batch update.
+ * And trigger `onCheck` event.
+ */
+ onCheckConductFinished () {
+ const { sCheckedKeys, sHalfCheckedKeys, checkStrictly, $slots: { default: children }} = this
+
+ // Use map to optimize update speed
+ const checkedKeySet = {}
+ const halfCheckedKeySet = {}
+
+ sCheckedKeys.forEach(key => {
+ checkedKeySet[key] = true
+ })
+ sHalfCheckedKeys.forEach(key => {
+ halfCheckedKeySet[key] = true
+ })
+
+ // Batch process
+ this.checkedBatch.list.forEach(({ key, checked, halfChecked }) => {
+ checkedKeySet[key] = checked
+ halfCheckedKeySet[key] = halfChecked
+ })
+ const newCheckedKeys = Object.keys(checkedKeySet).filter(key => checkedKeySet[key])
+ const newHalfCheckedKeys = Object.keys(halfCheckedKeySet).filter(key => halfCheckedKeySet[key])
+
+ // Trigger onChecked
+ let selectedObj
+
+ const eventObj = {
+ event: 'check',
+ node: this.checkedBatch.treeNode,
+ checked: this.checkedBatch.checked,
+ }
+
+ if (checkStrictly) {
+ selectedObj = getStrictlyValue(newCheckedKeys, newHalfCheckedKeys)
+
+ // [Legacy] TODO: add optimize prop to skip node process
+ eventObj.checkedNodes = []
+ traverseTreeNodes(children, ({ node, key }) => {
+ if (checkedKeySet[key]) {
+ eventObj.checkedNodes.push(node)
+ }
+ })
+
+ this.setUncontrolledState({ checkedKeys: newCheckedKeys })
+ } else {
+ selectedObj = newCheckedKeys
+
+ // [Legacy] TODO: add optimize prop to skip node process
+ eventObj.checkedNodes = []
+ eventObj.checkedNodesPositions = [] // [Legacy] TODO: not in API
+ eventObj.halfCheckedKeys = newHalfCheckedKeys // [Legacy] TODO: not in API
+ traverseTreeNodes(children, ({ node, pos, key }) => {
+ if (checkedKeySet[key]) {
+ eventObj.checkedNodes.push(node)
+ eventObj.checkedNodesPositions.push({ node, pos })
+ }
+ })
+
+ this.setUncontrolledState({
+ checkedKeys: newCheckedKeys,
+ halfCheckedKeys: newHalfCheckedKeys,
+ })
+ }
+ this.__emit('check', selectedObj, eventObj)
+
+ // Clean up
+ this.checkedBatch = null
+ },
+
+ onNodeExpand (e, treeNode) {
+ const { sExpandedKeys, loadData } = this
+ let expandedKeys = [...sExpandedKeys]
+ const { eventKey, expanded } = getOptionProps(treeNode)
+
+ // Update selected keys
+ const index = expandedKeys.indexOf(eventKey)
+ const targetExpanded = !expanded
+
+ warning(
+ (expanded && index !== -1) || (!expanded && index === -1)
+ , 'Expand state not sync with index check')
+
+ if (targetExpanded) {
+ expandedKeys = arrAdd(expandedKeys, eventKey)
+ } else {
+ expandedKeys = arrDel(expandedKeys, eventKey)
+ }
+
+ this.setUncontrolledState({ expandedKeys })
+ this.__emit('expand', expandedKeys, { node: treeNode, expanded: targetExpanded })
+
+ // Async Load data
+ if (targetExpanded && loadData) {
+ return loadData(treeNode).then(() => {
+ // [Legacy] Refresh logic
+ this.setUncontrolledState({ expandedKeys })
+ })
+ }
+
+ return null
+ },
+
+ onNodeMouseEnter (event, node) {
+ this.__emit('mouseenter', { event, node })
+ },
+
+ onNodeMouseLeave (event, node) {
+ this.__emit('mouseleave', { event, node })
+ },
+
+ onNodeContextMenu (event, node) {
+ event.preventDefault()
+ this.__emit('rightClick', { event, node })
+ },
+
+ /**
+ * Sync state with props if needed
+ */
+ getSyncProps (props = {}, prevProps) {
+ let needSync = false
+ const newState = {}
+ const myPrevProps = prevProps || {}
+ const children = this.$slots.default
+ function checkSync (name) {
+ if (props[name] !== myPrevProps[name]) {
+ needSync = true
+ return true
+ }
+ return false
+ }
+
+ // Children change will affect check box status.
+ // And no need to check when prev props not provided
+ if (prevProps && checkSync('children')) {
+ const { checkedKeys = [], halfCheckedKeys = [] } =
+ calcCheckedKeys(props.checkedKeys || this.sCheckedKeys, props, children) || {}
+ newState.sCheckedKeys = checkedKeys
+ newState.sHalfCheckedKeys = halfCheckedKeys
+ }
+
+ if (checkSync('expandedKeys')) {
+ newState.sExpandedKeys = calcExpandedKeys(props.expandedKeys, props, children)
+ }
+
+ if (checkSync('selectedKeys')) {
+ newState.sSelectedKeys = calcSelectedKeys(props.selectedKeys, props, children)
+ }
+
+ if (checkSync('checkedKeys')) {
+ const { checkedKeys = [], halfCheckedKeys = [] } =
+ calcCheckedKeys(props.checkedKeys, props, children) || {}
+ newState.sCheckedKeys = checkedKeys
+ newState.sHalfCheckedKeys = halfCheckedKeys
+ }
+
+ return needSync ? newState : null
+ },
+
+ /**
+ * Only update the value which is not in props
+ */
+ setUncontrolledState (state) {
+ let needSync = false
+ const newState = {}
+ const props = getOptionProps(this)
+ Object.keys(state).forEach(name => {
+ if (name in props) return
+
+ needSync = true
+ const key = this.propsToStateMap[name]
+ newState[key] = state[name]
+ })
+
+ this.setState(needSync ? newState : null)
+ },
+
+ isKeyChecked (key) {
+ const { sCheckedKeys = [] } = this
+ return sCheckedKeys.indexOf(key) !== -1
+ },
+
+ /**
+ * [Legacy] Original logic use `key` as tracking clue.
+ * We have to use `cloneElement` to pass `key`.
+ */
+ renderTreeNode (child, index, level = 0) {
+ const {
+ sExpandedKeys = [], sSelectedKeys = [], sHalfCheckedKeys = [],
+ dragOverNodeKey, dropPosition,
+ } = this
+ const pos = getPosition(level, index)
+ const key = child.key || pos
+
+ return cloneElement(child, {
+ props: {
+ eventKey: key,
+ expanded: sExpandedKeys.indexOf(key) !== -1,
+ selected: sSelectedKeys.indexOf(key) !== -1,
+ checked: this.isKeyChecked(key),
+ halfChecked: sHalfCheckedKeys.indexOf(key) !== -1,
+ pos,
+
+ // [Legacy] Drag props
+ dragOver: dragOverNodeKey === key && dropPosition === 0,
+ dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+ dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1,
+ },
+
+ })
+ },
+ },
+
+ render () {
+ const {
+ prefixCls, focusable,
+ showLine,
+ $slots: { default: children = [] },
+ } = this
+ const domProps = {}
+
+ return (
+ {}}
+ >
+ {children.map(this.renderTreeNode)}
+
+ )
+ },
+}
+
+export default Tree
diff --git a/components/vc-tree/src/TreeNode.jsx b/components/vc-tree/src/TreeNode.jsx
new file mode 100644
index 000000000..fb5ce8a86
--- /dev/null
+++ b/components/vc-tree/src/TreeNode.jsx
@@ -0,0 +1,589 @@
+import PropTypes from '../../_util/vue-types'
+import classNames from 'classnames'
+import warning from 'warning'
+import { contextTypes } from './Tree'
+import { getPosition, getNodeChildren, isCheckDisabled, traverseTreeNodes } from './util'
+import { initDefaultProps, getOptionProps, filterEmpty } from '../../_util/props-util'
+import BaseMixin from '../../_util/BaseMixin'
+import getTransitionProps from '../../_util/getTransitionProps'
+
+const ICON_OPEN = 'open'
+const ICON_CLOSE = 'close'
+
+const LOAD_STATUS_NONE = 0
+const LOAD_STATUS_LOADING = 1
+const LOAD_STATUS_LOADED = 2
+const LOAD_STATUS_FAILED = 0 // Action align, let's make failed same as init.
+
+const defaultTitle = '---'
+
+let onlyTreeNodeWarned = false // Only accept TreeNode
+
+export const nodeContextTypes = {
+ ...contextTypes,
+ vcTreeNode: PropTypes.shape({
+ onUpCheckConduct: PropTypes.func,
+ }),
+}
+
+const TreeNode = {
+ name: 'TreeNode',
+ mixins: [BaseMixin],
+ props: initDefaultProps({
+ eventKey: PropTypes.string, // Pass by parent `cloneElement`
+ prefixCls: PropTypes.string,
+ // className: PropTypes.string,
+ root: PropTypes.object,
+ // onSelect: PropTypes.func,
+
+ // By parent
+ expanded: PropTypes.bool,
+ selected: PropTypes.bool,
+ checked: PropTypes.bool,
+ halfChecked: PropTypes.bool,
+ title: PropTypes.any,
+ pos: PropTypes.string,
+ dragOver: PropTypes.bool,
+ dragOverGapTop: PropTypes.bool,
+ dragOverGapBottom: PropTypes.bool,
+
+ // By user
+ isLeaf: PropTypes.bool,
+ selectable: PropTypes.bool,
+ disabled: PropTypes.bool,
+ disableCheckbox: PropTypes.bool,
+ icon: PropTypes.any,
+ }, {
+ title: defaultTitle,
+ }),
+
+ data () {
+ return {
+ loadStatus: LOAD_STATUS_NONE,
+ dragNodeHighlight: false,
+ }
+ },
+ inject: {
+ vcTree: { default: {}},
+ },
+ provide () {
+ return {
+ vcTree: this.vcTree,
+ vcTreeNode: this,
+ }
+ },
+
+ // Isomorphic needn't load data in server side
+ mounted () {
+ this.syncLoadData(this.$props)
+ },
+ watch: {
+ expanded (val) {
+ this.syncLoadData({ expanded: val })
+ },
+ },
+
+ methods: {
+ onUpCheckConduct (treeNode, nodeChecked, nodeHalfChecked) {
+ const { pos: nodePos } = getOptionProps(treeNode)
+ const { eventKey, pos, checked, halfChecked } = this
+ const {
+ vcTree: { checkStrictly, isKeyChecked, onBatchNodeCheck, onCheckConductFinished },
+ vcTreeNode: { onUpCheckConduct } = {},
+ } = this
+
+ // Stop conduct when current node is disabled
+ if (isCheckDisabled(this)) {
+ onCheckConductFinished()
+ return
+ }
+
+ const children = this.getNodeChildren()
+
+ let checkedCount = nodeChecked ? 1 : 0
+
+ // Statistic checked count
+ children.forEach((node, index) => {
+ const childPos = getPosition(pos, index)
+
+ if (nodePos === childPos || isCheckDisabled(node)) {
+ return
+ }
+ if (isKeyChecked(node.key || childPos)) {
+ checkedCount += 1
+ }
+ })
+
+ // Static enabled children count
+ const enabledChildrenCount = children
+ .filter(node => !isCheckDisabled(node))
+ .length
+
+ // checkStrictly will not conduct check status
+ const nextChecked = checkStrictly ? checked : enabledChildrenCount === checkedCount
+ const nextHalfChecked = checkStrictly // propagated or child checked
+ ? halfChecked : (nodeHalfChecked || (checkedCount > 0 && !nextChecked))
+
+ // Add into batch update
+ if (checked !== nextChecked || halfChecked !== nextHalfChecked) {
+ onBatchNodeCheck(eventKey, nextChecked, nextHalfChecked)
+
+ if (onUpCheckConduct) {
+ onUpCheckConduct(this, nextChecked, nextHalfChecked)
+ } else {
+ // Flush all the update
+ onCheckConductFinished()
+ }
+ } else {
+ // Flush all the update
+ onCheckConductFinished()
+ }
+ },
+
+ onDownCheckConduct (nodeChecked) {
+ const { $slots } = this
+ const children = $slots.default || []
+ const { vcTree: { checkStrictly, isKeyChecked, onBatchNodeCheck }} = this
+ if (checkStrictly) return
+
+ traverseTreeNodes(children, ({ node, key }) => {
+ if (isCheckDisabled(node)) return false
+
+ if (nodeChecked !== isKeyChecked(key)) {
+ onBatchNodeCheck(key, nodeChecked, false)
+ }
+ })
+ },
+
+ onSelectorClick (e) {
+ if (this.isSelectable()) {
+ this.onSelect(e)
+ } else {
+ this.onCheck(e)
+ }
+ },
+
+ onSelect (e) {
+ if (this.isDisabled()) return
+
+ const { vcTree: { onNodeSelect }} = this
+ e.preventDefault()
+ onNodeSelect(e, this)
+ },
+
+ onCheck (e) {
+ if (this.isDisabled()) return
+
+ const { disableCheckbox, checked, eventKey } = this
+ const {
+ vcTree: { checkable, onBatchNodeCheck, onCheckConductFinished },
+ vcTreeNode: { onUpCheckConduct } = {},
+ } = this
+
+ if (!checkable || disableCheckbox) return
+
+ e.preventDefault()
+ const targetChecked = !checked
+ onBatchNodeCheck(eventKey, targetChecked, false, this)
+
+ // Children conduct
+ this.onDownCheckConduct(targetChecked)
+
+ // Parent conduct
+ if (onUpCheckConduct) {
+ onUpCheckConduct(this, targetChecked, false)
+ } else {
+ onCheckConductFinished()
+ }
+ },
+
+ onMouseEnter (e) {
+ const { vcTree: { onNodeMouseEnter }} = this
+ onNodeMouseEnter(e, this)
+ },
+
+ onMouseLeave (e) {
+ const { vcTree: { onNodeMouseLeave }} = this
+ onNodeMouseLeave(e, this)
+ },
+
+ onContextMenu (e) {
+ const { vcTree: { onNodeContextMenu }} = this
+ onNodeContextMenu(e, this)
+ },
+
+ onDragStart (e) {
+ const { vcTree: { onNodeDragStart }} = this
+
+ e.stopPropagation()
+ this.setState({
+ dragNodeHighlight: true,
+ })
+ onNodeDragStart(e, this)
+
+ try {
+ // ie throw error
+ // firefox-need-it
+ e.dataTransfer.setData('text/plain', '')
+ } catch (error) {
+ // empty
+ }
+ },
+
+ onDragEnter (e) {
+ const { vcTree: { onNodeDragEnter }} = this
+
+ e.preventDefault()
+ e.stopPropagation()
+ onNodeDragEnter(e, this)
+ },
+
+ onDragOver (e) {
+ const { vcTree: { onNodeDragOver }} = this
+
+ e.preventDefault()
+ e.stopPropagation()
+ onNodeDragOver(e, this)
+ },
+
+ onDragLeave (e) {
+ const { vcTree: { onNodeDragLeave }} = this
+
+ e.stopPropagation()
+ onNodeDragLeave(e, this)
+ },
+
+ onDragEnd (e) {
+ const { vcTree: { onNodeDragEnd }} = this
+
+ e.stopPropagation()
+ this.setState({
+ dragNodeHighlight: false,
+ })
+ onNodeDragEnd(e, this)
+ },
+
+ onDrop (e) {
+ const { vcTree: { onNodeDrop }} = this
+
+ e.preventDefault()
+ e.stopPropagation()
+ this.setState({
+ dragNodeHighlight: false,
+ })
+ onNodeDrop(e, this)
+ },
+
+ // Disabled item still can be switch
+ onExpand (e) {
+ const { vcTree: { onNodeExpand }} = this
+ const callbackPromise = onNodeExpand(e, this)
+
+ // Promise like
+ if (callbackPromise && callbackPromise.then) {
+ this.setState({ loadStatus: LOAD_STATUS_LOADING })
+
+ callbackPromise.then(() => {
+ this.setState({ loadStatus: LOAD_STATUS_LOADED })
+ }).catch(() => {
+ this.setState({ loadStatus: LOAD_STATUS_FAILED })
+ })
+ }
+ },
+
+ // Drag usage
+ setSelectHandle (node) {
+ this.selectHandle = node
+ },
+
+ getNodeChildren () {
+ const { $slots: { default: children }} = this
+ const originList = filterEmpty(children)
+ const targetList = getNodeChildren(originList)
+
+ if (originList.length !== targetList.length && !onlyTreeNodeWarned) {
+ onlyTreeNodeWarned = true
+ warning(false, 'Tree only accept TreeNode as children.')
+ }
+
+ return targetList
+ },
+
+ getNodeState () {
+ const { expanded } = this
+
+ if (this.isLeaf2()) {
+ return null
+ }
+
+ return expanded ? ICON_OPEN : ICON_CLOSE
+ },
+
+ isLeaf2 () {
+ const { isLeaf, loadStatus } = this
+ const { vcTree: { loadData }} = this
+
+ const hasChildren = this.getNodeChildren().length !== 0
+
+ return (
+ isLeaf ||
+ (!loadData && !hasChildren) ||
+ (loadData && loadStatus === LOAD_STATUS_LOADED && !hasChildren)
+ )
+ },
+
+ isDisabled () {
+ const { disabled } = this
+ const { vcTree: { disabled: treeDisabled }} = this
+
+ // Follow the logic of Selectable
+ if (disabled === false) {
+ return false
+ }
+
+ return !!(treeDisabled || disabled)
+ },
+
+ isSelectable () {
+ const { selectable } = this
+ const { vcTree: { selectable: treeSelectable }} = this
+
+ // Ignore when selectable is undefined or null
+ if (typeof selectable === 'boolean') {
+ return selectable
+ }
+
+ return treeSelectable
+ },
+
+ // Load data to avoid default expanded tree without data
+ syncLoadData (props) {
+ const { loadStatus } = this
+ const { expanded } = props
+ const { vcTree: { loadData }} = this
+
+ if (loadData && loadStatus === LOAD_STATUS_NONE && expanded && !this.isLeaf2()) {
+ this.setState({ loadStatus: LOAD_STATUS_LOADING })
+
+ loadData(this).then(() => {
+ this.setState({ loadStatus: LOAD_STATUS_LOADED })
+ }).catch(() => {
+ this.setState({ loadStatus: LOAD_STATUS_FAILED })
+ })
+ }
+ },
+
+ // Switcher
+ renderSwitcher () {
+ const { expanded } = this
+ const { vcTree: { prefixCls }} = this
+
+ if (this.isLeaf2()) {
+ return
+ }
+
+ return (
+
+ )
+ },
+
+ // Checkbox
+ renderCheckbox () {
+ const { checked, halfChecked, disableCheckbox } = this
+ const { vcTree: { prefixCls, checkable }} = this
+ const disabled = this.isDisabled()
+
+ if (!checkable) return null
+
+ // [Legacy] Custom element should be separate with `checkable` in future
+ const $custom = typeof checkable !== 'boolean' ? checkable : null
+
+ return (
+
+ {$custom}
+
+ )
+ },
+
+ renderIcon () {
+ const { loadStatus } = this
+ const { vcTree: { prefixCls }} = this
+
+ return (
+
+ )
+ },
+
+ // Icon + Title
+ renderSelector () {
+ const { title, selected, icon, loadStatus, dragNodeHighlight } = this
+ const { vcTree: { prefixCls, showIcon, draggable, loadData }} = this
+ const disabled = this.isDisabled()
+
+ const wrapClass = `${prefixCls}-node-content-wrapper`
+
+ // Icon - Still show loading icon when loading without showIcon
+ let $icon
+
+ if (showIcon) {
+ $icon = icon ? (
+
+ {typeof icon === 'function'
+ ? icon(this.$props) : icon}
+
+ ) : this.renderIcon()
+ } else if (loadData && loadStatus === LOAD_STATUS_LOADING) {
+ $icon = this.renderIcon()
+ }
+
+ // Title
+ const $title = {title}
+
+ return (
+
+ {$icon}{$title}
+
+ )
+ },
+
+ // Children list wrapped with `Animation`
+ renderChildren () {
+ const { expanded, pos } = this
+ const { vcTree: {
+ prefixCls,
+ openTransitionName, openAnimation,
+ renderTreeNode,
+ }} = this
+
+ // [Legacy] Animation control
+ const renderFirst = this.renderFirst
+ this.renderFirst = 1
+ let transitionAppear = true
+ if (!renderFirst && expanded) {
+ transitionAppear = false
+ }
+
+ let animProps = {}
+ if (openTransitionName) {
+ animProps = getTransitionProps(openTransitionName, { appear: transitionAppear })
+ } else if (typeof openAnimation === 'object') {
+ animProps = { ...openAnimation }
+ if (!transitionAppear) {
+ delete animProps.props.appear
+ }
+ }
+
+ // Children TreeNode
+ const nodeList = this.getNodeChildren()
+
+ if (nodeList.length === 0) {
+ return null
+ }
+
+ let $children
+ if (expanded) {
+ $children = (
+
+ {nodeList.map((node, index) => (
+ renderTreeNode(node, index, pos)
+ ))}
+
+ )
+ }
+
+ return (
+
+ {$children}
+
+ )
+ },
+ },
+
+ render () {
+ const {
+ dragOver, dragOverGapTop, dragOverGapBottom,
+ } = this
+ const { vcTree: {
+ prefixCls,
+ filterTreeNode,
+ }} = this
+ const disabled = this.isDisabled()
+
+ return (
+
+ {this.renderSwitcher()}
+ {this.renderCheckbox()}
+ {this.renderSelector()}
+ {this.renderChildren()}
+
+ )
+ },
+}
+
+TreeNode.isTreeNode = 1
+
+export default TreeNode
diff --git a/components/vc-tree/src/index.js b/components/vc-tree/src/index.js
new file mode 100644
index 000000000..e8c0e81b5
--- /dev/null
+++ b/components/vc-tree/src/index.js
@@ -0,0 +1,25 @@
+import { getOptionProps } from '../../_util/props-util'
+import Tree from './Tree'
+import TreeNode from './TreeNode'
+Tree.TreeNode = TreeNode
+
+//
+const NewTree = {
+ TreeNode: TreeNode,
+ props: Tree.props,
+ render () {
+ const { $listeners, $slots } = this
+ const treeProps = {
+ props: {
+ ...getOptionProps(this),
+ children: $slots.default,
+ },
+ on: $listeners,
+ }
+ return (
+ {$slots.default}
+ )
+ },
+}
+export { TreeNode }
+export default NewTree
diff --git a/components/vc-tree/src/util.js b/components/vc-tree/src/util.js
new file mode 100644
index 000000000..712853249
--- /dev/null
+++ b/components/vc-tree/src/util.js
@@ -0,0 +1,398 @@
+/* eslint no-loop-func: 0*/
+import warning from 'warning'
+import { getSlotOptions, getOptionProps } from '../../_util/props-util'
+
+export function arrDel (list, value) {
+ const clone = list.slice()
+ const index = clone.indexOf(value)
+ if (index >= 0) {
+ clone.splice(index, 1)
+ }
+ return clone
+}
+
+export function arrAdd (list, value) {
+ const clone = list.slice()
+ if (clone.indexOf(value) === -1) {
+ clone.push(value)
+ }
+ return clone
+}
+
+export function posToArr (pos) {
+ return pos.split('-')
+}
+
+// Only used when drag, not affect SSR.
+export function getOffset (ele) {
+ if (!ele.getClientRects().length) {
+ return { top: 0, left: 0 }
+ }
+
+ const rect = ele.getBoundingClientRect()
+ if (rect.width || rect.height) {
+ const doc = ele.ownerDocument
+ const win = doc.defaultView
+ const docElem = doc.documentElement
+
+ return {
+ top: rect.top + win.pageYOffset - docElem.clientTop,
+ left: rect.left + win.pageXOffset - docElem.clientLeft,
+ }
+ }
+
+ return rect
+}
+
+export function getPosition (level, index) {
+ return `${level}-${index}`
+}
+
+export function getNodeChildren (children = []) {
+ return children
+ .filter(child => getSlotOptions(child).isTreeNode)
+}
+
+export function isCheckDisabled (node) {
+ const { disabled, disableCheckbox } = getOptionProps(node) || {}
+ return !!(disabled || disableCheckbox)
+}
+
+export function traverseTreeNodes (treeNodes, subTreeData, callback) {
+ if (typeof subTreeData === 'function') {
+ callback = subTreeData
+ subTreeData = false
+ }
+
+ function processNode (node, index, parent) {
+ const children = node ? node.componentOptions.children : treeNodes
+ const pos = node ? getPosition(parent.pos, index) : 0
+
+ // Filter children
+ const childList = getNodeChildren(children)
+
+ // Process node if is not root
+ if (node) {
+ const data = {
+ node,
+ index,
+ pos,
+ key: node.key || pos,
+ parentPos: parent.node ? parent.pos : null,
+ }
+
+ // Children data is not must have
+ if (subTreeData) {
+ // Statistic children
+ const subNodes = []
+ childList.forEach((subNode, subIndex) => {
+ // Provide limit snapshot
+ const subPos = getPosition(pos, index)
+ subNodes.push({
+ node: subNode,
+ key: subNode.key || subPos,
+ pos: subPos,
+ index: subIndex,
+ })
+ })
+ data.subNodes = subNodes
+ }
+
+ // Can break traverse by return false
+ if (callback(data) === false) {
+ return
+ }
+ }
+
+ // Process children node
+ childList.forEach((subNode, subIndex) => {
+ processNode(subNode, subIndex, { node, pos })
+ })
+ }
+
+ processNode(null)
+}
+
+/**
+ * [Legacy] Return halfChecked when it has value.
+ * @param checkedKeys
+ * @param halfChecked
+ * @returns {*}
+ */
+export function getStrictlyValue (checkedKeys, halfChecked) {
+ if (halfChecked) {
+ return { checked: checkedKeys, halfChecked }
+ }
+ return checkedKeys
+}
+
+export function getFullKeyList (treeNodes) {
+ const keyList = []
+ traverseTreeNodes(treeNodes, ({ key }) => {
+ keyList.push(key)
+ })
+ return keyList
+}
+
+/**
+ * Check position relation.
+ * @param parentPos
+ * @param childPos
+ * @param directly only directly parent can be true
+ * @returns {boolean}
+ */
+export function isParent (parentPos, childPos, directly = false) {
+ if (!parentPos || !childPos || parentPos.length > childPos.length) return false
+
+ const parentPath = posToArr(parentPos)
+ const childPath = posToArr(childPos)
+
+ // Directly check
+ if (directly && parentPath.length !== childPath.length - 1) return false
+
+ const len = parentPath.length
+ for (let i = 0; i < len; i += 1) {
+ if (parentPath[i] !== childPath[i]) return false
+ }
+
+ return true
+}
+
+/**
+ * Statistic TreeNodes info
+ * @param treeNodes
+ * @returns {{}}
+ */
+export function getNodesStatistic (treeNodes) {
+ const statistic = {
+ keyNodes: {},
+ posNodes: {},
+ nodeList: [],
+ }
+
+ traverseTreeNodes(treeNodes, true, ({ node, index, pos, key, subNodes, parentPos }) => {
+ const data = { node, index, pos, key, subNodes, parentPos }
+ statistic.keyNodes[key] = data
+ statistic.posNodes[pos] = data
+ statistic.nodeList.push(data)
+ })
+
+ return statistic
+}
+
+export function getDragNodesKeys (treeNodes, node) {
+ const { eventKey, pos } = getOptionProps(node)
+ const dragNodesKeys = []
+
+ traverseTreeNodes(treeNodes, ({ pos: nodePos, key }) => {
+ if (isParent(pos, nodePos)) {
+ dragNodesKeys.push(key)
+ }
+ })
+ dragNodesKeys.push(eventKey || pos)
+ return dragNodesKeys
+}
+
+export function calcDropPosition (event, treeNode) {
+ const offsetTop = getOffset(treeNode.selectHandle).top
+ const offsetHeight = treeNode.selectHandle.offsetHeight
+ const pageY = event.pageY
+ const gapHeight = 2 // [Legacy] TODO: remove hard code
+ if (pageY > offsetTop + offsetHeight - gapHeight) {
+ return 1
+ }
+ if (pageY < offsetTop + gapHeight) {
+ return -1
+ }
+ return 0
+}
+
+/**
+ * Auto expand all related node when sub node is expanded
+ * @param keyList
+ * @param props
+ * @returns [string]
+ */
+export function calcExpandedKeys (keyList, props, children = []) {
+ if (!keyList) {
+ return []
+ }
+
+ const { autoExpandParent } = props
+
+ // Do nothing if not auto expand parent
+ if (!autoExpandParent) {
+ return keyList
+ }
+
+ // Fill parent expanded keys
+ const { keyNodes, nodeList } = getNodesStatistic(children)
+ const needExpandKeys = {}
+ const needExpandPathList = []
+
+ // Fill expanded nodes
+ keyList.forEach((key) => {
+ const node = keyNodes[key]
+ if (node) {
+ needExpandKeys[key] = true
+ needExpandPathList.push(node.pos)
+ }
+ })
+
+ // Match parent by path
+ nodeList.forEach(({ pos, key }) => {
+ if (needExpandPathList.some(childPos => isParent(pos, childPos))) {
+ needExpandKeys[key] = true
+ }
+ })
+
+ const calcExpandedKeyList = Object.keys(needExpandKeys)
+
+ // [Legacy] Return origin keyList if calc list is empty
+ return calcExpandedKeyList.length ? calcExpandedKeyList : keyList
+}
+
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export function calcSelectedKeys (selectedKeys, props) {
+ if (!selectedKeys) {
+ return undefined
+ }
+
+ const { multiple } = props
+ if (multiple) {
+ return selectedKeys.slice()
+ }
+
+ if (selectedKeys.length) {
+ return [selectedKeys[0]]
+ }
+ return selectedKeys
+}
+
+/**
+ * Check conduct is by key level. It pass though up & down.
+ * When conduct target node is check means already conducted will be skip.
+ * @param treeNodes
+ * @param checkedKeys
+ * @returns {{checkedKeys: Array, halfCheckedKeys: Array}}
+ */
+export function calcCheckStateConduct (treeNodes, checkedKeys) {
+ const { keyNodes, posNodes } = getNodesStatistic(treeNodes)
+
+ const tgtCheckedKeys = {}
+ const tgtHalfCheckedKeys = {}
+
+ // Conduct up
+ function conductUp (key, halfChecked) {
+ if (tgtCheckedKeys[key]) return
+
+ const { subNodes = [], parentPos, node } = keyNodes[key]
+ if (isCheckDisabled(node)) return
+
+ const allSubChecked = !halfChecked && subNodes
+ .filter(sub => !isCheckDisabled(sub.node))
+ .every(sub => tgtCheckedKeys[sub.key])
+
+ if (allSubChecked) {
+ tgtCheckedKeys[key] = true
+ } else {
+ tgtHalfCheckedKeys[key] = true
+ }
+
+ if (parentPos !== null) {
+ conductUp(posNodes[parentPos].key, !allSubChecked)
+ }
+ }
+
+ // Conduct down
+ function conductDown (key) {
+ if (tgtCheckedKeys[key]) return
+ const { subNodes = [], node } = keyNodes[key]
+
+ if (isCheckDisabled(node)) return
+
+ tgtCheckedKeys[key] = true
+
+ subNodes.forEach((sub) => {
+ conductDown(sub.key)
+ })
+ }
+
+ function conduct (key) {
+ if (!keyNodes[key]) {
+ warning(false, `'${key}' does not exist in the tree.`)
+ return
+ }
+
+ const { subNodes = [], parentPos, node } = keyNodes[key]
+ if (isCheckDisabled(node)) return
+
+ tgtCheckedKeys[key] = true
+
+ // Conduct down
+ subNodes
+ .filter(sub => !isCheckDisabled(sub.node))
+ .forEach((sub) => {
+ conductDown(sub.key)
+ })
+
+ // Conduct up
+ if (parentPos !== null) {
+ conductUp(posNodes[parentPos].key)
+ }
+ }
+
+ checkedKeys.forEach((key) => {
+ conduct(key)
+ })
+
+ return {
+ checkedKeys: Object.keys(tgtCheckedKeys),
+ halfCheckedKeys: Object.keys(tgtHalfCheckedKeys)
+ .filter(key => !tgtCheckedKeys[key]),
+ }
+}
+
+/**
+ * Calculate the value of checked and halfChecked keys.
+ * This should be only run in init or props changed.
+ */
+export function calcCheckedKeys (keys, props, children = []) {
+ const { checkable, checkStrictly } = props
+
+ if (!checkable || !keys) {
+ return null
+ }
+
+ // Convert keys to object format
+ let keyProps
+ if (Array.isArray(keys)) {
+ // [Legacy] Follow the api doc
+ keyProps = {
+ checkedKeys: keys,
+ halfCheckedKeys: undefined,
+ }
+ } else if (typeof keys === 'object') {
+ keyProps = {
+ checkedKeys: keys.checked || undefined,
+ halfCheckedKeys: keys.halfChecked || undefined,
+ }
+ } else {
+ warning(false, '`CheckedKeys` is not an array or an object')
+ return null
+ }
+
+ // Do nothing if is checkStrictly mode
+ if (checkStrictly) {
+ return keyProps
+ }
+
+ // Conduct calculate the check status
+ const { checkedKeys = [] } = keyProps
+ return calcCheckStateConduct(children, checkedKeys)
+}
diff --git a/package-lock.json b/package-lock.json
index be35897c4..b2cdd9e77 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
{
"name": "vue-antd-ui",
- "version": "0.1.0",
+ "version": "0.1.1",
"lockfileVersion": 1,
"requires": true,
"dependencies": {
@@ -206,7 +206,7 @@
},
"abab": {
"version": "1.0.4",
- "resolved": "https://registry.npmjs.org/abab/-/abab-1.0.4.tgz",
+ "resolved": "http://registry.npm.taobao.org/abab/download/abab-1.0.4.tgz",
"integrity": "sha1-X6rZwsB/YN12dw9xzwJbYqY8/U4=",
"dev": true,
"optional": true
@@ -251,7 +251,7 @@
},
"acorn-globals": {
"version": "1.0.9",
- "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-1.0.9.tgz",
+ "resolved": "http://registry.npm.taobao.org/acorn-globals/download/acorn-globals-1.0.9.tgz",
"integrity": "sha1-VbtemGkVB7dFedBRNBMhfDgMVM8=",
"dev": true,
"optional": true,
@@ -261,7 +261,7 @@
"dependencies": {
"acorn": {
"version": "2.7.0",
- "resolved": "https://registry.npmjs.org/acorn/-/acorn-2.7.0.tgz",
+ "resolved": "http://registry.npm.taobao.org/acorn/download/acorn-2.7.0.tgz",
"integrity": "sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=",
"dev": true,
"optional": true
@@ -2491,7 +2491,7 @@
},
"component-classes": {
"version": "1.2.6",
- "resolved": "http://registry.npm.taobao.org/component-classes/download/component-classes-1.2.6.tgz",
+ "resolved": "https://registry.npmjs.org/component-classes/-/component-classes-1.2.6.tgz",
"integrity": "sha1-xkI5TDYYpNiwuJGe/Mu9kw5c1pE=",
"requires": {
"component-indexof": "0.0.3"
@@ -3086,13 +3086,13 @@
},
"cssom": {
"version": "0.3.2",
- "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.2.tgz",
+ "resolved": "http://registry.npm.taobao.org/cssom/download/cssom-0.3.2.tgz",
"integrity": "sha1-uANhcMefB6kP8vFuIihAJ6JDhIs=",
"dev": true
},
"cssstyle": {
"version": "0.2.37",
- "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-0.2.37.tgz",
+ "resolved": "http://registry.npm.taobao.org/cssstyle/download/cssstyle-0.2.37.tgz",
"integrity": "sha1-VBCXI0yyUTyDzu06zdwn/yeYfVQ=",
"dev": true,
"optional": true,
@@ -8076,7 +8076,7 @@
},
"jsdom": {
"version": "7.2.2",
- "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-7.2.2.tgz",
+ "resolved": "http://registry.npm.taobao.org/jsdom/download/jsdom-7.2.2.tgz",
"integrity": "sha1-QLQCdwwr2iNGkJa+6Rq2deOx/G4=",
"dev": true,
"optional": true,
@@ -8100,14 +8100,14 @@
"dependencies": {
"acorn": {
"version": "2.7.0",
- "resolved": "https://registry.npmjs.org/acorn/-/acorn-2.7.0.tgz",
+ "resolved": "http://registry.npm.taobao.org/acorn/download/acorn-2.7.0.tgz",
"integrity": "sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=",
"dev": true,
"optional": true
},
"parse5": {
"version": "1.5.1",
- "resolved": "https://registry.npmjs.org/parse5/-/parse5-1.5.1.tgz",
+ "resolved": "http://registry.npm.taobao.org/parse5/download/parse5-1.5.1.tgz",
"integrity": "sha1-m387DeMr543CQBsXVzzK8Pb1nZQ=",
"dev": true,
"optional": true
@@ -8897,11 +8897,6 @@
"integrity": "sha1-soqmKIorn8ZRA1x3EfZathkDMaY=",
"dev": true
},
- "lodash.clonedeep": {
- "version": "4.5.0",
- "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
- "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8="
- },
"lodash.create": {
"version": "3.1.1",
"resolved": "https://registry.npm.taobao.org/lodash.create/download/lodash.create-3.1.1.tgz",
@@ -8913,11 +8908,6 @@
"lodash._isiterateecall": "3.0.9"
}
},
- "lodash.debounce": {
- "version": "4.0.8",
- "resolved": "https://registry.npm.taobao.org/lodash.debounce/download/lodash.debounce-4.0.8.tgz",
- "integrity": "sha1-gteb/zCmfEAF/9XiUVMArZyk168="
- },
"lodash.escape": {
"version": "3.2.0",
"resolved": "http://registry.npm.taobao.org/lodash.escape/download/lodash.escape-3.2.0.tgz",
@@ -8945,11 +8935,6 @@
"integrity": "sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=",
"dev": true
},
- "lodash.isequal": {
- "version": "4.5.0",
- "resolved": "https://registry.npm.taobao.org/lodash.isequal/download/lodash.isequal-4.5.0.tgz",
- "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
- },
"lodash.isplainobject": {
"version": "4.0.6",
"resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
@@ -15976,7 +15961,7 @@
},
"symbol-tree": {
"version": "3.2.2",
- "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.2.tgz",
+ "resolved": "http://registry.npm.taobao.org/symbol-tree/download/symbol-tree-3.2.2.tgz",
"integrity": "sha1-rifbOPZgp64uHDt9G8KQgZuFGeY=",
"dev": true,
"optional": true
@@ -16267,7 +16252,7 @@
},
"tr46": {
"version": "0.0.3",
- "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+ "resolved": "http://registry.npm.taobao.org/tr46/download/tr46-0.0.3.tgz",
"integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=",
"dev": true,
"optional": true
@@ -17031,7 +17016,7 @@
"dependencies": {
"cheerio": {
"version": "0.20.0",
- "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.20.0.tgz",
+ "resolved": "http://registry.npm.taobao.org/cheerio/download/cheerio-0.20.0.tgz",
"integrity": "sha1-XHEPK6uVZTJyhCugHG6mGzVF7DU=",
"dev": true,
"requires": {
@@ -17045,7 +17030,7 @@
},
"domhandler": {
"version": "2.3.0",
- "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.3.0.tgz",
+ "resolved": "http://registry.npm.taobao.org/domhandler/download/domhandler-2.3.0.tgz",
"integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=",
"dev": true,
"requires": {
@@ -17054,7 +17039,7 @@
},
"domutils": {
"version": "1.5.1",
- "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz",
+ "resolved": "http://registry.npm.taobao.org/domutils/download/domutils-1.5.1.tgz",
"integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=",
"dev": true,
"requires": {
@@ -17064,7 +17049,7 @@
},
"htmlparser2": {
"version": "3.8.3",
- "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.8.3.tgz",
+ "resolved": "http://registry.npm.taobao.org/htmlparser2/download/htmlparser2-3.8.3.tgz",
"integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=",
"dev": true,
"requires": {
@@ -17077,7 +17062,7 @@
"dependencies": {
"entities": {
"version": "1.0.0",
- "resolved": "https://registry.npmjs.org/entities/-/entities-1.0.0.tgz",
+ "resolved": "http://registry.npm.taobao.org/entities/download/entities-1.0.0.tgz",
"integrity": "sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=",
"dev": true
}
@@ -17085,13 +17070,13 @@
},
"isarray": {
"version": "0.0.1",
- "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
+ "resolved": "http://registry.npm.taobao.org/isarray/download/isarray-0.0.1.tgz",
"integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
"dev": true
},
"loader-utils": {
"version": "0.2.17",
- "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-0.2.17.tgz",
+ "resolved": "http://registry.npm.taobao.org/loader-utils/download/loader-utils-0.2.17.tgz",
"integrity": "sha1-+G5jdNQyBabmxg6RlvF8Apm/s0g=",
"dev": true,
"requires": {
@@ -17103,7 +17088,7 @@
},
"readable-stream": {
"version": "1.1.14",
- "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+ "resolved": "http://registry.npm.taobao.org/readable-stream/download/readable-stream-1.1.14.tgz",
"integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
"dev": true,
"requires": {
@@ -17115,7 +17100,7 @@
},
"string_decoder": {
"version": "0.10.31",
- "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+ "resolved": "http://registry.npm.taobao.org/string_decoder/download/string_decoder-0.10.31.tgz",
"integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
"dev": true
}
@@ -17319,7 +17304,7 @@
},
"webidl-conversions": {
"version": "2.0.1",
- "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-2.0.1.tgz",
+ "resolved": "http://registry.npm.taobao.org/webidl-conversions/download/webidl-conversions-2.0.1.tgz",
"integrity": "sha1-O/glj30xjHRDw28uFpQCoaZwNQY=",
"dev": true,
"optional": true
@@ -18038,7 +18023,7 @@
},
"whatwg-url-compat": {
"version": "0.6.5",
- "resolved": "https://registry.npmjs.org/whatwg-url-compat/-/whatwg-url-compat-0.6.5.tgz",
+ "resolved": "http://registry.npm.taobao.org/whatwg-url-compat/download/whatwg-url-compat-0.6.5.tgz",
"integrity": "sha1-AImBEa9om7CXVBzVpFymyHmERb8=",
"dev": true,
"optional": true,
@@ -18168,7 +18153,7 @@
},
"xml-name-validator": {
"version": "2.0.1",
- "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-2.0.1.tgz",
+ "resolved": "http://registry.npm.taobao.org/xml-name-validator/download/xml-name-validator-2.0.1.tgz",
"integrity": "sha1-TYuPHszTQZqjYgYb7O9RXh5VljU=",
"dev": true,
"optional": true
@@ -18250,4 +18235,4 @@
"dev": true
}
}
-}
\ No newline at end of file
+}