@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/components/features/settings/TaxonomyLibraryManager.js

@@ -0,0 +1,301 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { BookMarked, Check, Layers, PackageOpen, Shapes } from 'lucide-react';
+import styles from '../../../Taskforce.module.css';
+import { IconMap } from '../../../utils/constants';
+import { listBuiltInCustomTaxonomyLibraryPacks } from '../../../shared/customTaxonomyLibrary.js';
+import { listBuiltInTaxonomyLibraryPacks } from '../../../shared/taxonomyLibrary.js';
+import libraryStyles from './TaxonomyLibraryManager.module.css';
+function renderIcon(iconName, fallback = 'Layers') {
+    const ResolvedIcon = IconMap[iconName || fallback] || IconMap[fallback];
+    return _jsx(ResolvedIcon, { size: 15 });
+}
+function defaultApplySections(pack) {
+    return {
+        categories: pack.categories.length > 0,
+        types: pack.types.length > 0,
+        priorities: pack.priorities.length > 0,
+    };
+}
+function PreviewListSection(props) {
+    const { title, items } = props;
+    return (_jsxs("section", { className: libraryStyles.previewSection, children: [_jsx("h4", { className: libraryStyles.previewSectionTitle, children: title }), _jsx("div", { className: libraryStyles.previewList, children: items.map((item) => (_jsxs("div", { className: libraryStyles.previewItem, children: [_jsxs("span", { className: libraryStyles.previewItemLabel, children: [_jsx("span", { style: { color: item.color ? `var(--color-${item.color}, var(--text-secondary))` : 'var(--text-secondary)' }, children: renderIcon(item.icon) }), _jsx("span", { children: item.label })] }), item.meta ? _jsx("span", { className: libraryStyles.previewItemMeta, children: item.meta }) : null] }, item.key))) })] }));
+}
+function summarizeCustomPack(pack) {
+    let multiSelectCount = 0;
+    let numericCount = 0;
+    let requiredCount = 0;
+    let formEnabledCount = 0;
+    pack.taxonomies.forEach((taxonomy) => {
+        if (taxonomy.multiSelect)
+            multiSelectCount += 1;
+        if (taxonomy.widgetType === 'level')
+            numericCount += 1;
+        if (taxonomy.isRequired)
+            requiredCount += 1;
+        if (taxonomy.formEnabled !== false)
+            formEnabledCount += 1;
+    });
+    return { multiSelectCount, numericCount, requiredCount, formEnabledCount };
+}
+function taxonomyTraitBadges(taxonomy) {
+    const badges = [];
+    badges.push(taxonomy.widgetType === 'level' ? 'Numeric' : 'Descriptive');
+    if (taxonomy.multiSelect)
+        badges.push('Multi-select');
+    if (taxonomy.isRequired)
+        badges.push('Required');
+    if (taxonomy.formEnabled !== false)
+        badges.push('Shows in forms');
+    if (taxonomy.filterEnabled)
+        badges.push('Filterable');
+    if (taxonomy.sortEnabled)
+        badges.push('Sortable');
+    return badges;
+}
+function cloneCustomTaxonomyDefinition(taxonomy) {
+    return {
+        ...taxonomy,
+        aliases: Array.isArray(taxonomy.aliases) ? [...taxonomy.aliases] : undefined,
+        options: Array.isArray(taxonomy.options)
+            ? taxonomy.options.map((option) => ({
+                ...option,
+                aliases: Array.isArray(option.aliases) ? [...option.aliases] : undefined
+            }))
+            : []
+    };
+}
+function SystemTaxonomyLibrarySurface(props) {
+    const { onAnalyzeSystemTaxonomyPack, onApplySystemTaxonomyPack } = props;
+    const fallbackPacks = useMemo(() => listBuiltInTaxonomyLibraryPacks(), []);
+    const [packs, setPacks] = useState(fallbackPacks);
+    const [selectedPackId, setSelectedPackId] = useState(fallbackPacks[0]?.id || '');
+    const [applySections, setApplySections] = useState(() => (fallbackPacks[0] ? defaultApplySections(fallbackPacks[0]) : { categories: true, types: true, priorities: true }));
+    const [remapExistingValuesToDefault, setRemapExistingValuesToDefault] = useState(false);
+    const [libraryNotice, setLibraryNotice] = useState(null);
+    const [libraryLoading, setLibraryLoading] = useState(false);
+    const [applyBusy, setApplyBusy] = useState(false);
+    const selectedPack = packs.find((pack) => pack.id === selectedPackId) || packs[0] || null;
+    const packAnalysis = useMemo(() => {
+        if (!selectedPack || !onAnalyzeSystemTaxonomyPack)
+            return null;
+        return onAnalyzeSystemTaxonomyPack(selectedPack);
+    }, [onAnalyzeSystemTaxonomyPack, selectedPack]);
+    useEffect(() => {
+        let cancelled = false;
+        setLibraryLoading(true);
+        void fetch('/api/taskforce/taxonomy-library')
+            .then(async (res) => {
+            if (!res.ok)
+                return null;
+            const payload = await res.json().catch(() => ({}));
+            const nextPacks = Array.isArray(payload?.packs) ? payload.packs : [];
+            if (!cancelled && nextPacks.length > 0) {
+                setPacks(nextPacks);
+                setSelectedPackId((current) => nextPacks.some((pack) => pack.id === current) ? current : nextPacks[0].id);
+            }
+            return null;
+        })
+            .catch(() => null)
+            .finally(() => {
+            if (!cancelled)
+                setLibraryLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const handleSelectPack = (packId) => {
+        const pack = packs.find((entry) => entry.id === packId);
+        setSelectedPackId(packId);
+        setApplySections(pack ? defaultApplySections(pack) : { categories: true, types: true, priorities: true });
+        setRemapExistingValuesToDefault(false);
+        setLibraryNotice(null);
+    };
+    const handleToggleSection = (section) => {
+        setApplySections((current) => ({
+            ...current,
+            [section]: !current[section]
+        }));
+    };
+    const handleApply = () => {
+        if (!selectedPack)
+            return;
+        const enabledSections = Object.entries(applySections)
+            .filter(([, enabled]) => enabled)
+            .map(([key]) => key);
+        if (enabledSections.length === 0) {
+            setLibraryNotice({ type: 'error', message: 'Select at least one taxonomy section to apply.' });
+            return;
+        }
+        if (!onApplySystemTaxonomyPack) {
+            setLibraryNotice({ type: 'error', message: 'System taxonomy pack apply is not available in this surface yet.' });
+            return;
+        }
+        setApplyBusy(true);
+        setLibraryNotice(null);
+        void onApplySystemTaxonomyPack({
+            pack: selectedPack,
+            sections: applySections,
+            remapExistingValuesToDefault,
+        }).then((result) => {
+            if (result?.success) {
+                setLibraryNotice({ type: 'success', message: `${selectedPack.label} was applied to the selected taxonomy sections.` });
+                return;
+            }
+            setLibraryNotice({ type: 'error', message: result?.error || 'Failed to apply the selected taxonomy pack.' });
+        }).catch((error) => {
+            setLibraryNotice({
+                type: 'error',
+                message: error instanceof Error ? error.message : 'Failed to apply the selected taxonomy pack.'
+            });
+        }).finally(() => {
+            setApplyBusy(false);
+        });
+    };
+    if (!selectedPack) {
+        return (_jsx("div", { className: styles.emptyState, children: _jsx("p", { className: "tf-empty-copy", children: "No system taxonomy library packs are available." }) }));
+    }
+    return (_jsxs("div", { className: libraryStyles.libraryContainer, children: [_jsxs("section", { className: libraryStyles.introCard, children: [_jsxs("span", { className: libraryStyles.eyebrow, children: [_jsx(BookMarked, { size: 14 }), "System Taxonomy Library"] }), _jsx("h3", { className: libraryStyles.introTitle, children: "Browse starter packs before you replace anything." }), _jsx("p", { className: libraryStyles.introCopy, children: "Library packs give you coordinated categories, task types, and priority scales. Apply replaces only the sections you choose." }), libraryLoading ? _jsx("p", { className: libraryStyles.prototypeNotice, children: "Loading available packs\u2026" }) : null] }), _jsxs("div", { className: libraryStyles.libraryGrid, children: [_jsx("div", { className: libraryStyles.packList, children: packs.map((pack) => {
+                            const isActive = pack.id === selectedPackId;
+                            return (_jsxs("article", { className: `${libraryStyles.packCard} ${isActive ? libraryStyles.packCardActive : ''}`, children: [_jsx("div", { className: libraryStyles.packHeader, children: _jsxs("div", { className: libraryStyles.packHeaderText, children: [_jsx("div", { className: libraryStyles.packTitleRow, children: _jsx("h4", { className: libraryStyles.packTitle, children: pack.label }) }), _jsx("p", { className: libraryStyles.packDescription, children: pack.description })] }) }), _jsxs("div", { className: libraryStyles.packCounts, children: [_jsxs("span", { className: libraryStyles.packCountChip, children: [_jsx(Layers, { size: 13 }), pack.categories.length, " categories"] }), _jsxs("span", { className: libraryStyles.packCountChip, children: [_jsx(PackageOpen, { size: 13 }), pack.types.length, " types"] }), _jsxs("span", { className: libraryStyles.packCountChip, children: [_jsx(Check, { size: 13 }), pack.priorities.length, " priority levels"] })] }), _jsxs("div", { className: libraryStyles.packActions, children: [_jsx("button", { type: "button", className: styles.cancelBtn, onClick: () => handleSelectPack(pack.id), children: isActive ? 'Previewing' : 'Preview' }), _jsx("button", { type: "button", className: styles.submitBtn, onClick: () => handleSelectPack(pack.id), children: "Apply" })] })] }, pack.id));
+                        }) }), _jsxs("aside", { className: libraryStyles.previewPanel, children: [_jsxs("div", { className: libraryStyles.previewHeader, children: [_jsx("h3", { className: libraryStyles.previewTitle, children: selectedPack.label }), _jsx("p", { className: libraryStyles.previewSubtext, children: "Read-only preview. Applying this pack will replace only the sections you choose." })] }), _jsx(PreviewListSection, { title: "Categories", items: selectedPack.categories.map((category) => ({
+                                    key: category.value,
+                                    label: category.label,
+                                    icon: category.icon,
+                                    color: category.color,
+                                })) }), _jsx(PreviewListSection, { title: "Task Types", items: selectedPack.types.map((type) => ({
+                                    key: type.value,
+                                    label: type.label,
+                                    icon: type.icon,
+                                    color: type.color,
+                                    meta: type.status === 'retired' ? 'Retired' : undefined,
+                                })) }), _jsx(PreviewListSection, { title: "Priority Levels", items: selectedPack.priorities.map((priority) => ({
+                                    key: String(priority.value),
+                                    label: priority.label,
+                                    icon: priority.icon,
+                                    color: priority.color,
+                                    meta: `Level ${priority.value}`,
+                                })) }), _jsxs("section", { className: libraryStyles.applyPanel, children: [_jsx("h4", { className: libraryStyles.applyTitle, children: "Apply Selected Sections" }), _jsx("p", { className: libraryStyles.applyCopy, children: "Applying this pack will replace the selected taxonomy sections in this workspace." }), packAnalysis ? (_jsxs("div", { className: libraryStyles.analysisPanel, children: [packAnalysis.unmatchedCategoryValues.length > 0 ? (_jsxs("p", { className: libraryStyles.analysisCopy, children: [packAnalysis.unmatchedCategoryValues.length, " category value", packAnalysis.unmatchedCategoryValues.length === 1 ? '' : 's', " will be preserved as legacy unless you remap to default."] })) : null, packAnalysis.unmatchedTypeValues.length > 0 ? (_jsxs("p", { className: libraryStyles.analysisCopy, children: [packAnalysis.unmatchedTypeValues.length, " type value", packAnalysis.unmatchedTypeValues.length === 1 ? '' : 's', " will be preserved as legacy unless you remap to default."] })) : null, packAnalysis.incompatiblePriorityValues.length > 0 ? (_jsxs("p", { className: libraryStyles.analysisWarning, children: ["Existing tasks use priority level", packAnalysis.incompatiblePriorityValues.length === 1 ? '' : 's', " ", packAnalysis.incompatiblePriorityValues.join(', '), ". Priority replacement will be blocked unless you remap unmatched existing values to default."] })) : null, packAnalysis.unmatchedCategoryValues.length === 0
+                                                && packAnalysis.unmatchedTypeValues.length === 0
+                                                && packAnalysis.incompatiblePriorityValues.length === 0 ? (_jsx("p", { className: libraryStyles.analysisCopy, children: "This pack lines up with the current workspace values for the selected taxonomy sections." })) : null] })) : null, _jsxs("div", { className: libraryStyles.checkboxList, children: [_jsxs("label", { className: libraryStyles.checkboxLabel, children: [_jsx("input", { type: "checkbox", checked: applySections.categories, onChange: () => handleToggleSection('categories') }), _jsx("span", { children: "Categories" })] }), _jsxs("label", { className: libraryStyles.checkboxLabel, children: [_jsx("input", { type: "checkbox", checked: applySections.types, onChange: () => handleToggleSection('types') }), _jsx("span", { children: "Types" })] }), _jsxs("label", { className: libraryStyles.checkboxLabel, children: [_jsx("input", { type: "checkbox", checked: applySections.priorities, onChange: () => handleToggleSection('priorities') }), _jsx("span", { children: "Priorities" })] })] }), _jsxs("label", { className: libraryStyles.checkboxLabel, children: [_jsx("input", { type: "checkbox", checked: remapExistingValuesToDefault, onChange: () => setRemapExistingValuesToDefault((current) => !current) }), _jsx("span", { children: "Remap unmatched existing values to default" })] }), _jsx("p", { className: libraryStyles.applyCopy, children: "Leave this off to preserve unmatched category and type values as legacy entries. Priority replacement will be blocked if existing tasks use values outside the selected pack." }), _jsx("div", { className: libraryStyles.packActions, children: _jsx("button", { type: "button", className: styles.submitBtn, onClick: handleApply, disabled: applyBusy, children: applyBusy ? 'Applying…' : 'Apply Pack' }) }), libraryNotice ? (_jsx("p", { className: `${libraryStyles.prototypeResult} ${libraryNotice.type === 'error' ? libraryStyles.prototypeError : ''}`, children: libraryNotice.message })) : null] })] })] })] }));
+}
+function CustomTaxonomyLibrarySurface(props) {
+    const { taxonomies = [], onUpdateCustomTaxonomies } = props;
+    const fallbackPacks = useMemo(() => listBuiltInCustomTaxonomyLibraryPacks(), []);
+    const [packs, setPacks] = useState(fallbackPacks);
+    const [selectedPackId, setSelectedPackId] = useState(fallbackPacks[0]?.id || '');
+    const [libraryLoading, setLibraryLoading] = useState(false);
+    const [libraryError, setLibraryError] = useState(null);
+    const [selectedTaxonomyIds, setSelectedTaxonomyIds] = useState(fallbackPacks[0]?.taxonomies.map((taxonomy) => taxonomy.id) || []);
+    const [libraryNotice, setLibraryNotice] = useState(null);
+    const selectedPack = packs.find((pack) => pack.id === selectedPackId) || packs[0] || null;
+    const selectedPackSummary = selectedPack ? summarizeCustomPack(selectedPack) : null;
+    const selectedTaxonomies = useMemo(() => {
+        if (!selectedPack)
+            return [];
+        return selectedPack.taxonomies.filter((taxonomy) => selectedTaxonomyIds.includes(taxonomy.id));
+    }, [selectedPack, selectedTaxonomyIds]);
+    const selectedTaxonomyIdSet = useMemo(() => new Set(selectedTaxonomyIds), [selectedTaxonomyIds]);
+    const conflictIds = useMemo(() => {
+        const existingIds = new Set(taxonomies.map((taxonomy) => taxonomy.id));
+        return selectedTaxonomies
+            .map((taxonomy) => taxonomy.id)
+            .filter((taxonomyId) => existingIds.has(taxonomyId));
+    }, [selectedTaxonomies, taxonomies]);
+    const installableTaxonomies = useMemo(() => {
+        if (!selectedPack)
+            return [];
+        const existingIds = new Set(taxonomies.map((taxonomy) => taxonomy.id));
+        return selectedPack.taxonomies.filter((taxonomy) => selectedTaxonomyIdSet.has(taxonomy.id) && !existingIds.has(taxonomy.id));
+    }, [selectedPack, selectedTaxonomyIdSet, taxonomies]);
+    useEffect(() => {
+        let cancelled = false;
+        setLibraryLoading(true);
+        setLibraryError(null);
+        void fetch('/api/taskforce/custom-taxonomy-library')
+            .then(async (res) => {
+            if (!res.ok)
+                throw new Error(`Failed to load custom taxonomy packs (${res.status})`);
+            const payload = await res.json().catch(() => ({}));
+            const nextPacks = Array.isArray(payload?.packs) ? payload.packs : [];
+            if (!cancelled && nextPacks.length > 0) {
+                setPacks(nextPacks);
+                setSelectedPackId((current) => nextPacks.some((pack) => pack.id === current) ? current : nextPacks[0].id);
+            }
+        })
+            .catch((error) => {
+            if (cancelled)
+                return;
+            setLibraryError(error instanceof Error ? error.message : 'Failed to load custom taxonomy packs.');
+        })
+            .finally(() => {
+            if (!cancelled)
+                setLibraryLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    useEffect(() => {
+        setSelectedTaxonomyIds(selectedPack?.taxonomies.map((taxonomy) => taxonomy.id) || []);
+        setLibraryNotice(null);
+    }, [selectedPackId, selectedPack]);
+    if (!selectedPack) {
+        return (_jsx("div", { className: styles.emptyState, children: _jsx("p", { className: "tf-empty-copy", children: "No custom taxonomy library packs are available." }) }));
+    }
+    const handleToggleTaxonomySelection = (taxonomyId) => {
+        setSelectedTaxonomyIds((current) => (current.includes(taxonomyId)
+            ? current.filter((id) => id !== taxonomyId)
+            : [...current, taxonomyId]));
+        setLibraryNotice(null);
+    };
+    const handleSelectInstallableOnly = () => {
+        setSelectedTaxonomyIds(installableTaxonomies.map((taxonomy) => taxonomy.id));
+        setLibraryNotice(null);
+    };
+    const handleApply = () => {
+        if (selectedTaxonomyIds.length === 0) {
+            setLibraryNotice({ type: 'error', message: 'Select at least one taxonomy to install.' });
+            return;
+        }
+        if (conflictIds.length > 0) {
+            setLibraryNotice({
+                type: 'error',
+                message: `This workspace already has ${conflictIds.length} taxonomy ${conflictIds.length === 1 ? 'id' : 'ids'} that match your current selection. Deselect conflicting taxonomies before installing this pack.`
+            });
+            return;
+        }
+        if (!onUpdateCustomTaxonomies) {
+            setLibraryNotice({ type: 'error', message: 'Custom taxonomy install is not available in this surface yet.' });
+            return;
+        }
+        onUpdateCustomTaxonomies([
+            ...taxonomies,
+            ...installableTaxonomies.map((taxonomy) => cloneCustomTaxonomyDefinition(taxonomy))
+        ]);
+        setLibraryNotice({
+            type: 'success',
+            message: `${installableTaxonomies.length} custom ${installableTaxonomies.length === 1 ? 'taxonomy was' : 'taxonomies were'} added to this workspace.`
+        });
+    };
+    return (_jsxs("div", { className: libraryStyles.libraryContainer, children: [_jsxs("section", { className: libraryStyles.introCard, children: [_jsxs("span", { className: libraryStyles.eyebrow, children: [_jsx(Shapes, { size: 14 }), "Custom Taxonomy Library"] }), _jsx("h3", { className: libraryStyles.introTitle, children: "Browse reusable custom taxonomy packs." }), _jsx("p", { className: libraryStyles.introCopy, children: "These packs install workspace-owned custom taxonomies such as approval stages, channels, and effort bands. Review a pack, choose the taxonomies you want, and install them into this workspace." }), libraryLoading ? _jsx("p", { className: libraryStyles.prototypeNotice, children: "Loading available packs\u2026" }) : null, libraryError ? _jsx("p", { className: `${libraryStyles.prototypeResult} ${libraryStyles.prototypeError}`, children: libraryError }) : null] }), _jsxs("div", { className: libraryStyles.libraryGrid, children: [_jsx("div", { className: libraryStyles.packList, children: packs.map((pack) => {
+                            const isActive = pack.id === selectedPackId;
+                            const summary = summarizeCustomPack(pack);
+                            const taxonomyNames = pack.taxonomies.slice(0, 3).map((taxonomy) => taxonomy.label);
+                            return (_jsxs("article", { className: `${libraryStyles.packCard} ${isActive ? libraryStyles.packCardActive : ''}`, children: [_jsx("div", { className: libraryStyles.packHeader, children: _jsxs("div", { className: libraryStyles.packHeaderText, children: [_jsxs("div", { className: libraryStyles.packTitleRow, children: [_jsx("h4", { className: libraryStyles.packTitle, children: pack.label }), pack.domainTag ? _jsx("span", { className: libraryStyles.packBadge, children: pack.domainTag }) : null] }), _jsx("p", { className: libraryStyles.packDescription, children: pack.description }), pack.bestFor ? (_jsxs("p", { className: libraryStyles.packBestFor, children: [_jsx("strong", { children: "Best for:" }), " ", pack.bestFor] })) : null] }) }), _jsxs("div", { className: libraryStyles.packCounts, children: [_jsxs("span", { className: libraryStyles.packCountChip, children: [_jsx(Shapes, { size: 13 }), pack.taxonomies.length, " taxonomies"] }), summary.multiSelectCount > 0 ? (_jsx("span", { className: libraryStyles.packCountChip, children: "Multi-select" })) : null, summary.numericCount > 0 ? (_jsx("span", { className: libraryStyles.packCountChip, children: "Numeric" })) : null, summary.requiredCount > 0 ? (_jsx("span", { className: libraryStyles.packCountChip, children: "Required" })) : null] }), _jsxs("div", { className: libraryStyles.packTaxonomyPreview, children: [taxonomyNames.map((name) => (_jsx("span", { className: libraryStyles.packTaxonomyChip, children: name }, name))), pack.taxonomies.length > taxonomyNames.length ? (_jsxs("span", { className: libraryStyles.packTaxonomyMore, children: ["+", pack.taxonomies.length - taxonomyNames.length, " more"] })) : null] }), _jsx("div", { className: libraryStyles.packActions, children: _jsx("button", { type: "button", className: styles.cancelBtn, onClick: () => setSelectedPackId(pack.id), children: isActive ? 'Previewing' : 'Preview' }) })] }, pack.id));
+                        }) }), _jsxs("aside", { className: libraryStyles.previewPanel, children: [_jsxs("div", { className: libraryStyles.previewHeader, children: [_jsx("h3", { className: libraryStyles.previewTitle, children: selectedPack.label }), selectedPack.bestFor ? (_jsxs("p", { className: libraryStyles.previewBestFor, children: [_jsx("strong", { children: "Best for:" }), " ", selectedPack.bestFor] })) : null, _jsx("p", { className: libraryStyles.previewSubtext, children: "Review each taxonomy before installing it into this workspace. Installed taxonomies become normal workspace-owned custom taxonomies." })] }), _jsxs("div", { className: libraryStyles.previewSummaryRow, children: [_jsxs("span", { className: libraryStyles.packCountChip, children: [selectedPack.taxonomies.length, " taxonomies"] }), (selectedPackSummary?.formEnabledCount || 0) > 0 ? (_jsxs("span", { className: libraryStyles.packCountChip, children: [selectedPackSummary.formEnabledCount, " show in forms"] })) : null, (selectedPackSummary?.numericCount || 0) > 0 ? (_jsxs("span", { className: libraryStyles.packCountChip, children: [selectedPackSummary.numericCount, " numeric"] })) : null, (selectedPackSummary?.requiredCount || 0) > 0 ? (_jsxs("span", { className: libraryStyles.packCountChip, children: [selectedPackSummary.requiredCount, " required"] })) : null] }), _jsxs("section", { className: libraryStyles.applyPanel, children: [_jsx("h4", { className: libraryStyles.applyTitle, children: "Choose Taxonomies to Install" }), _jsx("p", { className: libraryStyles.applyCopy, children: "Select only the taxonomies you want to add. This first pass installs new custom taxonomies only and asks you to skip conflicts rather than replace them." }), _jsx("div", { className: libraryStyles.checkboxList, children: selectedPack.taxonomies.map((taxonomy) => (_jsxs("label", { className: libraryStyles.checkboxLabel, children: [_jsx("input", { type: "checkbox", checked: selectedTaxonomyIds.includes(taxonomy.id), onChange: () => handleToggleTaxonomySelection(taxonomy.id) }), _jsxs("span", { children: [taxonomy.label, taxonomies.some((existingTaxonomy) => existingTaxonomy.id === taxonomy.id) ? ' (Already installed)' : ''] })] }, taxonomy.id))) }), _jsxs("div", { className: libraryStyles.analysisPanel, children: [_jsxs("p", { className: libraryStyles.analysisCopy, children: [selectedTaxonomyIds.length, " ", selectedTaxonomyIds.length === 1 ? 'taxonomy is' : 'taxonomies are', " currently selected from this pack."] }), installableTaxonomies.length > 0 ? (_jsxs("p", { className: libraryStyles.analysisCopy, children: [installableTaxonomies.length, " selected ", installableTaxonomies.length === 1 ? 'taxonomy is' : 'taxonomies are', " ready to install right now."] })) : (_jsx("p", { className: libraryStyles.analysisCopy, children: "No selected taxonomies are currently installable." })), conflictIds.length > 0 ? (_jsxs("p", { className: libraryStyles.analysisWarning, children: [conflictIds.length, " selected ", conflictIds.length === 1 ? 'taxonomy conflicts' : 'taxonomies conflict', " with existing workspace ids: ", conflictIds.join(', '), "."] })) : null] }), _jsxs("div", { className: libraryStyles.packActions, children: [conflictIds.length > 0 ? (_jsx("button", { type: "button", className: styles.cancelBtn, onClick: handleSelectInstallableOnly, children: "Select Installable Only" })) : null, _jsx("button", { type: "button", className: styles.submitBtn, onClick: handleApply, disabled: selectedTaxonomyIds.length === 0 || installableTaxonomies.length === 0, children: "Install Selected Taxonomies" })] }), libraryNotice ? (_jsx("p", { className: `${libraryStyles.prototypeResult} ${libraryNotice.type === 'error' ? libraryStyles.prototypeError : ''}`, children: libraryNotice.message })) : null] }), selectedPack.taxonomies.map((taxonomy) => (_jsxs("section", { className: libraryStyles.customTaxonomyCard, children: [_jsx("div", { className: libraryStyles.customTaxonomyHeader, children: _jsxs("div", { children: [_jsx("h4", { className: libraryStyles.previewSectionTitle, children: taxonomy.label }), taxonomy.description ? _jsx("p", { className: libraryStyles.customTaxonomyDescription, children: taxonomy.description }) : null] }) }), conflictIds.includes(taxonomy.id) ? (_jsx("p", { className: libraryStyles.analysisWarning, children: "Conflicts with an existing taxonomy id in this workspace." })) : null, _jsx("div", { className: libraryStyles.customTaxonomyBadges, children: taxonomyTraitBadges(taxonomy).map((badge) => (_jsx("span", { className: libraryStyles.customTaxonomyBadge, children: badge }, badge))) }), _jsx(PreviewListSection, { title: taxonomy.widgetType === 'level' ? 'Levels' : 'Options', items: taxonomy.options.map((option) => ({
+                                            key: `${taxonomy.id}:${option.value}`,
+                                            label: option.label,
+                                            icon: option.icon,
+                                            color: option.color,
+                                            meta: taxonomy.widgetType === 'level' ? `Level ${option.value}` : String(option.value)
+                                        })) })] }, taxonomy.id)))] })] })] }));
+}
+export function TaxonomyLibraryManager(props) {
+    const { mode = 'system', taxonomies, onUpdateCustomTaxonomies, onAnalyzeSystemTaxonomyPack, onApplySystemTaxonomyPack } = props;
+    if (mode === 'custom') {
+        return _jsx(CustomTaxonomyLibrarySurface, { taxonomies: taxonomies, onUpdateCustomTaxonomies: onUpdateCustomTaxonomies });
+    }
+    return (_jsx(SystemTaxonomyLibrarySurface, { onAnalyzeSystemTaxonomyPack: onAnalyzeSystemTaxonomyPack, onApplySystemTaxonomyPack: onApplySystemTaxonomyPack }));
+}

package/dist/components/features/settings/TaxonomyLibraryManager.test.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { TaxonomyLibraryManager } from './TaxonomyLibraryManager';
+describe('TaxonomyLibraryManager', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/custom-taxonomy-library')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        packs: [{
+                                id: 'client-delivery',
+                                label: 'Client Delivery',
+                                description: 'Delivery pack',
+                                domainTag: 'operations',
+                                taxonomies: [
+                                    {
+                                        id: 'approval-stage',
+                                        label: 'Approval Stage',
+                                        description: 'Track approvals',
+                                        widgetType: 'select',
+                                        isSystem: false,
+                                        multiSelect: false,
+                                        isRequired: true,
+                                        formEnabled: true,
+                                        filterEnabled: true,
+                                        sortEnabled: true,
+                                        options: [
+                                            { value: 'draft', label: 'Draft', icon: 'Pencil', color: 'slate-500' },
+                                            { value: 'approved', label: 'Approved', icon: 'CheckCircle', color: 'emerald-500' }
+                                        ]
+                                    },
+                                    {
+                                        id: 'effort-band',
+                                        label: 'Effort Band',
+                                        description: 'Numeric scale',
+                                        widgetType: 'level',
+                                        isSystem: false,
+                                        multiSelect: false,
+                                        isRequired: false,
+                                        formEnabled: false,
+                                        filterEnabled: true,
+                                        sortEnabled: true,
+                                        options: [
+                                            { value: 1, label: 'Light', icon: 'Wind', color: 'teal-500' },
+                                            { value: 2, label: 'Standard', icon: 'Minus', color: 'blue-500' }
+                                        ]
+                                    }
+                                ]
+                            }]
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({ packs: [] })
+            };
+        }));
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('renders custom taxonomy packs and preview metadata', async () => {
+        const user = userEvent.setup();
+        render(_jsx(TaxonomyLibraryManager, { mode: "custom" }));
+        await waitFor(() => {
+            expect(screen.getByText('Browse reusable custom taxonomy packs.')).toBeInTheDocument();
+        });
+        expect(screen.getAllByText('Client Delivery')).toHaveLength(2);
+        expect(screen.getAllByText('2 taxonomies').length).toBeGreaterThan(0);
+        await user.click(screen.getByRole('button', { name: /previewing/i }));
+        expect(screen.getAllByText('Approval Stage').length).toBeGreaterThan(0);
+        expect(screen.getByText('Track approvals')).toBeInTheDocument();
+        expect(screen.getAllByText('Required').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('Numeric').length).toBeGreaterThan(0);
+        expect(screen.getByText(/review each taxonomy before installing it into this workspace/i)).toBeInTheDocument();
+    });
+    it('installs selected non-conflicting custom taxonomies', async () => {
+        const user = userEvent.setup();
+        const onUpdateCustomTaxonomies = vi.fn();
+        render(_jsx(TaxonomyLibraryManager, { mode: "custom", taxonomies: [], onUpdateCustomTaxonomies: onUpdateCustomTaxonomies }));
+        await waitFor(() => {
+            expect(screen.getByText('Choose Taxonomies to Install')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: /install selected taxonomies/i }));
+        expect(onUpdateCustomTaxonomies).toHaveBeenCalledTimes(1);
+        const nextTaxonomies = onUpdateCustomTaxonomies.mock.calls[0]?.[0];
+        expect(nextTaxonomies).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'approval-stage', label: 'Approval Stage' }),
+            expect.objectContaining({ id: 'effort-band', label: 'Effort Band' })
+        ]));
+        expect(screen.getByText(/2 custom taxonomies were added to this workspace/i)).toBeInTheDocument();
+    });
+    it('blocks install when selected taxonomy ids already exist', async () => {
+        const user = userEvent.setup();
+        const onUpdateCustomTaxonomies = vi.fn();
+        render(_jsx(TaxonomyLibraryManager, { mode: "custom", taxonomies: [{
+                    id: 'approval-stage',
+                    label: 'Approval Stage',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'existing', label: 'Existing' }]
+                }], onUpdateCustomTaxonomies: onUpdateCustomTaxonomies }));
+        await waitFor(() => {
+            expect(screen.getByText(/conflicts with an existing taxonomy id/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: /install selected taxonomies/i }));
+        expect(onUpdateCustomTaxonomies).not.toHaveBeenCalled();
+        expect(screen.getByText(/deselect conflicting taxonomies before installing this pack/i)).toBeInTheDocument();
+    });
+    it('can narrow the selection to installable custom taxonomies only', async () => {
+        const user = userEvent.setup();
+        const onUpdateCustomTaxonomies = vi.fn();
+        render(_jsx(TaxonomyLibraryManager, { mode: "custom", taxonomies: [{
+                    id: 'approval-stage',
+                    label: 'Approval Stage',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'existing', label: 'Existing' }]
+                }], onUpdateCustomTaxonomies: onUpdateCustomTaxonomies }));
+        await waitFor(() => {
+            expect(screen.getByRole('button', { name: /select installable only/i })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: /select installable only/i }));
+        await user.click(screen.getByRole('button', { name: /install selected taxonomies/i }));
+        expect(onUpdateCustomTaxonomies).toHaveBeenCalledTimes(1);
+        const nextTaxonomies = onUpdateCustomTaxonomies.mock.calls[0]?.[0];
+        expect(nextTaxonomies).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'approval-stage', label: 'Approval Stage' }),
+            expect.objectContaining({ id: 'effort-band', label: 'Effort Band' })
+        ]));
+        expect(nextTaxonomies).not.toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'approval-stage', options: expect.arrayContaining([expect.objectContaining({ value: 'draft' })]) })
+        ]));
+        expect(screen.getByText(/1 custom taxonomy was added to this workspace/i)).toBeInTheDocument();
+    });
+});

