@formily-design/shared 1.0.0 → 1.0.2

package/rollup.config.js

@@ -1,3 +0,0 @@
-import baseConfig from '../../scripts/rollup.base.js'
-
-export default baseConfig('designable.shared', 'Designable.Shared')

package/src/animation.ts

@@ -1,38 +0,0 @@
-export const createUniformSpeedAnimation = (
-  speed = 10,
-  callback: (delta: number) => void
-) => {
-  let request = null
-  let startTime = null
-  const start = () => {
-    if (request) return
-    request = requestAnimationFrame((timestamp) => {
-      if (startTime === null) {
-        startTime = timestamp
-      }
-      const deltaTime = timestamp - startTime
-      const delta = (deltaTime / 1000) * speed
-      callback(delta)
-      request = null
-      start()
-    })
-  }
-
-  start()
-
-  return () => {
-    if (request) {
-      cancelAnimationFrame(request)
-      request = null
-    }
-    startTime = null
-  }
-}
-
-//越接近阈值，速度越小，越远离阈值，速度越大
-export const calcSpeedFactor = (delta = 0, threshold = Infinity) => {
-  if (threshold >= delta) {
-    return (threshold - delta) / threshold
-  }
-  return 0
-}

package/src/array.ts

@@ -1,301 +0,0 @@
-import { isArr, isObj, isStr } from './types'
-
-type EachArrayIterator<T> = (currentValue: T, key: number) => void | boolean
-type EachStringIterator = (currentValue: string, key: number) => void | boolean
-type EachObjectIterator<T = any> = (
-  currentValue: T,
-  key: string
-) => void | boolean
-type MapArrayIterator<TItem, TResult> = (
-  currentValue: TItem,
-  key: number
-) => TResult
-type MapStringIterator<TResult> = (currentValue: string, key: number) => TResult
-type MapObjectIterator<TItem, TResult> = (
-  currentValue: TItem,
-  key: string
-) => TResult
-type MemoArrayIterator<T, U> = (
-  previousValue: U,
-  currentValue: T,
-  key: number
-) => U
-type MemoStringIterator<T> = (
-  previousValue: T,
-  currentValue: string,
-  key: number
-) => T
-type MemoObjectIterator<TValue, TResult> = (
-  previousValue: TResult,
-  currentValue: TValue,
-  key: string
-) => TResult
-
-export const toArr = (val: any): any[] => (isArr(val) ? val : val ? [val] : [])
-export function each(
-  val: string,
-  iterator: EachStringIterator,
-  revert?: boolean
-): void
-export function each<T>(
-  val: T[],
-  iterator: EachArrayIterator<T>,
-  revert?: boolean
-): void
-export function each<T extends {}, TValue = T[keyof T]>(
-  val: T,
-  iterator: EachObjectIterator<TValue>,
-  revert?: boolean
-): void
-export function each(val: any, iterator: any, revert?: boolean): void {
-  if (isArr(val) || isStr(val)) {
-    if (revert) {
-      for (let i: number = val.length - 1; i >= 0; i--) {
-        if (iterator(val[i], i) === false) {
-          return
-        }
-      }
-    } else {
-      for (let i = 0; i < val.length; i++) {
-        if (iterator(val[i], i) === false) {
-          return
-        }
-      }
-    }
-  } else if (isObj(val)) {
-    let key: string
-    for (key in val) {
-      if (Object.hasOwnProperty.call(val, key)) {
-        if (iterator(val[key], key) === false) {
-          return
-        }
-      }
-    }
-  }
-}
-
-export function map<T>(
-  val: string,
-  iterator: MapStringIterator<T>,
-  revert?: boolean
-): any
-export function map<TItem, TResult>(
-  val: TItem[],
-  iterator: MapArrayIterator<TItem, TResult>,
-  revert?: boolean
-): any
-export function map<T extends {}, TResult>(
-  val: T,
-  iterator: MapObjectIterator<T[keyof T], TResult>,
-  revert?: boolean
-): any
-export function map(val: any, iterator: any, revert?: boolean): any {
-  const res = isArr(val) || isStr(val) ? [] : {}
-  each(
-    val,
-    (item, key) => {
-      const value = iterator(item, key)
-      if (isArr(res)) {
-        ;(res as any).push(value)
-      } else {
-        res[key] = value
-      }
-    },
-    revert
-  )
-  return res
-}
-
-export function reduce<T, U>(
-  val: T[],
-  iterator: MemoArrayIterator<T, U>,
-  accumulator?: U,
-  revert?: boolean
-): U
-export function reduce<T>(
-  val: string,
-  iterator: MemoStringIterator<T>,
-  accumulator?: T,
-  revert?: boolean
-): T
-export function reduce<T extends {}, TValue = T[keyof T], TResult = any>(
-  val: T,
-  iterator: MemoObjectIterator<TValue, TResult>,
-  accumulator?: TResult,
-  revert?: boolean
-): TResult
-export function reduce(
-  val: any,
-  iterator: any,
-  accumulator?: any,
-  revert?: boolean
-): any {
-  let result = accumulator
-  each(
-    val,
-    (item, key) => {
-      result = iterator(result, item, key)
-    },
-    revert
-  )
-  return result
-}
-
-export function every<T extends string>(
-  val: T,
-  iterator: EachStringIterator,
-  revert?: boolean
-): boolean
-export function every<T>(
-  val: T[],
-  iterator: EachArrayIterator<T>,
-  revert?: boolean
-): boolean
-export function every<T extends {}, TValue = T[keyof T]>(
-  val: T,
-  iterator: EachObjectIterator,
-  revert?: boolean
-): boolean
-export function every(val: any, iterator: any, revert?: boolean): boolean {
-  let res = true
-  each(
-    val,
-    (item, key) => {
-      if (!iterator(item, key)) {
-        res = false
-        return false
-      }
-    },
-    revert
-  )
-  return res
-}
-
-export function some<T extends string>(
-  val: T,
-  iterator: EachStringIterator,
-  revert?: boolean
-): boolean
-export function some<T>(
-  val: T[],
-  iterator: EachArrayIterator<T>,
-  revert?: boolean
-): boolean
-export function some<T extends {}, TValue = T[keyof T]>(
-  val: T,
-  iterator: EachObjectIterator,
-  revert?: boolean
-): boolean
-export function some(val: any, iterator: any, revert?: boolean): boolean {
-  let res = false
-  each(
-    val,
-    (item, key) => {
-      if (iterator(item, key)) {
-        res = true
-        return false
-      }
-    },
-    revert
-  )
-  return res
-}
-
-export function findIndex<T extends string>(
-  val: T,
-  iterator: EachStringIterator,
-  revert?: boolean
-): number
-export function findIndex<T>(
-  val: T[],
-  iterator: EachArrayIterator<T>,
-  revert?: boolean
-): number
-export function findIndex<T extends {}, TValue = T[keyof T]>(
-  val: T,
-  iterator: EachObjectIterator,
-  revert?: boolean
-): keyof T
-export function findIndex(
-  val: any,
-  iterator: any,
-  revert?: boolean
-): string | number {
-  let res: number | string = -1
-  each(
-    val,
-    (item, key) => {
-      if (iterator(item, key)) {
-        res = key
-        return false
-      }
-    },
-    revert
-  )
-  return res
-}
-
-export function find<T extends string>(
-  val: T,
-  iterator: EachStringIterator,
-  revert?: boolean
-): any
-export function find<T>(
-  val: T[],
-  iterator: EachArrayIterator<T>,
-  revert?: boolean
-): T
-export function find<T extends {}, TValue = T[keyof T]>(
-  val: T,
-  iterator: EachObjectIterator,
-  revert?: boolean
-): T[keyof T]
-export function find(val: any, iterator: any, revert?: boolean): any {
-  let res: any
-  each(
-    val,
-    (item, key) => {
-      if (iterator(item, key)) {
-        res = item
-        return false
-      }
-    },
-    revert
-  )
-  return res
-}
-
-export function includes<T extends string>(
-  val: T,
-  searchElement: string,
-  revert?: boolean
-): boolean
-export function includes<T>(
-  val: T[],
-  searchElement: T,
-  revert?: boolean
-): boolean
-export function includes(val: any, searchElement: any, revert?: boolean) {
-  if (isStr(val)) return val.includes(searchElement)
-  return some(val, (item) => item === searchElement, revert)
-}
-
-export function includesWith<T extends string>(
-  val: T,
-  search: (item: string) => boolean
-): boolean
-export function includesWith<T>(val: T[], search: (item: T) => boolean): boolean
-export function includesWith(val: any, search: any) {
-  if (isArr(val)) {
-    return val.some((item) => search(item))
-  } else {
-    return false
-  }
-}
-
-export const flat = <T>(array: Array<T | T[]>): T[] => {
-  return toArr(array).reduce((buf, item) => {
-    if (isArr(item)) return buf.concat(flat(item))
-    return buf.concat(item)
-  }, [])
-}

