@nova-ui/bits
Version:
SolarWinds Nova Framework
291 lines • 42.8 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { Injectable, Optional } from "@angular/core";
import _differenceWith from "lodash/differenceWith";
import _intersectionWith from "lodash/intersectionWith";
import _isEqual from "lodash/isEqual";
import _isUndefined from "lodash/isUndefined";
import _reject from "lodash/reject";
import _unionWith from "lodash/unionWith";
import { CheckboxStatus, SelectionType } from "./public-api";
import { LoggerService } from "../../services/log-service";
import { SelectionModel, } from "../../services/public-api";
import { RepeatSelectionMode } from "../repeat/types";
import * as i0 from "@angular/core";
import * as i1 from "../../services/log-service";
/**
* @ignore
*/
export class SelectorService {
constructor(logger) {
this.logger = logger;
/**
* Map if SelectionType to internationalized selector options
*/
this.i18nTitleMap = {};
this.i18nTitleMap[SelectionType.All] = $localize `Select all items on this page`;
this.i18nTitleMap[SelectionType.AllPages] = $localize `Select all items on all pages`;
this.i18nTitleMap[SelectionType.None] = $localize `Unselect all items`;
this.i18nTitleMap[SelectionType.UnselectAll] = $localize `Unselect all items on this page`;
}
// TODO: think about an ability to provide isEqual function from outside
/**
* Allows to react on changes of a selector component.
* If user has selected one of the options in a selector (Select all items pages, Select all items on all pages),
* the new selection object should be created.
* @param {ISelection} currentSelection
* @param {any[]} currentItems Items on current page
* @param {SelectionType} selectorValue
* @param {number} totalItems
* @param trackBy
* @param {boolean} virtualScroll Enables virtual scroll selection behavior
* @returns {ISelection} New selection object
*/
applySelector(currentSelection, currentItems, selectorValue, totalItems, trackBy = (i, d) => d, virtualScroll) {
if (virtualScroll) {
if (selectorValue === SelectionType.AllPages ||
selectorValue === SelectionType.All) {
return new SelectionModel({ isAllPages: true });
}
return new SelectionModel();
}
if (selectorValue === SelectionType.AllPages) {
return new SelectionModel({ isAllPages: true });
}
const trackedItems = currentItems.map((value, index) => trackBy(index, value));
if (currentSelection.isAllPages) {
if (selectorValue === SelectionType.All) {
return new SelectionModel({
isAllPages: true,
exclude: _differenceWith(currentSelection.exclude, trackedItems, _isEqual),
});
}
if (selectorValue === SelectionType.UnselectAll) {
return new SelectionModel({
isAllPages: true,
exclude: _unionWith(currentSelection.exclude, trackedItems, _isEqual),
});
}
}
else {
if (selectorValue === SelectionType.All) {
return new SelectionModel({
include: _unionWith(currentSelection.include, trackedItems, _isEqual),
});
}
if (selectorValue === SelectionType.UnselectAll) {
return new SelectionModel({
include: _differenceWith(currentSelection.include, trackedItems, _isEqual),
});
}
}
return new SelectionModel();
}
/**
* You may need to obtain the set of items that are selected given selection object and some set of items.
* @param {ISelection} selection
* @param {any[]} items
* @param comparator
* @returns {any[]} Set of items
*/
getSelectedItems(selection, items, comparator = _isEqual) {
if (selection.isAllPages) {
return _differenceWith(items, selection.exclude, comparator);
}
else {
return _intersectionWith(items, selection.include, comparator);
}
}
/**
* Allows to react on changes of selected items (for selector).
* If user selects some items directly in a list, selector state may change
* @param {ISelection} currentSelection
* @param {number} totalOnCurrentPage
* @param {number} selectedOnCurrentPage
* @param totalItems
* @param selectedOnAllPages
* @param {boolean} virtualScroll Enables virtual scroll selection behavior
* @returns {ISelectorState}
*/
getSelectorState(currentSelection, totalOnCurrentPage, selectedOnCurrentPage, totalItems, selectedOnAllPages, virtualScroll) {
// Note: short cutting the flow in case we're preforming the selection in
// virtual scroll mode where we can't have options for selection, just select all and unselect all
if (virtualScroll) {
// Note: In case user manually selected all the items we should set the Checked state
if (selectedOnAllPages === totalItems) {
return {
checkboxStatus: CheckboxStatus.Checked,
selectorItems: [],
};
}
if (currentSelection.isAllPages) {
return {
// Note: In case master checkbox is in the checked state we should ensure
// that we don't have any excluded items to prevent displaying Checked state
checkboxStatus: currentSelection.exclude.length
? CheckboxStatus.Indeterminate
: CheckboxStatus.Checked,
selectorItems: [],
};
}
else {
return {
// Note: In case master checkbox is in the unchecked state we should ensure
// that we don't have any included items to prevent displaying Unchecked state
checkboxStatus: currentSelection.include.length
? CheckboxStatus.Indeterminate
: CheckboxStatus.Unchecked,
selectorItems: [],
};
}
}
if (selectedOnCurrentPage === 0) {
if (totalOnCurrentPage === totalItems) {
return {
checkboxStatus: CheckboxStatus.Unchecked,
selectorItems: this.getFlatSelectorItems([
SelectionType.All,
]),
};
}
if (selectedOnAllPages && selectedOnAllPages > 0) {
return {
checkboxStatus: CheckboxStatus.Unchecked,
selectorItems: this.getFlatSelectorItems([
SelectionType.All,
SelectionType.AllPages,
SelectionType.None,
]),
};
}
return {
checkboxStatus: CheckboxStatus.Unchecked,
selectorItems: this.getFlatSelectorItems([
SelectionType.AllPages,
SelectionType.All,
]),
};
}
// case when we have only one page. Clarified with UX team that when we have one page we need to have SelectionType.All
if (selectedOnCurrentPage < totalOnCurrentPage &&
totalOnCurrentPage === totalItems) {
return {
checkboxStatus: CheckboxStatus.Indeterminate,
selectorItems: this.getFlatSelectorItems([
SelectionType.All,
SelectionType.None,
]),
};
}
if (selectedOnCurrentPage === totalOnCurrentPage) {
return {
checkboxStatus: CheckboxStatus.Checked,
selectorItems: currentSelection.isAllPages &&
currentSelection.exclude.length === 0
? this.getFlatSelectorItems([SelectionType.None])
: this.getFlatSelectorItems([
SelectionType.AllPages,
SelectionType.None,
]),
};
}
return {
checkboxStatus: CheckboxStatus.Indeterminate,
selectorItems: this.getFlatSelectorItems([
SelectionType.All,
SelectionType.AllPages,
SelectionType.None,
]),
};
}
/**
* Allows to react on selection.
* @param {ISelection} prevSelection Previous selection
* @param {any[]} selectedItems Selected items on the current page
* @param {any[]} items Items on the current page
* @param {RepeatSelectionMode} selectionMode One of possible repeater selection modes
* @param {number} totalItems Deprecated in v9 - Unused - Removal: NUI-5809
* @returns {ISelection} New selection
*/
selectItems(prevSelection, selectedItems, items, selectionMode, totalItems) {
if (!_isUndefined(totalItems)) {
this.logger?.warn("'totalItems' parameter of SelectorService.selectItems is unused and deprecated. As of Nova v9, this \
argument may be omitted. Removal: NUI-5896");
}
if (selectionMode === RepeatSelectionMode.radio ||
selectionMode === RepeatSelectionMode.single ||
selectionMode ===
RepeatSelectionMode.radioWithNonRequiredSelection ||
selectionMode === RepeatSelectionMode.singleWithRequiredSelection) {
return new SelectionModel({ include: selectedItems });
}
// This is just common sense: if selection mode can be dynamically changed this may be useful
if (selectionMode === RepeatSelectionMode.none) {
return new SelectionModel();
}
const includedItems = this.getIncludedItems(prevSelection, items, selectedItems);
if (prevSelection.isAllPages) {
return new SelectionModel({
isAllPages: prevSelection.isAllPages,
exclude: this.getExcludedItems(prevSelection, items, selectedItems),
});
}
return new SelectionModel({
isAllPages: prevSelection.isAllPages,
include: includedItems,
});
}
// items are all items in current repeater
getIncludedItems(prevSelection, items, selectedItems) {
const unselectedItems = _differenceWith(items, selectedItems, _isEqual);
const includedItems = _reject(prevSelection.include, (includedItem) => unselectedItems.some((unselectedItem) => _isEqual(includedItem, unselectedItem)));
return _unionWith(includedItems, selectedItems, _isEqual);
}
getExcludedItems(prevSelection, items, selectedItems) {
const excludedItems = _reject(prevSelection.exclude, (excludedItem) => selectedItems.some((item) => _isEqual(excludedItem, item)));
const unselectedItemsOnPage = _differenceWith(items, selectedItems, _isEqual);
return unselectedItemsOnPage.reduce((memo, item) => {
const isItemExcluded = excludedItems.some((excludedItem) => _isEqual(excludedItem, item));
if (!isItemExcluded) {
memo.push(item);
}
return memo;
}, excludedItems);
}
getFlatSelectorItems(arr) {
return [
{
itemsSource: arr.map((element) => ({
value: element,
title: this.i18nTitleMap[element],
})),
},
];
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectorService, deps: [{ token: i1.LoggerService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectorService, providedIn: "root" }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectorService, decorators: [{
type: Injectable,
args: [{ providedIn: "root" }]
}], ctorParameters: () => [{ type: i1.LoggerService, decorators: [{
type: Optional
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selector.service.js","sourceRoot":"","sources":["../../../../src/lib/selector/selector.service.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAC5E,8EAA8E;AAC9E,+EAA+E;AAC/E,8EAA8E;AAC9E,4DAA4D;AAC5D,EAAE;AACF,6EAA6E;AAC7E,uDAAuD;AACvD,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,+EAA+E;AAC/E,0EAA0E;AAC1E,iFAAiF;AACjF,6EAA6E;AAC7E,iBAAiB;AAEjB,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAmB,MAAM,eAAe,CAAC;AACtE,OAAO,eAAe,MAAM,uBAAuB,CAAC;AACpD,OAAO,iBAAiB,MAAM,yBAAyB,CAAC;AACxD,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,OAAO,MAAM,eAAe,CAAC;AACpC,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAGH,cAAc,GACjB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;;;AAEtD;;GAEG;AAEH,MAAM,OAAO,eAAe;IAMxB,YAAgC,MAAsB;QAAtB,WAAM,GAAN,MAAM,CAAgB;QALtD;;WAEG;QACI,iBAAY,GAA2B,EAAE,CAAC;QAG7C,IAAI,CAAC,YAAY,CACb,aAAa,CAAC,GAAG,CACpB,GAAG,SAAS,CAAA,+BAA+B,CAAC;QAC7C,IAAI,CAAC,YAAY,CACb,aAAa,CAAC,QAAQ,CACzB,GAAG,SAAS,CAAA,+BAA+B,CAAC;QAC7C,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,SAAS,CAAA,oBAAoB,CAAC;QACtE,IAAI,CAAC,YAAY,CACb,aAAa,CAAC,WAAW,CAC5B,GAAG,SAAS,CAAA,iCAAiC,CAAC;IACnD,CAAC;IAED,wEAAwE;IAExE;;;;;;;;;;;OAWG;IACI,aAAa,CAChB,gBAA4B,EAC5B,YAAmB,EACnB,aAA4B,EAC5B,UAAkB,EAClB,UAAgC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAC3C,aAAuB;QAEvB,IAAI,aAAa,EAAE;YACf,IACI,aAAa,KAAK,aAAa,CAAC,QAAQ;gBACxC,aAAa,KAAK,aAAa,CAAC,GAAG,EACrC;gBACE,OAAO,IAAI,cAAc,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;aACnD;YACD,OAAO,IAAI,cAAc,EAAE,CAAC;SAC/B;QAED,IAAI,aAAa,KAAK,aAAa,CAAC,QAAQ,EAAE;YAC1C,OAAO,IAAI,cAAc,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;SACnD;QAED,MAAM,YAAY,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACnD,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CACxB,CAAC;QACF,IAAI,gBAAgB,CAAC,UAAU,EAAE;YAC7B,IAAI,aAAa,KAAK,aAAa,CAAC,GAAG,EAAE;gBACrC,OAAO,IAAI,cAAc,CAAC;oBACtB,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,eAAe,CACpB,gBAAgB,CAAC,OAAO,EACxB,YAAY,EACZ,QAAQ,CACX;iBACJ,CAAC,CAAC;aACN;YAED,IAAI,aAAa,KAAK,aAAa,CAAC,WAAW,EAAE;gBAC7C,OAAO,IAAI,cAAc,CAAC;oBACtB,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,UAAU,CACf,gBAAgB,CAAC,OAAO,EACxB,YAAY,EACZ,QAAQ,CACX;iBACJ,CAAC,CAAC;aACN;SACJ;aAAM;YACH,IAAI,aAAa,KAAK,aAAa,CAAC,GAAG,EAAE;gBACrC,OAAO,IAAI,cAAc,CAAC;oBACtB,OAAO,EAAE,UAAU,CACf,gBAAgB,CAAC,OAAO,EACxB,YAAY,EACZ,QAAQ,CACX;iBACJ,CAAC,CAAC;aACN;YAED,IAAI,aAAa,KAAK,aAAa,CAAC,WAAW,EAAE;gBAC7C,OAAO,IAAI,cAAc,CAAC;oBACtB,OAAO,EAAE,eAAe,CACpB,gBAAgB,CAAC,OAAO,EACxB,YAAY,EACZ,QAAQ,CACX;iBACJ,CAAC,CAAC;aACN;SACJ;QAED,OAAO,IAAI,cAAc,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,SAAqB,EAAE,KAAY,EAAE,aAA0C,QAAQ;QAC3G,IAAI,SAAS,CAAC,UAAU,EAAE;YACtB,OAAO,eAAe,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;SAChE;aAAM;YACH,OAAO,iBAAiB,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;SAClE;IACL,CAAC;IAED;;;;;;;;;;OAUG;IACI,gBAAgB,CACnB,gBAA4B,EAC5B,kBAA0B,EAC1B,qBAA6B,EAC7B,UAAmB,EACnB,kBAA2B,EAC3B,aAAuB;QAEvB,yEAAyE;QACzE,kGAAkG;QAClG,IAAI,aAAa,EAAE;YACf,qFAAqF;YACrF,IAAI,kBAAkB,KAAK,UAAU,EAAE;gBACnC,OAAO;oBACH,cAAc,EAAE,cAAc,CAAC,OAAO;oBACtC,aAAa,EAAE,EAAE;iBACpB,CAAC;aACL;YAED,IAAI,gBAAgB,CAAC,UAAU,EAAE;gBAC7B,OAAO;oBACH,yEAAyE;oBACzE,4EAA4E;oBAC5E,cAAc,EAAE,gBAAgB,CAAC,OAAO,CAAC,MAAM;wBAC3C,CAAC,CAAC,cAAc,CAAC,aAAa;wBAC9B,CAAC,CAAC,cAAc,CAAC,OAAO;oBAC5B,aAAa,EAAE,EAAE;iBACpB,CAAC;aACL;iBAAM;gBACH,OAAO;oBACH,2EAA2E;oBAC3E,8EAA8E;oBAC9E,cAAc,EAAE,gBAAgB,CAAC,OAAO,CAAC,MAAM;wBAC3C,CAAC,CAAC,cAAc,CAAC,aAAa;wBAC9B,CAAC,CAAC,cAAc,CAAC,SAAS;oBAC9B,aAAa,EAAE,EAAE;iBACpB,CAAC;aACL;SACJ;QAED,IAAI,qBAAqB,KAAK,CAAC,EAAE;YAC7B,IAAI,kBAAkB,KAAK,UAAU,EAAE;gBACnC,OAAO;oBACH,cAAc,EAAE,cAAc,CAAC,SAAS;oBACxC,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC;wBACrC,aAAa,CAAC,GAAG;qBACpB,CAAC;iBACL,CAAC;aACL;YACD,IAAI,kBAAkB,IAAI,kBAAkB,GAAG,CAAC,EAAE;gBAC9C,OAAO;oBACH,cAAc,EAAE,cAAc,CAAC,SAAS;oBACxC,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC;wBACrC,aAAa,CAAC,GAAG;wBACjB,aAAa,CAAC,QAAQ;wBACtB,aAAa,CAAC,IAAI;qBACrB,CAAC;iBACL,CAAC;aACL;YAED,OAAO;gBACH,cAAc,EAAE,cAAc,CAAC,SAAS;gBACxC,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC;oBACrC,aAAa,CAAC,QAAQ;oBACtB,aAAa,CAAC,GAAG;iBACpB,CAAC;aACL,CAAC;SACL;QACD,uHAAuH;QACvH,IACI,qBAAqB,GAAG,kBAAkB;YAC1C,kBAAkB,KAAK,UAAU,EACnC;YACE,OAAO;gBACH,cAAc,EAAE,cAAc,CAAC,aAAa;gBAC5C,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC;oBACrC,aAAa,CAAC,GAAG;oBACjB,aAAa,CAAC,IAAI;iBACrB,CAAC;aACL,CAAC;SACL;QAED,IAAI,qBAAqB,KAAK,kBAAkB,EAAE;YAC9C,OAAO;gBACH,cAAc,EAAE,cAAc,CAAC,OAAO;gBACtC,aAAa,EACT,gBAAgB,CAAC,UAAU;oBAC3B,gBAAgB,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;oBACjC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBACjD,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC;wBACtB,aAAa,CAAC,QAAQ;wBACtB,aAAa,CAAC,IAAI;qBACrB,CAAC;aACf,CAAC;SACL;QAED,OAAO;YACH,cAAc,EAAE,cAAc,CAAC,aAAa;YAC5C,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC;gBACrC,aAAa,CAAC,GAAG;gBACjB,aAAa,CAAC,QAAQ;gBACtB,aAAa,CAAC,IAAI;aACrB,CAAC;SACL,CAAC;IACN,CAAC;IAED;;;;;;;;OAQG;IACI,WAAW,CACd,aAAyB,EACzB,aAAoB,EACpB,KAAY,EACZ,aAAkC,EAClC,UAAmB;QAEnB,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE;YAC3B,IAAI,CAAC,MAAM,EAAE,IAAI,CACb;2DAC2C,CAC9C,CAAC;SACL;QAED,IACI,aAAa,KAAK,mBAAmB,CAAC,KAAK;YAC3C,aAAa,KAAK,mBAAmB,CAAC,MAAM;YAC5C,aAAa;gBACT,mBAAmB,CAAC,6BAA6B;YACrD,aAAa,KAAK,mBAAmB,CAAC,2BAA2B,EACnE;YACE,OAAO,IAAI,cAAc,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;SACzD;QAED,6FAA6F;QAC7F,IAAI,aAAa,KAAK,mBAAmB,CAAC,IAAI,EAAE;YAC5C,OAAO,IAAI,cAAc,EAAE,CAAC;SAC/B;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CACvC,aAAa,EACb,KAAK,EACL,aAAa,CAChB,CAAC;QAEF,IAAI,aAAa,CAAC,UAAU,EAAE;YAC1B,OAAO,IAAI,cAAc,CAAC;gBACtB,UAAU,EAAE,aAAa,CAAC,UAAU;gBACpC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAC1B,aAAa,EACb,KAAK,EACL,aAAa,CAChB;aACJ,CAAC,CAAC;SACN;QAED,OAAO,IAAI,cAAc,CAAC;YACtB,UAAU,EAAE,aAAa,CAAC,UAAU;YACpC,OAAO,EAAE,aAAa;SACzB,CAAC,CAAC;IACP,CAAC;IAED,0CAA0C;IAClC,gBAAgB,CACpB,aAAyB,EACzB,KAAY,EACZ,aAAoB;QAEpB,MAAM,eAAe,GAAG,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;QACxE,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,YAAY,EAAE,EAAE,CAClE,eAAe,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE,CACpC,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,CACzC,CACJ,CAAC;QACF,OAAO,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAEO,gBAAgB,CACpB,aAAyB,EACzB,KAAY,EACZ,aAAoB;QAEpB,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,YAAY,EAAE,EAAE,CAClE,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAC7D,CAAC;QACF,MAAM,qBAAqB,GAAG,eAAe,CACzC,KAAK,EACL,aAAa,EACb,QAAQ,CACX,CAAC;QAEF,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;YAC/C,MAAM,cAAc,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CACvD,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,CAC/B,CAAC;YACF,IAAI,CAAC,cAAc,EAAE;gBACjB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACnB;YACD,OAAO,IAAI,CAAC;QAChB,CAAC,EAAE,aAAa,CAAC,CAAC;IACtB,CAAC;IAEO,oBAAoB,CAAC,GAAoB;QAC7C,OAAO;YACH;gBACI,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,OAAsB,EAAE,EAAE,CAAC,CAAC;oBAC9C,KAAK,EAAE,OAAO;oBACd,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;iBACpC,CAAC,CAAC;aACN;SACJ,CAAC;IACN,CAAC;+GA3VQ,eAAe;mHAAf,eAAe,cADF,MAAM;;4FACnB,eAAe;kBAD3B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAOjB,QAAQ","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { Injectable, Optional, TrackByFunction } from \"@angular/core\";\nimport _differenceWith from \"lodash/differenceWith\";\nimport _intersectionWith from \"lodash/intersectionWith\";\nimport _isEqual from \"lodash/isEqual\";\nimport _isUndefined from \"lodash/isUndefined\";\nimport _reject from \"lodash/reject\";\nimport _unionWith from \"lodash/unionWith\";\n\nimport { CheckboxStatus, SelectionType } from \"./public-api\";\nimport { LoggerService } from \"../../services/log-service\";\nimport {\n    ISelection,\n    ISelectorState,\n    SelectionModel,\n} from \"../../services/public-api\";\nimport { IMenuGroup } from \"../menu/public-api\";\nimport { RepeatSelectionMode } from \"../repeat/types\";\n\n/**\n * @ignore\n */\n@Injectable({ providedIn: \"root\" })\nexport class SelectorService {\n    /**\n     * Map if SelectionType to internationalized selector options\n     */\n    public i18nTitleMap: Record<string, string> = {};\n\n    constructor(@Optional() private logger?: LoggerService) {\n        this.i18nTitleMap[\n            SelectionType.All\n        ] = $localize`Select all items on this page`;\n        this.i18nTitleMap[\n            SelectionType.AllPages\n        ] = $localize`Select all items on all pages`;\n        this.i18nTitleMap[SelectionType.None] = $localize`Unselect all items`;\n        this.i18nTitleMap[\n            SelectionType.UnselectAll\n        ] = $localize`Unselect all items on this page`;\n    }\n\n    // TODO: think about an ability to provide isEqual function from outside\n\n    /**\n     * Allows to react on changes of a selector component.\n     * If user has selected one of the options in a selector (Select all items pages, Select all items on all pages),\n     * the new selection object should be created.\n     * @param {ISelection} currentSelection\n     * @param {any[]} currentItems Items on current page\n     * @param {SelectionType} selectorValue\n     * @param {number} totalItems\n     * @param trackBy\n     * @param {boolean} virtualScroll Enables virtual scroll selection behavior\n     * @returns {ISelection} New selection object\n     */\n    public applySelector(\n        currentSelection: ISelection,\n        currentItems: any[],\n        selectorValue: SelectionType,\n        totalItems: number,\n        trackBy: TrackByFunction<any> = (i, d) => d,\n        virtualScroll?: boolean\n    ): ISelection {\n        if (virtualScroll) {\n            if (\n                selectorValue === SelectionType.AllPages ||\n                selectorValue === SelectionType.All\n            ) {\n                return new SelectionModel({ isAllPages: true });\n            }\n            return new SelectionModel();\n        }\n\n        if (selectorValue === SelectionType.AllPages) {\n            return new SelectionModel({ isAllPages: true });\n        }\n\n        const trackedItems = currentItems.map((value, index) =>\n            trackBy(index, value)\n        );\n        if (currentSelection.isAllPages) {\n            if (selectorValue === SelectionType.All) {\n                return new SelectionModel({\n                    isAllPages: true,\n                    exclude: _differenceWith(\n                        currentSelection.exclude,\n                        trackedItems,\n                        _isEqual\n                    ),\n                });\n            }\n\n            if (selectorValue === SelectionType.UnselectAll) {\n                return new SelectionModel({\n                    isAllPages: true,\n                    exclude: _unionWith(\n                        currentSelection.exclude,\n                        trackedItems,\n                        _isEqual\n                    ),\n                });\n            }\n        } else {\n            if (selectorValue === SelectionType.All) {\n                return new SelectionModel({\n                    include: _unionWith(\n                        currentSelection.include,\n                        trackedItems,\n                        _isEqual\n                    ),\n                });\n            }\n\n            if (selectorValue === SelectionType.UnselectAll) {\n                return new SelectionModel({\n                    include: _differenceWith(\n                        currentSelection.include,\n                        trackedItems,\n                        _isEqual\n                    ),\n                });\n            }\n        }\n\n        return new SelectionModel();\n    }\n\n    /**\n     * You may need to obtain the set of items that are selected given selection object and some set of items.\n     * @param {ISelection} selection\n     * @param {any[]} items\n     * @param comparator\n     * @returns {any[]} Set of items\n     */\n    public getSelectedItems(selection: ISelection, items: any[], comparator: (a: any, b: any) => boolean = _isEqual): any[] {\n        if (selection.isAllPages) {\n            return _differenceWith(items, selection.exclude, comparator);\n        } else {\n            return _intersectionWith(items, selection.include, comparator);\n        }\n    }\n\n    /**\n     * Allows to react on changes of selected items (for selector).\n     * If user selects some items directly in a list, selector state may change\n     * @param {ISelection} currentSelection\n     * @param {number} totalOnCurrentPage\n     * @param {number} selectedOnCurrentPage\n     * @param totalItems\n     * @param selectedOnAllPages\n     * @param {boolean} virtualScroll Enables virtual scroll selection behavior\n     * @returns {ISelectorState}\n     */\n    public getSelectorState(\n        currentSelection: ISelection,\n        totalOnCurrentPage: number,\n        selectedOnCurrentPage: number,\n        totalItems?: number,\n        selectedOnAllPages?: number,\n        virtualScroll?: boolean\n    ): ISelectorState {\n        // Note: short cutting the flow in case we're preforming the selection in\n        // virtual scroll mode where we can't have options for selection, just select all and unselect all\n        if (virtualScroll) {\n            // Note: In case user manually selected all the items we should set the Checked state\n            if (selectedOnAllPages === totalItems) {\n                return {\n                    checkboxStatus: CheckboxStatus.Checked,\n                    selectorItems: [],\n                };\n            }\n\n            if (currentSelection.isAllPages) {\n                return {\n                    // Note: In case master checkbox is in the checked state we should ensure\n                    // that we don't have any excluded items to prevent displaying Checked state\n                    checkboxStatus: currentSelection.exclude.length\n                        ? CheckboxStatus.Indeterminate\n                        : CheckboxStatus.Checked,\n                    selectorItems: [],\n                };\n            } else {\n                return {\n                    // Note: In case master checkbox is in the unchecked state we should ensure\n                    // that we don't have any included items to prevent displaying Unchecked state\n                    checkboxStatus: currentSelection.include.length\n                        ? CheckboxStatus.Indeterminate\n                        : CheckboxStatus.Unchecked,\n                    selectorItems: [],\n                };\n            }\n        }\n\n        if (selectedOnCurrentPage === 0) {\n            if (totalOnCurrentPage === totalItems) {\n                return {\n                    checkboxStatus: CheckboxStatus.Unchecked,\n                    selectorItems: this.getFlatSelectorItems([\n                        SelectionType.All,\n                    ]),\n                };\n            }\n            if (selectedOnAllPages && selectedOnAllPages > 0) {\n                return {\n                    checkboxStatus: CheckboxStatus.Unchecked,\n                    selectorItems: this.getFlatSelectorItems([\n                        SelectionType.All,\n                        SelectionType.AllPages,\n                        SelectionType.None,\n                    ]),\n                };\n            }\n\n            return {\n                checkboxStatus: CheckboxStatus.Unchecked,\n                selectorItems: this.getFlatSelectorItems([\n                    SelectionType.AllPages,\n                    SelectionType.All,\n                ]),\n            };\n        }\n        // case when we have only one page. Clarified with UX team that when we have one page we need to have SelectionType.All\n        if (\n            selectedOnCurrentPage < totalOnCurrentPage &&\n            totalOnCurrentPage === totalItems\n        ) {\n            return {\n                checkboxStatus: CheckboxStatus.Indeterminate,\n                selectorItems: this.getFlatSelectorItems([\n                    SelectionType.All,\n                    SelectionType.None,\n                ]),\n            };\n        }\n\n        if (selectedOnCurrentPage === totalOnCurrentPage) {\n            return {\n                checkboxStatus: CheckboxStatus.Checked,\n                selectorItems:\n                    currentSelection.isAllPages &&\n                    currentSelection.exclude.length === 0\n                        ? this.getFlatSelectorItems([SelectionType.None])\n                        : this.getFlatSelectorItems([\n                              SelectionType.AllPages,\n                              SelectionType.None,\n                          ]),\n            };\n        }\n\n        return {\n            checkboxStatus: CheckboxStatus.Indeterminate,\n            selectorItems: this.getFlatSelectorItems([\n                SelectionType.All,\n                SelectionType.AllPages,\n                SelectionType.None,\n            ]),\n        };\n    }\n\n    /**\n     * Allows to react on selection.\n     * @param {ISelection} prevSelection Previous selection\n     * @param {any[]} selectedItems Selected items on the current page\n     * @param {any[]} items Items on the current page\n     * @param {RepeatSelectionMode} selectionMode One of possible repeater selection modes\n     * @param {number} totalItems Deprecated in v9 - Unused - Removal: NUI-5809\n     * @returns {ISelection} New selection\n     */\n    public selectItems(\n        prevSelection: ISelection,\n        selectedItems: any[],\n        items: any[],\n        selectionMode: RepeatSelectionMode,\n        totalItems?: number\n    ): ISelection {\n        if (!_isUndefined(totalItems)) {\n            this.logger?.warn(\n                \"'totalItems' parameter of SelectorService.selectItems is unused and deprecated. As of Nova v9, this \\\n                argument may be omitted. Removal: NUI-5896\"\n            );\n        }\n\n        if (\n            selectionMode === RepeatSelectionMode.radio ||\n            selectionMode === RepeatSelectionMode.single ||\n            selectionMode ===\n                RepeatSelectionMode.radioWithNonRequiredSelection ||\n            selectionMode === RepeatSelectionMode.singleWithRequiredSelection\n        ) {\n            return new SelectionModel({ include: selectedItems });\n        }\n\n        // This is just common sense: if selection mode can be dynamically changed this may be useful\n        if (selectionMode === RepeatSelectionMode.none) {\n            return new SelectionModel();\n        }\n\n        const includedItems = this.getIncludedItems(\n            prevSelection,\n            items,\n            selectedItems\n        );\n\n        if (prevSelection.isAllPages) {\n            return new SelectionModel({\n                isAllPages: prevSelection.isAllPages,\n                exclude: this.getExcludedItems(\n                    prevSelection,\n                    items,\n                    selectedItems\n                ),\n            });\n        }\n\n        return new SelectionModel({\n            isAllPages: prevSelection.isAllPages,\n            include: includedItems,\n        });\n    }\n\n    // items are all items in current repeater\n    private getIncludedItems(\n        prevSelection: ISelection,\n        items: any[],\n        selectedItems: any[]\n    ): any[] {\n        const unselectedItems = _differenceWith(items, selectedItems, _isEqual);\n        const includedItems = _reject(prevSelection.include, (includedItem) =>\n            unselectedItems.some((unselectedItem) =>\n                _isEqual(includedItem, unselectedItem)\n            )\n        );\n        return _unionWith(includedItems, selectedItems, _isEqual);\n    }\n\n    private getExcludedItems(\n        prevSelection: ISelection,\n        items: any[],\n        selectedItems: any[]\n    ): any[] {\n        const excludedItems = _reject(prevSelection.exclude, (excludedItem) =>\n            selectedItems.some((item) => _isEqual(excludedItem, item))\n        );\n        const unselectedItemsOnPage = _differenceWith(\n            items,\n            selectedItems,\n            _isEqual\n        );\n\n        return unselectedItemsOnPage.reduce((memo, item) => {\n            const isItemExcluded = excludedItems.some((excludedItem) =>\n                _isEqual(excludedItem, item)\n            );\n            if (!isItemExcluded) {\n                memo.push(item);\n            }\n            return memo;\n        }, excludedItems);\n    }\n\n    private getFlatSelectorItems(arr: SelectionType[]): IMenuGroup[] {\n        return [\n            {\n                itemsSource: arr.map((element: SelectionType) => ({\n                    value: element,\n                    title: this.i18nTitleMap[element],\n                })),\n            },\n        ];\n    }\n}\n"]}