package/dist/components/features/settings/TaxonomyManager.d.ts

@@ -1,7 +1,18 @@
 import type { TaxonomyDefinition, CategoryConfig } from '../../../types';
+import type { TaxonomyLibraryPack } from '../../../shared/taxonomyLibrary.js';
 interface TaxonomyManagerProps {
     taxonomies: TaxonomyDefinition[];
     onUpdateTaxonomies: (taxonomies: TaxonomyDefinition[]) => void;
+    taxonomyDisplayLabels?: {
+        category?: string;
+        type?: string;
+        priority?: string;
+    };
+    onUpdateTaxonomyDisplayLabels?: (labels: {
+        category?: string;
+        type?: string;
+        priority?: string;
+    }) => Promise<void> | void;
     categories: CategoryConfig[];
     pathValidation: Record<string, {
         exists: boolean;
@@ -19,9 +30,16 @@ interface TaxonomyManagerProps {
     types: {
         value: string;
         label: string;
+        color?: string;
+        icon?: string;
     }[];
     onSaveType: (label: string) => void;
     onRemoveType: (value: string) => void;
+    onUpdateType: (value: string, updates: {
+        label?: string;
+        color?: string;
+        icon?: string;
+    }) => void;
     priorities: Array<{
         value: number;
         label: string;
@@ -34,21 +52,26 @@ interface TaxonomyManagerProps {
         color?: string;
         icon?: string;
     }>) => void;
-    approaches: Array<{
-        value: string;
-        label: string;
-        color?: string;
-        icon?: string;
+    onAnalyzeSystemTaxonomyPack?: (pack: TaxonomyLibraryPack) => {
+        unmatchedCategoryValues: string[];
+        unmatchedTypeValues: string[];
+        incompatiblePriorityValues: number[];
+    };
+    onApplySystemTaxonomyPack?: (input: {
+        pack: TaxonomyLibraryPack;
+        sections: {
+            categories: boolean;
+            types: boolean;
+            priorities: boolean;
+        };
+        remapExistingValuesToDefault: boolean;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
     }>;
-    onUpdateApproaches: (approaches: Array<{
-        value: string;
-        label: string;
-        color?: string;
-        icon?: string;
-    }>) => void;
     manualComplexityEnabled: boolean;
     onManualComplexityEnabledChange: (enabled: boolean) => Promise<void> | void;
-    initialTab?: 'categories' | 'types' | 'priorities' | 'complexities' | 'approaches' | null;
+    initialTab?: 'categories' | 'types' | 'priorities' | 'complexities' | null;
 }
 export declare function TaxonomyManager(props: TaxonomyManagerProps): import("react/jsx-runtime").JSX.Element;
 export {};