@adaptabletools/adaptable 16.2.4 → 17.0.0-canary.1

package/src/PredefinedConfig/Common/AdaptablePredicate.js

@@ -1,48 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemBadgeStylePredicateIds = exports.SystemFlashingCellPredicateIds = exports.SystemFormatColumnPredicateIds = exports.SystemAlertPredicateIds = exports.SystemFilterPredicateIds = exports.SystemPredicateDefs = void 0;
-const tslib_1 = require("tslib");
-const isAfter_1 = tslib_1.__importDefault(require("date-fns/isAfter"));
-const isBefore_1 = tslib_1.__importDefault(require("date-fns/isBefore"));
-const isEqual_1 = tslib_1.__importDefault(require("date-fns/isEqual"));
-const isFuture_1 = tslib_1.__importDefault(require("date-fns/isFuture"));
-const isPast_1 = tslib_1.__importDefault(require("date-fns/isPast"));
-const isSameDay_1 = tslib_1.__importDefault(require("date-fns/isSameDay"));
-const isThisMonth_1 = tslib_1.__importDefault(require("date-fns/isThisMonth"));
-const isThisQuarter_1 = tslib_1.__importDefault(require("date-fns/isThisQuarter"));
-const isThisWeek_1 = tslib_1.__importDefault(require("date-fns/isThisWeek"));
-const isThisYear_1 = tslib_1.__importDefault(require("date-fns/isThisYear"));
-const isToday_1 = tslib_1.__importDefault(require("date-fns/isToday"));
-const isTomorrow_1 = tslib_1.__importDefault(require("date-fns/isTomorrow"));
-const isYesterday_1 = tslib_1.__importDefault(require("date-fns/isYesterday"));
-const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
-const DateHelper_1 = require("../../Utilities/Helpers/DateHelper");
-const Helper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/Helper"));
-const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import isEqual from 'date-fns/isEqual';
+import isFuture from 'date-fns/isFuture';
+import isPast from 'date-fns/isPast';
+import isSameDay from 'date-fns/isSameDay';
+import isThisMonth from 'date-fns/isThisMonth';
+import isThisQuarter from 'date-fns/isThisQuarter';
+import isThisWeek from 'date-fns/isThisWeek';
+import isThisYear from 'date-fns/isThisYear';
+import isToday from 'date-fns/isToday';
+import isTomorrow from 'date-fns/isTomorrow';
+import isYesterday from 'date-fns/isYesterday';
+import StringExtensions from '../../Utilities/Extensions/StringExtensions';
+import { parseDateValue } from '../../Utilities/Helpers/DateHelper';
+import Helper from '../../Utilities/Helpers/Helper';
+import { BLANK_DISTINCT_COLUMN_VALUE } from '../../Utilities/Constants/GeneralConstants';
 /**
  * Array of Predicate Defs which are shipped by AdapTable
  */
