@vef-framework/hooks 1.0.128 → 1.0.129

package/esm/use-data-query.js

@@ -1,108 +1,2 @@
 "use strict";
-import { useApiContext } from '@vef-framework/core';
-import { isNullish, isFunction } from '@vef-framework/shared';
-import { useUnmount } from 'ahooks';
-import { useMemo } from 'react';
-
-"use strict";
-function useApi({
-  data,
-  dataDictionaryKey,
-  api,
-  apiParams,
-  apiEnabled,
-  staleTime,
-  keepPreviousData,
-  placeholderData
-}, stubQueryApi, dataDictionaryApi) {
-  return useMemo(() => {
-    if (!isNullish(data)) {
-      return [
-        stubQueryApi,
-        data,
-        {
-          keepPreviousData: true,
-          initialData: data
-        }
-      ];
-    }
-    if (!isNullish(dataDictionaryKey)) {
-      return [
-        dataDictionaryApi,
-        {
-          ...apiParams,
-          key: dataDictionaryKey
-        },
-        {
-          enabled: apiEnabled ?? true,
-          staleTime,
-          keepPreviousData,
-          placeholderData
-        }
-      ];
-    }
-    if (!isNullish(api)) {
-      return [
-        api,
-        apiParams,
-        {
-          enabled: apiEnabled ?? true,
-          staleTime,
-          keepPreviousData,
-          placeholderData
-        }
-      ];
-    }
-    return [
-      stubQueryApi,
-      [],
-      {
-        keepPreviousData: true,
-        initialData: []
-      }
-    ];
-  }, [
-    data,
-    dataDictionaryKey,
-    api,
-    stubQueryApi,
-    dataDictionaryApi,
-    apiParams,
-    apiEnabled,
-    staleTime,
-    keepPreviousData,
-    placeholderData
-  ]);
-}
-function useDataQuery({ onFetched, ...config }) {
-  const {
-    useApiQuery,
-    stubQueryApi,
-    dataDictionaryApi: dataDictionaryQueryApi
-  } = useApiContext();
-  const [api, args, options] = useApi(config, stubQueryApi, dataDictionaryQueryApi);
-  const result = useApiQuery(api, args, options);
-  useUnmount(() => {
-    if (Object.is(api, stubQueryApi)) {
-      stubQueryApi.removeQueries(args);
-    }
-  });
-  const {
-    isSuccess,
-    data: rawData,
-    ...rest
-  } = result;
-  const data = useMemo(() => {
-    if (isSuccess && isFunction(onFetched)) {
-      return onFetched(rawData);
-    }
-    return rawData;
-  }, [isSuccess, rawData, onFetched]);
-  return {
-    ...rest,
-    isSuccess,
-    data
-  };
-}
-
-export { useDataQuery };
+import{useApiContext as k}from"@vef-framework/core";import{isNullish as l,isFunction as v}from"@vef-framework/shared";import{useUnmount as y}from"ahooks";import{useMemo as m}from"react";function P({data:e,dataDictionaryKey:s,api:o,apiParams:a,apiEnabled:u,staleTime:t,keepPreviousData:i,placeholderData:p},n,r){return m(()=>l(e)?l(s)?l(o)?[n,[],{keepPreviousData:!0,initialData:[]}]:[o,a,{enabled:u??!0,staleTime:t,keepPreviousData:i,placeholderData:p}]:[r,{...a,key:s},{enabled:u??!0,staleTime:t,keepPreviousData:i,placeholderData:p}]:[n,e,{keepPreviousData:!0,initialData:e}],[e,s,o,n,r,a,u,t,i,p])}function b({onFetched:e,...s}){const{useApiQuery:o,stubQueryApi:a,dataDictionaryApi:u}=k(),[t,i,p]=P(s,a,u),n=o(t,i,p);y(()=>{Object.is(t,a)&&a.removeQueries(i)});const{isSuccess:r,data:c,...D}=n,d=m(()=>r&&v(e)?e(c):c,[r,c,e]);return{...D,isSuccess:r,data:d}}export{b as useDataQuery};

package/esm/use-deep-callback.js

