@vef-framework/hooks 1.0.135 → 2.0.1

package/dist/es/use-deep-isomorphic-effect/index.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import '../lib.js';
+import { useDeepCompare } from '../use-deep-compare/index.js';
+import { useIsomorphicEffect } from '@mantine/hooks';
+
+function useDeepIsomorphicEffect(effect, dependencies) {
+  return useIsomorphicEffect(effect, useDeepCompare(dependencies));
+}
+
+export { useDeepIsomorphicEffect };

package/dist/es/use-deep-layout-effect/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useLayoutEffect } from 'react';
+import { useDeepCompare } from '../use-deep-compare/index.js';
+
+function useDeepLayoutEffect(effect, dependencies) {
+  return useLayoutEffect(effect, useDeepCompare(dependencies));
+}
+
+export { useDeepLayoutEffect };

package/dist/es/use-deep-memo/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useMemo } from 'react';
+import { useDeepCompare } from '../use-deep-compare/index.js';
+
+function useDeepMemo(factory, dependencies) {
+  return useMemo(factory, useDeepCompare(dependencies));
+}
+
+export { useDeepMemo };

package/dist/es/use-document-event/index.js

@@ -0,0 +1,18 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useLatest } from '../use-latest/index.js';
+import { useShallowEffect } from '../use-shallow-effect/index.js';
+
+function useDocumentEvent(type, listener, options) {
+  const listenerFn = useLatest(listener);
+  useShallowEffect(() => {
+    function handleEvent(event) {
+      listenerFn.current.call(this, event);
+    }
+    document.addEventListener(type, handleEvent, options);
+    return () => {
+      document.removeEventListener(type, handleEvent, options);
+    };
+  }, [type, options, listenerFn]);
+}
+
+export { useDocumentEvent };

package/dist/es/use-emitter-event/index.js

@@ -0,0 +1,18 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import '@vef-framework/shared';
+import { useEffectEvent, useEffect } from 'react';
+
+function useEmitterEvent(emitter, eventType, eventListener) {
+  const listenerFn = useEffectEvent(eventListener);
+  useEffect(
+    () => {
+      const handler = (...args) => {
+        listenerFn(...args);
+      };
+      return emitter.on(eventType, handler);
+    },
+    [emitter, eventType]
+  );
+}
+
+export { useEmitterEvent };

package/dist/es/use-has-fetching/index.js

@@ -0,0 +1,13 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useIsFetching } from '@vef-framework/core';
+
+function useHasFetching(key, params) {
+  const count = useIsFetching({
+    queryKey: params ? [key, params] : [key],
+    exact: false,
+    type: "active"
+  });
+  return count > 0;
+}
+
+export { useHasFetching };

package/dist/es/use-has-mutating/index.js

@@ -0,0 +1,12 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useIsMutating } from '@vef-framework/core';
+
+function useHasMutating(key) {
+  const count = useIsMutating({
+    mutationKey: [key],
+    exact: false
+  });
+  return count > 0;
+}
+
+export { useHasMutating };

package/dist/es/use-is-authorized/index.js

@@ -0,0 +1,14 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useAppContext, checkPermission } from '@vef-framework/core';
+import { useMemo } from 'react';
+
+function useIsAuthorized(permTokens, checkMode) {
+  const { hasPermission = () => true } = useAppContext();
+  const isAuthorized = useMemo(
+    () => checkPermission(hasPermission, permTokens, checkMode),
+    [permTokens, checkMode, hasPermission]
+  );
+  return isAuthorized;
+}
+
+export { useIsAuthorized };

package/dist/es/use-latest/index.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useRef } from 'react';
+
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+export { useLatest };

package/dist/es/use-raf-state/index.js

