Merge branch '21.1.x' into mkirova/fix-17005-21.1.x

Author: dkamburov

.github/workflows/trigger-licensed-release.yml

@@ -0,0 +1,39 @@
+name: Trigger Licensed Release
+
+permissions:
+  contents: read
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Release tag to dispatch (e.g. 21.1.1)'
+        required: true
+        type: string
+
+jobs:
+  dispatch-to-private-repo:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Get app token
+        id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.IGNITEUI_GITHUB_APP_ID }}
+          private-key: ${{ secrets.IGNITEUI_GITHUB_APP_PRIVATE_KEY }}
+          owner: IgniteUI
+
+      - name: Send repository dispatch to private repo
+        uses: peter-evans/repository-dispatch@ff45666b9427631e3450c54a1bcbee4d9ff4d7c0 # v3
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          repository: IgniteUI/igniteui-actions
+          event-type: igniteui-angular-public-release-created
+          client-payload: |
+            {
+              "release_tag": "${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || github.event.release.tag_name }}",
+              "public_repo": "${{ github.repository }}"
+            }

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes for each version of this project will be documented in this file.
 
+## 21.1.3
+
+### Security Fixes
+- Bumped `jspdf` dependency to `4.2.1` to address a security vulnerability present in earlier versions.
+
 ## 21.1.0
 
 ### New Features

package-lock.json

@@ -79,7 +79,7 @@
     "igniteui-i18n-core": "^1.0.2",
     "igniteui-theming": "^25.0.0",
     "igniteui-trial-watermark": "^3.1.0",
-    "jspdf": "^4.0.0",
+    "jspdf": "^4.2.1",
     "lodash-es": "^4.17.21",
     "marked": "^17.0.1",
     "marked-shiki": "^1.2.1",

package.json

@@ -1,5 +1,5 @@
 import { registerI18n, setCurrentI18n } from 'igniteui-i18n-core';
-import { ByLevelTreeGridMergeStrategy, ColumnPinningPosition, DefaultMergeStrategy, DefaultTreeGridMergeStrategy, FilteringExpressionsTree, FilteringExpressionsTreeType, FilteringLogic, HorizontalAlignment, IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand, NoopFilteringStrategy, NoopSortingStrategy, SortingDirection, VerticalAlignment } from 'igniteui-angular/core';
+import { ByLevelTreeGridMergeStrategy, ColumnPinningPosition, DefaultMergeStrategy, DefaultTreeGridMergeStrategy, FilteringExpressionsTree, FilteringExpressionsTreeType, FilteringLogic, HorizontalAlignment, IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand, NoopFilteringStrategy, NoopSortingStrategy, SortingDirection, TransactionType, TransactionEventOrigin, VerticalAlignment } from 'igniteui-angular/core';
 import { DropPosition, GridPagingMode, IgxDateSummaryOperand, IgxNumberSummaryOperand, IgxPivotAggregate, IgxPivotDateAggregate, IgxPivotDateDimension, IgxPivotNumericAggregate, IgxPivotTimeAggregate, IgxSummaryOperand, IgxTimeSummaryOperand, NoopPivotDimensionsStrategy, PivotDimensionType, RowPinningPosition } from 'igniteui-angular/grids/core';
 
 /** Export Public API, TODO: reorganize, Generate all w/ renames? */
@@ -49,4 +49,8 @@ export {
     // i18n
     registerI18n,
     setCurrentI18n,
+
+    // Transactions API
+    TransactionType,
+    TransactionEventOrigin,
 }

projects/igniteui-angular-elements/src/public_api.ts

@@ -1866,6 +1866,40 @@ describe('igxCombo', () => {
                     expect(document.activeElement).toEqual(combo.comboInput.nativeElement);
                     expect(combo.selection.length).toEqual(0);
                 }));
