@thienvu18/designable-shared 2.0.1 → 2.0.2

package/esm/animation.d.ts

@@ -1,2 +1,8 @@
-export declare const createUniformSpeedAnimation: (speed: number, callback: (delta: number) => void) => () => void;
-export declare const calcSpeedFactor: (delta?: number, threshold?: number) => number;
+export declare const createUniformSpeedAnimation: (
+  speed: number,
+  callback: (delta: number) => void
+) => () => void
+export declare const calcSpeedFactor: (
+  delta?: number,
+  threshold?: number
+) => number

package/esm/animation.js

@@ -1,33 +1,32 @@
 export const createUniformSpeedAnimation = (speed = 10, callback) => {
-    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;
-    };
-};
+  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;
-};
+  if (threshold >= delta) {
+    return (threshold - delta) / threshold
+  }
+  return 0
+}

package/esm/array.d.ts

@@ -1,37 +1,163 @@
-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 declare const toArr: (val: any) => any[];
-export declare function each(val: string, iterator: EachStringIterator, revert?: boolean): void;
-export declare function each<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): void;
-export declare function each<T extends {}, TValue = T[keyof T]>(val: T, iterator: EachObjectIterator<TValue>, revert?: boolean): void;
-export declare function map<T>(val: string, iterator: MapStringIterator<T>, revert?: boolean): any;
-export declare function map<TItem, TResult>(val: TItem[], iterator: MapArrayIterator<TItem, TResult>, revert?: boolean): any;
-export declare function map<T extends {}, TResult>(val: T, iterator: MapObjectIterator<T[keyof T], TResult>, revert?: boolean): any;
-export declare function reduce<T, U>(val: T[], iterator: MemoArrayIterator<T, U>, accumulator?: U, revert?: boolean): U;
-export declare function reduce<T>(val: string, iterator: MemoStringIterator<T>, accumulator?: T, revert?: boolean): T;
-export declare function reduce<T extends {}, TValue = T[keyof T], TResult = any>(val: T, iterator: MemoObjectIterator<TValue, TResult>, accumulator?: TResult, revert?: boolean): TResult;
-export declare function every<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): boolean;
-export declare function every<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): boolean;
-export declare function every<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): boolean;
-export declare function some<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): boolean;
-export declare function some<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): boolean;
-export declare function some<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): boolean;
-export declare function findIndex<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): number;
-export declare function findIndex<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): number;
-export declare function findIndex<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): keyof T;
-export declare function find<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): any;
-export declare function find<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): T;
-export declare function find<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): T[keyof T];
-export declare function includes<T extends string>(val: T, searchElement: string, revert?: boolean): boolean;
-export declare function includes<T>(val: T[], searchElement: T, revert?: boolean): boolean;
-export declare function includesWith<T extends string>(val: T, search: (item: string) => boolean): boolean;
-export declare function includesWith<T>(val: T[], search: (item: T) => boolean): boolean;
-export declare const flat: <T>(array: (T | T[])[]) => T[];
-export {};
+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 declare const toArr: (val: any) => any[]
+export declare function each(
+  val: string,
+  iterator: EachStringIterator,
+  revert?: boolean
+): void
+export declare function each<T>(
+  val: T[],
+  iterator: EachArrayIterator<T>,
+  revert?: boolean
+): void
+export declare function each<T extends {}, TValue = T[keyof T]>(
+  val: T,
+  iterator: EachObjectIterator<TValue>,
+  revert?: boolean
+): void
+export declare function map<T>(
+  val: string,
+  iterator: MapStringIterator<T>,
+  revert?: boolean
+): any
+export declare function map<TItem, TResult>(
+  val: TItem[],
+  iterator: MapArrayIterator<TItem, TResult>,
+  revert?: boolean
+): any
+export declare function map<T extends {}, TResult>(
+  val: T,
+  iterator: MapObjectIterator<T[keyof T], TResult>,
+  revert?: boolean
+): any
+export declare function reduce<T, U>(
+  val: T[],
+  iterator: MemoArrayIterator<T, U>,
+  accumulator?: U,
+  revert?: boolean
+): U
+export declare function reduce<T>(
+  val: string,
+  iterator: MemoStringIterator<T>,
+  accumulator?: T,
+  revert?: boolean
+): T
+export declare function reduce<
+  T extends {},
+  TValue = T[keyof T],
+  TResult = any
+>(
+  val: T,
+  iterator: MemoObjectIterator<TValue, TResult>,
+  accumulator?: TResult,
+  revert?: boolean
+): TResult
+export declare function every<T extends string>(
+  val: T,
+  iterator: EachStringIterator,
+  revert?: boolean
+): boolean
+export declare function every<T>(
+  val: T[],
+  iterator: EachArrayIterator<T>,
+  revert?: boolean
+): boolean
+export declare function every<T extends {}>(
+  val: T,
+  iterator: EachObjectIterator,
+  revert?: boolean
+): boolean
+export declare function some<T extends string>(
+  val: T,
+  iterator: EachStringIterator,
+  revert?: boolean
+): boolean
+export declare function some<T>(
+  val: T[],
+  iterator: EachArrayIterator<T>,
+  revert?: boolean
+): boolean
+export declare function some<T extends {}>(
+  val: T,
+  iterator: EachObjectIterator,
+  revert?: boolean
+): boolean
+export declare function findIndex<T extends string>(
+  val: T,
+  iterator: EachStringIterator,
+  revert?: boolean
+): number
+export declare function findIndex<T>(
+  val: T[],
+  iterator: EachArrayIterator<T>,
+  revert?: boolean
+): number
+export declare function findIndex<T extends {}>(
+  val: T,
+  iterator: EachObjectIterator,
+  revert?: boolean
+): keyof T
+export declare function find<T extends string>(
+  val: T,
+  iterator: EachStringIterator,
+  revert?: boolean
+): any
+export declare function find<T>(
+  val: T[],
+  iterator: EachArrayIterator<T>,
+  revert?: boolean
+): T
+export declare function find<T extends {}>(
+  val: T,
+  iterator: EachObjectIterator,
+  revert?: boolean
+): T[keyof T]
+export declare function includes<T extends string>(
+  val: T,
+  searchElement: string,
+  revert?: boolean
+): boolean
+export declare function includes<T>(
+  val: T[],
+  searchElement: T,
+  revert?: boolean
+): boolean
+export declare function includesWith<T extends string>(
+  val: T,
+  search: (item: string) => boolean
+): boolean
+export declare function includesWith<T>(
+  val: T[],
+  search: (item: T) => boolean
+): boolean
+export declare const flat: <T>(array: (T | T[])[]) => T[]
+export {}

