resolver-egretimp-plus 0.1.113 → 0.1.115

package/src-bak/components/table/src/store/expand.ts

@@ -0,0 +1,76 @@
+// @ts-nocheck
+import { getCurrentInstance, ref } from 'vue'
+import { getKeysMap, getRowIdentity, toggleRowStatus } from '../util'
+
+import type { Ref } from 'vue'
+import type { WatcherPropsData } from '.'
+import type { Table } from '../table/defaults'
+
+function useExpand<T>(watcherData: WatcherPropsData<T>) {
+  const instance = getCurrentInstance() as Table<T>
+  const defaultExpandAll = ref(false)
+  const expandRows: Ref<T[]> = ref([])
+  const updateExpandRows = () => {
+    const data = watcherData.data.value || []
+    const rowKey = watcherData.rowKey.value
+    if (defaultExpandAll.value) {
+      expandRows.value = data.slice()
+    } else if (rowKey) {
+      // TODO：这里的代码可以优化
+      const expandRowsMap = getKeysMap(expandRows.value, rowKey)
+      expandRows.value = data.reduce((prev: T[], row: T) => {
+        const rowId = getRowIdentity(row, rowKey)
+        const rowInfo = expandRowsMap[rowId]
+        if (rowInfo) {
+          prev.push(row)
+        }
+        return prev
+      }, [])
+    } else {
+      expandRows.value = []
+    }
+  }
+
+  const toggleRowExpansion = (row: T, expanded?: boolean) => {
+    const changed = toggleRowStatus(expandRows.value, row, expanded)
+    if (changed) {
+      instance.emit('expand-change', row, expandRows.value.slice())
+    }
+  }
+
+  const setExpandRowKeys = (rowKeys: string[]) => {
+    instance.store.assertRowKey()
+    // TODO：这里的代码可以优化
+    const data = watcherData.data.value || []
+    const rowKey = watcherData.rowKey.value
+    const keysMap = getKeysMap(data, rowKey)
+    expandRows.value = rowKeys.reduce((prev: T[], cur: string) => {
+      const info = keysMap[cur]
+      if (info) {
+        prev.push(info.row)
+      }
+      return prev
+    }, [])
+  }
+
+  const isRowExpanded = (row: T): boolean => {
+    const rowKey = watcherData.rowKey.value
+    if (rowKey) {
+      const expandMap = getKeysMap(expandRows.value, rowKey)
+      return !!expandMap[getRowIdentity(row, rowKey)]
+    }
+    return expandRows.value.includes(row)
+  }
+  return {
+    updateExpandRows,
+    toggleRowExpansion,
+    setExpandRowKeys,
+    isRowExpanded,
+    states: {
+      expandRows,
+      defaultExpandAll,
+    },
+  }
+}
+
+export default useExpand

package/src-bak/components/table/src/store/helper.ts

@@ -0,0 +1,74 @@
+// @ts-nocheck
+import { watch } from 'vue'
+import { debounce } from 'lodash-unified'
+import useStore from '.'
+
+import type { Store } from '.'
+import type { Table, TableProps } from '../table/defaults'
+
+const InitialStateMap = {
+  rowKey: 'rowKey',
+  defaultExpandAll: 'defaultExpandAll',
+  selectOnIndeterminate: 'selectOnIndeterminate',
+  indent: 'indent',
+  lazy: 'lazy',
+  data: 'data',
+  ['treeProps.hasChildren']: {
+    key: 'lazyColumnIdentifier',
+    default: 'hasChildren',
+  },
+  ['treeProps.children']: {
+    key: 'childrenColumnName',
+    default: 'children',
+  },
+}
+
+export function createStore<T>(table: Table<T>, props: TableProps<T>) {
+  if (!table) {
+    throw new Error('Table is required.')
+  }
+
+  const store = useStore<T>()
+  // fix https://github.com/ElemeFE/element/issues/14075
+  // related pr https://github.com/ElemeFE/element/pull/14146
+  store.toggleAllSelection = debounce(store._toggleAllSelection, 10)
+  Object.keys(InitialStateMap).forEach((key) => {
+    handleValue(getArrKeysValue(props, key), key, store)
+  })
+  proxyTableProps(store, props)
+  return store
+}
+
+function proxyTableProps<T>(store: Store<T>, props: TableProps<T>) {
+  Object.keys(InitialStateMap).forEach((key) => {
+    watch(
+      () => getArrKeysValue(props, key),
+      (value) => {
+        handleValue(value, key, store)
+      }
+    )
+  })
+}
+
+function handleValue<T>(value, propsKey: string, store: Store<T>) {
+  let newVal = value
+  let storeKey = InitialStateMap[propsKey]
+  if (typeof InitialStateMap[propsKey] === 'object') {
+    storeKey = storeKey.key
+    newVal = newVal || InitialStateMap[propsKey].default
+  }
+  store.states[storeKey].value = newVal
+}
+
+function getArrKeysValue<T>(props: TableProps<T>, keys: string) {
+  if (keys.includes('.')) {
+    const keyList = keys.split('.')
+    let value = props
+    keyList.forEach((key) => {
+      value = value[key]
+    })
+    return value
+  } else {
+    return props[keys]
+  }
+}

