@formily-design/shared 1.0.0

package/lib/keycode.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeyCodeFromEvent = exports.KeyCode = void 0;
+var KeyCode;
+(function (KeyCode) {
+    KeyCode["Backspace"] = "Backspace";
+    KeyCode["Tab"] = "Tab";
+    KeyCode["Enter"] = "Enter";
+    KeyCode["Shift"] = "Shift";
+    KeyCode["Control"] = "Control";
+    KeyCode["Alt"] = "Alt";
+    KeyCode["CapsLock"] = "CapsLock";
+    KeyCode["Escape"] = "Escape";
+    KeyCode["Space"] = " ";
+    KeyCode["PageUp"] = "PageUp";
+    KeyCode["PageDown"] = "PageDown";
+    KeyCode["End"] = "End";
+    KeyCode["Home"] = "Home";
+    KeyCode["ArrowLeft"] = "ArrowLeft";
+    KeyCode["ArrowUp"] = "ArrowUp";
+    KeyCode["ArrowRight"] = "ArrowRight";
+    KeyCode["ArrowDown"] = "ArrowDown";
+    KeyCode["Left"] = "Left";
+    KeyCode["Up"] = "Up";
+    KeyCode["Right"] = "Right";
+    KeyCode["Down"] = "Down";
+    KeyCode["Insert"] = "Insert";
+    KeyCode["Delete"] = "Delete";
+    KeyCode["Zero"] = "0";
+    KeyCode["ClosedParen"] = ")";
+    KeyCode["One"] = "1";
+    KeyCode["ExclamationMark"] = "!";
+    KeyCode["Two"] = "2";
+    KeyCode["AtSign"] = "@";
+    KeyCode["Three"] = "3";
+    KeyCode["PoundSign"] = "\u00A3";
+    KeyCode["Hash"] = "#";
+    KeyCode["Four"] = "4";
+    KeyCode["DollarSign"] = "$";
+    KeyCode["Five"] = "5";
+    KeyCode["PercentSign"] = "%";
+    KeyCode["Six"] = "6";
+    KeyCode["Caret"] = "^";
+    KeyCode["Hat"] = "^";
+    KeyCode["Seven"] = "7";
+    KeyCode["Ampersand"] = "&";
+    KeyCode["Eight"] = "8";
+    KeyCode["Star"] = "*";
+    KeyCode["Asterisk"] = "*";
+    KeyCode["Nine"] = "9";
+    KeyCode["OpenParen"] = "(";
+    KeyCode["a"] = "a";
+    KeyCode["b"] = "b";
+    KeyCode["c"] = "c";
+    KeyCode["d"] = "d";
+    KeyCode["e"] = "e";
+    KeyCode["f"] = "f";
+    KeyCode["g"] = "g";
+    KeyCode["h"] = "h";
+    KeyCode["i"] = "i";
+    KeyCode["j"] = "j";
+    KeyCode["k"] = "k";
+    KeyCode["l"] = "l";
+    KeyCode["m"] = "m";
+    KeyCode["n"] = "n";
+    KeyCode["o"] = "o";
+    KeyCode["p"] = "p";
+    KeyCode["q"] = "q";
+    KeyCode["r"] = "r";
+    KeyCode["s"] = "s";
+    KeyCode["t"] = "t";
+    KeyCode["u"] = "u";
+    KeyCode["v"] = "v";
+    KeyCode["w"] = "w";
+    KeyCode["x"] = "x";
+    KeyCode["y"] = "y";
+    KeyCode["z"] = "z";
+    KeyCode["A"] = "A";
+    KeyCode["B"] = "B";
+    KeyCode["C"] = "C";
+    KeyCode["D"] = "D";
+    KeyCode["E"] = "E";
+    KeyCode["F"] = "F";
+    KeyCode["G"] = "G";
+    KeyCode["H"] = "H";
+    KeyCode["I"] = "I";
+    KeyCode["J"] = "J";
+    KeyCode["K"] = "K";
+    KeyCode["L"] = "L";
+    KeyCode["M"] = "M";
+    KeyCode["N"] = "N";
+    KeyCode["O"] = "O";
+    KeyCode["P"] = "P";
+    KeyCode["Q"] = "Q";
+    KeyCode["R"] = "R";
+    KeyCode["S"] = "S";
+    KeyCode["T"] = "T";
+    KeyCode["U"] = "U";
+    KeyCode["V"] = "V";
+    KeyCode["W"] = "W";
+    KeyCode["X"] = "X";
+    KeyCode["Y"] = "Y";
+    KeyCode["Z"] = "Z";
+    KeyCode["Meta"] = "Meta";
+    KeyCode["LeftWindowKey"] = "Meta";
+    KeyCode["RightWindowKey"] = "Meta";
+    KeyCode["Numpad0"] = "0";
+    KeyCode["Numpad1"] = "1";
+    KeyCode["Numpad2"] = "2";
+    KeyCode["Numpad3"] = "3";
+    KeyCode["Numpad4"] = "4";
+    KeyCode["Numpad5"] = "5";
+    KeyCode["Numpad6"] = "6";
+    KeyCode["Numpad7"] = "7";
+    KeyCode["Numpad8"] = "8";
+    KeyCode["Numpad9"] = "9";
+    KeyCode["Multiply"] = "*";
+    KeyCode["Add"] = "+";
+    KeyCode["Subtract"] = "-";
+    KeyCode["DecimalPoint"] = ".";
+    KeyCode["MSDecimalPoint"] = "Decimal";
+    KeyCode["Divide"] = "/";
+    KeyCode["F1"] = "F1";
+    KeyCode["F2"] = "F2";
+    KeyCode["F3"] = "F3";
+    KeyCode["F4"] = "F4";
+    KeyCode["F5"] = "F5";
+    KeyCode["F6"] = "F6";
+    KeyCode["F7"] = "F7";
+    KeyCode["F8"] = "F8";
+    KeyCode["F9"] = "F9";
+    KeyCode["F10"] = "F10";
+    KeyCode["F11"] = "F11";
+    KeyCode["F12"] = "F12";
+    KeyCode["NumLock"] = "NumLock";
+    KeyCode["ScrollLock"] = "ScrollLock";
+    KeyCode["SemiColon"] = ";";
+    KeyCode["Equals"] = "=";
+    KeyCode["Comma"] = ",";
+    KeyCode["Dash"] = "-";
+    KeyCode["Period"] = ".";
+    KeyCode["UnderScore"] = "_";
+    KeyCode["PlusSign"] = "+";
+    KeyCode["ForwardSlash"] = "/";
+    KeyCode["Tilde"] = "~";
+    KeyCode["GraveAccent"] = "`";
+    KeyCode["OpenBracket"] = "[";
+    KeyCode["ClosedBracket"] = "]";
+    KeyCode["Quote"] = "'";
+})(KeyCode || (exports.KeyCode = KeyCode = {}));
+const getKeyCodeFromEvent = (event) => {
+    return event.key;
+};
+exports.getKeyCodeFromEvent = getKeyCodeFromEvent;

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

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * 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 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUMap = void 0;
+const NEWER = Symbol('newer');
+const OLDER = Symbol('older');
+function Entry(key, value) {
+    this.key = key;
+    this.value = value;
+    this[NEWER] = undefined;
+    this[OLDER] = undefined;
+}
+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);
+    }
+}
+exports.LRUMap = LRUMap;
+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/lib/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/lib/observer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutObserver = void 0;
+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());
+    }
+}
+exports.LayoutObserver = LayoutObserver;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelIdle = exports.requestIdle = void 0;
+require("requestidlecallback");
+const globalThisPolyfill_1 = require("./globalThisPolyfill");
+const requestIdle = (callback, options) => {
+    return globalThisPolyfill_1.globalThisPolyfill['requestIdleCallback'](callback, options);
+};
+exports.requestIdle = requestIdle;
+const cancelIdle = (id) => {
+    globalThisPolyfill_1.globalThisPolyfill['cancelIdleCallback'](id);
+};
+exports.cancelIdle = cancelIdle;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollAnimate = exports.updateScrollValue = exports.calcAutoScrollBasicInfo = void 0;
+const animation_1 = require("./animation");
+const types_1 = require("./types");
+const MAX_SPEED = 80; // px/s
+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 * (0, animation_1.calcSpeedFactor)(end - pos, moveDistance),
+        };
+    }
+    else if (pos - begin < moveDistance) {
+        return {
+            direction: 'begin',
+            speedFactor,
+            speed: maxSpeed * (0, animation_1.calcSpeedFactor)(pos - begin, moveDistance),
+        };
+    }
+    return null;
+};
+exports.calcAutoScrollBasicInfo = calcAutoScrollBasicInfo;
+const updateScrollValue = (element, axis, value, callback) => {
+    if (element) {
+        if (!(0, types_1.isWindow)(element)) {
+            if (axis === 'x') {
+                if (element.scrollLeft + value > element.scrollWidth)
+                    return;
+                element.scrollLeft += value;
+                if ((0, types_1.isFn)(callback)) {
+                    callback(element.scrollLeft);
+                }
+            }
+            else {
+                if (element.scrollTop + value > element.scrollHeight)
+                    return;
+                element.scrollTop += value;
+                if ((0, types_1.isFn)(callback)) {
+                    callback(element.scrollTop);
+                }
+            }
+        }
+        else {
+            if (axis === 'x') {
+                element.scrollBy({
+                    left: value,
+                    behavior: 'smooth',
+                });
+            }
+            else {
+                element.scrollBy({
+                    top: value,
+                    behavior: 'smooth',
+                });
+            }
+            if ((0, types_1.isFn)(callback)) {
+                callback(value);
+            }
+        }
+    }
+};
+exports.updateScrollValue = updateScrollValue;
+const scrollAnimate = (element, axis, direction, speed, callback) => {
+    return (0, animation_1.createUniformSpeedAnimation)(speed, (delta) => {
+        (0, exports.updateScrollValue)(element, axis, direction === 'begin' ? 0 - delta : delta, callback);
+    });
+};
+exports.scrollAnimate = scrollAnimate;