@dxyl/utils 1.0.0 → 1.1.0

package/types/data/signals.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @desc 信息
+ * @ref preact-signals
+
+*/
+declare const BRAND_SYMBOL: unique symbol;
+type Node = {
+    _source: Signal;
+    _prevSource?: Node;
+    _nextSource?: Node;
+    _target: Computed | Effect;
+    _prevTarget?: Node;
+    _nextTarget?: Node;
+    _version: number;
+    _rollbackNode?: Node;
+};
+/**
+ * Combine multiple value updates into one "commit" at the end of the provided callback.
+ *
+ * Batches can be nested and changes are only flushed once the outermost batch callback
+ * completes.
+ *
+ * Accessing a signal that has been modified within a batch will reflect its updated
+ * value.
+ *
+ * @param fn The callback function.
+ * @returns The value returned by the callback.
+ */
+declare function batch<T>(fn: () => T): T;
+/**
+ * Run a callback function that can access signal values without
+ * subscribing to the signal updates.
+ *
+ * @param fn The callback function.
+ * @returns The value returned by the callback.
+ */
+declare function untracked<T>(fn: () => T): T;
+/**
+ * The base class for plain and computed signals.
+ */
+declare class Signal<T = any> {
+    /** @internal */
+    _value: unknown;
+    /**
+     * @internal
+     * Version numbers should always be >= 0, because the special value -1 is used
+     * by Nodes to signify potentially unused but recyclable nodes.
+     */
+    _version: number;
+    /** @internal */
+    _node?: Node;
+    /** @internal */
+    _targets?: Node;
+    constructor(value?: T);
+    /** @internal */
+    _refresh(): boolean;
+    /** @internal */
+    _subscribe(node: Node): void;
+    /** @internal */
+    _unsubscribe(node: Node): void;
+    subscribe(fn: (value: T) => void): () => void;
+    valueOf(): T;
+    toString(): string;
+    toJSON(): T;
+    peek(): T;
+    brand: typeof BRAND_SYMBOL;
+    get value(): T;
+    set value(value: T);
+}
+/** @internal */
+declare function Signal(this: Signal, value?: unknown): void;
+/**
+ * Create a new plain signal.
+ *
+ * @param value The initial value for the signal.
+ * @returns A new signal.
+ */
+export declare function signal<T>(value: T): Signal<T>;
+export declare function signal<T = undefined>(): Signal<T | undefined>;
+declare class Computed<T = any> extends Signal<T> {
+    _fn: () => T;
+    _sources?: Node;
+    _globalVersion: number;
+    _flags: number;
+    constructor(fn: () => T);
+    _notify(): void;
+    get value(): T;
+}
+declare function Computed(this: Computed, fn: () => unknown): void;
+declare namespace Computed {
+    var prototype: Computed<any>;
+}
+/**
+ * An interface for read-only signals.
+ */
+interface ReadonlySignal<T = any> {
+    readonly value: T;
+    peek(): T;
+    subscribe(fn: (value: T) => void): () => void;
+    valueOf(): T;
+    toString(): string;
+    toJSON(): T;
+    brand: typeof BRAND_SYMBOL;
+}
+/**
+ * Create a new signal that is computed based on the values of other signals.
+ *
+ * The returned computed signal is read-only, and its value is automatically
+ * updated when any signals accessed from within the callback function change.
+ *
+ * @param fn The effect callback.
+ * @returns A new read-only signal.
+ */
+declare function computed<T>(fn: () => T): ReadonlySignal<T>;
+type EffectFn = () => void | (() => void);
+declare class Effect {
+    _fn?: EffectFn;
+    _cleanup?: () => void;
+    _sources?: Node;
+    _nextBatchedEffect?: Effect;
+    _flags: number;
+    constructor(fn: EffectFn);
+    _callback(): void;
+    _start(): () => void;
+    _notify(): void;
+    _dispose(): void;
+}
+declare function Effect(this: Effect, fn: EffectFn): void;
+/**
+ * Create an effect to run arbitrary code in response to signal changes.
+ *
+ * An effect tracks which signals are accessed within the given callback
+ * function `fn`, and re-runs the callback when those signals change.
+ *
+ * The callback may return a cleanup function. The cleanup function gets
+ * run once, either when the callback is next called or when the effect
+ * gets disposed, whichever happens first.
+ *
+ * @param fn The effect callback.
+ * @returns A function for disposing the effect.
+ */
+declare function effect(fn: EffectFn): () => void;
+export { computed, effect, batch, untracked, Signal };
+export type { ReadonlySignal };