@@ -0,0 +1,19 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useRef, useState, useCallback, useEffect } from 'react';
+
+function useRafState(initialState) {
+  const frameId = useRef(0);
+  const [state, setState] = useState(initialState);
+  const setRafState = useCallback((state2) => {
+    cancelAnimationFrame(frameId.current);
+    frameId.current = requestAnimationFrame(() => {
+      setState(state2);
+    });
+  }, []);
+  useEffect(() => () => {
+    cancelAnimationFrame(frameId.current);
+  }, []);
+  return [state, setRafState];
+}
+
+export { useRafState };

package/dist/es/use-shallow-callback/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useCallback } from 'react';
+import { useShallowCompare } from '../use-shallow-compare/index.js';
+
+function useShallowCallback(callback, dependencies) {
+  return useCallback(callback, useShallowCompare(dependencies));
+}
+
+export { useShallowCallback };

package/dist/es/use-shallow-compare/index.js

@@ -0,0 +1,32 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { isShallowEqual } from '@vef-framework/shared';
+import { useRef } from 'react';
+
+function useShallowCompare(dependencies) {
+  const ref = useRef(void 0);
+  const signalRef = useRef(0);
+  if (!shallowCompare(ref.current, dependencies)) {
+    ref.current = dependencies;
+    signalRef.current += 1;
+  }
+  return [signalRef.current];
+}
+function shallowCompare(previous, current) {
+  if (!previous || !current) {
+    return false;
+  }
+  if (Object.is(previous, current)) {
+    return true;
+  }
+  if (previous.length !== current.length) {
+    return false;
+  }
+  for (const [index, element] of previous.entries()) {
+    if (!isShallowEqual(element, current[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { useShallowCompare };

package/dist/es/use-shallow-effect/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useEffect } from 'react';
+import { useShallowCompare } from '../use-shallow-compare/index.js';
+
+function useShallowEffect(effect, dependencies) {
+  return useEffect(effect, useShallowCompare(dependencies));
+}
+
+export { useShallowEffect };

package/dist/es/use-shallow-isomorphic-effect/index.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import '../lib.js';
+import { useShallowCompare } from '../use-shallow-compare/index.js';
+import { useIsomorphicEffect } from '@mantine/hooks';
+
+function useShallowIsomorphicEffect(effect, dependencies) {
+  return useIsomorphicEffect(effect, useShallowCompare(dependencies));
+}
+
+export { useShallowIsomorphicEffect };

package/dist/es/use-shallow-layout-effect/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useLayoutEffect } from 'react';
+import { useShallowCompare } from '../use-shallow-compare/index.js';
+
+function useShallowLayoutEffect(effect, dependencies) {
+  return useLayoutEffect(effect, useShallowCompare(dependencies));
+}
+
+export { useShallowLayoutEffect };

package/dist/es/use-shallow-memo/index.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useMemo } from 'react';
+import { useShallowCompare } from '../use-shallow-compare/index.js';
+
+function useShallowMemo(factory, dependencies) {
+  return useMemo(factory, useShallowCompare(dependencies));
+}
+
+export { useShallowMemo };

package/dist/es/use-singleton/index.js

@@ -0,0 +1,12 @@
+/*! @vef-framework/hooks v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:31.592Z */
+import { useRef } from 'react';
+
+function useSingleton(initializer) {
+  const ref = useRef(null);
+  if (ref.current === null) {
+    ref.current = initializer();
+  }
+  return ref;
+}
+
+export { useSingleton };

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+export { assignRef, getHotkeyHandler, HotkeysProvider, mergeRefs, useColorScheme, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDidUpdate, useDocumentTitle, useElementSize, useEventListener, useFocusTrap, useFullscreen, useHotkeys, useHotkeysContext, useIntersection, useInterval, useIsFirstRender, useIsomorphicEffect, useMediaQuery, useMergedRef, useMounted, useMutationObserver, usePrevious, useRecordHotkeys, useReducedMotion, useResizeObserver, useTimeout, useWindowEvent, type HotkeyCallback, type HotkeysOptions } from './lib';
+export { useAuthorizedItems, type PermissionAware } from './use-authorized-items';
+export { useBreakpoints, type Breakpoints, type UseBreakpointsOptions, type UseBreakpointsResult } from './use-breakpoints';
+export { useCheckPermission } from './use-check-permission';
+export { useDataDictQuery, type UseDataDictQueryOptions } from './use-data-dict-query';
+export { useDataOptionsQuery, type FieldExtractor, type UseDataOptionsQueryOptions, type UseDataOptionsQueryResult } from './use-data-options';
+export { useDeepCallback } from './use-deep-callback';
+export { useDeepCompare } from './use-deep-compare';
+export { useDeepEffect } from './use-deep-effect';
+export { useDeepIsomorphicEffect } from './use-deep-isomorphic-effect';
+export { useDeepLayoutEffect } from './use-deep-layout-effect';
+export { useDeepMemo } from './use-deep-memo';
+export { useDocumentEvent } from './use-document-event';
+export { useEmitterEvent } from './use-emitter-event';
+export { useHasFetching } from './use-has-fetching';
+export { useHasMutating } from './use-has-mutating';
+export { useIsAuthorized } from './use-is-authorized';
+export { useLatest } from './use-latest';
+export { useRafState } from './use-raf-state';
+export { useShallowCallback } from './use-shallow-callback';
+export { useShallowCompare } from './use-shallow-compare';
+export { useShallowEffect } from './use-shallow-effect';
+export { useShallowIsomorphicEffect } from './use-shallow-isomorphic-effect';
+export { useShallowLayoutEffect } from './use-shallow-layout-effect';
+export { useShallowMemo } from './use-shallow-memo';
+export { useSingleton, type SingletonRefObject } from './use-singleton';

package/dist/types/lib.d.ts

@@ -0,0 +1,6 @@
+import { UseColorSchemeValue, UseMediaQueryOptions } from '@mantine/hooks';
+export declare function useMediaQuery(query: string, initialValue?: boolean, options?: UseMediaQueryOptions): boolean;
+export declare function useColorScheme(initialValue?: UseColorSchemeValue, options?: UseMediaQueryOptions): UseColorSchemeValue;
+export declare function useReducedMotion(initialValue?: boolean, options?: UseMediaQueryOptions): boolean;
+export { assignRef, getHotkeyHandler, mergeRefs, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDidUpdate, useDocumentTitle, useElementSize, useEventListener, useFocusTrap, useFullscreen, useIntersection, useInterval, useIsFirstRender, useIsomorphicEffect, useMergedRef, useMounted, useMutationObserver, usePrevious, useResizeObserver, useTimeout, useWindowEvent } from '@mantine/hooks';
+export { HotkeysProvider, useHotkeys, useHotkeysContext, useRecordHotkeys, type HotkeyCallback, type Options as HotkeysOptions } from 'react-hotkeys-hook';

package/{types/use-authorized-items.d.ts → dist/types/use-authorized-items/index.d.ts}

@@ -1,12 +1,13 @@
-import type { PermissionCheckMode } from "@vef-framework/shared";
+import { PermissionCheckMode } from '@vef-framework/core';
+import { MaybeArray } from '@vef-framework/shared';
 /**
  * The permission aware interface.
  */
 export interface PermissionAware {
     /**
-     * The permission tokens.
+     * The permission tokens to check.
      */
-    permissions?: string[];
+    permTokens?: MaybeArray<string>;
     /**
      * The permission check mode.
      */

package/dist/types/use-breakpoints/index.d.ts

@@ -0,0 +1,47 @@
+export type BreakpointValue = number | string;
+export type Breakpoints<T extends string = string> = Record<T, BreakpointValue>;
+/**
+ * Result returned by useBreakpoints hook
+ */
+export interface UseBreakpointsResult<T extends string = string> {
+    /**
+     * The name of the current active breakpoint (largest matching)
+     */
+    current?: T;
+    /**
+     * The numeric value of the current breakpoint
+     */
+    value?: BreakpointValue;
+    /**
+     * Array of all matching breakpoint names
+     */
+    matches: T[];
+}
+/**
+ * Options for useBreakpoints hook
+ */
+export interface UseBreakpointsOptions<T extends string = string> {
+    /**
+     * Initial breakpoint name for SSR (server-side rendering)
+     * If not provided, will default to null during SSR
+     */
+    initialBreakpoint?: T;
+    /**
+     * Get initial value in effect instead of on mount
+     * This helps avoid hydration mismatches in SSR
+     * @default false
+     */
+    getInitialValueInEffect?: boolean;
+}
+/**
+ * Hook to track active breakpoints based on window width
+ *
+ * @param breakpoints - Breakpoint configuration object
+ * @param options - Hook options
+ * @returns Current breakpoint information
+ *
+ * @remarks
+ * **Important**: Since this hook uses `min-width` media queries, you should include
+ * a breakpoint starting from 0 to ensure all viewport sizes are covered.
+ */
+export declare function useBreakpoints<T extends string>(breakpoints: Breakpoints<T>, options?: UseBreakpointsOptions<T>): UseBreakpointsResult<T>;

package/dist/types/use-check-permission/index.d.ts

@@ -0,0 +1,8 @@
+import { PermissionCheckMode } from '@vef-framework/core';
+import { MaybeArray } from '@vef-framework/shared';
+/**
+ * The use check permission hook.
+ *
+ * @returns The check permission function.
+ */
+export declare function useCheckPermission(): (permTokens?: MaybeArray<string>, checkMode?: PermissionCheckMode) => boolean;

package/dist/types/use-data-dict-query/index.d.ts

@@ -0,0 +1,15 @@
+import { DataOption, UseQueryOptions, UseQueryResult } from '@vef-framework/core';
+import { Except } from '@vef-framework/shared';
+export type UseDataDictQueryOptions<TData = DataOption> = Except<UseQueryOptions<DataOption[], TData[]>, "queryFn" | "queryKey" | "queryHash" | "queryKeyHashFn"> & {
+    dataDictKey?: string;
+    onFetch?: (data: TData[]) => void;
+};
+/**
+ * A hook for querying data dictionary.
+ * Uses the dataDictQueryFn from app context to fetch data dictionary options.
+ *
+ * @param dataDictKey - The key of the data dictionary to query.
+ * @param options - Additional query options (excluding queryFn and queryKey).
+ * @returns The query result containing data dictionary options.
+ */
+export declare function useDataDictQuery<TData = DataOption>({ dataDictKey, onFetch, ...options }: UseDataDictQueryOptions<TData>): UseQueryResult<TData[]>;

package/dist/types/use-data-options/index.d.ts

@@ -0,0 +1,80 @@
+import { DataOption, DataOptionWithPinyin, UseQueryOptions, UseQueryResult } from '@vef-framework/core';
+import { Key, MaybeUndefined, Prettify } from '@vef-framework/shared';
+/**
+ * Field extractor - can be a string path (e.g., "user.name") or a function
+ */
+export type FieldExtractor<TData, TValue> = string | ((item: TData) => TValue);
+/**
+ * Base field mapping options
+ */
+export interface DataOptionsFieldMapping<TData = unknown> {
+    /**
+     * Field mapping for label
+     * @default "label"
+     */
+    labelKey?: FieldExtractor<TData, string>;
+    /**
+     * Field mapping for value
+     * @default "value"
+     */
+    valueKey?: FieldExtractor<TData, Key>;
+    /**
+     * Field mapping for disabled
+     * @default "disabled"
+     */
+    disabledKey?: FieldExtractor<TData, MaybeUndefined<boolean>>;
+    /**
+     * Field mapping for description
+     * @default "description"
+     */
+    descriptionKey?: FieldExtractor<TData, MaybeUndefined<string>>;
+    /**
+     * Field mapping for children
+     * @default "children"
+     */
+    childrenKey?: FieldExtractor<TData, MaybeUndefined<TData[]>>;
+}
+/**
+ * Options for useDataOptionsQuery with regular query
+ */
+export type UseDataOptionsQueryOptionsWithQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = DataOptionsFieldMapping<TData> & {
+    /**
+     * Options for fetching data using regular query
+     */
+    queryOptions: UseQueryOptions<TQueryFnData[], TData[], TParams>;
+    /**
+     * Data dictionary key - should not be provided when using queryOptions
+     */
+    dataDictKey?: never;
+};
+/**
+ * Options for useDataOptionsQuery with data dictionary query
+ */
+export type UseDataOptionsQueryOptionsWithDataDict<TData = DataOption> = DataOptionsFieldMapping<TData> & {
+    /**
+     * Data dictionary key
+     */
+    dataDictKey: string;
+    /**
+     * Regular query options - should not be provided when using dataDictKey
+     */
+    queryOptions?: never;
+};
+/**
+ * Options for useDataOptionsQuery hook - supports both regular query and data dictionary query
+ */
+export type UseDataOptionsQueryOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = UseDataOptionsQueryOptionsWithQuery<TQueryFnData, TData, TParams> | UseDataOptionsQueryOptionsWithDataDict<TData>;
+/**
+ * Return type for useDataOptionsQuery hook
+ */
+export type UseDataOptionsQueryResult<TData, TOption> = Prettify<Omit<UseQueryResult<TData[]>, "data"> & {
+    options: TOption[];
+}>;
+export declare function useDataOptionsQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(config: UseDataOptionsQueryOptions<TQueryFnData, TData, TParams>): UseDataOptionsQueryResult<TData, DataOption<TData>>;
+export declare function useDataOptionsQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: UseDataOptionsQueryOptions<TQueryFnData, TData, TParams> & {
+    /**
+     * Whether to add pinyin fields for label and description
+     * @default false
+     */
+    withPinyin: boolean;
+}): UseDataOptionsQueryResult<TData, DataOptionWithPinyin<TData>>;

package/dist/types/use-deep-callback/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList } from 'react';
+/**
+ * Use the deep callback of the callback
+ *
+ * @param callback - The callback to memo.
+ * @param dependencies - The dependencies to compare.
+ * @returns The memoized callback.
+ */
+export declare function useDeepCallback<T extends Function>(callback: T, dependencies: DependencyList): T;

package/dist/types/use-deep-compare/index.d.ts

@@ -0,0 +1,8 @@
+import { DependencyList } from 'react';
+/**
+ * Use the deep compare of the dependencies
+ *
+ * @param dependencies - The dependencies to compare.
+ * @returns The signal of the dependencies.
+ */
+export declare function useDeepCompare(dependencies?: DependencyList): readonly [number];

package/dist/types/use-deep-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the deep effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useDeepEffect(effect: EffectCallback, dependencies?: DependencyList): void;

package/dist/types/use-deep-isomorphic-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the deep isomorphic effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useDeepIsomorphicEffect(effect: EffectCallback, dependencies?: DependencyList): void;

package/dist/types/use-deep-layout-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the deep layout effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useDeepLayoutEffect(effect: EffectCallback, dependencies?: DependencyList): void;

package/dist/types/use-deep-memo/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList } from 'react';
+/**
+ * Use the deep memo of the factory
+ *
+ * @param factory - The factory to memo.
+ * @param dependencies - The dependencies to compare.
+ * @returns The memoized value.
+ */
+export declare function useDeepMemo<T>(factory: () => T, dependencies: DependencyList): T;

