shelflife-react-hooks 1.0.19 → 1.0.20

package/package.json

@@ -1,36 +1,36 @@
-{
-  "name": "shelflife-react-hooks",
-  "version": "1.0.19",
-  "description": "",
-  "license": "ISC",
-  "author": "Preisler25",
-  "type": "module",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs.js"
-    }
-  },
-  "devDependencies": {
-    "@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": "^19.0.0"
-  }
-}
+{
+  "name": "shelflife-react-hooks",
+  "version": "1.0.20",
+  "description": "",
+  "license": "ISC",
+  "author": "Preisler25",
+  "type": "module",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
+    }
+  },
+  "devDependencies": {
+    "@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": "^19.0.0"
+  }
+}

package/src/context/AuthContext.tsx

@@ -1,161 +1,161 @@
-import React, {
-    createContext,
-    useCallback,
-    useContext,
-    useEffect,
-    useMemo,
-    useState
-} from 'react';
-
-import type {
-    ChangePasswordRequest,
-    LoginRequest,
-    SignupRequest,
-    TokenStorage,
-    User
-} from '../type/auth.js';
-import {
-    changePasswordRequest,
-    getMeRequest,
-    loginRequest,
-    logoutRequest,
-    signupRequest
-} from './api/authApi.js';
-import type { ChangeUserDataRequest } from '../type/requests.js';
-import { updateUserRequest } from './api/userApi.js';
-
-export type AuthContextValue = {
-    token: string | null;
-    user: User | null;
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | null;
-    login: (dto: LoginRequest) => Promise<void>;
-    signup: (dto: SignupRequest) => Promise<User>;
-    changeMe: (dto: ChangeUserDataRequest) => Promise<User>;
-    changePassword: (dto: ChangePasswordRequest) => Promise<void>;
-    getMe: () => Promise<User | null>;
-    logout: () => Promise<void>;
-    getToken: () => string | null;
-};
-
-type AuthProviderProps = {
-    baseUrl: string;
-    children: React.ReactNode;
-    initialToken?: string | null;
-    tokenStorage?: TokenStorage;
-    storageKey?: string;
-};
-
-const AuthContext = createContext<AuthContextValue | undefined>(undefined);
-
-export const AuthProvider = ({
-    baseUrl,
-    children,
-    initialToken = null,
-    tokenStorage,
-    storageKey = 'auth_token'
-}: AuthProviderProps) => {
-    const [token, setTokenState] = useState<string | null>(initialToken);
-    const [user, setUser] = useState<User | null>(null);
-    const [isLoading, setIsLoading] = useState(true);
-    const [isError, setIsError] = useState(false);
-    const [error, setError] = useState<Error | null>(null);
-
-    // Load token from storage on mount
-    useEffect(() => {
-        if (tokenStorage && !initialToken) {
-            const loadToken = async () => {
-                try {
-                    const storedToken = await tokenStorage.getItem(storageKey);
-                    if (storedToken) {
-                        setTokenState(storedToken);
-                    }
-                } catch (err) {
-                    console.error('Failed to load token from storage:', err);
-                }
-            };
-            loadToken();
-        }
-    }, [tokenStorage, storageKey, initialToken]);
-
-    // Wrap setToken to persist to storage
-    const setToken = useCallback(async (newToken: string | null) => {
-        setTokenState(newToken);
-        if (tokenStorage) {
-            try {
-                if (newToken) {
-                    await tokenStorage.setItem(storageKey, newToken);
-                } else {
-                    await tokenStorage.removeItem(storageKey);
-                }
-            } catch (err) {
-                console.error('Failed to persist token to storage:', err);
-            }
-        }
-    }, [tokenStorage, storageKey]);
-
-    const getToken = useCallback(() => token, [token]);
-
-    const apiConfig = useMemo(() => ({
-        baseUrl,
-        token,
-        setToken,
-        setUser,
-        setIsLoading,
-        setIsError,
-        setError
-    }), [baseUrl, token]);
-
-    const login = useCallback((dto: LoginRequest) => loginRequest(apiConfig, dto), [apiConfig]);
-    const signup = useCallback((dto: SignupRequest) => signupRequest(apiConfig, dto), [apiConfig]);
-    const changeMe = useCallback(
-        (dto: ChangeUserDataRequest) => updateUserRequest({ ...apiConfig, setUsers: () => { }, setUser }, user!.id, dto),
-        [apiConfig, user]
-    )
-    const changePassword = useCallback(
-        (dto: ChangePasswordRequest) => changePasswordRequest(apiConfig, dto),
-        [apiConfig]
-    );
-    const getMe = useCallback(() => getMeRequest(apiConfig), [apiConfig]);
-    const logout = useCallback(() => logoutRequest(apiConfig), [apiConfig]);
-
-    const value = useMemo<AuthContextValue>(() => ({
-        token,
-        user,
-        isLoading,
-        isError,
-        error,
-        login,
-        signup,
-        changeMe,
-        changePassword,
-        getMe,
-        logout,
-        getToken
-    }), [
-        changeMe,
-        changePassword,
-        error,
-        getMe,
-        getToken,
-        isError,
-        isLoading,
-        login,
-        logout,
-        signup,
-        token,
-        user
-    ]);
-
-    return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
-};
-
-export const useAuth = (): AuthContextValue => {
-    const context = useContext(AuthContext);
-    if (!context) {
-        throw new Error('useAuth must be used within an AuthProvider');
-    }
-
-    return context;
-};
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useEffect,
+    useMemo,
+    useState
+} from 'react';
+
+import type {
+    ChangePasswordRequest,
+    LoginRequest,
+    SignupRequest,
+    TokenStorage,
+    User
+} from '../type/auth.js';
+import {
+    changePasswordRequest,
+    getMeRequest,
+    loginRequest,
+    logoutRequest,
+    signupRequest
+} from './api/authApi.js';
+import type { ChangeUserDataRequest } from '../type/requests.js';
+import { updateUserRequest } from './api/userApi.js';
+
+export type AuthContextValue = {
+    token: string | null;
+    user: User | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    login: (dto: LoginRequest) => Promise<void>;
+    signup: (dto: SignupRequest) => Promise<User>;
+    changeMe: (dto: ChangeUserDataRequest) => Promise<User>;
+    changePassword: (dto: ChangePasswordRequest) => Promise<void>;
+    getMe: () => Promise<User | null>;
+    logout: () => Promise<void>;
+    getToken: () => string | null;
+};
+
+type AuthProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+    initialToken?: string | null;
+    tokenStorage?: TokenStorage;
+    storageKey?: string;
+};
+
+const AuthContext = createContext<AuthContextValue | undefined>(undefined);
+
+export const AuthProvider = ({
+    baseUrl,
+    children,
+    initialToken = null,
+    tokenStorage,
+    storageKey = 'auth_token'
+}: AuthProviderProps) => {
+    const [token, setTokenState] = useState<string | null>(initialToken);
+    const [user, setUser] = useState<User | null>(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    // Load token from storage on mount
+    useEffect(() => {
+        if (tokenStorage && !initialToken) {
+            const loadToken = async () => {
+                try {
+                    const storedToken = await tokenStorage.getItem(storageKey);
+                    if (storedToken) {
+                        setTokenState(storedToken);
+                    }
+                } catch (err) {
+                    console.error('Failed to load token from storage:', err);
+                }
+            };
+            loadToken();
+        }
+    }, [tokenStorage, storageKey, initialToken]);
+
+    // Wrap setToken to persist to storage
+    const setToken = useCallback(async (newToken: string | null) => {
+        setTokenState(newToken);
+        if (tokenStorage) {
+            try {
+                if (newToken) {
+                    await tokenStorage.setItem(storageKey, newToken);
+                } else {
+                    await tokenStorage.removeItem(storageKey);
+                }
+            } catch (err) {
+                console.error('Failed to persist token to storage:', err);
+            }
+        }
+    }, [tokenStorage, storageKey]);
+
+    const getToken = useCallback(() => token, [token]);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setToken,
+        setUser,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const login = useCallback((dto: LoginRequest) => loginRequest(apiConfig, dto), [apiConfig]);
+    const signup = useCallback((dto: SignupRequest) => signupRequest(apiConfig, dto), [apiConfig]);
+    const changeMe = useCallback(
+        (dto: ChangeUserDataRequest) => updateUserRequest({ ...apiConfig, setUsers: () => { }, setUser }, user!.id, dto),
+        [apiConfig, user]
+    )
+    const changePassword = useCallback(
+        (dto: ChangePasswordRequest) => changePasswordRequest(apiConfig, dto),
+        [apiConfig]
+    );
+    const getMe = useCallback(() => getMeRequest(apiConfig), [apiConfig]);
+    const logout = useCallback(() => logoutRequest(apiConfig), [apiConfig]);
+
+    const value = useMemo<AuthContextValue>(() => ({
+        token,
+        user,
+        isLoading,
+        isError,
+        error,
+        login,
+        signup,
+        changeMe,
+        changePassword,
+        getMe,
+        logout,
+        getToken
+    }), [
+        changeMe,
+        changePassword,
+        error,
+        getMe,
+        getToken,
+        isError,
+        isLoading,
+        login,
+        logout,
+        signup,
+        token,
+        user
+    ]);
+
+    return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+};
+
+export const useAuth = (): AuthContextValue => {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+
+    return context;
+};

package/src/context/InviteContext.tsx

@@ -1,74 +1,74 @@
-import React, {
-    createContext,
-    useCallback,
-    useContext,
-    useMemo,
-    useState
-} from 'react';
-
-import type { StorageMember } from '../type/models.js';
-import { useAuth } from './AuthContext.js';
-import {
-    acceptInviteRequest,
-    declineInviteRequest,
-    fetchInvitesRequest
-} from './api/inviteApi.js';
-
-type InviteContextValue = {
-    invites: StorageMember[];
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | null;
-    fetchInvites: () => Promise<StorageMember[]>;
-    acceptInvite: (id: number) => Promise<void>;
-    declineInvite: (id: number) => Promise<void>;
-};
-
-type InviteProviderProps = {
-    baseUrl: string;
-    children: React.ReactNode;
-};
-
-const InviteContext = createContext<InviteContextValue | undefined>(undefined);
-
-export const InviteProvider = ({ baseUrl, children }: InviteProviderProps) => {
-    const { token } = useAuth();
-    const [invites, setInvites] = useState<StorageMember[]>([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [isError, setIsError] = useState(false);
-    const [error, setError] = useState<Error | null>(null);
-
-    const apiConfig = useMemo(() => ({
-        baseUrl,
-        token,
-        setInvites,
-        setIsLoading,
-        setIsError,
-        setError
-    }), [baseUrl, token]);
-
-    const fetchInvites = useCallback(() => fetchInvitesRequest(apiConfig), [apiConfig]);
-    const acceptInvite = useCallback((id: number) => acceptInviteRequest(apiConfig, id), [apiConfig]);
-    const declineInvite = useCallback((id: number) => declineInviteRequest(apiConfig, id), [apiConfig]);
-
-    const value = useMemo<InviteContextValue>(() => ({
-        invites,
-        isLoading,
-        isError,
-        error,
-        fetchInvites,
-        acceptInvite,
-        declineInvite
-    }), [acceptInvite, declineInvite, error, fetchInvites, isError, isLoading, invites]);
-
-    return <InviteContext.Provider value={value}>{children}</InviteContext.Provider>;
-};
-
-export const useInvites = (): InviteContextValue => {
-    const context = useContext(InviteContext);
-    if (!context) {
-        throw new Error('useInvites must be used within an InviteProvider');
-    }
-
-    return context;
-};
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { StorageMember } from '../type/models.js';
+import { useAuth } from './AuthContext.js';
+import {
+    acceptInviteRequest,
+    declineInviteRequest,
+    fetchInvitesRequest
+} from './api/inviteApi.js';
+
+type InviteContextValue = {
+    invites: StorageMember[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchInvites: () => Promise<StorageMember[]>;
+    acceptInvite: (id: number) => Promise<void>;
+    declineInvite: (id: number) => Promise<void>;
+};
+
+type InviteProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const InviteContext = createContext<InviteContextValue | undefined>(undefined);
+
+export const InviteProvider = ({ baseUrl, children }: InviteProviderProps) => {
+    const { token } = useAuth();
+    const [invites, setInvites] = useState<StorageMember[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setInvites,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchInvites = useCallback(() => fetchInvitesRequest(apiConfig), [apiConfig]);
+    const acceptInvite = useCallback((id: number) => acceptInviteRequest(apiConfig, id), [apiConfig]);
+    const declineInvite = useCallback((id: number) => declineInviteRequest(apiConfig, id), [apiConfig]);
+
+    const value = useMemo<InviteContextValue>(() => ({
+        invites,
+        isLoading,
+        isError,
+        error,
+        fetchInvites,
+        acceptInvite,
+        declineInvite
+    }), [acceptInvite, declineInvite, error, fetchInvites, isError, isLoading, invites]);
+
+    return <InviteContext.Provider value={value}>{children}</InviteContext.Provider>;
+};
+
+export const useInvites = (): InviteContextValue => {
+    const context = useContext(InviteContext);
+    if (!context) {
+        throw new Error('useInvites must be used within an InviteProvider');
+    }
+
+    return context;
+};