@larisarozin/dodone-shared 1.0.0

package/dist/hooks/useAllowanceHistoryTaskItems.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAllowanceHistoryTaskItems = useAllowanceHistoryTaskItems;
+const react_1 = require("react");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useAllowanceHistoryTaskItems(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedAllowanceHistoryTaskItems, setPagedAllowanceHistoryTaskItems] = (0, react_1.useState)();
+    const [loadingAllowanceHistoryTaskItems, setLoadingAllowanceHistoryTaskItems] = (0, react_1.useState)(true);
+    const fetchAllowanceHistoryTaskItems = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoadingAllowanceHistoryTaskItems(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching allowance history task items");
+            setLoadingAllowanceHistoryTaskItems(false);
+            return;
+        }
+        setLoadingAllowanceHistoryTaskItems(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.allowanceHistories.getPagedTaskItemsList(requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch allowance history task items:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoadingAllowanceHistoryTaskItems(false);
+                return;
+            }
+            setPagedAllowanceHistoryTaskItems(data);
+        }
+        catch (err) {
+            console.error("Error fetching allowance history task items:", err);
+        }
+        finally {
+            setLoadingAllowanceHistoryTaskItems(false);
+        }
+    }), [token, baseUrl]);
+    function refreshAllowanceHistoryTaskItems(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchAllowanceHistoryTaskItems to avoid state timing issues
+        fetchAllowanceHistoryTaskItems(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchAllowanceHistoryTaskItems(pagedListRequest);
+        }
+    }, [fetchAllowanceHistoryTaskItems]);
+    return { pagedAllowanceHistoryTaskItems, loadingAllowanceHistoryTaskItems, refreshAllowanceHistoryTaskItems };
+}

package/dist/hooks/useGrades.d.ts

@@ -0,0 +1,5 @@
+import type { GradeResponse } from "../types/TaskItem";
+export declare function useGrades(): {
+    grades: GradeResponse[];
+    loading: boolean;
+};

package/dist/hooks/useGrades.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGrades = useGrades;
+const react_1 = require("react");
+const routes_1 = require("../api/routes");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useGrades() {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [grades, setGrades] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const fetchGrades = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.get(routes_1.API_ROUTES.grades.getList());
+            setGrades(data);
+        }
+        catch (error) {
+            console.error("Error fetching grades:", error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    (0, react_1.useEffect)(() => {
+        fetchGrades();
+    }, [fetchGrades]);
+    return { grades, loading };
+}

package/dist/hooks/useNotificationPreferences.d.ts

@@ -0,0 +1,9 @@
+import { UserNotificationPreferenceResponse, BulkNotificationPreferenceUpdateRequest, BulkNotificationPreferenceCreateRequest } from "../types/UserNotificationPreferences";
+export declare function useNotificationPreferences(): {
+    notificationPreferences: UserNotificationPreferenceResponse[] | null;
+    createUserNotificationPreferences: (request: BulkNotificationPreferenceCreateRequest) => Promise<import("..").DataResponse<UserNotificationPreferenceResponse[]> | null>;
+    updateUserNotificationPreferences: (request: BulkNotificationPreferenceUpdateRequest) => Promise<import("..").ResponseBase | null>;
+    getUserNotificationPreferences: () => Promise<UserNotificationPreferenceResponse[] | null>;
+    loadingNotificationPreferences: boolean;
+    updatingNotificationPreferences: boolean;
+};

package/dist/hooks/useNotificationPreferences.js

@@ -0,0 +1,107 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNotificationPreferences = useNotificationPreferences;
+const react_1 = require("react");
+const useConfig_1 = require("../config/useConfig");
+const useAuth_1 = require("./auth/useAuth");
+const ApiClient_1 = require("../utils/ApiClient");
+function useNotificationPreferences() {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [notificationPreferences, setNotificationPreferences] = (0, react_1.useState)(null);
+    const [loadingNotificationPreferences, setLoading] = (0, react_1.useState)(false);
+    const [updatingNotificationPreferences, setUpdating] = (0, react_1.useState)(false);
+    const getUserNotificationPreferences = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.notifications.getUserNotificationPreferences();
+            if (!response || response.success === false) {
+                console.error("Failed to fetch user notification preferences:", (response === null || response === void 0 ? void 0 : response.message) || "Unknown error");
+                return null;
+            }
+            setNotificationPreferences(response.data);
+            return response.data;
+        }
+        catch (error) {
+            console.error("Error fetching user notification preferences:", error);
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    const updateUserNotificationPreferences = (0, react_1.useCallback)((request) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setUpdating(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.notifications.updateUserNotificationPreferences(request);
+            if (!response || response.success === false) {
+                console.error("Failed to update user notification preferences:", (response === null || response === void 0 ? void 0 : response.message) || "Unknown error");
+                return null;
+            }
+            // Refresh the preferences after successful update
+            yield getUserNotificationPreferences();
+            return response;
+        }
+        catch (error) {
+            console.error("Error updating user notification preferences:", error);
+            return null;
+        }
+        finally {
+            setUpdating(false);
+        }
+    }), [token, baseUrl, getUserNotificationPreferences]);
+    const createUserNotificationPreferences = (0, react_1.useCallback)((request) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setUpdating(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.notifications.createUserNotificationPreferences(request);
+            if (!response || response.success === false) {
+                console.error("Failed to create user notification preferences:", (response === null || response === void 0 ? void 0 : response.message) || "Unknown error");
+                return null;
+            }
+            // Refresh the preferences after successful creation
+            yield getUserNotificationPreferences();
+            return response;
+        }
+        catch (error) {
+            console.error("Error creating user notification preferences:", error);
+            return null;
+        }
+        finally {
+            setUpdating(false);
+        }
+    }), [token, baseUrl, getUserNotificationPreferences]);
+    return {
+        notificationPreferences,
+        createUserNotificationPreferences,
+        updateUserNotificationPreferences,
+        getUserNotificationPreferences,
+        loadingNotificationPreferences,
+        updatingNotificationPreferences,
+    };
+}

