@formily-design/shared 1.0.0

package/lib/event.d.ts

@@ -0,0 +1,96 @@
+import { Subscribable, ISubscriber } from './subscribable';
+export type EventOptions = boolean | (AddEventListenerOptions & EventListenerOptions & {
+    mode?: 'onlyOne' | 'onlyParent' | 'onlyChild';
+});
+export type EventContainer = Window | HTMLElement | HTMLDocument;
+export type EventDriverContainer = HTMLElement | HTMLDocument;
+export interface IEventEffect<T> {
+    (engine: T): void;
+}
+export interface IEventDriver {
+    container: EventDriverContainer;
+    contentWindow: Window;
+    attach(container: EventDriverContainer): void;
+    detach(container: EventDriverContainer): void;
+    dispatch<T extends ICustomEvent<any> = any>(event: T): void | boolean;
+    subscribe<T extends ICustomEvent<any> = any>(subscriber: ISubscriber<T>): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    addEventListener(type: any, listener: any, options: any): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    removeEventListener(type: any, listener: any, options?: any): void;
+    batchAddEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: any, listener: any, options?: any): void;
+    batchRemoveEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: any, listener: any, options: any): void;
+}
+export interface IEventDriverClass<T> {
+    new (engine: T, context?: any): IEventDriver;
+}
+export interface ICustomEvent<EventData = any, EventContext = any> {
+    type: string;
+    data?: EventData;
+    context?: EventContext;
+}
+export interface CustomEventClass {
+    new (...args: any[]): any;
+}
+export interface IEventProps<T = Event> {
+    drivers?: IEventDriverClass<T>[];
+    effects?: IEventEffect<T>[];
+}
+/**
+ * 事件驱动器基类
+ */
+export declare class EventDriver<Engine extends Event = Event, Context = any> implements IEventDriver {
+    engine: Engine;
+    container: EventDriverContainer;
+    contentWindow: Window;
+    context: Context;
+    constructor(engine: Engine, context?: Context);
+    dispatch<T extends ICustomEvent<any> = any>(event: T): boolean;
+    subscribe<T extends ICustomEvent<any> = any>(subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeTo<T extends CustomEventClass>(type: T, subscriber: ISubscriber<InstanceType<T>>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeWith<T extends ICustomEvent = ICustomEvent>(type: string | string[], subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    attach(container: EventDriverContainer): void;
+    detach(container: EventDriverContainer): void;
+    eventTarget(type: string): Window | EventDriverContainer;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchAddEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchRemoveEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+}
+/**
+ * 事件引擎
+ */
+export declare class Event extends Subscribable<ICustomEvent<any>> {
+    private drivers;
+    private containers;
+    constructor(props?: IEventProps);
+    subscribeTo<T extends CustomEventClass>(type: T, subscriber: ISubscriber<InstanceType<T>>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeWith<T extends ICustomEvent = ICustomEvent>(type: string | string[], subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    attachEvents(container: EventContainer, contentWindow?: Window, context?: any): any;
+    detachEvents(container?: EventContainer): any;
+}

package/lib/event.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = exports.EventDriver = void 0;
+const types_1 = require("./types");
+const subscribable_1 = require("./subscribable");
+const globalThisPolyfill_1 = require("./globalThisPolyfill");
+const ATTACHED_SYMBOL = Symbol('ATTACHED_SYMBOL');
+const EVENTS_SYMBOL = Symbol('__EVENTS_SYMBOL__');
+const EVENTS_ONCE_SYMBOL = Symbol('EVENTS_ONCE_SYMBOL');
+const EVENTS_BATCH_SYMBOL = Symbol('EVENTS_BATCH_SYMBOL');
+const DRIVER_INSTANCES_SYMBOL = Symbol('DRIVER_INSTANCES_SYMBOL');
+const isOnlyMode = (mode) => mode === 'onlyOne' || mode === 'onlyChild' || mode === 'onlyParent';
+/**
+ * 事件驱动器基类
+ */
+class EventDriver {
+    constructor(engine, context) {
+        this.container = document;
+        this.contentWindow = globalThisPolyfill_1.globalThisPolyfill;
+        this.engine = engine;
+        this.context = context;
+    }
+    dispatch(event) {
+        return this.engine.dispatch(event, this.context);
+    }
+    subscribe(subscriber) {
+        return this.engine.subscribe(subscriber);
+    }
+    subscribeTo(type, subscriber) {
+        return this.engine.subscribeTo(type, subscriber);
+    }
+    subscribeWith(type, subscriber) {
+        return this.engine.subscribeWith(type, subscriber);
+    }
+    attach(container) {
+        console.error('attach must implement.');
+    }
+    detach(container) {
+        console.error('attach must implement.');
+    }
+    eventTarget(type) {
+        var _a;
+        if (type === 'resize' || type === 'scroll') {
+            if (this.container === ((_a = this.contentWindow) === null || _a === void 0 ? void 0 : _a.document)) {
+                return this.contentWindow;
+            }
+        }
+        return this.container;
+    }
+    addEventListener(type, listener, options) {
+        var _a, _b, _c, _d;
+        const target = this.eventTarget(type);
+        if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+            target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+            const constructor = this['constructor'];
+            constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+            const handler = target[EVENTS_ONCE_SYMBOL][type];
+            const container = constructor[EVENTS_ONCE_SYMBOL][type];
+            if (!handler) {
+                if (container) {
+                    if (options.mode === 'onlyChild') {
+                        if (container.contains(target)) {
+                            container.removeEventListener(type, container[EVENTS_ONCE_SYMBOL][type], options);
+                            delete container[EVENTS_ONCE_SYMBOL][type];
+                        }
+                    }
+                    else if (options.mode === 'onlyParent') {
+                        if (container.contains(target))
+                            return;
+                    }
+                }
+                target.addEventListener(type, listener, options);
+                target[EVENTS_ONCE_SYMBOL][type] = listener;
+                constructor[EVENTS_ONCE_SYMBOL][type] = target;
+            }
+        }
+        else {
+            target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+            target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+            if (!((_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, listener))) {
+                target.addEventListener(type, listener, options);
+                (_d = (_c = target[EVENTS_SYMBOL][type]) === null || _c === void 0 ? void 0 : _c.set) === null || _d === void 0 ? void 0 : _d.call(_c, listener, true);
+            }
+        }
+    }
+    removeEventListener(type, listener, options) {
+        var _a, _b;
+        const target = this.eventTarget(type);
+        if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+            const constructor = this['constructor'];
+            constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+            target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+            delete constructor[EVENTS_ONCE_SYMBOL][type];
+            delete target[EVENTS_ONCE_SYMBOL][type];
+            target.removeEventListener(type, listener, options);
+        }
+        else {
+            target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+            target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+            (_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.delete) === null || _b === void 0 ? void 0 : _b.call(_a, listener);
+            target.removeEventListener(type, listener, options);
+        }
+    }
+    batchAddEventListener(type, listener, options) {
+        this.engine[DRIVER_INSTANCES_SYMBOL] =
+            this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+        if (!this.engine[DRIVER_INSTANCES_SYMBOL].includes(this)) {
+            this.engine[DRIVER_INSTANCES_SYMBOL].push(this);
+        }
+        this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+            const target = driver.eventTarget(type);
+            target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+            if (!target[EVENTS_BATCH_SYMBOL][type]) {
+                target.addEventListener(type, listener, options);
+                target[EVENTS_BATCH_SYMBOL][type] = listener;
+            }
+        });
+    }
+    batchRemoveEventListener(type, listener, options) {
+        this.engine[DRIVER_INSTANCES_SYMBOL] =
+            this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+        this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+            const target = driver.eventTarget(type);
+            target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+            target.removeEventListener(type, listener, options);
+            delete target[EVENTS_BATCH_SYMBOL][type];
+        });
+    }
+}
+exports.EventDriver = EventDriver;
+/**
+ * 事件引擎
+ */
+class Event extends subscribable_1.Subscribable {
+    constructor(props) {
+        super();
+        this.drivers = [];
+        this.containers = [];
+        if ((0, types_1.isArr)(props === null || props === void 0 ? void 0 : props.effects)) {
+            props.effects.forEach((plugin) => {
+                plugin(this);
+            });
+        }
+        if ((0, types_1.isArr)(props === null || props === void 0 ? void 0 : props.drivers)) {
+            this.drivers = props.drivers;
+        }
+    }
+    subscribeTo(type, subscriber) {
+        return this.subscribe((event) => {
+            if (type && event instanceof type) {
+                return subscriber(event);
+            }
+        });
+    }
+    subscribeWith(type, subscriber) {
+        return this.subscribe((event) => {
+            if ((0, types_1.isArr)(type)) {
+                if (type.includes(event === null || event === void 0 ? void 0 : event.type)) {
+                    return subscriber(event);
+                }
+            }
+            else {
+                if (type && (event === null || event === void 0 ? void 0 : event.type) === type) {
+                    return subscriber(event);
+                }
+            }
+        });
+    }
+    attachEvents(container, contentWindow = globalThisPolyfill_1.globalThisPolyfill, context) {
+        if (!container)
+            return;
+        if ((0, types_1.isWindow)(container)) {
+            return this.attachEvents(container.document, container, context);
+        }
+        if (container[ATTACHED_SYMBOL])
+            return;
+        container[ATTACHED_SYMBOL] = this.drivers.map((EventDriver) => {
+            const driver = new EventDriver(this, context);
+            driver.contentWindow = contentWindow;
+            driver.container = container;
+            driver.attach(container);
+            return driver;
+        });
+        if (!this.containers.includes(container)) {
+            this.containers.push(container);
+        }
+    }
+    detachEvents(container) {
+        if (!container) {
+            this.containers.forEach((container) => {
+                this.detachEvents(container);
+            });
+            return;
+        }
+        if ((0, types_1.isWindow)(container)) {
+            return this.detachEvents(container.document);
+        }
+        if (!container[ATTACHED_SYMBOL])
+            return;
+        container[ATTACHED_SYMBOL].forEach((driver) => {
+            driver.detach(container);
+        });
+        this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL] || [];
+        this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL].reduce((drivers, driver) => {
+            if (driver.container === container) {
+                driver.detach(container);
+                return drivers;
+            }
+            return drivers.concat(driver);
+        }, []);
+        this.containers = this.containers.filter((item) => item !== container);
+        delete container[ATTACHED_SYMBOL];
+        delete container[EVENTS_SYMBOL];
+        delete container[EVENTS_ONCE_SYMBOL];
+        delete container[EVENTS_BATCH_SYMBOL];
+    }
+}
+exports.Event = Event;

