@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/hooks/tasks/useTaskDescriptionImageDraftRecovery.js

@@ -0,0 +1,197 @@
+import { useCallback, useEffect, useRef } from 'react';
+const defaultFetch = (input, init) => globalThis.fetch(input, init);
+export const TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY = 'taskforce.task-description-image-draft-recovery.v1';
+const RETRY_DELAYS_MS = [1_000, 5_000, 15_000, 60_000];
+const MAX_AUTOMATIC_RETRY_ATTEMPTS = 8;
+const DORMANT_RETRY_AT = Number.MAX_SAFE_INTEGER;
+export function taskDescriptionImageDraftRetryDelay(attempts) {
+    const index = Math.max(0, Math.min(RETRY_DELAYS_MS.length - 1, Math.floor(attempts) - 1));
+    return RETRY_DELAYS_MS[index];
+}
+function recordKey(record) {
+    return `${record.workspaceId}\u0000${record.createdByUserId}\u0000${record.draftUploadId}`;
+}
+function isRecoveryRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return typeof record.workspaceId === 'string'
+        && Boolean(record.workspaceId.trim())
+        && typeof record.createdByUserId === 'string'
+        && Boolean(record.createdByUserId.trim())
+        && typeof record.draftUploadId === 'string'
+        && Boolean(record.draftUploadId.trim())
+        && (record.resolution === 'promote' || record.resolution === 'discard')
+        && Number.isFinite(record.attempts)
+        && Number.isFinite(record.nextAttemptAt)
+        && Number.isFinite(record.createdAt);
+}
+function readRecoveryRecords(storage) {
+    if (!storage)
+        return [];
+    try {
+        const parsed = JSON.parse(storage.getItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY) || '[]');
+        if (!Array.isArray(parsed))
+            return [];
+        const records = new Map();
+        parsed.filter(isRecoveryRecord).forEach((record) => {
+            records.set(recordKey(record), record);
+        });
+        return [...records.values()];
+    }
+    catch {
+        return [];
+    }
+}
+function writeRecoveryRecords(storage, records) {
+    if (!storage)
+        return;
+    try {
+        if (records.length === 0) {
+            storage.removeItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY);
+            return;
+        }
+        storage.setItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY, JSON.stringify(records));
+    }
+    catch {
+        // The request still gets an immediate attempt when browser storage is unavailable.
+    }
+}
+function updateRecoveryRecords(storage, update) {
+    const next = update(readRecoveryRecords(storage));
+    writeRecoveryRecords(storage, next);
+    return next;
+}
+function defaultStorage() {
+    try {
+        return globalThis.localStorage || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function useTaskDescriptionImageDraftRecovery(workspaceId, createdByUserId, options = {}) {
+    const fetchImpl = options.fetchImpl || defaultFetch;
+    const storage = options.storage === undefined ? defaultStorage() : options.storage;
+    const now = options.now || Date.now;
+    const timerRef = useRef(null);
+    const inFlightRef = useRef(new Map());
+    const drainRef = useRef(async () => { });
+    const clearRetryTimer = useCallback(() => {
+        if (timerRef.current === null)
+            return;
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+    }, []);
+    const scheduleRetry = useCallback(() => {
+        clearRetryTimer();
+        const nextRecord = readRecoveryRecords(storage)
+            .filter((record) => (record.workspaceId === workspaceId
+            && record.createdByUserId === createdByUserId
+            && record.nextAttemptAt < DORMANT_RETRY_AT))
+            .sort((left, right) => left.nextAttemptAt - right.nextAttemptAt)[0];
+        if (!nextRecord)
+            return;
+        const delay = Math.max(0, nextRecord.nextAttemptAt - now());
+        timerRef.current = setTimeout(() => {
+            timerRef.current = null;
+            void drainRef.current(false);
+        }, delay);
+    }, [clearRetryTimer, createdByUserId, now, storage, workspaceId]);
+    const attemptRecovery = useCallback((record) => {
+        const key = recordKey(record);
+        const existing = inFlightRef.current.get(key);
+        if (existing)
+            return existing;
+        const request = (async () => {
+            await Promise.resolve();
+            try {
+                const response = await fetchImpl(`/api/taskforce/context-upload/draft/${record.resolution}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: record.workspaceId,
+                        draftUploadId: record.draftUploadId,
+                        uploadPurpose: 'task-description-draft',
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`Draft upload ${record.resolution} was rejected (${response.status}).`);
+                }
+                updateRecoveryRecords(storage, (records) => (records.filter((candidate) => recordKey(candidate) !== key)));
+            }
+            catch (error) {
+                updateRecoveryRecords(storage, (records) => records.map((candidate) => {
+                    if (recordKey(candidate) !== key)
+                        return candidate;
+                    const attempts = Math.min(Number.MAX_SAFE_INTEGER, candidate.attempts + 1);
+                    return {
+                        ...candidate,
+                        attempts,
+                        nextAttemptAt: attempts >= MAX_AUTOMATIC_RETRY_ATTEMPTS
+                            ? DORMANT_RETRY_AT
+                            : now() + taskDescriptionImageDraftRetryDelay(attempts),
+                    };
+                }));
+                throw error;
+            }
+            finally {
+                inFlightRef.current.delete(key);
+                scheduleRetry();
+            }
+        })();
+        inFlightRef.current.set(key, request);
+        return request;
+    }, [fetchImpl, now, scheduleRetry, storage]);
+    const drain = useCallback(async (force = false) => {
+        const currentTime = now();
+        const dueRecords = readRecoveryRecords(storage).filter((record) => (record.workspaceId === workspaceId
+            && record.createdByUserId === createdByUserId
+            && (force || record.nextAttemptAt <= currentTime)));
+        await Promise.allSettled(dueRecords.map((record) => attemptRecovery(record)));
+        scheduleRetry();
+    }, [attemptRecovery, createdByUserId, now, scheduleRetry, storage, workspaceId]);
+    drainRef.current = drain;
+    useEffect(() => {
+        void drain(true);
+        const retryWhenOnline = () => { void drain(true); };
+        const retryWhenVisible = () => {
+            if (document.visibilityState === 'visible')
+                void drain(true);
+        };
+        const retryAfterStorageChange = (event) => {
+            if (event.key === TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY)
+                void drain(false);
+        };
+        window.addEventListener('online', retryWhenOnline);
+        window.addEventListener('storage', retryAfterStorageChange);
+        document.addEventListener('visibilitychange', retryWhenVisible);
+        return () => {
+            clearRetryTimer();
+            window.removeEventListener('online', retryWhenOnline);
+            window.removeEventListener('storage', retryAfterStorageChange);
+            document.removeEventListener('visibilitychange', retryWhenVisible);
+        };
+    }, [clearRetryTimer, drain]);
+    const resolveDraft = useCallback(async (input) => {
+        const draftUploadId = input.draftUploadId.trim();
+        if (!workspaceId || !createdByUserId || !draftUploadId)
+            return;
+        const queuedAt = now();
+        const record = {
+            workspaceId,
+            createdByUserId,
+            draftUploadId,
+            resolution: input.resolution,
+            attempts: 0,
+            nextAttemptAt: queuedAt,
+            createdAt: queuedAt,
+        };
+        updateRecoveryRecords(storage, (records) => [
+            ...records.filter((candidate) => recordKey(candidate) !== recordKey(record)),
+            record,
+        ]);
+        await attemptRecovery(record);
+    }, [attemptRecovery, createdByUserId, now, storage, workspaceId]);
+    return { resolveDraft };
+}

package/dist/hooks/tasks/useTaskEditorNavigation.d.ts

@@ -1,5 +1,12 @@
 import type { AttachmentItem, CategoryConfig, ChecklistItem, Comment, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
 type TaskforceTab = 'add' | 'tasks' | 'settings';
+type ApplyTaskOptions = {
+    preserveReturnTrail?: boolean;
+    adoptAsBaseline?: boolean;
+};
+type LoadTaskOptions = ApplyTaskOptions & {
+    shouldApply?: () => boolean;
+};
 interface UseTaskEditorNavigationInput {
     activeCategories: CategoryConfig[];
     activeTypes: Array<{
@@ -10,6 +17,7 @@ interface UseTaskEditorNavigationInput {
     attachments: Array<string | AttachmentItem>;
     checklistItems: ChecklistItem[];
     comments: Comment[];
+    cancelTaskDetailLoad?: () => void;
     description: string;
     editingTaskId: string | null;
     flushPendingAutoSave: () => Promise<boolean>;
@@ -17,7 +25,12 @@ interface UseTaskEditorNavigationInput {
     getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
     getTitleDraft?: () => string;
     lastUsedCategory: string;
+    loadTaskDetail?: (task: TaskItem, options?: {
+        shouldCommit?: () => boolean;
+        force?: boolean;
+    }) => Promise<TaskItem | null>;
     newCommentText: string;
+    onTaskApplied?: (task: TaskItem) => void;
     relationshipTasks: TaskItem[];
     workstreams: WorkstreamItem[];
     showArchive: boolean;
@@ -56,9 +69,9 @@ export declare function useTaskEditorNavigation(input: UseTaskEditorNavigationIn
     resetForm: () => void;
     resolveTaskIdInput: (value: string) => TaskItem | null;
     resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
-    handleEdit: (task: TaskItem, options?: {
-        preserveReturnTrail?: boolean;
-    }) => void;
+    handleEdit: (task: TaskItem, options?: ApplyTaskOptions) => void;
+    refreshTaskDetail: (task: TaskItem, options?: LoadTaskOptions) => Promise<TaskItem | null>;
+    applyTaskToEditor: (task: TaskItem, options?: ApplyTaskOptions) => void;
     handleOpenTaskById: (taskId: string) => void;
     returnToPreviousTask: () => boolean;
     clearReturnToParentTask: () => void;

package/dist/hooks/tasks/useTaskEditorNavigation.js

@@ -1,17 +1,26 @@
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
 import { getTaskReferenceLabel, parseTaskReference } from '../../utils/taskReferences';
 import { formatWorkstreamReference, parseWorkstreamReference } from '../../utils/planningReferences';
 import { buildDefaultFormTaxonomies } from '../../utils/taxonomyFormDefaults.js';
 export function useTaskEditorNavigation(input) {
-    const { activeCategories, activeTypes, activeTab, attachments, checklistItems, comments, description, editingTaskId, flushPendingAutoSave, getDescriptionDraft, getPreferredCategoryValue, getTitleDraft, lastUsedCategory, newCommentText, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setAssignee, setAttachments, setAttachmentsDirty, setCategory, setChecklistItems, setComments, setComplexity, setDescription, setDueDate, setEditingTaskId, setError, setFormTaxonomies, setIsOpen, setNewCommentText, setPendingNavigation, setWorkstreamInput, setPriority, setScheduledDate, setShowArchive, setStatus, setTaskReturnTrail, setTitle, setType, setUnsavedModalOpen, taskReturnTrail, title, } = input;
+    const { activeCategories, activeTypes, activeTab, attachments, checklistItems, comments, cancelTaskDetailLoad, description, editingTaskId, flushPendingAutoSave, getDescriptionDraft, getPreferredCategoryValue, getTitleDraft, lastUsedCategory, loadTaskDetail, newCommentText, onTaskApplied, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setAssignee, setAttachments, setAttachmentsDirty, setCategory, setChecklistItems, setComments, setComplexity, setDescription, setDueDate, setEditingTaskId, setError, setFormTaxonomies, setIsOpen, setNewCommentText, setPendingNavigation, setWorkstreamInput, setPriority, setScheduledDate, setShowArchive, setStatus, setTaskReturnTrail, setTitle, setType, setUnsavedModalOpen, taskReturnTrail, title, } = input;
+    const editRequestSequenceRef = useRef(0);
+    const invalidatePendingEdit = useCallback(() => {
+        editRequestSequenceRef.current += 1;
+        cancelTaskDetailLoad?.();
+    }, [cancelTaskDetailLoad]);
     const getPreferredTypeValue = useCallback(() => {
         return activeTypes.find((entry) => String(entry.value || '').trim().length > 0)?.value || DEFAULT_TYPE_VALUE;
     }, [activeTypes]);
     const handleNavigation = useCallback(async (action) => {
+        const navigate = () => {
+            invalidatePendingEdit();
+            action();
+        };
         if (editingTaskId) {
             if (await flushPendingAutoSave()) {
-                action();
+                navigate();
             }
             return;
         }
@@ -22,10 +31,10 @@ export function useTaskEditorNavigation(input) {
             comments.length > 0 ||
             attachments.length > 0;
         if (!hasChanges) {
-            action();
+            navigate();
             return;
         }
-        setPendingNavigation(() => action);
+        setPendingNavigation(() => navigate);
         setUnsavedModalOpen(true);
     }, [
         attachments,
@@ -36,15 +45,18 @@ export function useTaskEditorNavigation(input) {
         getDescriptionDraft,
         getTitleDraft,
         checklistItems,
+        invalidatePendingEdit,
         newCommentText,
         setPendingNavigation,
         setUnsavedModalOpen,
         title,
     ]);
     const handleClose = useCallback(() => {
+        invalidatePendingEdit();
         setIsOpen(false);
-    }, [setIsOpen]);
+    }, [invalidatePendingEdit, setIsOpen]);
     const resetForm = useCallback(() => {
+        invalidatePendingEdit();
         setEditingTaskId(null);
         setTitle('');
         setDescription('');
@@ -76,6 +88,7 @@ export function useTaskEditorNavigation(input) {
         activeCategories,
         getPreferredCategoryValue,
         getPreferredTypeValue,
+        invalidatePendingEdit,
         lastUsedCategory,
         setAssignee,
         setAttachments,
@@ -134,7 +147,7 @@ export function useTaskEditorNavigation(input) {
             return exactTitle;
         return null;
     }, [workstreams]);
-    const handleEdit = useCallback((task, options) => {
+    const applyTaskToEditor = useCallback((task, options) => {
         if (!options?.preserveReturnTrail) {
             setTaskReturnTrail([]);
         }
@@ -157,6 +170,8 @@ export function useTaskEditorNavigation(input) {
         setAttachments(task.attachments || []);
         setAttachmentsDirty(false);
         setActiveTab('add');
+        if (options?.adoptAsBaseline !== false)
+            onTaskApplied?.(task);
     }, [
         activeCategories,
         getPreferredCategoryValue,
@@ -179,20 +194,62 @@ export function useTaskEditorNavigation(input) {
         setTaskReturnTrail,
         setTitle,
         setType,
+        onTaskApplied,
         workstreams
     ]);
+    const loadAndApplyTask = useCallback(async (task, options) => {
+        const requestSequence = editRequestSequenceRef.current + 1;
+        editRequestSequenceRef.current = requestSequence;
+        if (!loadTaskDetail) {
+            cancelTaskDetailLoad?.();
+            applyTaskToEditor(task, { preserveReturnTrail: options?.preserveReturnTrail });
+            return task;
+        }
+        if (!task.isSummary) {
+            cancelTaskDetailLoad?.();
+            const detail = options?.shouldApply
+                ? await loadTaskDetail(task, { shouldCommit: options.shouldApply })
+                : await loadTaskDetail(task);
+            if (editRequestSequenceRef.current === requestSequence) {
+                const taskToApply = detail || task;
+                applyTaskToEditor(taskToApply, { preserveReturnTrail: options?.preserveReturnTrail });
+                return taskToApply;
+            }
+            return null;
+        }
+        const detail = options?.shouldApply
+            ? await loadTaskDetail(task, { shouldCommit: options.shouldApply })
+            : await loadTaskDetail(task);
+        if (detail
+            && editRequestSequenceRef.current === requestSequence) {
+            applyTaskToEditor(detail, { preserveReturnTrail: options?.preserveReturnTrail });
+            return detail;
+        }
+        return null;
+    }, [applyTaskToEditor, cancelTaskDetailLoad, loadTaskDetail]);
+    const handleEdit = useCallback((task, options) => {
+        void loadAndApplyTask(task, options);
+    }, [loadAndApplyTask]);
+    const refreshTaskDetail = useCallback((task, options) => loadAndApplyTask(task, options), [loadAndApplyTask]);
     const handleOpenTaskById = useCallback((taskId) => {
         const target = relationshipTasks.find((task) => task.id === taskId);
         if (!target)
             return;
+        const openTarget = () => {
+            if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
+                setTaskReturnTrail((prev) => prev[prev.length - 1] === editingTaskId ? prev : [...prev, editingTaskId]);
+            }
+            if (target.isArchived && !showArchive) {
+                setShowArchive(true);
+            }
+            handleEdit(target, { preserveReturnTrail: true });
+        };
         if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
-            setTaskReturnTrail((prev) => prev[prev.length - 1] === editingTaskId ? prev : [...prev, editingTaskId]);
-        }
-        if (target.isArchived && !showArchive) {
-            setShowArchive(true);
+            void handleNavigation(openTarget);
+            return;
         }
-        handleEdit(target, { preserveReturnTrail: true });
-    }, [activeTab, editingTaskId, handleEdit, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive]);
+        openTarget();
+    }, [activeTab, editingTaskId, handleEdit, handleNavigation, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive]);
     const returnToPreviousTask = useCallback(() => {
         if (activeTab !== 'add' || !editingTaskId || taskReturnTrail.length === 0)
             return false;
@@ -224,6 +281,8 @@ export function useTaskEditorNavigation(input) {
         resolveTaskIdInput,
         resolveWorkstreamIdInput,
         handleEdit,
+        refreshTaskDetail,
+        applyTaskToEditor,
         handleOpenTaskById,
         returnToPreviousTask,
         clearReturnToParentTask

package/dist/hooks/tasks/useTaskFormActions.d.ts

@@ -1,6 +1,7 @@
 import type { AttachmentItem, CategoryConfig, ChecklistItem, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
 import type { DurableTaskCreateMutationAdapter } from '../sync/useDurableTaskCreateMutation.js';
 import { createCloudTaskHttpMutationClient } from './taskHttpMutation.js';
+import type { TaskEditorDraft } from '../../utils/taskEditorReconciliation.js';
 interface UseTaskFormActionsInput {
     activeCategories: CategoryConfig[];
     activeTab: 'add' | 'tasks' | 'settings';
@@ -20,13 +21,18 @@ interface UseTaskFormActionsInput {
     taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
     updateTask?: (taskId: string, updates: Partial<TaskItem>) => Promise<boolean | void>;
     editingTaskId: string | null;
+    editorBaselineDraft?: TaskEditorDraft | null;
+    revisionConflict?: boolean;
     fetchTasks: (isSilent?: boolean) => Promise<void>;
     formTaxonomies: Record<string, string | number | string[] | number[]>;
+    getAttachmentsDraft?: () => Array<string | AttachmentItem>;
     getDescriptionDraft?: () => string;
     getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
     getTitleDraft?: () => string;
+    awaitPendingDescriptionImageUpload?: () => Promise<void>;
     mergeTaskFromServer: (task: unknown) => void;
     onTaskCreated?: (task: TaskItem) => void;
+    onTaskCreateAccepted?: (task: TaskItem) => Promise<void> | void;
     workstreamInput: string;
     priority: number | string;
     pushNotice: (message: string, tone?: 'success' | 'error' | 'info') => void;
@@ -52,6 +58,9 @@ interface UseTaskFormActionsInput {
 export type TaskAutoSaveState = 'idle' | 'saving' | 'saved' | 'error';
 export declare function useTaskFormActions(input: UseTaskFormActionsInput): {
     autoSaveState: TaskAutoSaveState;
+    hasUnsavedChanges: boolean;
+    hasUnsavedChangesNow: () => boolean;
+    hasPendingAutoSave: boolean;
     flushAutoSave: () => Promise<boolean>;
     scheduleWarningPrompt: {
         dueDate: string;