@antsoo-lib/components 0.1.11 → 0.1.12

package/src/vc-tree/contextTypes.ts

@@ -1,149 +0,0 @@
-/**
- * Webpack has bug for import loop, which is not the same behavior as ES module.
- * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
- */
-import type { ComputedRef, InjectionKey, PropType, ShallowRef } from 'vue'
-import { computed, defineComponent, inject, provide, shallowRef } from 'vue'
-
-import type { VueNode } from '../_util/type'
-import type { DraggableConfig } from './Tree'
-import type {
-  DataEntity,
-  Direction,
-  DragNodeEvent,
-  EventDataNode,
-  FlattenNode,
-  IconType,
-  Key,
-} from './interface'
-
-export interface NodeMouseEventParams {
-  event: MouseEvent
-  node: EventDataNode
-}
-export interface NodeDragEventParams {
-  event: DragEvent
-  node: EventDataNode
-}
-
-export type NodeMouseEventHandler = (e: MouseEvent, node: EventDataNode) => void
-export type NodeDragEventHandler = (
-  e: DragEvent,
-  node: DragNodeEvent,
-  outsideTree?: boolean,
-) => void
-
-export interface TreeContextProps {
-  prefixCls: string
-  selectable: boolean
-  showIcon: boolean
-  icon: IconType
-  switcherIcon: IconType
-  draggable: DraggableConfig | false
-  draggingNodeKey?: Key
-  checkable: boolean
-  customCheckable: () => any
-  checkStrictly: boolean
-  disabled: boolean
-  keyEntities: Record<Key, DataEntity<any>>
-  // for details see comment in Tree.state (Tree.tsx)
-  dropLevelOffset?: number
-  dropContainerKey: Key | null
-  dropTargetKey: Key | null
-  dropPosition: -1 | 0 | 1 | null
-  indent: number | null
-  dropIndicatorRender: (props: {
-    dropPosition: -1 | 0 | 1
-    dropLevelOffset: number
-    indent: number | null
-    prefixCls: string
-    direction: Direction
-  }) => VueNode
-  dragOverNodeKey: Key | null
-  dragging: boolean
-  direction: Direction
-
-  loadData: (treeNode: EventDataNode) => Promise<void>
-  filterTreeNode: (treeNode: EventDataNode) => boolean
-
-  onNodeClick: NodeMouseEventHandler
-  onNodeDoubleClick: NodeMouseEventHandler
-  onNodeExpand: NodeMouseEventHandler
-  onNodeSelect: NodeMouseEventHandler
-  onNodeCheck: (e: MouseEvent, treeNode: EventDataNode, checked: boolean) => void
-  onNodeLoad: (treeNode: EventDataNode) => void
-  onNodeMouseEnter: NodeMouseEventHandler
-  onNodeMouseLeave: NodeMouseEventHandler
-  onNodeContextMenu: NodeMouseEventHandler
-  onNodeDragStart: NodeDragEventHandler
-  onNodeDragEnter: NodeDragEventHandler
-  onNodeDragOver: NodeDragEventHandler
-  onNodeDragLeave: NodeDragEventHandler
-  onNodeDragEnd: NodeDragEventHandler
-  onNodeDrop: NodeDragEventHandler
-  slots: {
-    title?: (data: any) => any
-    titleRender?: (data: any) => any
-    [key: string]: ((...args: any[]) => any) | undefined
-  }
-}
-const TreeContextKey: InjectionKey<ComputedRef<TreeContextProps>> = Symbol('TreeContextKey')
-
-export const TreeContext = defineComponent({
-  compatConfig: { MODE: 3 },
-  name: 'TreeContext',
-  props: {
-    value: { type: Object as PropType<TreeContextProps> },
-  },
-  setup(props, { slots }) {
-    provide(
-      TreeContextKey,
-      computed(() => props.value),
-    )
-    return () => slots.default?.()
-  },
-})
-
-export const useInjectTreeContext = () => {
-  return inject(
-    TreeContextKey,
-    computed(() => ({}) as TreeContextProps),
-  )
-}
-interface KeysStateKeyType {
-  expandedKeysSet: ComputedRef<Set<Key>>
-  selectedKeysSet: ComputedRef<Set<Key>>
-  loadedKeysSet: ComputedRef<Set<Key>>
-  loadingKeysSet: ComputedRef<Set<Key>>
-  checkedKeysSet: ComputedRef<Set<Key>>
-  halfCheckedKeysSet: ComputedRef<Set<Key>>
-  expandedKeys: ShallowRef<Key[]>
-  selectedKeys: ShallowRef<Key[]>
-  loadedKeys: ShallowRef<Key[]>
-  loadingKeys: ShallowRef<Key[]>
-  checkedKeys: ShallowRef<Key[]>
-  halfCheckedKeys: ShallowRef<Key[]>
-  flattenNodes: ShallowRef<FlattenNode[]>
-}
-const KeysStateKey: InjectionKey<KeysStateKeyType> = Symbol('KeysStateKey')
-export const useProvideKeysState = (state: KeysStateKeyType) => {
-  provide(KeysStateKey, state)
-}
-
-export const useInjectKeysState = () => {
-  return inject(KeysStateKey, {
-    expandedKeys: shallowRef<Key[]>([]),
-    selectedKeys: shallowRef<Key[]>([]),
-    loadedKeys: shallowRef<Key[]>([]),
-    loadingKeys: shallowRef<Key[]>([]),
-    checkedKeys: shallowRef<Key[]>([]),
-    halfCheckedKeys: shallowRef<Key[]>([]),
-    expandedKeysSet: computed<Set<Key>>(() => new Set()),
-    selectedKeysSet: computed<Set<Key>>(() => new Set()),
-    loadedKeysSet: computed<Set<Key>>(() => new Set()),
-    loadingKeysSet: computed<Set<Key>>(() => new Set()),
-    checkedKeysSet: computed<Set<Key>>(() => new Set()),
-    halfCheckedKeysSet: computed<Set<Key>>(() => new Set()),
-    flattenNodes: shallowRef<FlattenNode[]>([]),
-  })
-}

