@ant-design/pro-components 2.8.9 → 3.0.0-beta.1

package/es/utils/hooks/useDebounceValue/index.js

@@ -0,0 +1,21 @@
+// src/utils/hooks/useDebounceValue/index.ts
+import { useEffect, useState } from "react";
+import { useLatest } from "../useLatest";
+function useDebounceValue(value, delay = 100, deps) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  const valueRef = useLatest(value);
+  useEffect(
+    () => {
+      const handler = setTimeout(() => {
+        setDebouncedValue(valueRef.current);
+      }, delay);
+      return () => clearTimeout(handler);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    deps ? [delay, ...deps] : void 0
+  );
+  return debouncedValue;
+}
+export {
+  useDebounceValue
+};

package/es/utils/hooks/useDeepCompareEffect/index.d.ts

@@ -0,0 +1,5 @@
+import type { DependencyList } from 'react';
+export declare const isDeepEqual: (a: any, b: any, ignoreKeys?: string[]) => boolean;
+export declare function useDeepCompareMemoize(value: any, ignoreKeys?: any): undefined;
+export declare function useDeepCompareEffect(effect: React.EffectCallback, dependencies: DependencyList, ignoreKeys?: string[]): void;
+export declare function useDeepCompareEffectDebounce(effect: React.EffectCallback, dependencies: DependencyList, ignoreKeys?: string[], waitTime?: number): void;

package/es/utils/hooks/useDeepCompareEffect/index.js