+                it('should stop Escape keydown event propagation when the dropdown is open', fakeAsync(() => {
+                    const escapeEvent = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true });
+                    spyOn(escapeEvent, 'stopPropagation');
+
+                    combo.comboInput.nativeElement.focus();
+                    fixture.detectChanges();
+
+                    combo.toggle();
+                    fixture.detectChanges();
+                    expect(combo.collapsed).toBeFalsy();
+
+                    combo.onEscape(escapeEvent);
+                    tick();
+                    fixture.detectChanges();
+
+                    expect(escapeEvent.stopPropagation).toHaveBeenCalled();
+                }));
+                it('should stop Escape key propagation when the combo is collapsed and has a selection', fakeAsync(() => {
+                    combo.comboInput.nativeElement.focus();
+                    fixture.detectChanges();
+
+                    combo.select([combo.data[0][combo.valueKey]]);
+                    expect(combo.selection.length).toEqual(1);
+                    fixture.detectChanges();
+
+                    const keyEvent = new KeyboardEvent('keydown', { key: 'Escape' });
+                    const stopPropSpy = spyOn(keyEvent, 'stopPropagation');
+
+                    combo.onEscape(keyEvent);
+                    tick();
+                    fixture.detectChanges();
+
+                    expect(stopPropSpy).toHaveBeenCalledTimes(1);
+                }));
                 it('should close the combo and preserve the focus when Escape key is pressed', fakeAsync(() => {
                     combo.comboInput.nativeElement.focus();
                     fixture.detectChanges();

projects/igniteui-angular/combo/src/combo/combo.component.spec.ts

@@ -187,6 +187,7 @@ export class IgxComboComponent extends IgxComboBaseDirective implements AfterVie
 
     @HostListener('keydown.Escape', ['$event'])
     public onEscape(event: Event) {
+        event.stopPropagation();
         if (this.collapsed) {
             this.deselectAllItems(true, event);
         }

projects/igniteui-angular/combo/src/combo/combo.component.ts

@@ -415,7 +415,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
     }
 
     public isScrollable() {
-        return this.scrollComponent.size > parseInt(this.igxForContainerSize, 10);
+        return this.scrollComponent.size > parseFloat(this.igxForContainerSize);
     }
 
     protected get embeddedViewNodes() {
@@ -583,8 +583,8 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         }
         const containerSize = 'igxForContainerSize';
         if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {
-            const prevSize = parseInt(changes[containerSize].previousValue, 10);
-            const newSize = parseInt(changes[containerSize].currentValue, 10);
+            const prevSize = parseFloat(changes[containerSize].previousValue);
+            const newSize = parseFloat(changes[containerSize].currentValue);
             this._recalcOnContainerChange({prevSize, newSize});
         }
     }
@@ -641,7 +641,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
             return false;
         }
         const originalVirtScrollTop = this._virtScrollPosition;
-        const containerSize = parseInt(this.igxForContainerSize, 10);
+        const containerSize = parseFloat(this.igxForContainerSize);
         const maxVirtScrollTop = this._virtSize - containerSize;
 
         this._bScrollInternal = true;
@@ -692,7 +692,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         if (index < 0 || index > (this.isRemote ? this.totalItemCount : this.igxForOf.length) - 1) {
             return;
         }
-        const containerSize = parseInt(this.igxForContainerSize, 10);
+        const containerSize = parseFloat(this.igxForContainerSize);
         const isPrevItem = index < this.state.startIndex || this.scrollPosition > this.sizesCache[index];
         let nextScroll = isPrevItem ? this.sizesCache[index] : this.sizesCache[index + 1] - containerSize;
         if (nextScroll < 0) {
@@ -717,7 +717,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
      */
     public scrollNext() {
         const scr = Math.abs(Math.ceil(this.scrollPosition));
-        const endIndex = this.getIndexAt(scr + parseInt(this.igxForContainerSize, 10), this.sizesCache);
+        const endIndex = this.getIndexAt(scr + parseFloat(this.igxForContainerSize), this.sizesCache);
         this.scrollTo(endIndex);
     }
 
@@ -740,7 +740,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
      * ```
      */
     public scrollNextPage() {
-        this.addScroll(parseInt(this.igxForContainerSize, 10));
+        this.addScroll(parseFloat(this.igxForContainerSize));
     }
 
     /**
@@ -751,7 +751,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
      * ```
      */
     public scrollPrevPage() {
-        const containerSize = (parseInt(this.igxForContainerSize, 10));
+        const containerSize = (parseFloat(this.igxForContainerSize));
         this.addScroll(-containerSize);
     }
 
@@ -774,7 +774,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
             // fisrt item is not fully in view
             startIndex++;
         }
-        const endIndex = this.getIndexAt(this.scrollPosition + parseInt(this.igxForContainerSize, 10), this.sizesCache);
+        const endIndex = this.getIndexAt(this.scrollPosition + parseFloat(this.igxForContainerSize), this.sizesCache);
         return endIndex - startIndex;
     }
 
