@antsoo-lib/components 0.1.11 → 0.1.12

package/src/vc-trigger/context.ts

@@ -1,38 +0,0 @@
-import type { InjectionKey, Ref } from 'vue'
-import { computed, inject, provide } from 'vue'
-
-export interface PortalContextProps {
-  shouldRender: Ref<boolean>
-  inTriggerContext: boolean // 仅处理 trigger 上下文的 portal
-}
-const PortalContextKey: InjectionKey<PortalContextProps> = Symbol('PortalContextKey')
-export const useProvidePortal = (instance: any, config = { inTriggerContext: true }) => {
-  provide(PortalContextKey, {
-    inTriggerContext: config.inTriggerContext,
-    shouldRender: computed(() => {
-      const { sPopupVisible, popupRef, forceRender, autoDestroy } = instance || {}
-      // if (popPortal) return true;
-      let shouldRender = false
-      if (sPopupVisible || popupRef || forceRender) {
-        shouldRender = true
-      }
-      if (!sPopupVisible && autoDestroy) {
-        shouldRender = false
-      }
-      return shouldRender
-    }),
-  })
-}
-
-export const useInjectPortal = () => {
-  useProvidePortal({}, { inTriggerContext: false })
-  const portalContext = inject(PortalContextKey, {
-    shouldRender: computed(() => false),
-    inTriggerContext: false,
-  })
-  return {
-    shouldRender: computed(
-      () => portalContext.shouldRender.value || portalContext.inTriggerContext === false,
-    ),
-  }
-}

package/src/vc-trigger/index.ts

@@ -1,8 +0,0 @@
-// based on rc-trigger 5.2.10
-import Trigger from './Trigger'
-import { triggerProps } from './interface'
-import type { TriggerProps } from './interface'
-
-export { triggerProps }
-export type { TriggerProps }
-export default Trigger

package/src/vc-trigger/interface.ts

