@codingfactory/task-engine-client 0.1.0

package/dist/composables/useTaskDetail.d.ts

@@ -0,0 +1,207 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { TaskCommentPayload, TaskDetail, TaskEscalationSnoozePayload } from '@/types';
+export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null | undefined>): {
+    task: import("vue").ComputedRef<{
+        comments: {
+            id: string;
+            task_id?: string;
+            author: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            };
+            content: string;
+            visibility: "team" | "private";
+            metadata?: Record<string, unknown> | null;
+            created_at: string;
+            updated_at?: string | null;
+        }[];
+        checklist_items: {
+            id: string;
+            task_id?: string;
+            title: string;
+            is_completed: boolean;
+            completed_at: string | null;
+            completed_by: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            } | null;
+            position: number;
+            template_item_id?: string | null;
+        }[];
+        watchers: {
+            id: string | number;
+            name: string;
+            avatar_url?: string;
+        }[];
+        relations: {
+            id: string;
+            type: import("@/types").TaskRelationType;
+            related_task: {
+                id: string;
+                display_number_formatted: string;
+                title: string;
+                status: import("@/types").TaskStatus;
+                priority: import("@/types").TaskPriority;
+            } | null;
+            created_at?: string | null;
+        }[];
+        activity_logs: {
+            id: string;
+            task_id?: string;
+            user: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            } | null;
+            action: string;
+            description: string | null;
+            changes: Record<string, unknown> | null;
+            metadata: Record<string, unknown> | null;
+            created_at: string | null;
+        }[];
+        escalation_policy: {
+            id: string;
+            tenant_id: string;
+            profile_key: string | null;
+            name: string;
+            description: string | null;
+            is_default: boolean;
+            tiers: {
+                name: import("@/types").EscalationTier;
+                label: string;
+                offset_hours: number;
+                visual: string;
+                channels: string[];
+                target: "assignee" | "team_lead" | "manager" | "owner";
+                cooldown_hours: number;
+                color: string;
+            }[];
+            business_hours_only: boolean;
+            quiet_hours_start: string | null;
+            quiet_hours_end: string | null;
+            timezone: string;
+            created_at: string | null;
+            updated_at: string | null;
+        } | null;
+        escalation_events: {
+            id: string;
+            tenant_id: string;
+            task_id: string;
+            policy_id: string | null;
+            tier_name: import("@/types").EscalationTier | null;
+            tier_label: string | null;
+            event_type: import("@/types").EscalationEventType;
+            target_user_id: string | null;
+            target_role: string | null;
+            target_user: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            } | null;
+            channels_used: string[];
+            acknowledged_at: string | null;
+            acknowledged_by: string | null;
+            acknowledged_by_user: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            } | null;
+            snoozed_until: string | null;
+            snooze_reason: string | null;
+            blocker_task_id: string | null;
+            blocker_task: {
+                id: string;
+                display_number_formatted: string;
+                title: string;
+                status: import("@/types").TaskStatus;
+                priority: import("@/types").TaskPriority;
+            } | null;
+            metadata: Record<string, unknown> | null;
+            created_at: string | null;
+        }[];
+        id: string;
+        tenant_id: string;
+        display_number: number;
+        display_number_formatted: string;
+        title: string;
+        description: string | null;
+        status: import("@/types").TaskStatus;
+        priority: import("@/types").TaskPriority;
+        taskable_type: string | null;
+        taskable_id: string | null;
+        created_by: {
+            id: string | number;
+            name: string;
+            avatar_url?: string;
+        } | null;
+        primary_assignee: {
+            id: string | number;
+            name: string;
+            avatar_url?: string;
+        } | null;
+        due_at: string | null;
+        completed_at: string | null;
+        completed_by: {
+            id: string | number;
+            name: string;
+            avatar_url?: string;
+        } | null;
+        source: import("@/types").TaskSource;
+        source_id: string | null;
+        template_item_id?: string | null;
+        escalation_policy_id: string | null;
+        current_escalation_tier: import("@/types").EscalationTier | null;
+        current_escalation_label: string | null;
+        next_escalation_at: string | null;
+        escalation_acknowledged_at: string | null;
+        escalation_snoozed_until: string | null;
+        comment_count?: number | null;
+        checklist_total?: number | null;
+        checklist_completed?: number | null;
+        blocker_count?: number | null;
+        open_blocker_count?: number | null;
+        has_unresolved_blockers?: boolean | null;
+        subtask_count?: number | null;
+        completed_subtask_count?: number | null;
+        completion_rules?: {
+            checklist_complete?: boolean;
+            comment_required?: boolean;
+            attachment_required?: boolean;
+            subtasks_complete?: boolean;
+            custom_field_required?: string[];
+        } | null;
+        tags: {
+            id: string;
+            name: string;
+            color: string | null;
+            created_at?: string;
+            updated_at?: string;
+        }[];
+        checklist_progress: {
+            completed: number;
+            total: number;
+        };
+        is_overdue: boolean;
+        is_complete: boolean;
+        progress_percentage: number;
+        metadata?: Record<string, unknown> | null;
+        created_at: string;
+        updated_at: string;
+    } | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    loadTask: (id?: string | null) => Promise<TaskDetail | null>;
+    addComment: (payload: TaskCommentPayload) => Promise<TaskDetail | null>;
+    acknowledgeEscalation: () => Promise<TaskDetail | null>;
+    snoozeEscalation: (payload: TaskEscalationSnoozePayload) => Promise<TaskDetail | null>;
+    addChecklistItem: (title: string) => Promise<TaskDetail | null>;
+    toggleChecklistItem: (itemId: string) => Promise<TaskDetail | null>;
+    removeChecklistItem: (itemId: string) => Promise<TaskDetail | null>;
+    completeTask: (id: string, note?: string) => Promise<TaskDetail>;
+    reopenTask: (id: string) => Promise<TaskDetail>;
+    cancelTask: (id: string) => Promise<TaskDetail>;
+    updateTask: (id: string, payload: import("@/types").TaskUpdatePayload) => Promise<TaskDetail>;
+    deleteTask: (id: string) => Promise<void>;
+};