@@ -813,7 +813,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
      * ```
      */
     public getScrollForIndex(index: number, bottom?: boolean) {
-        const containerSize = parseInt(this.igxForContainerSize, 10);
+        const containerSize = parseFloat(this.igxForContainerSize);
         const scroll = bottom ? Math.max(0, this.sizesCache[index + 1] - containerSize) : this.sizesCache[index];
         return scroll;
     }
@@ -837,7 +837,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         const targetNode = index >= this.state.startIndex && index <= this.state.startIndex + this.state.chunkSize ?
             this.embeddedViewNodes[index - this.state.startIndex] : null;
         const rowHeight = this.getSizeAt(index);
-        const containerSize = parseInt(this.igxForContainerSize, 10);
+        const containerSize = parseFloat(this.igxForContainerSize);
         const containerOffset = -(this.scrollPosition - this.sizesCache[this.state.startIndex]);
         const endTopOffset = targetNode ? targetNode.offsetTop + rowHeight + containerOffset : containerSize + rowHeight;
         return !targetNode || targetNode.offsetTop < Math.abs(containerOffset)
@@ -897,7 +897,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
             }
             const scrToBottom = this._isScrolledToBottom && !this.dc.instance.notVirtual;
             if (scrToBottom && !this._isAtBottomIndex) {
-                const containerSize = parseInt(this.igxForContainerSize, 10);
+                const containerSize = parseFloat(this.igxForContainerSize);
                 const maxVirtScrollTop = this._virtSize - containerSize;
                 this._bScrollInternal = true;
                 this._virtScrollPosition = maxVirtScrollTop;
@@ -946,7 +946,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
      */
     protected onScroll(event) {
         /* in certain situations this may be called when no scrollbar is visible */
-        if (!parseInt(this.scrollComponent.nativeElement.style.height, 10)) {
+        if (!parseFloat(this.scrollComponent.nativeElement.style.height)) {
             return;
         }
         this.scrollComponent.scrollAmount = event.target.scrollTop;
@@ -1153,7 +1153,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
     protected onHScroll(event) {
         /* in certain situations this may be called when no scrollbar is visible */
         const firstScrollChild = this.scrollComponent.nativeElement.children.item(0) as HTMLElement;
-        if (!parseInt(firstScrollChild.style.width, 10)) {
+        if (!parseFloat(firstScrollChild.style.width)) {
             return;
         }
         this.scrollComponent.scrollAmount = event.target.scrollLeft;
@@ -1326,7 +1326,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         let maxLength = 0;
         const arr = [];
         let sum = 0;
-        const availableSize = parseInt(this.igxForContainerSize, 10);
+        const availableSize = parseFloat(this.igxForContainerSize);
         if (!availableSize) {
             return 0;
         }
@@ -1356,7 +1356,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
                         const prevItem = this.igxForOf[prevIndex];
                         const prevSize = dimension === 'height' ?
                             this.individualSizeCache[prevIndex] :
-                            parseInt(prevItem[dimension], 10);
+                            parseFloat(prevItem[dimension]);
                         sum = arr.reduce(reducer, prevSize);
                         arr.unshift(prevItem);
                         length = arr.length;
@@ -1403,19 +1403,19 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         this.dc.instance.notVirtual = !(this.igxForContainerSize && this.dc && this.state.chunkSize < count);
         const scrollable = containerSizeInfo ? this.scrollComponent.size > containerSizeInfo.prevSize : this.isScrollable();
         if (this.igxForScrollOrientation === 'horizontal') {
-            const totalWidth = parseInt(this.igxForContainerSize, 10) > 0 ? this._calcSize() : 0;
-            if (totalWidth <= parseInt(this.igxForContainerSize, 10)) {
+            const totalWidth = parseFloat(this.igxForContainerSize) > 0 ? this._calcSize() : 0;
+            if (totalWidth <= parseFloat(this.igxForContainerSize)) {
                 this.resetScrollPosition();
             }
             this.scrollComponent.nativeElement.style.width = this.igxForContainerSize + 'px';
             this.scrollComponent.size = totalWidth;
         }
         if (this.igxForScrollOrientation === 'vertical') {
             const totalHeight = this._calcSize();
-            if (totalHeight <= parseInt(this.igxForContainerSize, 10)) {
+            if (totalHeight <= parseFloat(this.igxForContainerSize)) {
                 this.resetScrollPosition();
             }
-            this.scrollComponent.nativeElement.style.height = parseInt(this.igxForContainerSize, 10) + 'px';
+            this.scrollComponent.nativeElement.style.height = parseFloat(this.igxForContainerSize) + 'px';
             this.scrollComponent.size = totalHeight;
         }
         if (scrollable !== this.isScrollable()) {
@@ -1512,7 +1512,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
     }
 
     protected _calcVirtualScrollPosition(scrollPosition: number) {
-        const containerSize = parseInt(this.igxForContainerSize, 10);
+        const containerSize = parseFloat(this.igxForContainerSize);
         const maxRealScrollPosition = this.scrollComponent.size - containerSize;
         const realPercentScrolled = maxRealScrollPosition !== 0 ? scrollPosition / maxRealScrollPosition : 0;
         const maxVirtScroll = this._virtSize - containerSize;
@@ -1521,7 +1521,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
 
     protected _getItemSize(item, dimension: string): number {
         const dim = item ? item[dimension] : null;
-        return typeof dim === 'number' ? dim : parseInt(this.igxForItemSize, 10) || 0;
+        return typeof dim === 'number' ? dim : parseFloat(this.igxForItemSize) || 0;
     }
 
     protected _updateScrollOffset() {
@@ -1545,7 +1545,7 @@ export class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T,U
         // should update scroll top/left according to change so that same startIndex is in view
         if (Math.abs(sizeDiff) > 0 && this.scrollPosition > 0) {
             const offset = this.igxForScrollOrientation === 'horizontal' ?
-                parseInt(this.dc.instance._viewContainer.element.nativeElement.style.left, 10) :
+                parseFloat(this.dc.instance._viewContainer.element.nativeElement.style.left) :
                 Number(this.dc.instance._viewContainer.element.nativeElement.style.transform?.match(/translateY\((-?\d+\.?\d*)px\)/)?.[1]);
             const newSize = this.sizesCache[this.state.startIndex] - offset;
             this.scrollPosition = newSize;
@@ -1706,8 +1706,8 @@ export class IgxGridForOfDirective<T, U extends T[] = T[]> extends IgxForOfDirec
         }
         const containerSize = 'igxForContainerSize';
         if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {
-            const prevSize = parseInt(changes[containerSize].previousValue, 10);
-            const newSize = parseInt(changes[containerSize].currentValue, 10);
+            const prevSize = parseFloat(changes[containerSize].previousValue);
+            const newSize = parseFloat(changes[containerSize].currentValue);
             this._recalcOnContainerChange({prevSize, newSize});
         }
     }
@@ -1781,7 +1781,7 @@ export class IgxGridForOfDirective<T, U extends T[] = T[]> extends IgxForOfDirec
     public override onHScroll(scrollAmount) {
         /* in certain situations this may be called when no scrollbar is visible */
         const firstScrollChild = this.scrollComponent.nativeElement.children.item(0) as HTMLElement;
-        if (!this.scrollComponent || !parseInt(firstScrollChild.style.width, 10)) {
+        if (!this.scrollComponent || !parseFloat(firstScrollChild.style.width)) {
             return;
         }
         this.scrollComponent.scrollAmount = scrollAmount;
@@ -1807,7 +1807,7 @@ export class IgxGridForOfDirective<T, U extends T[] = T[]> extends IgxForOfDirec
                 size = item.height;
             }
         } else {
-            size = parseInt(item[dimension], 10) || 0;
+            size = parseFloat(item[dimension]) || 0;
         }
         return size;
     }
@@ -1836,7 +1836,7 @@ export class IgxGridForOfDirective<T, U extends T[] = T[]> extends IgxForOfDirec
     protected override getNodeSize(rNode: Element, index?: number): number {
         if (this.igxForScrollOrientation === 'vertical') {
             const view = this._embeddedViews[index];
-            return this._embeddedViewSizesCache.get(view) || parseInt(this.igxForItemSize, 10);
+            return this._embeddedViewSizesCache.get(view) || parseFloat(this.igxForItemSize);
         } else {
             return super.getNodeSize(rNode, index);
         }