@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/hooks/tasks/taskHttpMutation.js

@@ -0,0 +1,134 @@
+export function createTaskHttpOperationId() {
+    if (!globalThis.crypto?.randomUUID) {
+        throw new Error('Secure task operation identity generation is unavailable.');
+    }
+    return `operation-${globalThis.crypto.randomUUID()}`;
+}
+export function createTaskHttpMutationIdentity() {
+    const operationId = createTaskHttpOperationId();
+    return {
+        operationId,
+        taskId: `task-${globalThis.crypto.randomUUID()}`,
+    };
+}
+export async function fetchTaskHttpMutation(url, init, operationId) {
+    const requestInit = {
+        ...init,
+        headers: {
+            ...(init.headers || {}),
+            'x-taskforce-operation-id': operationId,
+        },
+    };
+    try {
+        return await fetch(url, requestInit);
+    }
+    catch {
+        return fetch(url, requestInit);
+    }
+}
+export async function isConclusiveTaskHttpResponse(response) {
+    if (response.ok)
+        return false;
+    if (![400, 404, 409, 422].includes(response.status))
+        return false;
+    const payload = await response.clone().json().catch(() => null);
+    const code = String(payload?.code || '').trim();
+    return new Set([
+        'TASK_CREATE_UNSUPPORTED_INPUT',
+        'DURABLE_TASK_HTTP_PATCH_UNSUPPORTED',
+        'DURABLE_TASK_PATCH_INVALID',
+        'WORKSPACE_SYNC_OPERATION_ID_REQUIRED',
+        'TASK_NOT_FOUND',
+        'TASK_ARCHIVED_READ_ONLY',
+        'TASK_CHECKLIST_INVALID',
+        'TASK_ATTACHMENT_LINKS_INVALID',
+        'TASK_COMMENT_INVALID',
+        'TASK_COMMENT_IDENTITY_CONFLICT',
+    ]).has(code);
+}
+function stableTaskCreateCandidate(candidate) {
+    const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...stable } = candidate;
+    return stable;
+}
+function cloudCreateParticipantStorageKey(workspaceId) {
+    return `taskforce.sync.v3.cloud-task-create-participant-v1:${workspaceId}`;
+}
+export function createCloudTaskHttpMutationClient(input) {
+    const createAttempts = input?.createAttempts || new IndexedDbLocalTaskCreateAttemptStore();
+    const operationIdentities = input?.operationIdentities || new IndexedDbLocalOperationIdentityStore();
+    const volatileParticipants = new Map();
+    const readParticipant = (workspaceId) => {
+        const existing = globalThis.sessionStorage?.getItem(cloudCreateParticipantStorageKey(workspaceId));
+        if (existing) {
+            try {
+                const parsed = JSON.parse(existing);
+                if (typeof parsed.participantId === 'string' && parsed.participantId.trim()) {
+                    return {
+                        participantId: parsed.participantId.trim(),
+                        draftFingerprint: typeof parsed.draftFingerprint === 'string'
+                            ? parsed.draftFingerprint
+                            : null,
+                    };
+                }
+            }
+            catch { /* replace malformed state below */ }
+        }
+        const volatile = volatileParticipants.get(workspaceId);
+        if (volatile)
+            return volatile;
+        return { participantId: createTaskHttpOperationId(), draftFingerprint: null };
+    };
+    const writeParticipant = (workspaceId, state) => {
+        volatileParticipants.set(workspaceId, state);
+        globalThis.sessionStorage?.setItem(cloudCreateParticipantStorageKey(workspaceId), JSON.stringify(state));
+    };
+    const rotateParticipant = (workspaceId) => {
+        writeParticipant(workspaceId, {
+            participantId: createTaskHttpOperationId(),
+            draftFingerprint: null,
+        });
+    };
+    return {
+        async prepareCreate(workspaceId, candidate) {
+            const identity = createTaskHttpMutationIdentity();
+            const candidateWithId = { ...candidate, id: identity.taskId };
+            const draftFingerprint = await fingerprintLocalOperation({
+                workspaceId,
+                task: stableTaskCreateCandidate(candidate),
+            });
+            let participant = readParticipant(workspaceId);
+            if (participant.draftFingerprint && participant.draftFingerprint !== draftFingerprint) {
+                participant = { participantId: createTaskHttpOperationId(), draftFingerprint };
+            }
+            else {
+                participant = { ...participant, draftFingerprint };
+            }
+            writeParticipant(workspaceId, participant);
+            const attempt = await createAttempts.claim(workspaceId, participant.participantId, candidateWithId, () => identity.operationId);
+            const storedCandidate = stableTaskCreateCandidate(attempt.task);
+            return {
+                operationId: attempt.operationId,
+                body: attempt.task,
+                recoveredChangedInput: canonicalWorkspaceSyncJson(storedCandidate)
+                    !== canonicalWorkspaceSyncJson(stableTaskCreateCandidate(candidate)),
+            };
+        },
+        async confirmCreate(workspaceId, operationId) {
+            await createAttempts.markResolved(workspaceId, operationId);
+            rotateParticipant(workspaceId);
+        },
+        resetCreateDraft(workspaceId) {
+            rotateParticipant(workspaceId);
+        },
+        async prepareUpdate(workspaceId, url, body, observedPrecondition) {
+            const fingerprint = canonicalWorkspaceSyncJson({ workspaceId, url, body, observedPrecondition });
+            const identity = await operationIdentities.getOrCreate(fingerprint, createTaskHttpOperationId);
+            return { fingerprint, operationId: identity.operationId };
+        },
+        confirmUpdate(fingerprint, operationId) {
+            return operationIdentities.deleteIfMatches(fingerprint, operationId);
+        },
+    };
+}
+import { canonicalWorkspaceSyncJson } from '../../sync/v3/canonicalWorkspaceSyncJson.js';
+import { IndexedDbLocalOperationIdentityStore, IndexedDbLocalTaskCreateAttemptStore, fingerprintLocalOperation, } from '../../sync/v3/localOperationIdentityStore.js';

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

