@antsoo-lib/components 0.1.11 → 0.1.12

package/src/_util/cssinjs/util.ts

@@ -1,118 +0,0 @@
-import hash from '@emotion/hash'
-
-import { removeCSS, updateCSS } from '../../vc-util/Dom/dynamicCSS'
-import canUseDom from '../canUseDom'
-import { Theme } from './theme'
-
-// Create a cache here to avoid always loop generate
-const flattenTokenCache = new WeakMap<any, string>()
-
-export function flattenToken(token: any) {
-  let str = flattenTokenCache.get(token) || ''
-
-  if (!str) {
-    Object.keys(token).forEach((key) => {
-      const value = token[key]
-      str += key
-      if (value instanceof Theme) {
-        str += value.id
-      } else if (value && typeof value === 'object') {
-        str += flattenToken(value)
-      } else {
-        str += value
-      }
-    })
-
-    // Put in cache
-    flattenTokenCache.set(token, str)
-  }
-  return str
-}
-
-/**
- * Convert derivative token to key string
- */
-export function token2key(token: any, salt: string): string {
-  return hash(`${salt}_${flattenToken(token)}`)
-}
-
-const randomSelectorKey = `random-${Date.now()}-${Math.random()}`.replace(/\./g, '')
-
-// Magic `content` for detect selector support
-const checkContent = '_bAmBoO_'
-
-function supportSelector(
-  styleStr: string,
-  handleElement: (ele: HTMLElement) => void,
-  supportCheck?: (ele: HTMLElement) => boolean,
-): boolean {
-  if (canUseDom()) {
-    updateCSS(styleStr, randomSelectorKey)
-
-    const ele = document.createElement('div')
-    ele.style.position = 'fixed'
-    ele.style.left = '0'
-    ele.style.top = '0'
-    handleElement?.(ele)
-    document.body.appendChild(ele)
-
-    if (process.env.NODE_ENV !== 'production') {
-      ele.innerHTML = 'Test'
-      ele.style.zIndex = '9999999'
-    }
-
-    const support = supportCheck
-      ? supportCheck(ele)
-      : getComputedStyle(ele).content?.includes(checkContent)
-
-    ele.parentNode?.removeChild(ele)
-    removeCSS(randomSelectorKey)
-
-    return support
-  }
-
-  return false
-}
-
-let canLayer: boolean | undefined
-export function supportLayer(): boolean {
-  if (canLayer === undefined) {
-    canLayer = supportSelector(
-      `@layer ${randomSelectorKey} { .${randomSelectorKey} { content: "${checkContent}"!important; } }`,
-      (ele) => {
-        ele.className = randomSelectorKey
-      },
-    )
-  }
-
-  return canLayer!
-}
-
-let canWhere: boolean | undefined
-export function supportWhere(): boolean {
-  if (canWhere === undefined) {
-    canWhere = supportSelector(
-      `:where(.${randomSelectorKey}) { content: "${checkContent}"!important; }`,
-      (ele) => {
-        ele.className = randomSelectorKey
-      },
-    )
-  }
-
-  return canWhere!
-}
-
-let canLogic: boolean | undefined
-export function supportLogicProps(): boolean {
-  if (canLogic === undefined) {
-    canLogic = supportSelector(
-      `.${randomSelectorKey} { inset-block: 93px !important; }`,
-      (ele) => {
-        ele.className = randomSelectorKey
-      },
-      (ele) => getComputedStyle(ele).bottom === '93px',
-    )
-  }
-
-  return canLogic!
-}

package/src/_util/debouncedWatch.ts