@@ -1,147 +0,0 @@
-import type { CSSProperties, ExtractPropTypes, PropType, TransitionProps } from 'vue'
-
-import type { VueNode } from '../_util/type'
-import PropTypes from '../_util/vue-types'
-
-/** Two char of 't' 'b' 'c' 'l' 'r'. Example: 'lt' */
-export type AlignPoint = string
-
-export type OffsetType = number | `${number}%`
-export interface AlignType {
-  /**
-   * move point of source node to align with point of target node.
-   * Such as ['tr','cc'], align top right point of source node with center point of target node.
-   * Point can be 't'(top), 'b'(bottom), 'c'(center), 'l'(left), 'r'(right) */
-  points?: (string | AlignPoint)[]
-  /**
-   * offset source node by offset[0] in x and offset[1] in y.
-   * If offset contains percentage string value, it is relative to sourceNode region.
-   */
-  offset?: OffsetType[]
-  /**
-   * offset target node by offset[0] in x and offset[1] in y.
-   * If targetOffset contains percentage string value, it is relative to targetNode region.
-   */
-  targetOffset?: OffsetType[]
-  /**
-   * If adjustX field is true, will adjust source node in x direction if source node is invisible.
-   * If adjustY field is true, will adjust source node in y direction if source node is invisible.
-   */
-  overflow?: {
-    adjustX?: boolean | number
-    adjustY?: boolean | number
-    shiftX?: boolean | number
-    shiftY?: boolean | number
-  }
-  /** Auto adjust arrow position */
-  autoArrow?: boolean
-  /**
-   * Config visible region check of html node. Default `visible`:
-   *  - `visible`:
-   *    The visible region of user browser window.
-   *    Use `clientHeight` for check.
-   *    If `visible` region not satisfy, fallback to `scroll`.
-   *  - `scroll`:
-   *    The whole region of the html scroll area.
-   *    Use `scrollHeight` for check.
-   *  - `visibleFirst`:
-   *    Similar to `visible`, but if `visible` region not satisfy, fallback to `scroll`.
-   */
-  htmlRegion?: 'visible' | 'scroll' | 'visibleFirst'
-  /**
-   * Whether use css right instead of left to position
-   */
-  useCssRight?: boolean
-  /**
-   * Whether use css bottom instead of top to position
-   */
-  useCssBottom?: boolean
-  /**
-   * Whether use css transform instead of left/top/right/bottom to position if browser supports.
-   * Defaults to false.
-   */
-  useCssTransform?: boolean
-  ignoreShake?: boolean
-}
-
-export type BuildInPlacements = Record<string, AlignType>
-
-export type StretchType = string
-
-export type ActionType = string
-
-export type AnimationType = string
-
-export type TransitionNameType = string
-
-export interface Point {
-  pageX: number
-  pageY: number
-}
-
-export interface CommonEventHandler {
-  remove: () => void
-}
-
-export interface MobileConfig {
-  /** Set popup motion. You can ref `rc-motion` for more info. */
-  popupMotion?: TransitionProps
-  popupClassName?: string
-  popupStyle?: CSSProperties
-  popupRender?: (originNode: VueNode) => VueNode
-}
-
-function returnEmptyString() {
-  return ''
-}
-
-function returnDocument(element) {
-  if (element) {
-    return element.ownerDocument
-  }
-  return window.document
-}
-
-export function noop() {}
-
-export const triggerProps = () => ({
-  action: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]).def([]),
-  showAction: PropTypes.any.def([]),
-  hideAction: PropTypes.any.def([]),
-  getPopupClassNameFromAlign: PropTypes.any.def(returnEmptyString),
-  onPopupVisibleChange: Function as PropType<(open: boolean) => void>,
-  afterPopupVisibleChange: PropTypes.func.def(noop),
-  popup: PropTypes.any,
-  arrow: PropTypes.bool.def(true),
-  popupStyle: { type: Object as PropType<CSSProperties>, default: undefined as CSSProperties },
-  prefixCls: PropTypes.string.def('rc-trigger-popup'),
-  popupClassName: PropTypes.string.def(''),
-  popupPlacement: String,
-  builtinPlacements: PropTypes.object,
-  popupTransitionName: String,
-  popupAnimation: PropTypes.any,
-  mouseEnterDelay: PropTypes.number.def(0),
-  mouseLeaveDelay: PropTypes.number.def(0.1),
-  zIndex: Number,
-  focusDelay: PropTypes.number.def(0),
-  blurDelay: PropTypes.number.def(0.15),
-  getPopupContainer: Function,
-  getDocument: PropTypes.func.def(returnDocument),
-  forceRender: { type: Boolean, default: undefined },
-  destroyPopupOnHide: { type: Boolean, default: false },
-  mask: { type: Boolean, default: false },
-  maskClosable: { type: Boolean, default: true },
-  // onPopupAlign: PropTypes.func.def(noop),
-  popupAlign: PropTypes.object.def(() => ({})),
-  popupVisible: { type: Boolean, default: undefined },
-  defaultPopupVisible: { type: Boolean, default: false },
-  maskTransitionName: String,
-  maskAnimation: String,
-  stretch: String,
-  alignPoint: { type: Boolean, default: undefined }, // Maybe we can support user pass position in the future
-  autoDestroy: { type: Boolean, default: false },
-  mobile: Object,
-  getTriggerDOMNode: Function as PropType<(d?: HTMLElement) => HTMLElement>,
-})
-
-export type TriggerProps = Partial<ExtractPropTypes<ReturnType<typeof triggerProps>>>

package/src/vc-trigger/utils/alignUtil.ts

@@ -1,40 +0,0 @@
-import type { AlignPoint, AlignType, BuildInPlacements } from '../interface'
-
-function isPointsEq(a1: AlignPoint[], a2: AlignPoint[], isAlignPoint: boolean): boolean {
-  if (isAlignPoint) {
-    return a1[0] === a2[0]
-  }
-  return a1[0] === a2[0] && a1[1] === a2[1]
-}
-
-export function getAlignFromPlacement(
-  builtinPlacements: BuildInPlacements,
-  placementStr: string,
-  align: AlignType,
-): AlignType {
-  const baseAlign = builtinPlacements[placementStr] || {}
-  return {
-    ...baseAlign,
-    ...align,
-  }
-}
-
-export function getAlignPopupClassName(
-  builtinPlacements: BuildInPlacements,
-  prefixCls: string,
-  align: AlignType,
-  isAlignPoint: boolean,
-): string {
-  const { points } = align
-
-  const placements = Object.keys(builtinPlacements)
-
-  for (let i = 0; i < placements.length; i += 1) {
-    const placement = placements[i]
-    if (isPointsEq(builtinPlacements[placement].points, points, isAlignPoint)) {
-      return `${prefixCls}-placement-${placement}`
-    }
-  }
-
-  return ''
-}