package/lib/globalThisPolyfill.d.ts

@@ -0,0 +1 @@
+export declare const globalThisPolyfill: Window;

package/lib/globalThisPolyfill.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalThisPolyfill = void 0;
+function getGlobalThis() {
+    try {
+        if (typeof self !== 'undefined') {
+            return self;
+        }
+    }
+    catch (e) { }
+    try {
+        if (typeof exports.globalThisPolyfill !== 'undefined') {
+            return exports.globalThisPolyfill;
+        }
+    }
+    catch (e) { }
+    try {
+        if (typeof global !== 'undefined') {
+            return global;
+        }
+    }
+    catch (e) { }
+    return Function('return this')();
+}
+exports.globalThisPolyfill = getGlobalThis();

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './event';
+export * from './scroller';
+export * from './subscribable';
+export * from './coordinate';
+export * from './types';
+export * from './uid';
+export * from './clone';
+export * from './instanceof';
+export * from './lru';
+export * from './compose';
+export * from './array';
+export * from './keycode';
+export * from './animation';
+export * from './request-idle';
+export * from './element';
+export * from './globalThisPolyfill';
+export * from './observer';

package/lib/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./event"), exports);
+__exportStar(require("./scroller"), exports);
+__exportStar(require("./subscribable"), exports);
+__exportStar(require("./coordinate"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./uid"), exports);
+__exportStar(require("./clone"), exports);
+__exportStar(require("./instanceof"), exports);
+__exportStar(require("./lru"), exports);
+__exportStar(require("./compose"), exports);
+__exportStar(require("./array"), exports);
+__exportStar(require("./keycode"), exports);
+__exportStar(require("./animation"), exports);
+__exportStar(require("./request-idle"), exports);
+__exportStar(require("./element"), exports);
+__exportStar(require("./globalThisPolyfill"), exports);
+__exportStar(require("./observer"), exports);

package/lib/instanceof.d.ts

@@ -0,0 +1 @@
+export declare const instOf: (value: any, cls: any) => boolean;

package/lib/instanceof.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instOf = void 0;
+const types_1 = require("./types");
+const globalThisPolyfill_1 = require("./globalThisPolyfill");
+const instOf = (value, cls) => {
+    if ((0, types_1.isFn)(cls))
+        return value instanceof cls;
+    if ((0, types_1.isStr)(cls))
+        return globalThisPolyfill_1.globalThisPolyfill[cls]
+            ? value instanceof globalThisPolyfill_1.globalThisPolyfill[cls]
+            : false;
+    return false;
+};
+exports.instOf = instOf;

package/lib/keycode.d.ts

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