@@ -1,87 +0,0 @@
-// copy from https://github.dev/vueuse/vueuse
-import type { Ref, WatchOptions, WatchStopHandle } from 'vue'
-import { unref, watch } from 'vue'
-
-type MaybeRef<T> = T | Ref<T>
-
-type Fn = () => void
-
-export type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return
-
-export interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
-  fn: FunctionArgs<Args, This>
-  args: Args
-  thisArg: This
-}
-
-export type EventFilter<Args extends any[] = any[], This = any> = (
-  invoke: Fn,
-  options: FunctionWrapperOptions<Args, This>,
-) => void
-
-const bypassFilter: EventFilter = (invoke) => {
-  return invoke()
-}
-/**
- * Create an EventFilter that debounce the events
- *
- * @param ms
- */
-export function debounceFilter(ms: MaybeRef<number>) {
-  let timer: ReturnType<typeof setTimeout> | undefined
-
-  const filter: EventFilter = (invoke) => {
-    const duration = unref(ms)
-
-    if (timer) clearTimeout(timer)
-
-    if (duration <= 0) return invoke()
-
-    timer = setTimeout(invoke, duration)
-  }
-
-  return filter
-}
-export interface DebouncedWatchOptions<Immediate> extends WatchOptions<Immediate> {
-  debounce?: MaybeRef<number>
-}
-
-interface ConfigurableEventFilter {
-  eventFilter?: EventFilter
-}
-/**
- * @internal
- */
-function createFilterWrapper<T extends FunctionArgs>(filter: EventFilter, fn: T) {
-  function wrapper(this: any, ...args: any[]) {
-    filter(() => fn.apply(this, args), { fn, thisArg: this, args })
-  }
-
-  return wrapper as any as T
-}
-export interface WatchWithFilterOptions<Immediate>
-  extends WatchOptions<Immediate>, ConfigurableEventFilter {}
-// implementation
-export function watchWithFilter<Immediate extends Readonly<boolean> = false>(
-  source: any,
-  cb: any,
-  options: WatchWithFilterOptions<Immediate> = {},
-): WatchStopHandle {
-  const { eventFilter = bypassFilter, ...watchOptions } = options
-
-  return watch(source, createFilterWrapper(eventFilter, cb), watchOptions)
-}
-
-// implementation
-export default function debouncedWatch<Immediate extends Readonly<boolean> = false>(
-  source: any,
-  cb: any,
-  options: DebouncedWatchOptions<Immediate> = {},
-): WatchStopHandle {
-  const { debounce = 0, ...watchOptions } = options
-
-  return watchWithFilter(source, cb, {
-    ...watchOptions,
-    eventFilter: debounceFilter(debounce),
-  })
-}

package/src/_util/eagerComputed.ts

@@ -1,17 +0,0 @@
-import { shallowRef, watchEffect } from 'vue'
-import type { ComputedRef } from 'vue'
-
-export declare type ComputedGetter<T> = (...args: any[]) => T
-export default function eagerComputed<T>(fn: ComputedGetter<T>) {
-  const result = shallowRef<T>()
-  watchEffect(
-    () => {
-      result.value = fn()
-    },
-    {
-      flush: 'sync', // needed so updates are immediate.
-    },
-  )
-
-  return result as any as ComputedRef<T>
-}

package/src/_util/easings.ts

@@ -1,8 +0,0 @@
-export function easeInOutCubic(t: number, b: number, c: number, d: number) {
-  const cc = c - b
-  t /= d / 2
-  if (t < 1) {
-    return (cc / 2) * t * t * t + b
-  }
-  return (cc / 2) * ((t -= 2) * t * t + 2) + b
-}

package/src/_util/env.ts

@@ -1,9 +0,0 @@
-// Browser environment sniffing
-export const inBrowser = typeof window !== 'undefined'
-export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
-export const isIE = UA && /msie|trident/.test(UA)
-export const isIE9 = UA && UA.indexOf('msie 9.0') > 0
-export const isEdge = UA && UA.indexOf('edge/') > 0
-export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
-export const isPhantomJS = UA && /phantomjs/.test(UA)
-export const isFF = UA && UA.match(/firefox\/(\d+)/)

package/src/_util/extendsObject.ts

@@ -1,21 +0,0 @@
-type RecordType = Record<string, any>
-
-function extendsObject<T extends RecordType>(...list: T[]) {
-  const result: RecordType = { ...list[0] }
-
-  for (let i = 1; i < list.length; i++) {
-    const obj = list[i]
-    if (obj) {
-      Object.keys(obj).forEach((key) => {
-        const val = obj[key]
-        if (val !== undefined) {
-          result[key] = val
-        }
-      })
-    }
-  }
-
-  return result
-}
-
-export default extendsObject

package/src/_util/firstNotUndefined.ts

@@ -1,10 +0,0 @@
-function firstNotUndefined<T>(arr: T[] = []): T {
-  for (let i = 0, len = arr.length; i < len; i++) {
-    if (arr[i] !== undefined) {
-      return arr[i]
-    }
-  }
-  return undefined
-}
-
-export default firstNotUndefined

package/src/_util/gapSize.ts

