@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/hooks/useTaskData.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useTaskData.test.js

@@ -1,291 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { useTaskData } from './useTaskData';
-function makeAbortableFetchResponse(payload) {
-    return {
-        ok: true,
-        status: 200,
-        json: async () => payload
-    };
-}
-function makeAbortableRequest(payload) {
-    let rejectRequest = null;
-    const promise = new Promise((resolve, reject) => {
-        rejectRequest = reject;
-        queueMicrotask(() => resolve(makeAbortableFetchResponse(payload)));
-    });
-    return {
-        promise,
-        attach(signal) {
-            signal?.addEventListener('abort', () => {
-                rejectRequest?.(new DOMException('Aborted', 'AbortError'));
-            }, { once: true });
-        }
-    };
-}
-function makeAbortableRequestRejectingWithReason(payload) {
-    let rejectRequest = null;
-    let resolveRequest = null;
-    const promise = new Promise((resolve, reject) => {
-        resolveRequest = resolve;
-        rejectRequest = reject;
-    });
-    return {
-        promise,
-        attach(signal) {
-            signal?.addEventListener('abort', () => {
-                rejectRequest?.(signal.reason);
-            }, { once: true });
-            queueMicrotask(() => {
-                if (!signal?.aborted) {
-                    resolveRequest?.(makeAbortableFetchResponse(payload));
-                }
-            });
-        }
-    };
-}
-function makeControlledAbortableRequest(payload) {
-    let rejectRequest = null;
-    let resolveRequest = null;
-    const promise = new Promise((resolve, reject) => {
-        rejectRequest = reject;
-        resolveRequest = () => resolve(makeAbortableFetchResponse(payload));
-    });
-    return {
-        promise,
-        resolve() {
-            resolveRequest?.();
-        },
-        attach(signal) {
-            signal?.addEventListener('abort', () => {
-                rejectRequest?.(new DOMException('Aborted', 'AbortError'));
-            }, { once: true });
-        }
-    };
-}
-describe('useTaskData', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-    });
-    it('aborts an in-flight tasks request when a replacement fetch starts', async () => {
-        const firstRequest = makeAbortableRequest({ tasks: [] });
-        const secondRequest = makeAbortableRequest({ tasks: [] });
-        const fetchMock = vi.mocked(fetch);
-        const requestSignals = [];
-        fetchMock.mockImplementation((_input, init) => {
-            const signal = init?.signal;
-            if (requestSignals.length === 0) {
-                requestSignals.push(signal);
-                firstRequest.attach(signal);
-                return firstRequest.promise;
-            }
-            requestSignals.push(signal);
-            secondRequest.attach(signal);
-            return secondRequest.promise;
-        });
-        const setTasks = vi.fn();
-        const setArchivedTasks = vi.fn();
-        const setLoadingTasks = vi.fn();
-        const { result } = renderHook(() => useTaskData({
-            tasks: [],
-            archivedTasks: [],
-            setTasks,
-            setArchivedTasks,
-            setLoadingTasks,
-            getCurrentWorkspaceId: () => 'workspace-1',
-            workspaceResetKey: 'workspace-1',
-            shouldDeferProtectedApiCalls: false,
-            shouldBlockProtectedApiCalls: false,
-            handleUnauthorized: vi.fn(),
-            authRequiredForApi: false
-        }));
-        let firstPromise;
-        let secondPromise;
-        await act(async () => {
-            firstPromise = result.current.fetchTasks(true);
-            secondPromise = result.current.fetchTasks(true);
-            await secondPromise;
-            await firstPromise;
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        expect(requestSignals[0]?.aborted).toBe(true);
-        expect(requestSignals[1]?.aborted).toBe(false);
-    });
-    it('aborts an in-flight archive request when a replacement fetch starts', async () => {
-        const firstRequest = makeAbortableRequest({ archived: [] });
-        const secondRequest = makeAbortableRequest({ archived: [] });
-        const fetchMock = vi.mocked(fetch);
-        const requestSignals = [];
-        fetchMock.mockImplementation((_input, init) => {
-            const signal = init?.signal;
-            if (requestSignals.length === 0) {
-                requestSignals.push(signal);
-                firstRequest.attach(signal);
-                return firstRequest.promise;
-            }
-            requestSignals.push(signal);
-            secondRequest.attach(signal);
-            return secondRequest.promise;
-        });
-        const { result } = renderHook(() => useTaskData({
-            tasks: [],
-            archivedTasks: [],
-            setTasks: vi.fn(),
-            setArchivedTasks: vi.fn(),
-            setLoadingTasks: vi.fn(),
-            getCurrentWorkspaceId: () => 'workspace-1',
-            workspaceResetKey: 'workspace-1',
-            shouldDeferProtectedApiCalls: false,
-            shouldBlockProtectedApiCalls: false,
-            handleUnauthorized: vi.fn(),
-            authRequiredForApi: false
-        }));
-        let firstPromise;
-        let secondPromise;
-        await act(async () => {
-            firstPromise = result.current.fetchArchive(true);
-            secondPromise = result.current.fetchArchive(true);
-            await secondPromise;
-            await firstPromise;
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        expect(requestSignals[0]?.aborted).toBe(true);
-        expect(requestSignals[1]?.aborted).toBe(false);
-    });
-    it('does not log an error when an archive request is aborted with a string reason', async () => {
-        const firstRequest = makeAbortableRequestRejectingWithReason({ archived: [] });
-        const secondRequest = makeAbortableRequestRejectingWithReason({ archived: [] });
-        const fetchMock = vi.mocked(fetch);
-        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-        let requestCount = 0;
-        fetchMock.mockImplementation((_input, init) => {
-            const signal = init?.signal;
-            requestCount += 1;
-            if (requestCount === 1) {
-                firstRequest.attach(signal);
-                return firstRequest.promise;
-            }
-            secondRequest.attach(signal);
-            return secondRequest.promise;
-        });
-        const { result } = renderHook(() => useTaskData({
-            tasks: [],
-            archivedTasks: [],
-            setTasks: vi.fn(),
-            setArchivedTasks: vi.fn(),
-            setLoadingTasks: vi.fn(),
-            getCurrentWorkspaceId: () => 'workspace-1',
-            workspaceResetKey: 'workspace-1',
-            shouldDeferProtectedApiCalls: false,
-            shouldBlockProtectedApiCalls: false,
-            handleUnauthorized: vi.fn(),
-            authRequiredForApi: false
-        }));
-        let firstPromise;
-        let secondPromise;
-        await act(async () => {
-            firstPromise = result.current.fetchArchive(true);
-            secondPromise = result.current.fetchArchive(true);
-            await secondPromise;
-            await firstPromise;
-        });
-        expect(consoleErrorSpy).not.toHaveBeenCalledWith('[Taskforce] Failed to fetch archive:', 'superseded');
-        expect(consoleErrorSpy).not.toHaveBeenCalled();
-    });
-    it('keeps loading active until the replacement tasks request finishes', async () => {
-        const firstRequest = makeControlledAbortableRequest({ tasks: [] });
-        const secondRequest = makeControlledAbortableRequest({ tasks: [] });
-        const fetchMock = vi.mocked(fetch);
-        const setLoadingTasks = vi.fn();
-        let requestCount = 0;
-        fetchMock.mockImplementation((_input, init) => {
-            const signal = init?.signal;
-            requestCount += 1;
-            if (requestCount === 1) {
-                firstRequest.attach(signal);
-                return firstRequest.promise;
-            }
-            secondRequest.attach(signal);
-            return secondRequest.promise;
-        });
-        const { result } = renderHook(() => useTaskData({
-            tasks: [],
-            archivedTasks: [],
-            setTasks: vi.fn(),
-            setArchivedTasks: vi.fn(),
-            setLoadingTasks,
-            getCurrentWorkspaceId: () => 'workspace-1',
-            workspaceResetKey: 'workspace-1',
-            shouldDeferProtectedApiCalls: false,
-            shouldBlockProtectedApiCalls: false,
-            handleUnauthorized: vi.fn(),
-            authRequiredForApi: false
-        }));
-        let firstPromise;
-        let secondPromise;
-        await act(async () => {
-            firstPromise = result.current.fetchTasks(false);
-            secondPromise = result.current.fetchTasks(false);
-            await Promise.resolve();
-        });
-        expect(setLoadingTasks).toHaveBeenNthCalledWith(1, true);
-        expect(setLoadingTasks).toHaveBeenNthCalledWith(2, true);
-        expect(setLoadingTasks).toHaveBeenCalledTimes(2);
-        await act(async () => {
-            secondRequest.resolve();
-            await secondPromise;
-            await firstPromise;
-        });
-        expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
-        expect(setLoadingTasks).toHaveBeenCalledTimes(3);
-    });
-    it('clears loading when a silent tasks refresh replaces a visible fetch', async () => {
-        const firstRequest = makeControlledAbortableRequest({ tasks: [] });
-        const secondRequest = makeControlledAbortableRequest({ tasks: [] });
-        const fetchMock = vi.mocked(fetch);
-        const setLoadingTasks = vi.fn();
-        let requestCount = 0;
-        fetchMock.mockImplementation((_input, init) => {
-            const signal = init?.signal;
-            requestCount += 1;
-            if (requestCount === 1) {
-                firstRequest.attach(signal);
-                return firstRequest.promise;
-            }
-            secondRequest.attach(signal);
-            return secondRequest.promise;
-        });
-        const { result } = renderHook(() => useTaskData({
-            tasks: [],
-            archivedTasks: [],
-            setTasks: vi.fn(),
-            setArchivedTasks: vi.fn(),
-            setLoadingTasks,
-            getCurrentWorkspaceId: () => 'workspace-1',
-            workspaceResetKey: 'workspace-1',
-            shouldDeferProtectedApiCalls: false,
-            shouldBlockProtectedApiCalls: false,
-            handleUnauthorized: vi.fn(),
-            authRequiredForApi: false
-        }));
-        let firstPromise;
-        let secondPromise;
-        await act(async () => {
-            firstPromise = result.current.fetchTasks(false);
-            secondPromise = result.current.fetchTasks(true);
-            await Promise.resolve();
-        });
-        expect(setLoadingTasks).toHaveBeenNthCalledWith(1, true);
-        expect(setLoadingTasks).toHaveBeenNthCalledWith(2, false);
-        await act(async () => {
-            secondRequest.resolve();
-            await secondPromise;
-            await firstPromise;
-        });
-        expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
-    });
-});

package/dist/hooks/useTaskMutations.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useTaskMutations.test.js

@@ -1,256 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { useTaskMutations } from './useTaskMutations';
-describe('useTaskMutations', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-    });
-    const baseTask = {
-        id: 'task-1',
-        title: 'Test task',
-        description: '',
-        category: 'general',
-        type: 'task',
-        priority: 2,
-        complexity: 3,
-        status: 'task',
-        createdAt: '2026-04-03T10:00:00.000Z',
-        updatedAt: '2026-04-03T10:05:00.000Z'
-    };
-    const buildHook = (overrides = {}) => {
-        const setTasks = vi.fn();
-        const setArchivedTasks = vi.fn();
-        const setDeletedTasks = vi.fn();
-        const setError = vi.fn();
-        const resetForm = vi.fn();
-        const setActiveTab = vi.fn();
-        const fetchTasks = vi.fn();
-        const fetchArchive = vi.fn();
-        const fetchDeletedTasks = vi.fn();
-        const mergeTaskFromServer = vi.fn();
-        const pushNotice = vi.fn();
-        const buildWorkspaceSyncSignature = vi.fn(() => 'sig-1');
-        const pushWorkspaceChangesToCloud = vi.fn();
-        const workspacePendingSignatureRef = { current: null };
-        const workspaceDeletedTaskIdsRef = { current: new Set() };
-        const workspaceDeletedTaskWatermarksRef = { current: new Map() };
-        const hook = renderHook(() => useTaskMutations({
-            tasks: [baseTask],
-            archivedTasks: [],
-            editingTaskId: null,
-            setTasks,
-            setArchivedTasks,
-            setDeletedTasks,
-            setError,
-            resetForm,
-            setActiveTab,
-            fetchTasks,
-            fetchArchive,
-            fetchDeletedTasks,
-            mergeTaskFromServer,
-            pushNotice,
-            cloudAuthConfigured: true,
-            runtimeMode: 'local',
-            isAuthenticated: true,
-            workspaceCloudSyncEnabled: true,
-            buildWorkspaceSyncSignature,
-            pushWorkspaceChangesToCloud,
-            workspacePendingSignatureRef,
-            workspaceDeletedTaskIdsRef,
-            workspaceDeletedTaskWatermarksRef,
-            ...overrides
-        }));
-        return {
-            ...hook,
-            deps: {
-                setTasks,
-                setArchivedTasks,
-                setDeletedTasks,
-                setError,
-                resetForm,
-                setActiveTab,
-                fetchTasks,
-                fetchArchive,
-                fetchDeletedTasks,
-                mergeTaskFromServer,
-                pushNotice,
-                buildWorkspaceSyncSignature,
-                pushWorkspaceChangesToCloud,
-                workspacePendingSignatureRef,
-                workspaceDeletedTaskIdsRef,
-                workspaceDeletedTaskWatermarksRef
-            }
-        };
-    };
-    it('clears pending delete ids when a deleted task is restored', async () => {
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                id: 'task-1',
-                title: 'Restored task',
-                description: 'Restored description',
-                category: 'general',
-                type: 'task',
-                priority: 2,
-                complexity: 3,
-                status: 'task',
-                createdAt: '2026-04-03T10:00:00.000Z',
-                updatedAt: '2026-04-03T10:05:00.000Z'
-            })
-        });
-        const setTasks = vi.fn();
-        const setArchivedTasks = vi.fn();
-        const setDeletedTasks = vi.fn();
-        const setError = vi.fn();
-        const resetForm = vi.fn();
-        const setActiveTab = vi.fn();
-        const fetchTasks = vi.fn();
-        const fetchArchive = vi.fn();
-        const fetchDeletedTasks = vi.fn();
-        const mergeTaskFromServer = vi.fn();
-        const pushNotice = vi.fn();
-        const buildWorkspaceSyncSignature = vi.fn(() => 'sig-1');
-        const pushWorkspaceChangesToCloud = vi.fn();
-        const workspacePendingSignatureRef = { current: null };
-        const workspaceDeletedTaskIdsRef = { current: new Set(['task-1']) };
-        const workspaceDeletedTaskWatermarksRef = { current: new Map([['task-1', '2026-04-03T10:10:00.000Z']]) };
-        const { result } = renderHook(() => useTaskMutations({
-            tasks: [],
-            archivedTasks: [],
-            editingTaskId: null,
-            setTasks,
-            setArchivedTasks,
-            setDeletedTasks,
-            setError,
-            resetForm,
-            setActiveTab,
-            fetchTasks,
-            fetchArchive,
-            fetchDeletedTasks,
-            mergeTaskFromServer,
-            pushNotice,
-            cloudAuthConfigured: true,
-            runtimeMode: 'local',
-            isAuthenticated: true,
-            workspaceCloudSyncEnabled: true,
-            buildWorkspaceSyncSignature,
-            pushWorkspaceChangesToCloud,
-            workspacePendingSignatureRef,
-            workspaceDeletedTaskIdsRef,
-            workspaceDeletedTaskWatermarksRef,
-        }));
-        await act(async () => {
-            await result.current.handleRestoreDeletedTask('task-1');
-        });
-        await waitFor(() => {
-            expect(workspaceDeletedTaskIdsRef.current.has('task-1')).toBe(false);
-        });
-        expect(workspaceDeletedTaskWatermarksRef.current.has('task-1')).toBe(false);
-        expect(mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1' }));
-        expect(buildWorkspaceSyncSignature).toHaveBeenCalled();
-        expect(pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
-        expect(setDeletedTasks).toHaveBeenCalled();
-    });
-    it('records the delete watermark immediately when a task delete succeeds', async () => {
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                deleted: {
-                    id: 'deleted-task-1',
-                    taskId: 'task-1',
-                    deletedAt: '2026-04-03T10:10:00.000Z',
-                    taskSnapshot: baseTask
-                }
-            })
-        });
-        const { result, deps } = buildHook();
-        await act(async () => {
-            await result.current.handleDelete('task-1', false, { skipConfirm: true });
-        });
-        expect(deps.workspaceDeletedTaskIdsRef.current.has('task-1')).toBe(true);
-        expect(deps.workspaceDeletedTaskWatermarksRef.current.get('task-1')).toBe('2026-04-03T10:10:00.000Z');
-        expect(deps.buildWorkspaceSyncSignature).toHaveBeenCalled();
-        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
-    });
-    it('optimistically marks a task done before the server responds', async () => {
-        let resolveResponse;
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockImplementation(() => new Promise((resolve) => {
-            resolveResponse = resolve;
-        }));
-        const { result, deps } = buildHook();
-        let togglePromise = null;
-        await act(async () => {
-            togglePromise = result.current.handleToggleComplete(baseTask);
-        });
-        expect(deps.setTasks).toHaveBeenCalledTimes(1);
-        const optimisticUpdater = deps.setTasks.mock.calls[0]?.[0];
-        const optimisticTasks = optimisticUpdater([baseTask]);
-        expect(optimisticTasks[0]?.status).toBe('done');
-        expect(optimisticTasks[0]?.completed).toBe(true);
-        resolveResponse({
-            ok: true,
-            status: 200,
-            json: async () => ({ ...baseTask, status: 'done', completedAt: '2026-04-14T12:00:00.000Z' })
-        });
-        await act(async () => {
-            await togglePromise;
-        });
-        expect(deps.mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: 'done' }));
-    });
-    it('rolls back the optimistic done state when the server update fails', async () => {
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 500,
-            json: async () => ({ error: 'Server exploded' })
-        });
-        const { result, deps } = buildHook();
-        await act(async () => {
-            await result.current.handleToggleComplete(baseTask);
-        });
-        expect(deps.setTasks).toHaveBeenCalledTimes(2);
-        expect(deps.setTasks.mock.calls[1]?.[0]).toEqual([baseTask]);
-        expect(deps.setArchivedTasks.mock.calls[1]?.[0]).toEqual([]);
-        expect(deps.pushNotice).toHaveBeenCalledWith('Server exploded', 'error');
-        expect(deps.mergeTaskFromServer).not.toHaveBeenCalled();
-    });
-    it('coalesces pending workspace sync pushes and preserves attachment delay', async () => {
-        vi.useFakeTimers();
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ ...baseTask, updatedAt: '2026-04-14T12:00:00.000Z' })
-        });
-        const { result, deps } = buildHook();
-        await act(async () => {
-            await result.current.handleUpdateTask(baseTask.id, { description: 'First update' });
-        });
-        await act(async () => {
-            await result.current.handleUpdateTask(baseTask.id, {
-                attachments: [{ id: 'asset-1', path: 'workspaces/workspace-local-active/assets/file.txt' }]
-            });
-        });
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(149);
-        });
-        expect(deps.pushWorkspaceChangesToCloud).not.toHaveBeenCalled();
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(1);
-        });
-        expect(deps.buildWorkspaceSyncSignature).toHaveBeenCalledTimes(1);
-        expect(deps.workspacePendingSignatureRef.current).toBe('sig-1');
-        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledTimes(1);
-        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
-    });
-});