package/src/clone.ts

@@ -1,96 +0,0 @@
-import { isFn } from './types'
-import { instOf } from './instanceof'
-type Filter = (value: any, key: string) => boolean
-
-const NATIVE_KEYS = [
-  ['Map', (map: any) => new Map(map)],
-  ['WeakMap', (map: any) => new WeakMap(map)],
-  ['WeakSet', (set: any) => new WeakSet(set)],
-  ['Set', (set: any) => new Set(set)],
-  ['Date', (date: any) => new Date(date)],
-  'FileList',
-  'File',
-  'URL',
-  'RegExp',
-  [
-    'Promise',
-    (promise: Promise<any>) =>
-      new Promise((resolve, reject) => promise.then(resolve, reject)),
-  ],
-]
-
-const isNativeObject = (values: any): any => {
-  for (let i = 0; i < NATIVE_KEYS.length; i++) {
-    const item = NATIVE_KEYS[i]
-    if (Array.isArray(item) && item[0]) {
-      if (instOf(values, item[0])) {
-        return item[1] ? item[1] : item[0]
-      }
-    } else {
-      if (instOf(values, item)) {
-        return item
-      }
-    }
-  }
-}
-
-export const shallowClone = (values: any) => {
-  let nativeClone: (values: any) => any
-  if (Array.isArray(values)) {
-    return values.slice(0)
-  } else if (isNativeObject(values)) {
-    nativeClone = isNativeObject(values)
-    return isFn(nativeClone) ? nativeClone(values) : values
-  } else if (typeof values === 'object' && !!values) {
-    return {
-      ...values,
-    }
-  }
-}
-
-export const clone = (values: any, filter?: Filter) => {
-  let nativeClone: (values: any) => any
-  if (Array.isArray(values)) {
-    return values.map((item) => clone(item, filter))
-  } else if (isNativeObject(values)) {
-    nativeClone = isNativeObject(values)
-    return isFn(nativeClone) ? nativeClone(values) : values
-  } else if (typeof values === 'object' && !!values) {
-    if ('$$typeof' in values && '_owner' in values) {
-      return values
-    }
-    if (values._isAMomentObject) {
-      return values
-    }
-    if (values._isJSONSchemaObject) {
-      return values
-    }
-
-    if (isFn(values.toJS)) {
-      return values
-    }
-    if (isFn(values.toJSON)) {
-      return values
-    }
-    if (Object.getOwnPropertySymbols(values || {}).length) {
-      return values
-    }
-    const res = {}
-    for (const key in values) {
-      if (Object.hasOwnProperty.call(values, key)) {
-        if (isFn(filter)) {
-          if (filter(values[key], key)) {
-            res[key] = clone(values[key], filter)
-          } else {
-            res[key] = values[key]
-          }
-        } else {
-          res[key] = clone(values[key], filter)
-        }
-      }
-    }
-    return res
-  } else {
-    return values
-  }
-}

package/src/compose.ts

@@ -1,7 +0,0 @@
-export const compose = (...fns: ((payload: any) => any)[]) => {
-  return (payload: any) => {
-    return fns.reduce((buf, fn) => {
-      return fn(buf)
-    }, payload)
-  }
-}