@fundamental-ngx/core 0.33.4-rc.6 → 0.33.4

package/utils/esm2020/helpers/range-selector.mjs

@@ -0,0 +1,113 @@
+/**
+ * Utility type, that allows to track and select ranges of elements while using multi-selection.
+ *
+ * @usage
+ * Imagine we have a simple list of checkboxes:
+ * ```html
+ * <input
+ *  #checkboxInput
+ *  *ngFor="let o of options; let idx = index"
+ *  type="checkbox"
+ *  [checked]="selectionModel.checked(o)"
+ *  (click)="toggle(idx, $event)"
+ *  >
+ * ```
+ * With the given layout the logic should be as follows:
+ * ```typescript
+ * export class YourComponent {
+ *  options = ['a', 'b', 'c'];
+ *  readonly selectionModel = new SelectionModel(true);
+ *
+ *  private readonly _rangeSelector = new RangeSelector();
+ *
+ *
+ *  toggle(idx: number, event: PointerEvent): void {
+ *      // getting the toggled value of the checkbox
+ *      const toggledSelection = event.target.value;
+ *
+ *      // registering the selection of current checkbox
+ *      this._rangeSelector.onRangeElementToggled(idx, event);
+ *
+ *      // Apply value to each element in range.
+ *      // If checkbox was toggled without shift pressed or without previously selected one,
+ *      // this method will select only it.
+ *      this._rangeSelector.applyValueToEachInRange(idx => {
+ *          if (toggledSelection) {
+ *              this.selectionModel.select(options[idx]);
+ *          } else {
+ *              this.selectionModel.deselect(options[idx]);
+ *          }
+ *      });
+ *  }
+ * }
+ * ```
+ */
+export class RangeSelector {
+    constructor() {
+        /** @hidden */
+        this._previousSelectedIndex = null;
+    }
+    /**
+     * Last registered selection state (either multiple or single).
+     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.
+     */
+    get lastRangeSelectionState() {
+        return this._state ? { ...this._state } : null;
+    }
+    /**
+     * The method that should be used to register each checkbox toggle.
+     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.
+     * Otherwise will register current index as last checked.
+     *
+     * If toggling was done with "shift" pressed and there's a previously registered index, will register a range selection.
+     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.
+     *
+     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.
+     *
+     * See usage example on this class itself.
+     */
+    onRangeElementToggled(index, event) {
+        if (this._isNonNegativeInteger(this._previousSelectedIndex) &&
+            this._isNonNegativeInteger(index) &&
+            event?.shiftKey) {
+            this._state = {
+                isRangeSelection: true,
+                from: Math.min(this._previousSelectedIndex, index),
+                to: Math.max(this._previousSelectedIndex, index)
+            };
+            this._previousSelectedIndex = index;
+        }
+        else if (this._isNonNegativeInteger(index)) {
+            this._state = { isRangeSelection: false, from: index, to: index };
+            this._previousSelectedIndex = index;
+        }
+        else {
+            this.reset();
+        }
+        return this.lastRangeSelectionState;
+    }
+    /**
+     * Allows to apply selection to each item in selection range.
+     * Accepts a function to apply selection to each item by registered index.
+     *
+     * See usage example on this class itself.
+     */
+    applyValueToEachInRange(selectionMethod) {
+        const state = this.lastRangeSelectionState;
+        if (this._isNonNegativeInteger(state?.from) && this._isNonNegativeInteger(state.to)) {
+            for (let index = state.from; index <= state.to; index++) {
+                selectionMethod(index);
+            }
+        }
+    }
+    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */
+    reset() {
+        this._state = null;
+        this._previousSelectedIndex = null;
+    }
+    /** @hidden */
+    _isNonNegativeInteger(num) {
+        return Number.isInteger(num) && num >= 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range-selector.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/utils/helpers/range-selector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,OAAO,aAAa;IAA1B;QACI,cAAc;QACN,2BAAsB,GAAkB,IAAI,CAAC;IAwEzD,CAAC;IApEG;;;OAGG;IACH,IAAI,uBAAuB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACnD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,qBAAqB,CAAC,KAAc,EAAE,KAA+C;QACjF,IACI,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,sBAAsB,CAAC;YACvD,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;YACjC,KAAK,EAAE,QAAQ,EACjB;YACE,IAAI,CAAC,MAAM,GAAG;gBACV,gBAAgB,EAAE,IAAI;gBACtB,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC;gBAClD,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC;aACnD,CAAC;YACF,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACvC;aAAM,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE;YAC1C,IAAI,CAAC,MAAM,GAAG,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;YAClE,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACvC;aAAM;YACH,IAAI,CAAC,KAAK,EAAE,CAAC;SAChB;QAED,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,uBAAuB,CAAC,eAAwC;QAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAE3C,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;YACjF,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,KAAK,IAAI,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;gBACrD,eAAe,CAAC,KAAK,CAAC,CAAC;aAC1B;SACJ;IACL,CAAC;IAED,4HAA4H;IAC5H,KAAK;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IACvC,CAAC;IAED,cAAc;IACN,qBAAqB,CAAC,GAAW;QACrC,OAAO,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAC7C,CAAC;CACJ","sourcesContent":["/**\n * Utility type, that allows to track and select ranges of elements while using multi-selection.\n *\n * @usage\n * Imagine we have a simple list of checkboxes:\n * ```html\n * <input\n *  #checkboxInput\n *  *ngFor=\"let o of options; let idx = index\"\n *  type=\"checkbox\"\n *  [checked]=\"selectionModel.checked(o)\"\n *  (click)=\"toggle(idx, $event)\"\n *  >\n * ```\n * With the given layout the logic should be as follows:\n * ```typescript\n * export class YourComponent {\n *  options = ['a', 'b', 'c'];\n *  readonly selectionModel = new SelectionModel(true);\n *\n *  private readonly _rangeSelector = new RangeSelector();\n *\n *\n *  toggle(idx: number, event: PointerEvent): void {\n *      // getting the toggled value of the checkbox\n *      const toggledSelection = event.target.value;\n *\n *      // registering the selection of current checkbox\n *      this._rangeSelector.onRangeElementToggled(idx, event);\n *\n *      // Apply value to each element in range.\n *      // If checkbox was toggled without shift pressed or without previously selected one,\n *      // this method will select only it.\n *      this._rangeSelector.applyValueToEachInRange(idx => {\n *          if (toggledSelection) {\n *              this.selectionModel.select(options[idx]);\n *          } else {\n *              this.selectionModel.deselect(options[idx]);\n *          }\n *      });\n *  }\n * }\n * ```\n */\nexport class RangeSelector {\n    /** @hidden */\n    private _previousSelectedIndex: number | null = null;\n    /** @hidden */\n    private _state: RangeSelectionState | null;\n\n    /**\n     * Last registered selection state (either multiple or single).\n     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.\n     */\n    get lastRangeSelectionState(): RangeSelectionState | null {\n        return this._state ? { ...this._state } : null;\n    }\n\n    /**\n     * The method that should be used to register each checkbox toggle.\n     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.\n     * Otherwise will register current index as last checked.\n     *\n     * If toggling was done with \"shift\" pressed and there's a previously registered index, will register a range selection.\n     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.\n     *\n     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.\n     *\n     * See usage example on this class itself.\n     */\n    onRangeElementToggled(index?: number, event?: KeyboardEvent | MouseEvent | TouchEvent): RangeSelectionState {\n        if (\n            this._isNonNegativeInteger(this._previousSelectedIndex) &&\n            this._isNonNegativeInteger(index) &&\n            event?.shiftKey\n        ) {\n            this._state = {\n                isRangeSelection: true,\n                from: Math.min(this._previousSelectedIndex, index),\n                to: Math.max(this._previousSelectedIndex, index)\n            };\n            this._previousSelectedIndex = index;\n        } else if (this._isNonNegativeInteger(index)) {\n            this._state = { isRangeSelection: false, from: index, to: index };\n            this._previousSelectedIndex = index;\n        } else {\n            this.reset();\n        }\n\n        return this.lastRangeSelectionState;\n    }\n\n    /**\n     * Allows to apply selection to each item in selection range.\n     * Accepts a function to apply selection to each item by registered index.\n     *\n     * See usage example on this class itself.\n     */\n    applyValueToEachInRange(selectionMethod: (index: number) => void): void {\n        const state = this.lastRangeSelectionState;\n\n        if (this._isNonNegativeInteger(state?.from) && this._isNonNegativeInteger(state.to)) {\n            for (let index = state.from; index <= state.to; index++) {\n                selectionMethod(index);\n            }\n        }\n    }\n\n    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */\n    reset(): void {\n        this._state = null;\n        this._previousSelectedIndex = null;\n    }\n\n    /** @hidden */\n    private _isNonNegativeInteger(num: number): boolean {\n        return Number.isInteger(num) && num >= 0;\n    }\n}\n\nexport interface RangeSelectionState {\n    isRangeSelection: boolean;\n    from: number;\n    to: number;\n}\n"]}

package/utils/esm2020/public_api.mjs

@@ -42,6 +42,7 @@ export * from './dynamic-component/dynamic-component-config';
 export * from './dynamic-component/dynamic-component-injector';
 export * from './dynamic-component/dynamic-component.service';
 export * from './dynamic-component/dynamic-component-container';
+export * from './helpers/range-selector';
 export * from './utils.module';
 export * from './datatypes/hash.datatype';
 export * from './datatypes/size.datatype';
@@ -56,4 +57,4 @@ export * from './abstract-fd-ngx-class';
 export * from './list-item/list-item-utils';
 export * from './mixins/apply-mixin';
 export * from './services/focus-trap.service';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/utils/fesm2015/fundamental-ngx-core-utils.mjs

@@ -2623,6 +2623,119 @@ class DynamicComponentContainer {
     }
 }
 
+/**
+ * Utility type, that allows to track and select ranges of elements while using multi-selection.
+ *
+ * @usage
+ * Imagine we have a simple list of checkboxes:
+ * ```html
+ * <input
+ *  #checkboxInput
+ *  *ngFor="let o of options; let idx = index"
+ *  type="checkbox"
+ *  [checked]="selectionModel.checked(o)"
+ *  (click)="toggle(idx, $event)"
+ *  >
+ * ```
+ * With the given layout the logic should be as follows:
+ * ```typescript
+ * export class YourComponent {
+ *  options = ['a', 'b', 'c'];
+ *  readonly selectionModel = new SelectionModel(true);
+ *
+ *  private readonly _rangeSelector = new RangeSelector();
+ *
+ *
+ *  toggle(idx: number, event: PointerEvent): void {
+ *      // getting the toggled value of the checkbox
+ *      const toggledSelection = event.target.value;
+ *
+ *      // registering the selection of current checkbox
+ *      this._rangeSelector.onRangeElementToggled(idx, event);
+ *
+ *      // Apply value to each element in range.
+ *      // If checkbox was toggled without shift pressed or without previously selected one,
+ *      // this method will select only it.
+ *      this._rangeSelector.applyValueToEachInRange(idx => {
+ *          if (toggledSelection) {
+ *              this.selectionModel.select(options[idx]);
+ *          } else {
+ *              this.selectionModel.deselect(options[idx]);
+ *          }
+ *      });
+ *  }
+ * }
+ * ```
+ */
+class RangeSelector {
+    constructor() {
+        /** @hidden */
+        this._previousSelectedIndex = null;
+    }
+    /**
+     * Last registered selection state (either multiple or single).
+     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.
+     */
+    get lastRangeSelectionState() {
+        return this._state ? Object.assign({}, this._state) : null;
+    }
+    /**
+     * The method that should be used to register each checkbox toggle.
+     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.
+     * Otherwise will register current index as last checked.
+     *
+     * If toggling was done with "shift" pressed and there's a previously registered index, will register a range selection.
+     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.
+     *
+     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.
+     *
+     * See usage example on this class itself.
+     */
+    onRangeElementToggled(index, event) {
+        if (this._isNonNegativeInteger(this._previousSelectedIndex) &&
+            this._isNonNegativeInteger(index) &&
+            (event === null || event === void 0 ? void 0 : event.shiftKey)) {
+            this._state = {
+                isRangeSelection: true,
+                from: Math.min(this._previousSelectedIndex, index),
+                to: Math.max(this._previousSelectedIndex, index)
+            };
+            this._previousSelectedIndex = index;
+        }
+        else if (this._isNonNegativeInteger(index)) {
+            this._state = { isRangeSelection: false, from: index, to: index };
+            this._previousSelectedIndex = index;
+        }
+        else {
+            this.reset();
+        }
+        return this.lastRangeSelectionState;
+    }
+    /**
+     * Allows to apply selection to each item in selection range.
+     * Accepts a function to apply selection to each item by registered index.
+     *
+     * See usage example on this class itself.
+     */
+    applyValueToEachInRange(selectionMethod) {
+        const state = this.lastRangeSelectionState;
+        if (this._isNonNegativeInteger(state === null || state === void 0 ? void 0 : state.from) && this._isNonNegativeInteger(state.to)) {
+            for (let index = state.from; index <= state.to; index++) {
+                selectionMethod(index);
+            }
+        }
+    }
+    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */
+    reset() {
+        this._state = null;
+        this._previousSelectedIndex = null;
+    }
+    /** @hidden */
+    _isNonNegativeInteger(num) {
+        return Number.isInteger(num) && num >= 0;
+    }
+}
+
 var ContentDensityEnum;
 (function (ContentDensityEnum) {
     ContentDensityEnum["COMPACT"] = "compact";
@@ -3009,5 +3122,5 @@ function applyMixins(derivedCtor, baseCtors) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANY_LANGUAGE_LETTERS_GROUP_REGEX, ANY_LANGUAGE_LETTERS_REGEX, AbstractFdNgxClass, AutoCompleteDirective, AutoCompleteModule, ContentDensityEnum, ContentDensityService, DECIMAL_NUMBER_UNICODE_GROUP_REGEX, DECIMAL_NUMBER_UNICODE_RANGE, DECIMAL_NUMBER_UNICODE_REGEX, DEFAULT_CONTENT_DENSITY, DefaultTruncateCharCount, DisplayFnPipe, DndItemDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective, DndListDirective, DragAndDropModule, DynamicComponentContainer, DynamicComponentInjector, DynamicComponentService, ELEMENT_REF_EXCEPTION, FocusKeyManagerHelpersModule, FocusKeyManagerItemDirective, FocusKeyManagerListDirective, FocusTrapService, INVALID_DATE_ERROR, InitialFocusDirective, InitialFocusModule, IsCompactDensityPipe, KeyUtil, KeyboardSupportService, LETTERS_UNICODE_RANGE, LIST_ITEM_COMPONENT, LineClampDirective, LineClampModule, LineClampTargetDirective, ListGroupPipe, MOBILE_CONFIG_ERROR, OVERFLOW_PRIORITY_SCORE, OnlyDigitsDirective, OnlyDigitsModule, OverflowListDirective, OverflowListItemDirective, OverflowListModule, PipeModule, RTL_LANGUAGE, ResizeDirective, ResizeHandleDirective, ResizeModule, RtlService, SafePipe, SearchHighlightPipe, THEME_SWITCHER_ROUTER_MISSING_ERROR, TemplateDirective, TemplateModule, ThemesService, TruncateDirective, TruncateModule, TwoDigitsPipe, UtilsModule, ValueByPathPipe, applyCssClass, applyCssStyle, applyMixins, getElementCapacity, getElementWidth, getRandomColorAccent, intersectionObservable, isCompactDensity, isValidContentDensity, parserFileSize, pxToNum, resizeObservable, scrollTop, toNativeElement, uuidv4 };
+export { ANY_LANGUAGE_LETTERS_GROUP_REGEX, ANY_LANGUAGE_LETTERS_REGEX, AbstractFdNgxClass, AutoCompleteDirective, AutoCompleteModule, ContentDensityEnum, ContentDensityService, DECIMAL_NUMBER_UNICODE_GROUP_REGEX, DECIMAL_NUMBER_UNICODE_RANGE, DECIMAL_NUMBER_UNICODE_REGEX, DEFAULT_CONTENT_DENSITY, DefaultTruncateCharCount, DisplayFnPipe, DndItemDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective, DndListDirective, DragAndDropModule, DynamicComponentContainer, DynamicComponentInjector, DynamicComponentService, ELEMENT_REF_EXCEPTION, FocusKeyManagerHelpersModule, FocusKeyManagerItemDirective, FocusKeyManagerListDirective, FocusTrapService, INVALID_DATE_ERROR, InitialFocusDirective, InitialFocusModule, IsCompactDensityPipe, KeyUtil, KeyboardSupportService, LETTERS_UNICODE_RANGE, LIST_ITEM_COMPONENT, LineClampDirective, LineClampModule, LineClampTargetDirective, ListGroupPipe, MOBILE_CONFIG_ERROR, OVERFLOW_PRIORITY_SCORE, OnlyDigitsDirective, OnlyDigitsModule, OverflowListDirective, OverflowListItemDirective, OverflowListModule, PipeModule, RTL_LANGUAGE, RangeSelector, ResizeDirective, ResizeHandleDirective, ResizeModule, RtlService, SafePipe, SearchHighlightPipe, THEME_SWITCHER_ROUTER_MISSING_ERROR, TemplateDirective, TemplateModule, ThemesService, TruncateDirective, TruncateModule, TwoDigitsPipe, UtilsModule, ValueByPathPipe, applyCssClass, applyCssStyle, applyMixins, getElementCapacity, getElementWidth, getRandomColorAccent, intersectionObservable, isCompactDensity, isValidContentDensity, parserFileSize, pxToNum, resizeObservable, scrollTop, toNativeElement, uuidv4 };
 //# sourceMappingURL=fundamental-ngx-core-utils.mjs.map