package/dist/hooks/useTaskforce.contract.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useTaskforce.contract.test.js

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-const matchesReturnType = true;
-describe('useTaskforce contract', () => {
-    it('exports a result alias that matches the hook return shape', () => {
-        expect(matchesReturnType).toBe(true);
-    });
-});

package/dist/hooks/useTaskforce.priority-filters.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useTaskforce.priority-filters.test.js

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { matchesPriorityFilter, normalizePriorityFilterValues } from '../utils/taskNormalization';
-describe('normalizePriorityFilterValues', () => {
-    const oneToFour = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }];
-    it('keeps only currently available priority values', () => {
-        const result = normalizePriorityFilterValues([0, 1, 2, 3, 4, 5], oneToFour);
-        expect(result).toEqual([1, 2, 3, 4]);
-    });
-    it('does not remap valid current values', () => {
-        const result = normalizePriorityFilterValues([2, 3, 4], oneToFour);
-        expect(result).toEqual([2, 3, 4]);
-    });
-    it('handles string values and drops out-of-range values', () => {
-        const result = normalizePriorityFilterValues(['1', '3', '99'], oneToFour);
-        expect(result).toEqual([1, 3]);
-    });
-});
-describe('matchesPriorityFilter', () => {
-    it('matches numeric task priority against saved string filter values', () => {
-        expect(matchesPriorityFilter(3, ['1', '3'])).toBe(true);
-    });
-    it('matches string task priority against numeric filter values', () => {
-        expect(matchesPriorityFilter('4', [2, 4])).toBe(true);
-    });
-    it('does not match when task priority is absent', () => {
-        expect(matchesPriorityFilter(undefined, ['1', '3'])).toBe(false);
-    });
-});

package/dist/hooks/useTaskforce.runtime-routing.test.d.ts

@@ -1 +0,0 @@
-export {};