+ statusOptions: LinearIssueFilterGroupedOption[]
+ labelOptions: LinearIssueFilterGroupedOption[]
onOpenSection: (section: LinearIssueFilterSectionKey) => void
}): React.JSX.Element {
- const selectedStatusCount = distinctFacetNames(value.stateIds, stateNamesById).length
- const selectedLabelCount = distinctFacetNames(value.labelIds, labelNamesById).length
const sections: { key: LinearIssueFilterSectionKey; label: string; summary: string }[] = [
{
key: 'status',
label: translate('auto.components.linear-issue-attribute-filter-sections.status', 'Status'),
- summary:
- selectedStatusCount > 0
- ? translate(
- 'auto.components.linear-issue-attribute-filter-sections.countSelected',
- '{{count}} selected',
- { count: selectedStatusCount }
- )
- : ''
+ summary: facetSummary(
+ statusOptions,
+ value.stateIds,
+ LINEAR_ISSUE_ATTRIBUTE_FILTER_MAX_STATE_IDS
+ )
},
{
key: 'priority',
@@ -176,14 +110,11 @@ export function LinearIssueFilterSectionMenu({
{
key: 'labels',
label: translate('auto.components.linear-issue-attribute-filter-sections.labels', 'Labels'),
- summary:
- selectedLabelCount > 0
- ? translate(
- 'auto.components.linear-issue-attribute-filter-sections.countSelected',
- '{{count}} selected',
- { count: selectedLabelCount }
- )
- : ''
+ summary: facetSummary(
+ labelOptions,
+ value.labelIds,
+ LINEAR_ISSUE_ATTRIBUTE_FILTER_MAX_LABEL_IDS
+ )
}
]
@@ -300,42 +231,43 @@ export function LinearIssueFilterSectionDetail({
)
}
- if (section === 'status') {
+ // Status and labels are the same grouped, cap-bounded picker over a different facet.
+ if (section === 'status' || section === 'labels') {
+ const isStatus = section === 'status'
+ const options = isStatus ? statusOptions : labelOptions
+ const selectedIds = isStatus ? value.stateIds : value.labelIds
return (
- onChange({ ...value, stateIds: expandLinearMetadataGroupKeys(statusOptions, keys) })
+ options={options}
+ selected={selectedLinearMetadataGroupKeys(options, selectedIds)}
+ loading={isStatus ? statusLoading : labelLoading}
+ error={isStatus ? statusError : labelError}
+ searchPlaceholder={
+ isStatus
+ ? translate(
+ 'auto.components.linear-issue-attribute-filter-sections.searchStatus',
+ 'Filter status…'
+ )
+ : translate(
+ 'auto.components.linear-issue-attribute-filter-sections.searchLabels',
+ 'Filter labels…'
+ )
}
+ onChange={(keys) => {
+ const ids = expandLinearMetadataGroupKeys(options, keys)
+ onChange(isStatus ? { ...value, stateIds: ids } : { ...value, labelIds: ids })
+ }}
/>
-
- )
- }
-
- if (section === 'labels') {
- return (
-
-
-
- onChange({ ...value, labelIds: expandLinearMetadataGroupKeys(labelOptions, keys) })
+
diff --git a/src/renderer/src/components/linear-issue-attribute-filter-team-ids.test.ts b/src/renderer/src/components/linear-issue-attribute-filter-team-ids.test.ts
index f8fcbbf9623..d94216eb0b7 100644
--- a/src/renderer/src/components/linear-issue-attribute-filter-team-ids.test.ts
+++ b/src/renderer/src/components/linear-issue-attribute-filter-team-ids.test.ts
@@ -1,8 +1,11 @@
import { describe, expect, it } from 'vitest'
import type { LinearTeam } from '../../../shared/linear/workspace-types'
import {
+ capLinearMetadataIdsAcrossGroups,
expandLinearMetadataGroupKeys,
groupLinearMetadataByName,
+ isLinearMetadataGroupSelectionPartial,
+ linearMetadataGroupCoverage,
resolveLinearIssueAttributeFilterTeamIds,
selectedLinearMetadataGroupKeys,
unionLinearMetadataById
@@ -131,3 +134,99 @@ describe('groupLinearMetadataByName', () => {
expect(expandLinearMetadataGroupKeys(groups, ['other-team-todo'])).toEqual(['other-team-todo'])
})
})
+
+describe('capLinearMetadataIdsAcrossGroups', () => {
+ const groups = [
+ { key: 'alpha', ids: ['a-1', 'a-2', 'a-3'] },
+ { key: 'zeta', ids: ['z-1'] }
+ ]
+
+ it('leaves a selection already within the cap untouched', () => {
+ expect(capLinearMetadataIdsAcrossGroups(groups, ['a-1', 'a-2'], 3)).toEqual(['a-1', 'a-2'])
+ })
+
+ // Why: a plain slice of the sorted id list drops the whole trailing group, which then
+ // renders unchecked and disappears from the coverage count (#16879).
+ it('keeps an id from every picked group instead of slicing the last one away', () => {
+ expect(capLinearMetadataIdsAcrossGroups(groups, ['a-1', 'a-2', 'a-3', 'z-1'], 3)).toEqual([
+ 'a-1',
+ 'z-1',
+ 'a-2'
+ ])
+ })
+
+ it('treats an id no group covers as its own group', () => {
+ expect(capLinearMetadataIdsAcrossGroups(groups, ['a-1', 'a-2', 'a-3', 'other'], 2)).toEqual([
+ 'a-1',
+ 'other'
+ ])
+ })
+})
+
+describe('capLinearMetadataIdsAcrossGroups over-subscribed rows', () => {
+ const singleIdGroups = (count: number): { key: string; ids: string[] }[] =>
+ Array.from({ length: count }, (_unused, index) => ({
+ key: `s${index}`,
+ ids: [`s${index}`]
+ }))
+
+ it('leaves a selection sitting exactly on the cap untouched', () => {
+ const groups = singleIdGroups(4)
+ const ids = groups.flatMap((group) => group.ids)
+ expect(capLinearMetadataIdsAcrossGroups(groups, ids, 4)).toEqual(ids)
+ // Why: on the cap, full coverage is indistinguishable from a starved row, so coverage
+ // warns rather than claim what it cannot prove — below the cap it stays quiet (#17342).
+ expect(isLinearMetadataGroupSelectionPartial(groups, ids, 4)).toBe(true)
+ expect(isLinearMetadataGroupSelectionPartial(groups, ids, 5)).toBe(false)
+ })
+
+ it('keeps one id per row when the selection is one id over the cap', () => {
+ const groups = [
+ { key: 'alpha', ids: ['a-1', 'a-2'] },
+ { key: 'beta', ids: ['b-1'] },
+ { key: 'gamma', ids: ['c-1'] }
+ ]
+ const capped = capLinearMetadataIdsAcrossGroups(groups, ['a-1', 'a-2', 'b-1', 'c-1'], 3)
+ expect(new Set(capped)).toEqual(new Set(['a-1', 'b-1', 'c-1']))
+ })
+
+ // Why: MultiSelectList.toggle appends the clicked key last, so the starved row was always
+ // the row the user just clicked — and coverage still reported a full 100 of 100.
+ it('never claims full coverage when more rows are picked than the cap can hold', () => {
+ const groups = singleIdGroups(101)
+ const ids = groups.flatMap((group) => group.ids)
+ const capped = capLinearMetadataIdsAcrossGroups(groups, ids, 100)
+ expect(capped).toHaveLength(100)
+ expect(linearMetadataGroupCoverage(groups, capped, 100).atLimit).toBe(true)
+ expect(isLinearMetadataGroupSelectionPartial(groups, capped, 100)).toBe(true)
+ })
+
+ it('never starves a single-id row to widen a row that has many ids', () => {
+ const groups = [
+ { key: 'wide', ids: Array.from({ length: 10 }, (_unused, index) => `w-${index}`) },
+ { key: 'x', ids: ['x-1'] },
+ { key: 'y', ids: ['y-1'] },
+ { key: 'z', ids: ['z-1'] }
+ ]
+ const ids = groups.flatMap((group) => group.ids)
+ const capped = capLinearMetadataIdsAcrossGroups(groups, ids, 5)
+ expect(capped).toHaveLength(5)
+ expect(capped).toContain('x-1')
+ expect(capped).toContain('y-1')
+ expect(capped).toContain('z-1')
+ })
+
+ // Why: the picker hands us click order, so the cap has to sort by metadata order instead.
+ it('caps the same visible selection to the same ids whatever the click order', () => {
+ const groups = [
+ { key: 'alpha', ids: ['a-1', 'a-2', 'a-3'] },
+ { key: 'beta', ids: ['b-1', 'b-2'] },
+ { key: 'gamma', ids: ['c-1'] }
+ ]
+ const alphaFirst = ['a-1', 'a-2', 'a-3', 'b-1', 'b-2', 'c-1']
+ const gammaFirst = ['c-1', 'b-1', 'b-2', 'a-1', 'a-2', 'a-3']
+ expect(capLinearMetadataIdsAcrossGroups(groups, gammaFirst, 4)).toEqual(
+ capLinearMetadataIdsAcrossGroups(groups, alphaFirst, 4)
+ )
+ })
+})
diff --git a/src/renderer/src/components/linear-issue-attribute-filter-team-ids.ts b/src/renderer/src/components/linear-issue-attribute-filter-team-ids.ts
index 08fb9309b45..df8cb3ce016 100644
--- a/src/renderer/src/components/linear-issue-attribute-filter-team-ids.ts
+++ b/src/renderer/src/components/linear-issue-attribute-filter-team-ids.ts
@@ -81,13 +81,97 @@ export function selectedLinearMetadataGroupKeys(
groups: readonly { key: string; ids: readonly string[] }[],
selectedIds: readonly string[]
): string[] {
+ const keyById = linearMetadataKeyById(groups)
+ return [...new Set(selectedIds.map((id) => keyById.get(id) ?? id))]
+}
+
+function linearMetadataKeyById(
+ groups: readonly { key: string; ids: readonly string[] }[]
+): Map {
const keyById = new Map()
for (const group of groups) {
for (const id of group.ids) {
keyById.set(id, group.key)
}
}
- return [...new Set(selectedIds.map((id) => keyById.get(id) ?? id))]
+ return keyById
+}
+
+/** Ids the picked rows stand for, against the ids the transport cap actually kept (#16879). */
+export function linearMetadataGroupCoverage(
+ groups: readonly { key: string; ids: readonly string[] }[],
+ selectedIds: readonly string[],
+ max: number
+): { applied: number; intended: number; atLimit: boolean } {
+ const keys = selectedLinearMetadataGroupKeys(groups, selectedIds)
+ return {
+ applied: selectedIds.length,
+ intended: expandLinearMetadataGroupKeys(groups, keys).length,
+ // Why: a row the cap could not fit leaves no trace in the ids, so once the budget is
+ // spent the honest claim is the exhausted budget itself — never full coverage (#17342).
+ atLimit: selectedIds.length >= max
+ }
+}
+
+/** True when the filter cannot be shown to cover every team id the picked rows stand for. */
+export function isLinearMetadataGroupSelectionPartial(
+ groups: readonly { key: string; ids: readonly string[] }[],
+ selectedIds: readonly string[],
+ max: number
+): boolean {
+ const { applied, intended, atLimit } = linearMetadataGroupCoverage(groups, selectedIds, max)
+ return intended > applied || atLimit
+}
+
+/**
+ * Trim an expanded selection to `max` ids by taking turns across the picked groups.
+ * A plain slice of the canonical (sorted) id list can drop every id of one picked row,
+ * which then renders unchecked with no explanation and vanishes from the coverage count.
+ * More picked rows than `max` cannot all be represented; `linearMetadataGroupCoverage`
+ * reports that shortfall so the starved row is never passed off as full coverage.
+ */
+export function capLinearMetadataIdsAcrossGroups(
+ groups: readonly { key: string; ids: readonly string[] }[],
+ ids: readonly string[],
+ max: number
+): string[] {
+ if (ids.length <= max) {
+ return [...ids]
+ }
+ const selected = new Set(ids)
+ // Why: the picker hands us click order, so bucket by metadata order instead — the same
+ // visible selection must always cap to the same ids (#17342).
+ const lists = groups
+ .map((group) => group.ids.filter((id) => selected.has(id)))
+ .filter((list) => list.length > 0)
+ const grouped = new Set(lists.flat())
+ // An id no loaded group covers is its own row; sorted so its slot is stable too (R12).
+ lists.push(
+ ...[...new Set(ids)]
+ .filter((id) => !grouped.has(id))
+ .sort()
+ .map((id) => [id])
+ )
+ const capped: string[] = []
+ // Round 0 gives every row one id before any row gets a second.
+ for (let round = 0; capped.length < max; round += 1) {
+ let advanced = false
+ for (const list of lists) {
+ const id = list[round]
+ if (id === undefined) {
+ continue
+ }
+ advanced = true
+ capped.push(id)
+ if (capped.length >= max) {
+ break
+ }
+ }
+ if (!advanced) {
+ break
+ }
+ }
+ return capped
}
/** Every id behind the picked group keys; an unknown key is itself an id. */
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 0519b661cce..31b048c7d1c 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -16185,7 +16185,15 @@
"allWorkspacesTitle": "Select one workspace",
"allWorkspacesBody": "Status, assignee, and label filters use ids from a single Linear workspace. Choose one workspace to filter by those attributes.",
"optionsFromTeam": "Options from {{team}}",
- "clearAll": "Clear all filters"
+ "clearAll": "Clear all filters",
+ "partialCoverage": "partial",
+ "partialCoverageTitle": "Some teams may be left out of this filter. Open Filters for details."
+ },
+ "linear-issue-attribute-filter-coverage-notice": {
+ "statusPartialTeamCoverage": "Filtering {{value0}} of {{value1}} team statuses — issues from the remaining teams are not included.",
+ "labelsPartialTeamCoverage": "Filtering {{value0}} of {{value1}} team labels — issues from the remaining teams are not included.",
+ "statusAtIdLimit": "Filtering the most this can carry: {{value0}} team statuses. Rows picked past that are left out.",
+ "labelsAtIdLimit": "Filtering the most this can carry: {{value0}} team labels. Rows picked past that are left out."
},
"linear-issue-attribute-filter-sections": {
"status": "Status",
@@ -16194,6 +16202,7 @@
"unassigned": "Unassigned",
"labels": "Labels",
"countSelected": "{{count}} selected",
+ "partialCoverageSuffix": "{{value0}} · partial",
"selected": "selected",
"searchPriority": "Filter priority…",
"searchStatus": "Filter status…",