@@ -0,0 +1,53 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/utils/hooks/useDeepCompareEffect/index.ts
+import { useEffect, useRef } from "react";
+import { isDeepEqualReact } from "../../isDeepEqualReact";
+import { useDebounceFn } from "../useDebounceFn";
+var isDeepEqual = (a, b, ignoreKeys) => isDeepEqualReact(a, b, ignoreKeys);
+function useDeepCompareMemoize(value, ignoreKeys) {
+  const ref = useRef();
+  if (!isDeepEqual(value, ref.current, ignoreKeys)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+function useDeepCompareEffect(effect, dependencies, ignoreKeys) {
+  useEffect(effect, useDeepCompareMemoize(dependencies || [], ignoreKeys));
+}
+function useDeepCompareEffectDebounce(effect, dependencies, ignoreKeys, waitTime) {
+  const effectDn = useDebounceFn(() => __async(this, null, function* () {
+    effect();
+  }), waitTime || 16);
+  useEffect(
+    () => {
+      effectDn.run();
+    },
+    useDeepCompareMemoize(dependencies || [], ignoreKeys)
+  );
+}
+export {
+  isDeepEqual,
+  useDeepCompareEffect,
+  useDeepCompareEffectDebounce,
+  useDeepCompareMemoize
+};

package/es/utils/hooks/useDeepCompareMemo/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * `useDeepCompareMemo` will only recompute the memoized value when one of the
+ * `deps` has changed.
+ *
+ * Usage note: only use this if `deps` are objects or arrays that contain
+ * objects. Otherwise you should just use React.useMemo.
+ *
+ */
+declare function useDeepCompareMemo<T>(factory: () => T, dependencies: React.DependencyList): T;
+export default useDeepCompareMemo;

package/es/utils/hooks/useDeepCompareMemo/index.js

@@ -0,0 +1,13 @@
+// src/utils/hooks/useDeepCompareMemo/index.ts
+import React from "react";
+import { useDeepCompareMemoize } from "../useDeepCompareEffect";
+function useDeepCompareMemo(factory, dependencies) {
+  return React.useMemo(
+    factory,
+    useDeepCompareMemoize(dependencies)
+  );
+}
+var useDeepCompareMemo_default = useDeepCompareMemo;
+export {
+  useDeepCompareMemo_default as default
+};

package/es/utils/hooks/useDocumentTitle/index.d.ts

@@ -0,0 +1,5 @@
+export declare function useDocumentTitle(titleInfo: {
+    title: string;
+    id: string;
+    pageName: string;
+}, appDefaultTitle: string | false): void;

package/es/utils/hooks/useDocumentTitle/index.js

@@ -0,0 +1,14 @@
+// src/utils/hooks/useDocumentTitle/index.ts
+import { useEffect } from "react";
+import { isBrowser } from "../../isBrowser";
+function useDocumentTitle(titleInfo, appDefaultTitle) {
+  const titleText = typeof titleInfo.pageName === "string" ? titleInfo.title : appDefaultTitle;
+  useEffect(() => {
+    if (isBrowser() && titleText) {
+      document.title = titleText;
+    }
+  }, [titleInfo.title, titleText]);
+}
+export {
+  useDocumentTitle
+};

package/es/utils/hooks/useFetchData/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export type ProRequestData<T, U = Record<string, any>> = (params: U, props: any) => Promise<T>;
+export declare function useFetchData<T, U = Record<string, any>>(props: {
+    proFieldKey?: React.Key;
+    params?: U;
+    request?: ProRequestData<T, U>;
+}): [T | undefined, boolean];

package/es/utils/hooks/useFetchData/index.js

@@ -0,0 +1,71 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/utils/hooks/useFetchData/index.tsx
+import { useRef, useState } from "react";
+import useSWR from "swr";
+var testId = 0;
+function useFetchData(props) {
+  const abortRef = useRef(null);
+  const [cacheKey] = useState(() => {
+    if (props.proFieldKey) {
+      return props.proFieldKey.toString();
+    }
+    testId += 1;
+    return testId.toString();
+  });
+  const proFieldKeyRef = useRef(cacheKey);
+  const fetchData = () => __async(this, null, function* () {
+    var _a;
+    (_a = abortRef.current) == null ? void 0 : _a.abort();
+    const abort = new AbortController();
+    abortRef.current = abort;
+    try {
+      if (!props.request) {
+        return void 0;
+      }
+      const response = yield props.request(props.params, abort.signal);
+      return response;
+    } catch (error2) {
+      if (error2.name === "AbortError") {
+        return void 0;
+      }
+      throw error2;
+    }
+  });
+  const { data, error, isValidating } = useSWR(
+    props.request ? [cacheKey, props.params] : null,
+    fetchData,
+    {
+      revalidateOnFocus: false,
+      shouldRetryOnError: false,
+      onError: () => {
+      }
+    }
+  );
+  if (!props.request) {
+    return [void 0, false];
+  }
+  return [data, isValidating];
+}
+export {
+  useFetchData
+};

package/es/utils/hooks/useForceRender/index.d.ts

@@ -0,0 +1 @@
+export default function useForceRender(): () => void;

package/es/utils/hooks/useForceRender/index.js

@@ -0,0 +1,10 @@
+// src/utils/hooks/useForceRender/index.ts
+import { useCallback, useState } from "react";
+function useForceRender() {
+  const [, setValue] = useState(true);
+  const updateValue = useCallback(() => setValue((oldValue) => !oldValue), []);
+  return updateValue;
+}
+export {
+  useForceRender as default
+};

package/es/utils/hooks/useLatest/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://github.com/streamich/react-use/blob/master/docs/useLatest.md
+ */
+export declare const useLatest: <T>(value: T) => {
+    readonly current: T;
+};

package/es/utils/hooks/useLatest/index.js

@@ -0,0 +1,10 @@
+// src/utils/hooks/useLatest/index.ts
+import { useRef } from "react";
+var useLatest = (value) => {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+};
+export {
+  useLatest
+};

package/es/utils/hooks/usePrevious/index.d.ts

@@ -0,0 +1 @@
+export declare const usePrevious: <T>(state: T) => T | undefined;

package/es/utils/hooks/usePrevious/index.js

@@ -0,0 +1,12 @@
+// src/utils/hooks/usePrevious/index.ts
+import { useEffect, useRef } from "react";
+var usePrevious = (state) => {
+  const ref = useRef();
+  useEffect(() => {
+    ref.current = state;
+  });
+  return ref.current;
+};
+export {
+  usePrevious
+};

package/es/utils/hooks/useReactiveRef/index.d.ts

@@ -0,0 +1,4 @@
+import type { MutableRefObject, RefObject } from 'react';
+export declare function useReactiveRef<T>(initialValue: T): MutableRefObject<T>;
+export declare function useReactiveRef<T>(initialValue: T | null): RefObject<T>;
+export declare function useReactiveRef<T = undefined>(): MutableRefObject<T | undefined>;

package/es/utils/hooks/useReactiveRef/index.js

@@ -0,0 +1,11 @@
+// src/utils/hooks/useReactiveRef/index.ts
+import useForceRender from "../useForceRender";
+import { useRefCallback } from "../useRefCallback";
+function useReactiveRef(initialValue) {
+  const forceRender = useForceRender();
+  const ref = useRefCallback(forceRender, initialValue);
+  return ref;
+}
+export {
+  useReactiveRef
+};

package/es/utils/hooks/useRefCallback/index.d.ts

@@ -0,0 +1,6 @@
+import type { MutableRefObject, RefObject } from 'react';
+type Callback<T> = (currentRef: T) => void;
+export declare function useRefCallback<T>(callback: Callback<MutableRefObject<T>>, initialValue: T): MutableRefObject<T>;
+export declare function useRefCallback<T>(callback: Callback<RefObject<T>>, initialValue: T | null): RefObject<T>;
+export declare function useRefCallback<T = undefined>(callback: Callback<MutableRefObject<T | undefined>>): MutableRefObject<T | undefined>;
+export {};

package/es/utils/hooks/useRefCallback/index.js

@@ -0,0 +1,22 @@
+// src/utils/hooks/useRefCallback/index.ts
+import { useMemo } from "react";
+function useRefCallback(callback, initialValue) {
+  const ref = useMemo(() => {
+    const defaultValue = {
+      current: initialValue
+    };
+    return new Proxy(defaultValue, {
+      set(target, prop, newValue) {
+        if (!Object.is(target[prop], newValue)) {
+          target[prop] = newValue;
+          callback(ref);
+        }
+        return true;
+      }
+    });
+  }, []);
+  return ref;
+}
+export {
+  useRefCallback
+};

package/es/utils/hooks/useRefFunction/index.d.ts

@@ -0,0 +1,2 @@
+declare const useRefFunction: <T extends (...args: any) => any>(reFunction: T) => (...rest: Parameters<T>) => ReturnType<T>;
+export { useRefFunction };

package/es/utils/hooks/useRefFunction/index.js

@@ -0,0 +1,13 @@
+// src/utils/hooks/useRefFunction/index.ts
+import { useCallback, useRef } from "react";
+var useRefFunction = (reFunction) => {
+  const ref = useRef(null);
+  ref.current = reFunction;
+  return useCallback((...rest) => {
+    var _a;
+    return (_a = ref.current) == null ? void 0 : _a.call(ref, ...rest);
+  }, []);
+};
+export {
+  useRefFunction
+};

package/es/utils/index.d.ts

@@ -0,0 +1,54 @@
+import { lighten, operationUnit, resetComponent, setAlpha, useStyle } from '../provider';
+import { compareVersions } from './compareVersions';
+import { coverToNewToken } from './compareVersions/coverToNewToken';
+import { DropdownFooter } from './components/DropdownFooter';
+import { ErrorBoundary } from './components/ErrorBoundary';
+import { FieldLabel } from './components/FieldLabel';
+import { FilterDropdown } from './components/FilterDropdown';
+import { InlineErrorFormItem } from './components/InlineErrorFormItem';
+import { LabelIconTip } from './components/LabelIconTip';
+import type { ProFormInstanceType } from './components/ProFormContext';
+import { ProFormContext } from './components/ProFormContext';
+import { conversionMomentValue, convertMoment, dateFormatterMap } from './conversionMomentValue';
+import { dateArrayFormatter } from './dateArrayFormatter';
+import { genCopyable } from './genCopyable';
+import { getFieldPropsOrFormItemProps } from './getFieldPropsOrFormItemProps';
+import { useDebounceFn } from './hooks/useDebounceFn';
+import { useDebounceValue } from './hooks/useDebounceValue';
+import { useDeepCompareEffect, useDeepCompareEffectDebounce } from './hooks/useDeepCompareEffect';
+import useDeepCompareMemo from './hooks/useDeepCompareMemo';
+import { useDocumentTitle } from './hooks/useDocumentTitle';
+import type { ProRequestData } from './hooks/useFetchData';
+import { useFetchData } from './hooks/useFetchData';
+import { useLatest } from './hooks/useLatest';
+import { usePrevious } from './hooks/usePrevious';
+import { useReactiveRef } from './hooks/useReactiveRef';
+import { useRefCallback } from './hooks/useRefCallback';
+import { useRefFunction } from './hooks/useRefFunction';
+import { isBrowser } from './isBrowser';
+import { isDeepEqualReact } from './isDeepEqualReact';
+import { isDropdownValueType } from './isDropdownValueType';
+import { isImg } from './isImg';
+import { isNil } from './isNil';
+import { isUrl } from './isUrl';
+import { merge } from './merge';
+import { nanoid } from './nanoid';
+import { omitBoolean } from './omitBoolean';
+import { omitUndefined } from './omitUndefined';
+import { omitUndefinedAndEmptyArr } from './omitUndefinedAndEmptyArr';
+import { parseValueToDay } from './parseValueToMoment';
+import { pickProFormItemProps } from './pickProFormItemProps';
+import { pickProProps } from './pickProProps';
+import { objectToMap, proFieldParsingText } from './proFieldParsingText';
+import { runFunction } from './runFunction';
+import stringify from './stringify';
+import { transformKeySubmitValue } from './transformKeySubmitValue';
+import type { RowEditableConfig, RowEditableType, UseEditableType, UseEditableUtilType } from './useEditableArray';
+import { editableRowByKey, recordKeyToString, useEditableArray } from './useEditableArray';
+import type { UseEditableMapType, UseEditableMapUtilType } from './useEditableMap';
+import { useEditableMap } from './useEditableMap';
+import { useBreakpoint } from './useMediaQuery';
+import { useMountMergeState } from './useMountMergeState';
+export * from './typing';
+export { compareVersions, conversionMomentValue, conversionMomentValue as conversionSubmitValue, convertMoment, coverToNewToken, dateArrayFormatter, dateFormatterMap, DropdownFooter, editableRowByKey, ErrorBoundary, FieldLabel, FilterDropdown, genCopyable, getFieldPropsOrFormItemProps, InlineErrorFormItem, isBrowser, isDeepEqualReact, isDropdownValueType, isImg, isNil, isUrl, LabelIconTip, lighten, merge, nanoid, objectToMap, omitBoolean, omitUndefined, omitUndefinedAndEmptyArr, operationUnit, parseValueToDay, pickProFormItemProps, pickProProps, proFieldParsingText, ProFormContext, recordKeyToString, resetComponent, runFunction, setAlpha, stringify, transformKeySubmitValue, useBreakpoint, useDebounceFn, useDebounceValue, useDeepCompareEffect, useDeepCompareEffectDebounce, useDeepCompareMemo, useDocumentTitle, useEditableArray, useEditableMap, useFetchData, useLatest, useMountMergeState, usePrevious, useReactiveRef, useRefCallback, useRefFunction, useStyle, };
+export type { ProFormInstanceType, ProRequestData, RowEditableConfig, RowEditableType, UseEditableMapType, UseEditableMapUtilType, UseEditableType, UseEditableUtilType, };

package/es/utils/index.js

@@ -0,0 +1,126 @@
+// src/utils/index.tsx
+import {
+  lighten,
+  operationUnit,
+  resetComponent,
+  setAlpha,
+  useStyle
+} from "../provider";
+import { compareVersions } from "./compareVersions";
+import { coverToNewToken } from "./compareVersions/coverToNewToken";
+import { DropdownFooter } from "./components/DropdownFooter";
+import { ErrorBoundary } from "./components/ErrorBoundary";
+import { FieldLabel } from "./components/FieldLabel";
+import { FilterDropdown } from "./components/FilterDropdown";
+import { InlineErrorFormItem } from "./components/InlineErrorFormItem";
+import { LabelIconTip } from "./components/LabelIconTip";
+import { ProFormContext } from "./components/ProFormContext";
+import {
+  conversionMomentValue,
+  convertMoment,
+  dateFormatterMap
+} from "./conversionMomentValue";
+import { dateArrayFormatter } from "./dateArrayFormatter";
+import { genCopyable } from "./genCopyable";
+import { getFieldPropsOrFormItemProps } from "./getFieldPropsOrFormItemProps";
+import { useDebounceFn } from "./hooks/useDebounceFn";
+import { useDebounceValue } from "./hooks/useDebounceValue";
+import {
+  useDeepCompareEffect,
+  useDeepCompareEffectDebounce
+} from "./hooks/useDeepCompareEffect";
+import useDeepCompareMemo from "./hooks/useDeepCompareMemo";
+import { useDocumentTitle } from "./hooks/useDocumentTitle";
+import { useFetchData } from "./hooks/useFetchData";
+import { useLatest } from "./hooks/useLatest";
+import { usePrevious } from "./hooks/usePrevious";
+import { useReactiveRef } from "./hooks/useReactiveRef";
+import { useRefCallback } from "./hooks/useRefCallback";
+import { useRefFunction } from "./hooks/useRefFunction";
+import { isBrowser } from "./isBrowser";
+import { isDeepEqualReact } from "./isDeepEqualReact";
+import { isDropdownValueType } from "./isDropdownValueType";
+import { isImg } from "./isImg";
+import { isNil } from "./isNil";
+import { isUrl } from "./isUrl";
+import { merge } from "./merge";
+import { nanoid } from "./nanoid";
+import { omitBoolean } from "./omitBoolean";
+import { omitUndefined } from "./omitUndefined";
+import { omitUndefinedAndEmptyArr } from "./omitUndefinedAndEmptyArr";
+import { parseValueToDay } from "./parseValueToMoment";
+import { pickProFormItemProps } from "./pickProFormItemProps";
+import { pickProProps } from "./pickProProps";
+import { objectToMap, proFieldParsingText } from "./proFieldParsingText";
+import { runFunction } from "./runFunction";
+import stringify from "./stringify";
+import { transformKeySubmitValue } from "./transformKeySubmitValue";
+import {
+  editableRowByKey,
+  recordKeyToString,
+  useEditableArray
+} from "./useEditableArray";
+import { useEditableMap } from "./useEditableMap";
+import { useBreakpoint } from "./useMediaQuery";
+import { useMountMergeState } from "./useMountMergeState";
+export * from "./typing";
+export {
+  DropdownFooter,
+  ErrorBoundary,
+  FieldLabel,
+  FilterDropdown,
+  InlineErrorFormItem,
+  LabelIconTip,
+  ProFormContext,
+  compareVersions,
+  conversionMomentValue,
+  conversionMomentValue as conversionSubmitValue,
+  convertMoment,
+  coverToNewToken,
+  dateArrayFormatter,
+  dateFormatterMap,
+  editableRowByKey,
+  genCopyable,
+  getFieldPropsOrFormItemProps,
+  isBrowser,
+  isDeepEqualReact,
+  isDropdownValueType,
+  isImg,
+  isNil,
+  isUrl,
+  lighten,
+  merge,
+  nanoid,
+  objectToMap,
+  omitBoolean,
+  omitUndefined,
+  omitUndefinedAndEmptyArr,
+  operationUnit,
+  parseValueToDay,
+  pickProFormItemProps,
+  pickProProps,
+  proFieldParsingText,
+  recordKeyToString,
+  resetComponent,
+  runFunction,
+  setAlpha,
+  stringify,
+  transformKeySubmitValue,
+  useBreakpoint,
+  useDebounceFn,
+  useDebounceValue,
+  useDeepCompareEffect,
+  useDeepCompareEffectDebounce,
+  useDeepCompareMemo,
+  useDocumentTitle,
+  useEditableArray,
+  useEditableMap,
+  useFetchData,
+  useLatest,
+  useMountMergeState,
+  usePrevious,
+  useReactiveRef,
+  useRefCallback,
+  useRefFunction,
+  useStyle
+};

package/es/utils/isBrowser/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 用于判断当前是否在浏览器环境中。
+ * 首先会判断当前是否处于测试环境中（通过 process.env.NODE_ENV === 'TEST' 判断），
+ * 如果是，则返回 true。否则，会进一步判断是否存在 window 对象、document 对象以及 matchMedia 方法
+ * 同时通过 !isNode 判断当前不是在服务器（Node.js）环境下执行，
+ * 如果都符合，则返回 true 表示当前处于浏览器环境中。
+ * @returns  boolean
+ */
+export declare const isBrowser: () => boolean;

package/es/utils/isBrowser/index.js

@@ -0,0 +1,11 @@
+// src/utils/isBrowser/index.ts
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isBrowser = () => {
+  if (typeof process !== "undefined" && false) {
+    return true;
+  }
+  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.matchMedia !== "undefined" && !isNode;
+};
+export {
+  isBrowser
+};

package/es/utils/isDeepEqualReact/index.d.ts

@@ -0,0 +1 @@
+export declare function isDeepEqualReact(a: any, b: any, ignoreKeys?: string[]): boolean;

package/es/utils/isDeepEqualReact/index.js

@@ -0,0 +1,78 @@
+// src/utils/isDeepEqualReact/index.ts
+function isDeepEqualReact(a, b, ignoreKeys) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    let length;
+    let i;
+    let keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!isDeepEqualReact(a[i], b[i], ignoreKeys))
+          return false;
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      for (i of a.entries())
+        if (!isDeepEqualReact(i[1], b.get(i[0]), ignoreKeys))
+          return false;
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (a[i] !== b[i])
+          return false;
+      return true;
+    }
+    if (a.constructor === RegExp)
+      return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf && a.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString && a.toString)
+      return a.toString() === b.toString();
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (ignoreKeys == null ? void 0 : ignoreKeys.includes(key))
+        continue;
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      }
+      if (!isDeepEqualReact(a[key], b[key], ignoreKeys)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+export {
+  isDeepEqualReact
+};

package/es/utils/isDropdownValueType/index.d.ts

@@ -0,0 +1 @@
+export declare const isDropdownValueType: (valueType: string) => boolean;

package/es/utils/isDropdownValueType/index.js

@@ -0,0 +1,11 @@
+// src/utils/isDropdownValueType/index.ts
+var isDropdownValueType = (valueType) => {
+  let isDropdown = false;
+  if (typeof valueType === "string" && valueType.startsWith("date") && !valueType.endsWith("Range") || valueType === "select" || valueType === "time") {
+    isDropdown = true;
+  }
+  return isDropdown;
+};
+export {
+  isDropdownValueType
+};

package/es/utils/isImg/index.d.ts

@@ -0,0 +1,2 @@
+/** 判断是否是图片链接 */
+export declare function isImg(path: string): boolean;

package/es/utils/isImg/index.js

@@ -0,0 +1,7 @@
+// src/utils/isImg/index.ts
+function isImg(path) {
+  return /\w.(png|jpg|jpeg|svg|webp|gif|bmp)$/i.test(path);
+}
+export {
+  isImg
+};

package/es/utils/isNil/index.d.ts

@@ -0,0 +1 @@
+export declare const isNil: (value: any) => value is null | undefined;

package/es/utils/isNil/index.js

@@ -0,0 +1,5 @@
+// src/utils/isNil/index.ts
+var isNil = (value) => value === null || value === void 0;
+export {
+  isNil
+};