package/dist/hooks/useTaskCategories.d.ts

@@ -0,0 +1,7 @@
+import type { TaskCategoryDetailsResponse } from "../types/TaskItem";
+import { PagedListRequest, PagedListResponse } from "../utils/paging";
+export declare function useTaskCategories(request: PagedListRequest): {
+    pagedTaskCategories: PagedListResponse<TaskCategoryDetailsResponse> | undefined;
+    loading: boolean;
+    refreshTaskCategories: (request: PagedListRequest) => void;
+};

package/dist/hooks/useTaskCategories.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskCategories = useTaskCategories;
+const react_1 = require("react");
+const routes_1 = require("../api/routes");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useTaskCategories(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedTaskCategories, setPagedTaskCategories] = (0, react_1.useState)();
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const fetchCategories = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoading(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching task categories");
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.getPagedListDetails(routes_1.API_ROUTES.taskCategories.getPagedListDetails(), requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch task categories:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoading(false);
+                return;
+            }
+            setPagedTaskCategories(data);
+        }
+        catch (error) {
+            console.error("Error fetching task categories:", error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTaskCategories(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchCategories to avoid state timing issues
+        fetchCategories(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchCategories(pagedListRequest);
+        }
+    }, [fetchCategories]);
+    return { pagedTaskCategories, loading, refreshTaskCategories };
+}

package/dist/hooks/useTaskComments.d.ts

@@ -0,0 +1,7 @@
+import type { TaskCommentResponse } from "../types/TaskItem";
+import { PagedTaskCommentListRequest, PagedTaskCommentListResponse } from "../utils/paging";
+export declare function useTaskComments(request: PagedTaskCommentListRequest): {
+    pagedTaskComments: PagedTaskCommentListResponse<TaskCommentResponse> | undefined;
+    loadingTaskComments: boolean;
+    refreshTaskComments: (request: PagedTaskCommentListRequest) => void;
+};

package/dist/hooks/useTaskComments.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskComments = useTaskComments;
+const react_1 = require("react");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useTaskComments(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedTaskComments, setPagedTaskComments] = (0, react_1.useState)();
+    const [loadingTaskComments, setLoadingTaskComments] = (0, react_1.useState)(true);
+    const fetchTaskComments = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoadingTaskComments(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching task items");
+            setLoadingTaskComments(false);
+            return;
+        }
+        setLoadingTaskComments(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.comments.getList(requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch task comments:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoadingTaskComments(false);
+                return;
+            }
+            setPagedTaskComments(data);
+        }
+        catch (err) {
+            console.error("Error fetching task comments:", err);
+        }
+        finally {
+            setLoadingTaskComments(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTaskComments(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchTaskComments to avoid state timing issues
+        fetchTaskComments(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchTaskComments(pagedListRequest);
+        }
+    }, [fetchTaskComments]);
+    return { pagedTaskComments, loadingTaskComments, refreshTaskComments };
+}