package/dist/composables/useTaskFilters.d.ts

@@ -0,0 +1,38 @@
+import type { TaskFilters } from '@/types';
+export declare function useTaskFilters(): {
+    filters: import("vue").ComputedRef<{
+        status?: import("@/types").TaskStatus | import("@/types").TaskStatus[];
+        priority?: import("@/types").TaskPriority | import("@/types").TaskPriority[];
+        assignee?: string;
+        assignee_id?: string;
+        created_by?: string;
+        watching?: boolean;
+        tag?: string;
+        overdue?: boolean;
+        due_before?: string;
+        due_after?: string;
+        search?: string;
+        taskable_type?: string;
+        taskable_id?: string;
+        sort?: string;
+        page?: number;
+        per_page?: number;
+    }>;
+    pagination: import("vue").ComputedRef<{
+        current_page: number;
+        last_page: number;
+        per_page: number;
+        total: number;
+    }>;
+    view: import("vue").ComputedRef<import("@/types").TaskListViewMode>;
+    activeSavedFilterId: import("vue").ComputedRef<string | null>;
+    activeFilterCount: import("vue").ComputedRef<number>;
+    setFilter: <K extends keyof TaskFilters>(key: K, value: TaskFilters[K]) => void;
+    setFilters: (value: Partial<TaskFilters>) => void;
+    setSort: (sort: string) => void;
+    setView: (value: import("@/types").TaskListViewMode) => void;
+    setActiveSavedFilter: (id: string | null) => void;
+    clearFilters: () => void;
+    nextPage: () => void;
+    previousPage: () => void;
+};

package/dist/composables/useTaskNotificationFeed.d.ts

@@ -0,0 +1,47 @@
+import type { TaskNotificationToastItem, TaskNotificationToastKind, TaskNotificationToastTone } from '@/types';
+export interface PushTaskNotificationToastInput {
+    id?: string;
+    kind: TaskNotificationToastKind;
+    title: string;
+    body: string;
+    taskId: string;
+    taskNumber: string;
+    tone?: TaskNotificationToastTone;
+    duration?: number;
+    url?: string | null;
+    created_at?: string;
+}
+declare function dismissTaskNotificationToast(id: string): void;
+declare function pushTaskNotificationToast(input: PushTaskNotificationToastInput): TaskNotificationToastItem;
+declare function clearTaskNotificationFeed(): void;
+export declare function resetTaskNotificationFeed(): void;
+export declare function useTaskNotificationFeed(): {
+    notifications: Readonly<import("vue").Ref<readonly {
+        readonly id: string;
+        readonly kind: TaskNotificationToastKind;
+        readonly title: string;
+        readonly body: string;
+        readonly taskId: string;
+        readonly taskNumber: string;
+        readonly tone: TaskNotificationToastTone;
+        readonly duration: number;
+        readonly url: string | null;
+        readonly created_at: string;
+    }[], readonly {
+        readonly id: string;
+        readonly kind: TaskNotificationToastKind;
+        readonly title: string;
+        readonly body: string;
+        readonly taskId: string;
+        readonly taskNumber: string;
+        readonly tone: TaskNotificationToastTone;
+        readonly duration: number;
+        readonly url: string | null;
+        readonly created_at: string;
+    }[]>>;
+    hasNotifications: import("vue").ComputedRef<boolean>;
+    pushTaskNotificationToast: typeof pushTaskNotificationToast;
+    dismissTaskNotificationToast: typeof dismissTaskNotificationToast;
+    clearTaskNotificationFeed: typeof clearTaskNotificationFeed;
+};
+export {};

package/dist/composables/useTaskPresence.d.ts

