@antsoo-lib/components 0.1.11 → 0.1.12

package/src/vc-table/utils/valueUtil.tsx

@@ -1,89 +0,0 @@
-import type { DataIndex, Key } from '../interface'
-
-const INTERNAL_KEY_PREFIX = 'RC_TABLE_KEY'
-
-function toArray<T>(arr: T | readonly T[]): T[] {
-  if (arr === undefined || arr === null) {
-    return []
-  }
-  return (Array.isArray(arr) ? arr : [arr]) as T[]
-}
-
-export function getPathValue<ValueType, ObjectType extends object>(
-  record: ObjectType,
-  path: DataIndex,
-): ValueType {
-  // Skip if path is empty
-  if (!path && typeof path !== 'number') {
-    return record as unknown as ValueType
-  }
-
-  const pathList = toArray(path)
-
-  let current: ValueType | ObjectType = record
-
-  for (let i = 0; i < pathList.length; i += 1) {
-    if (!current) {
-      return null
-    }
-
-    const prop = pathList[i]
-    current = current[prop]
-  }
-
-  return current as ValueType
-}
-
-interface GetColumnKeyColumn {
-  key?: Key
-  dataIndex?: DataIndex
-}
-
-export function getColumnsKey(columns: readonly GetColumnKeyColumn[]) {
-  const columnKeys: Key[] = []
-  const keys: Record<Key, boolean> = {}
-
-  columns.forEach((column) => {
-    const { key, dataIndex } = column || {}
-
-    let mergedKey = key || toArray(dataIndex).join('-') || INTERNAL_KEY_PREFIX
-    while (keys[mergedKey]) {
-      mergedKey = `${mergedKey}_next`
-    }
-    keys[mergedKey] = true
-
-    columnKeys.push(mergedKey)
-  })
-
-  return columnKeys
-}
-
-export function mergeObject<ReturnObject extends object>(
-  ...objects: Partial<ReturnObject>[]
-): ReturnObject {
-  const merged: Partial<ReturnObject> = {}
-
-  function fillProps(obj: object, clone: object) {
-    if (clone) {
-      Object.keys(clone).forEach((key) => {
-        const value = clone[key]
-        if (value && typeof value === 'object') {
-          obj[key] = obj[key] || {}
-          fillProps(obj[key], value)
-        } else {
-          obj[key] = value
-        }
-      })
-    }
-  }
-
-  objects.forEach((clone) => {
-    fillProps(merged, clone)
-  })
-
-  return merged as ReturnObject
-}
-
-export function validateValue<T>(val: T) {
-  return val !== null && val !== undefined
-}

package/src/vc-tooltip/index.ts

@@ -1,4 +0,0 @@
-// base rc-tooltip 5.1.1
-import Tooltip from './src/Tooltip'
-
-export default Tooltip

package/src/vc-tooltip/src/Content.tsx

@@ -1,30 +0,0 @@
-import type { ExtractPropTypes } from 'vue'
-import { defineComponent } from 'vue'
-
-import PropTypes from '../../_util/vue-types'
-
-const tooltipContentProps = {
-  prefixCls: String,
-  id: String,
-  overlayInnerStyle: PropTypes.any,
-}
-
-export type TooltipContentProps = Partial<ExtractPropTypes<typeof tooltipContentProps>>
-
-export default defineComponent({
-  compatConfig: { MODE: 3 },
-  name: 'TooltipContent',
-  props: tooltipContentProps,
-  setup(props: TooltipContentProps, { slots }) {
-    return () => (
-      <div
-        class={`${props.prefixCls}-inner`}
-        id={props.id}
-        role="tooltip"
-        style={props.overlayInnerStyle}
-      >
-        {slots.overlay?.()}
-      </div>
-    )
-  },
-})

package/src/vc-tooltip/src/Tooltip.tsx