@@ -1,13 +0,0 @@
-import type { SizeType } from '../config-provider/SizeContext'
-
-export function isPresetSize(size?: SizeType | string | number): size is SizeType {
-  return ['small', 'middle', 'large'].includes(size as string)
-}
-
-export function isValidGapNumber(size?: SizeType | string | number): size is number {
-  if (!size) {
-    // The case of size = 0 is deliberately excluded here, because the default value of the gap attribute in CSS is 0, so if the user passes 0 in, we can directly ignore it.
-    return false
-  }
-  return typeof size === 'number' && !Number.isNaN(size)
-}

package/src/_util/getRequestAnimationFrame.ts

@@ -1,47 +0,0 @@
-const availablePrefixs = ['moz', 'ms', 'webkit']
-
-function requestAnimationFramePolyfill() {
-  let lastTime = 0
-  return function (callback) {
-    const currTime = new Date().getTime()
-    const timeToCall = Math.max(0, 16 - (currTime - lastTime))
-    const id = window.setTimeout(() => {
-      callback(currTime + timeToCall)
-    }, timeToCall)
-    lastTime = currTime + timeToCall
-    return id
-  }
-}
-
-export default function getRequestAnimationFrame() {
-  if (typeof window === 'undefined') {
-    return () => {}
-  }
-  if (window.requestAnimationFrame) {
-    // https://github.com/vuejs/vue/issues/4465
-    return window.requestAnimationFrame.bind(window)
-  }
-
-  const prefix = availablePrefixs.filter((key) => `${key}RequestAnimationFrame` in window)[0]
-
-  return prefix ? window[`${prefix}RequestAnimationFrame`] : requestAnimationFramePolyfill()
-}
-
-export function cancelRequestAnimationFrame(id) {
-  if (typeof window === 'undefined') {
-    return null
-  }
-  if (window.cancelAnimationFrame) {
-    return window.cancelAnimationFrame(id)
-  }
-  const prefix = availablePrefixs.filter(
-    (key) =>
-      `${key}CancelAnimationFrame` in window || `${key}CancelRequestAnimationFrame` in window,
-  )[0]
-
-  return prefix
-    ? (
-        window[`${prefix}CancelAnimationFrame`] || window[`${prefix}CancelRequestAnimationFrame`]
-      ).call(this, id)
-    : clearTimeout(id)
-}

package/src/_util/getScroll.ts

@@ -1,33 +0,0 @@
-export function isWindow(obj: any): obj is Window {
-  return obj !== null && obj !== undefined && obj === obj.window
-}
-
-export default function getScroll(
-  target: HTMLElement | Window | Document | null,
-  top: boolean,
-): number {
-  if (typeof window === 'undefined') {
-    return 0
-  }
-  const method = top ? 'scrollTop' : 'scrollLeft'
-  let result = 0
-  if (isWindow(target)) {
-    result = target[top ? 'scrollY' : 'scrollX']
-  } else if (target instanceof Document) {
-    result = target.documentElement[method]
-  } else if (target instanceof HTMLElement) {
-    result = target[method]
-  } else if (target) {
-    // According to the type inference, the `target` is `never` type.
-    // Since we configured the loose mode type checking, and supports mocking the target with such shape below::
-    //    `{ documentElement: { scrollLeft: 200, scrollTop: 400 } }`,
-    //    the program may falls into this branch.
-    // Check the corresponding tests for details. Don't sure what is the real scenario this happens.
-    result = target[method]
-  }
-
-  if (target && !isWindow(target) && typeof result !== 'number') {
-    result = ((target.ownerDocument ?? target) as any).documentElement?.[method]
-  }
-  return result
-}

package/src/_util/getScrollBarSize.ts