@@ -1,11 +1,2 @@
 "use strict";
-import { useCallback } from 'react';
-import { useDeepMemo } from './use-deep-memo.js';
-
-"use strict";
-function useDeepCallback(callback, dependencies) {
-  const memoizedDependencies = useDeepMemo(() => dependencies, dependencies);
-  return useCallback(callback, memoizedDependencies);
-}
-
-export { useDeepCallback };
+import{useCallback as r}from"react";import{useDeepMemo as s}from"./use-deep-memo.js";function u(t,e){const o=s(()=>e,e);return r(t,o)}export{u as useDeepCallback};

package/esm/use-deep-memo.js

@@ -1,19 +1,2 @@
 "use strict";
-import { isDeepEqual } from '@vef-framework/shared';
-import { useRef, useMemo } from 'react';
-
-"use strict";
-function useDeepMemo(factory, dependencies) {
-  const lastDependencies = useRef();
-  const signal = useRef(0);
-  if (lastDependencies.current === void 0 || !isEqual(dependencies, lastDependencies.current)) {
-    signal.current += 1;
-  }
-  lastDependencies.current = dependencies;
-  return useMemo(factory, [signal.current]);
-}
-function isEqual(one, another) {
-  return one.length === another.length && one.every((value, index) => isDeepEqual(value, another[index]));
-}
-
-export { useDeepMemo };
+import{isDeepEqual as o}from"@vef-framework/shared";import{useRef as n,useMemo as c}from"react";function s(t,r){const e=n(),u=n(0);return(e.current===void 0||!i(r,e.current))&&(u.current+=1),e.current=r,c(t,[u.current])}function i(t,r){return t.length===r.length&&t.every((e,u)=>o(e,r[u]))}export{s as useDeepMemo};

package/esm/use-deep-selector.js

@@ -1,14 +1,2 @@
 "use strict";
-import { isDeepEqual } from '@vef-framework/shared';
-import { useRef } from 'react';
-
-"use strict";
-function useDeepSelector(selector) {
-  const prevSelectedState = useRef();
-  return (state) => {
-    const nextSelectedState = selector(state);
-    return isDeepEqual(prevSelectedState.current, nextSelectedState) ? prevSelectedState.current : prevSelectedState.current = nextSelectedState;
-  };
-}
-
-export { useDeepSelector };
+import{isDeepEqual as n}from"@vef-framework/shared";import{useRef as o}from"react";function c(t){const r=o();return u=>{const e=t(u);return n(r.current,e)?r.current:r.current=e}}export{c as useDeepSelector};

package/esm/use-fallback-options.js

@@ -1,103 +1,2 @@
 "use strict";