package/dist/types/use-document-event/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook to listen for document events.
+ *
+ * @param type - The type of event to listen for.
+ * @param listener - The function to call when the event is triggered.
+ * @param options - The options to pass to the event listener.
+ */
+export declare function useDocumentEvent<TType extends string>(type: TType, listener: TType extends keyof DocumentEventMap ? (this: Document, event: DocumentEventMap[TType]) => void : (this: Document, event: CustomEvent) => void, options?: boolean | AddEventListenerOptions): void;

package/dist/types/use-emitter-event/index.d.ts

@@ -0,0 +1,9 @@
+import { EventHandler, EventType, EventEmitter } from '@vef-framework/shared';
+/**
+ * A hook to listen to an event from an EventEmitter.
+ *
+ * @param emitter - The EventEmitter instance to listen to.
+ * @param eventType - The type of event to listen to.
+ * @param eventListener - The function to call when the event is emitted.
+ */
+export declare function useEmitterEvent<TEvents extends Record<EventType, unknown>>(emitter: EventEmitter<TEvents>, eventType: keyof TEvents, eventListener: EventHandler<TEvents[keyof TEvents]>): void;

package/dist/types/use-has-fetching/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A hook to check if there are any active queries fetching for a specific query key.
+ *
+ * @param key - The base query key to check for fetching status.
+ * @param params - Optional parameters to include in the query key for more specific filtering.
+ * @returns True if there are any active queries fetching with the specified key, false otherwise.
+ */
+export declare function useHasFetching(key: string, params?: unknown): boolean;

