@v-c/util 0.0.4 → 0.0.6

package/src/omit.ts

@@ -1,14 +0,0 @@
-export default function omit<T extends object, K extends keyof T>(
-  obj: T,
-  fields: K[] | readonly K[],
-): Omit<T, K> {
-  const clone = { ...obj }
-
-  if (Array.isArray(fields)) {
-    fields.forEach((key) => {
-      delete clone[key]
-    })
-  }
-
-  return clone
-}

package/src/pickAttrs.ts

@@ -1,79 +0,0 @@
-const attributes = `accept acceptCharset accessKey action allowFullScreen allowTransparency
-    alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge
-    charSet checked classID className colSpan cols content contentEditable contextMenu
-    controls coords crossOrigin data dateTime default defer dir disabled download draggable
-    encType form formAction formEncType formMethod formNoValidate formTarget frameBorder
-    headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity
-    is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media
-    mediaGroup method min minLength multiple muted name noValidate nonce open
-    optimum pattern placeholder poster preload radioGroup readOnly rel required
-    reversed role rowSpan rows sandbox scope scoped scrolling seamless selected
-    shape size sizes span spellCheck src srcDoc srcLang srcSet start step style
-    summary tabIndex target title type useMap value width wmode wrap`
-
-const eventsName = `onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown
-    onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick
-    onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown
-    onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel
-    onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough
-    onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata
-    onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad onError`
-
-const propList = `${attributes} ${eventsName}`.split(/\s+/)
-
-const ariaPrefix = 'aria-'
-const dataPrefix = 'data-'
-
-function match(key: string, prefix: string) {
-  return key.indexOf(prefix) === 0
-}
-
-export interface PickConfig {
-  aria?: boolean
-  data?: boolean
-  attr?: boolean
-}
-
-/**
- * Picker props from exist props with filter
- * @param props Passed props
- * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
- */
-export default function pickAttrs(
-  props: object,
-  ariaOnly: boolean | PickConfig = false,
-) {
-  let mergedConfig: PickConfig
-  if (ariaOnly === false) {
-    mergedConfig = {
-      aria: true,
-      data: true,
-      attr: true,
-    }
-  }
-  else if (ariaOnly === true) {
-    mergedConfig = {
-      aria: true,
-    }
-  }
-  else {
-    mergedConfig = {
-      ...ariaOnly,
-    }
-  }
-
-  const attrs: Record<string, any> = {}
-  Object.keys(props).forEach((key) => {
-    if (
-    // Aria
-      (mergedConfig.aria && (key === 'role' || match(key, ariaPrefix)))
-      // Data
-      || (mergedConfig.data && match(key, dataPrefix))
-      // Attr
-      || (mergedConfig.attr && propList.includes(key))
-    ) {
-      attrs[key] = (props as any)[key]
-    }
-  })
-  return attrs
-}

package/src/props-util/index.ts

@@ -1,57 +0,0 @@
-import type { VNode, VNodeNormalizedChildren } from 'vue'
-import { Comment, Fragment, isVNode, Text } from 'vue'
-import isValid from '../isValid'
-import initDefaultProps from './initDefaultProps'
-
-export function isEmptyElement(c: any) {
-  return (
-    c
-    && (c.type === Comment
-      || (c.type === Fragment && c.children.length === 0)
-      || (c.type === Text && c.children.trim() === ''))
-  )
-}
-export function filterEmpty(children: any[] = []) {
-  const res: any[] = []
-  children.forEach((child: any) => {
-    if (Array.isArray(child))
-      res.push(...child)
-    else if (child?.type === Fragment)
-      res.push(...filterEmpty(child.children))
-    else res.push(child)
-  })
-  return res.filter(c => !isEmptyElement(c))
-}
-
-export const skipFlattenKey = Symbol('skipFlatten')
-function flattenChildren(children?: VNode | VNodeNormalizedChildren, filterEmpty = true) {
-  const temp = Array.isArray(children) ? children : [children]
-  const res = []
-  temp.forEach((child) => {
-    if (Array.isArray(child)) {
-      res.push(...flattenChildren(child, filterEmpty))
-    }
-    else if (isValid(child)) {
-      res.push(child)
-    }
-    else if (child && typeof child === 'object' && child.type === Fragment) {
-      if (child.key === skipFlattenKey) {
-        res.push(child)
-      }
-      else {
-        res.push(...flattenChildren(child.children, filterEmpty))
-      }
-    }
-    else if (child && isVNode(child)) {
-      if (filterEmpty && !isEmptyElement(child)) {
-        res.push(child)
-      }
-      else if (!filterEmpty) {
-        res.push(child)
-      }
-    }
-  })
-  return res
-}
-
-export { flattenChildren, initDefaultProps }

package/src/props-util/initDefaultProps.ts