@@ -1,60 +0,0 @@
-let cached: number
-
-export default function getScrollBarSize(fresh?: boolean) {
-  if (typeof document === 'undefined') {
-    return 0
-  }
-
-  if (fresh || cached === undefined) {
-    const inner = document.createElement('div')
-    inner.style.width = '100%'
-    inner.style.height = '200px'
-
-    const outer = document.createElement('div')
-    const outerStyle = outer.style
-
-    outerStyle.position = 'absolute'
-    outerStyle.top = '0'
-    outerStyle.left = '0'
-    outerStyle.pointerEvents = 'none'
-    outerStyle.visibility = 'hidden'
-    outerStyle.width = '200px'
-    outerStyle.height = '150px'
-    outerStyle.overflow = 'hidden'
-
-    outer.appendChild(inner)
-
-    document.body.appendChild(outer)
-
-    const widthContained = inner.offsetWidth
-    outer.style.overflow = 'scroll'
-    let widthScroll = inner.offsetWidth
-
-    if (widthContained === widthScroll) {
-      widthScroll = outer.clientWidth
-    }
-
-    document.body.removeChild(outer)
-
-    cached = widthContained - widthScroll
-  }
-  return cached
-}
-
-function ensureSize(str: string) {
-  const match = str.match(/^(.*)px$/)
-  const value = Number(match?.[1])
-  return Number.isNaN(value) ? getScrollBarSize() : value
-}
-
-export function getTargetScrollBarSize(target: HTMLElement) {
-  if (typeof document === 'undefined' || !target || !(target instanceof Element)) {
-    return { width: 0, height: 0 }
-  }
-
-  const { width, height } = getComputedStyle(target, '::-webkit-scrollbar')
-  return {
-    width: ensureSize(width),
-    height: ensureSize(height),
-  }
-}

package/src/_util/hooks/_vueuse/_configurable.ts

@@ -1,34 +0,0 @@
-import { isClient } from './is'
-
-export interface ConfigurableWindow {
-  /*
-   * Specify a custom `window` instance, e.g. working with iframes or in testing environments.
-   */
-  window?: Window
-}
-
-export interface ConfigurableDocument {
-  /*
-   * Specify a custom `document` instance, e.g. working with iframes or in testing environments.
-   */
-  document?: Document
-}
-
-export interface ConfigurableNavigator {
-  /*
-   * Specify a custom `navigator` instance, e.g. working with iframes or in testing environments.
-   */
-  navigator?: Navigator
-}
-
-export interface ConfigurableLocation {
-  /*
-   * Specify a custom `location` instance, e.g. working with iframes or in testing environments.
-   */
-  location?: Location
-}
-
-export const defaultWindow = isClient ? window : undefined
-export const defaultDocument = isClient ? window.document : undefined
-export const defaultNavigator = isClient ? window.navigator : undefined
-export const defaultLocation = isClient ? window.location : undefined

package/src/_util/hooks/_vueuse/is.ts

@@ -1,26 +0,0 @@
-export const isClient = typeof window !== 'undefined'
-export const isDef = <T = any>(val?: T): val is T => typeof val !== 'undefined'
-export const assert = (condition: boolean, ...infos: any[]) => {
-  if (!condition) console.warn(...infos)
-}
-const toString = Object.prototype.toString
-export const isBoolean = (val: any): val is boolean => typeof val === 'boolean'
-export const isFunction = <T extends Function>(val: any): val is T => typeof val === 'function'
-export const isNumber = (val: any): val is number => typeof val === 'number'
-export const isString = (val: unknown): val is string => typeof val === 'string'
-export const isObject = (val: any): val is object => toString.call(val) === '[object Object]'
-export const isWindow = (val: any): val is Window =>
-  typeof window !== 'undefined' && toString.call(val) === '[object Window]'
-export const now = () => Date.now()
-export const timestamp = () => +Date.now()
-export const clamp = (n: number, min: number, max: number) => Math.min(max, Math.max(min, n))
-export const noop = () => {}
-export const rand = (min: number, max: number) => {
-  min = Math.ceil(min)
-  max = Math.floor(max)
-  return Math.floor(Math.random() * (max - min + 1)) + min
-}
-export const isIOS =
-  isClient && window?.navigator?.userAgent && /iP(ad|hone|od)/.test(window.navigator.userAgent)
-export const hasOwn = <T extends object, K extends keyof T>(val: T, key: K): key is K =>
-  Object.prototype.hasOwnProperty.call(val, key)

package/src/_util/hooks/_vueuse/resolveUnref.ts

@@ -1,10 +0,0 @@
-import { unref } from 'vue'
-
-import type { MaybeComputedRef } from './types'
-
-/**
- * Get the value of value/ref/getter.
- */
-export function resolveUnref<T>(r: MaybeComputedRef<T>): T {
-  return typeof r === 'function' ? (r as any)() : unref(r)
-}

package/src/_util/hooks/_vueuse/tryOnMounted.ts

