@antsoo-lib/components 0.1.11 → 0.1.12

package/src/vc-tree-select/TreeSelectContext.ts

@@ -1,27 +0,0 @@
-import type { InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-
-import type { ExpandAction } from '../vc-tree/props'
-import type { DefaultOptionType, InternalFieldName, OnInternalSelect } from './TreeSelect'
-
-export interface TreeSelectContextProps {
-  virtual?: boolean
-  dropdownMatchSelectWidth?: boolean | number
-  listHeight: number
-  listItemHeight: number
-  treeData: DefaultOptionType[]
-  fieldNames: InternalFieldName
-  onSelect: OnInternalSelect
-  treeExpandAction?: ExpandAction
-}
-
-const TreeSelectContextPropsKey: InjectionKey<TreeSelectContextProps> = Symbol(
-  'TreeSelectContextPropsKey',
-)
-
-export function useProvideSelectContext(props: TreeSelectContextProps) {
-  return provide(TreeSelectContextPropsKey, props)
-}
-export default function useInjectSelectContext() {
-  return inject(TreeSelectContextPropsKey, {} as TreeSelectContextProps)
-}

package/src/vc-tree-select/hooks/useCache.ts

@@ -1,44 +0,0 @@
-import type { Ref } from 'vue'
-import { computed, shallowRef, toRaw, watch } from 'vue'
-
-import type { LabeledValueType, RawValueType } from '../TreeSelect'
-
-/**
- * This function will try to call requestIdleCallback if available to save performance.
- * No need `getLabel` here since already fetch on `rawLabeledValue`.
- */
-export default (values: Ref<LabeledValueType[]>): [Ref<LabeledValueType[]>] => {
-  const cacheRef = shallowRef({
-    valueLabels: new Map<RawValueType, any>(),
-  })
-  const mergedValues = shallowRef()
-  watch(
-    values,
-    () => {
-      mergedValues.value = toRaw(values.value)
-    },
-    { immediate: true },
-  )
-  const newFilledValues = computed(() => {
-    const { valueLabels } = cacheRef.value
-    const valueLabelsCache = new Map<RawValueType, any>()
-
-    const filledValues = mergedValues.value.map((item) => {
-      const { value } = item
-      const mergedLabel = item.label ?? valueLabels.get(value)
-
-      // Save in cache
-      valueLabelsCache.set(value, mergedLabel)
-
-      return {
-        ...item,
-        label: mergedLabel,
-      }
-    })
-
-    cacheRef.value.valueLabels = valueLabelsCache
-
-    return filledValues
-  })
-  return [newFilledValues]
-}

package/src/vc-tree-select/hooks/useCheckedKeys.ts

@@ -1,39 +0,0 @@
-import type { Ref, ShallowRef } from 'vue'
-import { shallowRef, watchEffect } from 'vue'
-
-import type { Key } from '../../_util/type'
-import type { DataEntity } from '../../vc-tree/interface'
-import { conductCheck } from '../../vc-tree/utils/conductUtil'
-import type { LabeledValueType, RawValueType } from '../TreeSelect'
-
-export default (
-  rawLabeledValues: ShallowRef<LabeledValueType[]>,
-  rawHalfCheckedValues: ShallowRef<LabeledValueType[]>,
-  treeConduction: Ref<boolean>,
-  keyEntities: Ref<Record<Key, DataEntity>>,
-  maxLevel: Ref<number>,
-  levelEntities: ShallowRef<Map<number, Set<DataEntity>>>,
-) => {
-  const newRawCheckedValues = shallowRef<RawValueType[]>([])
-  const newRawHalfCheckedValues = shallowRef<RawValueType[]>([])
-
-  watchEffect(() => {
-    let checkedKeys: RawValueType[] = rawLabeledValues.value.map(({ value }) => value)
-    let halfCheckedKeys: RawValueType[] = rawHalfCheckedValues.value.map(({ value }) => value)
-
-    const missingValues = checkedKeys.filter((key) => !keyEntities.value[key])
-
-    if (treeConduction.value) {
-      ;({ checkedKeys, halfCheckedKeys } = conductCheck(
-        checkedKeys,
-        true,
-        keyEntities.value,
-        maxLevel.value,
-        levelEntities.value,
-      ))
-    }
-    newRawCheckedValues.value = Array.from(new Set([...missingValues, ...checkedKeys]))
-    newRawHalfCheckedValues.value = halfCheckedKeys
-  })
-  return [newRawCheckedValues, newRawHalfCheckedValues]
-}

package/src/vc-tree-select/hooks/useDataEntities.ts

@@ -1,42 +0,0 @@
-import type { Ref, ShallowRef } from 'vue'
-import { shallowRef, watchEffect } from 'vue'
-
-import type { DataEntity } from '../../vc-tree/interface'
-import { convertDataToEntities } from '../../vc-tree/utils/treeUtil'
-import { warning } from '../../vc-util/warning'
-import type { FieldNames, RawValueType } from '../TreeSelect'
-import { isNil } from '../utils/valueUtil'
-
-export default (treeData: ShallowRef<any>, fieldNames: Ref<FieldNames>) => {
-  const valueEntities = shallowRef(new Map<RawValueType, DataEntity>())
-  const keyEntities = shallowRef<Record<string, DataEntity>>({})
-  watchEffect(() => {
-    const fieldNamesValue = fieldNames.value
-    const collection = convertDataToEntities(treeData.value, {
-      fieldNames: fieldNamesValue,
-      initWrapper: (wrapper) => ({
-        ...wrapper,
-        valueEntities: new Map(),
-      }),
-      processEntity: (entity, wrapper: any) => {
-        const val = entity.node[fieldNamesValue.value]
-
-        // Check if exist same value
-        if (process.env.NODE_ENV !== 'production') {
-          const key = entity.node.key
-
-          warning(!isNil(val), 'TreeNode `value` is invalidate: undefined')
-          warning(!wrapper.valueEntities.has(val), `Same \`value\` exist in the tree: ${val}`)
-          warning(
-            !key || String(key) === String(val),
-            `\`key\` or \`value\` with TreeNode must be the same or you can remove one of them. key: ${key}, value: ${val}.`,
-          )
-        }
-        wrapper.valueEntities.set(val, entity)
-      },
-    }) as any
-    valueEntities.value = collection.valueEntities
-    keyEntities.value = collection.keyEntities
-  })
-  return { valueEntities, keyEntities }
-}

package/src/vc-tree-select/hooks/useFilterTreeData.ts

@@ -1,64 +0,0 @@
-import type { Ref, ShallowRef } from 'vue'
-import { computed } from 'vue'
-
-import type { DefaultOptionType, InternalFieldName, TreeSelectProps } from '../TreeSelect'
-import { fillLegacyProps } from '../utils/legacyUtil'
-
-type GetFuncType<T> = T extends boolean ? never : T
-type FilterFn = GetFuncType<TreeSelectProps['filterTreeNode']>
-
-export default (
-  treeData: ShallowRef<DefaultOptionType[]>,
-  searchValue: Ref<string>,
-  {
-    treeNodeFilterProp,
-    filterTreeNode,
-    fieldNames,
-  }: {
-    fieldNames: Ref<InternalFieldName>
-    treeNodeFilterProp: Ref<string>
-    filterTreeNode: Ref<TreeSelectProps['filterTreeNode']>
-  },
-) => {
-  return computed(() => {
-    const { children: fieldChildren } = fieldNames.value
-    const searchValueVal = searchValue.value
-    const treeNodeFilterPropValue = treeNodeFilterProp?.value
-    if (!searchValueVal || filterTreeNode.value === false) {
-      return treeData.value
-    }
-
-    let filterOptionFunc: FilterFn
-    if (typeof filterTreeNode.value === 'function') {
-      filterOptionFunc = filterTreeNode.value
-    } else {
-      const upperStr = searchValueVal.toUpperCase()
-      filterOptionFunc = (_, dataNode) => {
-        const value = dataNode[treeNodeFilterPropValue]
-
-        return String(value).toUpperCase().includes(upperStr)
-      }
-    }
-
-    function dig(list: DefaultOptionType[], keepAll = false) {
-      const res = []
-      for (let index = 0, len = list.length; index < len; index++) {
-        const dataNode = list[index]
-        const children = dataNode[fieldChildren]
-
-        const match = keepAll || filterOptionFunc(searchValueVal, fillLegacyProps(dataNode))
-        const childList = dig(children || [], match)
-
-        if (match || childList.length) {
-          res.push({
-            ...dataNode,
-            [fieldChildren]: childList,
-          })
-        }
-      }
-      return res
-    }
-
-    return dig(treeData.value)
-  })
-}

package/src/vc-tree-select/hooks/useTreeData.ts

@@ -1,75 +0,0 @@
-import type { Ref, ShallowRef } from 'vue'
-import { shallowRef, toRaw, watch } from 'vue'
-
-import type { VueNode } from '../../_util/type'
-import type { DefaultOptionType } from '../TreeSelect'
-import type { DataNode, SimpleModeConfig } from '../interface'
-import { convertChildrenToData } from '../utils/legacyUtil'
-
-function parseSimpleTreeData(
-  treeData: DataNode[],
-  { id, pId, rootPId }: SimpleModeConfig,
-): DataNode[] {
-  const keyNodes = {}
-  const rootNodeList = []
-
-  // Fill in the map
-  const nodeList = treeData.map((node) => {
-    const clone = { ...node }
-    const key = clone[id]
-    keyNodes[key] = clone
-    clone.key = clone.key || key
-    return clone
-  })
-
-  // Connect tree
-  nodeList.forEach((node) => {
-    const parentKey = node[pId]
-    const parent = keyNodes[parentKey]
-
-    // Fill parent
-    if (parent) {
-      parent.children = parent.children || []
-      parent.children.push(node)
-    }
-
-    // Fill root tree node
-    if (parentKey === rootPId || (!parent && rootPId === null)) {
-      rootNodeList.push(node)
-    }
-  })
-
-  return rootNodeList
-}
-
-/**
- * Convert `treeData` or `children` into formatted `treeData`.
- * Will not re-calculate if `treeData` or `children` not change.
- */
-export default function useTreeData(
-  treeData: Ref<DataNode[]>,
-  children: Ref<VueNode[]>,
-  simpleMode: Ref<boolean | SimpleModeConfig>,
-): ShallowRef<DefaultOptionType[]> {
-  const mergedTreeData = shallowRef<DefaultOptionType[]>()
-  watch(
-    [simpleMode, treeData, children],
-    () => {
-      const simpleModeValue = simpleMode.value
-      if (treeData.value) {
-        mergedTreeData.value = simpleMode.value
-          ? parseSimpleTreeData(toRaw(treeData.value), {
-              id: 'id',
-              pId: 'pId',
-              rootPId: null,
-              ...(simpleModeValue !== true ? simpleModeValue : {}),
-            })
-          : toRaw(treeData.value).slice()
-      } else {
-        mergedTreeData.value = convertChildrenToData(toRaw(children.value))
-      }
-    },
-    { immediate: true, deep: true },
-  )
-  return mergedTreeData
-}

package/src/vc-tree-select/index.tsx

@@ -1,10 +0,0 @@
-// base rc-tree-select@5.4.0
-import TreeNode from './TreeNode'
-import type { TreeSelectProps } from './TreeSelect'
-import TreeSelect, { treeSelectProps } from './TreeSelect'
-import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil'
-
-export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeNode, treeSelectProps }
-export type { TreeSelectProps }
-
-export default TreeSelect