@@ -1,137 +0,0 @@
-import type { CSSProperties, PropType } from 'vue'
-import { defineComponent, shallowRef, watchEffect } from 'vue'
-
-import { getPropsSlot } from '../../_util/props-util'
-import PropTypes from '../../_util/vue-types'
-import Trigger from '../../vc-trigger'
-import Content from './Content'
-import { placements } from './placements'
-
-function noop() {}
-export default defineComponent({
-  compatConfig: { MODE: 3 },
-  name: 'Tooltip',
-  inheritAttrs: false,
-  props: {
-    trigger: PropTypes.any.def(['hover']),
-    defaultVisible: { type: Boolean, default: undefined },
-    visible: { type: Boolean, default: undefined },
-    placement: PropTypes.string.def('right'),
-    transitionName: String,
-    animation: PropTypes.any,
-    afterVisibleChange: PropTypes.func.def(() => {}),
-    overlayStyle: { type: Object as PropType<CSSProperties>, default: undefined as CSSProperties },
-    overlayClassName: String,
-    prefixCls: PropTypes.string.def('rc-tooltip'),
-    mouseEnterDelay: PropTypes.number.def(0.1),
-    mouseLeaveDelay: PropTypes.number.def(0.1),
-    getPopupContainer: Function as PropType<(triggerNode?: HTMLElement) => HTMLElement>,
-    destroyTooltipOnHide: { type: Boolean, default: false },
-    align: PropTypes.object.def(() => ({})),
-    arrowContent: PropTypes.any.def(null),
-    tipId: String,
-    builtinPlacements: PropTypes.object,
-    overlayInnerStyle: {
-      type: Object as PropType<CSSProperties>,
-      default: undefined as CSSProperties,
-    },
-    popupVisible: { type: Boolean, default: undefined },
-    onVisibleChange: Function,
-    onPopupAlign: Function,
-    arrow: { type: Boolean, default: true },
-  },
-  setup(props, { slots, attrs, expose }) {
-    const triggerDOM = shallowRef()
-
-    const getPopupElement = () => {
-      const { prefixCls, tipId, overlayInnerStyle } = props
-
-      return [
-        props.arrow ? (
-          <div class={`${prefixCls}-arrow`} key="arrow">
-            {getPropsSlot(slots, props, 'arrowContent')}
-          </div>
-        ) : null,
-        <Content
-          key="content"
-          prefixCls={prefixCls}
-          id={tipId}
-          overlayInnerStyle={overlayInnerStyle}
-          v-slots={{ overlay: slots.overlay }}
-        />,
-      ]
-    }
-
-    const getPopupDomNode = () => {
-      return triggerDOM.value.getPopupDomNode()
-    }
-
-    expose({
-      getPopupDomNode,
-      triggerDOM,
-      forcePopupAlign: () => triggerDOM.value?.forcePopupAlign(),
-    })
-
-    const destroyTooltip = shallowRef(false)
-    const autoDestroy = shallowRef(false)
-    watchEffect(() => {
-      const { destroyTooltipOnHide } = props
-      if (typeof destroyTooltipOnHide === 'boolean') {
-        destroyTooltip.value = destroyTooltipOnHide
-      } else if (destroyTooltipOnHide && typeof destroyTooltipOnHide === 'object') {
-        const { keepParent } = destroyTooltipOnHide
-        destroyTooltip.value = keepParent === true
-        autoDestroy.value = keepParent === false
-      }
-    })
-
-    return () => {
-      const {
-        overlayClassName,
-        trigger,
-        mouseEnterDelay,
-        mouseLeaveDelay,
-        overlayStyle,
-        prefixCls,
-        afterVisibleChange,
-        transitionName,
-        animation,
-        placement,
-        align,
-        destroyTooltipOnHide,
-        defaultVisible,
-        ...restProps
-      } = props
-      const extraProps = { ...restProps }
-      if (props.visible !== undefined) {
-        extraProps.popupVisible = props.visible
-      }
-
-      const triggerProps = {
-        popupClassName: overlayClassName,
-        prefixCls,
-        action: trigger,
-        builtinPlacements: placements,
-        popupPlacement: placement,
-        popupAlign: align,
-        afterPopupVisibleChange: afterVisibleChange,
-        popupTransitionName: transitionName,
-        popupAnimation: animation,
-        defaultPopupVisible: defaultVisible,
-        destroyPopupOnHide: destroyTooltip.value,
-        autoDestroy: autoDestroy.value,
-        mouseLeaveDelay,
-        popupStyle: overlayStyle,
-        mouseEnterDelay,
-        ...extraProps,
-        ...attrs,
-        onPopupVisibleChange: props.onVisibleChange || (noop as any),
-        onPopupAlign: props.onPopupAlign || noop,
-        ref: triggerDOM,
-        arrow: !!props.arrow,
-        popup: getPopupElement(),
-      }
-      return <Trigger {...triggerProps} v-slots={{ default: slots.default }}></Trigger>
-    }
-  },
-})

package/src/vc-tooltip/src/placements.ts

@@ -1,83 +0,0 @@
-const autoAdjustOverflow = {
-  adjustX: 1,
-  adjustY: 1,
-}
-
-const targetOffset = [0, 0]
-
-export const placements = {
-  left: {
-    points: ['cr', 'cl'],
-    overflow: autoAdjustOverflow,
-    offset: [-4, 0],
-    targetOffset,
-  },
-  right: {
-    points: ['cl', 'cr'],
-    overflow: autoAdjustOverflow,
-    offset: [4, 0],
-    targetOffset,
-  },
-  top: {
-    points: ['bc', 'tc'],
-    overflow: autoAdjustOverflow,
-    offset: [0, -4],
-    targetOffset,
-  },
-  bottom: {
-    points: ['tc', 'bc'],
-    overflow: autoAdjustOverflow,
-    offset: [0, 4],
-    targetOffset,
-  },
-  topLeft: {
-    points: ['bl', 'tl'],
-    overflow: autoAdjustOverflow,
-    offset: [0, -4],
-    targetOffset,
-  },
-  leftTop: {
-    points: ['tr', 'tl'],
-    overflow: autoAdjustOverflow,
-    offset: [-4, 0],
-    targetOffset,
-  },
-  topRight: {
-    points: ['br', 'tr'],
-    overflow: autoAdjustOverflow,
-    offset: [0, -4],
-    targetOffset,
-  },
-  rightTop: {
-    points: ['tl', 'tr'],
-    overflow: autoAdjustOverflow,
-    offset: [4, 0],
-    targetOffset,
-  },
-  bottomRight: {
-    points: ['tr', 'br'],
-    overflow: autoAdjustOverflow,
-    offset: [0, 4],
-    targetOffset,
-  },
-  rightBottom: {
-    points: ['bl', 'br'],
-    overflow: autoAdjustOverflow,
-    offset: [4, 0],
-    targetOffset,
-  },
-  bottomLeft: {
-    points: ['tl', 'bl'],
-    overflow: autoAdjustOverflow,
-    offset: [0, 4],
-    targetOffset,
-  },
-  leftBottom: {
-    points: ['br', 'bl'],
-    overflow: autoAdjustOverflow,
-    offset: [-4, 0],
-    targetOffset,
-  },
-}
-
-export default placements

