@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/hooks/useFilterSort.test.js

@@ -1,419 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
-import { useFilterSort } from './useFilterSort';
-function makeTask(overrides) {
-    return {
-        id: overrides.id || 'task-1',
-        title: overrides.title || 'Task',
-        description: overrides.description ?? null,
-        status: (overrides.status || 'task'),
-        priority: overrides.priority ?? 2,
-        complexity: overrides.complexity ?? 3,
-        type: overrides.type || 'feature',
-        category: overrides.category || 'default',
-        createdAt: overrides.createdAt || '2026-03-23T00:00:00.000Z',
-        updatedAt: overrides.updatedAt || null,
-        completedAt: overrides.completedAt || null,
-        canceledReason: overrides.canceledReason || null,
-        isArchived: overrides.isArchived || false,
-        scheduledDate: overrides.scheduledDate || null,
-        dueDate: overrides.dueDate || null,
-        scheduledWeekKey: overrides.scheduledWeekKey || null,
-        orderInDay: overrides.orderInDay || null,
-        taxonomies: overrides.taxonomies || {},
-        createdBy: overrides.createdBy,
-        assignee: overrides.assignee || 'unassigned',
-        comments: overrides.comments || [],
-        attachments: overrides.attachments || [],
-        activity: overrides.activity || [],
-        taskEvents: overrides.taskEvents || [],
-        referenceLabel: overrides.referenceLabel
-    };
-}
-describe('useFilterSort', () => {
-    const activeCategories = [
-        { value: 'default', label: 'Default', disabled: false },
-        { value: 'ops', label: 'Ops', disabled: false }
-    ];
-    const activeTypes = [
-        { value: 'feature', label: 'Feature' },
-        { value: 'bug', label: 'Bug' }
-    ];
-    const priorities = [
-        { value: 1, label: 'Low' },
-        { value: 2, label: 'Medium' },
-        { value: 3, label: 'High' }
-    ];
-    const assigneeOptions = [
-        { value: 'unassigned', label: 'Unassigned', icon: 'HelpCircle', color: '#999', kind: 'unassigned' },
-        { value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member' }
-    ];
-    const taxonomies = [
-        {
-            id: 'track',
-            label: 'Track',
-            options: [{ value: 'platform', label: 'Platform' }],
-            widgetType: 'select',
-            isSystem: false,
-            multiSelect: false
-        }
-    ];
-    it('keeps tasks with unknown values visible when every filter is effectively toggle-all', async () => {
-        const knownTask = makeTask({
-            id: 'known-task',
-            title: 'Known task',
-            category: 'default',
-            type: 'feature',
-            priority: 2,
-            status: 'task',
-            assignee: 'unassigned',
-            taxonomies: { track: 'platform' }
-        });
-        const unknownTask = makeTask({
-            id: 'unknown-task',
-            title: 'Unknown task',
-            category: 'ghost-category',
-            type: 'ghost-type',
-            priority: 99,
-            status: 'ghost-status',
-            assignee: 'ghost-assignee',
-            taxonomies: { track: 'ghost-track' }
-        });
-        const unknownArchivedTask = makeTask({
-            id: 'unknown-archived-task',
-            title: 'Unknown archived task',
-            category: 'ghost-category',
-            type: 'ghost-type',
-            priority: 99,
-            assignee: 'ghost-assignee',
-            taxonomies: { track: 'ghost-track' },
-            isArchived: true
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [knownTask, unknownTask],
-            archivedTasks: [unknownArchivedTask],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies,
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['known-task', 'unknown-task']);
-        expect(result.current.searchAgnosticTasks.map((task) => task.id)).toEqual(['known-task', 'unknown-task']);
-        expect(result.current.filteredArchive.map((task) => task.id)).toEqual(['unknown-archived-task']);
-    });
-    it('matches task reference labels when the search query has surrounding spaces or pasted formatting', async () => {
-        const matchingTask = makeTask({
-            id: 'matching-task',
-            title: 'Reference match',
-            referenceLabel: 'T-123'
-        });
-        const otherTask = makeTask({
-            id: 'other-task',
-            title: 'Other task',
-            referenceLabel: 'T-456'
-        });
-        const archivedMatch = makeTask({
-            id: 'archived-match',
-            title: 'Archived reference match',
-            referenceLabel: 'T-123',
-            isArchived: true
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [matchingTask, otherTask],
-            archivedTasks: [archivedMatch],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setSearchQuery(' T - 123 ');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
-        expect(result.current.filteredArchive.map((task) => task.id)).toEqual(['archived-match']);
-        act(() => {
-            result.current.setSearchQuery('t–123');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
-        act(() => {
-            result.current.setSearchQuery('   ');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task', 'other-task']);
-    });
-    it('matches tokenized search text and task metadata labels', async () => {
-        const matchingTask = makeTask({
-            id: 'matching-task',
-            title: 'Billing API cleanup',
-            category: 'ops',
-            priority: 3,
-            assignee: 'member-1'
-        });
-        const otherTask = makeTask({
-            id: 'other-task',
-            title: 'Marketing copy cleanup',
-            category: 'default',
-            priority: 1,
-            assignee: 'unassigned'
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [matchingTask, otherTask],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setSearchQuery('api billing');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
-        act(() => {
-            result.current.setSearchQuery('Member One');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
-    });
-    it('still excludes unknown values when the user selects a subset filter', async () => {
-        const knownTask = makeTask({
-            id: 'known-task',
-            title: 'Known task',
-            category: 'default'
-        });
-        const unknownTask = makeTask({
-            id: 'unknown-task',
-            title: 'Unknown task',
-            category: 'ghost-category'
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [knownTask, unknownTask],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setFilterCategories(['default']);
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['known-task']);
-    });
-    it('ignores custom taxonomy filters when that taxonomy is not filter-enabled', async () => {
-        const platformTask = makeTask({
-            id: 'platform-task',
-            title: 'Platform task',
-            taxonomies: { track: 'platform' }
-        });
-        const ghostTask = makeTask({
-            id: 'ghost-task',
-            title: 'Ghost task',
-            taxonomies: { track: 'ghost-track' }
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [platformTask, ghostTask],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [{
-                    ...taxonomies[0],
-                    filterEnabled: false
-                }],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setFilterTaxonomies({ track: ['platform'] });
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['platform-task', 'ghost-task']);
-    });
-    it('does not initialize filters for retired custom taxonomies with no task usage', async () => {
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [{
-                    id: 'review-status',
-                    label: 'Review Status',
-                    status: 'retired',
-                    options: [{ value: 'pending', label: 'Pending', status: 'active' }],
-                    widgetType: 'select',
-                    isSystem: false,
-                    multiSelect: false,
-                    filterEnabled: true
-                }],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        expect(result.current.filterTaxonomies).toEqual({});
-    });
-    it('sorts by enabled custom taxonomy option order and keeps missing values last', async () => {
-        const alphaTask = makeTask({
-            id: 'alpha-task',
-            title: 'Alpha task',
-            taxonomies: { track: 'alpha' }
-        });
-        const betaTask = makeTask({
-            id: 'beta-task',
-            title: 'Beta task',
-            taxonomies: { track: 'beta' }
-        });
-        const missingTask = makeTask({
-            id: 'missing-task',
-            title: 'Missing task'
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [missingTask, betaTask, alphaTask],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [{
-                    id: 'track',
-                    label: 'Track',
-                    options: [
-                        { value: 'alpha', label: 'Alpha' },
-                        { value: 'beta', label: 'Beta' }
-                    ],
-                    widgetType: 'select',
-                    isSystem: false,
-                    multiSelect: false,
-                    sortEnabled: true
-                }],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setSortBy('taxonomy:track');
-            result.current.setSortOrder('asc');
-        });
-        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['alpha-task', 'beta-task', 'missing-task']);
-    });
-    it('initializes custom taxonomy filters with active and in-use retired options only', async () => {
-        const activeTask = makeTask({
-            id: 'active-task',
-            taxonomies: { track: 'platform' }
-        });
-        const legacyTask = makeTask({
-            id: 'legacy-task',
-            taxonomies: { track: 'legacy' }
-        });
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [activeTask, legacyTask],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [{
-                    id: 'track',
-                    label: 'Track',
-                    options: [
-                        { value: 'platform', label: 'Platform', status: 'active' },
-                        { value: 'legacy', label: 'Legacy', status: 'retired' },
-                        { value: 'unused-legacy', label: 'Unused Legacy', status: 'retired' }
-                    ],
-                    widgetType: 'select',
-                    isSystem: false,
-                    multiSelect: false,
-                    filterEnabled: true
-                }],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        expect(result.current.filterTaxonomies.track).toEqual(['platform', 'legacy']);
-    });
-    it('normalizes restored type filters when they do not exist in the active workspace', async () => {
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [makeTask({ id: 'task-1', type: 'feature' })],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies: [],
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setFilterTypes(['legacy-type']);
-        });
-        await waitFor(() => {
-            expect(result.current.filterTypes).toEqual(['feature', 'bug']);
-        });
-    });
-    it('normalizes restored taxonomy filters when they do not exist in the active workspace', async () => {
-        const { result } = renderHook(() => useFilterSort({
-            tasks: [makeTask({ id: 'task-1', taxonomies: { track: 'platform' } })],
-            archivedTasks: [],
-            activeCategories,
-            activeTypes,
-            priorities,
-            taxonomies,
-            configLoaded: true,
-            referenceDataLoaded: true,
-            assigneeOptionsLoaded: true,
-            assigneeOptions
-        }));
-        await waitFor(() => {
-            expect(result.current.hasInitedFilters).toBe(true);
-        });
-        act(() => {
-            result.current.setFilterTaxonomies({ track: ['legacy-track'] });
-        });
-        await waitFor(() => {
-            expect(result.current.filterTaxonomies.track).toEqual(['platform']);
-        });
-    });
-});

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

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