-import { useApiContext } from '@vef-framework/core';
-import { isFunction } from '@vef-framework/shared';
-import { useUnmount } from 'ahooks';
-import { useId } from 'react';
-import { useShallowMemo } from './use-shallow-memo.js';
-
-"use strict";
-function useApi(missingOptionValues, {
-  fallbackOptionsApi,
-  fallbackOptionsApiParams,
-  valuesKey,
-  resolveFallbackOptions
-}, stubQueryApi, asyncFnQueryApi) {
-  const uniqueId = useId();
-  return useShallowMemo(() => {
-    if (missingOptionValues.length > 0) {
-      if (isFunction(resolveFallbackOptions)) {
-        const params = {
-          key: uniqueId,
-          args: [missingOptionValues],
-          fn: resolveFallbackOptions
-        };
-        return [
-          asyncFnQueryApi,
-          params,
-          {
-            keepPreviousData: true
-          }
-        ];
-      }
-      if (fallbackOptionsApi) {
-        const params = {
-          ...fallbackOptionsApiParams,
-          [valuesKey ?? "ids"]: missingOptionValues
-        };
-        return [
-          fallbackOptionsApi,
-          params,
-          {
-            keepPreviousData: true
-          }
-        ];
-      }
-    }
-    return [
-      stubQueryApi,
-      [],
-      {
-        keepPreviousData: true,
-        initialData: []
-      }
-    ];
-  }, [
-    resolveFallbackOptions,
-    fallbackOptionsApi,
-    stubQueryApi,
-    uniqueId,
-    missingOptionValues,
-    asyncFnQueryApi,
-    fallbackOptionsApiParams,
-    valuesKey
-  ]);
-}
-function useFallbackOptions(missingOptionValues, {
-  fallbackOptionsApi,
-  fallbackOptionsApiParams,
-  valuesKey,
-  resolveFallbackOptions
-}) {
-  const {
-    useApiQuery,
-    stubQueryApi,
-    asyncFnQueryApi
-  } = useApiContext();
-  const [
-    api,
-    params,
-    options
-  ] = useApi(
-    missingOptionValues,
-    {
-      fallbackOptionsApi,
-      fallbackOptionsApiParams,
-      valuesKey,
-      resolveFallbackOptions
-    },
-    stubQueryApi,
-    asyncFnQueryApi
-  );
-  const result = useApiQuery(api, params, options);
-  useUnmount(() => {
-    if (Object.is(api, stubQueryApi)) {
-      stubQueryApi.removeQueries(params);
-    }
-    if (Object.is(api, asyncFnQueryApi)) {
-      asyncFnQueryApi.removeQueries(params);
-    }
-  });
-  return result;
-}
-
-export { useFallbackOptions };
+import{useApiContext as m}from"@vef-framework/core";import{isFunction as f}from"@vef-framework/shared";import{useUnmount as b}from"ahooks";import{useId as k}from"react";import{useShallowMemo as O}from"./use-shallow-memo.js";function v(e,{fallbackOptionsApi:r,fallbackOptionsApiParams:o,valuesKey:l,resolveFallbackOptions:s},n,a){const i=k();return O(()=>{if(e.length>0){if(f(s))return[a,{key:i,args:[e],fn:s},{keepPreviousData:!0}];if(r){const t={...o,[l??"ids"]:e};return[r,t,{keepPreviousData:!0}]}}return[n,[],{keepPreviousData:!0,initialData:[]}]},[s,r,n,i,e,a,o,l])}function A(e,{fallbackOptionsApi:r,fallbackOptionsApiParams:o,valuesKey:l,resolveFallbackOptions:s}){const{useApiQuery:n,stubQueryApi:a,asyncFnQueryApi:i}=m(),[t,p,u]=v(e,{fallbackOptionsApi:r,fallbackOptionsApiParams:o,valuesKey:l,resolveFallbackOptions:s},a,i),c=n(t,p,u);return b(()=>{Object.is(t,a)&&a.removeQueries(p),Object.is(t,i)&&i.removeQueries(p)}),c}export{A as useFallbackOptions};

package/esm/use-gap-size-normalizer.js

@@ -1,36 +1,2 @@
 "use strict";
-import { useCallback } from 'react';
-import { useThemeTokens } from './use-theme-tokens.js';
-
-"use strict";
-function useGapSizeNormalizer() {
-  const {
-    paddingXS,
-    paddingSM,
-    padding,
-    paddingMD,
-    paddingLG
-  } = useThemeTokens();
-  return useCallback((gap) => {
-    if (gap === "tiny") {
-      return paddingXS;
-    } else if (gap === "small") {
-      return paddingSM;
-    } else if (gap === "medium") {
-      return padding;
-    } else if (gap === "large") {
-      return paddingMD;
-    } else if (gap === "huge") {
-      return paddingLG;
-    }
-    return gap;
-  }, [
-    paddingXS,
-    paddingSM,
-    padding,
-    paddingMD,
-    paddingLG
-  ]);
-}
-
-export { useGapSizeNormalizer };
+import{useCallback as t}from"react";import{useThemeTokens as e}from"./use-theme-tokens.js";function m(){const{paddingXS:n,paddingSM:r,padding:a,paddingMD:d,paddingLG:o}=e();return t(i=>i==="tiny"?n:i==="small"?r:i==="medium"?a:i==="large"?d:i==="huge"?o:i,[n,r,a,d,o])}export{m as useGapSizeNormalizer};

package/esm/use-normalized-gap-size.js