package/src/vc-tour/Mask.tsx

@@ -1,132 +0,0 @@
-import type { CSSProperties } from 'vue'
-import { defineComponent } from 'vue'
-
-import Portal from '../_util/PortalWrapper'
-import classNames from '../_util/classNames'
-import useId from '../_util/hooks/useId'
-import { booleanType, objectType, someType } from '../_util/type'
-import type { PosInfo } from './hooks/useTarget'
-
-const COVER_PROPS = {
-  fill: 'transparent',
-  'pointer-events': 'auto',
-}
-
-export interface MaskProps {
-  prefixCls?: string
-  pos: PosInfo //	获取引导卡片指向的元素
-  rootClassName?: string
-  showMask?: boolean
-  style?: CSSProperties
-  fill?: string
-  open?: boolean
-  animated?: boolean | { placeholder: boolean }
-  zIndex?: number
-}
-const Mask = defineComponent({
-  name: 'TourMask',
-  props: {
-    prefixCls: { type: String },
-    pos: objectType<PosInfo>(), //	获取引导卡片指向的元素
-    rootClassName: { type: String },
-    showMask: booleanType(),
-    fill: { type: String, default: 'rgba(0,0,0,0.5)' },
-    open: booleanType(),
-    animated: someType<boolean | { placeholder: boolean }>([Boolean, Object]),
-    zIndex: { type: Number },
-  },
-  setup(props, { attrs }) {
-    const id = useId()
-    return () => {
-      const { prefixCls, open, rootClassName, pos, showMask, fill, animated, zIndex } = props
-
-      const maskId = `${prefixCls}-mask-${id}`
-      const mergedAnimated = typeof animated === 'object' ? animated?.placeholder : animated
-      return (
-        <Portal
-          visible={open}
-          autoLock
-          v-slots={{
-            default: () =>
-              open && (
-                <div
-                  {...attrs}
-                  class={classNames(`${prefixCls}-mask`, rootClassName, attrs.class)}
-                  style={[
-                    {
-                      position: 'fixed',
-                      left: 0,
-                      right: 0,
-                      top: 0,
-                      bottom: 0,
-                      zIndex,
-                      pointerEvents: 'none',
-                    },
-                    attrs.style as CSSProperties,
-                  ]}
-                >
-                  {showMask ? (
-                    <svg
-                      style={{
-                        width: '100%',
-                        height: '100%',
-                      }}
-                    >
-                      <defs>
-                        <mask id={maskId}>
-                          <rect x="0" y="0" width="100vw" height="100vh" fill="white" />
-                          {pos && (
-                            <rect
-                              x={pos.left}
-                              y={pos.top}
-                              rx={pos.radius}
-                              width={pos.width}
-                              height={pos.height}
-                              fill="black"
-                              class={mergedAnimated ? `${prefixCls}-placeholder-animated` : ''}
-                            />
-                          )}
-                        </mask>
-                      </defs>
-                      <rect
-                        x="0"
-                        y="0"
-                        width="100%"
-                        height="100%"
-                        fill={fill}
-                        mask={`url(#${maskId})`}
-                      />
-
-                      {/* Block click region */}
-                      {pos && (
-                        <>
-                          <rect {...COVER_PROPS} x="0" y="0" width="100%" height={pos.top} />
-                          <rect {...COVER_PROPS} x="0" y="0" width={pos.left} height="100%" />
-                          <rect
-                            {...COVER_PROPS}
-                            x="0"
-                            y={pos.top + pos.height}
-                            width="100%"
-                            height={`calc(100vh - ${pos.top + pos.height}px)`}
-                          />
-                          <rect
-                            {...COVER_PROPS}
-                            x={pos.left + pos.width}
-                            y="0"
-                            width={`calc(100vw - ${pos.left + pos.width}px)`}
-                            height="100%"
-                          />
-                        </>
-                      )}
-                    </svg>
-                  ) : null}
-                </div>
-              ),
-          }}
-        />
-      )
-    }
-  },
-})
-
-export default Mask