shelflife-react-hooks 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shelflife-react-hooks",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "license": "ISC",
   "author": "Preisler25",
@@ -14,20 +14,23 @@
   },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.esm.js",
       "require": "./dist/index.cjs.js"
     }
   },
   "devDependencies": {
-    "@types/react": "^18.3.12",
-    "@types/react-test-renderer": "^18.3.1",
-    "react-test-renderer": "^18.3.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^25.2.3",
+    "@types/react": "^19.0.0",
+    "jsdom": "^28.1.0",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^2.1.9"
   },
   "peerDependencies": {
-    "react": "^18.0.0"
+    "react": "^19.0.0"
   }
 }

package/src/context/__tests__/contexts.test.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect } from 'react';
-import TestRenderer, { act } from 'react-test-renderer';
+import { render, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 
 import {
@@ -83,14 +83,16 @@ describe('AuthContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useAuth> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl}>
-                    <AuthProbe onReady={(value) => {
-                        ctxRef.current = value;
-                    }} />
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl}>
+                <AuthProbe onReady={(value) => {
+                    ctxRef.current = value;
+                }} />
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -98,12 +100,12 @@ describe('AuthContext', () => {
             throw new Error('Auth context not ready');
         }
 
-        await act(async () => {
-            await ctx.login({ email: 'user@example.com', password: 'pass' });
-        });
+        await ctx.login({ email: 'user@example.com', password: 'pass' });
 
-        expect(ctxRef.current?.token).toBe('token-123');
-        expect(ctxRef.current?.user).toEqual({ id: 1, username: 'jane', admin: false });
+        await waitFor(() => {
+            expect(ctxRef.current?.token).toBe('token-123');
+            expect(ctxRef.current?.user).toEqual({ id: 1, username: 'jane', admin: false });
+        });
     });
 });
 
@@ -117,14 +119,16 @@ describe('InviteContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useInvites> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <InviteProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useInvites} onReady={(value) => { ctxRef.current = value; }} />
-                    </InviteProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <InviteProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useInvites} onReady={(value) => { ctxRef.current = value; }} />
+                </InviteProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -132,11 +136,11 @@ describe('InviteContext', () => {
             throw new Error('Invite context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchInvites();
-        });
+        await ctx.fetchInvites();
 
-        expect(ctxRef.current?.invites).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.invites).toHaveLength(1);
+        });
     });
 });
 
@@ -150,14 +154,16 @@ describe('ProductContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useProducts> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <ProductProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useProducts} onReady={(value) => { ctxRef.current = value; }} />
-                    </ProductProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <ProductProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useProducts} onReady={(value) => { ctxRef.current = value; }} />
+                </ProductProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -165,11 +171,11 @@ describe('ProductContext', () => {
             throw new Error('Product context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchProducts();
-        });
+        await ctx.fetchProducts();
 
-        expect(ctxRef.current?.products).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.products).toHaveLength(1);
+        });
     });
 });
 
@@ -188,14 +194,16 @@ describe('RunningLowContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useRunningLow> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <RunningLowProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useRunningLow} onReady={(value) => { ctxRef.current = value; }} />
-                    </RunningLowProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <RunningLowProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useRunningLow} onReady={(value) => { ctxRef.current = value; }} />
+                </RunningLowProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -203,11 +211,11 @@ describe('RunningLowContext', () => {
             throw new Error('Running low context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchSettings(1);
-        });
+        await ctx.fetchSettings(1);
 
-        expect(ctxRef.current?.settings).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.settings).toHaveLength(1);
+        });
     });
 });
 
@@ -221,14 +229,16 @@ describe('StorageContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useStorages> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <StorageProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useStorages} onReady={(value) => { ctxRef.current = value; }} />
-                    </StorageProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <StorageProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useStorages} onReady={(value) => { ctxRef.current = value; }} />
+                </StorageProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -236,11 +246,11 @@ describe('StorageContext', () => {
             throw new Error('Storage context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchStorages();
-        });
+        await ctx.fetchStorages();
 
-        expect(ctxRef.current?.storages).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.storages).toHaveLength(1);
+        });
     });
 });
 
@@ -259,14 +269,16 @@ describe('StorageItemContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useStorageItems> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <StorageItemProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useStorageItems} onReady={(value) => { ctxRef.current = value; }} />
-                    </StorageItemProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <StorageItemProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useStorageItems} onReady={(value) => { ctxRef.current = value; }} />
+                </StorageItemProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -274,11 +286,11 @@ describe('StorageItemContext', () => {
             throw new Error('Storage item context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchItems(1);
-        });
+        await ctx.fetchItems(1);
 
-        expect(ctxRef.current?.items).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.items).toHaveLength(1);
+        });
     });
 });
 
@@ -297,14 +309,16 @@ describe('StorageMemberContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useStorageMembers> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <StorageMemberProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useStorageMembers} onReady={(value) => { ctxRef.current = value; }} />
-                    </StorageMemberProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <StorageMemberProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useStorageMembers} onReady={(value) => { ctxRef.current = value; }} />
+                </StorageMemberProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -312,11 +326,11 @@ describe('StorageMemberContext', () => {
             throw new Error('Storage member context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchMembers(1);
-        });
+        await ctx.fetchMembers(1);
 
-        expect(ctxRef.current?.members).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.members).toHaveLength(1);
+        });
     });
 });
 
@@ -330,14 +344,16 @@ describe('UserContext', () => {
 
         const ctxRef: { current?: ReturnType<typeof useUsers> } = {};
 
-        await act(async () => {
-            TestRenderer.create(
-                <AuthProvider baseUrl={baseUrl} initialToken="token">
-                    <UserProvider baseUrl={baseUrl}>
-                        <ProviderProbe useHook={useUsers} onReady={(value) => { ctxRef.current = value; }} />
-                    </UserProvider>
-                </AuthProvider>
-            );
+        render(
+            <AuthProvider baseUrl={baseUrl} initialToken="token">
+                <UserProvider baseUrl={baseUrl}>
+                    <ProviderProbe useHook={useUsers} onReady={(value) => { ctxRef.current = value; }} />
+                </UserProvider>
+            </AuthProvider>
+        );
+
+        await waitFor(() => {
+            expect(ctxRef.current).toBeDefined();
         });
 
         const ctx = ctxRef.current;
@@ -345,10 +361,10 @@ describe('UserContext', () => {
             throw new Error('User context not ready');
         }
 
-        await act(async () => {
-            await ctx.fetchUsers();
-        });
+        await ctx.fetchUsers();
 
-        expect(ctxRef.current?.users).toHaveLength(1);
+        await waitFor(() => {
+            expect(ctxRef.current?.users).toHaveLength(1);
+        });
     });
 });

package/vitest.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
     test: {
-        environment: 'node',
+        environment: 'jsdom',
         globals: true
     }
 });