@availity/hooks 5.2.0 → 6.0.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+# [6.0.0](https://github.com/Availity/availity-react/compare/@availity/hooks@5.2.0...@availity/hooks@6.0.0) (2026-06-12)
+
+
+* feat(hooks)!: migrate to ESM exports, vitest, and @tanstack/react-query v5 ([bab37b2](https://github.com/Availity/availity-react/commit/bab37b24f60ec88f7ade5bb23510053dae03ca38))
+
+
+### BREAKING CHANGES
+
+* Package now uses ESM exports field and requires @tanstack/react-query ^5.
+The useQuery API now uses object syntax. Status 'loading' is renamed to 'pending'.
+
+
+
 # [5.2.0](https://github.com/Availity/availity-react/compare/@availity/hooks@5.1.11...@availity/hooks@5.2.0) (2026-06-09)
 
 

package/dist/index.d.ts

@@ -0,0 +1,208 @@
+import { DependencyList, EffectCallback } from 'react';
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * @deprecated useEffectAsync is an anti-pattern. Use useEffect with an IIFE or extract async logic into a separate function instead.
+ */
+declare function useEffectAsync(effect: () => void, inputs?: DependencyList): void;
+
+declare function useMount(effect: EffectCallback): void;
+
+declare function useTimeout(ms?: number): boolean;
+
+declare function useToggle(initialState?: boolean): [boolean, (state?: boolean) => void];
+
+interface CurrentRegion {
+    code: string;
+    value: string;
+}
+declare function useCurrentRegion(options?: Omit<UseQueryOptions<CurrentRegion, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<CurrentRegion, unknown>;
+
+interface CurrentUser {
+    akaname: string;
+    createDate: string;
+    currentRegion: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    id: string;
+    jobTitle: string;
+    userHasSecurityException: boolean;
+    userId: string;
+    userValidated: boolean;
+}
+declare function useCurrentUser(options?: Omit<UseQueryOptions<CurrentUser, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<CurrentUser, unknown>;
+
+interface AriesHookBase {
+    data: {
+        totalCount: number;
+        count: number;
+        offSet: number;
+        links: {
+            next: {
+                href: string;
+            };
+            last: {
+                href: string;
+            };
+            self: {
+                href: string;
+            };
+        };
+    };
+}
+
+interface ProvidersResponse extends AriesHookBase {
+    data: AriesHookBase['data'] & {
+        providers: {
+            id: string;
+            lastName: string;
+            firstName: string;
+            middleName: string;
+            uiDisplayName: string;
+            atypical: boolean;
+            npi: string;
+            customerIds: string[];
+            roles: {
+                code: string;
+                value: string;
+            }[];
+            primarySpecialty: {
+                code: string;
+                value: string;
+            };
+            primaryFax: {
+                internationalCellularCode: string;
+                areaCode: string;
+                phoneNumber: string;
+            };
+            primaryAddress: {
+                line1: string;
+                line2: string;
+                city: string;
+                state: string;
+                stateCode: string;
+                zip: {
+                    code: string;
+                    addon: string;
+                };
+            };
+        }[];
+    };
+}
+interface AvProvidersConfig {
+    customerId: string;
+    [key: string]: unknown;
+}
+declare function useProviders(config: AvProvidersConfig, options?: Omit<UseQueryOptions<ProvidersResponse, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<ProvidersResponse, unknown>;
+
+interface PermissionsResponse extends AriesHookBase {
+    data: AriesHookBase['data'] & {
+        permissions: {
+            id: string;
+            description: string;
+            links: {
+                self: {
+                    href: string;
+                };
+            };
+        }[];
+    };
+}
+declare function usePermissions(config: string | string[], options?: Omit<UseQueryOptions<PermissionsResponse, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<PermissionsResponse, unknown>;
+
+interface Organization {
+    links: {
+        permissions: {
+            href: string;
+        };
+        patients: {
+            href: string;
+        };
+        self: {
+            href: string;
+        };
+        admin: {
+            href: string;
+        };
+        businessArrangements: {
+            href: string;
+        };
+        users: {
+            href: string;
+        };
+    };
+    id: string;
+    customerId: string;
+    name: string;
+    status: string;
+    statusCode: string;
+    types: {
+        code: string;
+        value: string;
+    }[];
+    primaryControllingAuthority: {
+        lastName: string;
+        firstName: string;
+        primaryPhone: string;
+        email: string;
+    };
+    physicalAddress: {
+        line1: string;
+        city: string;
+        state: string;
+        stateCode: string;
+        zipCode: string;
+    };
+    mailingAddress: {
+        line1: string;
+        city: string;
+        state: string;
+        stateCode: string;
+        zipCode: string;
+    };
+    billingAddress: {
+        line1: string;
+        city: string;
+        state: string;
+        stateCode: string;
+        zipCode: string;
+    };
+    regions: {
+        code: string;
+        value: string;
+    }[];
+    npis: {
+        number: string;
+    }[];
+    taxIds: {
+        number: string;
+        type: string;
+    }[];
+    phoneNumber: {
+        areaCode: string;
+        exchange: string;
+        phoneNumber: string;
+    };
+    numberOfLicensedPhysicians: string;
+    numberOfLicensedClinicians: string;
+}
+interface OrganizationsResponse extends AriesHookBase {
+    data: AriesHookBase['data'] & {
+        organizations: Organization[];
+    };
+}
+declare function useOrganizations(config: Record<string, unknown>, options?: Omit<UseQueryOptions<OrganizationsResponse, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<OrganizationsResponse, unknown>;
+
+declare const useUpdateNav: () => void;
+
+interface Dimensions {
+    width: number;
+    height: number;
+}
+declare function useWindowDimensions(): Dimensions;
+
+type StashData = Record<string, unknown>;
+declare function useStash(sessionId: string, options?: Omit<UseQueryOptions<StashData, unknown>, 'queryKey' | 'queryFn'>): UseQueryResult<StashData, unknown>;
+
+export { type AriesHookBase, type AvProvidersConfig, type CurrentRegion, type CurrentUser, type Dimensions, type Organization, type OrganizationsResponse, type PermissionsResponse, type ProvidersResponse, useCurrentRegion, useCurrentUser, useEffectAsync, useMount, useOrganizations, usePermissions, useProviders, useStash, useTimeout, useToggle, useUpdateNav, useWindowDimensions };

package/dist/index.js

@@ -0,0 +1,156 @@
+// src/useEffectAsync.ts
+import { useEffect } from "react";
+function useEffectAsync(effect, inputs) {
+  useEffect(() => {
+    effect();
+  }, inputs);
+}
+
+// src/useMount.ts
+import { useEffect as useEffect2 } from "react";
+function useMount(effect) {
+  useEffect2(effect, []);
+}
+
+// src/useTimeout.ts
+import { useEffect as useEffect3, useState } from "react";
+function useTimeout(ms = 0) {
+  const [ready, setReady] = useState(false);
+  useEffect3(() => {
+    let unmounted = false;
+    const timer = setTimeout(() => {
+      if (!unmounted) {
+        setReady(true);
+      }
+    }, ms);
+    return () => {
+      unmounted = true;
+      clearTimeout(timer);
+    };
+  }, [ms]);
+  return ready;
+}
+
+// src/useToggle.ts
+import { useState as useState2 } from "react";
+function useToggle(initialState = false) {
+  const [state, setState] = useState2(initialState);
+  const toggle = (newState) => {
+    if (newState !== void 0 && newState !== state) {
+      setState(newState);
+    } else if (newState === void 0) {
+      setState(!state);
+    }
+  };
+  return [state, toggle];
+}
+
+// src/useCurrentRegion.ts
+import { useQuery } from "@tanstack/react-query";
+import { avRegionsApi } from "@availity/api-axios";
+async function fetchRegion() {
+  const response = await avRegionsApi.getCurrentRegion();
+  const data = response?.data;
+  return {
+    code: data?.regions?.[0]?.id || "",
+    value: data?.regions?.[0]?.value || ""
+  };
+}
+function useCurrentRegion(options) {
+  return useQuery({ queryKey: ["region"], queryFn: fetchRegion, ...options });
+}
+
+// src/useCurrentUser.ts
+import { avUserApi } from "@availity/api-axios";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+var fetchUser = async () => avUserApi.me();
+function useCurrentUser(options) {
+  return useQuery2({ queryKey: ["user"], queryFn: fetchUser, ...options });
+}
+
+// src/useProviders.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { avProvidersApi } from "@availity/api-axios";
+var fetchProviders = async (config) => avProvidersApi.getProviders(config.customerId, config);
+function useProviders(config, options) {
+  return useQuery3({ queryKey: ["providers", config], queryFn: () => fetchProviders(config), ...options });
+}
+
+// src/usePermissions.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+import { avPermissionsApi } from "@availity/api-axios";
+var fetchPermissions = async (config) => avPermissionsApi.getPermissions(config);
+function usePermissions(config, options) {
+  return useQuery4({ queryKey: ["permissions", config], queryFn: () => fetchPermissions(config), ...options });
+}
+
+// src/useOrganizations.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+import { avOrganizationsApi } from "@availity/api-axios";
+var fetchOrganization = async (config) => avOrganizationsApi.getOrganizations(config);
+function useOrganizations(config, options) {
+  return useQuery5({ queryKey: ["organizations", config], queryFn: () => fetchOrganization(config), ...options });
+}
+
+// src/useUpdateNav.ts
+import { useEffect as useEffect4 } from "react";
+import { useLocation } from "react-router-dom";
+import avMessage from "@availity/message-core";
+var useUpdateNav = () => {
+  const location = useLocation();
+  useEffect4(() => {
+    try {
+      avMessage.send({ event: "navChange", url: window.location.href });
+    } catch {
+    }
+  }, [location]);
+};
+var useUpdateNav_default = useUpdateNav;
+
+// src/useWindowDimensions.ts
+import { useEffect as useEffect5, useState as useState3 } from "react";
+var getWindowDimensions = () => {
+  const { innerWidth: width, innerHeight: height } = window;
+  return { width, height };
+};
+function useWindowDimensions() {
+  const [windowDimensions, setWindowDimensions] = useState3(getWindowDimensions());
+  useEffect5(() => {
+    const handleResize = () => {
+      setWindowDimensions(getWindowDimensions());
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return windowDimensions;
+}
+
+// src/useStash.ts
+import { avStashApi } from "@availity/api-axios";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+var fetchStash = async (sessionId) => {
+  const response = await avStashApi.get(sessionId);
+  return response?.data;
+};
+function useStash(sessionId, options) {
+  return useQuery6({
+    queryKey: ["stash", sessionId],
+    queryFn: () => fetchStash(sessionId),
+    enabled: !!sessionId,
+    ...options
+  });
+}
+export {
+  useCurrentRegion,
+  useCurrentUser,
+  useEffectAsync,
+  useMount,
+  useOrganizations,
+  usePermissions,
+  useProviders,
+  useStash,
+  useTimeout,
+  useToggle,
+  useUpdateNav_default as useUpdateNav,
+  useWindowDimensions
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@availity/hooks",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "description": "A group of pre-built hooks that are common in most apps",
   "keywords": [
     "react",
@@ -17,33 +17,43 @@
     "directory": "packages/hooks"
   },
   "license": "MIT",
+  "type": "module",
   "author": "Kyle Gray <kyle.gray@availity.com>",
-  "main": "index.js",
-  "types": "index.d.ts",
   "scripts": {
     "publish": "yarn npm publish --tolerate-republish --access public",
-    "publish:canary": "yarn npm publish --access public --tag canary"
-  },
-  "dependencies": {
-    "@tanstack/react-query": "^4.36.1",
-    "prop-types": "^15.8.1"
+    "publish:canary": "yarn npm publish --access public --tag canary",
+    "build": "tsup src/index.ts --format esm --clean --dts",
+    "dev": "tsup src/index.ts --format esm --watch --dts",
+    "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "@availity/api-axios": "^12.3.1",
-    "@availity/message-core": "^8.0.2",
-    "axios": "^1.13.2",
+    "@availity/api-axios": "^13.0.2",
+    "@availity/message-core": "^9.0.2",
+    "@tanstack/react-query": "^5.75.5",
+    "axios": "^1.17.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-router-dom": "^6.30.0"
+    "react-router-dom": "^6.30.4",
+    "tsup": "^8.5.1"
   },
   "peerDependencies": {
-    "@availity/api-axios": "^12.0.0",
-    "@availity/message-core": "^8.0.2",
+    "@availity/api-axios": "^12.0.0 || ^13.0.0",
+    "@availity/message-core": "^8.0.2 || ^9.0.2",
+    "@tanstack/react-query": "^5.75.5",
     "axios": "^1.13.2",
-    "react": "^18.0.0",
+    "react": "^18.0.0 || ^19.0.0",
     "react-router-dom": "^6.26.0"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
   }
 }

package/project.json

@@ -4,10 +4,15 @@
   "projectType": "library",
   "targets": {
     "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/hooks"],
+      "executor": "nx:run-commands",
       "options": {
-        "jestConfig": "packages/hooks/jest.config.js"
+        "command": "vitest run --project=hooks",
+        "cwd": "."
+      },
+      "configurations": {
+        "ci": {
+          "command": "vitest run --project=hooks --coverage"
+        }
       }
     },
     "version": {
@@ -33,6 +38,12 @@
         "hasTypeAwareRules": true,
         "cacheStrategy": "metadata"
       }
+    },
+    "build": {
+      "command": "tsup src/index.ts --format esm --dts",
+      "options": {
+        "cwd": "packages/hooks"
+      }
     }
   }
 }

package/src/index.ts

@@ -0,0 +1,20 @@
+export { default as useEffectAsync } from './useEffectAsync';
+export { default as useMount } from './useMount';
+export { default as useTimeout } from './useTimeout';
+export { default as useToggle } from './useToggle';
+export { default as useCurrentRegion } from './useCurrentRegion';
+export { default as useCurrentUser } from './useCurrentUser';
+export { default as useProviders } from './useProviders';
+export { default as usePermissions } from './usePermissions';
+export { default as useOrganizations } from './useOrganizations';
+export { default as useUpdateNav } from './useUpdateNav';
+export { default as useWindowDimensions } from './useWindowDimensions';
+export { default as useStash } from './useStash';
+
+export type { CurrentRegion } from './useCurrentRegion';
+export type { CurrentUser } from './useCurrentUser';
+export type { Dimensions } from './useWindowDimensions';
+export type { OrganizationsResponse, Organization } from './useOrganizations';
+export type { PermissionsResponse } from './usePermissions';
+export type { ProvidersResponse, AvProvidersConfig } from './useProviders';
+export type { AriesHookBase } from './types';

package/src/useCurrentRegion.ts

@@ -0,0 +1,23 @@
+import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { avRegionsApi } from '@availity/api-axios';
+
+export interface CurrentRegion {
+  code: string;
+  value: string;
+}
+
+async function fetchRegion(): Promise<CurrentRegion> {
+  const response = await avRegionsApi.getCurrentRegion();
+  const data = response?.data as { regions?: { id?: string; value?: string }[] };
+
+  return {
+    code: data?.regions?.[0]?.id || '',
+    value: data?.regions?.[0]?.value || '',
+  };
+}
+
+export default function useCurrentRegion(
+  options?: Omit<UseQueryOptions<CurrentRegion, unknown>, 'queryKey' | 'queryFn'>
+): UseQueryResult<CurrentRegion, unknown> {
+  return useQuery({ queryKey: ['region'], queryFn: fetchRegion, ...options });
+}

package/src/useCurrentUser.ts

@@ -0,0 +1,24 @@
+import { avUserApi } from '@availity/api-axios';
+import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+
+export interface CurrentUser {
+  akaname: string;
+  createDate: string;
+  currentRegion: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  id: string;
+  jobTitle: string;
+  userHasSecurityException: boolean;
+  userId: string;
+  userValidated: boolean;
+}
+
+const fetchUser = async () => avUserApi.me() as unknown as CurrentUser;
+
+export default function useCurrentUser(
+  options?: Omit<UseQueryOptions<CurrentUser, unknown>, 'queryKey' | 'queryFn'>
+): UseQueryResult<CurrentUser, unknown> {
+  return useQuery({ queryKey: ['user'], queryFn: fetchUser, ...options });
+}

package/src/useEffectAsync.ts

@@ -0,0 +1,9 @@
+import { DependencyList, useEffect } from 'react';
+
+/**
+ * @deprecated useEffectAsync is an anti-pattern. Use useEffect with an IIFE or extract async logic into a separate function instead.
+ */
+export default function useEffectAsync(effect: () => void, inputs?: DependencyList): void {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(() => { effect(); }, inputs);
+}

package/src/useMount.ts

@@ -0,0 +1,6 @@
+import { EffectCallback, useEffect } from 'react';
+
+export default function useMount(effect: EffectCallback): void {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(effect, []);
+}

package/src/useOrganizations.ts

@@ -0,0 +1,73 @@
+import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { avOrganizationsApi } from '@availity/api-axios';
+import { AriesHookBase } from './types';
+
+export interface Organization {
+  links: {
+    permissions: { href: string };
+    patients: { href: string };
+    self: { href: string };
+    admin: { href: string };
+    businessArrangements: { href: string };
+    users: { href: string };
+  };
+  id: string;
+  customerId: string;
+  name: string;
+  status: string;
+  statusCode: string;
+  types: { code: string; value: string }[];
+  primaryControllingAuthority: {
+    lastName: string;
+    firstName: string;
+    primaryPhone: string;
+    email: string;
+  };
+  physicalAddress: {
+    line1: string;
+    city: string;
+    state: string;
+    stateCode: string;
+    zipCode: string;
+  };
+  mailingAddress: {
+    line1: string;
+    city: string;
+    state: string;
+    stateCode: string;
+    zipCode: string;
+  };
+  billingAddress: {
+    line1: string;
+    city: string;
+    state: string;
+    stateCode: string;
+    zipCode: string;
+  };
+  regions: { code: string; value: string }[];
+  npis: { number: string }[];
+  taxIds: { number: string; type: string }[];
+  phoneNumber: {
+    areaCode: string;
+    exchange: string;
+    phoneNumber: string;
+  };
+  numberOfLicensedPhysicians: string;
+  numberOfLicensedClinicians: string;
+}
+
+export interface OrganizationsResponse extends AriesHookBase {
+  data: AriesHookBase['data'] & {
+    organizations: Organization[];
+  };
+}
+
+const fetchOrganization = async (config: Record<string, unknown>) =>
+  avOrganizationsApi.getOrganizations(config) as unknown as OrganizationsResponse;
+
+export default function useOrganizations(
+  config: Record<string, unknown>,
+  options?: Omit<UseQueryOptions<OrganizationsResponse, unknown>, 'queryKey' | 'queryFn'>
+): UseQueryResult<OrganizationsResponse, unknown> {
+  return useQuery({ queryKey: ['organizations', config], queryFn: () => fetchOrganization(config), ...options });
+}

package/src/usePermissions.ts

@@ -0,0 +1,23 @@
+import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { avPermissionsApi } from '@availity/api-axios';
+import { AriesHookBase } from './types';
+
+export interface PermissionsResponse extends AriesHookBase {
+  data: AriesHookBase['data'] & {
+    permissions: {
+      id: string;
+      description: string;
+      links: { self: { href: string } };
+    }[];
+  };
+}
+
+const fetchPermissions = async (config: string | string[]) =>
+  avPermissionsApi.getPermissions(config) as unknown as PermissionsResponse;
+
+export default function usePermissions(
+  config: string | string[],
+  options?: Omit<UseQueryOptions<PermissionsResponse, unknown>, 'queryKey' | 'queryFn'>
+): UseQueryResult<PermissionsResponse, unknown> {
+  return useQuery({ queryKey: ['permissions', config], queryFn: () => fetchPermissions(config), ...options });
+}