@thienvu18/designable-shared 2.0.0

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Alibaba Group Holding Limited. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @thienvu18/designable-shared

package/esm/animation.d.ts

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

package/esm/animation.js

@@ -0,0 +1,33 @@
+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;
+    };
+};
+//越接近阈值，速度越小，越远离阈值，速度越大
+export const calcSpeedFactor = (delta = 0, threshold = Infinity) => {
+    if (threshold >= delta) {
+        return (threshold - delta) / threshold;
+    }
+    return 0;
+};

package/esm/array.d.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,111 @@
+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;
+                }
+            }
+        }
+        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;
+                }
+            }
+        }
+    }
+}
+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;
+}
+export function reduce(val, iterator, accumulator, revert) {
+    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;
+}
+export function some(val, iterator, revert) {
+    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;
+}
+export function find(val, iterator, revert) {
+    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);
+}
+export function includesWith(val, search) {
+    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);
+    }, []);
+};

package/esm/clone.d.ts

@@ -0,0 +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 {};

package/esm/clone.js

@@ -0,0 +1,97 @@
+import { isFn } from './types';
+import { instOf } from './instanceof';
+const NATIVE_KEYS = [
+    ['Map', (map) => new Map(map)],
+    ['WeakMap', (map) => new WeakMap(map)],
+    ['WeakSet', (set) => new WeakSet(set)],
+    ['Set', (set) => new Set(set)],
+    ['Date', (date) => new Date(date)],
+    'FileList',
+    'File',
+    'URL',
+    'RegExp',
+    [
+        'Promise',
+        (promise) => new Promise((resolve, reject) => promise.then(resolve, reject)),
+    ],
+];
+const isNativeObject = (values) => {
+    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) => {
+    let nativeClone;
+    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, filter) => {
+    let nativeClone;
+    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/esm/compose.d.ts

@@ -0,0 +1 @@
+export declare const compose: (...fns: ((payload: any) => any)[]) => (payload: any) => any;

package/esm/compose.js

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

package/esm/coordinate.d.ts

@@ -0,0 +1,106 @@
+export interface IPoint {
+    x: number;
+    y: number;
+}
+export interface ISize {
+    width: number;
+    height: number;
+}
+export interface ILineSegment {
+    start: IPoint;
+    end: IPoint;
+}
+export interface IRectEdgeLines {
+    v: ILineSegment[];
+    h: ILineSegment[];
+}
+export declare function isRect(rect: any): rect is IRect;
+export declare function isPoint(val: any): val is IPoint;
+export declare function isLineSegment(val: any): val is ILineSegment;
+export declare class Point implements IPoint {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+}
+export declare class Rect implements IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    get left(): number;
+    get right(): number;
+    get top(): number;
+    get bottom(): number;
+}
+export declare class LineSegment {
+    start: IPoint;
+    end: IPoint;
+    constructor(start: IPoint, end: IPoint);
+}
+export interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare enum RectQuadrant {
+    Inner1 = "I1",
+    Inner2 = "I2",
+    Inner3 = "I3",
+    Inner4 = "I4",
+    Outer1 = "O1",
+    Outer2 = "O2",
+    Outer3 = "O3",
+    Outer4 = "O4"
+}
+export interface IPointToRectRelative {
+    quadrant: RectQuadrant;
+    distance: number;
+}
+export declare function isPointInRect(point: IPoint, rect: IRect, sensitive?: boolean): boolean;
+export declare function isEqualRect(target: IRect, source: IRect): boolean;
+export declare function getRectPoints(source: IRect): Point[];
+export declare function isRectInRect(target: IRect, source: IRect): boolean;
+export declare function isCrossRectInRect(target: IRect, source: IRect): boolean;
+/**
+ * 计算点在矩形的哪个象限
+ * @param point
+ * @param rect
+ */
+export declare function calcQuadrantOfPointToRect(point: IPoint, rect: IRect): RectQuadrant;
+export declare function calcDistanceOfPointToRect(point: IPoint, rect: IRect): number;
+export declare function calcDistancePointToEdge(point: IPoint, rect: IRect): number;
+export declare function isNearAfter(point: IPoint, rect: IRect, inline?: boolean): boolean;
+/**
+ * 计算点鱼矩形的相对位置信息
+ * @param point
+ * @param rect
+ */
+export declare function calcRelativeOfPointToRect(point: IPoint, rect: IRect): IPointToRectRelative;
+export declare function calcBoundingRect(rects: IRect[]): Rect;
+export declare function calcRectByStartEndPoint(startPoint: IPoint, endPoint: IPoint, scrollX?: number, scrollY?: number): Rect;
+export declare function calcEdgeLinesOfRect(rect: IRect): IRectEdgeLines;
+export declare function calcRectOfAxisLineSegment(line: ILineSegment): Rect;
+export declare function calcSpaceBlockOfRect(target: IRect, source: IRect, type?: string): {
+    type: string;
+    distance: number;
+    rect: Rect;
+};
+export declare function calcExtendsLineSegmentOfRect(targetRect: Rect, referRect: Rect): {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};
+export declare function calcOffsetOfSnapLineSegmentToEdge(line: ILineSegment, current: IRect): {
+    x: number;
+    y: number;
+};
+export declare function calcDistanceOfSnapLineToEdges(line: ILineSegment, edges: IRectEdgeLines): number;
+export declare function calcCombineSnapLineSegment(target: ILineSegment, source: ILineSegment): ILineSegment;
+export declare function calcClosestEdges(line: ILineSegment, edges: IRectEdgeLines): [number, ILineSegment];