package/esm/array.js

@@ -1,111 +1,128 @@
-import { isArr, isObj, isStr } from './types';
-export const toArr = (val) => (isArr(val) ? val : val ? [val] : []);
+import { isArr, isObj, isStr } from './types'
+export const toArr = (val) => (isArr(val) ? val : val ? [val] : [])
 export function each(val, iterator, revert) {
-    if (isArr(val) || isStr(val)) {
-        if (revert) {
-            for (let i = val.length - 1; i >= 0; i--) {
-                if (iterator(val[i], i) === false) {
-                    return;
-                }
-            }
+  if (isArr(val) || isStr(val)) {
+    if (revert) {
+      for (let i = 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 {
+      for (let i = 0; i < val.length; i++) {
+        if (iterator(val[i], i) === false) {
+          return
         }
+      }
     }
-    else if (isObj(val)) {
-        let key;
-        for (key in val) {
-            if (Object.hasOwnProperty.call(val, key)) {
-                if (iterator(val[key], key) === false) {
-                    return;
-                }
-            }
+  } else if (isObj(val)) {
+    let key
+    for (key in val) {
+      if (Object.hasOwnProperty.call(val, key)) {
+        if (iterator(val[key], key) === false) {
+          return
         }
+      }
     }
+  }
 }
 export function map(val, iterator, revert) {
-    const res = isArr(val) || isStr(val) ? [] : {};
-    each(val, (item, key) => {
-        const value = iterator(item, key);
-        if (isArr(res)) {
-            ;
-            res.push(value);
-        }
-        else {
-            res[key] = value;
-        }
-    }, revert);
-    return res;
+  const res = isArr(val) || isStr(val) ? [] : {}
+  each(
+    val,
+    (item, key) => {
+      const value = iterator(item, key)
+      if (isArr(res)) {
+        res.push(value)
+      } else {
+        res[key] = value
+      }
+    },
+    revert
+  )
+  return res
 }
 export function reduce(val, iterator, accumulator, revert) {
-    let result = accumulator;
-    each(val, (item, key) => {
-        result = iterator(result, item, key);
-    }, revert);
-    return result;
+  let result = accumulator
+  each(
+    val,
+    (item, key) => {
+      result = iterator(result, item, key)
+    },
+    revert
+  )
+  return result
 }
 export function every(val, iterator, revert) {
-    let res = true;
-    each(val, (item, key) => {
-        if (!iterator(item, key)) {
-            res = false;
-            return false;
-        }
-    }, revert);
-    return res;
+  let res = true
+  each(
+    val,
+    (item, key) => {
+      if (!iterator(item, key)) {
+        res = false
+        return false
+      }
+    },
+    revert
+  )
+  return res
 }
 export function some(val, iterator, revert) {
-    let res = false;
-    each(val, (item, key) => {
-        if (iterator(item, key)) {
-            res = true;
-            return false;
-        }
-    }, revert);
-    return res;
+  let res = false
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = true
+        return false
+      }
+    },
+    revert
+  )
+  return res
 }
 export function findIndex(val, iterator, revert) {
-    let res = -1;
-    each(val, (item, key) => {
-        if (iterator(item, key)) {
-            res = key;
-            return false;
-        }
-    }, revert);
-    return res;
+  let res = -1
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = key
+        return false
+      }
+    },
+    revert
+  )
+  return res
 }
 export function find(val, iterator, revert) {
-    let res;
-    each(val, (item, key) => {
-        if (iterator(item, key)) {
-            res = item;
-            return false;
-        }
-    }, revert);
-    return res;
+  let res
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = item
+        return false
+      }
+    },
+    revert
+  )
+  return res
 }
 export function includes(val, searchElement, revert) {
-    if (isStr(val))
-        return val.includes(searchElement);
-    return some(val, (item) => item === searchElement, revert);
+  if (isStr(val)) return val.includes(searchElement)
+  return some(val, (item) => item === searchElement, revert)
 }
 export function includesWith(val, search) {
-    if (isArr(val)) {
-        return val.some((item) => search(item));
-    }
-    else {
-        return false;
-    }
+  if (isArr(val)) {
+    return val.some((item) => search(item))
+  } else {
+    return false
+  }
 }
 export const flat = (array) => {
-    return toArr(array).reduce((buf, item) => {
-        if (isArr(item))
-            return buf.concat(flat(item));
-        return buf.concat(item);
-    }, []);
-};
+  return toArr(array).reduce((buf, item) => {
+    if (isArr(item)) return buf.concat(flat(item))
+    return buf.concat(item)
+  }, [])
+}

package/esm/clone.d.ts

@@ -1,4 +1,4 @@
-type Filter = (value: any, key: string) => boolean;
-export declare const shallowClone: (values: any) => any;
-export declare const clone: (values: any, filter?: Filter) => any;
-export {};
+type Filter = (value: any, key: string) => boolean
+export declare const shallowClone: (values: any) => any
+export declare const clone: (values: any, filter?: Filter) => any
+export {}