@formily-design/shared 1.0.0

package/lib/subscribable.d.ts

@@ -0,0 +1,14 @@
+declare const UNSUBSCRIBE_ID_SYMBOL: unique symbol;
+export interface ISubscriber<Payload = any> {
+    (payload: Payload): void | boolean;
+}
+export declare class Subscribable<ExtendsType = any> {
+    private subscribers;
+    dispatch<T extends ExtendsType = any>(event: T, context?: any): boolean;
+    subscribe(subscriber: ISubscriber): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    unsubscribe: (id?: number | string | (() => void)) => void;
+}
+export {};

package/lib/subscribable.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscribable = void 0;
+const types_1 = require("./types");
+const UNSUBSCRIBE_ID_SYMBOL = Symbol('UNSUBSCRIBE_ID_SYMBOL');
+class Subscribable {
+    constructor() {
+        this.subscribers = {
+            index: 0,
+        };
+        this.unsubscribe = (id) => {
+            if (id === undefined || id === null) {
+                for (const key in this.subscribers) {
+                    this.unsubscribe(key);
+                }
+                return;
+            }
+            if (!(0, types_1.isFn)(id)) {
+                delete this.subscribers[id];
+            }
+            else {
+                delete this.subscribers[id[UNSUBSCRIBE_ID_SYMBOL]];
+            }
+        };
+    }
+    dispatch(event, context) {
+        let interrupted = false;
+        for (const key in this.subscribers) {
+            if ((0, types_1.isFn)(this.subscribers[key])) {
+                event['context'] = context;
+                if (this.subscribers[key](event) === false) {
+                    interrupted = true;
+                }
+            }
+        }
+        return interrupted ? false : true;
+    }
+    subscribe(subscriber) {
+        let id;
+        if ((0, types_1.isFn)(subscriber)) {
+            id = this.subscribers.index + 1;
+            this.subscribers[id] = subscriber;
+            this.subscribers.index++;
+        }
+        const unsubscribe = () => {
+            this.unsubscribe(id);
+        };
+        unsubscribe[UNSUBSCRIBE_ID_SYMBOL] = id;
+        return unsubscribe;
+    }
+}
+exports.Subscribable = Subscribable;

package/lib/types.d.ts

@@ -0,0 +1,13 @@
+export declare const getType: (obj: any) => any;
+export declare const isFn: (obj: unknown) => obj is (...args: any[]) => any;
+export declare const isWindow: (obj: unknown) => obj is Window;
+export declare const isHTMLElement: (obj: any) => obj is HTMLElement;
+export declare const isArr: (arg: any) => arg is any[];
+export declare const isPlainObj: (obj: unknown) => obj is object;
+export declare const isStr: (obj: unknown) => obj is string;
+export declare const isBool: (obj: unknown) => obj is boolean;
+export declare const isNum: (obj: unknown) => obj is number;
+export declare const isObj: (val: unknown) => val is object;
+export declare const isRegExp: (obj: unknown) => obj is RegExp;
+export declare const isValid: (val: any) => boolean;
+export declare const isValidNumber: (val: any) => val is number;

package/lib/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidNumber = exports.isValid = exports.isRegExp = exports.isObj = exports.isNum = exports.isBool = exports.isStr = exports.isPlainObj = exports.isArr = exports.isHTMLElement = exports.isWindow = exports.isFn = exports.getType = void 0;
+const isType = (type) => (obj) => obj != null &&
+    (Array.isArray(type) ? type : [type]).some((t) => (0, exports.getType)(obj) === `[object ${t}]`);
+const getType = (obj) => Object.prototype.toString.call(obj);
+exports.getType = getType;
+exports.isFn = isType([
+    'Function',
+    'AsyncFunction',
+    'GeneratorFunction',
+]);
+exports.isWindow = isType('Window');
+const isHTMLElement = (obj) => {
+    return (obj === null || obj === void 0 ? void 0 : obj['nodeName']) || (obj === null || obj === void 0 ? void 0 : obj['tagName']);
+};
+exports.isHTMLElement = isHTMLElement;
+exports.isArr = Array.isArray;
+exports.isPlainObj = isType('Object');
+exports.isStr = isType('String');
+exports.isBool = isType('Boolean');
+exports.isNum = isType('Number');
+const isObj = (val) => typeof val === 'object';
+exports.isObj = isObj;
+exports.isRegExp = isType('RegExp');
+const isValid = (val) => val !== null && val !== undefined;
+exports.isValid = isValid;
+const isValidNumber = (val) => !isNaN(val) && (0, exports.isNum)(val);
+exports.isValidNumber = isValidNumber;

package/lib/uid.d.ts

@@ -0,0 +1 @@
+export declare function uid(len?: number): string;

package/lib/uid.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uid = uid;
+let IDX = 36, HEX = '';
+while (IDX--)
+    HEX += IDX.toString(36);
+function uid(len) {
+    let str = '', num = len || 11;
+    while (num--)
+        str += HEX[(Math.random() * 36) | 0];
+    return str;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@formily-design/shared",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "lib",
+  "types": "lib/index.d.ts",
+  "engines": {
+    "npm": ">=3.0.0"
+  },
+  "module": "esm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alibaba/designable.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alibaba/designable/issues"
+  },
+  "homepage": "https://github.com/alibaba/designable#readme",
+  "scripts": {
+    "build": "rimraf -rf lib esm dist && npm run build:cjs && npm run build:esm && npm run build:umd",
+    "build:cjs": "tsc --project tsconfig.build.json",
+    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir esm",
+    "build:umd": "rollup --config"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "requestidlecallback": "^0.3.0"
+  },
+  "gitHead": "f3496a519e4be3f14900ddbe44744ae482247047"
+}

package/rollup.config.js

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

package/src/animation.ts

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

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

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

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