@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/utils/constants.js

@@ -1,13 +1,15 @@
 import * as Icons from 'lucide-react';
 import { listBuiltInTaxonomyLibraryPacks } from '../shared/taxonomyLibrary.js';
+import { resolveColor } from '../shared/colorPalette.js';
+export { COLOR_PALETTE, PALETTE_ORDER, resolveColor } from '../shared/colorPalette.js';
 export const STORAGE_KEY = 'taskforce-settings';
 export const STATUS_DEFINITIONS = [
     { value: 'task', label: 'To Do', shortLabel: 'To Do', icon: 'Square', color: 'blue-200' },
     { value: 'on-hold', label: 'Blocked', shortLabel: 'Blocked', icon: 'Pause', color: 'amber-500' },
     { value: 'in-progress', label: 'Working', shortLabel: 'Working', icon: 'Play', color: 'blue-500' },
-    { value: 'review', label: 'Review', shortLabel: 'Review', icon: 'ScanSearch', color: 'violet-500' },
+    { value: 'review', label: 'Review', shortLabel: 'Review', icon: 'ClipboardCheck', color: 'violet-500' },
     { value: 'done', label: 'Done', shortLabel: 'Done', icon: 'SquareCheck', color: 'green-500' },
-    { value: 'cancelled', label: 'Cancelled', shortLabel: 'Cancelled', icon: 'Ban', color: 'red-500' }
+    { value: 'cancelled', label: 'Cancelled', shortLabel: 'Cancelled', icon: 'Ban', color: 'var(--status-cancelled)' }
 ];
 export const STATUS_SYSTEM_TAXONOMY = {
     id: 'status',
@@ -41,7 +43,7 @@ const curatedIcons = [
     'Bot', 'Cloud', 'Kanban', 'Infinity', 'Monitor', 'Smartphone', 'History', 'Brain', 'Calendar',
     'Play', 'Pause', 'Sparkles', 'Check', 'Ban', 'Circle', 'CheckCircle', 'Wind', 'Github',
     'Square', 'SquareCheck', 'CheckSquare',
-    'Package', 'AlertCircle', 'Lightbulb', 'ScanSearch',
+    'Package', 'AlertCircle', 'Lightbulb', 'ClipboardCheck', 'ScanSearch',
     // Used by built-in columns/taxonomies/defaults.
     'Inbox', 'HelpCircle', 'Gauge', 'FileCode',
     'ArrowDown', 'Minus', 'ArrowUp', 'AlertTriangle',
@@ -72,67 +74,6 @@ const FILE_TYPE_COLOR_TOKENS = {
     TXT: 'violet-200',
     MD: 'violet-200',
 };
-// ------------------------------------------------------------------
-// Color Palette System (Token-based)
-// ------------------------------------------------------------------
-export const COLOR_PALETTE = {
-    // Light Row (normalized curve)
-    'red-200': '#eb7a7a',
-    'orange-200': '#eba87a',
-    'amber-200': '#ebc17a',
-    'yellow-200': '#ebd07a',
-    'green-200': '#7aeba4',
-    'teal-200': '#7aebdf',
-    'sky-200': '#7ac8eb',
-    'blue-200': '#7aa5eb',
-    'indigo-200': '#7a7ceb',
-    'violet-200': '#9c7aeb',
-    // Medium Row (normalized curve)
-    'red-500': '#e42525',
-    'orange-500': '#e47325',
-    'amber-500': '#e49d25',
-    'yellow-500': '#e4b625',
-    'green-500': '#25e46b',
-    'teal-500': '#25e4cf',
-    'sky-500': '#25a9e4',
-    'blue-500': '#256ee4',
-    'indigo-500': '#2529e4',
-    'violet-500': '#5f25e4',
-    // Dark Row (normalized curve)
-    'red-700': '#951818',
-    'orange-700': '#954b18',
-    'amber-700': '#956718',
-    'yellow-700': '#957718',
-    'green-700': '#189546',
-    'teal-700': '#189587',
-    'sky-700': '#186e95',
-    'blue-700': '#184895',
-    'indigo-700': '#181b95',
-    'violet-700': '#3e1895',
-};
-// Ordered list of IDs for the color picker grid (Row by Row)
-export const PALETTE_ORDER = [
-    // Light
-    'red-200', 'orange-200', 'amber-200', 'yellow-200', 'green-200', 'teal-200', 'sky-200', 'blue-200', 'indigo-200', 'violet-200',
-    // Medium
-    'red-500', 'orange-500', 'amber-500', 'yellow-500', 'green-500', 'teal-500', 'sky-500', 'blue-500', 'indigo-500', 'violet-500',
-    // Dark
-    'red-700', 'orange-700', 'amber-700', 'yellow-700', 'green-700', 'teal-700', 'sky-700', 'blue-700', 'indigo-700', 'violet-700',
-];
-/**
- * Resolves a color value to a valid CSS hex string.
- * Supports token IDs (e.g. 'red-500') and raw hex codes.
- */
-export function resolveColor(colorValue) {
-    if (!colorValue)
-        return undefined;
-    // Check if it's a token
-    if (COLOR_PALETTE[colorValue]) {
-        return COLOR_PALETTE[colorValue];
-    }
-    // Return as-is (legacy hex or other format)
-    return colorValue;
-}
 export function getTypeAccentColor(type) {
     const normalized = String(type || '').trim().toLowerCase();
     return resolveColor(TypeMeta[normalized]?.color) || resolveColor('violet-200') || '#9c7aeb';

package/dist/utils/contextAttachmentPreview.d.ts

@@ -0,0 +1,11 @@
+import type { AttachmentItem } from '../types';
+export type ContextAttachmentPreviewOwnerType = 'task' | 'initiative' | 'workstream';
+export interface ContextAttachmentPreviewDetail {
+    attachment: string | AttachmentItem;
+    ownerType: ContextAttachmentPreviewOwnerType;
+    ownerId?: string | null;
+    ownerReferenceLabel?: string | null;
+    workspaceId?: string | null;
+}
+export declare const CONTEXT_ATTACHMENT_PREVIEW_EVENT = "taskforce:preview-context-attachment";
+export declare function dispatchPreviewContextAttachment(attachment: string | AttachmentItem, options: Omit<ContextAttachmentPreviewDetail, 'attachment'>): boolean;

package/dist/utils/contextAttachmentPreview.js

@@ -0,0 +1,8 @@
+export const CONTEXT_ATTACHMENT_PREVIEW_EVENT = 'taskforce:preview-context-attachment';
+export function dispatchPreviewContextAttachment(attachment, options) {
+    const event = new CustomEvent(CONTEXT_ATTACHMENT_PREVIEW_EVENT, {
+        detail: { attachment, ...options },
+        cancelable: true,
+    });
+    return !window.dispatchEvent(event);
+}

package/dist/utils/contextAttachmentUpload.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentItem } from '../types';
+export type ContextAttachmentOwnerType = 'task' | 'initiative' | 'workstream';
+export interface UploadContextAttachmentOptions {
+    ownerType: ContextAttachmentOwnerType;
+    ownerId?: string | null;
+    workspaceId?: string | null;
+}
+export declare function uploadContextAttachment(file: File, options: UploadContextAttachmentOptions): Promise<AttachmentItem>;

package/dist/utils/contextAttachmentUpload.js

@@ -0,0 +1,144 @@
+function readFileAsDataUrl(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(String(reader.result || ''));
+        reader.onerror = () => reject(reader.error || new Error('Failed to read file'));
+        reader.readAsDataURL(file);
+    });
+}
+async function readUploadError(response, fallback) {
+    try {
+        const jsonResponse = typeof response.clone === 'function' ? response.clone() : response;
+        const body = await jsonResponse.json().catch(() => null);
+        const message = String(body?.error
+            || body?.message
+            || '').trim();
+        if (message)
+            return message;
+    }
+    catch {
+        // Fall through to text response handling.
+    }
+    try {
+        const textResponse = typeof response.clone === 'function' ? response.clone() : response;
+        const message = (await textResponse.text().catch(() => '')).trim();
+        if (message)
+            return message;
+    }
+    catch {
+        // Ignore unreadable error bodies and use the caller's fallback.
+    }
+    return fallback;
+}
+export async function uploadContextAttachment(file, options) {
+    const workspaceId = String(options.workspaceId || '').trim();
+    const ownerId = String(options.ownerId || '').trim();
+    const ownerPayload = {
+        ownerType: options.ownerType,
+        ownerId: ownerId || null,
+        taskId: options.ownerType === 'task' ? (ownerId || null) : null,
+    };
+    const operationId = globalThis.crypto?.randomUUID?.()
+        || `context-upload-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const buildHeaders = () => ({
+        'Content-Type': 'application/json',
+        ...(workspaceId ? { 'x-taskforce-workspace-id': workspaceId } : {}),
+        'x-taskforce-operation-id': operationId,
+    });
+    let data = null;
+    let stagedUploadError = null;
+    const initRes = await fetch('/api/taskforce/context-upload/init', {
+        method: 'POST',
+        headers: buildHeaders(),
+        body: JSON.stringify({
+            originalName: file.name,
+            mimeType: file.type || 'application/octet-stream',
+            size: file.size,
+            ...ownerPayload,
+            workspaceId: workspaceId || null,
+        }),
+    });
+    if (initRes.ok) {
+        const initData = await initRes.json();
+        if (initData?.success && typeof initData?.uploadUrl === 'string' && typeof initData?.path === 'string') {
+            let stagedUploadCompleted = false;
+            try {
+                const uploadRes = await fetch(initData.uploadUrl, {
+                    method: String(initData.method || 'PUT'),
+                    headers: initData.headers || { 'Content-Type': file.type || 'application/octet-stream' },
+                    body: file,
+                });
+                if (!uploadRes.ok) {
+                    stagedUploadError = await readUploadError(uploadRes, `Upload failed for ${file.name}`);
+                }
+                else {
+                    stagedUploadCompleted = true;
+                    const finalizeRes = await fetch('/api/taskforce/context-upload/finalize', {
+                        method: 'POST',
+                        headers: buildHeaders(),
+                        body: JSON.stringify({
+                            relativePath: initData.relativePath,
+                            mimeType: file.type || 'application/octet-stream',
+                            originalName: file.name,
+                            size: file.size,
+                            ...ownerPayload,
+                            workspaceId: workspaceId || null,
+                        }),
+                    });
+                    if (!finalizeRes.ok) {
+                        throw new Error(await readUploadError(finalizeRes, `Upload failed for ${file.name}`));
+                    }
+                    data = await finalizeRes.json().catch(() => null);
+                }
+            }
+            catch (error) {
+                if (stagedUploadCompleted)
+                    throw error;
+                stagedUploadError = error instanceof Error ? error.message : `Upload failed for ${file.name}`;
+            }
+        }
+        else if (initData?.success && typeof initData?.path === 'string') {
+            data = initData;
+        }
+    }
+    else {
+        stagedUploadError = await readUploadError(initRes, `Upload failed for ${file.name}`);
+    }
+    if (!data) {
+        const encoded = await readFileAsDataUrl(file);
+        const fallbackRes = await fetch('/api/taskforce/context-upload', {
+            method: 'POST',
+            headers: buildHeaders(),
+            body: JSON.stringify({
+                file: encoded,
+                originalName: file.name,
+                ...ownerPayload,
+                workspaceId: workspaceId || null,
+            }),
+        });
+        if (!fallbackRes.ok) {
+            const fallbackError = await readUploadError(fallbackRes, `Upload failed for ${file.name}`);
+            throw new Error(stagedUploadError && stagedUploadError !== fallbackError
+                ? `${fallbackError} (${stagedUploadError})`
+                : fallbackError);
+        }
+        data = await fallbackRes.json();
+    }
+    if (!data?.success || !data?.path) {
+        throw new Error(`Upload failed for ${file.name}`);
+    }
+    return {
+        path: data.path,
+        fsPath: data.fsPath,
+        caption: typeof data.caption === 'string' && data.caption.trim().length > 0 ? data.caption : file.name,
+        displayName: typeof data.displayName === 'string' ? data.displayName : undefined,
+        originalFilename: typeof data.originalFilename === 'string' ? data.originalFilename : file.name,
+        assetId: typeof data.assetId === 'string' ? data.assetId : undefined,
+        referenceNumber: typeof data.referenceNumber === 'number' ? data.referenceNumber : null,
+        referenceLabel: typeof data.referenceLabel === 'string' ? data.referenceLabel : undefined,
+        taskId: options.ownerType === 'task' && typeof data.taskId === 'string' ? data.taskId : null,
+        timestamp: typeof data.timestamp === 'string' && data.timestamp.trim().length > 0
+            ? data.timestamp
+            : new Date().toISOString(),
+    };
+}

package/dist/utils/documentNames.js

@@ -56,6 +56,12 @@ export function isGeneratedDocumentName(value, assetId) {
     return strippedStem !== stem;
 }
 export function getCanonicalDocumentName(input) {
+    const title = String(input.title || '').trim();
+    if (title && !isGeneratedDocumentName(title, input.assetId)) {
+        return title;
+    }
+    // `logicalName` remains the persisted v2 compatibility source until the
+    // document-root cutover. New document callers should supply `title`.
     const logicalName = String(input.logicalName || '').trim();
     if (logicalName && !isGeneratedDocumentName(logicalName, input.assetId)) {
         return logicalName;
@@ -64,10 +70,6 @@ export function getCanonicalDocumentName(input) {
     if (displayName && !isGeneratedDocumentName(displayName, input.assetId)) {
         return displayName;
     }
-    const title = String(input.title || '').trim();
-    if (title && !isGeneratedDocumentName(title, input.assetId)) {
-        return title;
-    }
     const originalFilename = String(input.originalFilename || '').trim();
     if (originalFilename)
         return deriveNameFromFilename(originalFilename, input.assetId);

package/dist/utils/entityReferences.d.ts

@@ -1,4 +1,18 @@
 export declare function normalizeEntityReferenceNumber(value: unknown): number | null;
+export type CanonicalEntityReferenceKind = 'initiative' | 'workstream' | 'document' | 'image';
+export type CanonicalEntityReference = {
+    [Kind in CanonicalEntityReferenceKind]: {
+        kind: Kind;
+        token: string;
+        referenceNumber: number;
+    };
+}[CanonicalEntityReferenceKind];
+export interface CanonicalEntityReferenceContract {
+    resolve: (token: string) => CanonicalEntityReference | null;
+    activate: (reference: CanonicalEntityReference) => void;
+}
+export declare const CANONICAL_ENTITY_REFERENCE_TOKEN_PATTERN: RegExp;
+export declare function parseCanonicalEntityReference(value: string | null | undefined): CanonicalEntityReference | null;
 export declare function formatEntityReference(prefix: string, value: number | {
     referenceNumber?: number | null;
 } | null | undefined): string;

package/dist/utils/entityReferences.js

@@ -5,6 +5,27 @@ export function normalizeEntityReferenceNumber(value) {
     const normalized = Math.floor(numeric);
     return normalized > 0 ? normalized : null;
 }
+export const CANONICAL_ENTITY_REFERENCE_TOKEN_PATTERN = /(?<![\w-])((?:IN|WS|D|I)-\d+)(?![\w-])/gi;
+const CANONICAL_ENTITY_REFERENCE_PREFIXES = {
+    IN: 'initiative',
+    WS: 'workstream',
+    D: 'document',
+    I: 'image',
+};
+export function parseCanonicalEntityReference(value) {
+    const normalized = String(value || '').trim().toUpperCase();
+    const match = normalized.match(/^(IN|WS|D|I)-(\d+)$/);
+    if (!match)
+        return null;
+    const referenceNumber = normalizeEntityReferenceNumber(match[2]);
+    if (!referenceNumber)
+        return null;
+    return {
+        kind: CANONICAL_ENTITY_REFERENCE_PREFIXES[match[1]],
+        token: `${match[1]}-${referenceNumber}`,
+        referenceNumber,
+    };
+}
 export function formatEntityReference(prefix, value) {
     const referenceNumber = typeof value === 'object' && value !== null
         ? normalizeEntityReferenceNumber(value.referenceNumber)

package/dist/utils/httpSetCookie.d.ts

@@ -0,0 +1,3 @@
+export declare function rewriteSetCookieForLocalHost(cookie: string): string;
+export declare function readSetCookieHeaders(headers: Headers): string[];
+export declare function findSetCookieHeader(headers: readonly string[], cookieName: string): string | null;

package/dist/utils/httpSetCookie.js

@@ -0,0 +1,22 @@
+export function rewriteSetCookieForLocalHost(cookie) {
+    const parts = String(cookie || '').split(';').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0)
+        return cookie;
+    const [nameValue, ...attrs] = parts;
+    const filteredAttrs = attrs.filter((attr) => !attr.toLowerCase().startsWith('domain='));
+    return [nameValue, ...filteredAttrs].join('; ');
+}
+export function readSetCookieHeaders(headers) {
+    const values = headers.getSetCookie?.();
+    if (Array.isArray(values) && values.length > 0)
+        return values;
+    const fallback = headers.get('set-cookie');
+    return fallback ? [fallback] : [];
+}
+export function findSetCookieHeader(headers, cookieName) {
+    const prefix = `${cookieName}=`;
+    return headers.find((header) => {
+        const nameValue = String(header || '').split(';', 1)[0]?.trim() || '';
+        return nameValue.startsWith(prefix);
+    }) || null;
+}

package/dist/utils/imageNoteStoragePaths.d.ts

@@ -0,0 +1,3 @@
+export declare const IMAGE_NOTE_ASSET_SEGMENT = "image-notes";
+export declare function buildImageNoteStoragePrefix(workspaceId: string): string;
+export declare function isImageNoteStorageKey(storageKey: unknown, workspaceId: string): boolean;

package/dist/utils/imageNoteStoragePaths.js

@@ -0,0 +1,19 @@
+function normalizeId(value) {
+    return String(value || '').trim();
+}
+function sanitizeStorageSegment(value, fallback) {
+    const normalized = normalizeId(value)
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || fallback;
+}
+export const IMAGE_NOTE_ASSET_SEGMENT = 'image-notes';
+export function buildImageNoteStoragePrefix(workspaceId) {
+    const workspaceIdSafe = sanitizeStorageSegment(workspaceId, 'default');
+    return `workspaces/${workspaceIdSafe}/assets/${IMAGE_NOTE_ASSET_SEGMENT}/`;
+}
+export function isImageNoteStorageKey(storageKey, workspaceId) {
+    const normalized = String(storageKey || '').replace(/\\/g, '/');
+    return normalized.startsWith(buildImageNoteStoragePrefix(workspaceId));
+}

package/dist/utils/imageReferences.d.ts

@@ -1,4 +1,10 @@
+import type { AttachmentItem } from '../types';
 export declare const IMAGE_REFERENCE_PREFIX = "I-";
+export declare const IMAGE_REFERENCE_TOKEN_PATTERN: RegExp;
+export interface ImageReferenceContract {
+    resolve: (token: string) => AttachmentItem | null;
+    activate: (attachment: AttachmentItem) => void;
+}
 export declare function formatImageReference(value: number | {
     referenceNumber?: number | null;
 } | null | undefined): string;

package/dist/utils/imageReferences.js

@@ -1,5 +1,6 @@
 import { formatEntityReference, getEntityReferenceLabel, parseEntityReference } from './entityReferences.js';
 export const IMAGE_REFERENCE_PREFIX = 'I-';
+export const IMAGE_REFERENCE_TOKEN_PATTERN = /(?<![\w-])(I-\d+)(?![\w-])/gi;
 export function formatImageReference(value) {
     return formatEntityReference(IMAGE_REFERENCE_PREFIX, value);
 }

package/dist/utils/planningArchiveOrchestrator.d.ts

@@ -0,0 +1,23 @@
+export type ArchiveHierarchyTask = {
+    id: string;
+    status?: string | null;
+    isArchived?: boolean;
+};
+export type ArchiveHierarchyWorkstream = {
+    id: string;
+    isArchived?: boolean;
+    tasks?: ArchiveHierarchyTask[];
+};
+export declare function archiveResolvedWorkstreamHierarchy({ workstream, allowEmpty, archiveTask, archiveWorkstream, }: {
+    workstream: ArchiveHierarchyWorkstream;
+    allowEmpty?: boolean;
+    archiveTask: (taskId: string) => boolean | Promise<boolean>;
+    archiveWorkstream: (workstreamId: string) => unknown | Promise<unknown>;
+}): Promise<boolean>;
+export declare function archiveResolvedInitiativeHierarchy({ workstreams, archiveTask, archiveWorkstream, archiveInitiative, initiativeId, }: {
+    workstreams: ArchiveHierarchyWorkstream[];
+    archiveTask: (taskId: string) => boolean | Promise<boolean>;
+    archiveWorkstream: (workstreamId: string) => unknown | Promise<unknown>;
+    archiveInitiative: (initiativeId: string) => unknown | Promise<unknown>;
+    initiativeId: string;
+}): Promise<boolean>;

package/dist/utils/planningArchiveOrchestrator.js

@@ -0,0 +1,37 @@
+export async function archiveResolvedWorkstreamHierarchy({ workstream, allowEmpty = false, archiveTask, archiveWorkstream, }) {
+    if (workstream.isArchived)
+        return true;
+    const tasks = workstream.tasks || [];
+    if ((!allowEmpty && tasks.length === 0)
+        || tasks.some((task) => task.status !== 'done' && task.status !== 'cancelled')) {
+        return false;
+    }
+    for (const task of tasks) {
+        if (task.isArchived)
+            continue;
+        if (!await archiveTask(task.id))
+            return false;
+    }
+    await archiveWorkstream(workstream.id);
+    return true;
+}
+export async function archiveResolvedInitiativeHierarchy({ workstreams, archiveTask, archiveWorkstream, archiveInitiative, initiativeId, }) {
+    const tasks = workstreams.flatMap((workstream) => workstream.tasks || []);
+    if (workstreams.length === 0
+        || tasks.length === 0
+        || tasks.some((task) => task.status !== 'done' && task.status !== 'cancelled')) {
+        return false;
+    }
+    for (const workstream of workstreams) {
+        const archived = await archiveResolvedWorkstreamHierarchy({
+            workstream,
+            allowEmpty: true,
+            archiveTask,
+            archiveWorkstream,
+        });
+        if (!archived)
+            return false;
+    }
+    await archiveInitiative(initiativeId);
+    return true;
+}

package/dist/utils/planningArchivePresentation.d.ts

@@ -0,0 +1,20 @@
+export type PlanningArchiveDetailState = {
+    mode: 'archived';
+} | {
+    mode: 'empty';
+} | {
+    mode: 'ready';
+} | {
+    mode: 'blocked';
+    remainingKind: 'task' | 'workstream';
+} | {
+    mode: 'checking';
+};
+export declare function resolvePlanningArchiveDetailState({ isArchived, taskCount, completedTaskCount, archiveReady, entityType, activeWorkstreamCount, }: {
+    isArchived?: boolean;
+    taskCount: number;
+    completedTaskCount: number;
+    archiveReady?: boolean;
+    entityType: 'initiative' | 'workstream';
+    activeWorkstreamCount?: number;
+}): PlanningArchiveDetailState;

package/dist/utils/planningArchivePresentation.js

@@ -0,0 +1,23 @@
+export function resolvePlanningArchiveDetailState({ isArchived, taskCount, completedTaskCount, archiveReady, entityType, activeWorkstreamCount = 0, }) {
+    if (isArchived)
+        return { mode: 'archived' };
+    if (taskCount === 0) {
+        if (entityType === 'initiative' && activeWorkstreamCount > 0) {
+            return {
+                mode: 'blocked',
+                remainingKind: 'workstream',
+            };
+        }
+        return { mode: 'empty' };
+    }
+    const unresolvedTaskCount = Math.max(0, taskCount - completedTaskCount);
+    if (unresolvedTaskCount > 0) {
+        return {
+            mode: 'blocked',
+            remainingKind: 'task',
+        };
+    }
+    if (archiveReady)
+        return { mode: 'ready' };
+    return { mode: 'checking' };
+}

package/dist/utils/planningArchiveReadiness.d.ts

@@ -0,0 +1,26 @@
+export type PlanningArchiveTask = {
+    status?: string | null;
+    isArchived?: boolean;
+};
+export type PlanningArchiveWorkstream = {
+    isArchived?: boolean;
+    tasks?: PlanningArchiveTask[];
+};
+export type PlanningArchiveReadiness = {
+    archiveReady: boolean;
+    activeTaskCount: number;
+    activeWorkstreamCount: number;
+};
+export declare function mergePlanningLifetimeTasks<T extends {
+    id: string;
+}>(activeTasks: T[], archivedTasks: T[]): T[];
+export declare function resolveWorkstreamArchiveReadiness({ isArchived, tasks, dataReady, }: {
+    isArchived?: boolean;
+    tasks: PlanningArchiveTask[];
+    dataReady: boolean;
+}): PlanningArchiveReadiness;
+export declare function resolveInitiativeArchiveReadiness({ isArchived, workstreams, dataReady, }: {
+    isArchived?: boolean;
+    workstreams: PlanningArchiveWorkstream[];
+    dataReady: boolean;
+}): PlanningArchiveReadiness;

package/dist/utils/planningArchiveReadiness.js

@@ -0,0 +1,30 @@
+export function mergePlanningLifetimeTasks(activeTasks, archivedTasks) {
+    return Array.from([...activeTasks, ...archivedTasks]
+        .reduce((tasksById, task) => tasksById.set(task.id, task), new Map())
+        .values());
+}
+function isTerminalTask(task) {
+    return task.status === 'done' || task.status === 'cancelled';
+}
+export function resolveWorkstreamArchiveReadiness({ isArchived, tasks, dataReady, }) {
+    return {
+        archiveReady: dataReady
+            && !isArchived
+            && tasks.length > 0
+            && tasks.every(isTerminalTask),
+        activeTaskCount: tasks.filter((task) => !task.isArchived).length,
+        activeWorkstreamCount: 0,
+    };
+}
+export function resolveInitiativeArchiveReadiness({ isArchived, workstreams, dataReady, }) {
+    const tasks = workstreams.flatMap((workstream) => workstream.tasks || []);
+    return {
+        archiveReady: dataReady
+            && !isArchived
+            && workstreams.length > 0
+            && tasks.length > 0
+            && tasks.every(isTerminalTask),
+        activeTaskCount: tasks.filter((task) => !task.isArchived).length,
+        activeWorkstreamCount: workstreams.filter((workstream) => !workstream.isArchived).length,
+    };
+}

package/dist/utils/planningFavorites.d.ts

@@ -0,0 +1,7 @@
+export type PlanningFavorite = {
+    type: 'initiative' | 'workstream';
+    id: string;
+};
+export declare function getPlanningFavoriteKey(favorite: PlanningFavorite): string;
+export declare function normalizePlanningFavorites(value: unknown): PlanningFavorite[] | undefined;
+export declare function togglePlanningFavorite(favorites: PlanningFavorite[], favorite: PlanningFavorite): PlanningFavorite[];

package/dist/utils/planningFavorites.js

@@ -0,0 +1,34 @@
+export function getPlanningFavoriteKey(favorite) {
+    return `${favorite.type}:${favorite.id}`;
+}
+export function normalizePlanningFavorites(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const seen = new Set();
+    const favorites = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const type = entry.type;
+        const idValue = entry.id;
+        if ((type !== 'initiative' && type !== 'workstream') || typeof idValue !== 'string')
+            continue;
+        const id = idValue.trim();
+        if (!id)
+            continue;
+        const favorite = { type, id };
+        const key = getPlanningFavoriteKey(favorite);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        favorites.push(favorite);
+    }
+    return favorites;
+}
+export function togglePlanningFavorite(favorites, favorite) {
+    const targetKey = getPlanningFavoriteKey(favorite);
+    const exists = favorites.some((item) => getPlanningFavoriteKey(item) === targetKey);
+    return exists
+        ? favorites.filter((item) => getPlanningFavoriteKey(item) !== targetKey)
+        : [...favorites, favorite];
+}