package/src/vc-trigger/utils/motionUtil.ts

@@ -1,22 +0,0 @@
-import type { AnimationType, TransitionNameType } from '../interface'
-
-interface GetMotionProps {
-  animation: AnimationType
-  transitionName: TransitionNameType
-  prefixCls: string
-}
-
-export function getMotion({ prefixCls, animation, transitionName }: GetMotionProps) {
-  if (animation) {
-    return {
-      name: `${prefixCls}-${animation}`,
-    }
-  }
-
-  if (transitionName) {
-    return {
-      name: transitionName,
-    }
-  }
-  return {}
-}

package/src/vc-upload/AjaxUploader.tsx

@@ -1,320 +0,0 @@
-import partition from 'lodash-es/partition'
-
-import { defineComponent, onBeforeUnmount, onMounted, ref } from 'vue'
-
-import type { ChangeEvent } from '../_util/EventInterface'
-import pickAttrs from '../_util/pickAttrs'
-import attrAccept from './attr-accept'
-import type {
-  BeforeUploadFileType,
-  RcFile,
-  UploadProgressEvent,
-  UploadRequestError,
-} from './interface'
-import { uploadProps } from './interface'
-import defaultRequest from './request'
-import traverseFileTree from './traverseFileTree'
-import getUid from './uid'
-
-interface ParsedFileInfo {
-  origin: RcFile
-  action: string
-  data: Record<string, unknown>
-  parsedFile: RcFile
-}
-export default defineComponent({
-  compatConfig: { MODE: 3 },
-  name: 'AjaxUploader',
-  inheritAttrs: false,
-  props: uploadProps(),
-  setup(props, { slots, attrs, expose }) {
-    const uid = ref(getUid())
-    const reqs: any = {}
-
-    const fileInput = ref<HTMLInputElement>()
-
-    let isMounted = false
-
-    /**
-     * Process file before upload. When all the file is ready, we start upload.
-     */
-    const processFile = async (file: RcFile, fileList: RcFile[]): Promise<ParsedFileInfo> => {
-      const { beforeUpload } = props
-
-      let transformedFile: BeforeUploadFileType | void = file
-      if (beforeUpload) {
-        try {
-          transformedFile = await beforeUpload(file, fileList)
-        } catch (e) {
-          // Rejection will also trade as false
-          transformedFile = false
-        }
-        if (transformedFile === false) {
-          return {
-            origin: file,
-            parsedFile: null,
-            action: null,
-            data: null,
-          }
-        }
-      }
-
-      // Get latest action
-      const { action } = props
-      let mergedAction: string
-      if (typeof action === 'function') {
-        mergedAction = await action(file)
-      } else {
-        mergedAction = action
-      }
-
-      // Get latest data
-      const { data } = props
-      let mergedData: Record<string, unknown>
-      if (typeof data === 'function') {
-        mergedData = await data(file)
-      } else {
-        mergedData = data
-      }
-
-      const parsedData =
-        // string type is from legacy `transformFile`.
-        // Not sure if this will work since no related test case works with it
-        (typeof transformedFile === 'object' || typeof transformedFile === 'string') &&
-        transformedFile
-          ? transformedFile
-          : file
-
-      let parsedFile: File
-      if (parsedData instanceof File) {
-        parsedFile = parsedData
-      } else {
-        parsedFile = new File([parsedData], file.name, { type: file.type })
-      }
-
-      const mergedParsedFile: RcFile = parsedFile as RcFile
-      mergedParsedFile.uid = file.uid
-
-      return {
-        origin: file,
-        data: mergedData,
-        parsedFile: mergedParsedFile,
-        action: mergedAction,
-      }
-    }
-
-    const post = ({ data, origin, action, parsedFile }: ParsedFileInfo) => {
-      if (!isMounted) {
-        return
-      }
-
-      const { onStart, customRequest, name, headers, withCredentials, method } = props
-
-      const { uid } = origin
-      const request = customRequest || defaultRequest
-
-      const requestOption = {
-        action,
-        filename: name,
-        data,
-        file: parsedFile,
-        headers,
-        withCredentials,
-        method: method || 'post',
-        onProgress: (e: UploadProgressEvent) => {
-          const { onProgress } = props
-          onProgress?.(e, parsedFile)
-        },
-        onSuccess: (ret: any, xhr: XMLHttpRequest) => {
-          const { onSuccess } = props
-          onSuccess?.(ret, parsedFile, xhr)
-
-          delete reqs[uid]
-        },
-        onError: (err: UploadRequestError, ret: any) => {
-          const { onError } = props
-          onError?.(err, ret, parsedFile)
-
-          delete reqs[uid]
-        },
-      }
-
-      onStart(origin)
-      reqs[uid] = request(requestOption)
-    }
-
-    const reset = () => {
-      uid.value = getUid()
-    }
-
-    const abort = (file?: any) => {
-      if (file) {
-        const uid = file.uid ? file.uid : file
-        if (reqs[uid] && reqs[uid].abort) {
-          reqs[uid].abort()
-        }
-        delete reqs[uid]
-      } else {
-        Object.keys(reqs).forEach((uid) => {
-          if (reqs[uid] && reqs[uid].abort) {
-            reqs[uid].abort()
-          }
-          delete reqs[uid]
-        })
-      }
-    }
-
-    onMounted(() => {
-      isMounted = true
-    })
-
-    onBeforeUnmount(() => {
-      isMounted = false
-      abort()
-    })
-    const uploadFiles = (files: File[]) => {
-      const originFiles = [...files] as RcFile[]
-      const postFiles = originFiles.map((file: RcFile & { uid?: string }) => {
-        file.uid = getUid()
-        return processFile(file, originFiles)
-      })
-
-      // Batch upload files
-      Promise.all(postFiles).then((fileList) => {
-        const { onBatchStart } = props
-
-        onBatchStart?.(fileList.map(({ origin, parsedFile }) => ({ file: origin, parsedFile })))
-
-        fileList
-          .filter((file) => file.parsedFile !== null)
-          .forEach((file) => {
-            post(file)
-          })
-      })
-    }
-
-    const onChange = (e: ChangeEvent) => {
-      const { accept, directory } = props
-      const { files } = e.target as any
-      const acceptedFiles = [...files].filter(
-        (file: RcFile) => !directory || attrAccept(file, accept),
-      )
-      uploadFiles(acceptedFiles)
-      reset()
-    }
-
-    const onClick = (e: MouseEvent | KeyboardEvent) => {
-      const el = fileInput.value
-      if (!el) {
-        return
-      }
-      const { onClick } = props
-      // TODO
-      // if (children && (children as any).type === 'button') {
-      //   const parent = el.parentNode as HTMLInputElement;
-      //   parent.focus();
-      //   parent.querySelector('button').blur();
-      // }
-      el.click()
-      if (onClick) {
-        onClick(e)
-      }
-    }
-
-    const onKeyDown = (e: KeyboardEvent) => {
-      if (e.key === 'Enter') {
-        onClick(e)
-      }
-    }
-
-    const onFileDrop = (e: DragEvent) => {
-      const { multiple } = props
-
-      e.preventDefault()
-
-      if (e.type === 'dragover') {
-        return
-      }
-
-      if (props.directory) {
-        traverseFileTree(
-          Array.prototype.slice.call(e.dataTransfer.items),
-          uploadFiles,
-          (_file: RcFile) => attrAccept(_file, props.accept),
-        )
-      } else {
-        const files: [RcFile[], RcFile[]] = partition(
-          Array.prototype.slice.call(e.dataTransfer.files),
-          (file: RcFile) => attrAccept(file, props.accept),
-        )
-        let successFiles = files[0]
-        const errorFiles = files[1]
-        if (multiple === false) {
-          successFiles = successFiles.slice(0, 1)
-        }
-
-        uploadFiles(successFiles)
-        if (errorFiles.length && props.onReject) props.onReject(errorFiles)
-      }
-    }
-    expose({
-      abort,
-    })
-    return () => {
-      const {
-        componentTag: Tag,
-        prefixCls,
-        disabled,
-        id,
-        multiple,
-        accept,
-        capture,
-        directory,
-        openFileDialogOnClick,
-        onMouseenter,
-        onMouseleave,
-        ...otherProps
-      } = props
-      const cls = {
-        [prefixCls]: true,
-        [`${prefixCls}-disabled`]: disabled,
-        [attrs.class as string]: !!attrs.class,
-      }
-      // because input don't have directory/webkitdirectory type declaration
-      const dirProps: any = directory
-        ? { directory: 'directory', webkitdirectory: 'webkitdirectory' }
-        : {}
-      const events = disabled
-        ? {}
-        : {
-            onClick: openFileDialogOnClick ? onClick : () => {},
-            onKeydown: openFileDialogOnClick ? onKeyDown : () => {},
-            onMouseenter,
-            onMouseleave,
-            onDrop: onFileDrop,
-            onDragover: onFileDrop,
-            tabindex: '0',
-          }
-      return (
-        <Tag {...events} class={cls} role="button" style={attrs.style}>
-          <input
-            {...pickAttrs(otherProps, { aria: true, data: true })}
-            id={id}
-            type="file"
-            ref={fileInput}
-            onClick={(e) => e.stopPropagation()} // https://github.com/ant-design/ant-design/issues/19948
-            onCancel={(e) => e.stopPropagation()}
-            key={uid.value}
-            style={{ display: 'none' }}
-            accept={accept}
-            {...dirProps}
-            multiple={multiple}
-            onChange={onChange}
-            {...(capture != null ? { capture } : {})}
-          />
-          {slots.default?.()}
-        </Tag>
-      )
-    }
-  },
-})