-exports.SystemPredicateDefs = [
+export const SystemPredicateDefs = [
     {
         id: 'Values',
         label: 'Values',
         icon: { text: 'IN' },
         columnScope: { DataTypes: ['String', 'Number', 'Date'] },
-        moduleScope: ['filter', 'formatColumn', 'alert', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'flashingcell', 'formatColumn', 'alert', 'badgeStyle'],
         handler: ({ inputs, column, value, adaptableApi }) => {
             if (inputs.length === 0) {
                 return true;
             }
-            if (inputs.includes(GeneralConstants_1.BLANK_DISTINCT_COLUMN_VALUE) && Helper_1.default.isInputNullOrEmpty(value)) {
+            if (inputs.includes(BLANK_DISTINCT_COLUMN_VALUE) && Helper.isInputNullOrEmpty(value)) {
                 return true;
             }
             if (column.dataType === 'Date') {
                 return inputs.some((input) => {
-                    if (adaptableApi.optionsApi.getFilterOptions().filterUsingTime) {
-                        return (0, isEqual_1.default)(input, value);
+                    if (adaptableApi.optionsApi.getColumnFilterOptions().valuesFilterOptions.filterValuesUsingTime) {
+                        return isEqual(input, value);
                     }
                     else {
-                        return (0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(input), (0, DateHelper_1.parseDateValue)(value));
+                        return isSameDay(parseDateValue(input), parseDateValue(value));
                     }
                 });
             }
@@ -68,24 +64,24 @@ exports.SystemPredicateDefs = [
         label: 'Exclude Values',
         icon: { text: '!IN' },
         columnScope: { DataTypes: ['String', 'Number', 'Date'] },
-        moduleScope: ['filter', 'formatColumn', 'alert', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'flashingcell', 'formatColumn', 'alert', 'badgeStyle'],
         handler: ({ inputs, column, value, adaptableApi }) => {
             // basically negation of IN
             if (inputs.length === 0) {
                 return true;
             }
-            if (inputs.includes(GeneralConstants_1.BLANK_DISTINCT_COLUMN_VALUE) && Helper_1.default.isInputNullOrEmpty(value)) {
+            if (inputs.includes(BLANK_DISTINCT_COLUMN_VALUE) && Helper.isInputNullOrEmpty(value)) {
                 return false;
             }
             if (column.dataType === 'Date') {
-                if (adaptableApi.optionsApi.getFilterOptions().filterUsingTime) {
+                if (adaptableApi.optionsApi.getColumnFilterOptions().valuesFilterOptions.filterValuesUsingTime) {
                     return inputs.every((input) => {
-                        return !(0, isEqual_1.default)(input, value);
+                        return !isEqual(input, value);
                     });
                 }
                 else {
                     return inputs.every((input) => {
-                        return !(0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(input), (0, DateHelper_1.parseDateValue)(value));
+                        return !isSameDay(parseDateValue(input), parseDateValue(value));
                     });
                 }
             }
@@ -110,16 +106,16 @@ exports.SystemPredicateDefs = [
         label: 'Blanks',
         icon: { name: 'unfilled-circle' },
         columnScope: { All: true },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
-        handler: ({ value }) => Helper_1.default.isInputNullOrEmpty(value),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        handler: ({ value }) => Helper.isInputNullOrEmpty(value),
     },
     {
         id: 'NonBlanks',
         label: 'Non Blanks',
         icon: { name: 'filled-circle' },
         columnScope: { All: true },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
-        handler: ({ value }) => Helper_1.default.isInputNotNullOrEmpty(value),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        handler: ({ value }) => Helper.isInputNotNullOrEmpty(value),
     },
     // Numeric System Filters
     {
@@ -127,7 +123,7 @@ exports.SystemPredicateDefs = [
         label: 'Greater Than',
         icon: { name: 'greater-than' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }],
         handler: ({ value, inputs }) => Number(value) > Number(inputs[0]),
         toString: ({ inputs }) => `> ${inputs[0]}`,
@@ -138,7 +134,7 @@ exports.SystemPredicateDefs = [
         label: 'Less Than',
         icon: { name: 'less-than' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }],
         handler: ({ value, inputs }) => Number(value) < Number(inputs[0]),
         toString: ({ inputs }) => `< ${inputs[0]}`,
@@ -149,7 +145,7 @@ exports.SystemPredicateDefs = [
         label: 'Positive',
         icon: { text: '>0' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         handler: ({ value }) => Number(value) > 0,
     },
     {
@@ -157,7 +153,7 @@ exports.SystemPredicateDefs = [
         label: 'Negative',
         icon: { text: '<0' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         handler: ({ value }) => Number(value) < 0,
     },
     {
@@ -165,12 +161,12 @@ exports.SystemPredicateDefs = [
         label: 'Zero',
         icon: { text: '=0' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         handler: ({ value }) => {
-            if (typeof value === 'string' && !StringExtensions_1.default.IsNumeric(value)) {
+            if (typeof value === 'string' && !StringExtensions.IsNumeric(value)) {
                 return false;
             }
-            if (Helper_1.default.objectNotExists(value)) {
+            if (Helper.objectNotExists(value)) {
                 return false;
             }
             return Number(value) === 0;
@@ -181,12 +177,12 @@ exports.SystemPredicateDefs = [
         label: 'Equals',
         icon: { name: 'equals' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }],
         handler: ({ value, inputs }) => {
             const input = inputs[0];
-            if ((typeof value === 'string' && !StringExtensions_1.default.IsNumeric(value)) ||
-                (typeof input === 'string' && !StringExtensions_1.default.IsNumeric(input))) {
+            if ((typeof value === 'string' && !StringExtensions.IsNumeric(value)) ||
+                (typeof input === 'string' && !StringExtensions.IsNumeric(input))) {
                 return false;
             }
             return Number(value) === Number(inputs[0]);
@@ -199,12 +195,12 @@ exports.SystemPredicateDefs = [
         label: 'Not Equals',
         icon: { name: 'not-equal' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }],
         handler: ({ value, inputs }) => {
             const input = inputs[0];
-            if ((typeof value === 'string' && !StringExtensions_1.default.IsNumeric(value)) ||
-                (typeof input === 'string' && !StringExtensions_1.default.IsNumeric(input))) {
+            if ((typeof value === 'string' && !StringExtensions.IsNumeric(value)) ||
+                (typeof input === 'string' && !StringExtensions.IsNumeric(input))) {
                 return false;
             }
             return Number(value) !== Number(inputs[0]);
@@ -217,7 +213,7 @@ exports.SystemPredicateDefs = [
         label: 'Between',
         icon: { text: 'BE' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }, { type: 'number' }],
         handler: ({ value, inputs }) => Number(value) >= Number(inputs[0]) && Number(value) <= Number(inputs[1]),
         toString: ({ inputs }) => `Between ${inputs[0]}:${inputs[1]}`,
@@ -228,7 +224,7 @@ exports.SystemPredicateDefs = [
         label: 'Not Between',
         icon: { text: '!BE' },
         columnScope: { DataTypes: ['Number'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'number' }, { type: 'number' }],
         handler: ({ value, inputs }) => Number(value) < Number(inputs[0]) || Number(value) > Number(inputs[1]),
         toString: ({ inputs }) => `Not Between ${inputs[0]}:${inputs[1]}`,
@@ -256,7 +252,7 @@ exports.SystemPredicateDefs = [
         label: 'Equals',
         icon: { name: 'equals' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -275,7 +271,7 @@ exports.SystemPredicateDefs = [
         label: 'Not Equals',
         icon: { name: 'not-equal' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -294,7 +290,7 @@ exports.SystemPredicateDefs = [
         label: 'Contains',
         icon: { name: 'contains' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -312,7 +308,7 @@ exports.SystemPredicateDefs = [
         label: 'Not Contains',
         icon: { name: 'not-contains' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -330,7 +326,7 @@ exports.SystemPredicateDefs = [
         label: 'Starts With',
         icon: { name: 'starts-with' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -348,7 +344,7 @@ exports.SystemPredicateDefs = [
         label: 'Ends With',
         icon: { name: 'ends-with' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs, adaptableApi }) => {
             if (!value) {
@@ -366,7 +362,7 @@ exports.SystemPredicateDefs = [
         label: 'Regex',
         icon: { name: 'regex' },
         columnScope: { DataTypes: ['String'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
         handler: ({ value, inputs }) => new RegExp(inputs[0]).test(value),
         toString: ({ inputs }) => `Regex ${inputs[0]}`,
@@ -377,81 +373,81 @@ exports.SystemPredicateDefs = [
         label: 'Today',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isToday_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isToday(parseDateValue(value)),
     },
     {
         id: 'Yesterday',
         label: 'Yesterday',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isYesterday_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isYesterday(parseDateValue(value)),
     },
     {
         id: 'Tomorrow',
         label: 'Tomorrow',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isTomorrow_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isTomorrow(parseDateValue(value)),
     },
     {
         id: 'ThisWeek',
         label: 'This Week',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isThisWeek_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isThisWeek(parseDateValue(value)),
     },
     {
         id: 'ThisMonth',
         label: 'This Month',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isThisMonth_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isThisMonth(parseDateValue(value)),
     },
     {
         id: 'ThisQuarter',
         label: 'This Quarter',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isThisQuarter_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isThisQuarter(parseDateValue(value)),
     },
     {
         id: 'ThisYear',
         label: 'This Year',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isThisYear_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isThisYear(parseDateValue(value)),
     },
     {
         id: 'InPast',
         label: 'In Past',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isPast_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isPast(parseDateValue(value)),
     },
     {
         id: 'InFuture',
         label: 'In Future',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value }) => (0, isFuture_1.default)((0, DateHelper_1.parseDateValue)(value)),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value }) => isFuture(parseDateValue(value)),
     },
     {
         id: 'After',
         label: 'After',
         icon: { name: 'greater-than' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         inputs: [{ type: 'date' }],
-        handler: ({ value, inputs }) => (0, isAfter_1.default)((0, DateHelper_1.parseDateValue)(value), (0, DateHelper_1.parseDateValue)(inputs[0])),
+        handler: ({ value, inputs }) => isAfter(parseDateValue(value), parseDateValue(inputs[0])),
         toString: ({ inputs }) => `> ${inputs[0]}`,
     },
     {
@@ -459,9 +455,9 @@ exports.SystemPredicateDefs = [
         label: 'Before',
         icon: { name: 'less-than' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         inputs: [{ type: 'date' }],
-        handler: ({ value, inputs }) => (0, isBefore_1.default)((0, DateHelper_1.parseDateValue)(value), (0, DateHelper_1.parseDateValue)(inputs[0])),
+        handler: ({ value, inputs }) => isBefore(parseDateValue(value), parseDateValue(inputs[0])),
         toString: ({ inputs }) => `< ${inputs[0]}`,
     },
     {
@@ -469,9 +465,9 @@ exports.SystemPredicateDefs = [
         label: 'Equals',
         icon: { name: 'equals' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         inputs: [{ type: 'date' }],
-        handler: ({ value, inputs }) => (0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(value), (0, DateHelper_1.parseDateValue)(inputs[0])),
+        handler: ({ value, inputs }) => isSameDay(parseDateValue(value), parseDateValue(inputs[0])),
         toString: ({ inputs }) => `= ${inputs[0]}`,
     },
     {
@@ -479,9 +475,9 @@ exports.SystemPredicateDefs = [
         label: 'NotEquals',
         icon: { name: 'not-equal' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         inputs: [{ type: 'date' }],
-        handler: ({ value, inputs }) => !(0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(value), (0, DateHelper_1.parseDateValue)(inputs[0])),
+        handler: ({ value, inputs }) => !isSameDay(parseDateValue(value), parseDateValue(inputs[0])),
         toString: ({ inputs }) => `!= ${inputs[0]}`,
     },
     {
@@ -489,23 +485,23 @@ exports.SystemPredicateDefs = [
         label: 'Next Work Day',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value, adaptableApi }) => (0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(value), adaptableApi.calendarApi.getNextWorkingDay()),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value, adaptableApi }) => isSameDay(parseDateValue(value), adaptableApi.calendarApi.getNextWorkingDay()),
     },
     {
         id: 'LastWorkDay',
         label: 'Last Work Day',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
-        handler: ({ value, adaptableApi }) => (0, isSameDay_1.default)((0, DateHelper_1.parseDateValue)(value), adaptableApi.calendarApi.getPreviousWorkingDay()),
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
+        handler: ({ value, adaptableApi }) => isSameDay(parseDateValue(value), adaptableApi.calendarApi.getPreviousWorkingDay()),
     },
     {
         id: 'WorkDay',
         label: 'Working Day',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         handler: ({ value, adaptableApi }) => adaptableApi.calendarApi.isWorkingDay(value),
     },
     {
@@ -513,7 +509,7 @@ exports.SystemPredicateDefs = [
         label: 'Holiday',
         icon: { name: 'calendar' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         handler: ({ value, adaptableApi }) => adaptableApi.calendarApi.isHoliday(value),
     },
     {
@@ -521,7 +517,7 @@ exports.SystemPredicateDefs = [
         label: 'Range',
         icon: { name: 'date-range' },
         columnScope: { DataTypes: ['Date'] },
-        moduleScope: ['filter'],
+        moduleScope: ['columnFilter'],
         inputs: [{ type: 'date' }, { type: 'date' }],
         handler: ({ value, inputs }) => new Date(value) >= new Date(inputs[0]) && new Date(value) <= new Date(inputs[1]),
     },
@@ -531,7 +527,7 @@ exports.SystemPredicateDefs = [
         label: 'True',
         icon: { text: 'T' },
         columnScope: { DataTypes: ['Boolean'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         handler: ({ value }) => Boolean(value) === true,
     },
     {
@@ -539,7 +535,7 @@ exports.SystemPredicateDefs = [
         label: 'False',
         icon: { text: 'F' },
         columnScope: { DataTypes: ['Boolean'] },
-        moduleScope: ['filter', 'alert', 'flashingcell', 'formatColumn'],
+        moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn'],
         handler: ({ value }) => Boolean(value) === false,
     },
     {
@@ -547,9 +543,9 @@ exports.SystemPredicateDefs = [
         label: 'BooleanToggle',
         icon: { name: 'boolean-list' },
         columnScope: { DataTypes: ['Boolean'] },
-        moduleScope: ['filter'],
+        moduleScope: ['columnFilter'],
         inputs: [{ type: 'boolean' }],
-        // working with string aliases instead of booleans because the FilterAPI cannot handle falsy filter values (it ignores them)
+        // working with string aliases instead of booleans because the ColumnFilterAPI cannot handle falsy filter values (it ignores them)
         handler: ({ value, inputs }) => {
             if (inputs[0] == 'all') {
                 // if it's indeterminate, all values (true&false) are matched
@@ -561,7 +557,7 @@ exports.SystemPredicateDefs = [
     },
     // Other System Filters
     {
-        id: 'Any',
+        id: 'AnyChange',
         label: 'Any Change',
         columnScope: { All: true },
         moduleScope: ['alert', 'flashingcell'],
@@ -580,19 +576,6 @@ exports.SystemPredicateDefs = [
             return (change / base) * 100 > threshold;
         },
     },
-    {
-        id: 'PrimaryKeyDuplicate',
-        label: 'Primary Key Duplicate',
-        columnScope: { All: true },
-        moduleScope: ['alert'],
-        handler: ({ value, column, adaptableApi, node }) => {
-            return (column === null || column === void 0 ? void 0 : column.isPrimaryKey)
-                ? adaptableApi.gridApi.internalApi
-                    .getDistinctRawValuesForColumn(column.columnId, node)
-                    .includes(value)
-                : false;
-        },
-    },
     {
         id: 'ExistingValuesOnly',
         label: 'Existing Values Only',
@@ -638,8 +621,8 @@ exports.SystemPredicateDefs = [
         },
     },
 ];
-exports.SystemFilterPredicateIds = exports.SystemPredicateDefs.filter((p) => p.moduleScope.includes('filter')).map((p) => p.id);
-exports.SystemAlertPredicateIds = exports.SystemPredicateDefs.filter((p) => p.moduleScope.includes('alert')).map((p) => p.id);
-exports.SystemFormatColumnPredicateIds = exports.SystemPredicateDefs.filter((p) => p.moduleScope.includes('formatColumn')).map((p) => p.id);
-exports.SystemFlashingCellPredicateIds = exports.SystemPredicateDefs.filter((p) => p.moduleScope.includes('flashingcell')).map((p) => p.id);
-exports.SystemBadgeStylePredicateIds = exports.SystemPredicateDefs.filter((p) => p.moduleScope.includes('badgeStyle')).map((p) => p.id);
+export const SystemFilterPredicateIds = SystemPredicateDefs.filter((p) => p.moduleScope.includes('columnFilter')).map((p) => p.id);
+export const SystemAlertPredicateIds = SystemPredicateDefs.filter((p) => p.moduleScope.includes('alert')).map((p) => p.id);
+export const SystemFormatColumnPredicateIds = SystemPredicateDefs.filter((p) => p.moduleScope.includes('formatColumn')).map((p) => p.id);
+export const SystemFlashingCellPredicateIds = SystemPredicateDefs.filter((p) => p.moduleScope.includes('flashingcell')).map((p) => p.id);
+export const SystemBadgeStylePredicateIds = SystemPredicateDefs.filter((p) => p.moduleScope.includes('badgeStyle')).map((p) => p.id);

package/src/PredefinedConfig/Common/AdaptableQuery.d.ts

@@ -3,34 +3,49 @@ import { XOR } from '../../Utilities/Extensions/TypeExtensions';
  * Wraps an AdapTableQL Boolean Expression
  */
 export interface AdaptableBooleanQuery {
+    /**
+     * AdapTableQL Expression that returns true / false
+     */
     BooleanExpression: string;
 }
 /**
  * Wraps an AdapTableQL Scalar Expression
  */
 export interface AdaptableScalarQuery {
+    /**
+     * AdapTableQL Expression that returns any value
+     */
     ScalarExpression: string;
 }
 /**
  * Wraps an AdapTableQL Observable Expression
  */
 export interface AdaptableObservableQuery {
+    /**
+     * AdapTableQL Expression that observes the Grid or given rows
+     */
     ObservableExpression: string;
 }
 /**
  * Wraps an AdapTableQL Aggregated Boolean Expression
  */
 export interface AdaptableAggregatedBooleanQuery {
+    /**
+     * AdapTableQL Expression that returns true / false based on multiple rows
+     */
     AggregatedBooleanExpression: string;
 }
 /**
  * Wraps an AdapTableQL Aggregated Scalar Expression
  */
 export interface AdaptableAggregatedScalarQuery {
+    /**
+     * AdapTableQL Expression that returns any value based on multiple rows
+     */
     AggregatedScalarExpression: string;
 }
 /**
  * An AdaptableQuery can be either a Boolean, Scalar, Observable, AggregatedBoolean, or AggregatedScalar expression
  */
-export declare type AdaptableQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableScalarQuery, XOR<AdaptableObservableQuery, XOR<AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery>>>>;
+export type AdaptableQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableScalarQuery, XOR<AdaptableObservableQuery, XOR<AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery>>>>;
 export declare const isReactiveQuery: (query: Partial<AdaptableQuery>) => boolean;

package/src/PredefinedConfig/Common/AdaptableQuery.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReactiveQuery = void 0;
-const isReactiveQuery = (query) => {
+export const isReactiveQuery = (query) => {
     return !!query.ObservableExpression;
 };
-exports.isReactiveQuery = isReactiveQuery;

package/src/PredefinedConfig/Common/AdaptableScope.d.ts

@@ -1,14 +1,14 @@
-export declare type ScopeDataType = 'String' | 'Number' | 'Boolean' | 'Date';
-export declare type ScopeAll = {
+export type ScopeDataType = 'String' | 'Number' | 'Boolean' | 'Date';
+export type ScopeAll = {
     All: true;
 };
-export declare type ScopeDataTypes<Type = ScopeDataType> = {
+export type ScopeDataTypes<Type = ScopeDataType> = {
     DataTypes: Type[];
 };
-export declare type ScopeColumnIds = {
+export type ScopeColumnIds = {
     ColumnIds: string[];
 };
 /**
  * Defines where a given Object / Module is active
  */
-export declare type AdaptableScope<Type = ScopeDataType> = ScopeAll | ScopeDataTypes<Type> | ScopeColumnIds;
+export type AdaptableScope<Type = ScopeDataType> = ScopeAll | ScopeDataTypes<Type> | ScopeColumnIds;

package/src/PredefinedConfig/Common/AdaptableScope.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/src/PredefinedConfig/Common/AdaptableStyle.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/src/PredefinedConfig/Common/AggregationColumns.d.ts

@@ -15,4 +15,4 @@ export interface WeightedAverageAggregation {
 /**
  * Defines which Columns in a Layout display Aggregated values when Row-Grouped
  */
-export declare type AggregationColumns = Record<string, string | true | WeightedAverageAggregation>;
+export type AggregationColumns = Record<string, string | true | WeightedAverageAggregation>;