resolver-egretimp-plus 0.1.119 → 0.1.120

package/src-bak/components/table/src/util.ts

@@ -1,521 +0,0 @@
-// @ts-nocheck
-import { createVNode, render } from 'vue'
-import { flatMap, get } from 'lodash-unified'
-import {
-  hasOwn,
-  isArray,
-  isBoolean,
-  isObject,
-  throwError,
-} from 'element-plus/es/utils/index.mjs'
-import ElTooltip, {
-  type ElTooltipProps,
-} from 'element-plus/es/components/tooltip/index.mjs'
-import type { Table } from './table/defaults'
-import type { TableColumnCtx } from './table-column/defaults'
-
-export type TableOverflowTooltipOptions = Partial<
-  Pick<
-    ElTooltipProps,
-    | 'appendTo'
-    | 'effect'
-    | 'enterable'
-    | 'hideAfter'
-    | 'offset'
-    | 'placement'
-    | 'popperClass'
-    | 'popperOptions'
-    | 'showAfter'
-    | 'showArrow'
-    | 'transition'
-  >
->
-
-type RemovePopperFn = (() => void) & {
-  trigger?: HTMLElement
-}
-
-export const getCell = function (event: Event) {
-  return (event.target as HTMLElement)?.closest('td')
-}
-
-export const orderBy = function <T>(
-  array: T[],
-  sortKey: string,
-  reverse: string | number,
-  sortMethod,
-  sortBy: string | (string | ((a: T, b: T, array?: T[]) => number))[]
-) {
-  if (
-    !sortKey &&
-    !sortMethod &&
-    (!sortBy || (Array.isArray(sortBy) && !sortBy.length))
-  ) {
-    return array
-  }
-  if (typeof reverse === 'string') {
-    reverse = reverse === 'descending' ? -1 : 1
-  } else {
-    reverse = reverse && reverse < 0 ? -1 : 1
-  }
-  const getKey = sortMethod
-    ? null
-    : function (value, index) {
-        if (sortBy) {
-          if (!Array.isArray(sortBy)) {
-            sortBy = [sortBy]
-          }
-          return sortBy.map((by) => {
-            if (typeof by === 'string') {
-              return get(value, by)
-            } else {
-              return by(value, index, array)
-            }
-          })
-        }
-        if (sortKey !== '$key') {
-          if (isObject(value) && '$value' in value) value = value.$value
-        }
-        return [isObject(value) ? get(value, sortKey) : value]
-      }
-  const compare = function (a, b) {
-    if (sortMethod) {
-      return sortMethod(a.value, b.value)
-    }
-    for (let i = 0, len = a.key.length; i < len; i++) {
-      if (a.key[i] < b.key[i]) {
-        return -1
-      }
-      if (a.key[i] > b.key[i]) {
-        return 1
-      }
-    }
-    return 0
-  }
-  return array
-    .map((value, index) => {
-      return {
-        value,
-        index,
-        key: getKey ? getKey(value, index) : null,
-      }
-    })
-    .sort((a, b) => {
-      let order = compare(a, b)
-      if (!order) {
-        // make stable https://en.wikipedia.org/wiki/Sorting_algorithm#Stability
-        order = a.index - b.index
-      }
-      return order * +reverse
-    })
-    .map((item) => item.value)
-}
-
-export const getColumnById = function <T>(
-  table: {
-    columns: TableColumnCtx<T>[]
-  },
-  columnId: string
-): null | TableColumnCtx<T> {
-  let column = null
-  table.columns.forEach((item) => {
-    if (item.id === columnId) {
-      column = item
-    }
-  })
-  return column
-}
-
-export const getColumnByKey = function <T>(
-  table: {
-    columns: TableColumnCtx<T>[]
-  },
-  columnKey: string
-): TableColumnCtx<T> {
-  let column = null
-  for (let i = 0; i < table.columns.length; i++) {
-    const item = table.columns[i]
-    if (item.columnKey === columnKey) {
-      column = item
-      break
-    }
-  }
-  if (!column)
-    throwError('ElTable', `No column matching with column-key: ${columnKey}`)
-  return column
-}
-
-export const getColumnByCell = function <T>(
-  table: {
-    columns: TableColumnCtx<T>[]
-  },
-  cell: HTMLElement,
-  namespace: string
-): null | TableColumnCtx<T> {
-  const matches = (cell.className || '').match(
-    new RegExp(`${namespace}-table_[^\\s]+`, 'gm')
-  )
-  if (matches) {
-    return getColumnById(table, matches[0])
-  }
-  return null
-}
-
-export const getRowIdentity = <T>(
-  row: T,
-  rowKey: string | ((row: T) => any)
-): string => {
-  if (!row) throw new Error('Row is required when get row identity')
-  if (typeof rowKey === 'string') {
-    if (!rowKey.includes('.')) {
-      return `${row[rowKey]}`
-    }
-    const key = rowKey.split('.')
-    let current = row
-    for (const element of key) {
-      current = current[element]
-    }
-    return `${current}`
-  } else if (typeof rowKey === 'function') {
-    return rowKey.call(null, row)
-  }
-}
-
-export const getKeysMap = function <T>(
-  array: T[],
-  rowKey: string
-): Record<string, { row: T; index: number }> {
-  const arrayMap = {}
-  ;(array || []).forEach((row, index) => {
-    arrayMap[getRowIdentity(row, rowKey)] = { row, index }
-  })
-  return arrayMap
-}
-
-export function mergeOptions<T, K>(defaults: T, config: K): T & K {
-  const options = {} as T & K
-  let key
-  for (key in defaults) {
-    options[key] = defaults[key]
-  }
-  for (key in config) {
-    if (hasOwn(config as unknown as Record<string, any>, key)) {
-      const value = config[key]
-      if (typeof value !== 'undefined') {
-        options[key] = value
-      }
-    }
-  }
-  return options
-}
-
-export function parseWidth(width: number | string): number | string {
-  if (width === '') return width
-  if (width !== undefined) {
-    width = Number.parseInt(width as string, 10)
-    if (Number.isNaN(width)) {
-      width = ''
-    }
-  }
-  return width
-}
-
-export function parseMinWidth(minWidth: number | string): number | string {
-  if (minWidth === '') return minWidth
-  if (minWidth !== undefined) {
-    minWidth = parseWidth(minWidth)
-    if (Number.isNaN(minWidth)) {
-      minWidth = 80
-    }
-  }
-  return minWidth
-}
-
-export function parseHeight(height: number | string) {
-  if (typeof height === 'number') {
-    return height
-  }
-  if (typeof height === 'string') {
-    if (/^\d+(?:px)?$/.test(height)) {
-      return Number.parseInt(height, 10)
-    } else {
-      return height
-    }
-  }
-  return null
-}
-
-// https://github.com/reduxjs/redux/blob/master/src/compose.js
-export function compose(...funcs) {
-  if (funcs.length === 0) {
-    return (arg) => arg
-  }
-  if (funcs.length === 1) {
-    return funcs[0]
-  }
-  return funcs.reduce(
-    (a, b) =>
-      (...args) =>
-        a(b(...args))
-  )
-}
-
-export function toggleRowStatus<T>(
-  statusArr: T[],
-  row: T,
-  newVal: boolean
-): boolean {
-  let changed = false
-  const index = statusArr.indexOf(row)
-  const included = index !== -1
-
-  const toggleStatus = (type: 'add' | 'remove') => {
-    if (type === 'add') {
-      statusArr.push(row)
-    } else {
-      statusArr.splice(index, 1)
-    }
-    changed = true
-    if (isArray(row.children)) {
-      row.children.forEach((item) => {
-        toggleRowStatus(statusArr, item, newVal ?? !included)
-      })
-    }
-  }
-
-  if (isBoolean(newVal)) {
-    if (newVal && !included) {
-      toggleStatus('add')
-    } else if (!newVal && included) {
-      toggleStatus('remove')
-    }
-  } else {
-    included ? toggleStatus('remove') : toggleStatus('add')
-  }
-  return changed
-}
-
-export function walkTreeNode(
-  root,
-  cb,
-  childrenKey = 'children',
-  lazyKey = 'hasChildren'
-) {
-  const isNil = (array) => !(Array.isArray(array) && array.length)
-
-  function _walker(parent, children, level) {
-    cb(parent, children, level)
-    children.forEach((item) => {
-      if (item[lazyKey]) {
-        cb(item, null, level + 1)
-        return
-      }
-      const children = item[childrenKey]
-      if (!isNil(children)) {
-        _walker(item, children, level + 1)
-      }
-    })
-  }
-
-  root.forEach((item) => {
-    if (item[lazyKey]) {
-      cb(item, null, 0)
-      return
-    }
-    const children = item[childrenKey]
-    if (!isNil(children)) {
-      _walker(item, children, 0)
-    }
-  })
-}
-
-export let removePopper: RemovePopperFn | null = null
-
-export function createTablePopper(
-  props: TableOverflowTooltipOptions,
-  popperContent: string,
-  trigger: HTMLElement,
-  table: Table<[]>
-) {
-  if (removePopper?.trigger === trigger) {
-    return
-  }
-  removePopper?.()
-  const parentNode = table?.refs.tableWrapper
-  const ns = parentNode?.dataset.prefix
-  const popperOptions = {
-    strategy: 'fixed',
-    ...props.popperOptions,
-  }
-  const vm = createVNode(ElTooltip, {
-    content: popperContent,
-    virtualTriggering: true,
-    virtualRef: trigger,
-    appendTo: parentNode,
-    placement: 'top',
-    transition: 'none', // Default does not require transition
-    offset: 0,
-    hideAfter: 0,
-    ...props,
-    popperOptions,
-    onHide: () => {
-      removePopper?.()
-    },
-  })
-  vm.appContext = { ...table.appContext, ...table }
-  const container = document.createElement('div')
-  render(vm, container)
-  vm.component!.exposed!.onOpen()
-  const scrollContainer = parentNode?.querySelector(`.${ns}-scrollbar__wrap`)
-  removePopper = () => {
-    render(null, container)
-    scrollContainer?.removeEventListener('scroll', removePopper!)
-    removePopper = null
-  }
-  removePopper.trigger = trigger
-  scrollContainer?.addEventListener('scroll', removePopper)
-}
-
-function getCurrentColumns<T>(column: TableColumnCtx<T>): TableColumnCtx<T>[] {
-  if (column.children) {
-    return flatMap(column.children, getCurrentColumns)
-  } else {
-    return [column]
-  }
-}
-
-function getColSpan<T>(colSpan: number, column: TableColumnCtx<T>) {
-  return colSpan + column.colSpan
-}
-
-export const isFixedColumn = <T>(
-  index: number,
-  fixed: string | boolean,
-  store: any,
-  realColumns?: TableColumnCtx<T>[]
-) => {
-  let start = 0
-  let after = index
-  const columns = store.states.columns.value
-  if (realColumns) {
-    // fixed column supported in grouped header
-    const curColumns = getCurrentColumns(realColumns[index])
-    const preColumns = columns.slice(0, columns.indexOf(curColumns[0]))
-
-    start = preColumns.reduce(getColSpan, 0)
-    after = start + curColumns.reduce(getColSpan, 0) - 1
-  } else {
-    start = index
-  }
-  let fixedLayout
-  switch (fixed) {
-    case 'left':
-      if (after < store.states.fixedLeafColumnsLength.value) {
-        fixedLayout = 'left'
-      }
-      break
-    case 'right':
-      if (
-        start >=
-        columns.length - store.states.rightFixedLeafColumnsLength.value
-      ) {
-        fixedLayout = 'right'
-      }
-      break
-    default:
-      if (after < store.states.fixedLeafColumnsLength.value) {
-        fixedLayout = 'left'
-      } else if (
-        start >=
-        columns.length - store.states.rightFixedLeafColumnsLength.value
-      ) {
-        fixedLayout = 'right'
-      }
-  }
-  return fixedLayout
-    ? {
-        direction: fixedLayout,
-        start,
-        after,
-      }
-    : {}
-}
-
-export const getFixedColumnsClass = <T>(
-  namespace: string,
-  index: number,
-  fixed: string | boolean,
-  store: any,
-  realColumns?: TableColumnCtx<T>[],
-  offset = 0
-) => {
-  const classes: string[] = []
-  const { direction, start, after } = isFixedColumn(
-    index,
-    fixed,
-    store,
-    realColumns
-  )
-  if (direction) {
-    const isLeft = direction === 'left'
-    classes.push(`${namespace}-fixed-column--${direction}`)
-    if (
-      isLeft &&
-      after + offset === store.states.fixedLeafColumnsLength.value - 1
-    ) {
-      classes.push('is-last-column')
-    } else if (
-      !isLeft &&
-      start - offset ===
-        store.states.columns.value.length -
-          store.states.rightFixedLeafColumnsLength.value
-    ) {
-      classes.push('is-first-column')
-    }
-  }
-  return classes
-}
-
-function getOffset<T>(offset: number, column: TableColumnCtx<T>) {
-  return (
-    offset +
-    (column.realWidth === null || Number.isNaN(column.realWidth)
-      ? Number(column.width)
-      : column.realWidth)
-  )
-}
-
-export const getFixedColumnOffset = <T>(
-  index: number,
-  fixed: string | boolean,
-  store: any,
-  realColumns?: TableColumnCtx<T>[]
-) => {
-  const {
-    direction,
-    start = 0,
-    after = 0,
-  } = isFixedColumn(index, fixed, store, realColumns)
-  if (!direction) {
-    return
-  }
-  const styles: any = {}
-  const isLeft = direction === 'left'
-  const columns = store.states.columns.value
-  if (isLeft) {
-    styles.left = columns.slice(0, start).reduce(getOffset, 0)
-  } else {
-    styles.right = columns
-      .slice(after + 1)
-      .reverse()
-      .reduce(getOffset, 0)
-  }
-  return styles
-}
-
-export const ensurePosition = (style, key: string) => {
-  if (!style) return
-  if (!Number.isNaN(style[key])) {
-    style[key] = `${style[key]}px`
-  }
-}

