resolver-egretimp-plus 0.1.119 → 0.1.121

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

@@ -1,76 +0,0 @@
-// @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

@@ -1,74 +0,0 @@
-// @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

@@ -1,246 +0,0 @@
-// @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

@@ -1,230 +0,0 @@
-// @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