@@ -1,15 +0,0 @@
-import { getCurrentInstance, nextTick, onMounted } from 'vue'
-
-import type { Fn } from './types'
-
-/**
- * Call onMounted() if it's inside a component lifecycle, if not, just call the function
- *
- * @param fn
- * @param sync if set to false, it will run in the nextTick() of Vue
- */
-export function tryOnMounted(fn: Fn, sync = true) {
-  if (getCurrentInstance()) onMounted(fn)
-  else if (sync) fn()
-  else nextTick(fn)
-}

package/src/_util/hooks/_vueuse/tryOnScopeDispose.ts

@@ -1,16 +0,0 @@
-import { getCurrentScope, onScopeDispose } from 'vue'
-
-import type { Fn } from './types'
-
-/**
- * Call onScopeDispose() if it's inside a effect scope lifecycle, if not, do nothing
- *
- * @param fn
- */
-export function tryOnScopeDispose(fn: Fn) {
-  if (getCurrentScope()) {
-    onScopeDispose(fn)
-    return true
-  }
-  return false
-}

package/src/_util/hooks/_vueuse/types.ts

@@ -1,143 +0,0 @@
-import type { ComputedRef, Ref, WatchOptions, WatchSource } from 'vue'
-
-/**
- * Any function
- */
-export type Fn = () => void
-
-/**
- * A ref that allow to set null or undefined
- */
-export type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
-  get value(): T
-  set value(value: T | null | undefined)
-}
-
-/**
- * @deprecated Use `RemovableRef`
- */
-export type RemoveableRef<T> = RemovableRef<T>
-
-/**
- * Maybe it's a ref, or a plain value
- *
- * ```ts
- * type MaybeRef<T> = T | Ref<T>
- * ```
- */
-export type MaybeRef<T> = T | Ref<T>
-
-/**
- * Maybe it's a ref, or a plain value, or a getter function
- *
- * ```ts
- * type MaybeComputedRef<T> = (() => T) | T | Ref<T> | ComputedRef<T>
- * ```
- */
-export type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>
-
-/**
- * Maybe it's a computed ref, or a getter function
- *
- * ```ts
- * type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>
- * ```
- */
-export type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>
-
-/**
- * Make all the nested attributes of an object or array to MaybeRef<T>
- *
- * Good for accepting options that will be wrapped with `reactive` or `ref`
- *
- * ```ts
- * UnwrapRef<DeepMaybeRef<T>> === T
- * ```
- */
-export type DeepMaybeRef<T> =
-  T extends Ref<infer V>
-    ? MaybeRef<V>
-    : T extends Array<any> | object
-      ? { [K in keyof T]: DeepMaybeRef<T[K]> }
-      : MaybeRef<T>
-
-/**
- * Infers the element type of an array
- */
-export type ElementOf<T> = T extends (infer E)[] ? E : never
-
-export type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T
-
-export type Awaitable<T> = Promise<T> | T
-
-export type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never
-
-export interface Pausable {
-  /**
-   * A ref indicate whether a pausable instance is active
-   */
-  isActive: Ref<boolean>
-
-  /**
-   * Temporary pause the effect from executing
-   */
-  pause: Fn
-
-  /**
-   * Resume the effects
-   */
-  resume: Fn
-}
-
-export interface Stoppable {
-  /**
-   * A ref indicate whether a stoppable instance is executing
-   */
-  isPending: Ref<boolean>
-
-  /**
-   * Stop the effect from executing
-   */
-  stop: Fn
-
-  /**
-   * Start the effects
-   */
-  start: Fn
-}
-
-/**
- * @deprecated Use `Stoppable`
- */
-export type Stopable = Stoppable
-
-export interface ConfigurableFlush {
-  /**
-   * Timing for monitoring changes, refer to WatchOptions for more details
-   *
-   * @default 'pre'
-   */
-  flush?: WatchOptions['flush']
-}
-
-export interface ConfigurableFlushSync {
-  /**
-   * Timing for monitoring changes, refer to WatchOptions for more details.
-   * Unlike `watch()`, the default is set to `sync`
-   *
-   * @default 'sync'
-   */
-  flush?: WatchOptions['flush']
-}
-
-// Internal Types
-export type MapSources<T> = {
-  [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never
-}
-export type MapOldSources<T, Immediate> = {
-  [K in keyof T]: T[K] extends WatchSource<infer V>
-    ? Immediate extends true
-      ? V | undefined
-      : V
-    : never
-}