package/src/vc-upload/Upload.tsx

@@ -1,43 +0,0 @@
-import { defineComponent, ref } from 'vue'
-
-import { initDefaultProps } from '../_util/props-util'
-import AjaxUpload from './AjaxUploader'
-import type { RcFile } from './interface'
-import { uploadProps } from './interface'
-
-function empty() {}
-
-export default defineComponent({
-  compatConfig: { MODE: 3 },
-  name: 'Upload',
-  inheritAttrs: false,
-  props: initDefaultProps(uploadProps(), {
-    componentTag: 'span',
-    prefixCls: 'rc-upload',
-    data: {},
-    headers: {},
-    name: 'file',
-    multipart: false,
-    onStart: empty,
-    onError: empty,
-    onSuccess: empty,
-    multiple: false,
-    beforeUpload: null,
-    customRequest: null,
-    withCredentials: false,
-    openFileDialogOnClick: true,
-  }),
-  setup(props, { slots, attrs, expose }) {
-    const uploader = ref()
-
-    const abort = (file: RcFile) => {
-      uploader.value?.abort(file)
-    }
-    expose({
-      abort,
-    })
-    return () => {
-      return <AjaxUpload {...props} {...attrs} v-slots={slots} ref={uploader} />
-    }
-  },
-})

package/src/vc-upload/attr-accept.ts