@@ -1,10 +1,2 @@
 "use strict";
-import { useGapSizeNormalizer } from './use-gap-size-normalizer.js';
-
-"use strict";
-function useNormalizedGapSize(gap) {
-  const normalize = useGapSizeNormalizer();
-  return normalize(gap);
-}
-
-export { useNormalizedGapSize };
+import{useGapSizeNormalizer as r}from"./use-gap-size-normalizer.js";function i(e){return r()(e)}export{i as useNormalizedGapSize};

package/esm/use-normalized-menu-items.js

@@ -1,45 +1,2 @@
 "use strict";
-import { useMemo } from 'react';
-
-"use strict";
-function normalizeMenuItem(item) {
-  if (item.type === "item") {
-    return {
-      type: "item",
-      key: item.key,
-      label: item.label,
-      disabled: item.disabled,
-      icon: item.icon,
-      extra: item.extra
-    };
-  } else if (item.type === "submenu") {
-    return {
-      type: "submenu",
-      key: item.key,
-      label: item.label,
-      disabled: item.disabled,
-      icon: item.icon,
-      children: item.children.map(normalizeMenuItem)
-    };
-  } else if (item.type === "group") {
-    return {
-      type: "group",
-      key: item.key,
-      label: item.label,
-      children: item.children.map(normalizeMenuItem)
-    };
-  } else {
-    return {
-      type: "divider",
-      key: item.key
-    };
-  }
-}
-function useNormalizedMenuItems(items) {
-  return useMemo(
-    () => items.map(normalizeMenuItem),
-    [items]
-  );
-}
-
-export { normalizeMenuItem, useNormalizedMenuItems };
+import{useMemo as l}from"react";function i(e){return e.type==="item"?{type:"item",key:e.key,label:e.label,disabled:e.disabled,icon:e.icon,extra:e.extra}:e.type==="submenu"?{type:"submenu",key:e.key,label:e.label,disabled:e.disabled,icon:e.icon,children:e.children.map(i)}:e.type==="group"?{type:"group",key:e.key,label:e.label,children:e.children.map(i)}:{type:"divider",key:e.key}}function t(e){return l(()=>e.map(i),[e])}export{i as normalizeMenuItem,t as useNormalizedMenuItems};

package/esm/use-normalized-options.js

@@ -1,102 +1,2 @@
 "use strict";