package/types/deepmerge.d.ts

@@ -0,0 +1,16 @@
+export interface Options {
+    arrayMerge?(target: any[], source: any[], options?: ArrayMergeOptions): any[];
+    clone?: boolean;
+    customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | undefined;
+    isMergeableObject?(value: object): boolean;
+}
+export interface ArrayMergeOptions {
+    isMergeableObject(value: object): boolean;
+    cloneUnlessOtherwiseSpecified(value: object, options?: Options): object;
+}
+declare function deepmerge<T>(target: Partial<T>, source: Partial<T>, options?: Options): T;
+declare namespace deepmerge {
+    var all: typeof deepmergeAll;
+}
+declare function deepmergeAll(objects: object[], options?: Options): object;
+export default deepmerge;

package/types/events/eventTarget.d.ts

@@ -0,0 +1,93 @@
+export interface EventListener<T = any> {
+    (evt: Event<T>): void;
+}
+interface EventListenerObject<T = any> {
+    handleEvent(object: Event<T>): void;
+}
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+interface EventListenerOptions {
+    capture?: boolean;
+}
+type EventListenerOrEventListenerObject<T = any> = EventListener<T> | EventListenerObject<T>;
+interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+export declare class Event<T = any> {
+    readonly NONE = 0;
+    readonly CAPTURING_PHASE = 1;
+    readonly AT_TARGET = 2;
+    readonly BUBBLING_PHASE = 3;
+    data: T | null;
+    /** 事件类型 */
+    type: string;
+    /** 事件是否冒泡 */
+    bubbles: boolean;
+    /** 阻止事件冒泡的标志 */
+    cancelBubble: boolean;
+    /** 事件是否可以取消 */
+    cancelable: boolean;
+    /** 事件是否支持跨文档冒泡 */
+    composed: boolean;
+    /** 事件是否被默认行为阻止 */
+    defaultPrevented: boolean;
+    /** 事件是否由用户操作生成 */
+    isTrusted: boolean;
+    /** 事件的目标对象 */
+    target: EventTarget | null;
+    /** 当前正在处理事件的对象 */
+    currentTarget: EventTarget | null;
+    /** 事件阶段 */
+    eventPhase: number;
+    /** 事件的时间戳 */
+    timeStamp: number;
+    /**
+     * 标记事件是否应该立即停止传播
+     */
+    stopImmediatePropagationInternal: boolean;
+    /**
+     * 构造函数
+     * @param type 事件类型
+     * @param eventInitDict 可选的事件初始化字典
+     */
+    constructor(type: string, eventInitDict?: EventInit);
+    setData(data: T): this;
+    /**
+      * 初始化事件对象的属性
+      * @param type 事件类型
+      * @param bubbles 是否冒泡
+      * @param cancelable 是否可以取消
+      */
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    /**
+     * 阻止事件冒泡
+     */
+    stopPropagation(): void;
+    /**
+     * 阻止事件的默认行为
+     */
+    preventDefault(): void;
+    /**
+     * 阻止事件冒泡并停止调用事件监听器
+     */
+    stopImmediatePropagation(): void;
+    /**
+     * 返回事件的目标对象及其祖先对象的路径
+     * @returns 事件路径的数组
+     */
+    composedPath(): EventTarget[];
+}
+export declare class EventTarget<Events extends Record<string, any> = any> {
+    private listeners;
+    parentNode: EventTarget | null;
+    constructor();
+    addEventListener<E extends keyof Events>(type: E, callback: EventListenerOrEventListenerObject<Events[E]>, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent<E extends keyof Events>(event: Event<Events[E]>): boolean;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+export {};

package/types/events/event_emiter.d.ts

@@ -0,0 +1,43 @@
+type EventData = {
+    [Key: string]: any;
+};
+type ListenerFunc<D extends EventData> = (e: EmitterEvent<D>) => void;
+type ListenerObject<D extends EventData> = {
+    handleEvent(e: EmitterEvent<D>): void;
+};
+type ListenerFuncOrObject<D extends EventData> = ListenerFunc<D> | ListenerObject<D>;
+type ListenerData<D extends EventData> = {
+    once: boolean;
+    listener: ListenerFuncOrObject<D>;
+};
+export declare class EmitterEvent<Data extends EventData> {
+    static NONE: number;
+    static AT_TARGET: number;
+    static BUBBLING_PHASE: number;
+    static new(type: string, data: any): EmitterEvent<any>;
+    type: string;
+    eventPhase: number;
+    data: Data;
+    target: EventEmitter<any> | null;
+    currentTarget: EventEmitter<any> | null;
+    composedPath: EventEmitter<any>[];
+    bubbles: boolean;
+    propagationStopped: boolean;
+    immediatePropagationStopped: boolean;
+    constructor(type: string, data: Data);
+    reset(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+declare const isEventEmitter_Property: unique symbol;
+export declare class EventEmitter<EventListeners extends Record<string, EventData> = {}> {
+    static createEvent(type: string, data: any): EmitterEvent<any>;
+    [isEventEmitter_Property]: boolean;
+    parent?: EventEmitter;
+    listeners: Map<string, ListenerData<EventData>[]>;
+    hasEvent(type: string): boolean;
+    on<Type extends Extract<keyof EventListeners, string>>(type: Type, listener: ListenerFuncOrObject<EventListeners[Type]>, once?: boolean): boolean;
+    off<Type extends Extract<keyof EventListeners, string>>(type?: Type, listener?: ListenerFuncOrObject<EventListeners[Type]>): boolean;
+    emit(event: EmitterEvent<EventListeners[keyof EventListeners]>): void;
+}
+export {};

package/types/events/eventemitter3.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ */
+declare class EventEmitter<
+  EventTypes extends EventEmitter.ValidEventTypes = string | symbol,
+  Context extends any = any
+> {
+  static prefixed: string | boolean;
+
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   */
+  eventNames(): Array<EventEmitter.EventNames<EventTypes>>;
+
+  /**
+   * Return the listeners registered for a given event.
+   */
+  listeners<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T
+  ): Array<EventEmitter.EventListener<EventTypes, T>>;
+
+  /**
+   * Return the number of listeners listening to a given event.
+   */
+  listenerCount(event: EventEmitter.EventNames<EventTypes>): number;
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   */
+  emit<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    ...args: EventEmitter.EventArgs<EventTypes, T>
+  ): boolean;
+
+  /**
+   * Add a listener for a given event.
+   */
+  on<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    fn: EventEmitter.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+  addListener<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    fn: EventEmitter.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+
+  /**
+   * Add a one-time listener for a given event.
+   */
+  once<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    fn: EventEmitter.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+
+  /**
+   * Remove the listeners of a given event.
+   */
+  removeListener<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    fn?: EventEmitter.EventListener<EventTypes, T>,
+    context?: Context,
+    once?: boolean
+  ): this;
+  off<T extends EventEmitter.EventNames<EventTypes>>(
+    event: T,
+    fn?: EventEmitter.EventListener<EventTypes, T>,
+    context?: Context,
+    once?: boolean
+  ): this;
+
+  /**
+   * Remove all listeners, or those of the specified event.
+   */
+  removeAllListeners(event?: EventEmitter.EventNames<EventTypes>): this;
+}
+
+declare namespace EventEmitter {
+  export interface ListenerFn<Args extends any[] = any[]> {
+    (...args: Args): void;
+  }
+
+  export interface EventEmitterStatic {
+    new <
+      EventTypes extends ValidEventTypes = string | symbol,
+      Context = any
+    >(): EventEmitter<EventTypes, Context>;
+  }
+
+  /**
+   * `object` should be in either of the following forms:
+   * ```
+   * interface EventTypes {
+   *   'event-with-parameters': any[]
+   *   'event-with-example-handler': (...args: any[]) => void
+   * }
+   * ```
+   */
+  export type ValidEventTypes = string | symbol | object;
+
+  export type EventNames<T extends ValidEventTypes> = T extends string | symbol
+    ? T
+    : keyof T;
+
+  export type ArgumentMap<T extends object> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => void
+      ? Parameters<T[K]>
+      : T[K] extends any[]
+      ? T[K]
+      : any[];
+  };
+
+  export type EventListener<
+    T extends ValidEventTypes,
+    K extends EventNames<T>
+  > = T extends string | symbol
+    ? (...args: any[]) => void
+    : (
+        ...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]
+      ) => void;
+
+  export type EventArgs<
+    T extends ValidEventTypes,
+    K extends EventNames<T>
+  > = Parameters<EventListener<T, K>>;
+
+  export const EventEmitter: EventEmitterStatic;
+}
+
+export { EventEmitter }
+export default EventEmitter;