package/src-bak/components/table/src/store/index.ts

@@ -0,0 +1,246 @@
+// @ts-nocheck
+import { getCurrentInstance, nextTick, unref } from 'vue'
+import { useNamespace } from 'element-plus/es/hooks/index.mjs'
+import useWatcher from './watcher'
+
+import type { Ref } from 'vue'
+import type { TableColumnCtx } from '../table-column/defaults'
+import type { Filter, Sort, Table } from '../table/defaults'
+
+interface WatcherPropsData<T> {
+  data: Ref<T[]>
+  rowKey: Ref<string>
+}
+
+function replaceColumn<T>(
+  array: TableColumnCtx<T>[],
+  column: TableColumnCtx<T>
+) {
+  return array.map((item) => {
+    if (item.id === column.id) {
+      return column
+    } else if (item.children?.length) {
+      item.children = replaceColumn(item.children, column)
+    }
+    return item
+  })
+}
+
+function sortColumn<T>(array: TableColumnCtx<T>[]) {
+  array.forEach((item) => {
+    item.no = item.getColumnIndex?.()
+    if (item.children?.length) {
+      sortColumn(item.children)
+    }
+  })
+  array.sort((cur, pre) => cur.no - pre.no)
+}
+
+function useStore<T>() {
+  const instance = getCurrentInstance() as Table<T>
+  const watcher = useWatcher<T>()
+  const ns = useNamespace('table')
+  type StoreStates = typeof watcher.states
+  const mutations = {
+    setData(states: StoreStates, data: T[]) {
+      const dataInstanceChanged = unref(states._data) !== data
+      states.data.value = data
+      states._data.value = data
+      instance.store.execQuery()
+      // 数据变化，更新部分数据。
+      // 没有使用 computed，而是手动更新部分数据 https://github.com/vuejs/vue/issues/6660#issuecomment-331417140
+      instance.store.updateCurrentRowData()
+      instance.store.updateExpandRows()
+      instance.store.updateTreeData(
+        instance.store.states.defaultExpandAll.value
+      )
+      if (unref(states.reserveSelection)) {
+        instance.store.assertRowKey()
+        instance.store.updateSelectionByRowKey()
+      } else {
+        if (dataInstanceChanged) {
+          instance.store.clearSelection()
+        } else {
+          instance.store.cleanSelection()
+        }
+      }
+      instance.store.updateAllSelected()
+      if (instance.$ready) {
+        instance.store.scheduleLayout()
+      }
+    },
+
+    insertColumn(
+      states: StoreStates,
+      column: TableColumnCtx<T>,
+      parent: TableColumnCtx<T>,
+      updateColumnOrder: () => void
+    ) {
+      const array = unref(states._columns)
+      let newColumns = []
+      if (!parent) {
+        array.push(column)
+        newColumns = array
+      } else {
+        if (parent && !parent.children) {
+          parent.children = []
+        }
+        parent.children.push(column)
+        newColumns = replaceColumn(array, parent)
+      }
+      sortColumn(newColumns)
+      states._columns.value = newColumns
+      states.updateOrderFns.push(updateColumnOrder)
+      if (column.type === 'selection') {
+        states.selectable.value = column.selectable
+        states.reserveSelection.value = column.reserveSelection
+      }
+      if (instance.$ready) {
+        instance.store.updateColumns() // hack for dynamics insert column
+        instance.store.scheduleLayout()
+      }
+    },
+
+    updateColumnOrder(states: StoreStates, column: TableColumnCtx<T>) {
+      const newColumnIndex = column.getColumnIndex?.()
+      if (newColumnIndex === column.no) return
+
+      sortColumn(states._columns.value)
+
+      if (instance.$ready) {
+        instance.store.updateColumns()
+      }
+    },
+
+    removeColumn(
+      states: StoreStates,
+      column: TableColumnCtx<T>,
+      parent: TableColumnCtx<T>,
+      updateColumnOrder: () => void
+    ) {
+      const array = unref(states._columns) || []
+      if (parent) {
+        parent.children.splice(
+          parent.children.findIndex((item) => item.id === column.id),
+          1
+        )
+        // fix #10699, delete parent.children immediately will trigger again
+        nextTick(() => {
+          if (parent.children?.length === 0) {
+            delete parent.children
+          }
+        })
+        states._columns.value = replaceColumn(array, parent)
+      } else {
+        const index = array.indexOf(column)
+        if (index > -1) {
+          array.splice(index, 1)
+          states._columns.value = array
+        }
+      }
+
+      const updateFnIndex = states.updateOrderFns.indexOf(updateColumnOrder)
+      updateFnIndex > -1 && states.updateOrderFns.splice(updateFnIndex, 1)
+
+      if (instance.$ready) {
+        instance.store.updateColumns() // hack for dynamics remove column
+        instance.store.scheduleLayout()
+      }
+    },
+
+    sort(states: StoreStates, options: Sort) {
+      const { prop, order, init } = options
+      if (prop) {
+        const column = unref(states.columns).find(
+          (column) => column.property === prop
+        )
+        if (column) {
+          column.order = order
+          instance.store.updateSort(column, prop, order)
+          instance.store.commit('changeSortCondition', { init })
+        }
+      }
+    },
+
+    changeSortCondition(states: StoreStates, options: Sort) {
+      // 修复 pr https://github.com/ElemeFE/element/pull/15012 导致的 bug
+      // https://github.com/element-plus/element-plus/pull/4640
+      const { sortingColumn, sortProp, sortOrder } = states
+      const columnValue = unref(sortingColumn),
+        propValue = unref(sortProp),
+        orderValue = unref(sortOrder)
+      if (orderValue === null) {
+        states.sortingColumn.value = null
+        states.sortProp.value = null
+      }
+      const ignore = { filter: true }
+      instance.store.execQuery(ignore)
+
+      if (!options || !(options.silent || options.init)) {
+        instance.emit('sort-change', {
+          column: columnValue,
+          prop: propValue,
+          order: orderValue,
+        })
+      }
+
+      instance.store.updateTableScrollY()
+    },
+
+    filterChange(_states: StoreStates, options: Filter<T>) {
+      const { column, values, silent } = options
+      const newFilters = instance.store.updateFilters(column, values)
+      instance.store.execQuery()
+
+      if (!silent) {
+        instance.emit('filter-change', newFilters)
+      }
+      instance.store.updateTableScrollY()
+    },
+
+    toggleAllSelection() {
+      instance.store.toggleAllSelection()
+    },
+
+    rowSelectedChanged(_states, row: T) {
+      instance.store.toggleRowSelection(row)
+      instance.store.updateAllSelected()
+    },
+
+    setHoverRow(states: StoreStates, row: T) {
+      states.hoverRow.value = row
+    },
+
+    setCurrentRow(_states, row: T) {
+      instance.store.updateCurrentRow(row)
+    },
+  }
+  const commit = function (name: keyof typeof mutations, ...args) {
+    const mutations = instance.store.mutations
+    if (mutations[name]) {
+      mutations[name].apply(instance, [instance.store.states].concat(args))
+    } else {
+      throw new Error(`Action not found: ${name}`)
+    }
+  }
+  const updateTableScrollY = function () {
+    nextTick(() => instance.layout.updateScrollY.apply(instance.layout))
+  }
+  return {
+    ns,
+    ...watcher,
+    mutations,
+    commit,
+    updateTableScrollY,
+  }
+}
+
+export default useStore
+
+class HelperStore<T> {
+  Return = useStore<T>()
+}
+
+type StoreFilter = Record<string, string[]>
+type Store<T> = HelperStore<T>['Return']
+export type { WatcherPropsData, Store, StoreFilter }