package/dist/types/use-has-mutating/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook to check if there are any active mutations for a specific mutation key.
+ *
+ * @param key - The base mutation key to check for mutating status.
+ * @returns True if there are any active mutations with the specified key, false otherwise.
+ */
+export declare function useHasMutating(key: string): boolean;

package/dist/types/use-is-authorized/index.d.ts

@@ -0,0 +1,10 @@
+import { PermissionCheckMode } from '@vef-framework/core';
+import { MaybeArray } from '@vef-framework/shared';
+/**
+ * The use is authorized hook.
+ *
+ * @param permTokens - The permission tokens to check.
+ * @param checkMode - The check mode to use.
+ * @returns Whether the user is authorized to access the resource identified by the permission token.
+ */
+export declare function useIsAuthorized(permTokens?: MaybeArray<string>, checkMode?: PermissionCheckMode): boolean;

package/dist/types/use-latest/index.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+/**
+ * Use the latest value of the ref
+ *
+ * @param value - The value to use.
+ * @returns The latest value of the ref.
+ */
+export declare function useLatest<T>(value: T): RefObject<T>;

package/dist/types/use-raf-state/index.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, SetStateAction } from 'react';
+/**
+ * A hook to use the request animation frame state.
+ *
+ * @param initialState - The initial state.
+ * @returns The state and the set state function.
+ */
+export declare function useRafState<T>(initialState: T | (() => T)): [T, Dispatch<SetStateAction<T>>];