package/src/vc-tree/index.ts

@@ -1,9 +0,0 @@
-// base rc-tree 5.6.3
-import Tree from './Tree'
-import TreeNode from './TreeNode'
-import type { BasicDataNode } from './interface'
-import type { TreeNodeProps, TreeProps } from './props'
-
-export { TreeNode }
-export type { BasicDataNode, TreeNodeProps, TreeProps }
-export default Tree

package/src/vc-tree/interface.tsx

@@ -1,102 +0,0 @@
-import type { CSSProperties, VNode } from 'vue'
-
-import type { TreeNodeProps } from './props'
-
-export type { ScrollTo } from '../vc-virtual-list/List'
-
-/** For fieldNames, we provides a abstract interface */
-export interface BasicDataNode {
-  checkable?: boolean
-  disabled?: boolean
-  disableCheckbox?: boolean
-  icon?: IconType
-  isLeaf?: boolean
-  selectable?: boolean
-  switcherIcon?: IconType
-
-  /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
-  class?: string
-  style?: CSSProperties
-  slots?: Record<string, string>
-  [key: string]: any
-}
-
-export interface DataNode extends BasicDataNode {
-  children?: DataNode[]
-  key: string | number
-  title?: any
-}
-
-export interface EventDataNode extends DataNode {
-  expanded?: boolean
-  selected?: boolean
-  checked: boolean
-  loaded?: boolean
-  loading?: boolean
-  halfChecked?: boolean
-  dragOver?: boolean
-  dragOverGapTop?: boolean
-  dragOverGapBottom?: boolean
-  pos?: string
-  active?: boolean
-  dataRef?: DataNode
-  parent?: DataNode
-  eventKey?: Key // 兼容 v2， 推荐直接用 key
-}
-
-export type IconType = any
-
-export type Key = string | number
-
-export type NodeElement = VNode<TreeNodeProps>
-
-export interface DragNodeEvent {
-  key: Key
-  eventData: EventDataNode
-  eventKey: Key
-  selectHandle: HTMLSpanElement
-  pos: string
-}
-export interface Entity {
-  node: NodeElement
-  index: number
-  key: Key
-  pos: string
-  parent?: Entity
-  children?: Entity[]
-}
-
-export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<
-  Entity,
-  'node' | 'parent' | 'children'
-> {
-  node: TreeDataType
-  nodes: TreeDataType[]
-  parent?: DataEntity<TreeDataType>
-  children?: DataEntity<TreeDataType>[]
-  level: number
-}
-
-export interface FlattenNode {
-  parent: FlattenNode | null
-  children: FlattenNode[]
-  pos: string
-  data: DataNode
-  title: any
-  key: Key
-  isStart: boolean[]
-  isEnd: boolean[]
-}
-
-export type GetKey<RecordType> = (record: RecordType, index?: number) => Key
-
-export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean
-
-export type Direction = 'ltr' | 'rtl' | undefined
-
-export interface FieldNames {
-  title?: string
-  _title?: string[]
-  key?: string
-  children?: string
-}