package/src-bak/components/table/src/store/tree.ts

@@ -0,0 +1,230 @@
+// @ts-nocheck
+import { computed, getCurrentInstance, ref, unref, watch } from 'vue'
+import { getRowIdentity, walkTreeNode } from '../util'
+
+import type { WatcherPropsData } from '.'
+import type { Table, TableProps } from '../table/defaults'
+
+function useTree<T>(watcherData: WatcherPropsData<T>) {
+  const expandRowKeys = ref<string[]>([])
+  const treeData = ref<unknown>({})
+  const indent = ref(16)
+  const lazy = ref(false)
+  const lazyTreeNodeMap = ref({})
+  const lazyColumnIdentifier = ref('hasChildren')
+  const childrenColumnName = ref('children')
+  const instance = getCurrentInstance() as Table<T>
+  const normalizedData = computed(() => {
+    if (!watcherData.rowKey.value) return {}
+    const data = watcherData.data.value || []
+    return normalize(data)
+  })
+  const normalizedLazyNode = computed(() => {
+    const rowKey = watcherData.rowKey.value
+    const keys = Object.keys(lazyTreeNodeMap.value)
+    const res = {}
+    if (!keys.length) return res
+    keys.forEach((key) => {
+      if (lazyTreeNodeMap.value[key].length) {
+        const item = { children: [] }
+        lazyTreeNodeMap.value[key].forEach((row) => {
+          const currentRowKey = getRowIdentity(row, rowKey)
+          item.children.push(currentRowKey)
+          if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
+            res[currentRowKey] = { children: [] }
+          }
+        })
+        res[key] = item
+      }
+    })
+    return res
+  })
+
+  const normalize = (data) => {
+    const rowKey = watcherData.rowKey.value
+    const res = {}
+    walkTreeNode(
+      data,
+      (parent, children, level) => {
+        const parentId = getRowIdentity(parent, rowKey)
+        if (Array.isArray(children)) {
+          res[parentId] = {
+            children: children.map((row) => getRowIdentity(row, rowKey)),
+            level,
+          }
+        } else if (lazy.value) {
+          // 当 children 不存在且 lazy 为 true，该节点即为懒加载的节点
+          res[parentId] = {
+            children: [],
+            lazy: true,
+            level,
+          }
+        }
+      },
+      childrenColumnName.value,
+      lazyColumnIdentifier.value
+    )
+    return res
+  }
+
+  const updateTreeData = (
+    ifChangeExpandRowKeys = false,
+    ifExpandAll = instance.store?.states.defaultExpandAll.value
+  ) => {
+    const nested = normalizedData.value
+    const normalizedLazyNode_ = normalizedLazyNode.value
+    const keys = Object.keys(nested)
+    const newTreeData = {}
+    if (keys.length) {
+      const oldTreeData = unref(treeData)
+      const rootLazyRowKeys = []
+      const getExpanded = (oldValue, key) => {
+        if (ifChangeExpandRowKeys) {
+          if (expandRowKeys.value) {
+            return ifExpandAll || expandRowKeys.value.includes(key)
+          } else {
+            return !!(ifExpandAll || oldValue?.expanded)
+          }
+        } else {
+          const included =
+            ifExpandAll ||
+            (expandRowKeys.value && expandRowKeys.value.includes(key))
+          return !!(oldValue?.expanded || included)
+        }
+      }
+      // 合并 expanded 与 display，确保数据刷新后，状态不变
+      keys.forEach((key) => {
+        const oldValue = oldTreeData[key]
+        const newValue = { ...nested[key] }
+        newValue.expanded = getExpanded(oldValue, key)
+        if (newValue.lazy) {
+          const { loaded = false, loading = false } = oldValue || {}
+          newValue.loaded = !!loaded
+          newValue.loading = !!loading
+          rootLazyRowKeys.push(key)
+        }
+        newTreeData[key] = newValue
+      })
+      // 根据懒加载数据更新 treeData
+      const lazyKeys = Object.keys(normalizedLazyNode_)
+      if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
+        lazyKeys.forEach((key) => {
+          const oldValue = oldTreeData[key]
+          const lazyNodeChildren = normalizedLazyNode_[key].children
+          if (rootLazyRowKeys.includes(key)) {
+            // 懒加载的 root 节点，更新一下原有的数据，原来的 children 一定是空数组
+            if (newTreeData[key].children.length !== 0) {
+              throw new Error('[ElTable]children must be an empty array.')
+            }
+            newTreeData[key].children = lazyNodeChildren
+          } else {
+            const { loaded = false, loading = false } = oldValue || {}
+            newTreeData[key] = {
+              lazy: true,
+              loaded: !!loaded,
+              loading: !!loading,
+              expanded: getExpanded(oldValue, key),
+              children: lazyNodeChildren,
+              level: '',
+            }
+          }
+        })
+      }
+    }
+    treeData.value = newTreeData
+    instance.store?.updateTableScrollY()
+  }
+
+  watch(
+    () => expandRowKeys.value,
+    () => {
+      updateTreeData(true)
+    }
+  )
+
+  watch(
+    () => normalizedData.value,
+    () => {
+      updateTreeData()
+    }
+  )
+  watch(
+    () => normalizedLazyNode.value,
+    () => {
+      updateTreeData()
+    }
+  )
+
+  const updateTreeExpandKeys = (value: string[]) => {
+    expandRowKeys.value = value
+    updateTreeData()
+  }
+
+  const toggleTreeExpansion = (row: T, expanded?: boolean) => {
+    instance.store.assertRowKey()
+
+    const rowKey = watcherData.rowKey.value
+    const id = getRowIdentity(row, rowKey)
+    const data = id && treeData.value[id]
+    if (id && data && 'expanded' in data) {
+      const oldExpanded = data.expanded
+      expanded = typeof expanded === 'undefined' ? !data.expanded : expanded
+      treeData.value[id].expanded = expanded
+      if (oldExpanded !== expanded) {
+        instance.emit('expand-change', row, expanded)
+      }
+      instance.store.updateTableScrollY()
+    }
+  }
+
+  const loadOrToggle = (row) => {
+    instance.store.assertRowKey()
+    const rowKey = watcherData.rowKey.value
+    const id = getRowIdentity(row, rowKey)
+    const data = treeData.value[id]
+    if (lazy.value && data && 'loaded' in data && !data.loaded) {
+      loadData(row, id, data)
+    } else {
+      toggleTreeExpansion(row, undefined)
+    }
+  }
+
+  const loadData = (row: T, key: string, treeNode) => {
+    const { load } = instance.props as unknown as TableProps<T>
+    if (load && !treeData.value[key].loaded) {
+      treeData.value[key].loading = true
+      load(row, treeNode, (data) => {
+        if (!Array.isArray(data)) {
+          throw new TypeError('[ElTable] data must be an array')
+        }
+        treeData.value[key].loading = false
+        treeData.value[key].loaded = true
+        treeData.value[key].expanded = true
+        if (data.length) {
+          lazyTreeNodeMap.value[key] = data
+        }
+        instance.emit('expand-change', row, true)
+      })
+    }
+  }
+
+  return {
+    loadData,
+    loadOrToggle,
+    toggleTreeExpansion,
+    updateTreeExpandKeys,
+    updateTreeData,
+    normalize,
+    states: {
+      expandRowKeys,
+      treeData,
+      indent,
+      lazy,
+      lazyTreeNodeMap,
+      lazyColumnIdentifier,
+      childrenColumnName,
+    },
+  }
+}
+
+export default useTree