@taskforcehq/taskforce 0.3.303 → 0.3.304

package/dist/components/task/TaskKanban.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import type { TaskItem, CategoryConfig, TaxonomyDefinition, PriorityDefinition, TaskAssignee, WorkstreamItem, InitiativeItem } from '../../types';
 import type { TaskAssigneeOption } from '../../utils/assignees';
 import { type TaskSortKey } from '../../utils/taxonomySorting.js';
+import { type ScheduleDayKey } from './taskKanbanDropRules';
 export interface KanbanColumnDef {
     value: string | number;
     label: string;
@@ -11,7 +12,6 @@ export interface KanbanColumnDef {
     isSelected?: boolean;
     isWeekend?: boolean;
 }
-type ScheduleDayKey = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
 interface TaskKanbanProps {
     tasks: TaskItem[];
     allTasks?: TaskItem[];

package/dist/components/task/TaskKanban.js

@@ -7,6 +7,7 @@ import { createPortal } from 'react-dom';
 import styles from '../../Taskforce.module.css';
 import { TaskCard } from './TaskCard';
 import { compareTasksBySortKey } from '../../utils/taxonomySorting.js';
+import { buildScheduleDropResult, buildStatusTransitionUpdates, getGroupedTaskStatus, } from './taskKanbanDropRules';
 import * as Icons from 'lucide-react';
 import { IconMap, resolveColor } from '../../utils/constants';
 const EXPIRED_CARD_ID_PREFIX = 'expired::';
@@ -58,12 +59,7 @@ export function TaskKanban({ tasks, columns: kanbanColumns, groupBy, searchQuery
         coordinateGetter: sortableKeyboardCoordinates,
     }));
     // Helper to determine status string from task flags
-    const getTaskStatus = (task) => {
-        const status = task.status || 'task';
-        if (status === 'done' || status === 'cancelled')
-            return 'completed';
-        return status;
-    };
+    const getTaskStatus = getGroupedTaskStatus;
     const todayDateOnly = useMemo(() => {
         const now = new Date();
         const year = now.getFullYear();
@@ -481,171 +477,46 @@ export function TaskKanban({ tasks, columns: kanbanColumns, groupBy, searchQuery
         if (column) {
             if (groupBy === 'schedule') {
                 const targetColumn = String(column.value);
-                const scheduleKeys = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
-                const isScheduleReorderColumn = targetColumn === 'backlog' || targetColumn === 'expired' || scheduleKeys.includes(targetColumn);
-                const buildInsertIndex = (targetTasks) => {
-                    let insertAt = targetTasks.length;
-                    const candidateOverTaskId = overId && isTaskCardId(overId) ? getTaskIdFromCardId(overId) : null;
-                    if (!candidateOverTaskId || !taskIdSet.has(candidateOverTaskId))
-                        return insertAt;
-                    const overTaskId = candidateOverTaskId;
-                    const overIndex = targetTasks.findIndex(t => t.id === overTaskId);
-                    if (overIndex < 0)
-                        return insertAt;
-                    const overRect = over?.rect;
-                    const translatedActiveRect = active.rect.current.translated;
-                    const activeRect = translatedActiveRect || active.rect.current.initial;
-                    const isBelowOverItem = Boolean(overRect
-                        && activeRect
-                        && (activeRect.top + activeRect.height / 2) > (overRect.top + overRect.height / 2));
-                    return overIndex + (isBelowOverItem ? 1 : 0);
-                };
-                const reindexSourceColumnAfterMove = (sourceColumnId, targetColumnId, pendingUpdates) => {
-                    if (!sourceColumnId || sourceColumnId === targetColumnId)
-                        return;
-                    const sourceTasks = (groupedTasks[String(sourceColumnId)] || []).filter(t => t.id !== activeTaskId);
-                    sourceTasks.forEach((task, index) => {
-                        pendingUpdates.set(task.id, {
-                            ...(pendingUpdates.get(task.id) || {}),
-                            orderInDay: index
-                        });
-                    });
-                };
-                if (targetColumn === 'expired') {
-                    // Expired is virtual and source-only: allow reordering within Expired,
-                    // but do not allow drops from other columns into Expired.
-                    if (resolvedSourceContainerId !== 'expired')
-                        return;
-                    const pendingUpdates = new Map();
-                    const targetTasks = (groupedTasks.expired || []).filter(t => t.id !== activeTaskId);
-                    const insertAt = buildInsertIndex(targetTasks);
-                    const reorderedTarget = [...targetTasks];
-                    reorderedTarget.splice(insertAt, 0, activeTask);
-                    reorderedTarget.forEach((task, index) => {
-                        pendingUpdates.set(task.id, {
-                            ...(pendingUpdates.get(task.id) || {}),
-                            orderInDay: index
-                        });
-                    });
-                    pendingUpdates.forEach((updates, taskId) => onUpdateTask(taskId, updates));
+                const candidateOverTaskId = overId && isTaskCardId(overId) ? getTaskIdFromCardId(overId) : null;
+                const overRect = over?.rect;
+                const translatedActiveRect = active.rect.current.translated;
+                const activeRect = translatedActiveRect || active.rect.current.initial;
+                const isBelowOverItem = Boolean(overRect
+                    && activeRect
+                    && (activeRect.top + activeRect.height / 2) > (overRect.top + overRect.height / 2));
+                const targetTasks = (groupedTasks[targetColumn] || []).filter((task) => task.id !== activeTaskId);
+                const sourceTasks = (groupedTasks[String(resolvedSourceContainerId)] || []).filter((task) => task.id !== activeTaskId);
+                const scheduleDropResult = buildScheduleDropResult({
+                    activeTask,
+                    sourceColumnId: resolvedSourceContainerId,
+                    targetColumnId: targetColumn,
+                    targetTasks,
+                    sourceTasks,
+                    overTaskId: candidateOverTaskId,
+                    isBelowOverItem,
+                    scheduleDates: scheduleContext.dates,
+                    parseToIsoWeekKey: scheduleContext.parseToIsoWeekKey,
+                    todayDate: todayDateOnly,
+                });
+                if (!scheduleDropResult)
                     return;
-                }
-                if (targetColumn === 'backlog') {
-                    const pendingUpdates = new Map();
-                    const targetTasks = (groupedTasks.backlog || []).filter(t => t.id !== activeTaskId);
-                    const insertAt = buildInsertIndex(targetTasks);
-                    const reorderedTarget = [...targetTasks];
-                    reorderedTarget.splice(insertAt, 0, activeTask);
-                    reorderedTarget.forEach((task, index) => {
-                        if (task.id === activeTaskId) {
-                            if (activeTask.scheduledDate) {
-                                pendingUpdates.set(task.id, {
-                                    ...(pendingUpdates.get(task.id) || {}),
-                                    scheduledDate: null,
-                                    scheduledWeekKey: null,
-                                    orderInDay: index
-                                });
-                            }
-                            else {
-                                pendingUpdates.set(task.id, {
-                                    ...(pendingUpdates.get(task.id) || {}),
-                                    orderInDay: index
-                                });
-                            }
-                        }
-                        else {
-                            pendingUpdates.set(task.id, {
-                                ...(pendingUpdates.get(task.id) || {}),
-                                orderInDay: index
-                            });
-                        }
-                    });
-                    reindexSourceColumnAfterMove(resolvedSourceContainerId, targetColumn, pendingUpdates);
-                    pendingUpdates.forEach((updates, taskId) => onUpdateTask(taskId, updates));
+                if (scheduleDropResult.kind === 'blocked') {
+                    window.alert(scheduleDropResult.reason);
                     return;
                 }
-                if (!isScheduleReorderColumn || !scheduleKeys.includes(targetColumn))
-                    return;
-                const scheduledDate = scheduleContext.dates[targetColumn];
-                if (!scheduledDate)
-                    return;
-                const isTerminal = activeTask.status === 'done' || activeTask.status === 'cancelled';
-                if (!isTerminal && scheduledDate < todayDateOnly) {
-                    window.alert('Only completed work can be scheduled in the past.');
-                    return;
+                scheduleDropResult.updates.forEach(({ taskId, updates }) => onUpdateTask(taskId, updates));
+                if (scheduleDropResult.selectedDate) {
+                    onScheduleDaySelected?.(scheduleDropResult.selectedDate);
                 }
-                const scheduledWeekKey = scheduleContext.parseToIsoWeekKey(scheduledDate);
-                const pendingUpdates = new Map();
-                const targetTasks = (groupedTasks[targetColumn] || []).filter(t => t.id !== activeTaskId);
-                const insertAt = buildInsertIndex(targetTasks);
-                const reorderedTarget = [...targetTasks];
-                reorderedTarget.splice(insertAt, 0, activeTask);
-                reorderedTarget.forEach((task, index) => {
-                    if (task.id === activeTaskId) {
-                        pendingUpdates.set(task.id, {
-                            ...(pendingUpdates.get(task.id) || {}),
-                            scheduledDate,
-                            scheduledWeekKey,
-                            orderInDay: index
-                        });
-                    }
-                    else {
-                        pendingUpdates.set(task.id, {
-                            ...(pendingUpdates.get(task.id) || {}),
-                            orderInDay: index
-                        });
-                    }
-                });
-                reindexSourceColumnAfterMove(resolvedSourceContainerId, targetColumn, pendingUpdates);
-                pendingUpdates.forEach((updates, taskId) => onUpdateTask(taskId, updates));
-                onScheduleDaySelected?.(scheduledDate);
                 return;
             }
             // Determine the value to update based on the grouping
             let targetValue = column.value;
             // STATUS HANDLING
             if (groupBy === 'status') {
-                const currentStatus = getTaskStatus(activeTask);
                 const targetStatus = String(targetValue);
-                if (currentStatus !== targetStatus) {
-                    const updates = {
-                        status: targetStatus
-                    };
-                    if (targetStatus === 'task') {
-                        updates.inProgress = false;
-                        updates.readyForReview = false;
-                        updates.completed = false;
-                        updates.cancelled = false;
-                    }
-                    else if (targetStatus === 'on-hold') {
-                        updates.inProgress = false;
-                        updates.readyForReview = false;
-                        updates.completed = false;
-                        updates.cancelled = false;
-                    }
-                    else if (targetStatus === 'in-progress') {
-                        updates.inProgress = true;
-                        updates.readyForReview = false;
-                        updates.completed = false;
-                        updates.cancelled = false;
-                    }
-                    else if (targetStatus === 'review') {
-                        updates.inProgress = false;
-                        updates.readyForReview = true;
-                        updates.completed = false;
-                        updates.cancelled = false;
-                    }
-                    else if (targetStatus === 'done' || targetStatus === 'completed') {
-                        updates.status = 'done';
-                        updates.inProgress = false;
-                        updates.readyForReview = false;
-                        updates.completed = true;
-                        updates.cancelled = false;
-                        updates.completedAt = new Date().toISOString();
-                    }
-                    else if (targetStatus === 'cancelled') {
-                        updates.status = 'cancelled';
-                    }
+                const updates = buildStatusTransitionUpdates(activeTask, targetStatus, new Date().toISOString());
+                if (updates) {
                     onUpdateTask(activeTask.id, updates);
                 }
                 return;

package/dist/components/task/TaskStatusActions.d.ts

@@ -1,12 +1,17 @@
 import type { TaskItem, TaskStatus } from '../../types';
+type ArchiveActionMode = 'auto' | 'archive' | 'unarchive' | 'none';
 interface TaskStatusActionsProps {
     task?: TaskItem | null;
     disabled?: boolean;
+    actionDisabled?: boolean;
+    statusDisabled?: boolean;
     compressed?: boolean;
     shortLabels?: boolean;
     showLabel?: boolean;
     onSetStatus?: (task: TaskItem, status: TaskStatus) => void;
     onArchiveTask?: (task: TaskItem) => void;
+    onUnarchiveTask?: (task: TaskItem) => void;
+    archiveActionMode?: ArchiveActionMode;
 }
-export declare function TaskStatusActions({ task, disabled, compressed, shortLabels, showLabel, onSetStatus, onArchiveTask }: TaskStatusActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function TaskStatusActions({ task, disabled, actionDisabled, statusDisabled, compressed, shortLabels, showLabel, onSetStatus, onArchiveTask, onUnarchiveTask, archiveActionMode }: TaskStatusActionsProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/task/TaskStatusActions.js

@@ -1,16 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Archive } from 'lucide-react';
+import { Archive, RotateCcw } from 'lucide-react';
 import styles from '../../Taskforce.module.css';
 import { STATUS_DEFINITIONS } from '../../utils/constants';
 import { TaxonomyDropdown } from '../ui/TaxonomyDropdown';
-export function TaskStatusActions({ task, disabled = false, compressed = false, shortLabels = false, showLabel = true, onSetStatus, onArchiveTask }) {
+export function TaskStatusActions({ task, disabled = false, actionDisabled, statusDisabled, compressed = false, shortLabels = false, showLabel = true, onSetStatus, onArchiveTask, onUnarchiveTask, archiveActionMode = 'auto' }) {
     const currentStatus = task?.status || 'task';
     const canArchive = !!task && (currentStatus === 'done' || currentStatus === 'cancelled');
+    const resolvedArchiveActionMode = archiveActionMode === 'auto'
+        ? (canArchive ? 'archive' : 'none')
+        : archiveActionMode;
+    const resolvedActionDisabled = actionDisabled ?? disabled;
+    const resolvedStatusDisabled = statusDisabled ?? disabled;
     const statusOptions = STATUS_DEFINITIONS.map((option) => ({
         ...option,
         label: (compressed || shortLabels) ? (option.shortLabel || option.label) : option.label
     }));
-    return (_jsxs("div", { className: `${styles.statusActionsGroup} ${compressed ? styles.statusActionsGroupCompact : ''}`, children: [canArchive && (_jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.archiveTaskBtn}`, onClick: () => task && !disabled && onArchiveTask?.(task), disabled: disabled, title: "Archive Now", "aria-label": "Archive task", children: _jsx(Archive, { size: compressed ? 12 : 16 }) })), _jsx("div", { className: `${styles.statusSelectWrap} ${styles.statusTaxonomyDropdownWrap}`, children: _jsx(TaxonomyDropdown, { value: currentStatus, options: statusOptions, disabled: disabled || !task, ariaLabel: "Status", hideSelectedLabel: !showLabel, hideChevron: !showLabel, className: `${styles.statusTaxonomyDropdown} ${compressed ? styles.statusTaxonomyDropdownCompact : ''} ${!showLabel ? styles.statusTaxonomyDropdownIconOnly : ''}`, panelClassName: !showLabel ? styles.statusTaxonomyDropdownIconOnlyPanel : '', portalPanel: !showLabel, panelMinWidth: !showLabel ? 144 : undefined, onChange: (value) => {
+    return (_jsxs("div", { className: `${styles.statusActionsGroup} ${compressed ? styles.statusActionsGroupCompact : ''}`, children: [resolvedArchiveActionMode === 'archive' && (_jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.archiveTaskBtn}`, onClick: () => task && !resolvedActionDisabled && onArchiveTask?.(task), disabled: resolvedActionDisabled, title: "Archive Now", "aria-label": "Archive task", children: _jsx(Archive, { size: compressed ? 12 : 16 }) })), resolvedArchiveActionMode === 'unarchive' && (_jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.archiveTaskBtn}`, onClick: () => task && !resolvedActionDisabled && onUnarchiveTask?.(task), disabled: resolvedActionDisabled, title: "Unarchive task", "aria-label": "Unarchive task", children: _jsx(RotateCcw, { size: compressed ? 12 : 16 }) })), _jsx("div", { className: `${styles.statusSelectWrap} ${styles.statusTaxonomyDropdownWrap}`, children: _jsx(TaxonomyDropdown, { value: currentStatus, options: statusOptions, disabled: resolvedStatusDisabled || !task, ariaLabel: "Status", hideSelectedLabel: !showLabel, hideChevron: !showLabel, className: `${styles.statusTaxonomyDropdown} ${compressed ? styles.statusTaxonomyDropdownCompact : ''} ${!showLabel ? styles.statusTaxonomyDropdownIconOnly : ''}`, panelClassName: !showLabel ? styles.statusTaxonomyDropdownIconOnlyPanel : '', portalPanel: !showLabel, panelMinWidth: !showLabel ? 144 : undefined, onChange: (value) => {
                         if (!task)
                             return;
                         onSetStatus?.(task, value);

package/dist/components/task/TaskStatusActions.test.js

@@ -25,6 +25,15 @@ describe('TaskStatusActions', () => {
         rerender(_jsx(TaskStatusActions, { task: makeTask({ status: 'done' }) }));
         expect(screen.getByRole('button', { name: 'Archive task' })).toBeInTheDocument();
     });
+    it('can render an unarchive action for archived read-only views', async () => {
+        const user = userEvent.setup();
+        const task = makeTask({ status: 'done' });
+        const onUnarchiveTask = vi.fn();
+        render(_jsx(TaskStatusActions, { task: task, archiveActionMode: "unarchive", onUnarchiveTask: onUnarchiveTask }));
+        await user.click(screen.getByRole('button', { name: 'Unarchive task' }));
+        expect(screen.queryByRole('button', { name: 'Archive task' })).not.toBeInTheDocument();
+        expect(onUnarchiveTask).toHaveBeenCalledWith(task);
+    });
     it('uses the compact short label when compressed', () => {
         render(_jsx(TaskStatusActions, { task: makeTask({ status: 'in-progress' }), compressed: true }));
         expect(screen.getByRole('combobox', { name: 'Status' })).toHaveTextContent('Working');

package/dist/components/task/taskKanbanDropRules.d.ts

@@ -0,0 +1,58 @@
+import type { TaskItem } from '../../types';
+export type ScheduleDayKey = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+export type TaskUpdatePair = {
+    taskId: string;
+    updates: Partial<TaskItem>;
+};
+export type ScheduleDropBlockedResult = {
+    kind: 'blocked';
+    reason: string;
+};
+export type ScheduleDropUpdatesResult = {
+    kind: 'updates';
+    updates: TaskUpdatePair[];
+    selectedDate?: string;
+};
+export type ScheduleDropResult = ScheduleDropBlockedResult | ScheduleDropUpdatesResult;
+export declare const getGroupedTaskStatus: (task: TaskItem) => string;
+export declare const buildStatusTransitionUpdates: (task: TaskItem, targetStatus: string, nowIso: string) => Partial<TaskItem> | null;
+export declare const buildInsertIndex: ({ targetTasks, overTaskId, isBelowOverItem, }: {
+    targetTasks: TaskItem[];
+    overTaskId: string | null;
+    isBelowOverItem: boolean;
+}) => number;
+export declare const reindexTasks: (tasks: TaskItem[], baseUpdates?: Map<string, Partial<TaskItem>>) => Map<string, Partial<TaskItem>>;
+export declare const buildBacklogDropUpdates: ({ activeTask, sourceColumnId, targetTasks, sourceTasks, insertAt, }: {
+    activeTask: TaskItem;
+    sourceColumnId: string | null;
+    targetTasks: TaskItem[];
+    sourceTasks: TaskItem[];
+    insertAt: number;
+}) => TaskUpdatePair[];
+export declare const buildExpiredReorderUpdates: ({ activeTask, targetTasks, insertAt, }: {
+    activeTask: TaskItem;
+    targetTasks: TaskItem[];
+    insertAt: number;
+}) => TaskUpdatePair[];
+export declare const buildScheduledDayDropUpdates: ({ activeTask, sourceColumnId, targetColumnId, targetTasks, sourceTasks, insertAt, scheduledDate, scheduledWeekKey, }: {
+    activeTask: TaskItem;
+    sourceColumnId: string | null;
+    targetColumnId: string;
+    targetTasks: TaskItem[];
+    sourceTasks: TaskItem[];
+    insertAt: number;
+    scheduledDate: string;
+    scheduledWeekKey: string | null;
+}) => TaskUpdatePair[];
+export declare const buildScheduleDropResult: ({ activeTask, sourceColumnId, targetColumnId, targetTasks, sourceTasks, overTaskId, isBelowOverItem, scheduleDates, parseToIsoWeekKey, todayDate, }: {
+    activeTask: TaskItem;
+    sourceColumnId: string | null;
+    targetColumnId: string;
+    targetTasks: TaskItem[];
+    sourceTasks: TaskItem[];
+    overTaskId: string | null;
+    isBelowOverItem: boolean;
+    scheduleDates: Record<ScheduleDayKey, string>;
+    parseToIsoWeekKey: (dateOnly: string) => string | null;
+    todayDate: string;
+}) => ScheduleDropResult | null;

package/dist/components/task/taskKanbanDropRules.js

@@ -0,0 +1,187 @@
+export const getGroupedTaskStatus = (task) => {
+    const status = task.status || 'task';
+    if (status === 'done' || status === 'cancelled')
+        return 'completed';
+    return status;
+};
+export const buildStatusTransitionUpdates = (task, targetStatus, nowIso) => {
+    const currentStatus = getGroupedTaskStatus(task);
+    if (currentStatus === targetStatus)
+        return null;
+    const updates = {
+        status: targetStatus
+    };
+    if (targetStatus === 'task' || targetStatus === 'on-hold') {
+        updates.inProgress = false;
+        updates.readyForReview = false;
+        updates.completed = false;
+        updates.cancelled = false;
+        updates.completedAt = null;
+        return updates;
+    }
+    if (targetStatus === 'in-progress') {
+        updates.inProgress = true;
+        updates.readyForReview = false;
+        updates.completed = false;
+        updates.cancelled = false;
+        updates.completedAt = null;
+        return updates;
+    }
+    if (targetStatus === 'review') {
+        updates.inProgress = false;
+        updates.readyForReview = true;
+        updates.completed = false;
+        updates.cancelled = false;
+        updates.completedAt = null;
+        return updates;
+    }
+    if (targetStatus === 'done' || targetStatus === 'completed') {
+        updates.status = 'done';
+        updates.inProgress = false;
+        updates.readyForReview = false;
+        updates.completed = true;
+        updates.cancelled = false;
+        updates.completedAt = nowIso;
+        return updates;
+    }
+    if (targetStatus === 'cancelled') {
+        updates.status = 'cancelled';
+        return updates;
+    }
+    return updates;
+};
+export const buildInsertIndex = ({ targetTasks, overTaskId, isBelowOverItem, }) => {
+    if (!overTaskId)
+        return targetTasks.length;
+    const overIndex = targetTasks.findIndex((task) => task.id === overTaskId);
+    if (overIndex < 0)
+        return targetTasks.length;
+    return overIndex + (isBelowOverItem ? 1 : 0);
+};
+export const reindexTasks = (tasks, baseUpdates = new Map()) => {
+    const updates = new Map(baseUpdates);
+    tasks.forEach((task, index) => {
+        updates.set(task.id, {
+            ...(updates.get(task.id) || {}),
+            orderInDay: index,
+        });
+    });
+    return updates;
+};
+const toUpdatePairs = (updates) => (Array.from(updates.entries()).map(([taskId, taskUpdates]) => ({ taskId, updates: taskUpdates })));
+const reindexSourceColumnAfterMove = ({ sourceColumnId, targetColumnId, sourceTasks, updates, }) => {
+    if (!sourceColumnId || sourceColumnId === targetColumnId)
+        return updates;
+    return reindexTasks(sourceTasks, updates);
+};
+export const buildBacklogDropUpdates = ({ activeTask, sourceColumnId, targetTasks, sourceTasks, insertAt, }) => {
+    const reorderedTarget = [...targetTasks];
+    reorderedTarget.splice(insertAt, 0, activeTask);
+    let updates = new Map();
+    reorderedTarget.forEach((task, index) => {
+        if (task.id === activeTask.id) {
+            updates.set(task.id, {
+                ...(updates.get(task.id) || {}),
+                ...(activeTask.scheduledDate ? { scheduledDate: null, scheduledWeekKey: null } : {}),
+                orderInDay: index,
+            });
+            return;
+        }
+        updates.set(task.id, {
+            ...(updates.get(task.id) || {}),
+            orderInDay: index,
+        });
+    });
+    updates = reindexSourceColumnAfterMove({
+        sourceColumnId,
+        targetColumnId: 'backlog',
+        sourceTasks,
+        updates,
+    });
+    return toUpdatePairs(updates);
+};
+export const buildExpiredReorderUpdates = ({ activeTask, targetTasks, insertAt, }) => {
+    const reorderedTarget = [...targetTasks];
+    reorderedTarget.splice(insertAt, 0, activeTask);
+    return toUpdatePairs(reindexTasks(reorderedTarget));
+};
+export const buildScheduledDayDropUpdates = ({ activeTask, sourceColumnId, targetColumnId, targetTasks, sourceTasks, insertAt, scheduledDate, scheduledWeekKey, }) => {
+    const reorderedTarget = [...targetTasks];
+    reorderedTarget.splice(insertAt, 0, activeTask);
+    let updates = new Map();
+    reorderedTarget.forEach((task, index) => {
+        if (task.id === activeTask.id) {
+            updates.set(task.id, {
+                ...(updates.get(task.id) || {}),
+                scheduledDate,
+                scheduledWeekKey,
+                orderInDay: index,
+            });
+            return;
+        }
+        updates.set(task.id, {
+            ...(updates.get(task.id) || {}),
+            orderInDay: index,
+        });
+    });
+    updates = reindexSourceColumnAfterMove({
+        sourceColumnId,
+        targetColumnId,
+        sourceTasks,
+        updates,
+    });
+    return toUpdatePairs(updates);
+};
+export const buildScheduleDropResult = ({ activeTask, sourceColumnId, targetColumnId, targetTasks, sourceTasks, overTaskId, isBelowOverItem, scheduleDates, parseToIsoWeekKey, todayDate, }) => {
+    const scheduleKeys = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+    const isScheduleReorderColumn = targetColumnId === 'backlog' || targetColumnId === 'expired' || scheduleKeys.includes(targetColumnId);
+    if (!isScheduleReorderColumn)
+        return null;
+    const insertAt = buildInsertIndex({ targetTasks, overTaskId, isBelowOverItem });
+    if (targetColumnId === 'expired') {
+        if (sourceColumnId !== 'expired')
+            return null;
+        return {
+            kind: 'updates',
+            updates: buildExpiredReorderUpdates({ activeTask, targetTasks, insertAt }),
+        };
+    }
+    if (targetColumnId === 'backlog') {
+        return {
+            kind: 'updates',
+            updates: buildBacklogDropUpdates({
+                activeTask,
+                sourceColumnId,
+                targetTasks,
+                sourceTasks,
+                insertAt,
+            }),
+        };
+    }
+    if (!scheduleKeys.includes(targetColumnId))
+        return null;
+    const scheduledDate = scheduleDates[targetColumnId];
+    if (!scheduledDate)
+        return null;
+    const isTerminal = activeTask.status === 'done' || activeTask.status === 'cancelled';
+    if (!isTerminal && scheduledDate < todayDate) {
+        return {
+            kind: 'blocked',
+            reason: 'Only completed work can be scheduled in the past.',
+        };
+    }
+    return {
+        kind: 'updates',
+        updates: buildScheduledDayDropUpdates({
+            activeTask,
+            sourceColumnId,
+            targetColumnId,
+            targetTasks,
+            sourceTasks,
+            insertAt,
+            scheduledDate,
+            scheduledWeekKey: parseToIsoWeekKey(scheduledDate),
+        }),
+        selectedDate: scheduledDate,
+    };
+};

package/dist/components/task/taskKanbanDropRules.test.d.ts

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