pict-section-recordset 1.9.6 → 1.11.0

package/source/views/RecordSet-Filters.js

@@ -88,6 +88,12 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 .prsp-quickfilter-dash { color: var(--theme-color-text-muted, #6b7686); }
 /* Entity quick control: the pict-section-picker mounts into this host (its own .pps chrome themes it). */
 .prsp-quickfilter-entityhost { display: inline-block; width: 14rem; max-width: 100%; vertical-align: middle; }
+/* Show-deleted switch (RecordSetListShowDeletedFilter): a labeled checkbox in the drawer actions row.
+   Painted post-render into the host label; :empty hides it for record sets that haven't opted in. */
+.prsp-filters-showdeleted { display: inline-flex; align-items: center; gap: 0.4rem; cursor: pointer; user-select: none;
+	font-size: 0.88rem; color: var(--theme-color-text-secondary, #45505f); margin-right: 0.35rem; }
+.prsp-filters-showdeleted:empty { display: none; }
+.prsp-filters-showdeleted-checkbox { width: 1.05rem; height: 1.05rem; cursor: pointer; accent-color: var(--theme-color-brand-primary, #156dd1); }
 
 /* Module-owned "Add filter" popover (replaces the old native <select> pickers). */
 /* Fixed (viewport-anchored) + JS-positioned on open, so no ancestor overflow:hidden — the filter card,
@@ -196,6 +202,7 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 			Template: /*html*/`
 	<!-- DefaultPackage pict view template: [PRSP-SUBSET-Filters-Template-DrawerActions-Fieldset] -->
 	<div class="prsp-filters-actions">
+		<label class="prsp-filters-showdeleted" id="PRSP_ShowDeleted_Host" title="Include soft-deleted records in the results"></label>
 		<button type="button" class="prsp-filters-btn-text" id="PRSP_Filter_Button_Clear" title="Clear all filters to a blank state" onclick="_Pict.views['PRSP-Filters'].handleClear(event, '{~D:Record.RecordSet~}', '{~D:Record.ViewContext~}')">Clear</button>
 		<button type="button" class="prsp-filters-btn-text" id="PRSP_Filter_Button_Reset" title="Reset all filters to the last saved/defaulted state" onclick="_Pict.views['PRSP-Filters'].handleReset(event, '{~D:Record.RecordSet~}', '{~D:Record.ViewContext~}')">Reset</button>
 		<button type="button" class="prsp-filters-apply" id="PRSP_Filter_Button_ApplyDrawer" onclick="_Pict.views['PRSP-Filters'].handleSearch(event, '{~D:Record.RecordSet~}', '{~D:Record.ViewContext~}')">Apply</button>
@@ -286,6 +293,7 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 			{~TS:PRSP-QuickFilter-Text:Record.TextSlot~}
 			{~TS:PRSP-QuickFilter-Date:Record.DateSlot~}
 			{~TS:PRSP-QuickFilter-Entity:Record.EntitySlot~}
+			{~TS:PRSP-QuickFilter-Distinct:Record.DistinctSlot~}
 		</div>
 `
 		},
@@ -318,6 +326,14 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 			Hash: 'PRSP-QuickFilter-Entity',
 			Template: /*html*/`
 		<span class="prsp-quickfilter-entityhost" id="{~D:Record.HostID~}"></span>
+`
+		},
+		{
+			// Distinct-values control — a multi-select pict-section-picker mounts into this host
+			// (post-render, in _mountQuickFilterDistinct), its options the column's distinct values.
+			Hash: 'PRSP-QuickFilter-Distinct',
+			Template: /*html*/`
+		<span class="prsp-quickfilter-entityhost" id="{~D:Record.HostID~}"></span>
 `
 		},
 	],
@@ -630,10 +646,11 @@ class ViewRecordSetSUBSETFilters extends libPictView
 		// `quickFiltersAutoDefault` (host-settable, default on) gates the clever schema defaults: a host
 		// can set it false to make quick filters opt-in (only record sets with an explicit config show).
 		const tmpEntityMounts = [];
+		const tmpDistinctMounts = [];
 		const tmpItems = tmpProvider.getQuickFilterDefinitions(this.quickFiltersAutoDefault).map((pDefinition) =>
 		{
 			const tmpBase = { Field: pDefinition.Field, ClauseKey: pDefinition.ClauseKey, Label: pDefinition.Label, RecordSet: pRecordSet, ViewContext: pViewContext };
-			const tmpItem = { Label: pDefinition.Label, TextSlot: [], DateSlot: [], EntitySlot: [] };
+			const tmpItem = { Label: pDefinition.Label, TextSlot: [], DateSlot: [], EntitySlot: [], DistinctSlot: [] };
 			if (pDefinition.Control === 'text')
 			{
 				tmpItem.TextSlot = [ Object.assign({}, tmpBase, { Value: tmpProvider.getQuickFilterClauseValue(pDefinition.Field), Placeholder: `Search ${pDefinition.Label}…` }) ];
@@ -649,12 +666,19 @@ class ViewRecordSetSUBSETFilters extends libPictView
 				tmpItem.EntitySlot = [ Object.assign({}, tmpBase, { HostID: tmpHostID }) ];
 				tmpEntityMounts.push(Object.assign({}, tmpBase, { HostID: tmpHostID }));
 			}
+			else if (pDefinition.Control === 'distinct')
+			{
+				const tmpHostID = `PRSP_QuickDistinct_${pRecordSet}_${pDefinition.Field}`;
+				tmpItem.DistinctSlot = [ Object.assign({}, tmpBase, { HostID: tmpHostID }) ];
+				tmpDistinctMounts.push(Object.assign({}, tmpBase, { HostID: tmpHostID }));
+			}
 			return tmpItem;
 		});
 		const tmpHTML = (tmpItems.length > 0) ? this.pict.parseTemplateByHash('PRSP-QuickFilters-Bar', { Filters: tmpItems }) : '';
 		this.pict.ContentAssignment.assignContent('#PRSP_QuickFilters', tmpHTML);
-		// Entity controls: mount (or re-mount) a picker into each host after the wholesale re-render.
+		// Entity / distinct controls: mount (or re-mount) a picker into each host after the wholesale re-render.
 		tmpEntityMounts.forEach((pMount) => this._mountQuickFilterEntity(pRecordSet, pViewContext, pMount));
+		tmpDistinctMounts.forEach((pMount) => this._mountQuickFilterDistinct(pRecordSet, pViewContext, pMount));
 	}
 
 	/**
@@ -713,12 +737,107 @@ class ViewRecordSetSUBSETFilters extends libPictView
 		tmpView.setValue((Array.isArray(tmpCurrent) && tmpCurrent.length > 0) ? tmpCurrent[0] : '');
 	}
 
+	/**
+	 * Mount (idempotently) a multi-select pict-section-picker into a quick-filter distinct host,
+	 * its options the clause's static `Options` or the column's distinct values (fetched + cached
+	 * on the recordset provider; re-mounted once the fetch resolves so the options fill in). The
+	 * picker substring-filters static options client-side, so search works without a server trip.
+	 * On change it STAGES the clause (Values array) — Apply / Search commits. No-op if the picker
+	 * module isn't registered.
+	 *
+	 * @param {string} pRecordSet @param {string} pViewContext @param {Record<string, any>} pMount
+	 */
+	_mountQuickFilterDistinct(pRecordSet, pViewContext, pMount)
+	{
+		if (!document.getElementById(pMount.HostID)) { return; }
+		const tmpPickerProvider = this.pict.providers['Pict-Section-Picker'];
+		const tmpProvider = this.pict.providers['RSP-Provider-' + pRecordSet];
+		if (!tmpPickerProvider || typeof tmpPickerProvider.createPicker !== 'function' || !tmpProvider) { return; }
+		const tmpDescriptor = tmpProvider.getFilterClauseSchemaForKey(pMount.Field)?.AvailableClauses?.find?.((pClause) => pClause.ClauseKey === pMount.ClauseKey);
+		if (!tmpDescriptor || !tmpDescriptor.FilterByColumn) { return; }
+		let tmpValues;
+		if (Array.isArray(tmpDescriptor.Options) && tmpDescriptor.Options.length > 0)
+		{
+			tmpValues = tmpDescriptor.Options;
+		}
+		else
+		{
+			const tmpCacheKey = tmpDescriptor.DistinctFilter ? `${tmpDescriptor.FilterByColumn}::${tmpDescriptor.DistinctFilter}` : tmpDescriptor.FilterByColumn;
+			tmpValues = (tmpProvider._scopeDistinctCache || {})[tmpCacheKey];
+			if (!Array.isArray(tmpValues) && typeof tmpProvider.getRecordSetColumnDistinct === 'function')
+			{
+				tmpProvider.getRecordSetColumnDistinct(tmpDescriptor.FilterByColumn, { Filter: tmpDescriptor.DistinctFilter },
+					() => this._mountQuickFilterDistinct(pRecordSet, pViewContext, pMount));
+				tmpValues = [];
+			}
+		}
+		const tmpOptions = (Array.isArray(tmpValues) ? tmpValues : []).map((pValue) => ({ Value: pValue, Text: String(pValue) }));
+		const tmpView = tmpPickerProvider.createPicker(`Quick-Distinct-${pRecordSet}-${pMount.Field}`,
+		{
+			DestinationAddress: `#${pMount.HostID}`,
+			// Multi-select: "any of the checked values" is the natural distinct-filter semantic.
+			Mode: 'multi',
+			Options: tmpOptions,
+			Placeholder: `Select ${pMount.Label}…`,
+			OnChange: (pValuesArray) => this.applyQuickFilterDistinct(pRecordSet, pViewContext, pMount.Field, pMount.ClauseKey, pValuesArray),
+		});
+		if (!tmpView) { return; }
+		tmpView.render();
+		const tmpCurrent = (typeof tmpProvider.getQuickFilterEntityValue === 'function') ? tmpProvider.getQuickFilterEntityValue(pMount.Field) : [];
+		tmpView.setValue(Array.isArray(tmpCurrent) ? tmpCurrent : []);
+	}
+
 	/**
 	 * Apply a text quick filter: upsert (or clear) its tagged clause, then run the standard search +
 	 * serialize path. Commits on blur / Enter (not per-keystroke) so the re-render never steals focus.
 	 *
 	 * @param {string} pRecordSet @param {string} pViewContext @param {string} pField @param {string} pClauseKey @param {string} pValue
 	 */
+	/**
+	 * Flip the show-deleted switch (the drawer-footer checkbox, RecordSetListShowDeletedFilter
+	 * recordsets). The switch is a REAL clause — a RawFilter referencing the Deleted column, which
+	 * suppresses the automatic `Deleted = 0` so soft-deleted rows enumerate — upserted into the
+	 * active filter state and applied through the normal search flow. Because the clause changes
+	 * the serialized filter experience, the route URL always changes: the fetch reliably fires,
+	 * and the state survives reloads and shared links. Clear/Reset drop it like any clause.
+	 *
+	 * @param {string} pRecordSet - The record set the toggle belongs to
+	 * @param {string} pViewContext - The view context (List, Dashboard)
+	 * @param {boolean} pChecked - Whether deleted records should be included
+	 */
+	toggleShowDeletedFilter(pRecordSet, pViewContext, pChecked)
+	{
+		const tmpProvider = this.pict.providers['RSP-Provider-' + pRecordSet];
+		if (!tmpProvider || typeof tmpProvider.setShowDeletedFilterValue !== 'function')
+		{
+			return;
+		}
+		tmpProvider.setShowDeletedFilterValue(pChecked === true);
+		this.handleSearch(null, pRecordSet, pViewContext);
+	}
+
+	/**
+	 * Paint the show-deleted checkbox into its drawer-footer host (next to Clear/Reset/Apply),
+	 * seeded from the clause's presence. Painted post-render like the quick bar; empty when the
+	 * record set hasn't opted in via RecordSetListShowDeletedFilter.
+	 *
+	 * @param {string} pRecordSet @param {string} pViewContext
+	 */
+	_renderShowDeletedControl(pRecordSet, pViewContext)
+	{
+		if (!document.getElementById('PRSP_ShowDeleted_Host')) { return; }
+		const tmpRecordSetConfiguration = this.pict.PictSectionRecordSet?.recordSetProviderConfigurations?.[pRecordSet] || {};
+		if (tmpRecordSetConfiguration.RecordSetListShowDeletedFilter !== true)
+		{
+			this.pict.ContentAssignment.assignContent('#PRSP_ShowDeleted_Host', '');
+			return;
+		}
+		const tmpProvider = this.pict.providers['RSP-Provider-' + pRecordSet];
+		const tmpChecked = (tmpProvider && typeof tmpProvider.getShowDeletedFilterValue === 'function' && tmpProvider.getShowDeletedFilterValue()) ? 'checked' : '';
+		this.pict.ContentAssignment.assignContent('#PRSP_ShowDeleted_Host',
+			`<input class="prsp-filters-showdeleted-checkbox" type="checkbox" ${tmpChecked} onchange="_Pict.views['PRSP-Filters'].toggleShowDeletedFilter('${pRecordSet}', '${pViewContext}', this.checked)"> Show deleted`);
+	}
+
 	applyQuickFilterText(pRecordSet, pViewContext, pField, pClauseKey, pValue)
 	{
 		this.bumpRenderEpoch();
@@ -768,6 +887,23 @@ class ViewRecordSetSUBSETFilters extends libPictView
 		}
 	}
 
+	/**
+	 * Stage a field's distinct quick-filter selection (the Values array of its
+	 * DistinctSelectedValueList clause). Doesn't fire the search — commit happens
+	 * on Apply / Search.
+	 *
+	 * @param {string} pRecordSet @param {string} pViewContext @param {string} pField @param {string} pClauseKey @param {Array<any>} pValues
+	 */
+	applyQuickFilterDistinct(pRecordSet, pViewContext, pField, pClauseKey, pValues)
+	{
+		this.bumpRenderEpoch();
+		const tmpProvider = this.pict.providers['RSP-Provider-' + pRecordSet];
+		if (tmpProvider && typeof tmpProvider.upsertQuickFilterEntity === 'function')
+		{
+			tmpProvider.upsertQuickFilterEntity(pField, pClauseKey, pValues);
+		}
+	}
+
 	/**
 	 * @param {Event} pEvent - The DOM event that triggered the search
 	 * @param {string} pRecordSet - The record set being filtered
@@ -1162,7 +1298,8 @@ class ViewRecordSetSUBSETFilters extends libPictView
 			if (tmpFilterRecordSet)
 			{
 				this._paintFilterControls(tmpFilterRecordSet);
-					this._renderQuickFilters(tmpFilterRecordSet, tmpFilterViewContext);
+				this._renderQuickFilters(tmpFilterRecordSet, tmpFilterViewContext);
+				this._renderShowDeletedControl(tmpFilterRecordSet, tmpFilterViewContext);
 				// (Re)render the experiences dropdown only when its container is empty — i.e. on
 				// a fresh filter render — not on every sub-render (add-filter dropdown, etc.).
 				const tmpExpContainer = document.getElementById('FilterPersistenceView-Container');

package/source/views/filters/RecordSet-Filter-DistinctSelectedValueList.js

@@ -0,0 +1,233 @@
+const ViewRecordSetSUBSETFilterBase = require('./RecordSet-Filter-Base');
+
+/**
+ * DistinctSelectedValueList — a dropdown/checkbox filter whose options ARE the distinct
+ * values of a column on the CORE entity (no join), fetched from Meadow's
+ * `<Entity>s/Distinct/<Column>` endpoint through the recordset provider's cached
+ * `getRecordSetColumnDistinct()`. The clause's `Values` array holds the selection; pict's
+ * Filter.js compiles it to an OR-chain of `FBVOR~<col>~EQ~<value>` stanzas inside one
+ * paren group.
+ *
+ * Clause config:
+ *   - FilterByColumn {string} - the core-entity column the options come from / filter on.
+ *   - Options {Array<any>} - optional STATIC option list; when present the distinct fetch is skipped.
+ *   - DistinctFilter {string} - optional FoxHound stanza appended as `/FilteredTo/<...>` on the
+ *     distinct query (e.g. `FBV~Deleted~EQ~0` to keep soft-deleted rows' values out of the list).
+ *
+ * Selected values missing from the option list (e.g. restored from a saved filter experience
+ * whose value no longer appears in the data) are unioned in so they stay visible and
+ * un-checkable. Selection toggles by option INDEX, never by value — values can contain
+ * quotes that would break inline onclick attributes.
+ *
+ * Staging only: toggling checkboxes mutates the live clause but does NOT fire a search —
+ * the user commits with Apply / Search (the stage-then-Apply contract).
+ */
+const _DEFAULT_CONFIGURATION_Filter_DistinctSelectedValueList =
+{
+	ViewIdentifier: 'PRSP-FilterType-DistinctSelectedValueList',
+
+	CSS: /*css*/`
+.prsp-filter-distinct { min-width: 12rem; }
+.prsp-filter-distinct-options { display: flex; flex-direction: column; gap: 0.15rem; max-height: 11rem; overflow-y: auto;
+	padding: 0.35rem 0.5rem; border-radius: 8px; border: 1px solid var(--theme-color-border-default, #d7dce3);
+	background: var(--theme-color-background-primary, #fff); }
+.prsp-filter-distinct-option { display: flex; align-items: center; gap: 0.45rem; cursor: pointer;
+	font-size: 0.92rem; color: var(--theme-color-text-primary, #1f2733); margin: 0; }
+.prsp-filter-distinct-option input[type="checkbox"] { width: auto; margin: 0; cursor: pointer; }
+.prsp-filter-distinct-note { font-size: 0.82rem; color: var(--theme-color-text-muted, #6b7686); padding: 0.15rem 0; }
+`,
+
+	Templates:
+	[
+		{
+			Hash: 'PRSP-Filter-DistinctSelectedValueList-Template',
+			Template: /*html*/`
+	<!-- DefaultPackage pict view template: [PRSP-Filter-DistinctSelectedValueList-Template] -->
+	<div class="prsp-filter-distinct">
+		<label>{~D:Record.Label~}</label>
+		<div class="prsp-filter-distinct-options">
+			{~TS:PRSP-Filter-Distinct-Loading:Record.DistinctLoading~}
+			{~TS:PRSP-Filter-Distinct-Empty:Record.DistinctEmpty~}
+			{~TSWP:PRSP-Filter-Distinct-Option:Record.DistinctOptions:Record~}
+		</div>
+	</div>
+	<!-- DefaultPackage end view template: [PRSP-Filter-DistinctSelectedValueList-Template] -->
+`
+		},
+		{
+			Hash: 'PRSP-Filter-Distinct-Option',
+			Template: /*html*/`
+	<label class="prsp-filter-distinct-option">
+		<input type="checkbox" {~D:Record.Data.CheckedAttribute~}
+			onchange="_Pict.views['PRSP-FilterType-DistinctSelectedValueList'].toggleOption(event, '{~D:Record.Payload.ClauseAddress~}', '{~D:Record.Payload.Hash~}', {~D:Record.Data.OptionIndex~})">
+		<span>{~D:Record.Data.Text~}</span>
+	</label>
+`
+		},
+		{
+			Hash: 'PRSP-Filter-Distinct-Loading',
+			Template: /*html*/`
+	<span class="prsp-filter-distinct-note">Loading values…</span>
+`
+		},
+		{
+			Hash: 'PRSP-Filter-Distinct-Empty',
+			Template: /*html*/`
+	<span class="prsp-filter-distinct-note">No values available.</span>
+`
+		},
+	],
+};
+
+class ViewRecordSetSUBSETFilterDistinctSelectedValueList extends ViewRecordSetSUBSETFilterBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+	}
+
+	getFilterFormTemplate()
+	{
+		return 'PRSP-Filter-DistinctSelectedValueList-Template';
+	}
+
+	/**
+	 * The ordered raw option values for a clause: the static `Options` list when configured,
+	 * else the provider's cached distinct values, with any selected values missing from the
+	 * list unioned onto the end.
+	 *
+	 * @param {Record<string, any>} pClause
+	 * @param {Record<string, any>} pProvider - The recordset provider (`RSP-Provider-<RecordSet>`).
+	 * @return {Array<any>}
+	 */
+	_optionValues(pClause, pProvider)
+	{
+		let tmpValues = Array.isArray(pClause.Options) ? pClause.Options.slice() : null;
+		if (!tmpValues)
+		{
+			const tmpCacheKey = pClause.DistinctFilter ? `${pClause.FilterByColumn}::${pClause.DistinctFilter}` : pClause.FilterByColumn;
+			const tmpCached = (pProvider && pProvider._scopeDistinctCache) ? pProvider._scopeDistinctCache[tmpCacheKey] : null;
+			tmpValues = Array.isArray(tmpCached) ? tmpCached.slice() : [];
+		}
+		if (Array.isArray(pClause.Values))
+		{
+			for (const tmpSelected of pClause.Values)
+			{
+				if (!tmpValues.some((pValue) => pValue === tmpSelected))
+				{
+					tmpValues.push(tmpSelected);
+				}
+			}
+		}
+		return tmpValues;
+	}
+
+	/**
+	 * Map the option values to render rows ({ Text, OptionIndex, CheckedAttribute }).
+	 *
+	 * @param {Record<string, any>} pClause
+	 * @param {Record<string, any>} pProvider
+	 * @return {Array<{ Text: string, OptionIndex: number, CheckedAttribute: string }>}
+	 */
+	_composeOptionList(pClause, pProvider)
+	{
+		const tmpSelected = Array.isArray(pClause.Values) ? pClause.Values : [];
+		return this._optionValues(pClause, pProvider).map((pValue, pIndex) => (
+		{
+			Text: String(pValue),
+			OptionIndex: pIndex,
+			CheckedAttribute: tmpSelected.some((pSelectedValue) => pSelectedValue === pValue) ? 'checked' : '',
+		}));
+	}
+
+	/**
+	 * @param {Record<string, any>} pRecord
+	 */
+	prepareRecord(pRecord)
+	{
+		super.prepareRecord(pRecord);
+
+		const tmpProvider = this.pict.providers['RSP-Provider-' + pRecord.RecordSet];
+		pRecord.DistinctLoading = [];
+		// No static Options: make sure the distinct values are fetched (cached on the provider),
+		// re-rendering just this clause's container once they resolve. Errored fetches cache []
+		// so this can't loop.
+		if (!Array.isArray(pRecord.Options) && pRecord.FilterByColumn
+			&& tmpProvider && typeof tmpProvider.getRecordSetColumnDistinct === 'function')
+		{
+			const tmpCacheKey = pRecord.DistinctFilter ? `${pRecord.FilterByColumn}::${pRecord.DistinctFilter}` : pRecord.FilterByColumn;
+			if (!tmpProvider._scopeDistinctCache || !Array.isArray(tmpProvider._scopeDistinctCache[tmpCacheKey]))
+			{
+				pRecord.DistinctLoading = [ {} ];
+				const tmpClauseAddress = pRecord.ClauseAddress;
+				const tmpClauseHash = pRecord.Hash;
+				tmpProvider.getRecordSetColumnDistinct(pRecord.FilterByColumn, { Filter: pRecord.DistinctFilter },
+					() => this._reRenderClause(tmpClauseAddress, tmpClauseHash));
+			}
+		}
+		pRecord.DistinctOptions = this._composeOptionList(pRecord, tmpProvider);
+		pRecord.DistinctEmpty = (pRecord.DistinctLoading.length === 0 && pRecord.DistinctOptions.length === 0) ? [ {} ] : [];
+	}
+
+	/**
+	 * Toggle an option's membership in the live clause's `Values` by option index. Staging
+	 * only — the search fires on Apply / Search, not here.
+	 *
+	 * @param {Event} pEvent
+	 * @param {string} pClauseInformaryAddress
+	 * @param {string} pClauseHash
+	 * @param {number} pOptionIndex
+	 */
+	toggleOption(pEvent, pClauseInformaryAddress, pClauseHash, pOptionIndex)
+	{
+		const tmpClause = this.getInformaryScopedValue(pClauseInformaryAddress);
+		if (!tmpClause)
+		{
+			this.pict.log.error(`[Filter-DistinctSelectedValueList] No clause found for address: ${pClauseInformaryAddress}`);
+			return;
+		}
+		const tmpProvider = this.pict.providers['RSP-Provider-' + tmpClause.RecordSet];
+		const tmpOptionValues = this._optionValues(tmpClause, tmpProvider);
+		if (pOptionIndex < 0 || pOptionIndex >= tmpOptionValues.length)
+		{
+			return;
+		}
+		const tmpValue = tmpOptionValues[pOptionIndex];
+		if (!Array.isArray(tmpClause.Values))
+		{
+			tmpClause.Values = [];
+		}
+		const tmpSelectedIndex = tmpClause.Values.findIndex((pSelectedValue) => pSelectedValue === tmpValue);
+		if (tmpSelectedIndex >= 0)
+		{
+			tmpClause.Values.splice(tmpSelectedIndex, 1);
+		}
+		else
+		{
+			tmpClause.Values.push(tmpValue);
+		}
+		this._reRenderClause(pClauseInformaryAddress, pClauseHash);
+	}
+
+	/**
+	 * Re-render this clause's container (the checkbox list repaints on toggle / fetch resolve).
+	 *
+	 * @param {string} pClauseInformaryAddress
+	 * @param {string} pClauseHash
+	 */
+	_reRenderClause(pClauseInformaryAddress, pClauseHash)
+	{
+		const tmpClause = this.getInformaryScopedValue(pClauseInformaryAddress);
+		if (!tmpClause)
+		{
+			return;
+		}
+		const tmpRecord = Object.assign({ ClauseAddress: pClauseInformaryAddress }, tmpClause);
+		this.prepareRecord(tmpRecord);
+		this.render(null, `#PRSP_Filter_Container_${pClauseHash}`, tmpRecord);
+	}
+}
+
+module.exports = ViewRecordSetSUBSETFilterDistinctSelectedValueList;
+
+module.exports.default_configuration = Object.assign({}, ViewRecordSetSUBSETFilterBase.default_configuration, _DEFAULT_CONFIGURATION_Filter_DistinctSelectedValueList);

package/source/views/filters/index.js

@@ -10,6 +10,8 @@ module.exports =
 	StringMatch: require('./RecordSet-Filter-StringMatch.js'),
 	StringRange: require('./RecordSet-Filter-StringRange.js'),
 
+	DistinctSelectedValueList: require('./RecordSet-Filter-DistinctSelectedValueList.js'),
+
 	InternalJoinDateMatch: require('./RecordSet-Filter-InternalJoinDateMatch.js'),
 	InternalJoinDateRange: require('./RecordSet-Filter-InternalJoinDateRange.js'),
 	InternalJoinNumericMatch: require('./RecordSet-Filter-InternalJoinNumericMatch.js'),