package/src-bak/components/table/style/css.ts

@@ -1,5 +0,0 @@
-import '@element-plus/components/base/style/css'
-import '@element-plus/theme-chalk/el-table.css'
-import '@element-plus/components/checkbox/style/css'
-import '@element-plus/components/tooltip/style/css'
-import '@element-plus/components/scrollbar/style/css'

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

@@ -1,5 +0,0 @@
-import '@element-plus/components/base/style'
-import '@element-plus/theme-chalk/src/table.scss'
-import '@element-plus/components/checkbox/style'
-import '@element-plus/components/tooltip/style'
-import '@element-plus/components/scrollbar/style'

package/src-bak/components/tabs/index.js

@@ -1,8 +0,0 @@
-import Tabs from './src/tabs.jsx'
-import TabPane from './src/tab-pane.vue'
-
-export default Tabs
-
-export {
-  TabPane
-}

package/src-bak/components/tabs/src/constants.js

@@ -1,23 +0,0 @@
-// import type { ComputedRef, InjectionKey, Ref, Slots, UnwrapRef } from 'vue'
-// import type { TabsProps } from './tabs'
-// import type { TabPaneProps } from './tab-pane'
-
-// export type TabsPaneContext = UnwrapRef<{
-//   uid: number
-//   slots: Slots
-//   props: TabPaneProps
-//   paneName: ComputedRef<string | number | undefined>
-//   active: ComputedRef<boolean>
-//   index: Ref<string | undefined>
-//   isClosable: ComputedRef<boolean>
-// }>
-
-// export interface TabsRootContext {
-//   props: TabsProps
-//   currentName: Ref<string | number>
-//   registerPane: (pane: TabsPaneContext) => void
-//   unregisterPane: (uid: number) => void
-// }
-
-export const tabsRootContextKey =
-  Symbol('tabsRootContextKey')

