Merge branch 'angular-11' of https://github.com/IgniteUI/igniteui-angular into angular-11

Author: Lipata

package-lock.json

@@ -477,17 +477,34 @@
 }
 
 @function igx-generate-series-colors($palette) {
+    $color-blind: if(global-variable-exists('_igx-enhanced-accessibility'), $_igx-enhanced-accessibility, false);
+
+    @if $color-blind {
+        @return (
+            rgb(86, 180, 233),
+            rgb(0, 158, 115),
+            rgb(240, 228, 68),
+            rgb(213, 94, 0),
+            rgb(214, 0, 254),
+            rgb(0, 73, 159),
+            rgb(230, 159, 0),
+            rgb(0, 0, 0),
+            rgb(132, 240, 223),
+            rgb(115, 86, 86),
+        );
+    }
+
     @return (
-        igx-color($palette, 'primary'),
-        igx-color($palette, 'secondary'),
-        rgb(249, 98, 50),
-        rgb(60, 189, 201),
-        rgb(220, 63, 118),
-        rgb(255, 152, 0),
-        rgb(78, 98, 207),
-        rgb(84, 194, 90),
-        rgb(121, 85, 72),
-        rgb(154, 154, 154)
+        rgb(157, 231, 114),
+        rgb(139, 91, 177),
+        rgb(109, 177, 255),
+        rgb(154, 242, 228),
+        rgb(238, 88, 121),
+        rgb(115, 86, 86),
+        rgb(247, 210, 98),
+        rgb(168, 168, 183),
+        rgb(224, 81, 169),
+        rgb(248, 161, 95),
     );
 }
 

projects/igniteui-angular/src/lib/core/styles/base/utilities/_functions.scss

@@ -88,20 +88,24 @@
 
 /// @param {boolean} $print-layout [true] - Activates the printing styles of the components.
 /// @param {string} $direction [ltr] - Sets the layout direction. Can be 'ltr' or 'rtl'.
+/// @param {boolean} $enhanced-accesibility [false] - Switches component colors and other properties to more accessible values.
 /// @param {color} $foreground-color [0, 0, 0, .87] - Sets the value of the global $igx-foreground-color used in all typography styles.
 /// @requires {mixin} igx-typography
 /// @requires {mixin} igx-vhelper
 /// @requires {mixin} igx-print-layout
 @mixin igx-core(
     $print-layout: true,
     $direction: ltr,
+    $enhanced-accessibility: false
 ) {
     @if $direction != ltr and $direction != rtl {
         $direction: ltr !global;
     } @else {
         $direction: $direction !global;
     }
 
+    $_igx-enhanced-accessibility: $enhanced-accessibility !global;
+
     @include igx-typography();
     @include igx-vhelper();
 

projects/igniteui-angular/src/lib/core/styles/themes/_core.scss

@@ -103,6 +103,34 @@ export function cloneValue(value: any): any {
     return value;
 }
 
+/**
+ * Parse provided input to Date.
+ * @param value input to parse
+ * @returns Date if parse succeed or null
+ * @hidden
+ */
+export function parseDate(value: any): Date | null {
+    // if value is Invalid Date return null
+    if (isDate(value)) {
+        return !isNaN(value.getTime()) ? value : null;
+    }
+    return value ? new Date(value) : null;
+}
+
+/**
+ * Returns an array with unique dates only.
+ * @param columnValues collection of date values (might be numbers or ISO 8601 strings)
+ * @returns collection of unique dates.
+ * @hidden
+ */
+export function uniqueDates(columnValues: any[]) {
+    return columnValues.reduce((a, c) => {
+        if (!a.cache[c.label]) { a.result.push(c); }
+        a.cache[c.label] = true;
+        return a;
+      }, {result: [], cache: {}}).result;
+}
+
 /**
  * Checks if provided variable is Object
  * @param value Value to check
@@ -119,8 +147,8 @@ export function isObject(value: any): boolean {
  * @returns true if provided variable is Date
  * @hidden
  */
-export function isDate(value: any) {
-    return Object.prototype.toString.call(value) === '[object Date]';
+export function isDate(value: any): boolean {
+    return value instanceof Date;
 }
 
 /**
@@ -326,9 +354,9 @@ export interface CancelableBrowserEventArgs extends CancelableEventArgs {
     event?: Event;
 }
 
-export interface IBaseCancelableBrowserEventArgs extends CancelableBrowserEventArgs, IBaseEventArgs {}
+export interface IBaseCancelableBrowserEventArgs extends CancelableBrowserEventArgs, IBaseEventArgs { }
 
-export interface IBaseCancelableEventArgs extends CancelableEventArgs, IBaseEventArgs {}
+export interface IBaseCancelableEventArgs extends CancelableEventArgs, IBaseEventArgs { }
 
 export const HORIZONTAL_NAV_KEYS = new Set(['arrowleft', 'left', 'arrowright', 'right', 'home', 'end']);
 
@@ -349,7 +377,8 @@ export const NAVIGATION_KEYS = new Set([
 ]);
 export const ROW_EXPAND_KEYS = new Set('right down arrowright arrowdown'.split(' '));
 export const ROW_COLLAPSE_KEYS = new Set('left up arrowleft arrowup'.split(' '));
-export const SUPPORTED_KEYS = new Set([...Array.from(NAVIGATION_KEYS), 'enter', 'f2', 'escape', 'esc', 'pagedown', 'pageup', '+', 'add']);
+export const ROW_ADD_KEYS = new Set(['+', 'add', '≠', '±', '=']);
+export const SUPPORTED_KEYS = new Set([...Array.from(NAVIGATION_KEYS), ...Array.from(ROW_ADD_KEYS), 'enter', 'f2', 'escape', 'esc', 'pagedown', 'pageup']);
 export const HEADER_KEYS = new Set([...Array.from(NAVIGATION_KEYS), 'escape', 'esc' , 'l',
     /** This symbol corresponds to the Alt + L combination under MAC. */
     '¬']);