package/dist/hooks/useTaskGroups.d.ts

@@ -0,0 +1,7 @@
+import type { TaskGroupDetailsResponse } from "../types/TaskItem";
+import { PagedListRequest, PagedListResponse } from "../utils/paging";
+export declare function useTaskGroups(request: PagedListRequest): {
+    pagedTaskGroups: PagedListResponse<TaskGroupDetailsResponse> | undefined;
+    taskGroupsLoading: boolean;
+    refreshTaskGroups: (request: PagedListRequest) => void;
+};

package/dist/hooks/useTaskGroups.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskGroups = useTaskGroups;
+const react_1 = require("react");
+const routes_1 = require("../api/routes");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useTaskGroups(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedTaskGroups, setPagedTaskGroups] = (0, react_1.useState)();
+    const [taskGroupsLoading, setLoading] = (0, react_1.useState)(true);
+    const fetchGroups = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoading(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching task groups");
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.getPagedListDetails(routes_1.API_ROUTES.taskGroups.getPagedListDetails(), requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch task groups:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoading(false);
+                return;
+            }
+            setPagedTaskGroups(data);
+        }
+        catch (error) {
+            console.error("Error fetching task groups:", error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTaskGroups(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchGroups to avoid state timing issues
+        fetchGroups(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchGroups(pagedListRequest);
+        }
+    }, [fetchGroups]);
+    return { pagedTaskGroups, taskGroupsLoading, refreshTaskGroups };
+}

package/dist/hooks/useTaskItems.d.ts

@@ -0,0 +1,7 @@
+import type { TaskItemDetailsResponse } from "../types/TaskItem";
+import { PagedTaskItemListRequest, PagedTaskItemListResponse } from "../utils/paging";
+export declare function useTaskItems(request: PagedTaskItemListRequest): {
+    pagedTaskItems: PagedTaskItemListResponse<TaskItemDetailsResponse> | undefined;
+    loadingTaskItems: boolean;
+    refreshTaskItems: (request: PagedTaskItemListRequest) => void;
+};

package/dist/hooks/useTaskItems.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskItems = useTaskItems;
+const react_1 = require("react");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+// TODO: Add other task item API operations
+function useTaskItems(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedTaskItems, setPagedTaskItems] = (0, react_1.useState)();
+    const [loadingTaskItems, setLoadingTaskItems] = (0, react_1.useState)(true);
+    const fetchTaskItems = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoadingTaskItems(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching task items");
+            setLoadingTaskItems(false);
+            return;
+        }
+        setLoadingTaskItems(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.tasks.getPagedListDetails(requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch task items:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoadingTaskItems(false);
+                return;
+            }
+            setPagedTaskItems(data);
+        }
+        catch (error) {
+            console.error("Error fetching task items:", error);
+        }
+        finally {
+            setLoadingTaskItems(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTaskItems(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchTaskItems to avoid state timing issues
+        fetchTaskItems(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchTaskItems(pagedListRequest);
+        }
+    }, [fetchTaskItems]);
+    return { pagedTaskItems, loadingTaskItems, refreshTaskItems };
+}

package/dist/hooks/useTaskKinds.d.ts

@@ -0,0 +1,7 @@
+import type { TaskKindDetailsResponse } from "../types/TaskItem";
+import { PagedListRequest, PagedListResponse } from "../utils/paging";
+export declare function useTaskKinds(request: PagedListRequest): {
+    pagedTaskKinds: PagedListResponse<TaskKindDetailsResponse> | undefined;
+    loading: boolean;
+    refreshTaskKinds: (request: PagedListRequest) => void;
+};

package/dist/hooks/useTaskKinds.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskKinds = useTaskKinds;
+const react_1 = require("react");
+const routes_1 = require("../api/routes");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useTaskKinds(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedTaskKinds, setPagedTaskKinds] = (0, react_1.useState)();
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const fetchKinds = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoading(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching task kinds");
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.getPagedListDetails(routes_1.API_ROUTES.taskKinds.getPagedListDetails(), requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch task kinds:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoading(false);
+                return;
+            }
+            setPagedTaskKinds(data);
+        }
+        catch (error) {
+            console.error("Error fetching task kinds:", error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTaskKinds(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchKinds to avoid state timing issues
+        fetchKinds(request);
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchKinds(pagedListRequest);
+        }
+    }, [fetchKinds]);
+    return { pagedTaskKinds, loading, refreshTaskKinds };
+}