@@ -1,53 +0,0 @@
-import { warning } from '../vc-util/warning'
-import type { RcFile } from './interface'
-
-export default (file: RcFile, acceptedFiles: string | string[]) => {
-  if (file && acceptedFiles) {
-    const acceptedFilesArray = Array.isArray(acceptedFiles)
-      ? acceptedFiles
-      : acceptedFiles.split(',')
-    const fileName = file.name || ''
-    const mimeType = file.type || ''
-    const baseMimeType = mimeType.replace(/\/.*$/, '')
-
-    return acceptedFilesArray.some((type) => {
-      const validType = type.trim()
-      // This is something like */*,*  allow all files
-      if (/^\*(\/\*)?$/.test(type)) {
-        return true
-      }
-
-      // like .jpg, .png
-      if (validType.charAt(0) === '.') {
-        const lowerFileName = fileName.toLowerCase()
-        const lowerType = validType.toLowerCase()
-
-        let affixList = [lowerType]
-        if (lowerType === '.jpg' || lowerType === '.jpeg') {
-          affixList = ['.jpg', '.jpeg']
-        }
-
-        return affixList.some((affix) => lowerFileName.endsWith(affix))
-      }
-
-      // This is something like a image/* mime type
-      if (/\/\*$/.test(validType)) {
-        return baseMimeType === validType.replace(/\/.*$/, '')
-      }
-
-      // Full match
-      if (mimeType === validType) {
-        return true
-      }
-
-      // Invalidate type should skip
-      if (/^\w+$/.test(validType)) {
-        warning(false, `Upload takes an invalidate 'accept' type '${validType}'.Skip for check.`)
-        return true
-      }
-
-      return false
-    })
-  }
-  return true
-}

package/src/vc-upload/index.ts

@@ -1,7 +0,0 @@
-// rc-upload 4.3.3
-import Upload from './Upload'
-import type { UploadProps } from './interface'
-
-export type { UploadProps }
-
-export default Upload