@formily-design/shared 1.0.0

package/esm/lru.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+ * recently used items while discarding least recently used items when its limit
+ * is reached.
+ *
+ * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+ * See README.md for details.
+ *
+ * Illustration of the design:
+ *
+ *       entry             entry             entry             entry
+ *       ______            ______            ______            ______
+ *      | head |.newer => |      |.newer => |      |.newer => | tail |
+ *      |  A   |          |  B   |          |  C   |          |  D   |
+ *      |______| <= older.|______| <= older.|______| <= older.|______|
+ *
+ *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+ */
+export declare class LRUMap<K, V> {
+    size: number;
+    limit: number;
+    oldest: any;
+    newest: any;
+    _keymap: Map<K, {
+        key: K;
+        value: V;
+    }>;
+    constructor(limit: number, entries?: any);
+    private _markEntryAsUsed;
+    assign(entries: any): void;
+    get(key: K): V;
+    set(key: K, value: V): this;
+    shift(): any[];
+    find(key: K): V;
+    has(key: K): boolean;
+    delete(key: any): V;
+    clear(): void;
+    keys(): KeyIterator;
+    values(): ValueIterator;
+    entries(): void;
+    forEach(fun: (value: any, key: any, ctx: object) => void, thisObj: any): void;
+    toJSON(): any[];
+    toString(): string;
+    [Symbol.iterator](): EntryIterator;
+}
+declare class EntryIterator {
+    entry: any;
+    constructor(oldestEntry: any);
+    [Symbol.iterator](): this;
+    next(): {
+        done: boolean;
+        value: any[];
+    };
+}
+declare class KeyIterator {
+    entry: any;
+    constructor(oldestEntry: any);
+    [Symbol.iterator](): this;
+    next(): {
+        done: boolean;
+        value: any;
+    };
+}
+declare class ValueIterator {
+    entry: any;
+    constructor(oldestEntry: any);
+    [Symbol.iterator](): this;
+    next(): {
+        done: boolean;
+        value: any;
+    };
+}
+export {};

package/esm/lru.js