package/dist/types/use-shallow-callback/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList } from 'react';
+/**
+ * Use the shallow callback of the callback
+ *
+ * @param callback - The callback to memo.
+ * @param dependencies - The dependencies to compare.
+ * @returns The memoized callback.
+ */
+export declare function useShallowCallback<T extends Function>(callback: T, dependencies: DependencyList): T;

package/dist/types/use-shallow-compare/index.d.ts

@@ -0,0 +1,8 @@
+import { DependencyList } from 'react';
+/**
+ * Use the shallow compare of the dependencies
+ *
+ * @param dependencies - The dependencies to compare.
+ * @returns The signal of the dependencies.
+ */
+export declare function useShallowCompare(dependencies?: DependencyList): readonly [number];

package/dist/types/use-shallow-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the shallow effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useShallowEffect(effect: EffectCallback, dependencies?: DependencyList): void;

package/dist/types/use-shallow-isomorphic-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the shallow isomorphic effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useShallowIsomorphicEffect(effect: EffectCallback, dependencies?: DependencyList): void;

package/dist/types/use-shallow-layout-effect/index.d.ts

@@ -0,0 +1,9 @@
+import { DependencyList, EffectCallback } from 'react';
+/**
+ * Use the shallow layout effect of the effect
+ *
+ * @param effect - The effect to run.
+ * @param dependencies - The dependencies to compare.
+ * @returns The effect.
+ */
+export declare function useShallowLayoutEffect(effect: EffectCallback, dependencies?: DependencyList): void;