@@ -0,0 +1,22 @@
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
+import type { TaskPresenceViewer } from '@/types';
+export interface TaskPresenceChannelLike {
+    here: (callback: (users: unknown[]) => void) => TaskPresenceChannelLike;
+    joining: (callback: (user: unknown) => void) => TaskPresenceChannelLike;
+    leaving: (callback: (user: unknown) => void) => TaskPresenceChannelLike;
+}
+export interface TaskPresenceEchoLike {
+    join: (channel: string) => TaskPresenceChannelLike;
+    leave: (channel: string) => void;
+}
+export interface UseTaskPresenceOptions {
+    echo?: TaskPresenceEchoLike | (() => TaskPresenceEchoLike | null | undefined) | null;
+    autoConnect?: boolean;
+}
+export interface UseTaskPresenceReturn {
+    viewers: Ref<TaskPresenceViewer[]>;
+    isConnected: ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+}
+export declare function useTaskPresence(taskId: MaybeRefOrGetter<string | number | null | undefined>, options?: UseTaskPresenceOptions): UseTaskPresenceReturn;

package/dist/composables/useTaskSavedFilters.d.ts

@@ -0,0 +1,47 @@
+import type { TaskFilters, TaskSavedFilter } from '@/types';
+interface SaveCurrentFilterOptions {
+    name: string;
+    is_default?: boolean;
+    is_shared?: boolean;
+    position?: number;
+}
+export declare function useTaskSavedFilters(): {
+    savedFilters: import("vue").ComputedRef<{
+        id: string;
+        tenant_id: string;
+        user_id: string;
+        name: string;
+        filters: {
+            status?: import("@/types").TaskStatus | import("@/types").TaskStatus[];
+            priority?: import("@/types").TaskPriority | import("@/types").TaskPriority[];
+            assignee?: string;
+            assignee_id?: string;
+            created_by?: string;
+            watching?: boolean;
+            tag?: string;
+            overdue?: boolean;
+            due_before?: string;
+            due_after?: string;
+            search?: string;
+            taskable_type?: string;
+            taskable_id?: string;
+            sort?: string;
+            page?: number;
+            per_page?: number;
+        };
+        is_default: boolean;
+        is_shared: boolean;
+        position: number;
+        created_at: string | null;
+        updated_at: string | null;
+    }[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    activeSavedFilterId: import("vue").ComputedRef<string | null>;
+    loadSavedFilters: () => Promise<TaskSavedFilter[]>;
+    applySavedFilter: (filter: TaskSavedFilter) => TaskFilters;
+    saveCurrentFilter: (options: SaveCurrentFilterOptions) => Promise<TaskSavedFilter>;
+    updateSavedFilter: (id: string, data: Partial<Omit<TaskSavedFilter, "id" | "tenant_id" | "user_id" | "created_at" | "updated_at">>) => Promise<TaskSavedFilter>;
+    deleteSavedFilter: (id: string) => Promise<void>;
+};
+export {};

package/dist/composables/useTaskWebSocket.d.ts

@@ -0,0 +1,31 @@
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
+import type { TaskAssignedBroadcastPayload, TaskChecklistToggledBroadcastPayload, TaskCommentAddedBroadcastPayload, TaskCompletedBroadcastPayload, TaskCreatedBroadcastPayload, TaskNotificationToastItem, TaskRealtimeEventName, TaskStatusChangedBroadcastPayload, TaskUpdatedBroadcastPayload } from '@/types';
+export interface TaskEchoPrivateChannelLike {
+    listen: (event: string, callback: (payload: unknown) => void) => TaskEchoPrivateChannelLike;
+}
+export interface TaskEchoLike {
+    private: (channel: string) => TaskEchoPrivateChannelLike;
+    leave: (channel: string) => void;
+}
+export interface UseTaskWebSocketEntityTarget {
+    type: string;
+    id: string | number;
+}
+export interface UseTaskWebSocketOptions {
+    echo?: TaskEchoLike | (() => TaskEchoLike | null | undefined) | null | undefined;
+    entity?: MaybeRefOrGetter<UseTaskWebSocketEntityTarget | null | undefined>;
+    teamIds?: MaybeRefOrGetter<Array<string | number> | null | undefined>;
+    autoConnect?: boolean;
+    onToast?: (toast: TaskNotificationToastItem) => void;
+    onConnectionChange?: (connected: boolean) => void;
+    onEvent?: (event: TaskRealtimeEventName, payload: TaskRealtimeEventPayload) => void;
+}
+export interface UseTaskWebSocketReturn {
+    isConnected: ComputedRef<boolean>;
+    activeChannels: Ref<string[]>;
+    connect: () => void;
+    disconnect: () => void;
+    reconnect: () => void;
+}
+export type TaskRealtimeEventPayload = TaskCreatedBroadcastPayload | TaskUpdatedBroadcastPayload | TaskStatusChangedBroadcastPayload | TaskAssignedBroadcastPayload | TaskCompletedBroadcastPayload | TaskCommentAddedBroadcastPayload | TaskChecklistToggledBroadcastPayload;
+export declare function useTaskWebSocket(userId: MaybeRefOrGetter<string | number | null | undefined>, options?: UseTaskWebSocketOptions): UseTaskWebSocketReturn;