@@ -0,0 +1,293 @@
+/**
+ * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+ * recently used items while discarding least recently used items when its limit
+ * is reached.
+ *
+ * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+ * See README.md for details.
+ *
+ * Illustration of the design:
+ *
+ *       entry             entry             entry             entry
+ *       ______            ______            ______            ______
+ *      | head |.newer => |      |.newer => |      |.newer => | tail |
+ *      |  A   |          |  B   |          |  C   |          |  D   |
+ *      |______| <= older.|______| <= older.|______| <= older.|______|
+ *
+ *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+ */
+/* eslint-disable */
+const NEWER = Symbol('newer');
+const OLDER = Symbol('older');
+function Entry(key, value) {
+    this.key = key;
+    this.value = value;
+    this[NEWER] = undefined;
+    this[OLDER] = undefined;
+}
+export class LRUMap {
+    constructor(limit, entries) {
+        if (typeof limit !== 'number') {
+            // called as (entries)
+            entries = limit;
+            limit = 0;
+        }
+        this.size = 0;
+        this.limit = limit;
+        this.oldest = this.newest = undefined;
+        this._keymap = new Map();
+        if (entries) {
+            this.assign(entries);
+            if (limit < 1) {
+                this.limit = this.size;
+            }
+        }
+    }
+    _markEntryAsUsed(entry) {
+        if (entry === this.newest) {
+            // Already the most recenlty used entry, so no need to update the list
+            return;
+        }
+        // HEAD--------------TAIL
+        //   <.older   .newer>
+        //  <--- add direction --
+        //   A  B  C  <D>  E
+        if (entry[NEWER]) {
+            if (entry === this.oldest) {
+                this.oldest = entry[NEWER];
+            }
+            entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.
+        }
+        if (entry[OLDER]) {
+            entry[OLDER][NEWER] = entry[NEWER]; // C. --> E
+        }
+        entry[NEWER] = undefined; // D --x
+        entry[OLDER] = this.newest; // D. --> E
+        if (this.newest) {
+            this.newest[NEWER] = entry; // E. <-- D
+        }
+        this.newest = entry;
+    }
+    assign(entries) {
+        let entry;
+        let limit = this.limit || Number.MAX_VALUE;
+        this._keymap.clear();
+        const it = entries[Symbol.iterator]();
+        for (let itv = it.next(); !itv.done; itv = it.next()) {
+            const e = new Entry(itv.value[0], itv.value[1]);
+            this._keymap.set(e.key, e);
+            if (!entry) {
+                this.oldest = e;
+            }
+            else {
+                entry[NEWER] = e;
+                e[OLDER] = entry;
+            }
+            entry = e;
+            if (limit-- === 0) {
+                throw new Error('overflow');
+            }
+        }
+        this.newest = entry;
+        this.size = this._keymap.size;
+    }
+    get(key) {
+        // First, find our cache entry
+        const entry = this._keymap.get(key);
+        if (!entry) {
+            return;
+        } // Not cached. Sorry.
+        // As <key> was found in the cache, register it as being requested recently
+        this._markEntryAsUsed(entry);
+        return entry.value;
+    }
+    set(key, value) {
+        let entry = this._keymap.get(key);
+        if (entry) {
+            // update existing
+            entry.value = value;
+            this._markEntryAsUsed(entry);
+            return this;
+        }
+        // new entry
+        this._keymap.set(key, (entry = new Entry(key, value)));
+        if (this.newest) {
+            // link previous tail to the new tail (entry)
+            this.newest[NEWER] = entry;
+            entry[OLDER] = this.newest;
+        }
+        else {
+            // we're first in -- yay
+            this.oldest = entry;
+        }
+        // add new entry to the end of the linked list -- it's now the freshest entry.
+        this.newest = entry;
+        ++this.size;
+        if (this.size > this.limit) {
+            // we hit the limit -- remove the head
+            this.shift();
+        }
+        return this;
+    }
+    shift() {
+        // todo: handle special case when limit == 1
+        const entry = this.oldest;
+        if (entry) {
+            if (this.oldest[NEWER]) {
+                // advance the list
+                this.oldest = this.oldest[NEWER];
+                this.oldest[OLDER] = undefined;
+            }
+            else {
+                // the cache is exhausted
+                this.oldest = undefined;
+                this.newest = undefined;
+            }
+            // Remove last strong reference to <entry> and remove links from the purged
+            // entry being returned:
+            entry[NEWER] = entry[OLDER] = undefined;
+            this._keymap.delete(entry.key);
+            --this.size;
+            return [entry.key, entry.value];
+        }
+    }
+    find(key) {
+        const e = this._keymap.get(key);
+        return e ? e.value : undefined;
+    }
+    has(key) {
+        return this._keymap.has(key);
+    }
+    delete(key) {
+        const entry = this._keymap.get(key);
+        if (!entry) {
+            return;
+        }
+        this._keymap.delete(entry.key);
+        if (entry[NEWER] && entry[OLDER]) {
+            // relink the older entry with the newer entry
+            entry[OLDER][NEWER] = entry[NEWER];
+            entry[NEWER][OLDER] = entry[OLDER];
+        }
+        else if (entry[NEWER]) {
+            // remove the link to us
+            entry[NEWER][OLDER] = undefined;
+            // link the newer entry to head
+            this.oldest = entry[NEWER];
+        }
+        else if (entry[OLDER]) {
+            // remove the link to us
+            entry[OLDER][NEWER] = undefined;
+            // link the newer entry to head
+            this.newest = entry[OLDER];
+        }
+        else {
+            // if(entry[OLDER] === undefined && entry.newer === undefined) {
+            this.oldest = this.newest = undefined;
+        }
+        this.size--;
+        return entry.value;
+    }
+    clear() {
+        // Not clearing links should be safe, as we don't expose live links to user
+        this.oldest = this.newest = undefined;
+        this.size = 0;
+        this._keymap.clear();
+    }
+    keys() {
+        return new KeyIterator(this.oldest);
+    }
+    values() {
+        return new ValueIterator(this.oldest);
+    }
+    entries() { }
+    forEach(fun, thisObj) {
+        if (typeof thisObj !== 'object') {
+            thisObj = this;
+        }
+        let entry = this.oldest;
+        while (entry) {
+            fun.call(thisObj, entry.value, entry.key, this);
+            entry = entry[NEWER];
+        }
+    }
+    toJSON() {
+        const s = new Array(this.size);
+        let i = 0;
+        let entry = this.oldest;
+        while (entry) {
+            s[i++] = { key: entry.key, value: entry.value };
+            entry = entry[NEWER];
+        }
+        return s;
+    }
+    toString() {
+        let s = '';
+        let entry = this.oldest;
+        while (entry) {
+            s += String(entry.key) + ':' + entry.value;
+            entry = entry[NEWER];
+            if (entry) {
+                s += ' < ';
+            }
+        }
+        return s;
+    }
+    [Symbol.iterator]() {
+        return new EntryIterator(this.oldest);
+    }
+}
+class EntryIterator {
+    constructor(oldestEntry) {
+        this.entry = oldestEntry;
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    next() {
+        const ent = this.entry;
+        if (ent) {
+            this.entry = ent[NEWER];
+            return { done: false, value: [ent.key, ent.value] };
+        }
+        else {
+            return { done: true, value: undefined };
+        }
+    }
+}
+class KeyIterator {
+    constructor(oldestEntry) {
+        this.entry = oldestEntry;
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    next() {
+        const ent = this.entry;
+        if (ent) {
+            this.entry = ent[NEWER];
+            return { done: false, value: ent.key };
+        }
+        else {
+            return { done: true, value: undefined };
+        }
+    }
+}
+class ValueIterator {
+    constructor(oldestEntry) {
+        this.entry = oldestEntry;
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    next() {
+        const ent = this.entry;
+        if (ent) {
+            this.entry = ent[NEWER];
+            return { done: false, value: ent.value };
+        }
+        else {
+            return { done: true, value: undefined };
+        }
+    }
+}

package/esm/observer.d.ts

@@ -0,0 +1,9 @@
+export declare class LayoutObserver {
+    private resizeObserver;
+    private performanceObserver;
+    private mutationObserver;
+    private connected;
+    constructor(observer?: () => void);
+    observe: (target: HTMLElement | Element) => void;
+    disconnect: () => void;
+}

package/esm/observer.js

@@ -0,0 +1,29 @@
+export class LayoutObserver {
+    constructor(observer = () => { }) {
+        this.connected = false;
+        this.observe = (target) => {
+            this.resizeObserver.observe(target);
+            this.performanceObserver.observe({
+                entryTypes: ['paint', 'element', 'layout-shift', 'event'],
+            });
+            this.mutationObserver.observe(target, {
+                attributeFilter: ['style'],
+                attributes: true,
+            });
+            this.connected = true;
+        };
+        this.disconnect = () => {
+            if (this.connected) {
+                this.resizeObserver.disconnect();
+                this.performanceObserver.disconnect();
+                this.mutationObserver.disconnect();
+            }
+            this.connected = false;
+        };
+        this.resizeObserver = new ResizeObserver(() => observer());
+        this.performanceObserver = new PerformanceObserver(() => {
+            observer();
+        });
+        this.mutationObserver = new MutationObserver(() => observer());
+    }
+}

package/esm/request-idle.d.ts

@@ -0,0 +1,10 @@
+import 'requestidlecallback';
+export interface IIdleDeadline {
+    didTimeout: boolean;
+    timeRemaining: () => DOMHighResTimeStamp;
+}
+export interface IdleCallbackOptions {
+    timeout?: number;
+}
+export declare const requestIdle: (callback: (params: IIdleDeadline) => void, options?: IdleCallbackOptions) => number;
+export declare const cancelIdle: (id: number) => void;

package/esm/request-idle.js

@@ -0,0 +1,8 @@
+import 'requestidlecallback';
+import { globalThisPolyfill } from './globalThisPolyfill';
+export const requestIdle = (callback, options) => {
+    return globalThisPolyfill['requestIdleCallback'](callback, options);
+};
+export const cancelIdle = (id) => {
+    globalThisPolyfill['cancelIdleCallback'](id);
+};

package/esm/scroller.d.ts

@@ -0,0 +1,10 @@
+import { IPoint } from './coordinate';
+export type ScrollDirection = 'begin' | 'end';
+export interface IAutoScrollBasicInfo {
+    direction: ScrollDirection;
+    speedFactor: number;
+    speed: number;
+}
+export declare const calcAutoScrollBasicInfo: (point: IPoint, axis: "x" | "y", viewport: DOMRect, maxSpeed?: number) => IAutoScrollBasicInfo | null;
+export declare const updateScrollValue: (element: HTMLElement | Window, axis: "x" | "y", value: number, callback?: (scrollValue: number) => void) => void;
+export declare const scrollAnimate: (element: HTMLElement | Window, axis: "x" | "y", direction: "begin" | "end", speed: number, callback?: (scrollValue: number) => void) => () => void;

package/esm/scroller.js

@@ -0,0 +1,82 @@
+import { createUniformSpeedAnimation, calcSpeedFactor } from './animation';
+import { isFn, isWindow } from './types';
+const MAX_SPEED = 80; // px/s
+export const calcAutoScrollBasicInfo = (point, axis, viewport, maxSpeed = MAX_SPEED) => {
+    const { left, right, top, bottom } = viewport;
+    const { x, y } = point;
+    let begin;
+    let end;
+    let pos;
+    let speedFactor;
+    if (axis === 'x') {
+        begin = left;
+        end = right;
+        pos = x;
+    }
+    else {
+        begin = top;
+        end = bottom;
+        pos = y;
+    }
+    const scrollerSize = end - begin;
+    const moveDistance = scrollerSize > 400 ? 100 : scrollerSize / 3;
+    if (end - pos < moveDistance) {
+        return {
+            direction: 'end',
+            speedFactor,
+            speed: maxSpeed * calcSpeedFactor(end - pos, moveDistance),
+        };
+    }
+    else if (pos - begin < moveDistance) {
+        return {
+            direction: 'begin',
+            speedFactor,
+            speed: maxSpeed * calcSpeedFactor(pos - begin, moveDistance),
+        };
+    }
+    return null;
+};
+export const updateScrollValue = (element, axis, value, callback) => {
+    if (element) {
+        if (!isWindow(element)) {
+            if (axis === 'x') {
+                if (element.scrollLeft + value > element.scrollWidth)
+                    return;
+                element.scrollLeft += value;
+                if (isFn(callback)) {
+                    callback(element.scrollLeft);
+                }
+            }
+            else {
+                if (element.scrollTop + value > element.scrollHeight)
+                    return;
+                element.scrollTop += value;
+                if (isFn(callback)) {
+                    callback(element.scrollTop);
+                }
+            }
+        }
+        else {
+            if (axis === 'x') {
+                element.scrollBy({
+                    left: value,
+                    behavior: 'smooth',
+                });
+            }
+            else {
+                element.scrollBy({
+                    top: value,
+                    behavior: 'smooth',
+                });
+            }
+            if (isFn(callback)) {
+                callback(value);
+            }
+        }
+    }
+};
+export const scrollAnimate = (element, axis, direction, speed, callback) => {
+    return createUniformSpeedAnimation(speed, (delta) => {
+        updateScrollValue(element, axis, direction === 'begin' ? 0 - delta : delta, callback);
+    });
+};

package/esm/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/esm/subscribable.js

@@ -0,0 +1,48 @@
+import { isFn } from './types';
+const UNSUBSCRIBE_ID_SYMBOL = Symbol('UNSUBSCRIBE_ID_SYMBOL');
+export 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 (!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 (isFn(this.subscribers[key])) {
+                event['context'] = context;
+                if (this.subscribers[key](event) === false) {
+                    interrupted = true;
+                }
+            }
+        }
+        return interrupted ? false : true;
+    }
+    subscribe(subscriber) {
+        let id;
+        if (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;
+    }
+}

package/esm/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/esm/types.js

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

package/esm/uid.d.ts

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

package/esm/uid.js

@@ -0,0 +1,9 @@
+let IDX = 36, HEX = '';
+while (IDX--)
+    HEX += IDX.toString(36);
+export function uid(len) {
+    let str = '', num = len || 11;
+    while (num--)
+        str += HEX[(Math.random() * 36) | 0];
+    return str;
+}

package/lib/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/lib/animation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcSpeedFactor = exports.createUniformSpeedAnimation = void 0;
+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;
+    };
+};
+exports.createUniformSpeedAnimation = createUniformSpeedAnimation;
+//越接近阈值，速度越小，越远离阈值，速度越大
+const calcSpeedFactor = (delta = 0, threshold = Infinity) => {
+    if (threshold >= delta) {
+        return (threshold - delta) / threshold;
+    }
+    return 0;
+};
+exports.calcSpeedFactor = calcSpeedFactor;