@@ -1,10 +1,15 @@
-import type { Comment, InitiativeItem, TaskItem, WorkstreamItem } from '../../types';
+import type { ChecklistItem, Comment, InitiativeItem, TaskAssignee, TaskItem, WorkstreamItem } from '../../types';
 interface UseCurrentTaskRelationsInput {
     editingTaskId: string | null;
     relationshipTasks: TaskItem[];
     initiatives?: InitiativeItem[];
     workstreams?: WorkstreamItem[];
+    workstreamInput?: string;
+    resolveWorkstreamIdInput?: (value: string) => WorkstreamItem | null;
     supplementalTasks?: TaskItem[];
+    assignee: TaskAssignee;
+    setAssignee: (value: TaskAssignee) => void;
+    setChecklistItems: (value: ChecklistItem[]) => void;
     setComments: (value: Comment[]) => void;
 }
 export declare function useCurrentTaskRelations(input: UseCurrentTaskRelationsInput): {

package/dist/hooks/tasks/useCurrentTaskRelations.js

@@ -1,6 +1,7 @@
-import { useEffect, useMemo } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 export function useCurrentTaskRelations(input) {
-    const { editingTaskId, relationshipTasks, initiatives = [], workstreams = [], supplementalTasks = [], setComments } = input;
+    const { editingTaskId, relationshipTasks, initiatives = [], workstreams = [], workstreamInput = '', resolveWorkstreamIdInput, supplementalTasks = [], assignee, setAssignee, setChecklistItems, setComments, } = input;
+    const observedAssigneeRef = useRef(null);
     const availableTasks = useMemo(() => {
         if (supplementalTasks.length === 0)
             return relationshipTasks;
@@ -17,13 +18,38 @@ export function useCurrentTaskRelations(input) {
     useEffect(() => {
         if (!editingTaskId)
             return;
+        setChecklistItems(currentTask?.checklistItems || []);
         setComments(currentTask?.comments || []);
-    }, [editingTaskId, currentTask?.id, currentTask?.updatedAt, currentTask?.comments, setComments]);
+    }, [editingTaskId, currentTask?.id, currentTask?.updatedAt, currentTask?.checklistItems, currentTask?.comments, setChecklistItems, setComments]);
+    useEffect(() => {
+        if (!editingTaskId || !currentTask) {
+            observedAssigneeRef.current = null;
+            return;
+        }
+        const nextAssignee = (currentTask.assignee || 'unassigned');
+        const observed = observedAssigneeRef.current;
+        if (!observed || observed.taskId !== editingTaskId) {
+            observedAssigneeRef.current = { taskId: editingTaskId, assignee: nextAssignee };
+            if (assignee !== nextAssignee)
+                setAssignee(nextAssignee);
+            return;
+        }
+        if (observed.assignee !== nextAssignee) {
+            // Adopt an external handoff only while the editor still holds the
+            // previously observed value; a different value is a local edit.
+            if (assignee === observed.assignee)
+                setAssignee(nextAssignee);
+            observedAssigneeRef.current = { taskId: editingTaskId, assignee: nextAssignee };
+        }
+    }, [assignee, currentTask?.assignee, currentTask?.id, editingTaskId, setAssignee]);
     const currentTaskWorkstream = useMemo(() => {
-        if (!currentTask?.workstreamId)
+        if (currentTask?.workstreamId) {
+            return workstreams.find((workstream) => workstream.id === currentTask.workstreamId);
+        }
+        if (editingTaskId || !workstreamInput.trim())
             return undefined;
-        return workstreams.find((workstream) => workstream.id === currentTask.workstreamId);
-    }, [currentTask, workstreams]);
+        return resolveWorkstreamIdInput?.(workstreamInput) || undefined;
+    }, [currentTask, editingTaskId, resolveWorkstreamIdInput, workstreamInput, workstreams]);
     const currentTaskInitiative = useMemo(() => {
         if (!currentTaskWorkstream?.initiativeId)
             return undefined;

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

@@ -12,8 +12,10 @@ interface UseTaskEditorNavigationInput {
     comments: Comment[];
     description: string;
     editingTaskId: string | null;
-    flushPendingAutoSave: () => Promise<void>;
+    flushPendingAutoSave: () => Promise<boolean>;
+    getDescriptionDraft?: () => string;
     getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
+    getTitleDraft?: () => string;
     lastUsedCategory: string;
     newCommentText: string;
     relationshipTasks: TaskItem[];
@@ -21,7 +23,6 @@ interface UseTaskEditorNavigationInput {
     showArchive: boolean;
     taxonomies: TaxonomyDefinition[];
     setActiveTab: (tab: TaskforceTab) => void;
-    setApproach: (value: string) => void;
     setAssignee: (value: TaskAssignee) => void;
     setAttachments: (value: Array<string | AttachmentItem>) => void;
     setAttachmentsDirty: (value: boolean) => void;
@@ -50,7 +51,7 @@ interface UseTaskEditorNavigationInput {
     title: string;
 }
 export declare function useTaskEditorNavigation(input: UseTaskEditorNavigationInput): {
-    handleNavigation: (action: () => void) => void;
+    handleNavigation: (action: () => void) => Promise<void>;
     handleClose: () => void;
     resetForm: () => void;
     resolveTaskIdInput: (value: string) => TaskItem | null;

package/dist/hooks/tasks/useTaskEditorNavigation.js

@@ -4,18 +4,19 @@ import { getTaskReferenceLabel, parseTaskReference } from '../../utils/taskRefer
 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, getPreferredCategoryValue, lastUsedCategory, newCommentText, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setApproach, 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, 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 getPreferredTypeValue = useCallback(() => {
         return activeTypes.find((entry) => String(entry.value || '').trim().length > 0)?.value || DEFAULT_TYPE_VALUE;
     }, [activeTypes]);
-    const handleNavigation = useCallback((action) => {
+    const handleNavigation = useCallback(async (action) => {
         if (editingTaskId) {
-            void flushPendingAutoSave();
-            action();
+            if (await flushPendingAutoSave()) {
+                action();
+            }
             return;
         }
-        const hasChanges = title.trim() !== '' ||
-            description.trim() !== '' ||
+        const hasChanges = (getTitleDraft?.() ?? title).trim() !== '' ||
+            (getDescriptionDraft?.() ?? description).trim() !== '' ||
             checklistItems.length > 0 ||
             newCommentText.trim() !== '' ||
             comments.length > 0 ||
@@ -32,6 +33,8 @@ export function useTaskEditorNavigation(input) {
         description,
         editingTaskId,
         flushPendingAutoSave,
+        getDescriptionDraft,
+        getTitleDraft,
         checklistItems,
         newCommentText,
         setPendingNavigation,
@@ -58,7 +61,6 @@ export function useTaskEditorNavigation(input) {
         setPriority(2);
         setComplexity(3);
         setStatus('task');
-        setApproach('default');
         setAssignee('unassigned');
         setScheduledDate('');
         setDueDate('');
@@ -75,7 +77,6 @@ export function useTaskEditorNavigation(input) {
         getPreferredCategoryValue,
         getPreferredTypeValue,
         lastUsedCategory,
-        setApproach,
         setAssignee,
         setAttachments,
         setAttachmentsDirty,
@@ -145,7 +146,6 @@ export function useTaskEditorNavigation(input) {
         setPriority(typeof task.priority === 'number' ? task.priority : 2);
         setComplexity(typeof task.complexity === 'number' ? task.complexity : 3);
         setStatus(task.status || 'task');
-        setApproach(task.approach || 'default');
         setAssignee((task.assignee || 'unassigned'));
         setScheduledDate(task.scheduledDate || '');
         setDueDate(task.dueDate || '');
@@ -154,9 +154,6 @@ export function useTaskEditorNavigation(input) {
         setChecklistItems(task.checklistItems || []);
         setComments(task.comments || []);
         setFormTaxonomies(task.taxonomies || {});
-        if (task.taxonomies?.approach) {
-            setApproach(task.taxonomies.approach);
-        }
         setAttachments(task.attachments || []);
         setAttachmentsDirty(false);
         setActiveTab('add');
@@ -165,7 +162,6 @@ export function useTaskEditorNavigation(input) {
         getPreferredCategoryValue,
         getPreferredTypeValue,
         setActiveTab,
-        setApproach,
         setAssignee,
         setAttachments,
         setAttachmentsDirty,

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

@@ -1,9 +1,10 @@
 import type { AttachmentItem, CategoryConfig, ChecklistItem, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
+import type { DurableTaskCreateMutationAdapter } from '../sync/useDurableTaskCreateMutation.js';
+import { createCloudTaskHttpMutationClient } from './taskHttpMutation.js';
 interface UseTaskFormActionsInput {
     activeCategories: CategoryConfig[];
     activeTab: 'add' | 'tasks' | 'settings';
     apiEndpoint: string;
-    approach: string;
     assignee: TaskAssignee;
     attachments: Array<string | AttachmentItem>;
     attachmentsDirty: boolean;
@@ -13,16 +14,25 @@ interface UseTaskFormActionsInput {
     complexity: number | string;
     description: string;
     dueDate: string;
+    createTaskDurably?: DurableTaskCreateMutationAdapter;
+    durableTaskHttpRootActivationEnabled?: boolean;
+    workspaceId: string;
+    taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
+    updateTask?: (taskId: string, updates: Partial<TaskItem>) => Promise<boolean | void>;
     editingTaskId: string | null;
     fetchTasks: (isSilent?: boolean) => Promise<void>;
     formTaxonomies: Record<string, string | number | string[] | number[]>;
+    getDescriptionDraft?: () => string;
     getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
+    getTitleDraft?: () => string;
     mergeTaskFromServer: (task: unknown) => void;
+    onTaskCreated?: (task: TaskItem) => void;
     workstreamInput: string;
     priority: number | string;
     pushNotice: (message: string, tone?: 'success' | 'error' | 'info') => void;
     queueWorkspaceSyncFromAuthoritativeTaskState: () => void;
     relationshipTasks: TaskItem[];
+    supplementalTasks?: TaskItem[];
     resetForm: () => void;
     resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
     scheduledDate: string;
@@ -36,12 +46,13 @@ interface UseTaskFormActionsInput {
     status: TaskStatus;
     title: string;
     taxonomies: TaxonomyDefinition[];
+    textDraftOccupied?: boolean;
     type: string;
 }
 export type TaskAutoSaveState = 'idle' | 'saving' | 'saved' | 'error';
 export declare function useTaskFormActions(input: UseTaskFormActionsInput): {
     autoSaveState: TaskAutoSaveState;
-    flushAutoSave: () => Promise<void>;
+    flushAutoSave: () => Promise<boolean>;
     scheduleWarningPrompt: {
         dueDate: string;
         scheduledDate: string;
@@ -49,6 +60,10 @@ export declare function useTaskFormActions(input: UseTaskFormActionsInput): {
     saveTask: (options?: {
         quiet?: boolean;
         source?: "manual" | "autosave";
+        textDraft?: {
+            title: string;
+            description: string;
+        };
     }) => Promise<boolean>;
     handleSubmit: (event: React.FormEvent) => Promise<void>;
     confirmScheduleWarning: () => Promise<void>;