@@ -464,7 +493,7 @@ export function yieldingLoop(count: number, chunkSize: number, callback: (index:
     let i = 0;
     const chunk = () => {
         const end = Math.min(i + chunkSize, count);
-        for ( ; i < end; ++i) {
+        for (; i < end; ++i) {
             callback(i);
         }
         if (i < count) {

projects/igniteui-angular/src/lib/core/utils.ts

@@ -15,6 +15,7 @@ import { ITreeGridRecord } from '../grids/tree-grid/public_api';
 import { cloneValue, mergeObjects, mkenum } from '../core/utils';
 import { Transaction, TransactionType, HierarchicalTransaction } from '../services/transaction/transaction';
 import { getHierarchy, isHierarchyMatch } from './operations';
+import { GridType } from '../grids/common/grid.interface';
 
 /**
  * @hidden
@@ -31,25 +32,27 @@ export type DataType = (typeof DataType)[keyof typeof DataType];
  * @hidden
  */
 export class DataUtil {
-    public static sort<T>(data: T[], expressions: ISortingExpression[], sorting: IGridSortingStrategy = new IgxSorting()): T[] {
-        return sorting.sort(data, expressions);
+    public static sort<T>(data: T[], expressions: ISortingExpression[], sorting: IGridSortingStrategy = new IgxSorting(),
+        grid?: GridType): T[] {
+        return sorting.sort(data, expressions, grid);
     }
 
     public static treeGridSort(hierarchicalData: ITreeGridRecord[],
         expressions: ISortingExpression[],
         sorting: IGridSortingStrategy = new IgxDataRecordSorting(),
-        parent?: ITreeGridRecord): ITreeGridRecord[] {
+        parent?: ITreeGridRecord,
+        grid?: GridType): ITreeGridRecord[] {
         let res: ITreeGridRecord[] = [];
         hierarchicalData.forEach((hr: ITreeGridRecord) => {
             const rec: ITreeGridRecord = DataUtil.cloneTreeGridRecord(hr);
             rec.parent = parent;
             if (rec.children) {
-                rec.children = DataUtil.treeGridSort(rec.children, expressions, sorting, rec);
+                rec.children = DataUtil.treeGridSort(rec.children, expressions, sorting, rec, grid);
             }
             res.push(rec);
         });
 
-        res = DataUtil.sort(res, expressions, sorting);
+        res = DataUtil.sort(res, expressions, sorting, grid);
 
         return res;
     }
@@ -66,7 +69,7 @@ export class DataUtil {
         return rec;
     }
 
-    public static group<T>(data: T[], state: IGroupingState, grid: any = null,
+    public static group<T>(data: T[], state: IGroupingState, grid: GridType = null,
         groupsRecords: any[] = [], fullResult: IGroupByResult = { data: [], metadata: [] }): IGroupByResult {
         const grouping = new IgxGrouping();
         groupsRecords.splice(0, groupsRecords.length);
@@ -105,11 +108,11 @@ export class DataUtil {
         return data.slice(index * recordsPerPage, (index + 1) * recordsPerPage);
     }
 
-    public static filter<T>(data: T[], state: IFilteringState): T[] {
+    public static filter<T>(data: T[], state: IFilteringState, grid?: GridType): T[] {
         if (!state.strategy) {
             state.strategy = new FilteringStrategy();
         }
-        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree);
+        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree, grid);
     }
 
     public static correctPagingState(state: IPagingState, length: number) {

projects/igniteui-angular/src/lib/data-operations/data-util.ts

@@ -391,7 +391,7 @@ export class IgxDateFilteringOperand extends IgxFilteringOperand {
 
     protected findValueInSet(target: any, searchVal: Set<any>) {
         if (!target) { return false; }
-        return searchVal.has(new Date(target.getFullYear(), target.getMonth(), target.getDate()).toISOString());
+        return searchVal.has(target.toISOString());
     }
 }
 

projects/igniteui-angular/src/lib/data-operations/filtering-condition.ts

@@ -23,7 +23,7 @@ describe('Unit testing FilteringStrategy', () => {
                 searchVal: 1
             }
         ];
-        const res = fs.filter(data, expressionTree);
+        const res = fs.filter(data, expressionTree, null, null);
         expect(dataGenerator.getValuesForColumn(res, 'number'))
                     .toEqual([2, 3, 4]);
     });
@@ -65,7 +65,7 @@ describe('Unit testing FilteringStrategy', () => {
                 searchVal: 'ROW'
             }
         ];
-        const res = filterstr.filter(data, expressionTree);
+        const res = filterstr.filter(data, expressionTree, null, null);
         expect(dataGenerator.getValuesForColumn(res, 'number'))
                     .toEqual([0]);
     });

projects/igniteui-angular/src/lib/data-operations/filtering-strategy.spec.ts

@@ -1,9 +1,13 @@
 import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';
 import { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';
-import { resolveNestedPath } from '../core/utils';
+import { resolveNestedPath, parseDate } from '../core/utils';
+import { GridType } from '../grids/common/grid.interface';
+
+const DateType = 'date';
 
 export interface IFilteringStrategy {
-    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree): any[];
+    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree,
+        grid?: GridType): any[];
 }
 
 export class NoopFilteringStrategy implements IFilteringStrategy {
@@ -22,17 +26,17 @@ export class NoopFilteringStrategy implements IFilteringStrategy {
 
 export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
     public abstract filter(data: any[], expressionsTree: IFilteringExpressionsTree,
-        advancedExpressionsTree?: IFilteringExpressionsTree): any[];
+        advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridType): any[];
 
-    protected abstract getFieldValue(rec: object, fieldName: string): any;
+    protected abstract getFieldValue(rec: object, fieldName: string, isDate: boolean): any;
 
-    public findMatchByExpression(rec: object, expr: IFilteringExpression): boolean {
+    public findMatchByExpression(rec: object, expr: IFilteringExpression, isDate?: boolean): boolean {
         const cond = expr.condition;
-        const val = this.getFieldValue(rec, expr.fieldName);
+        const val = this.getFieldValue(rec, expr.fieldName, isDate);
         return cond.logic(val, expr.searchVal, expr.ignoreCase);
     }
 
-    public matchRecord(rec: object, expressions: IFilteringExpressionsTree | IFilteringExpression): boolean {
+    public matchRecord(rec: object, expressions: IFilteringExpressionsTree | IFilteringExpression, grid?: GridType): boolean {
         if (expressions) {
             if (expressions instanceof FilteringExpressionsTree) {
                 const expressionsTree = expressions as IFilteringExpressionsTree;
@@ -42,7 +46,7 @@ export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
                 if (expressionsTree.filteringOperands && expressionsTree.filteringOperands.length) {
                     for (let i = 0; i < expressionsTree.filteringOperands.length; i++) {
                         operand = expressionsTree.filteringOperands[i];
-                        matchOperand = this.matchRecord(rec, operand);
+                        matchOperand = this.matchRecord(rec, operand, grid);
 
                         // Return false if at least one operand does not match and the filtering logic is And
                         if (!matchOperand && operator === FilteringLogic.And) {
@@ -61,7 +65,9 @@ export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
                 return true;
             } else {
                 const expression = expressions as IFilteringExpression;
-                return this.findMatchByExpression(rec, expression);
+                const isDate = grid && grid.getColumnByName(expression.fieldName) ?
+                    grid.getColumnByName(expression.fieldName).dataType === DateType : false;
+                return this.findMatchByExpression(rec, expression, isDate);
             }
         }
 
@@ -78,7 +84,8 @@ export class FilteringStrategy extends BaseFilteringStrategy {
         return this._instace || (this._instace = new this());
     }
 
-    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree): T[] {
+    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree: IFilteringExpressionsTree,
+        grid: GridType): T[] {
         let i;
         let rec;
         const len = data.length;
@@ -88,14 +95,16 @@ export class FilteringStrategy extends BaseFilteringStrategy {
         }
         for (i = 0; i < len; i++) {
             rec = data[i];
-            if (this.matchRecord(rec, expressionsTree) && this.matchRecord(rec, advancedExpressionsTree)) {
+            if (this.matchRecord(rec, expressionsTree, grid) && this.matchRecord(rec, advancedExpressionsTree, grid)) {
                 res.push(rec);
             }
         }
         return res;
     }
 
-    protected getFieldValue(rec: object, fieldName: string): any {
-        return resolveNestedPath(rec, fieldName);
+    protected getFieldValue(rec: object, fieldName: string, isDate: boolean = false): any {
+        let value = resolveNestedPath(rec, fieldName);
+        value = value && isDate ? parseDate(value) : value;
+        return value;
     }
 }