@@ -1,34 +0,0 @@
-import type { PropType } from 'vue'
-import type { VueTypeDef, VueTypeValidableDef } from 'vue-types'
-
-function initDefaultProps<T>(types: T, defaultProps: {
-  [K in keyof T]?: T[K] extends VueTypeValidableDef<infer U>
-    ? U
-    : T[K] extends VueTypeDef<infer U>
-      ? U
-      : T[K] extends { type: PropType<infer U> }
-        ? U
-        : any;
-}): T {
-  const propTypes: T = { ...types }
-  Object.keys(defaultProps).forEach((k) => {
-    const prop = propTypes[k] as VueTypeValidableDef
-    if (prop) {
-      if (prop.type || prop.default) {
-        prop.default = defaultProps[k]
-      }
-      else if (prop.def) {
-        prop.def(defaultProps[k])
-      }
-      else {
-        propTypes[k] = { type: prop, default: defaultProps[k] }
-      }
-    }
-    else {
-      throw new Error(`not have ${k} prop`)
-    }
-  })
-  return propTypes
-}
-
-export default initDefaultProps

package/src/raf.ts

@@ -1,55 +0,0 @@
-let raf = (callback: FrameRequestCallback) => +setTimeout(callback, 16)
-let caf = (num: number) => clearTimeout(num)
-
-if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
-  raf = (callback: FrameRequestCallback) =>
-    window.requestAnimationFrame(callback)
-  caf = (handle: number) => window.cancelAnimationFrame(handle)
-}
-
-let rafUUID = 0
-
-const rafIds = new Map<number, number>()
-
-function cleanup(id: number) {
-  rafIds.delete(id)
-}
-
-function wrapperRaf(callback: () => void, times = 1): number {
-  rafUUID += 1
-  const id = rafUUID
-
-  function callRef(leftTimes: number) {
-    if (leftTimes === 0) {
-      // Clean up
-      cleanup(id)
-
-      // Trigger
-      callback()
-    }
-    else {
-      // Next raf
-      const realId = raf(() => {
-        callRef(leftTimes - 1)
-      })
-
-      // Bind real raf id
-      rafIds.set(id, realId)
-    }
-  }
-
-  callRef(times)
-
-  return id
-}
-
-wrapperRaf.cancel = (id: number) => {
-  const realId = rafIds.get(id)
-  cleanup(id)
-  return caf(realId!)
-}
-
-if (process.env.NODE_ENV !== 'production')
-  wrapperRaf.ids = () => rafIds
-
-export default wrapperRaf

package/src/setStyle.ts

@@ -1,38 +0,0 @@
-import type { CSSProperties } from 'vue'
-
-export interface SetStyleOptions {
-  element?: HTMLElement
-}
-
-/**
- * Easy to set element style, return previous style
- * IE browser compatible(IE browser doesn't merge overflow style, need to set it separately)
- * https://github.com/ant-design/ant-design/issues/19393
- *
- */
-
-function setStyle(
-  style: CSSProperties,
-  options: SetStyleOptions = {},
-): CSSProperties {
-  if (!style)
-    return {}
-
-  const { element = document.body } = options
-  const oldStyle: CSSProperties = {}
-
-  const styleKeys = Object.keys(style)
-
-  // IE browser compatible
-  styleKeys.forEach((key: any) => {
-    oldStyle[key] = element.style[key]
-  })
-
-  styleKeys.forEach((key: any) => {
-    (element as any).style[key] = style[key]
-  })
-
-  return oldStyle
-}
-
-export default setStyle

package/src/switchScrollingEffect.ts

@@ -1,48 +0,0 @@
-import getScrollBarSize from './getScrollBarSize'
-import setStyle from './setStyle'
-
-function isBodyOverflowing() {
-  return (
-    document.body.scrollHeight
-    > (window.innerHeight || document.documentElement.clientHeight)
-    && window.innerWidth > document.body.offsetWidth
-  )
-}
-
-let cacheStyle = {}
-
-export default (close: any) => {
-  if (!isBodyOverflowing() && !close)
-    return
-
-  // https://github.com/ant-design/ant-design/issues/19729
-  const scrollingEffectClassName = 'ant-scrolling-effect'
-  const scrollingEffectClassNameReg = new RegExp(
-    `${scrollingEffectClassName}`,
-    'g',
-  )
-  const bodyClassName = document.body.className
-
-  if (close) {
-    if (!scrollingEffectClassNameReg.test(bodyClassName))
-      return
-    setStyle(cacheStyle)
-    cacheStyle = {}
-    document.body.className = bodyClassName
-      .replace(scrollingEffectClassNameReg, '')
-      .trim()
-    return
-  }
-
-  const scrollBarSize = getScrollBarSize()
-  if (scrollBarSize) {
-    cacheStyle = setStyle({
-      position: 'relative',
-      width: `calc(100% - ${scrollBarSize}px)`,
-    })
-    if (!scrollingEffectClassNameReg.test(bodyClassName)) {
-      const addClassName = `${bodyClassName} ${scrollingEffectClassName}`
-      document.body.className = addClassName.trim()
-    }
-  }
-}