package/src/vc-tree/props.ts

@@ -1,256 +0,0 @@
-import type { CSSProperties, ExtractPropTypes, PropType } from 'vue'
-
-import type { BasicDataNode } from '.'
-import type { EventHandler } from '../_util/EventInterface'
-import PropTypes from '../_util/vue-types'
-import type {
-  NodeDragEventParams,
-  NodeMouseEventHandler,
-  NodeMouseEventParams,
-} from './contextTypes'
-import type { DataNode, Direction, EventDataNode, FieldNames, FlattenNode, Key } from './interface'
-
-export interface CheckInfo {
-  event: 'check'
-  node: EventDataNode
-  checked: boolean
-  nativeEvent: MouseEvent
-  checkedNodes: DataNode[]
-  checkedNodesPositions?: { node: DataNode; pos: string }[]
-  halfCheckedKeys?: Key[]
-}
-
-export const treeNodeProps = {
-  eventKey: [String, Number], // Pass by parent `cloneElement`
-  prefixCls: String,
-
-  // By parent
-  // expanded: { type: Boolean, default: undefined },
-  // selected: { type: Boolean, default: undefined },
-  // checked: { type: Boolean, default: undefined },
-  // loaded: { type: Boolean, default: undefined },
-  // loading: { type: Boolean, default: undefined },
-  // halfChecked: { type: Boolean, default: undefined },
-  // dragOver: { type: Boolean, default: undefined },
-  // dragOverGapTop: { type: Boolean, default: undefined },
-  // dragOverGapBottom: { type: Boolean, default: undefined },
-  // pos: String,
-
-  title: PropTypes.any,
-  /** New added in Tree for easy data access */
-  data: { type: Object as PropType<DataNode>, default: undefined as DataNode },
-  parent: { type: Object as PropType<DataNode>, default: undefined as DataNode },
-
-  isStart: { type: Array as PropType<boolean[]> },
-  isEnd: { type: Array as PropType<boolean[]> },
-  active: { type: Boolean, default: undefined },
-  onMousemove: { type: Function as PropType<EventHandler> },
-
-  // By user
-  isLeaf: { type: Boolean, default: undefined },
-  checkable: { type: Boolean, default: undefined },
-  selectable: { type: Boolean, default: undefined },
-  disabled: { type: Boolean, default: undefined },
-  disableCheckbox: { type: Boolean, default: undefined },
-  icon: PropTypes.any,
-  switcherIcon: PropTypes.any,
-  domRef: { type: Function as PropType<(arg: any) => void> },
-}
-
-export type TreeNodeProps = Partial<ExtractPropTypes<typeof treeNodeProps>>
-
-export const nodeListProps = {
-  prefixCls: { type: String as PropType<string> },
-  // data: { type: Array as PropType<FlattenNode[]> },
-  motion: { type: Object as PropType<any> },
-  focusable: { type: Boolean as PropType<boolean> },
-  activeItem: { type: Object as PropType<FlattenNode> },
-  focused: { type: Boolean as PropType<boolean> },
-  tabindex: { type: Number as PropType<number> },
-  checkable: { type: Boolean as PropType<boolean> },
-  selectable: { type: Boolean as PropType<boolean> },
-  disabled: { type: Boolean as PropType<boolean> },
-
-  // expandedKeys: { type: Array as PropType<Key[]> },
-  // selectedKeys: { type: Array as PropType<Key[]> },
-  // checkedKeys: { type: Array as PropType<Key[]> },
-  // loadedKeys: { type: Array as PropType<Key[]> },
-  // loadingKeys: { type: Array as PropType<Key[]> },
-  // halfCheckedKeys: { type: Array as PropType<Key[]> },
-  // keyEntities: { type: Object as PropType<Record<Key, DataEntity<DataNode>>> },
-
-  // dragging: { type: Boolean as PropType<boolean> },
-  // dragOverNodeKey: { type: [String, Number] as PropType<Key> },
-  // dropPosition: { type: Number as PropType<number> },
-
-  // Virtual list
-  height: { type: Number as PropType<number> },
-  itemHeight: { type: Number as PropType<number> },
-  virtual: { type: Boolean as PropType<boolean> },
-
-  onScroll: { type: Function as PropType<EventHandler> },
-  onKeydown: { type: Function as PropType<EventHandler> },
-  onFocus: { type: Function as PropType<(e: FocusEvent) => void> },
-  onBlur: { type: Function as PropType<(e: FocusEvent) => void> },
-  onActiveChange: { type: Function as PropType<(key: Key) => void> },
-  onContextmenu: { type: Function as PropType<EventHandler> },
-
-  onListChangeStart: { type: Function as PropType<() => void> },
-  onListChangeEnd: { type: Function as PropType<() => void> },
-}
-
-export type NodeListProps = Partial<ExtractPropTypes<typeof nodeListProps>>
-
-export interface AllowDropOptions<TreeDataType extends BasicDataNode = DataNode> {
-  dragNode: EventDataNode
-  dropNode: TreeDataType
-  dropPosition: -1 | 0 | 1
-}
-export type AllowDrop<TreeDataType extends BasicDataNode = DataNode> = (
-  options: AllowDropOptions<TreeDataType>,
-) => boolean
-
-export type DraggableFn = (node: DataNode) => boolean
-export type ExpandAction = false | 'click' | 'doubleclick' | 'dblclick'
-export const treeProps = () => ({
-  prefixCls: String,
-  focusable: { type: Boolean, default: undefined },
-  activeKey: [Number, String] as PropType<Key>,
-  tabindex: Number,
-  children: PropTypes.any,
-  treeData: { type: Array as PropType<DataNode[]> }, // Generate treeNode by children
-  fieldNames: { type: Object as PropType<FieldNames> },
-  showLine: {
-    type: [Boolean, Object] as PropType<boolean | { showLeafIcon: boolean }>,
-    default: undefined,
-  },
-  showIcon: { type: Boolean, default: undefined },
-  icon: PropTypes.any,
-  selectable: { type: Boolean, default: undefined },
-  expandAction: [String, Boolean] as PropType<ExpandAction>,
-  disabled: { type: Boolean, default: undefined },
-  multiple: { type: Boolean, default: undefined },
-  checkable: { type: Boolean, default: undefined },
-  checkStrictly: { type: Boolean, default: undefined },
-  draggable: { type: [Function, Boolean] as PropType<DraggableFn | boolean> },
-  defaultExpandParent: { type: Boolean, default: undefined },
-  autoExpandParent: { type: Boolean, default: undefined },
-  defaultExpandAll: { type: Boolean, default: undefined },
-  defaultExpandedKeys: { type: Array as PropType<Key[]> },
-  expandedKeys: { type: Array as PropType<Key[]> },
-  defaultCheckedKeys: { type: Array as PropType<Key[]> },
-  checkedKeys: {
-    type: [Object, Array] as PropType<Key[] | { checked: Key[]; halfChecked: Key[] }>,
-  },
-  defaultSelectedKeys: { type: Array as PropType<Key[]> },
-  selectedKeys: { type: Array as PropType<Key[]> },
-  allowDrop: { type: Function as PropType<AllowDrop> },
-
-  dropIndicatorRender: {
-    type: Function as PropType<
-      (props: {
-        dropPosition: -1 | 0 | 1
-        dropLevelOffset: number
-        indent: number
-        prefixCls: string
-        direction: Direction
-      }) => any
-    >,
-  },
-  onFocus: { type: Function as PropType<(e: FocusEvent) => void> },
-  onBlur: { type: Function as PropType<(e: FocusEvent) => void> },
-  onKeydown: { type: Function as PropType<EventHandler> },
-  onContextmenu: { type: Function as PropType<EventHandler> },
-  onClick: { type: Function as PropType<NodeMouseEventHandler> },
-  onDblclick: { type: Function as PropType<NodeMouseEventHandler> },
-  onScroll: { type: Function as PropType<EventHandler> },
-  onExpand: {
-    type: Function as PropType<
-      (
-        expandedKeys: Key[],
-        info: {
-          node: EventDataNode
-          expanded: boolean
-          nativeEvent: MouseEvent
-        },
-      ) => void
-    >,
-  },
-  onCheck: {
-    type: Function as PropType<
-      (checked: { checked: Key[]; halfChecked: Key[] } | Key[], info: CheckInfo) => void
-    >,
-  },
-  onSelect: {
-    type: Function as PropType<
-      (
-        selectedKeys: Key[],
-        info: {
-          event: 'select'
-          selected: boolean
-          node: EventDataNode
-          selectedNodes: DataNode[]
-          nativeEvent: MouseEvent
-        },
-      ) => void
-    >,
-  },
-  onLoad: {
-    type: Function as PropType<
-      (
-        loadedKeys: Key[],
-        info: {
-          event: 'load'
-          node: EventDataNode
-        },
-      ) => void
-    >,
-  },
-  loadData: { type: Function as PropType<(treeNode: EventDataNode) => Promise<any>> },
-  loadedKeys: { type: Array as PropType<Key[]> },
-  onMouseenter: { type: Function as PropType<(info: NodeMouseEventParams) => void> },
-  onMouseleave: { type: Function as PropType<(info: NodeMouseEventParams) => void> },
-  onRightClick: {
-    type: Function as PropType<(info: { event: MouseEvent; node: EventDataNode }) => void>,
-  },
-  onDragstart: { type: Function as PropType<(info: NodeDragEventParams) => void> },
-  onDragenter: {
-    type: Function as PropType<(info: NodeDragEventParams & { expandedKeys: Key[] }) => void>,
-  },
-  onDragover: { type: Function as PropType<(info: NodeDragEventParams) => void> },
-  onDragleave: { type: Function as PropType<(info: NodeDragEventParams) => void> },
-  onDragend: { type: Function as PropType<(info: NodeDragEventParams) => void> },
-  onDrop: {
-    type: Function as PropType<
-      (
-        info: NodeDragEventParams & {
-          dragNode: EventDataNode
-          dragNodesKeys: Key[]
-          dropPosition: number
-          dropToGap: boolean
-        },
-      ) => void
-    >,
-  },
-  /**
-   * Used for `rc-tree-select` only.
-   * Do not use in your production code directly since this will be refactor.
-   */
-  onActiveChange: { type: Function as PropType<(key: Key) => void> },
-  filterTreeNode: { type: Function as PropType<(treeNode: EventDataNode) => boolean> },
-  motion: PropTypes.any,
-  switcherIcon: PropTypes.any,
-
-  // Virtual List
-  height: Number,
-  itemHeight: Number,
-  virtual: { type: Boolean, default: undefined },
-
-  // direction for drag logic
-  direction: { type: String as PropType<Direction> },
-
-  rootClassName: String,
-  rootStyle: Object as PropType<CSSProperties>,
-})
-
-export type TreeProps = Partial<ExtractPropTypes<ReturnType<typeof treeProps>>>