-import { isNullish, VefError, isString, parsePinyinFirstLetter, isArray } from '@vef-framework/shared';
-import { useMemo } from 'react';
-
-"use strict";
-function useNormalizedDataOptions(options, {
-  labelKey = "label",
-  valueKey = "value",
-  childrenKey = "children",
-  descriptionKey = "description",
-  disabledKey = "disabled",
-  defaultToFirst = false
-}, {
-  isTree = false,
-  isGrouped = false,
-  parsePinyin = false,
-  selectedOptionValues = []
-} = {}) {
-  return useMemo(() => {
-    const selectedOptionValuesSet = new Set(selectedOptionValues);
-    const isGroupedOptions = !isTree && isGrouped;
-    const normalizeOption = (option, isTopLevel = false) => {
-      const label = option[labelKey];
-      if (isNullish(label)) {
-        if (labelKey === "label") {
-          throw new VefError(-10001, `The label value of the option is required.`);
-        }
-        throw new VefError(-10001, `The label value pointed by '${labelKey}' of the option is required.`);
-      }
-      const value = option[valueKey];
-      if (isNullish(value)) {
-        if (valueKey === "value") {
-          throw new VefError(-10002, `The value of the option is required.`);
-        }
-        throw new VefError(-10002, `The value pointed by '${valueKey}' of the option is required.`);
-      }
-      const children = option[childrenKey];
-      const description = option[descriptionKey];
-      const disabled = option[disabledKey] ?? false;
-      const normalizedOption = {
-        ...option,
-        label,
-        value,
-        children,
-        description,
-        disabled
-      };
-      if (parsePinyin) {
-        const { labelText, descriptionText } = normalizedOption;
-        if (isString(label) || isString(labelText)) {
-          normalizedOption.labelPinyin = parsePinyinFirstLetter(
-            isString(label) ? label : labelText
-          ).join("");
-        }
-        if (isString(description) || isString(descriptionText)) {
-          normalizedOption.descriptionPinyin = parsePinyinFirstLetter(
-            isString(description) ? description : descriptionText
-          ).join("");
-        }
-      }
-      if ((!isTopLevel || !isGroupedOptions) && selectedOptionValuesSet.has(value)) {
-        selectedOptionValuesSet.delete(value);
-      }
-      if (isArray(normalizedOption.children)) {
-        normalizedOption.children = normalizedOption.children.map((option2) => normalizeOption(option2));
-      }
-      return normalizedOption;
-    };
-    const normalizedOptions = options.map((option) => normalizeOption(option, true));
-    const missingOptionValues = Array.from(selectedOptionValuesSet);
-    if (!defaultToFirst) {
-      return [normalizedOptions, missingOptionValues];
-    }
-    if (isGroupedOptions) {
-      const firstNonEmptyGroupOption = normalizedOptions.find((item) => isArray(item.children) && item.children.length > 0);
-      return [
-        normalizedOptions,
-        missingOptionValues,
-        firstNonEmptyGroupOption?.children?.[0]
-      ];
-    }
-    return [
-      normalizedOptions,
-      missingOptionValues,
-      normalizedOptions[0]
-    ];
-  }, [
-    childrenKey,
-    defaultToFirst,
-    descriptionKey,
-    disabledKey,
-    isGrouped,
-    isTree,
-    labelKey,
-    options,
-    parsePinyin,
-    // selectedOptionValues,
-    valueKey
-  ]);
-}
-
-export { useNormalizedDataOptions };
+import{isNullish as F,VefError as c,isString as n,parsePinyinFirstLetter as O,isArray as g}from"@vef-framework/shared";import{useMemo as V}from"react";function $(f,{labelKey:l="label",valueKey:o="value",childrenKey:y="children",descriptionKey:b="description",disabledKey:m="disabled",defaultToFirst:v=!1},{isTree:w=!1,isGrouped:T=!1,parsePinyin:K=!1,selectedOptionValues:j=[]}={}){return V(()=>{const p=new Set(j),P=!w&&T,q=(e,s=!1)=>{const t=e[l];if(F(t))throw l==="label"?new c(-10001,"The label value of the option is required."):new c(-10001,`The label value pointed by '${l}' of the option is required.`);const d=e[o];if(F(d))throw o==="value"?new c(-10002,"The value of the option is required."):new c(-10002,`The value pointed by '${o}' of the option is required.`);const A=e[y],a=e[b],S=e[m]??!1,i={...e,label:t,value:d,children:A,description:a,disabled:S};if(K){const{labelText:u,descriptionText:x}=i;(n(t)||n(u))&&(i.labelPinyin=O(n(t)?t:u).join("")),(n(a)||n(x))&&(i.descriptionPinyin=O(n(a)?a:x).join(""))}return(!s||!P)&&p.has(d)&&p.delete(d),g(i.children)&&(i.children=i.children.map(u=>q(u))),i},r=f.map(e=>q(e,!0)),h=Array.from(p);if(!v)return[r,h];if(P){const e=r.find(s=>g(s.children)&&s.children.length>0);return[r,h,e?.children?.[0]]}return[r,h,r[0]]},[y,v,b,m,T,w,l,f,K,o])}export{$ as useNormalizedDataOptions};

package/esm/use-option-filter.js

@@ -1,18 +1,2 @@
 "use strict";