package/types/events/mitt.d.ts

@@ -0,0 +1,21 @@
+export type EventType = string | symbol;
+export type Handler<T = unknown> = (event: T) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+export interface Emitter<Events extends Record<EventType, unknown>> {
+    all: EventHandlerMap<Events>;
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export default function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;

package/types/fast-deep-equal.d.ts

@@ -0,0 +1 @@
+export default function equal(a: any, b: any): boolean;

package/types/index.d.ts

@@ -0,0 +1,20 @@
+export * from './events/eventTarget';
+export * from './events/eventemitter3';
+export * from './events/mitt';
+export * from './callbacks';
+export * from './ismobilejs';
+export * from './priority_queue';
+export * from './stats.module';
+export * from './parse-svg-path';
+export * as radash from './radash';
+export * as lodash from './lodash';
+export * as antvUtil from './antv-util';
+export * as immer from './data/immer';
+export * as Immutable from './data/immutable';
+export * as reactivity from './data/reactivity';
+export * as signals from './data/signals';
+export { Options } from './Options';
+export type { OptionsProperties, OptionConfig } from './Options';
+export { default as deepmerge } from './deepmerge';
+export { default as fastDeepEqual } from './fast-deep-equal';
+export * from './Color';

package/types/ismobilejs.d.ts

@@ -0,0 +1,46 @@
+declare global {
+    const MSStream: any;
+}
+export type UserAgent = string;
+export type Navigator = {
+    userAgent: string;
+    platform: string;
+    maxTouchPoints?: number;
+};
+export type isMobileResult = {
+    apple: {
+        phone: boolean;
+        ipod: boolean;
+        tablet: boolean;
+        universal: boolean;
+        device: boolean;
+    };
+    amazon: {
+        phone: boolean;
+        tablet: boolean;
+        device: boolean;
+    };
+    android: {
+        phone: boolean;
+        tablet: boolean;
+        device: boolean;
+    };
+    windows: {
+        phone: boolean;
+        tablet: boolean;
+        device: boolean;
+    };
+    other: {
+        blackberry: boolean;
+        blackberry10: boolean;
+        opera: boolean;
+        firefox: boolean;
+        chrome: boolean;
+        device: boolean;
+    };
+    phone: boolean;
+    tablet: boolean;
+    any: boolean;
+};
+export type IsMobileParameter = UserAgent | Navigator;
+export default function isMobile(param?: IsMobileParameter): isMobileResult;

package/types/lodash/augment.d.ts

@@ -0,0 +1,2 @@
+declare const augment: (...args: any[]) => void;
+export default augment;

package/types/lodash/cache.d.ts

@@ -0,0 +1,14 @@
+/**
+ * k-v 存储
+ */
+export default class<T> {
+    map: {
+        [key: string]: T;
+    };
+    has(key: string): boolean;
+    get(key: string, def?: T): T | undefined;
+    set(key: string, value: T): void;
+    clear(): void;
+    delete(key: string): void;
+    size(): number;
+}

package/types/lodash/clamp.d.ts

@@ -0,0 +1,2 @@
+declare const clamp: (a: number, min: number, max: number) => number;
+export default clamp;

package/types/lodash/clear-animation-frame.d.ts

@@ -0,0 +1 @@
+export default function cancelAnimationFrame(handler: number): void;

package/types/lodash/clone.d.ts

@@ -0,0 +1,2 @@
+declare const clone: (obj: any) => any;
+export default clone;

package/types/lodash/contains.d.ts

@@ -0,0 +1,2 @@
+declare const contains: (arr: any[], value: any) => boolean;
+export default contains;

package/types/lodash/debounce.d.ts

@@ -0,0 +1,2 @@
+declare function debounce(func: Function, wait?: number, immediate?: boolean): () => void;
+export default debounce;

package/types/lodash/deep-mix.d.ts

@@ -0,0 +1,2 @@
+declare const deepMix: (rst: any, ...args: any[]) => any;
+export default deepMix;

package/types/lodash/difference.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @param {Array} arr The array to inspect.
+ * @param {Array} values The values to exclude.
+ * @return {Array} Returns the new array of filtered values.
+ * @example
+ * difference([2, 1], [2, 3]);  // => [1]
+ */
+declare const difference: <T>(arr: T[], values?: T[]) => T[];
+export default difference;

package/types/lodash/each.d.ts

@@ -0,0 +1,2 @@
+declare function each(elements: any[] | object, func: (v: any, k: any) => any): void;
+export default each;

package/types/lodash/ends-with.d.ts

@@ -0,0 +1,3 @@
+declare function endsWith(arr: string, e: string): boolean;
+declare function endsWith<T>(arr: T[], e: T): boolean;
+export default endsWith;

package/types/lodash/every.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 只要有一个不满足条件就返回 false
+ * @param arr
+ * @param func
+ */
+declare const every: <T>(arr: T[], func: (v: T, idx?: number) => any) => boolean;
+export default every;

package/types/lodash/extend.d.ts

@@ -0,0 +1,2 @@
+declare const extend: (subclass: any, superclass: any, overrides?: any, staticOverrides?: any) => any;
+export default extend;

package/types/lodash/filter.d.ts

@@ -0,0 +1,2 @@
+declare const filter: <T>(arr: T[], func: (v: T, idx: number) => boolean) => T[];
+export default filter;

package/types/lodash/find-index.d.ts

@@ -0,0 +1,2 @@
+declare function findIndex<T>(arr: T[], predicate: (item: T, idx?: number) => boolean, fromIndex?: number): number;
+export default findIndex;

package/types/lodash/find.d.ts

@@ -0,0 +1,3 @@
+declare function find<T>(arr: T[], predicate: Function): T;
+declare function find<T>(arr: T[], predicate: object): T;
+export default find;

package/types/lodash/first-value.d.ts

@@ -0,0 +1,2 @@
+declare const firstValue: (data: object[], name: string) => any;
+export default firstValue;

package/types/lodash/fixed-base.d.ts

@@ -0,0 +1,2 @@
+declare const fixedBase: (v: number, base: number | string) => number;
+export default fixedBase;

package/types/lodash/flatten-deep.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @param {Array} arr The array to flatten.
+ * @param {Array} result The array to return.
+ * @return {Array} Returns the new flattened array.
+ * @example
+ *
+ * flattenDeep([1, [2, [3, [4]], 5]]);  // => [1, 2, 3, 4, 5]
+ */
+declare const flattenDeep: (arr: any[], result?: any[]) => any[];
+export default flattenDeep;

package/types/lodash/flatten.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @param {Array} arr The array to flatten.
+ * @return {Array} Returns the new flattened array.
+ * @example
+ *
+ * flatten([1, [2, [3, [4]], 5]]);  // => [1, 2, [3, [4]], 5]
+ */
+declare const flatten: <T>(arr: T[]) => T[];
+export default flatten;

package/types/lodash/for-in.d.ts

@@ -0,0 +1,2 @@
+import { default as each } from './each';
+export default each;

package/types/lodash/get-range.d.ts

@@ -0,0 +1,6 @@
+export interface RangeType {
+    readonly min: number;
+    readonly max: number;
+}
+declare const getRange: (values: number[]) => RangeType;
+export default getRange;

package/types/lodash/get-type.d.ts

@@ -0,0 +1,2 @@
+declare const getType: (value: any) => string;
+export default getType;