package/src-bak/components/tabs/src/tab-bar.js

@@ -1,8 +0,0 @@
-import { buildProps, definePropType, mutable } from 'element-plus/es/utils/index.mjs'
-
-export const tabBarProps = buildProps({
-  tabs: {
-    type: definePropType(Array),
-    default: () => mutable([]),
-  },
-})

package/src-bak/components/tabs/src/tab-bar.vue

@@ -1,92 +0,0 @@
-<template>
-  <div
-    ref="barRef"
-    :class="[ns.e('active-bar'), ns.is(rootTabs.props.tabPosition)]"
-    :style="barStyle"
-  />
-</template>
-
-<script setup>
-import { getCurrentInstance, defineOptions, defineProps, inject, nextTick, ref, watch } from 'vue'
-import { useResizeObserver } from '@vueuse/core'
-import { capitalize, throwError } from 'element-plus/es/utils/index.mjs'
-import { useNamespace } from 'element-plus/es/hooks/index.mjs'
-import { tabsRootContextKey } from './constants.js'
-import { tabBarProps } from './tab-bar'
-
-// import type { CSSProperties } from 'vue'
-
-const COMPONENT_NAME = 'ElTabBar'
-defineOptions({
-  name: COMPONENT_NAME,
-})
-const props = defineProps(tabBarProps)
-
-const instance = getCurrentInstance()
-const rootTabs = inject(tabsRootContextKey)
-if (!rootTabs) throwError(COMPONENT_NAME, '<el-tabs><el-tab-bar /></el-tabs>')
-
-const ns = useNamespace('tabs')
-
-const barRef = ref()
-const barStyle = ref()
-
-const getBarStyle = () => {
-  let offset = 0
-  let tabSize = 0
-
-  const sizeName = ['top', 'bottom'].includes(rootTabs.props.tabPosition)
-    ? 'width'
-    : 'height'
-  const sizeDir = sizeName === 'width' ? 'x' : 'y'
-  const position = sizeDir === 'x' ? 'left' : 'top'
-
-  props.tabs.every((tab) => {
-    const $el = instance.parent?.refs?.[`tab-${tab.uid}`]
-    if (!tab && !$el) return false
-
-    if (!tab.active) {
-      return true
-    }
-
-    offset = $el[`offset${capitalize(position)}`]
-    tabSize = $el[`client${capitalize(sizeName)}`]
-
-    const tabStyles = window.getComputedStyle($el)
-
-    if (sizeName === 'width') {
-      if (props.tabs.length > 1) {
-        tabSize -=
-          Number.parseFloat(tabStyles.paddingLeft) +
-          Number.parseFloat(tabStyles.paddingRight)
-      }
-      offset += Number.parseFloat(tabStyles.paddingLeft)
-    }
-    return false
-  })
-
-  return {
-    [sizeName]: `${tabSize}px`,
-    transform: `translate${capitalize(sizeDir)}(${offset}px)`,
-  }
-}
-
-const update = () => (barStyle.value = getBarStyle())
-
-watch(
-  () => props.tabs,
-  async () => {
-    await nextTick()
-    update()
-  },
-  { immediate: true }
-)
-useResizeObserver(barRef, () => update())
-
-defineExpose({
-  /** @description tab root html element */
-  ref: barRef,
-  /** @description method to manually update tab bar style */
-  update,
-})
-</script>