package/src/vc-tree-select/interface.ts

@@ -1,101 +0,0 @@
-export type SelectSource = 'option' | 'selection' | 'input' | 'clear'
-
-export type Key = string | number
-
-export type RawValueType = string | number
-
-export interface LabelValueType {
-  key?: Key
-  value?: RawValueType
-  label?: any
-  /** Only works on `treeCheckStrictly` */
-  halfChecked?: boolean
-}
-
-export type DefaultValueType = RawValueType | RawValueType[] | LabelValueType | LabelValueType[]
-
-export interface DataNode {
-  value?: RawValueType
-  title?: any
-  label?: any
-  key?: Key
-  disabled?: boolean
-  disableCheckbox?: boolean
-  checkable?: boolean
-  selectable?: boolean
-  children?: DataNode[]
-
-  /** Customize data info */
-  [prop: string]: any
-}
-
-export interface InternalDataEntity {
-  key: Key
-  value: RawValueType
-  title?: any
-  checkable: boolean
-  disableCheckbox: boolean
-  disabled: boolean
-  selectable: boolean
-  isLeaf: boolean
-  children?: InternalDataEntity[]
-
-  /** Origin DataNode */
-  node: DataNode
-
-  dataRef: DataNode
-
-  slots?: Record<string, string> // 兼容 V2
-}
-
-export interface LegacyDataNode extends DataNode {
-  props: any
-}
-
-export interface TreeDataNode extends DataNode {
-  key: Key
-  children?: TreeDataNode[]
-}
-
-export interface FlattenDataNode {
-  data: InternalDataEntity
-  key: Key
-  value: RawValueType
-  level: number
-  parent?: FlattenDataNode
-}
-
-export interface SimpleModeConfig {
-  id?: Key
-  pId?: Key
-  rootPId?: Key
-}
-
-/** @deprecated This is only used for legacy compatible. Not works on new code. */
-export interface LegacyCheckedNode {
-  pos: string
-  node: any
-  children?: LegacyCheckedNode[]
-}
-
-export interface ChangeEventExtra {
-  /** @deprecated Please save prev value by control logic instead */
-  preValue: LabelValueType[]
-  triggerValue: RawValueType
-  /** @deprecated Use `onSelect` or `onDeselect` instead. */
-  selected?: boolean
-  /** @deprecated Use `onSelect` or `onDeselect` instead. */
-  checked?: boolean
-
-  // Not sure if exist user still use this. We have to keep but not recommend user to use
-  /** @deprecated This prop not work as react node anymore. */
-  triggerNode: any
-  /** @deprecated This prop not work as react node anymore. */
-  allCheckedNodes: LegacyCheckedNode[]
-}
-
-export interface FieldNames {
-  value?: string
-  label?: string
-  children?: string
-}