-import { isString } from '@vef-framework/shared';
-import { useMemo } from 'react';
-
-"use strict";
-function useOptionFilter(filterable, filterFromRemote) {
-  return useMemo(() => {
-    if (!filterable) {
-      return;
-    }
-    if (filterFromRemote) {
-      return false;
-    }
-    return (filterValue, option) => (isString(option.label) && option.label.includes(filterValue) || isString(option.labelText) && option.labelText.includes(filterValue) || option.labelPinyin?.includes(filterValue) || option.value.includes(filterValue) || isString(option.description) && option.description.includes(filterValue) || isString(option.descriptionText) && option.descriptionText.includes(filterValue) || option.descriptionPinyin?.includes(filterValue)) ?? false;
-  }, [filterable, filterFromRemote]);
-}
-
-export { useOptionFilter };
+import{isString as t}from"@vef-framework/shared";import{useMemo as r}from"react";function s(l,n){return r(()=>{if(l)return n?!1:(e,i)=>(t(i.label)&&i.label.includes(e)||t(i.labelText)&&i.labelText.includes(e)||i.labelPinyin?.includes(e)||i.value.includes(e)||t(i.description)&&i.description.includes(e)||t(i.descriptionText)&&i.descriptionText.includes(e)||i.descriptionPinyin?.includes(e))??!1},[l,n])}export{s as useOptionFilter};

package/esm/use-remote-filter.js

@@ -1,37 +1,2 @@
 "use strict";
-import { trim, debounce } from '@vef-framework/shared';
-import { useState, useMemo } from 'react';
-
-"use strict";
-function useRemoteFilter(enabled, apiParams, keywordKey = "keyword") {
-  const [filterKeyword, setFilterKeyword] = useState();
-  const mergedApiParams = useMemo(() => {
-    if (!enabled) {
-      return apiParams;
-    }
-    const params = {
-      ...apiParams
-    };
-    const keywordToUse = trim(filterKeyword);
-    if (keywordToUse) {
-      params[keywordKey] = keywordToUse;
-    }
-    return params;
-  }, [
-    enabled,
-    apiParams,
-    filterKeyword,
-    keywordKey
-  ]);
-  const handleInputKeyword = useMemo(() => {
-    if (!enabled) {
-      return;
-    }
-    return debounce({ delay: 500 }, (keyword) => {
-      setFilterKeyword(keyword);
-    });
-  }, [enabled]);
-  return [mergedApiParams, handleInputKeyword];
-}
-
-export { useRemoteFilter };
+import{trim as f,debounce as d}from"@vef-framework/shared";import{useState as p,useMemo as i}from"react";function y(r,t,o="keyword"){const[u,m]=p(),s=i(()=>{if(!r)return t;const e={...t},n=f(u);return n&&(e[o]=n),e},[r,t,u,o]),c=i(()=>{if(r)return d({delay:500},e=>{m(e)})},[r]);return[s,c]}export{y as useRemoteFilter};

package/esm/use-shallow-callback.js

@@ -1,11 +1,2 @@
 "use strict";
-import { useCallback } from 'react';
-import { useShallowMemo } from './use-shallow-memo.js';
-
-"use strict";
-function useShallowCallback(callback, dependencies) {
-  const memoizedDependencies = useShallowMemo(() => dependencies, dependencies);
-  return useCallback(callback, memoizedDependencies);
-}
-
-export { useShallowCallback };
+import{useCallback as r}from"react";import{useShallowMemo as a}from"./use-shallow-memo.js";function e(t,o){const l=a(()=>o,o);return r(t,l)}export{e as useShallowCallback};

package/esm/use-shallow-memo.js

@@ -1,19 +1,2 @@
 "use strict";
-import { isShallowEqual } from '@vef-framework/shared';
-import { useRef, useMemo } from 'react';
-
-"use strict";
-function useShallowMemo(factory, dependencies) {
-  const lastDependencies = useRef();
-  const signal = useRef(0);
-  if (lastDependencies.current === void 0 || !isEqual(dependencies, lastDependencies.current)) {
-    signal.current += 1;
-  }
-  lastDependencies.current = dependencies;
-  return useMemo(factory, [signal.current]);
-}
-function isEqual(one, another) {
-  return one.length === another.length && one.every((value, index) => isShallowEqual(value, another[index]));
-}
-
-export { useShallowMemo };
+import{isShallowEqual as o}from"@vef-framework/shared";import{useRef as n,useMemo as c}from"react";function s(e,r){const t=n(),u=n(0);return(t.current===void 0||!i(r,t.current))&&(u.current+=1),t.current=r,c(e,[u.current])}function i(e,r){return e.length===r.length&&e.every((t,u)=>o(t,r[u]))}export{s as useShallowMemo};

