@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/components/features/planning/PlanningOwnerDropdown.d.ts

@@ -0,0 +1,27 @@
+import { type TaskAssigneeOption } from '../../../utils/assignees';
+export type PlanningOwnerOption = {
+    value: string;
+    label: string;
+    icon?: string | null;
+    color?: string | null;
+    kind?: string | null;
+    avatarUrl?: string | null;
+    avatarRevision?: number | null;
+    avatarUpdatedAt?: string | null;
+    username?: string | null;
+    surfaceType?: string | null;
+    providerMetadata?: Record<string, unknown> | null;
+    archivedAt?: string | null;
+};
+export declare function normalizePlanningOwnerOptions(options: PlanningOwnerOption[], selectedValue: string): PlanningOwnerOption[];
+export declare function toPlanningAssigneeOption(option: PlanningOwnerOption): TaskAssigneeOption;
+export declare function PlanningOwnerDropdown({ value, options, leadingOptions, includeUnassigned, onChange, disabled, ariaLabel, className, }: {
+    value: string;
+    options: PlanningOwnerOption[];
+    leadingOptions?: PlanningOwnerOption[];
+    includeUnassigned?: boolean;
+    onChange: (value: string) => void;
+    disabled: boolean;
+    ariaLabel: string;
+    className: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningOwnerDropdown.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { AssigneeIdentity } from '../../ui/AssigneeIdentity';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import { TASK_ASSIGNEE_UNASSIGNED_COLOR, TASK_ASSIGNEE_UNASSIGNED_ICON, } from '../../../utils/assignees';
+export function normalizePlanningOwnerOptions(options, selectedValue) {
+    const selected = String(selectedValue || '').trim();
+    const byIdentity = new Map();
+    for (const option of options) {
+        const value = String(option?.value || '').trim();
+        if (!value || value === 'unassigned')
+            continue;
+        if (typeof option.archivedAt === 'string' && option.archivedAt.trim().length > 0)
+            continue;
+        const label = String(option.label || value).trim() || value;
+        const kind = String(option.kind || '').trim().toLowerCase();
+        const username = String(option.username || '').trim().toLowerCase();
+        const identity = kind === 'agent'
+            ? `agent:${username || label.toLowerCase()}`
+            : `value:${value}`;
+        if (!byIdentity.has(identity) || value === selected) {
+            byIdentity.set(identity, { ...option, value, label });
+        }
+    }
+    return Array.from(byIdentity.values()).sort((left, right) => (left.label.localeCompare(right.label, undefined, { sensitivity: 'base' })));
+}
+export function toPlanningAssigneeOption(option) {
+    const kind = option.kind === 'agent'
+        ? 'agent'
+        : option.kind === 'member'
+            ? 'member'
+            : 'unassigned';
+    return {
+        value: option.value,
+        label: option.label,
+        icon: option.icon || (kind === 'agent' ? 'Bot' : kind === 'member' ? 'User' : TASK_ASSIGNEE_UNASSIGNED_ICON),
+        color: option.color || (kind === 'agent' ? 'var(--brand-primary)' : kind === 'member' ? 'var(--status-success)' : TASK_ASSIGNEE_UNASSIGNED_COLOR),
+        kind,
+        avatarUrl: option.avatarUrl,
+        avatarRevision: option.avatarRevision,
+        avatarUpdatedAt: option.avatarUpdatedAt,
+        username: option.username,
+        surfaceType: option.surfaceType,
+        providerMetadata: option.providerMetadata,
+        archivedAt: option.archivedAt,
+    };
+}
+export function PlanningOwnerDropdown({ value, options, leadingOptions = [], includeUnassigned = true, onChange, disabled, ariaLabel, className, }) {
+    const resolvedOptions = React.useMemo(() => {
+        const normalizedLeadingOptions = leadingOptions.map((option) => ({
+            ...option,
+            value: String(option.value || '').trim(),
+            label: String(option.label || option.value || '').trim(),
+        })).filter((option) => option.value && option.label);
+        const leadingValues = new Set(normalizedLeadingOptions.map((option) => option.value));
+        const assignableOptions = normalizePlanningOwnerOptions(options, value)
+            .filter((option) => !leadingValues.has(option.value));
+        return [
+            ...normalizedLeadingOptions,
+            ...(includeUnassigned ? [{
+                    value: '',
+                    label: 'Unassigned',
+                    icon: TASK_ASSIGNEE_UNASSIGNED_ICON,
+                    color: TASK_ASSIGNEE_UNASSIGNED_COLOR,
+                    kind: 'unassigned',
+                }] : []),
+            ...assignableOptions,
+        ];
+    }, [includeUnassigned, leadingOptions, options, value]);
+    const identityByValue = React.useMemo(() => new Map(resolvedOptions.map((option) => [option.value, toPlanningAssigneeOption(option)])), [resolvedOptions]);
+    return (_jsx(TaxonomyDropdown, { value: value, options: resolvedOptions.map((option) => ({
+            value: option.value,
+            label: option.label,
+            icon: option.icon || undefined,
+            color: option.color || undefined,
+        })), onChange: (nextValue) => onChange(String(nextValue)), disabled: disabled, ariaLabel: ariaLabel, className: className, portalPanel: true, panelAlign: "start", panelMinWidth: 240, searchable: true, searchPlaceholder: "Search owners...", noResultsText: "No owners found.", renderOptionContent: (option) => {
+            const identity = identityByValue.get(String(option.value));
+            return identity ? _jsx(AssigneeIdentity, { option: identity }) : option.label;
+        } }));
+}

package/dist/components/features/planning/PlanningTaskArrangeControl.d.ts

@@ -0,0 +1,5 @@
+import { type PlanningTaskArrangeMode } from './planningTaskArrangement';
+export declare function PlanningTaskArrangeControl({ value, onChange, }: {
+    value: PlanningTaskArrangeMode;
+    onChange: (value: PlanningTaskArrangeMode) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningTaskArrangeControl.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowUpDown } from 'lucide-react';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import { PLANNING_TASK_ARRANGE_OPTIONS, } from './planningTaskArrangement';
+import controlStyles from './PlanningDropdownControl.module.css';
+import styles from './PlanningTaskArrangeControl.module.css';
+export function PlanningTaskArrangeControl({ value, onChange, }) {
+    const selected = PLANNING_TASK_ARRANGE_OPTIONS.find((option) => option.value === value)
+        || PLANNING_TASK_ARRANGE_OPTIONS[0];
+    return (_jsx(TaxonomyDropdown, { value: value, options: [...PLANNING_TASK_ARRANGE_OPTIONS], onChange: (nextValue) => onChange(nextValue), ariaLabel: "Arrange workstream tasks", className: controlStyles.control, portalPanel: true, panelAlign: "end", triggerContent: (_jsxs("span", { className: styles.trigger, title: selected.description, children: [_jsx(ArrowUpDown, { size: 14, "aria-hidden": "true" }), _jsx("span", { children: selected.label })] })) }));
+}

package/dist/components/features/planning/PlanningTaskCard.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { TaskStatus } from '../../../types';
+import type { TaskAssigneeOption } from '../../../utils/assignees';
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+type PlanningTaskCardProps = {
+    task: PlanningTaskPreview;
+    assigneeOption?: TaskAssigneeOption;
+    assigneeOptions?: TaskAssigneeOption[];
+    showStatusLabel: boolean;
+    onOpen?: () => void;
+    onAssigneeChange?: (assignee: string) => void | Promise<void>;
+    onStatusChange?: (status: TaskStatus) => void;
+    referenceAction?: React.ReactNode;
+    actions?: React.ReactNode;
+    feedback?: React.ReactNode;
+    referenceInteractive?: boolean;
+    compact?: boolean;
+};
+export declare function PlanningTaskCard({ task, assigneeOption, assigneeOptions, showStatusLabel, onOpen, onAssigneeChange, onStatusChange, referenceAction, actions, feedback, referenceInteractive, compact, }: PlanningTaskCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/planning/PlanningTaskCard.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { getStatusDefinition, resolveColor } from '../../../utils/constants';
+import { getTaskReferenceDisplayState } from '../../../utils/taskReferences';
+import { TaskStatusActions } from '../../task/TaskStatusActions';
+import { PlanningCardIdentity } from './PlanningCardIdentity';
+import { PlanningCardFooter, PlanningCardMeta, PlanningCardTitle, PlanningContextCount, PlanningReferenceBadge, } from './PlanningEntitySummary';
+import styles from './PlanningTaskCard.module.css';
+export function PlanningTaskCard({ task, assigneeOption, assigneeOptions, showStatusLabel, onOpen, onAssigneeChange, onStatusChange, referenceAction, actions, feedback, referenceInteractive = true, compact = false, }) {
+    const taskReference = getTaskReferenceDisplayState(task);
+    const referenceLabel = taskReference.label;
+    const statusDefinition = getStatusDefinition(task.status);
+    const statusLabel = statusDefinition.value === 'task'
+        ? ''
+        : (statusDefinition.shortLabel || statusDefinition.label);
+    const statusColor = resolveColor(statusDefinition.color);
+    const openLabel = referenceLabel
+        ? `Open task ${referenceLabel}: ${task.title}`
+        : `Open task ${task.title}`;
+    const handleKeyDown = (event) => {
+        if (!onOpen || (event.key !== 'Enter' && event.key !== ' '))
+            return;
+        event.preventDefault();
+        onOpen();
+    };
+    return (_jsxs("div", { className: `${styles.card} ${compact ? styles.compact : ''} ${task.isArchived ? styles.archived : ''}`.trim(), "data-task-status": statusDefinition.value, style: { '--planning-task-status-color': statusColor }, children: [_jsxs("div", { className: styles.topRow, children: [_jsxs("div", { className: styles.referenceRow, children: [referenceAction, referenceLabel ? (_jsx(PlanningReferenceBadge, { label: referenceLabel, entityType: "task", interactive: referenceInteractive, provisional: taskReference.isProvisional })) : _jsx("span", { "aria-hidden": "true" })] }), _jsxs("div", { className: styles.actions, onClick: (event) => event.stopPropagation(), children: [actions, _jsx(TaskStatusActions, { status: statusDefinition.value, disabled: Boolean(task.isArchived) || !onStatusChange, compressed: true, shortLabels: true, showLabel: showStatusLabel, archiveActionMode: "none", onStatusChange: onStatusChange })] })] }), feedback, _jsxs("div", { role: onOpen ? 'button' : undefined, tabIndex: onOpen ? 0 : undefined, className: styles.content, onClick: onOpen, onKeyDown: handleKeyDown, "aria-label": onOpen ? openLabel : undefined, children: [_jsx(PlanningCardTitle, { children: task.title }), _jsx(PlanningCardFooter, { identity: (_jsx(PlanningCardIdentity, { role: "assignee", option: assigneeOption, value: task.assignee, options: assigneeOptions, onChange: onAssigneeChange, disabled: Boolean(task.isArchived) })), children: _jsxs(PlanningCardMeta, { children: [statusLabel ? _jsxs(_Fragment, { children: [statusLabel, _jsx("span", { "aria-hidden": "true", children: " \u2022 " })] }) : null, _jsx(PlanningContextCount, { count: task.attachmentCount }), task.isArchived ? _jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": "true", children: " \u2022 " }), "archived"] }) : null] }) })] })] }));
+}

package/dist/components/features/planning/PlanningTaskOrderList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+import type { PlanningTaskArrangeMode } from './planningTaskArrangement';
+export declare function PlanningTaskOrderList(props: {
+    tasks: PlanningTaskPreview[];
+    mode: PlanningTaskArrangeMode;
+    onReorder?: (taskIds: string[]) => void | Promise<void>;
+    children: (task: PlanningTaskPreview) => React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningTaskOrderList.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { DndContext, KeyboardSensor, PointerSensor, closestCenter, useSensor, useSensors, } from '@dnd-kit/core';
+import { SortableContext, arrayMove, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy, } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { GripVertical } from 'lucide-react';
+import styles from './PlanningTaskOrderList.module.css';
+function SortableTask(props) {
+    const sortable = useSortable({ id: props.task.id, disabled: props.disabled });
+    return (_jsxs("div", { ref: sortable.setNodeRef, className: styles.item, style: { transform: CSS.Transform.toString(sortable.transform), transition: sortable.transition }, children: [_jsx("button", { type: "button", className: styles.grip, disabled: props.disabled, "aria-label": `Reorder ${props.task.title}`, title: "Drag to change execution order", ...sortable.attributes, ...sortable.listeners, children: _jsx(GripVertical, { size: 15, "aria-hidden": "true" }) }), _jsx("div", { className: styles.card, children: props.children })] }));
+}
+export function PlanningTaskOrderList(props) {
+    const [orderedIds, setOrderedIds] = React.useState(() => props.tasks.map((task) => task.id));
+    const [saving, setSaving] = React.useState(false);
+    const sourceKey = props.tasks.map((task) => task.id).join('\0');
+    React.useEffect(() => setOrderedIds(props.tasks.map((task) => task.id)), [sourceKey]);
+    const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 6 } }), useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }));
+    const orderedTasks = React.useMemo(() => {
+        const byId = new Map(props.tasks.map((task) => [task.id, task]));
+        return orderedIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+    }, [orderedIds, props.tasks]);
+    const draggable = props.mode === 'execution' && Boolean(props.onReorder);
+    const handleDragEnd = React.useCallback(async (event) => {
+        if (!draggable || saving || !event.over || event.active.id === event.over.id)
+            return;
+        const previous = orderedIds;
+        const from = previous.indexOf(String(event.active.id));
+        const to = previous.indexOf(String(event.over.id));
+        if (from < 0 || to < 0)
+            return;
+        const byId = new Map(orderedTasks.map((task) => [task.id, task]));
+        const terminal = (task) => task?.status === 'done' || task?.status === 'cancelled';
+        if (terminal(byId.get(previous[from])) !== terminal(byId.get(previous[to])))
+            return;
+        const next = arrayMove(previous, from, to);
+        setOrderedIds(next);
+        setSaving(true);
+        try {
+            await props.onReorder?.(next);
+        }
+        catch {
+            setOrderedIds(previous);
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [draggable, orderedIds, orderedTasks, props, saving]);
+    if (!draggable) {
+        return _jsx("div", { className: `${styles.list} ${props.className || ''}`.trim(), children: props.tasks.map((task) => (_jsx(React.Fragment, { children: props.children(task) }, task.id))) });
+    }
+    return (_jsx(DndContext, { sensors: sensors, collisionDetection: closestCenter, onDragEnd: (event) => void handleDragEnd(event), children: _jsx(SortableContext, { items: orderedIds, strategy: verticalListSortingStrategy, children: _jsx("div", { className: `${styles.list} ${props.className || ''}`.trim(), "aria-busy": saving || undefined, children: orderedTasks.map((task) => (_jsx(SortableTask, { task: task, disabled: saving, children: props.children(task) }, task.id))) }) }) }));
+}

package/dist/components/features/planning/PlanningUnlinkConfirmation.d.ts

@@ -0,0 +1,15 @@
+import type { TaskforceTheme } from '../../../utils/theme';
+export type PlanningRelationshipUnlink = {
+    entityType: 'workstream' | 'task';
+    id: string;
+    referenceLabel: string;
+    title: string;
+    parentLabel: string;
+};
+export declare function PlanningUnlinkConfirmation({ item, busy, theme, onCancel, onConfirm, }: {
+    item: PlanningRelationshipUnlink | null;
+    busy: boolean;
+    theme?: TaskforceTheme;
+    onCancel: () => void;
+    onConfirm: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningUnlinkConfirmation.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Unlink } from 'lucide-react';
+import { Modal } from '../../ui/Modal';
+import styles from './PlanningUnlinkConfirmation.module.css';
+export function PlanningUnlinkConfirmation({ item, busy, theme, onCancel, onConfirm, }) {
+    return (_jsx(Modal, { isOpen: Boolean(item), onClose: onCancel, closeDisabled: busy, closeOnOverlayClick: false, size: "sm", theme: theme, title: (_jsxs("span", { className: styles.title, children: [_jsx(Unlink, { size: 17, "aria-hidden": "true" }), "Unlink ", item?.entityType || 'item'] })), footer: (_jsxs("div", { className: styles.actions, children: [_jsx("button", { type: "button", className: "tf-button-secondary", disabled: busy, onClick: onCancel, "data-modal-initial-focus": true, children: "Cancel" }), _jsx("button", { type: "button", className: "tf-button-destructive", disabled: busy, onClick: onConfirm, children: busy ? 'Unlinking…' : 'Unlink' })] })), children: item ? (_jsxs("div", { className: styles.content, children: [_jsxs("p", { children: ["Unlink ", _jsx("strong", { children: item.referenceLabel }), " ", item.title, " from ", item.parentLabel, "?"] }), _jsx("p", { className: styles.help, children: "The item will remain available and can be linked again later." })] })) : null }));
+}

package/dist/components/features/planning/PlanningVisualIdentity.d.ts

@@ -0,0 +1,14 @@
+import { type PlanningIdentityColor, type PlanningIdentityEntityType, type PlanningIdentityIcon } from '../../../shared/planningIdentity';
+export type PlanningIdentityPatch = {
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+};
+export declare function PlanningVisualIdentity({ entityType, entityId, icon, color, disabled, size, onChange, }: {
+    entityType: PlanningIdentityEntityType;
+    entityId: string;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    disabled?: boolean;
+    size?: 'card' | 'inline' | 'detail';
+    onChange?: (patch: PlanningIdentityPatch) => void | Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningVisualIdentity.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { createPortal } from 'react-dom';
+import { BookOpen, Briefcase, Bug, Camera, Code, Compass, Flag, FlaskConical, Folder, Globe, Heart, Landmark, Layers, Lightbulb, Map, Music, Palette, Rocket, Route, Shield, Sparkles, Target, Users, Wrench, } from 'lucide-react';
+import { PLANNING_IDENTITY_COLORS, PLANNING_IDENTITY_ICONS, planningIdentityColorToken, resolvePlanningIdentity, } from '../../../shared/planningIdentity';
+import styles from './PlanningVisualIdentity.module.css';
+const ICONS = {
+    Target, Route, Flag, Rocket, Briefcase, Folder, Layers, Map, Compass, Landmark,
+    BookOpen, Lightbulb, Wrench, Shield, Bug, Palette, Camera, Music, Heart, Globe,
+    Users, Sparkles, FlaskConical, Code,
+};
+export function PlanningVisualIdentity({ entityType, entityId, icon, color, disabled = false, size = 'card', onChange, }) {
+    const [open, setOpen] = React.useState(false);
+    const [pending, setPending] = React.useState(false);
+    const [optimisticPatch, setOptimisticPatch] = React.useState(null);
+    const [portalTheme, setPortalTheme] = React.useState();
+    const [popoverPosition, setPopoverPosition] = React.useState({ top: 0, left: 0 });
+    const rootRef = React.useRef(null);
+    const triggerRef = React.useRef(null);
+    const popoverRef = React.useRef(null);
+    const optimisticIcon = optimisticPatch && Object.prototype.hasOwnProperty.call(optimisticPatch, 'icon')
+        ? optimisticPatch.icon
+        : icon;
+    const optimisticColor = optimisticPatch && Object.prototype.hasOwnProperty.call(optimisticPatch, 'color')
+        ? optimisticPatch.color
+        : color;
+    const resolved = resolvePlanningIdentity({
+        entityType,
+        entityId,
+        icon: optimisticIcon,
+        color: optimisticColor,
+    });
+    const Icon = ICONS[resolved.icon];
+    const editable = !disabled && Boolean(onChange);
+    React.useEffect(() => {
+        if (!open)
+            return undefined;
+        const close = (event) => {
+            const target = event.target;
+            if (!rootRef.current?.contains(target) && !popoverRef.current?.contains(target))
+                setOpen(false);
+        };
+        document.addEventListener('pointerdown', close);
+        return () => document.removeEventListener('pointerdown', close);
+    }, [open]);
+    React.useLayoutEffect(() => {
+        if (!open)
+            return undefined;
+        const positionPopover = () => {
+            const triggerRect = triggerRef.current?.getBoundingClientRect();
+            if (!triggerRect)
+                return;
+            setPortalTheme(triggerRef.current?.closest('[data-theme]')?.dataset.theme);
+            const popoverRect = popoverRef.current?.getBoundingClientRect();
+            const width = popoverRect?.width || 248;
+            const height = popoverRect?.height || 320;
+            const gap = 8;
+            const viewportPadding = 8;
+            const left = Math.max(viewportPadding, Math.min(triggerRect.left, window.innerWidth - width - viewportPadding));
+            const preferredTop = triggerRect.bottom + gap;
+            const top = preferredTop + height <= window.innerHeight - viewportPadding
+                ? preferredTop
+                : Math.max(viewportPadding, triggerRect.top - height - gap);
+            setPopoverPosition({ top, left });
+        };
+        positionPopover();
+        window.addEventListener('resize', positionPopover);
+        window.addEventListener('scroll', positionPopover, true);
+        return () => {
+            window.removeEventListener('resize', positionPopover);
+            window.removeEventListener('scroll', positionPopover, true);
+        };
+    }, [open]);
+    React.useEffect(() => {
+        if (!optimisticPatch)
+            return;
+        const iconSettled = !Object.prototype.hasOwnProperty.call(optimisticPatch, 'icon')
+            || (optimisticPatch.icon ?? null) === (icon ?? null);
+        const colorSettled = !Object.prototype.hasOwnProperty.call(optimisticPatch, 'color')
+            || (optimisticPatch.color ?? null) === (color ?? null);
+        if (iconSettled && colorSettled)
+            setOptimisticPatch(null);
+    }, [color, icon, optimisticPatch]);
+    const commit = async (patch) => {
+        if (!onChange || pending)
+            return;
+        setOptimisticPatch((current) => ({ ...current, ...patch }));
+        setPending(true);
+        try {
+            await onChange(patch);
+        }
+        catch {
+            setOptimisticPatch(null);
+        }
+        finally {
+            setPending(false);
+        }
+    };
+    const marker = (_jsx("span", { className: `${styles.marker} ${styles[size]} ${disabled ? styles.disabled : ''}`.trim(), style: { color: planningIdentityColorToken(resolved.color) }, "aria-hidden": "true", children: _jsx(Icon, { size: size === 'detail' ? 26 : size === 'inline' ? 18 : 24, strokeWidth: 1.9 }) }));
+    if (!editable)
+        return marker;
+    return (_jsxs("div", { ref: rootRef, className: styles.root, onClick: (event) => event.stopPropagation(), children: [_jsx("button", { ref: triggerRef, type: "button", className: styles.trigger, onClick: () => setOpen((current) => !current), onKeyDown: (event) => event.stopPropagation(), "aria-label": `Change ${entityType} icon and color`, "aria-expanded": open, disabled: pending, children: marker }), open ? createPortal((_jsxs("div", { ref: popoverRef, className: styles.popover, role: "dialog", "aria-label": `${entityType} icon and color`, "aria-busy": pending, "data-theme": portalTheme, style: popoverPosition, onClick: (event) => event.stopPropagation(), onKeyDown: (event) => event.stopPropagation(), children: [_jsx("div", { className: styles.colorGrid, "aria-label": "Colors", children: PLANNING_IDENTITY_COLORS.map((option) => (_jsx("button", { type: "button", className: `${styles.colorOption} ${resolved.color === option ? styles.selected : ''}`.trim(), style: { backgroundColor: planningIdentityColorToken(option) }, onClick: () => void commit({ color: option }), "aria-label": `${option} color`, "aria-pressed": resolved.color === option, disabled: pending }, option))) }), _jsx("div", { className: styles.divider }), _jsx("div", { className: styles.iconGrid, "aria-label": "Icons", children: PLANNING_IDENTITY_ICONS.map((option) => {
+                            const OptionIcon = ICONS[option];
+                            return (_jsx("button", { type: "button", className: `${styles.iconOption} ${resolved.icon === option ? styles.selected : ''}`.trim(), onClick: () => void commit({ icon: option }), "aria-label": option, "aria-pressed": resolved.icon === option, disabled: pending, children: _jsx(OptionIcon, { size: 18, strokeWidth: 1.8 }) }, option));
+                        }) }), _jsx("div", { className: styles.divider }), _jsx("button", { type: "button", className: styles.reset, onClick: () => void commit({ icon: null, color: null }), disabled: !resolved.customized || pending, children: "Reset to default" })] })), document.body) : null] }));
+}

package/dist/components/features/planning/planningCreateIntent.d.ts

@@ -0,0 +1,10 @@
+interface PlanningInitiativeReference {
+    id: string;
+    referenceNumber?: number | null;
+    title: string;
+}
+export declare function resolveWorkstreamCreateInitiativeId(initiatives: PlanningInitiativeReference[], fixedInitiativeId: string | null | undefined, draftInitiativeReference: string): {
+    initiativeId: string | null;
+    invalid: boolean;
+};
+export {};

package/dist/components/features/planning/planningCreateIntent.js

@@ -0,0 +1,16 @@
+import { resolveInitiativeReference } from '../../../utils/planningReferences';
+export function resolveWorkstreamCreateInitiativeId(initiatives, fixedInitiativeId, draftInitiativeReference) {
+    const fixedId = String(fixedInitiativeId || '').trim();
+    if (fixedId) {
+        return initiatives.some((initiative) => initiative.id === fixedId)
+            ? { initiativeId: fixedId, invalid: false }
+            : { initiativeId: null, invalid: true };
+    }
+    const draftReference = draftInitiativeReference.trim();
+    if (!draftReference)
+        return { initiativeId: null, invalid: false };
+    const resolved = resolveInitiativeReference(initiatives, draftReference);
+    return resolved
+        ? { initiativeId: resolved.id, invalid: false }
+        : { initiativeId: null, invalid: true };
+}

package/dist/components/features/planning/planningNavigator.d.ts

@@ -0,0 +1,33 @@
+import type { PlanningInitiativeSummary, PlanningNodeSummary, PlanningWorkstreamSummary } from './planningWorkspaceModel';
+export type PlanningNavigatorOwnerFilter = string;
+export type PlanningNavigatorSort = 'default' | 'title' | 'owner' | 'progress';
+export declare const PLANNING_NAVIGATOR_SORT_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+export type PlanningNavigatorInitiativeResult = {
+    initiative: PlanningInitiativeSummary;
+    workstreams: PlanningWorkstreamSummary[];
+};
+export declare function matchesPlanningNavigatorItem({ item, entityType, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, }: {
+    item: PlanningNodeSummary;
+    entityType: 'initiative' | 'workstream';
+    showArchivedPlanning: boolean;
+    searchQuery: string;
+    ownerFilter: PlanningNavigatorOwnerFilter;
+    currentOwnerId: string;
+}): boolean;
+export declare function buildPlanningNavigatorResults({ initiatives, standaloneWorkstreams, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, sort, }: {
+    initiatives: PlanningInitiativeSummary[];
+    standaloneWorkstreams: PlanningWorkstreamSummary[];
+    showArchivedPlanning: boolean;
+    searchQuery: string;
+    ownerFilter: PlanningNavigatorOwnerFilter;
+    currentOwnerId: string;
+    sort: PlanningNavigatorSort;
+}): {
+    initiatives: PlanningNavigatorInitiativeResult[];
+    standaloneWorkstreams: PlanningWorkstreamSummary[];
+    hasCriteria: boolean;
+    resultCount: number;
+};

package/dist/components/features/planning/planningNavigator.js

@@ -0,0 +1,96 @@
+import { formatInitiativeReference, formatWorkstreamReference, } from '../../../utils/planningReferences';
+export const PLANNING_NAVIGATOR_SORT_OPTIONS = [
+    { value: 'default', label: 'Default order' },
+    { value: 'title', label: 'Title' },
+    { value: 'owner', label: 'Owner' },
+    { value: 'progress', label: 'Progress' },
+];
+function matchesPlanningOwner(item, ownerFilter, currentOwnerId) {
+    if (ownerFilter === 'all')
+        return true;
+    const ownerId = String(item.ownerId || '').trim();
+    if (ownerFilter === 'unassigned')
+        return !ownerId;
+    if (ownerFilter === 'mine')
+        return Boolean(currentOwnerId) && ownerId === currentOwnerId;
+    return ownerId === ownerFilter;
+}
+function matchesPlanningSearch(item, entityType, normalizedQuery) {
+    if (!normalizedQuery)
+        return true;
+    const reference = entityType === 'initiative'
+        ? formatInitiativeReference(item)
+        : formatWorkstreamReference(item);
+    return item.title.toLocaleLowerCase().includes(normalizedQuery)
+        || reference.toLocaleLowerCase().includes(normalizedQuery);
+}
+export function matchesPlanningNavigatorItem({ item, entityType, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, }) {
+    return (showArchivedPlanning || !item.isArchived)
+        && matchesPlanningOwner(item, ownerFilter, currentOwnerId.trim())
+        && matchesPlanningSearch(item, entityType, searchQuery.trim().toLocaleLowerCase());
+}
+function sortPlanningItems(items, sort) {
+    if (sort === 'default')
+        return items;
+    return items
+        .map((item, index) => ({ item, index }))
+        .sort((left, right) => {
+        let comparison = 0;
+        if (sort === 'title') {
+            comparison = left.item.title.localeCompare(right.item.title, undefined, { sensitivity: 'base' });
+        }
+        else if (sort === 'owner') {
+            const leftOwner = String(left.item.ownerLabel || '').trim();
+            const rightOwner = String(right.item.ownerLabel || '').trim();
+            if (!leftOwner && rightOwner)
+                comparison = 1;
+            else if (leftOwner && !rightOwner)
+                comparison = -1;
+            else
+                comparison = leftOwner.localeCompare(rightOwner, undefined, { sensitivity: 'base' });
+        }
+        else {
+            comparison = right.item.progressPercent - left.item.progressPercent;
+        }
+        return comparison || left.index - right.index;
+    })
+        .map(({ item }) => item);
+}
+export function buildPlanningNavigatorResults({ initiatives, standaloneWorkstreams, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, sort, }) {
+    const normalizedQuery = searchQuery.trim().toLocaleLowerCase();
+    const hasCriteria = Boolean(normalizedQuery) || ownerFilter !== 'all';
+    const normalizedCurrentOwnerId = currentOwnerId.trim();
+    const visibleInitiatives = initiatives.filter((initiative) => showArchivedPlanning || !initiative.isArchived);
+    const initiativeResults = visibleInitiatives.flatMap((initiative) => {
+        const allWorkstreams = (initiative.allWorkstreams || initiative.workstreams)
+            .filter((workstream) => showArchivedPlanning || !workstream.isArchived);
+        if (!hasCriteria) {
+            return [{ initiative, workstreams: sortPlanningItems(allWorkstreams, sort) }];
+        }
+        const initiativeOwnerMatches = matchesPlanningOwner(initiative, ownerFilter, normalizedCurrentOwnerId);
+        const initiativeSearchMatches = matchesPlanningSearch(initiative, 'initiative', normalizedQuery);
+        const initiativeMatches = initiativeOwnerMatches && initiativeSearchMatches;
+        const ownerMatchedWorkstreams = allWorkstreams.filter((workstream) => (matchesPlanningOwner(workstream, ownerFilter, normalizedCurrentOwnerId)));
+        const matchingWorkstreams = ownerMatchedWorkstreams.filter((workstream) => (matchesPlanningSearch(workstream, 'workstream', normalizedQuery)));
+        const resultWorkstreams = initiativeMatches && normalizedQuery
+            ? ownerMatchedWorkstreams
+            : matchingWorkstreams;
+        if (!initiativeMatches && resultWorkstreams.length === 0)
+            return [];
+        return [{ initiative, workstreams: sortPlanningItems(resultWorkstreams, sort) }];
+    });
+    const initiativeResultById = new Map(initiativeResults.map((result) => [result.initiative.id, result]));
+    const sortedInitiativeResults = sortPlanningItems(initiativeResults.map(({ initiative }) => initiative), sort).map((initiative) => initiativeResultById.get(initiative.id));
+    const visibleStandaloneWorkstreams = standaloneWorkstreams.filter((workstream) => ((showArchivedPlanning || !workstream.isArchived)
+        && matchesPlanningOwner(workstream, ownerFilter, normalizedCurrentOwnerId)
+        && matchesPlanningSearch(workstream, 'workstream', normalizedQuery)));
+    const sortedStandaloneWorkstreams = sortPlanningItems(visibleStandaloneWorkstreams, sort);
+    return {
+        initiatives: sortedInitiativeResults,
+        standaloneWorkstreams: sortedStandaloneWorkstreams,
+        hasCriteria,
+        resultCount: sortedInitiativeResults.length
+            + sortedInitiativeResults.reduce((count, result) => count + result.workstreams.length, 0)
+            + sortedStandaloneWorkstreams.length,
+    };
+}

package/dist/components/features/planning/planningTaskArrangement.d.ts

@@ -0,0 +1,18 @@
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+export type PlanningTaskArrangeMode = 'execution' | 'ready' | 'priority';
+export declare const PLANNING_TASK_ARRANGE_OPTIONS: readonly ({
+    value: "execution";
+    label: string;
+    description: string;
+} | {
+    value: "ready";
+    label: string;
+    description: string;
+} | {
+    value: "priority";
+    label: string;
+    description: string;
+})[];
+export declare function normalizePlanningTaskArrangeMode(value: unknown): PlanningTaskArrangeMode;
+export declare function mergeVisiblePlanningTaskOrder(allTasks: readonly PlanningTaskPreview[], reorderedVisibleTaskIds: readonly string[]): string[];
+export declare function arrangePlanningTasks(tasks: readonly PlanningTaskPreview[], mode: PlanningTaskArrangeMode): PlanningTaskPreview[];