package/src/test/domHook.ts

@@ -1,66 +0,0 @@
-const NO_EXIST = { __NOT_EXIST: true }
-
-export type ElementClass = Function
-
-export type Property = PropertyDescriptor | Function
-
-export function spyElementPrototypes<T extends ElementClass>(
-  elementClass: T,
-  properties: Record<string, Property>,
-) {
-  const propNames = Object.keys(properties)
-  const originDescriptors: any = {}
-
-  propNames.forEach((propName) => {
-    const originDescriptor: any = Object.getOwnPropertyDescriptor(elementClass.prototype, propName)
-    originDescriptors[propName] = originDescriptor || NO_EXIST
-
-    const spyProp: any = properties[propName]
-
-    if (typeof spyProp === 'function') {
-      // If is a function
-      elementClass.prototype[propName] = function spyFunc(...args: any[]) {
-        return spyProp.call(this, originDescriptor, ...args)
-      }
-    }
-    else {
-      // Otherwise tread as a property
-      Object.defineProperty(elementClass.prototype, propName, {
-        ...spyProp,
-        set(value) {
-          if (spyProp.set)
-            return (spyProp as any).set.call(this, originDescriptor, value)
-
-          return originDescriptor.set(value)
-        },
-        get() {
-          if (spyProp.get)
-            return spyProp.get.call(this, originDescriptor)
-
-          return originDescriptor.get()
-        },
-        configurable: true,
-      })
-    }
-  })
-
-  return {
-    mockRestore() {
-      propNames.forEach((propName) => {
-        const originDescriptor = originDescriptors[propName]
-        if (originDescriptor === NO_EXIST)
-          delete elementClass.prototype[propName]
-        else if (typeof originDescriptor === 'function')
-          elementClass.prototype[propName] = originDescriptor
-        else
-          Object.defineProperty(elementClass.prototype, propName, originDescriptor)
-      })
-    },
-  }
-}
-
-export function spyElementPrototype(Element: ElementClass, propName: string, property: Property) {
-  return spyElementPrototypes(Element, {
-    [propName]: property,
-  })
-}

package/src/type.ts

@@ -1,94 +0,0 @@
-import type { App, Component, Plugin, PropType, Ref, SlotsType, VNode } from 'vue'
-
-// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
-export const tuple = <T extends string[]>(...args: T) => args
-
-export const tupleNum = <T extends number[]>(...args: T) => args
-
-/**
- * https://stackoverflow.com/a/59187769
- * Extract the type of an element of an array/tuple without performing indexing
- */
-export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never
-
-/**
- * https://github.com/Microsoft/TypeScript/issues/29729
- */
-export type LiteralUnion<T extends string> = T | (string & {})
-
-export type Data = Record<string, unknown>
-
-export type Key = string | number
-
-type DefaultFactory<T> = (props: Data) => T | null | undefined
-
-export interface PropOptions<T = any, D = T> {
-  type?: PropType<T> | true | null
-  required?: boolean
-  default?: D | DefaultFactory<D> | null | undefined | object
-  validator?: (value: unknown) => boolean
-}
-
-declare type VNodeChildAtom = Component | VNode | string | number | null | undefined | void
-
-export type VueNode = VNodeChildAtom | VNodeChildAtom[] | VNode
-
-export function withInstall<T>(comp: T) {
-  const c = comp as any
-  c.install = function (app: App) {
-    app.component(c.displayName || c.name, comp as any)
-  }
-
-  return comp as T & Plugin
-}
-
-export type MaybeRef<T> = T | Ref<T>
-
-export function eventType<T>() {
-  return { type: [Function, Array] as PropType<T | T[]> }
-}
-
-export function objectType<T = object>(defaultVal?: T) {
-  return { type: Object as PropType<T>, default: defaultVal as T }
-}
-
-export function booleanType(defaultVal?: boolean) {
-  return { type: Boolean, default: defaultVal as boolean }
-}
-
-export function functionType<T = () => object>(defaultVal?: T) {
-  return { type: Function as PropType<T>, default: defaultVal as T }
-}
-
-export function anyType<T = any>(defaultVal?: T, required?: boolean) {
-  const type = { validator: () => true, default: defaultVal as T } as unknown
-  return required
-    ? (type as {
-        type: PropType<T>
-        default: T
-        required: true
-      })
-    : (type as {
-        default: T
-        type: PropType<T>
-      })
-}
-export function vNodeType<T = VueNode>() {
-  return { validator: () => true } as unknown as { type: PropType<T> }
-}
-
-export function arrayType<T extends any[]>(defaultVal?: T) {
-  return { type: Array as unknown as PropType<T>, default: defaultVal as T }
-}
-
-export function stringType<T extends string = string>(defaultVal?: T) {
-  return { type: String as unknown as PropType<T>, default: defaultVal as T }
-}
-
-export function someType<T>(types?: any[], defaultVal?: T) {
-  return types ? { type: types as PropType<T>, default: defaultVal as T } : anyType<T>(defaultVal)
-}
-
-export type CustomSlotsType<T extends Record<string, any>> = SlotsType<T>
-
-export type AnyObject = Record<PropertyKey, any>