package/esm/use-shallow-selector.js

@@ -1,14 +1,2 @@
 "use strict";
-import { isShallowEqual } from '@vef-framework/shared';
-import { useRef } from 'react';
-
-"use strict";
-function useShallowSelector(selector) {
-  const prevSelectedState = useRef();
-  return (state) => {
-    const nextSelectedState = selector(state);
-    return isShallowEqual(prevSelectedState.current, nextSelectedState) ? prevSelectedState.current : prevSelectedState.current = nextSelectedState;
-  };
-}
-
-export { useShallowSelector };
+import{isShallowEqual as u}from"@vef-framework/shared";import{useRef as n}from"react";function c(e){const r=n();return o=>{const t=e(o);return u(r.current,t)?r.current:r.current=t}}export{c as useShallowSelector};

package/esm/use-singleton.js

@@ -1,14 +1,2 @@
 "use strict";
-import { isNullish } from '@vef-framework/shared';
-import { useRef } from 'react';
-
-"use strict";
-function useSingleton(factory) {
-  const singleton = useRef();
-  if (isNullish(singleton.current)) {
-    singleton.current = factory();
-  }
-  return singleton.current;
-}
-
-export { useSingleton };
+import{isNullish as e}from"@vef-framework/shared";import{useRef as n}from"react";function u(t){const r=n();return e(r.current)&&(r.current=t()),r.current}export{u as useSingleton};

package/esm/use-theme-tokens.js

@@ -1,11 +1,2 @@
 "use strict";
-import { theme } from 'antd';
-
-"use strict";
-const { useToken } = theme;
-function useThemeTokens() {
-  const { token } = useToken();
-  return token;
-}
-
-export { useThemeTokens };
+import{theme as t}from"antd";const{useToken:n}=t;function o(){const{token:e}=n();return e}export{o as useThemeTokens};

package/esm/use-transient-store.js

@@ -1,32 +1,2 @@
 "use strict";
-import { isShallowEqual } from '@vef-framework/shared';
-import { useRef, useEffect } from 'react';
-
-"use strict";
-function useTransientStore({ subscribe, getState }, {
-  selector = (state) => state,
-  equalityFn = isShallowEqual,
-  listener
-} = {}) {
-  const stateRef = useRef();
-  if (!stateRef.current) {
-    stateRef.current = selector(getState());
-  }
-  useEffect(
-    () => subscribe(
-      selector,
-      (state, prevState) => {
-        stateRef.current = state;
-        listener?.(state, prevState);
-      },
-      {
-        fireImmediately: false,
-        equalityFn
-      }
-    ),
-    [equalityFn, listener, selector, subscribe]
-  );
-  return stateRef;
-}
-
-export { useTransientStore };
+import{isShallowEqual as o}from"@vef-framework/shared";import{useRef as l,useEffect as f}from"react";function a({subscribe:r,getState:n},{selector:t=e=>e,equalityFn:u=o,listener:i}={}){const e=l();return e.current||(e.current=t(n())),f(()=>r(t,(s,c)=>{e.current=s,i?.(s,c)},{fireImmediately:!1,equalityFn:u}),[u,i,t,r]),e}export{a as useTransientStore};

package/esm/use-window-size.js

@@ -1,19 +1,2 @@
 "use strict";
-import { useRafState, useEventListener } from 'ahooks';
-
-"use strict";
-function useWindowSize() {
-  const [size, setSize] = useRafState(() => ({
-    width: window.innerWidth,
-    height: window.innerHeight
-  }));
-  useEventListener("resize", () => {
-    setSize({
-      width: window.innerWidth,
-      height: window.innerHeight
-    });
-  });
-  return size;
-}
-
-export { useWindowSize };
+import{useRafState as n,useEventListener as t}from"ahooks";function r(){const[i,e]=n(()=>({width:window.innerWidth,height:window.innerHeight}));return t("resize",()=>{e({width:window.innerWidth,height:window.innerHeight})}),i}export{r as useWindowSize};