package/src/vc-tree-select/utils/legacyUtil.tsx

@@ -1,180 +0,0 @@
-import { camelize, filterEmpty } from '../../_util/props-util'
-import type { VueNode } from '../../_util/type'
-import { warning } from '../../vc-util/warning'
-import TreeNode from '../TreeNode'
-import type { DefaultOptionType, FieldNames } from '../TreeSelect'
-import type { ChangeEventExtra, DataNode, LegacyCheckedNode, RawValueType } from '../interface'
-
-function isTreeSelectNode(node: any) {
-  return node && node.type && (node.type as any).isTreeSelectNode
-}
-export function convertChildrenToData(rootNodes: VueNode[]): DataNode[] {
-  function dig(treeNodes: any[] = []): DataNode[] {
-    return filterEmpty(treeNodes).map((treeNode) => {
-      // Filter invalidate node
-      if (!isTreeSelectNode(treeNode)) {
-        warning(!treeNode, 'TreeSelect/TreeSelectNode can only accept TreeSelectNode as children.')
-        return null
-      }
-      const slots = (treeNode.children as any) || {}
-      const key = treeNode.key as string | number
-      const props: any = {}
-      for (const [k, v] of Object.entries(treeNode.props)) {
-        props[camelize(k)] = v
-      }
-      const { isLeaf, checkable, selectable, disabled, disableCheckbox } = props
-      // 默认值为 undefined
-      const newProps = {
-        isLeaf: isLeaf || isLeaf === '' || undefined,
-        checkable: checkable || checkable === '' || undefined,
-        selectable: selectable || selectable === '' || undefined,
-        disabled: disabled || disabled === '' || undefined,
-        disableCheckbox: disableCheckbox || disableCheckbox === '' || undefined,
-      }
-      const slotsProps = { ...props, ...newProps }
-      const {
-        title = slots.title?.(slotsProps),
-        switcherIcon = slots.switcherIcon?.(slotsProps),
-        ...rest
-      } = props
-      const children = slots.default?.()
-      const dataNode: DataNode = {
-        ...rest,
-        title,
-        switcherIcon,
-        key,
-        isLeaf,
-        ...newProps,
-      }
-
-      const parsedChildren = dig(children)
-      if (parsedChildren.length) {
-        dataNode.children = parsedChildren
-      }
-
-      return dataNode
-    })
-  }
-
-  return dig(rootNodes as any[])
-}
-
-export function fillLegacyProps(dataNode: DataNode): any {
-  // Skip if not dataNode exist
-  if (!dataNode) {
-    return dataNode
-  }
-
-  const cloneNode = { ...dataNode }
-
-  if (!('props' in cloneNode)) {
-    Object.defineProperty(cloneNode, 'props', {
-      get() {
-        warning(
-          false,
-          'New `vc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.',
-        )
-        return cloneNode
-      },
-    })
-  }
-
-  return cloneNode
-}
-
-export function fillAdditionalInfo(
-  extra: ChangeEventExtra,
-  triggerValue: RawValueType,
-  checkedValues: RawValueType[],
-  treeData: DefaultOptionType[],
-  showPosition: boolean,
-  fieldNames: FieldNames,
-) {
-  let triggerNode = null
-  let nodeList: LegacyCheckedNode[] = null
-
-  function generateMap() {
-    function dig(list: DefaultOptionType[], level = '0', parentIncluded = false) {
-      return list
-        .map((option, index) => {
-          const pos = `${level}-${index}`
-          const value = option[fieldNames.value]
-          const included = checkedValues.includes(value)
-          const children = dig(option[fieldNames.children] || [], pos, included)
-          const node = (
-            <TreeNode {...(option as Required<DefaultOptionType>)}>
-              {children.map((child) => child.node)}
-            </TreeNode>
-          )
-
-          // Link with trigger node
-          if (triggerValue === value) {
-            triggerNode = node
-          }
-
-          if (included) {
-            const checkedNode: LegacyCheckedNode = {
-              pos,
-              node,
-              children,
-            }
-
-            if (!parentIncluded) {
-              nodeList.push(checkedNode)
-            }
-
-            return checkedNode
-          }
-          return null
-        })
-        .filter((node) => node)
-    }
-
-    if (!nodeList) {
-      nodeList = []
-
-      dig(treeData)
-
-      // Sort to keep the checked node length
-      nodeList.sort(
-        (
-          {
-            node: {
-              props: { value: val1 },
-            },
-          },
-          {
-            node: {
-              props: { value: val2 },
-            },
-          },
-        ) => {
-          const index1 = checkedValues.indexOf(val1)
-          const index2 = checkedValues.indexOf(val2)
-          return index1 - index2
-        },
-      )
-    }
-  }
-
-  Object.defineProperty(extra, 'triggerNode', {
-    get() {
-      warning(false, '`triggerNode` is deprecated. Please consider decoupling data with node.')
-      generateMap()
-
-      return triggerNode
-    },
-  })
-  Object.defineProperty(extra, 'allCheckedNodes', {
-    get() {
-      warning(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.')
-      generateMap()
-
-      if (showPosition) {
-        return nodeList
-      }
-
-      return nodeList.map(({ node }) => node)
-    },
-  })
-}

package/src/vc-tree-select/utils/strategyUtil.ts

@@ -1,48 +0,0 @@
-import type { DataEntity } from '../../vc-tree/interface'
-import type { InternalFieldName } from '../TreeSelect'
-import type { Key, RawValueType } from '../interface'
-import { isCheckDisabled } from './valueUtil'
-
-export const SHOW_ALL = 'SHOW_ALL'
-export const SHOW_PARENT = 'SHOW_PARENT'
-export const SHOW_CHILD = 'SHOW_CHILD'
-
-export type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD
-
-export function formatStrategyValues(
-  values: Key[],
-  strategy: CheckedStrategy,
-  keyEntities: Record<Key, DataEntity>,
-  fieldNames: InternalFieldName,
-): RawValueType[] {
-  const valueSet = new Set(values)
-
-  if (strategy === SHOW_CHILD) {
-    return values.filter((key) => {
-      const entity = keyEntities[key]
-
-      if (
-        entity &&
-        entity.children &&
-        entity.children.some(({ node }) => valueSet.has(node[fieldNames.value])) &&
-        entity.children.every(
-          ({ node }) => isCheckDisabled(node) || valueSet.has(node[fieldNames.value]),
-        )
-      ) {
-        return false
-      }
-      return true
-    })
-  }
-  if (strategy === SHOW_PARENT) {
-    return values.filter((key) => {
-      const entity = keyEntities[key]
-      const parent = entity ? entity.parent : null
-      if (parent && !isCheckDisabled(parent.node) && valueSet.has(parent.key)) {
-        return false
-      }
-      return true
-    })
-  }
-  return values
-}

package/src/vc-tree-select/utils/valueUtil.ts

@@ -1,50 +0,0 @@
-import type { DefaultOptionType, InternalFieldName } from '../TreeSelect'
-import type { DataNode, FieldNames, Key } from '../interface'
-
-export function toArray<T>(value: T | T[]): T[] {
-  if (Array.isArray(value)) {
-    return value
-  }
-  return value !== undefined ? [value] : []
-}
-
-export function fillFieldNames(fieldNames?: FieldNames) {
-  const { label, value, children } = fieldNames || {}
-
-  const mergedValue = value || 'value'
-
-  return {
-    _title: label ? [label] : ['title', 'label'],
-    value: mergedValue,
-    key: mergedValue,
-    children: children || 'children',
-  }
-}
-
-export function isCheckDisabled(node: DataNode) {
-  return node.disabled || node.disableCheckbox || node.checkable === false
-}
-
-/** Loop fetch all the keys exist in the tree */
-export function getAllKeys(treeData: DefaultOptionType[], fieldNames: InternalFieldName) {
-  const keys: Key[] = []
-
-  function dig(list: DefaultOptionType[]) {
-    list.forEach((item) => {
-      keys.push(item[fieldNames.value])
-
-      const children = item[fieldNames.children]
-      if (children) {
-        dig(children)
-      }
-    })
-  }
-
-  dig(treeData)
-
-  return keys
-}
-
-export function isNil(val: any) {
-  return val === null || val === undefined
-}