package/src/vc-tree/useMaxLevel.ts

@@ -1,39 +0,0 @@
-import type { ShallowRef } from 'vue'
-import { ref, shallowRef, watchEffect } from 'vue'
-
-import type { BasicDataNode, DataEntity, DataNode, Key } from './interface'
-
-export default function useMaxLevel<TreeDataType extends BasicDataNode = DataNode>(
-  keyEntities: ShallowRef<Record<Key, DataEntity<TreeDataType>>>,
-) {
-  const maxLevel = ref(0)
-  const levelEntities = shallowRef<Map<number, Set<DataEntity<TreeDataType>>>>()
-  watchEffect(() => {
-    const newLevelEntities = new Map<number, Set<DataEntity<TreeDataType>>>()
-    let newMaxLevel = 0
-    const keyEntitiesValue = keyEntities.value || {}
-    // Convert entities by level for calculation
-    for (const key in keyEntitiesValue) {
-      if (Object.prototype.hasOwnProperty.call(keyEntitiesValue, key)) {
-        const entity = keyEntitiesValue[key]
-        const { level } = entity
-
-        let levelSet: Set<DataEntity<TreeDataType>> = newLevelEntities.get(level)
-        if (!levelSet) {
-          levelSet = new Set()
-          newLevelEntities.set(level, levelSet)
-        }
-
-        levelSet.add(entity)
-
-        newMaxLevel = Math.max(newMaxLevel, level)
-      }
-    }
-    maxLevel.value = newMaxLevel
-    levelEntities.value = newLevelEntities
-  })
-  return {
-    maxLevel,
-    levelEntities,
-  }
-}