package/src/utils/checkSlotProp.ts

@@ -1,10 +0,0 @@
-export function checkSlotProp(props: Record<string, any>, slots: Record<string, any>, name: string, ...args: any[]) {
-  if (slots[name])
-    return slots[name]?.(...args)
-  if (name in props) {
-    if (typeof props[name] === 'function')
-      return props[name]?.(...args)
-    return props[name]
-  }
-  return null
-}

package/src/utils/get.ts

@@ -1,15 +0,0 @@
-export default function get(
-  entity: any,
-  path: (string | number | symbol)[] | readonly (string | number | symbol)[],
-) {
-  let current = entity
-
-  for (let i = 0; i < path.length; i += 1) {
-    if (current === null || current === undefined)
-      return undefined
-
-    current = current[path[i]]
-  }
-
-  return current
-}

package/src/utils/omit.ts

@@ -1,9 +0,0 @@
-export function omit<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {
-  const result = { ...obj }
-
-  keys.forEach((key) => {
-    delete result[key]
-  })
-
-  return result
-}

package/src/utils/set.ts

@@ -1,110 +0,0 @@
-import get from './get'
-
-export type Path = (string | number | symbol)[]
-
-function internalSet<Entity = any, Output = Entity, Value = any>(
-  entity: Entity,
-  paths: Path,
-  value: Value,
-  removeIfUndefined: boolean,
-): Output {
-  if (!paths.length)
-    return (value as unknown) as Output
-
-  const [path, ...restPath] = paths
-
-  let clone: Output
-  if (!entity && typeof path === 'number')
-    clone = ([] as unknown) as Output
-  else if (Array.isArray(entity))
-    clone = ([...entity] as unknown) as Output
-  else
-    clone = ({ ...entity } as unknown) as Output
-
-  // Delete prop if `removeIfUndefined` and value is undefined
-  if (removeIfUndefined && value === undefined && restPath.length === 1)
-    delete (clone as any)[path][restPath[0]]
-  else
-    (clone as any)[path] = internalSet((clone as any)[path], restPath, value, removeIfUndefined)
-
-  return clone
-}
-
-export default function set<Entity = any, Output = Entity, Value = any>(
-  entity: Entity,
-  paths: Path,
-  value: Value,
-  removeIfUndefined: boolean = false,
-): Output {
-  // Do nothing if `removeIfUndefined` and parent object not exist
-  if (
-    paths.length
-    && removeIfUndefined
-    && value === undefined
-    && !get(entity, paths.slice(0, -1))
-  ) {
-    return (entity as unknown) as Output
-  }
-
-  return internalSet(entity, paths, value, removeIfUndefined)
-}
-
-export function isObject(obj: any) {
-  return (
-    typeof obj === 'object'
-    && obj !== null
-    && Object.getPrototypeOf(obj) === Object.prototype
-  )
-}
-
-function createEmpty<T>(source: T) {
-  return (Array.isArray(source) ? [] : {}) as T
-}
-
-const keys = typeof Reflect === 'undefined' ? Object.keys : Reflect.ownKeys
-
-/**
- * Merge objects which will create
- */
-export function merge<T extends object>(...sources: T[]) {
-  let clone = createEmpty(sources[0])
-
-  sources.forEach((src) => {
-    function internalMerge(path: Path, parentLoopSet?: Set<object>) {
-      const loopSet = new Set(parentLoopSet)
-
-      const value = get(src, path)
-
-      const isArr = Array.isArray(value)
-
-      if (isArr || isObject(value)) {
-        // Only add not loop obj
-        if (!loopSet.has(value)) {
-          loopSet.add(value)
-
-          const originValue = get(clone, path)
-
-          if (isArr) {
-            // Array will always be overridden
-            clone = set(clone, path, [])
-          }
-          else if (!originValue || typeof originValue !== 'object') {
-            // Init container if not exist
-            clone = set(clone, path, createEmpty(value))
-          }
-
-          keys(value).forEach((key) => {
-            internalMerge([...path, key], loopSet)
-          })
-        }
-      }
-      else {
-        clone = set(clone, path, value)
-      }
-    }
-
-    internalMerge([])
-  })
-
-  return clone
-}