@antsoo-lib/components 0.1.11 → 0.1.13

package/src/vc-table/constant.ts

@@ -1 +0,0 @@
-export const EXPAND_COLUMN = {} as const

package/src/vc-table/context/BodyContext.tsx

@@ -1,41 +0,0 @@
-import type { InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-
-import type {
-  ColumnType,
-  ColumnsType,
-  DefaultRecordType,
-  ExpandableType,
-  ExpandedRowRender,
-  RenderExpandIcon,
-  RowClassName,
-  TableLayout,
-  TriggerEventHandler,
-} from '../interface'
-
-export interface BodyContextProps<RecordType = DefaultRecordType> {
-  rowClassName: string | RowClassName<RecordType>
-  expandedRowClassName: RowClassName<RecordType>
-
-  columns: ColumnsType<RecordType>
-  flattenColumns: readonly ColumnType<RecordType>[]
-
-  tableLayout: TableLayout
-
-  indentSize: number
-  expandableType: ExpandableType
-  expandRowByClick: boolean
-  expandedRowRender: ExpandedRowRender<RecordType>
-  expandIcon: RenderExpandIcon<RecordType>
-  onTriggerExpand: TriggerEventHandler<RecordType>
-  expandIconColumnIndex: number
-}
-export const BodyContextKey: InjectionKey<BodyContextProps> = Symbol('BodyContextProps')
-
-export const useProvideBody = (props: BodyContextProps) => {
-  provide(BodyContextKey, props)
-}
-
-export const useInjectBody = () => {
-  return inject(BodyContextKey, {} as BodyContextProps)
-}

package/src/vc-table/context/ExpandedRowContext.tsx

@@ -1,18 +0,0 @@
-import type { InjectionKey, Ref } from 'vue'
-import { inject, provide } from 'vue'
-
-export interface ExpandedRowProps {
-  componentWidth: Ref<number>
-  fixHeader: Ref<boolean>
-  fixColumn: Ref<boolean>
-  horizonScroll: Ref<boolean>
-}
-export const ExpandedRowContextKey: InjectionKey<ExpandedRowProps> = Symbol('ExpandedRowProps')
-
-export const useProvideExpandedRow = (props: ExpandedRowProps) => {
-  provide(ExpandedRowContextKey, props)
-}
-
-export const useInjectExpandedRow = () => {
-  return inject(ExpandedRowContextKey, {} as ExpandedRowProps)
-}

package/src/vc-table/context/HoverContext.tsx

@@ -1,21 +0,0 @@
-import type { InjectionKey, Ref } from 'vue'
-import { inject, provide, shallowRef } from 'vue'
-
-export interface HoverContextProps {
-  startRow: Ref<number>
-  endRow: Ref<number>
-  onHover: (start: number, end: number) => void
-}
-export const HoverContextKey: InjectionKey<HoverContextProps> = Symbol('HoverContextProps')
-
-export const useProvideHover = (props: HoverContextProps) => {
-  provide(HoverContextKey, props)
-}
-
-export const useInjectHover = () => {
-  return inject(HoverContextKey, {
-    startRow: shallowRef(-1),
-    endRow: shallowRef(-1),
-    onHover() {},
-  } as HoverContextProps)
-}

package/src/vc-table/context/ResizeContext.tsx

@@ -1,18 +0,0 @@
-import type { InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-
-import type { Key } from '../interface'
-
-interface ResizeContextProps {
-  onColumnResize: (columnKey: Key, width: number) => void
-}
-
-export const ResizeContextKey: InjectionKey<ResizeContextProps> = Symbol('ResizeContextProps')
-
-export const useProvideResize = (props: ResizeContextProps) => {
-  provide(ResizeContextKey, props)
-}
-
-export const useInjectResize = () => {
-  return inject(ResizeContextKey, { onColumnResize: () => {} })
-}

package/src/vc-table/context/StickyContext.tsx

@@ -1,14 +0,0 @@
-import { onMounted, shallowRef } from 'vue'
-
-import isStyleSupport from '../../_util/styleChecker'
-
-const supportSticky = shallowRef(false)
-export const useProvideSticky = () => {
-  onMounted(() => {
-    supportSticky.value = supportSticky.value || isStyleSupport('position', 'sticky')
-  })
-}
-
-export const useInjectSticky = () => {
-  return supportSticky
-}

package/src/vc-table/context/SummaryContext.tsx

@@ -1,23 +0,0 @@
-import type { InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-
-import type { ColumnType, StickyOffsets } from '../interface'
-
-export type FlattenColumns<RecordType> = readonly (ColumnType<RecordType> & {
-  scrollbar?: boolean
-})[]
-interface SummaryContextProps {
-  stickyOffsets?: StickyOffsets
-  scrollColumnIndex?: number
-  flattenColumns?: FlattenColumns<any>
-}
-
-export const SummaryContextKey: InjectionKey<SummaryContextProps> = Symbol('SummaryContextProps')
-
-export const useProvideSummary = (props: SummaryContextProps) => {
-  provide(SummaryContextKey, props)
-}
-
-export const useInjectSummary = () => {
-  return inject(SummaryContextKey, {} as SummaryContextProps)
-}

package/src/vc-table/context/TableContext.tsx

@@ -1,34 +0,0 @@
-import type { InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-
-import type { GetComponent, TransformCellText } from '../interface'
-import type { FixedInfo } from '../utils/fixUtil'
-
-export interface TableContextProps {
-  // Table context
-  prefixCls: string
-
-  getComponent: GetComponent
-
-  scrollbarSize: number
-
-  direction: 'ltr' | 'rtl'
-
-  fixedInfoList: readonly FixedInfo[]
-
-  isSticky: boolean
-
-  summaryCollect: (uniKey: string, fixed: boolean | string) => void
-
-  transformCellText: TransformCellText<unknown>
-}
-
-export const TableContextKey: InjectionKey<TableContextProps> = Symbol('TableContextProps')
-
-export const useProvideTable = (props: TableContextProps) => {
-  provide(TableContextKey, props)
-}
-
-export const useInjectTable = () => {
-  return inject(TableContextKey, {} as TableContextProps)
-}

package/src/vc-table/hooks/useColumns.tsx

@@ -1,251 +0,0 @@
-import type { ComputedRef, Ref } from 'vue'
-import { computed, watchEffect } from 'vue'
-
-import { customRenderSlot } from '../../_util/vnode'
-import { useInjectSlots } from '../../table/context'
-import { warning } from '../../vc-util/warning'
-import { EXPAND_COLUMN } from '../constant'
-import type {
-  ColumnGroupType,
-  ColumnType,
-  ColumnsType,
-  FixedType,
-  GetRowKey,
-  Key,
-  RenderExpandIcon,
-  TriggerEventHandler,
-} from '../interface'
-import { INTERNAL_COL_DEFINE } from '../utils/legacyUtil'
-
-function flatColumns<RecordType>(columns: ColumnsType<RecordType>): ColumnType<RecordType>[] {
-  return columns.reduce((list, column) => {
-    const { fixed } = column
-
-    // Convert `fixed='true'` to `fixed='left'` instead
-    const parsedFixed = fixed === true ? 'left' : fixed
-
-    const subColumns = (column as ColumnGroupType<RecordType>).children
-    if (subColumns && subColumns.length > 0) {
-      return [
-        ...list,
-        ...flatColumns(subColumns).map((subColum) => ({
-          fixed: parsedFixed,
-          ...subColum,
-        })),
-      ]
-    }
-    return [
-      ...list,
-      {
-        ...column,
-        fixed: parsedFixed,
-      },
-    ]
-  }, [])
-}
-
-function warningFixed(flattenColumns: readonly { fixed?: FixedType }[]) {
-  let allFixLeft = true
-  for (let i = 0; i < flattenColumns.length; i += 1) {
-    const col = flattenColumns[i]
-    if (allFixLeft && col.fixed !== 'left') {
-      allFixLeft = false
-    } else if (!allFixLeft && col.fixed === 'left') {
-      warning(false, `Index ${i - 1} of \`columns\` missing \`fixed='left'\` prop.`)
-      break
-    }
-  }
-
-  let allFixRight = true
-  for (let i = flattenColumns.length - 1; i >= 0; i -= 1) {
-    const col = flattenColumns[i]
-    if (allFixRight && col.fixed !== 'right') {
-      allFixRight = false
-    } else if (!allFixRight && col.fixed === 'right') {
-      warning(false, `Index ${i + 1} of \`columns\` missing \`fixed='right'\` prop.`)
-      break
-    }
-  }
-}
-
-function revertForRtl<RecordType>(columns: ColumnsType<RecordType>): ColumnsType<RecordType> {
-  return columns.map((column) => {
-    const { fixed, ...restProps } = column
-
-    // Convert `fixed='left'` to `fixed='right'` instead
-    let parsedFixed = fixed
-    if (fixed === 'left') {
-      parsedFixed = 'right'
-    } else if (fixed === 'right') {
-      parsedFixed = 'left'
-    }
-    return {
-      fixed: parsedFixed,
-      ...restProps,
-    }
-  })
-}
-
-/**
- * Parse `columns` & `children` into `columns`.
- */
-function useColumns<RecordType>(
-  {
-    prefixCls,
-    columns: baseColumns,
-    // children,
-    expandable,
-    expandedKeys,
-    getRowKey,
-    onTriggerExpand,
-    expandIcon,
-    rowExpandable,
-    expandIconColumnIndex,
-    direction,
-    expandRowByClick,
-    expandColumnWidth,
-    expandFixed,
-  }: {
-    prefixCls?: Ref<string>
-    columns?: Ref<ColumnsType<RecordType>>
-    expandable: Ref<boolean>
-    expandedKeys: ComputedRef<Set<Key>>
-    getRowKey: Ref<GetRowKey<RecordType>>
-    onTriggerExpand: TriggerEventHandler<RecordType>
-    expandIcon?: Ref<RenderExpandIcon<RecordType>>
-    rowExpandable?: Ref<(record: RecordType) => boolean>
-    expandIconColumnIndex?: Ref<number>
-    direction?: Ref<'ltr' | 'rtl'>
-    expandRowByClick?: Ref<boolean>
-    expandColumnWidth?: Ref<number | string>
-    expandFixed?: Ref<FixedType>
-  },
-  transformColumns: Ref<(columns: ColumnsType<RecordType>) => ColumnsType<RecordType>>,
-): [ComputedRef<ColumnsType<RecordType>>, ComputedRef<readonly ColumnType<RecordType>[]>] {
-  const contextSlots = useInjectSlots()
-  // Add expand column
-  const withExpandColumns = computed<ColumnsType<RecordType>>(() => {
-    if (expandable.value) {
-      let cloneColumns = baseColumns.value.slice()
-
-      // >>> Warning if use `expandIconColumnIndex`
-      if (process.env.NODE_ENV !== 'production' && expandIconColumnIndex.value >= 0) {
-        warning(
-          false,
-          '`expandIconColumnIndex` is deprecated. Please use `Table.EXPAND_COLUMN` in `columns` instead.',
-        )
-      }
-
-      // >>> Insert expand column if not exist
-      if (!cloneColumns.includes(EXPAND_COLUMN)) {
-        const expandColIndex = expandIconColumnIndex.value || 0
-        if (expandColIndex >= 0) {
-          cloneColumns.splice(expandColIndex, 0, EXPAND_COLUMN)
-        }
-      }
-
-      // >>> Deduplicate additional expand column
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        cloneColumns.filter((c) => c === EXPAND_COLUMN).length > 1
-      ) {
-        warning(false, 'There exist more than one `EXPAND_COLUMN` in `columns`.')
-      }
-      const expandColumnIndex = cloneColumns.indexOf(EXPAND_COLUMN)
-      cloneColumns = cloneColumns.filter(
-        (column, index) => column !== EXPAND_COLUMN || index === expandColumnIndex,
-      )
-
-      // >>> Check if expand column need to fixed
-      const prevColumn = baseColumns.value[expandColumnIndex]
-
-      let fixedColumn: FixedType | null
-      if ((expandFixed.value === 'left' || expandFixed.value) && !expandIconColumnIndex.value) {
-        fixedColumn = 'left'
-      } else if (
-        (expandFixed.value === 'right' || expandFixed.value) &&
-        expandIconColumnIndex.value === baseColumns.value.length
-      ) {
-        fixedColumn = 'right'
-      } else {
-        fixedColumn = prevColumn ? prevColumn.fixed : null
-      }
-      const expandedKeysValue = expandedKeys.value
-      const rowExpandableValue = rowExpandable.value
-      const expandIconValue = expandIcon.value
-      const prefixClsValue = prefixCls.value
-      const expandRowByClickValue = expandRowByClick.value
-      // >>> Create expandable column
-      const expandColumn = {
-        [INTERNAL_COL_DEFINE]: {
-          class: `${prefixCls.value}-expand-icon-col`,
-          columnType: 'EXPAND_COLUMN',
-        },
-        title: customRenderSlot(contextSlots.value, 'expandColumnTitle', {}, () => ['']),
-        fixed: fixedColumn,
-        class: `${prefixCls.value}-row-expand-icon-cell`,
-        width: expandColumnWidth.value,
-        customRender: ({ record, index }) => {
-          const rowKey = getRowKey.value(record, index)
-          const expanded = expandedKeysValue.has(rowKey)
-          const recordExpandable = rowExpandableValue ? rowExpandableValue(record) : true
-
-          const icon = expandIconValue({
-            prefixCls: prefixClsValue,
-            expanded,
-            expandable: recordExpandable,
-            record,
-            onExpand: onTriggerExpand,
-          })
-
-          if (expandRowByClickValue) {
-            return <span onClick={(e) => e.stopPropagation()}>{icon}</span>
-          }
-          return icon
-        },
-      }
-
-      return cloneColumns.map((col) => (col === EXPAND_COLUMN ? expandColumn : col))
-    }
-    if (process.env.NODE_ENV !== 'production' && baseColumns.value.includes(EXPAND_COLUMN)) {
-      warning(false, '`expandable` is not config but there exist `EXPAND_COLUMN` in `columns`.')
-    }
-
-    return baseColumns.value.filter((col) => col !== EXPAND_COLUMN)
-  })
-
-  const mergedColumns = computed(() => {
-    let finalColumns = withExpandColumns.value
-    if (transformColumns.value) {
-      finalColumns = transformColumns.value(finalColumns)
-    }
-
-    // Always provides at least one column for table display
-    if (!finalColumns.length) {
-      finalColumns = [
-        {
-          customRender: () => null,
-        },
-      ]
-    }
-    return finalColumns
-  })
-
-  const flattenColumns = computed(() => {
-    if (direction.value === 'rtl') {
-      return revertForRtl(flatColumns(mergedColumns.value))
-    }
-    return flatColumns(mergedColumns.value)
-  })
-  // Only check out of production since it's waste for each render
-  if (process.env.NODE_ENV !== 'production') {
-    watchEffect(() => {
-      setTimeout(() => {
-        warningFixed(flattenColumns.value)
-      })
-    })
-  }
-  return [mergedColumns, flattenColumns]
-}
-
-export default useColumns

package/src/vc-table/hooks/useFlattenRecords.ts

@@ -1,90 +0,0 @@
-import type { Ref } from 'vue'
-import { computed } from 'vue'
-
-import type { GetRowKey, Key } from '../interface'
-
-// recursion (flat tree structure)
-function flatRecord<T>(
-  record: T,
-  indent: number,
-  childrenColumnName: string,
-  expandedKeys: Set<Key>,
-  getRowKey: GetRowKey<T>,
-  index: number,
-) {
-  const arr = []
-
-  arr.push({
-    record,
-    indent,
-    index,
-  })
-
-  const key = getRowKey(record)
-
-  const expanded = expandedKeys?.has(key)
-
-  if (record && Array.isArray(record[childrenColumnName]) && expanded) {
-    // expanded state, flat record
-    for (let i = 0; i < record[childrenColumnName].length; i += 1) {
-      const tempArr = flatRecord(
-        record[childrenColumnName][i],
-        indent + 1,
-        childrenColumnName,
-        expandedKeys,
-        getRowKey,
-        i,
-      )
-
-      arr.push(...tempArr)
-    }
-  }
-
-  return arr
-}
-
-/**
- * flat tree data on expanded state
- *
- * @export
- * @template T
- * @param {*} data : table data
- * @param {string} childrenColumnName : 指定树形结构的列名
- * @param {Set<Key>} expandedKeys : 展开的行对应的keys
- * @param {GetRowKey<T>} getRowKey  : 获取当前rowKey的方法
- * @returns flattened data
- */
-export default function useFlattenRecords<T = unknown>(
-  dataRef: Ref<T[]>,
-  childrenColumnNameRef: Ref<string>,
-  expandedKeysRef: Ref<Set<Key>>,
-  getRowKey: Ref<GetRowKey<T>>,
-) {
-  const arr: Ref<{ record: T; indent: number; index: number }[]> = computed(() => {
-    const childrenColumnName = childrenColumnNameRef.value
-    const expandedKeys = expandedKeysRef.value
-    const data = dataRef.value
-    if (expandedKeys?.size) {
-      const temp: { record: T; indent: number; index: number }[] = []
-
-      // collect flattened record
-      for (let i = 0; i < data?.length; i += 1) {
-        const record = data[i]
-
-        temp.push(...flatRecord<T>(record, 0, childrenColumnName, expandedKeys, getRowKey.value, i))
-      }
-
-      return temp
-    }
-
-    return data?.map((item, index) => {
-      return {
-        record: item,
-        indent: 0,
-        index,
-      }
-    })
-  })
-
-  return arr
-}

package/src/vc-table/hooks/useFrame.ts

@@ -1,63 +0,0 @@
-import type { Ref, UnwrapRef } from 'vue'
-import { onBeforeUnmount, ref, shallowRef } from 'vue'
-
-import raf from '../../_util/raf'
-
-export type Updater<State> = (prev: State) => State
-
-export function useLayoutState<State>(
-  defaultState: State,
-): [Ref<State>, (updater: Updater<State>) => void] {
-  const stateRef = shallowRef<State>(defaultState)
-  let rafId: number
-  const updateBatchRef = shallowRef<Updater<State>[]>([])
-  function setFrameState(updater: Updater<State>) {
-    updateBatchRef.value.push(updater)
-    raf.cancel(rafId)
-    rafId = raf(() => {
-      const prevBatch = updateBatchRef.value
-      // const prevState = stateRef.value;
-      updateBatchRef.value = []
-      prevBatch.forEach((batchUpdater) => {
-        stateRef.value = batchUpdater(stateRef.value as State)
-      })
-    })
-  }
-  onBeforeUnmount(() => {
-    raf.cancel(rafId)
-  })
-
-  return [stateRef as Ref<State>, setFrameState]
-}
-
-/** Lock frame, when frame pass reset the lock. */
-export function useTimeoutLock<State>(
-  defaultState?: State,
-): [(state: UnwrapRef<State>) => void, () => UnwrapRef<State> | null] {
-  const frameRef = ref<State | null>(defaultState || null)
-  const timeoutRef = ref<any>()
-
-  function cleanUp() {
-    clearTimeout(timeoutRef.value)
-  }
-
-  function setState(newState: UnwrapRef<State>) {
-    frameRef.value = newState
-    cleanUp()
-
-    timeoutRef.value = setTimeout(() => {
-      frameRef.value = null
-      timeoutRef.value = undefined
-    }, 100)
-  }
-
-  function getState() {
-    return frameRef.value
-  }
-
-  onBeforeUnmount(() => {
-    cleanUp()
-  })
-
-  return [setState, getState]
-}

package/src/vc-table/hooks/useSticky.ts

@@ -1,41 +0,0 @@
-import type { ComputedRef, Ref } from 'vue'
-import { computed } from 'vue'
-
-import canUseDom from '../../_util/canUseDom'
-import type { TableSticky } from '../interface'
-
-// fix ssr render
-const defaultContainer = canUseDom() ? window : null
-
-/** Sticky header hooks */
-export default function useSticky(
-  stickyRef: Ref<boolean | TableSticky>,
-  prefixClsRef: Ref<string>,
-): ComputedRef<{
-  isSticky: boolean
-  offsetHeader: number
-  offsetSummary: number
-  offsetScroll: number
-  stickyClassName: string
-  container: Window | HTMLElement
-}> {
-  return computed(() => {
-    const {
-      offsetHeader = 0,
-      offsetSummary = 0,
-      offsetScroll = 0,
-      getContainer = () => defaultContainer,
-    } = typeof stickyRef.value === 'object' ? stickyRef.value : {}
-
-    const container = getContainer() || defaultContainer
-    const isSticky = !!stickyRef.value
-    return {
-      isSticky,
-      stickyClassName: isSticky ? `${prefixClsRef.value}-sticky-holder` : '',
-      offsetHeader,
-      offsetSummary,
-      offsetScroll,
-      container,
-    }
-  })
-}

package/src/vc-table/hooks/useStickyOffsets.ts

@@ -1,55 +0,0 @@
-import type { ComputedRef, Ref } from 'vue'
-import { computed } from 'vue'
-
-import type { StickyOffsets } from '../interface'
-
-/**
- * Get sticky column offset width
- */
-function useStickyOffsets(
-  colWidthsRef: Ref<number[]>,
-  columnCountRef: Ref<number>,
-  directionRef: Ref<'ltr' | 'rtl'>,
-) {
-  const stickyOffsets: ComputedRef<StickyOffsets> = computed(() => {
-    const leftOffsets: number[] = []
-    const rightOffsets: number[] = []
-    let left = 0
-    let right = 0
-
-    const colWidths = colWidthsRef.value
-    const columnCount = columnCountRef.value
-    const direction = directionRef.value
-
-    for (let start = 0; start < columnCount; start += 1) {
-      if (direction === 'rtl') {
-        // Left offset
-        rightOffsets[start] = right
-        right += colWidths[start] || 0
-
-        // Right offset
-        const end = columnCount - start - 1
-        leftOffsets[end] = left
-        left += colWidths[end] || 0
-      } else {
-        // Left offset
-        leftOffsets[start] = left
-        left += colWidths[start] || 0
-
-        // Right offset
-        const end = columnCount - start - 1
-        rightOffsets[end] = right
-        right += colWidths[end] || 0
-      }
-    }
-
-    return {
-      left: leftOffsets,
-      right: rightOffsets,
-    }
-  })
-
-  return stickyOffsets
-}
-
-export default useStickyOffsets

package/src/vc-table/index.ts

@@ -1,11 +0,0 @@
-// base rc-table@7.22.2
-import { FooterComponents as Summary, SummaryCell, SummaryRow } from './Footer'
-import Table from './Table'
-import { EXPAND_COLUMN } from './constant'
-import Column from './sugar/Column'
-import ColumnGroup from './sugar/ColumnGroup'
-import { INTERNAL_COL_DEFINE } from './utils/legacyUtil'
-
-export { Column, ColumnGroup, EXPAND_COLUMN, INTERNAL_COL_DEFINE, Summary, SummaryCell, SummaryRow }
-
-export default Table