@servicetitan/data-query 31.2.0 → 32.0.0

package/dist/filter-serialization.common.js

@@ -8,63 +8,53 @@ import { isString, isDate } from './utils';
  * //ignoreCase=true -> tolower(${field})`
  * //ignoreCase=false -> ${field}`
  * ```
- */
-export const wrapIf = predicate => (str, ...args) => predicate() ? `${str[0]}${args[0]}${str[1]}` : args[0];
+ */ export const wrapIf = (predicate)=>(str, ...args)=>predicate() ? `${str[0]}${args[0]}${str[1]}` : args[0];
 /**
  * @hidden
- */
-export const toUTC = (date) => new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+ */ export const toUTC = (date)=>new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
 /**
  * @hidden
- */
-export const quote = ({ field, value, ignoreCase, operator }) => ({
-    value: `'${value.replace(/'/g, "''")}'`,
-    field,
-    ignoreCase,
-    operator
-});
+ */ export const quote = ({ field, value, ignoreCase, operator })=>({
+        value: `'${value.replace(/'/g, "''")}'`,
+        field,
+        ignoreCase,
+        operator
+    });
 /**
  * @hidden
- */
-export const encodeValue = ({ field, value, ignoreCase, operator }) => ({
-    value: `${encodeURIComponent(value)}`,
-    field,
-    ignoreCase,
-    operator
-});
+ */ export const encodeValue = ({ field, value, ignoreCase, operator })=>({
+        value: `${encodeURIComponent(value)}`,
+        field,
+        ignoreCase,
+        operator
+    });
 /**
  * @hidden
- */
-export const toLower = ({ field, value, ignoreCase, operator }) => ({
-    field: wrapIf(() => ignoreCase) `tolower(${field})`,
-    value,
-    ignoreCase,
-    operator
-});
+ */ export const toLower = ({ field, value, ignoreCase, operator })=>({
+        field: wrapIf(()=>ignoreCase)`tolower(${field})`,
+        value,
+        ignoreCase,
+        operator
+    });
 /**
  * @hidden
- */
-export const normalizeField = ({ field, value, ignoreCase, operator }) => ({
-    value,
-    field: field.replace(/\./g, "/"),
-    ignoreCase,
-    operator
-});
+ */ export const normalizeField = ({ field, value, ignoreCase, operator })=>({
+        value,
+        field: field.replace(/\./g, "/"),
+        ignoreCase,
+        operator
+    });
 /**
  * @hidden
- */
-export const isStringValue = x => isString(x.value);
+ */ export const isStringValue = (x)=>isString(x.value);
 /**
  * @hidden
- */
-export const isDateValue = x => isDate(x.value);
+ */ export const isDateValue = (x)=>isDate(x.value);
 /**
  * @hidden
- */
-export const serializeFilters = (map, join) => (filter) => {
-    const brackets = wrapIf(() => filter.filters.length > 1);
-    return brackets `(${filter.filters
-        .map(map)
-        .join(join(filter))})`;
-};
+ */ export const serializeFilters = (map, join)=>(filter)=>{
+        const brackets = wrapIf(()=>filter.filters.length > 1);
+        return brackets`(${filter.filters.map(map).join(join(filter))})`;
+    };
+
 //# sourceMappingURL=filter-serialization.common.js.map

package/dist/filter-serialization.common.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-serialization.common.js","sourceRoot":"","sources":["../src/filter-serialization.common.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAO3C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAE5G;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,IAAU,EAAE,EAAE,CAChC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CACb,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,EACd,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,UAAU,EAAE,EACjB,IAAI,CAAC,UAAU,EAAE,EACjB,IAAI,CAAC,eAAe,EAAE,CACzB,CAAC,CAAC;AAEP;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAmB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IAC9E,KAAK,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG;IACvC,KAAK;IACL,UAAU;IACV,QAAQ;CACX,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAmB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IACpF,KAAK,EAAE,GAAG,kBAAkB,CAAC,KAAK,CAAC,EAAE;IACrC,KAAK;IACL,UAAU;IACV,QAAQ;CACX,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAmB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IAChF,KAAK,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,CAAA,WAAW,KAAK,GAAG;IAClD,KAAK;IACL,UAAU;IACV,QAAQ;CACX,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAmB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IACvF,KAAK;IACL,KAAK,EAAW,KAAM,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;IAC1C,UAAU;IACV,QAAQ;CACX,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACpD;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,MAAiC,EAAU,EAAE;IACzF,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzD,OAAO,QAAQ,CAAA,IACX,MAAM,CAAC,OAAO;SACT,GAAG,CAAC,GAAG,CAAC;SACR,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CACtB,GAAG,CAAC;AACZ,CAAC,CAAC"}
+{"version":3,"sources":["../src/filter-serialization.common.ts"],"sourcesContent":["import { FilterDescriptor, CompositeFilterDescriptor } from './filtering/filter-descriptor.interface';\nimport { isString, isDate } from './utils';\n\n/**\n * @hidden\n */\nexport type Transformation = (x: FilterDescriptor) => FilterDescriptor;\n\n/**\n * @hidden\n * Creates a single arity function which wraps the value based on the provided predicate.\n * @example\n * ```\n * wrapIf(() => ignoreCase) `tolower(${field})`\n * //ignoreCase=true -> tolower(${field})`\n * //ignoreCase=false -> ${field}`\n * ```\n */\nexport const wrapIf = predicate => (str, ...args) => predicate() ? `${str[0]}${args[0]}${str[1]}` : args[0];\n\n/**\n * @hidden\n */\nexport const toUTC = (date: Date) =>\n    new Date(Date.UTC(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate(),\n        date.getHours(),\n        date.getMinutes(),\n        date.getSeconds(),\n        date.getMilliseconds()\n    ));\n\n/**\n * @hidden\n */\nexport const quote: Transformation = ({ field, value, ignoreCase, operator }) => ({\n    value: `'${value.replace(/'/g, \"''\")}'`,\n    field,\n    ignoreCase,\n    operator\n});\n\n/**\n * @hidden\n */\nexport const encodeValue: Transformation = ({ field, value, ignoreCase, operator }) => ({\n    value: `${encodeURIComponent(value)}`,\n    field,\n    ignoreCase,\n    operator\n});\n\n/**\n * @hidden\n */\nexport const toLower: Transformation = ({ field, value, ignoreCase, operator }) => ({\n    field: wrapIf(() => ignoreCase)`tolower(${field})`,\n    value,\n    ignoreCase,\n    operator\n});\n\n/**\n * @hidden\n */\nexport const normalizeField: Transformation = ({ field, value, ignoreCase, operator }) => ({\n    value,\n    field: (<string>field).replace(/\\./g, \"/\"),\n    ignoreCase,\n    operator\n});\n\n/**\n * @hidden\n */\nexport const isStringValue = x => isString(x.value);\n/**\n * @hidden\n */\nexport const isDateValue = x => isDate(x.value);\n\n/**\n * @hidden\n */\nexport const serializeFilters = (map, join) => (filter: CompositeFilterDescriptor): string => {\n    const brackets = wrapIf(() => filter.filters.length > 1);\n    return brackets`(${\n        filter.filters\n            .map(map)\n            .join(join(filter))\n        })`;\n};\n"],"names":["isString","isDate","wrapIf","predicate","str","args","toUTC","date","Date","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","quote","field","value","ignoreCase","operator","replace","encodeValue","encodeURIComponent","toLower","normalizeField","isStringValue","x","isDateValue","serializeFilters","map","join","filter","brackets","filters","length"],"mappings":"AACA,SAASA,QAAQ,EAAEC,MAAM,QAAQ,UAAU;AAO3C;;;;;;;;;CASC,GACD,OAAO,MAAMC,SAASC,CAAAA,YAAa,CAACC,KAAK,GAAGC,OAASF,cAAc,GAAGC,GAAG,CAAC,EAAE,GAAGC,IAAI,CAAC,EAAE,GAAGD,GAAG,CAAC,EAAE,EAAE,GAAGC,IAAI,CAAC,EAAE,CAAC;AAE5G;;CAEC,GACD,OAAO,MAAMC,QAAQ,CAACC,OAClB,IAAIC,KAAKA,KAAKC,GAAG,CACbF,KAAKG,WAAW,IAChBH,KAAKI,QAAQ,IACbJ,KAAKK,OAAO,IACZL,KAAKM,QAAQ,IACbN,KAAKO,UAAU,IACfP,KAAKQ,UAAU,IACfR,KAAKS,eAAe,KACrB;AAEP;;CAEC,GACD,OAAO,MAAMC,QAAwB,CAAC,EAAEC,KAAK,EAAEC,KAAK,EAAEC,UAAU,EAAEC,QAAQ,EAAE,GAAM,CAAA;QAC9EF,OAAO,CAAC,CAAC,EAAEA,MAAMG,OAAO,CAAC,MAAM,MAAM,CAAC,CAAC;QACvCJ;QACAE;QACAC;IACJ,CAAA,EAAG;AAEH;;CAEC,GACD,OAAO,MAAME,cAA8B,CAAC,EAAEL,KAAK,EAAEC,KAAK,EAAEC,UAAU,EAAEC,QAAQ,EAAE,GAAM,CAAA;QACpFF,OAAO,GAAGK,mBAAmBL,QAAQ;QACrCD;QACAE;QACAC;IACJ,CAAA,EAAG;AAEH;;CAEC,GACD,OAAO,MAAMI,UAA0B,CAAC,EAAEP,KAAK,EAAEC,KAAK,EAAEC,UAAU,EAAEC,QAAQ,EAAE,GAAM,CAAA;QAChFH,OAAOhB,OAAO,IAAMkB,WAAW,CAAC,QAAQ,EAAEF,MAAM,CAAC,CAAC;QAClDC;QACAC;QACAC;IACJ,CAAA,EAAG;AAEH;;CAEC,GACD,OAAO,MAAMK,iBAAiC,CAAC,EAAER,KAAK,EAAEC,KAAK,EAAEC,UAAU,EAAEC,QAAQ,EAAE,GAAM,CAAA;QACvFF;QACAD,OAAO,AAASA,MAAOI,OAAO,CAAC,OAAO;QACtCF;QACAC;IACJ,CAAA,EAAG;AAEH;;CAEC,GACD,OAAO,MAAMM,gBAAgBC,CAAAA,IAAK5B,SAAS4B,EAAET,KAAK,EAAE;AACpD;;CAEC,GACD,OAAO,MAAMU,cAAcD,CAAAA,IAAK3B,OAAO2B,EAAET,KAAK,EAAE;AAEhD;;CAEC,GACD,OAAO,MAAMW,mBAAmB,CAACC,KAAKC,OAAS,CAACC;QAC5C,MAAMC,WAAWhC,OAAO,IAAM+B,OAAOE,OAAO,CAACC,MAAM,GAAG;QACtD,OAAOF,QAAQ,CAAC,CAAC,EACbD,OAAOE,OAAO,CACTJ,GAAG,CAACA,KACJC,IAAI,CAACA,KAAKC,SACd,CAAC,CAAC;IACX,EAAE"}

package/dist/filtering/filter-descriptor.interface.js

@@ -3,8 +3,8 @@ import { isPresent } from '../utils';
 /**
  * @hidden
  * Type guard for `CompositeFilterDescriptor`.
- */
-export const isCompositeFilterDescriptor = (source) => {
+ */ export const isCompositeFilterDescriptor = (source)=>{
     return isPresent(source.filters);
 };
+
 //# sourceMappingURL=filter-descriptor.interface.js.map

package/dist/filtering/filter-descriptor.interface.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-descriptor.interface.js","sourceRoot":"","sources":["../../src/filtering/filter-descriptor.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AA+DrC,gCAAgC;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,MAAoD,EAAuC,EAAE;IACrI,OAAO,SAAS,CAA6B,MAAO,CAAC,OAAO,CAAC,CAAC;AAClE,CAAC,CAAC"}
+{"version":3,"sources":["../../src/filtering/filter-descriptor.interface.ts"],"sourcesContent":["import { isPresent } from '../utils';\n\n// tslint:disable:max-line-length\n/**\n * A basic filter expression. Usually is a part of [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n *\n * For more information on filtering the provided data array, refer to the [`filterBy`]({% slug api_kendo-data-query_filterby %}) method.\n * For examples on using the `FilterDescriptor`, refer to the [documentation on filtering the Grid]({% slug filtering_grid %}).\n */\nexport interface FilterDescriptor {\n    /**\n     * The data item field to which the filter operator is applied.\n     */\n    field?: string | Function;\n    /**\n     * The filter operator (comparison).\n     *\n     * The supported operators are:\n     * * `\"eq\"` (equal to)\n     * * `\"neq\"` (not equal to)\n     * * `\"isnull\"` (is equal to null)\n     * * `\"isnotnull\"` (is not equal to null)\n     * * `\"lt\"` (less than)\n     * * `\"lte\"` (less than or equal to)\n     * * `\"gt\"` (greater than)\n     * * `\"gte\"` (greater than or equal to)\n     *\n     * The following operators are supported for string fields only:\n     * * `\"startswith\"`\n     * * `\"endswith\"`\n     * * `\"contains\"`\n     * * `\"doesnotcontain\"`\n     * * `\"isempty\"`\n     * * `\"isnotempty\"`\n     */\n    operator: string | Function;\n    /**\n     * The value to which the field is compared. Has to be of the same type as the field.\n     */\n    value?: any;\n    /**\n     * Determines if the string comparison is case-insensitive.\n     */\n    ignoreCase?: boolean;\n}\n\n/**\n * A complex filter expression. For more information, refer to the [`filterBy`]({% slug api_kendo-data-query_filterby %}) method.\n */\nexport interface CompositeFilterDescriptor {\n    /**\n     * The logical operation to use when the `filter.filters` option is set.\n     *\n     * The supported values are:\n     * * `\"and\"`\n     * * `\"or\"`\n     */\n    logic: 'or' | 'and';\n    /**\n     * The nested filter expressions&mdash;either [`FilterDescriptor`]({% slug api_kendo-data-query_filterdescriptor %}), or [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}). Supports the same options as `filter`. You can nest filters indefinitely.\n     */\n    filters: Array<FilterDescriptor | CompositeFilterDescriptor>;\n}\n// tslint:enable:max-line-length\n\n/**\n * @hidden\n * Type guard for `CompositeFilterDescriptor`.\n */\nexport const isCompositeFilterDescriptor = (source: CompositeFilterDescriptor | FilterDescriptor): source is CompositeFilterDescriptor => {\n    return isPresent((<CompositeFilterDescriptor>source).filters);\n};\n"],"names":["isPresent","isCompositeFilterDescriptor","source","filters"],"mappings":"AAAA,SAASA,SAAS,QAAQ,WAAW;AA+DrC,gCAAgC;AAEhC;;;CAGC,GACD,OAAO,MAAMC,8BAA8B,CAACC;IACxC,OAAOF,UAAU,AAA4BE,OAAQC,OAAO;AAChE,EAAE"}

package/dist/filtering/filter-expression.factory.js

@@ -18,11 +18,10 @@ import { transformCompositeFilter } from "./filter-no-eval";
  * const result = data.filter(predicate);
  *
  * ```
- */
-// tslint:enable:max-line-length
-export const compileFilter = (descriptor, preprocessors = {}) => {
+ */ // tslint:enable:max-line-length
+export const compileFilter = (descriptor, preprocessors = {})=>{
     if (!descriptor || descriptor.filters.length === 0) {
-        return () => true;
+        return ()=>true;
     }
     return transformCompositeFilter(descriptor, preprocessors);
 };
@@ -55,12 +54,12 @@ export const compileFilter = (descriptor, preprocessors = {}) => {
  * // output:
  * // [{ "name": "Pork", "category": "Food", "subcategory": "Meat" }]
  * ```
- */
-// tslint:enable:max-line-length
-export const filterBy = (data, descriptor, preprocessors = {}) => {
-    if (!isPresent(descriptor) || (isCompositeFilterDescriptor(descriptor) && descriptor.filters.length === 0)) {
+ */ // tslint:enable:max-line-length
+export const filterBy = (data, descriptor, preprocessors = {})=>{
+    if (!isPresent(descriptor) || isCompositeFilterDescriptor(descriptor) && descriptor.filters.length === 0) {
         return data;
     }
     return data.filter(compileFilter(normalizeFilters(descriptor), preprocessors));
 };
+
 //# sourceMappingURL=filter-expression.factory.js.map

package/dist/filtering/filter-expression.factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-expression.factory.js","sourceRoot":"","sources":["../../src/filtering/filter-expression.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAA+C,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACzH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,iCAAiC;AACjC;;;;;;;;;;;;;;;GAeG;AACH,gCAAgC;AAChC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAI,UAAqC,EAAE,gBAAkC,EAAE,EAAa,EAAE;IACvH,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjD,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC;IACtB,CAAC;IACD,OAAO,wBAAwB,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;AAC/D,CAAC,CAAC;AAEF,iCAAiC;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gCAAgC;AAChC,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAI,IAAS,EAAE,UAAwD,EAAE,gBAAkC,EAAE,EAAO,EAAE;IAC1I,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACzG,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;AACnF,CAAC,CAAC"}
+{"version":3,"sources":["../../src/filtering/filter-expression.factory.ts"],"sourcesContent":["import { isPresent } from '../utils';\nimport { CompositeFilterDescriptor, FilterDescriptor, isCompositeFilterDescriptor } from './filter-descriptor.interface';\nimport { normalizeFilters } from './filter.operators';\nimport { Predicate, Preprocessors } from '../common.interfaces';\nimport { transformCompositeFilter } from \"./filter-no-eval\";\n\n// tslint:disable:max-line-length\n/**\n * Creates a [`Predicate`]({% slug api_kendo-data-query_predicate %}) function for the specified [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n *\n * @param {CompositeFilterDescriptor} descriptor - The descriptor for which the predicate is created.\n * @returns {Predicate} - The created function instance.\n *\n * @example\n * ```ts-no-run\n * import { compileFilter } from '@progress/kendo-data-query';\n *\n * const data = [{ name: \"Pork\" }, { name: \"Pepper\" }, { name: \"Beef\" } ];\n * const predicate = compileFilter({ logic: \"and\", filters: [{ field: \"name\", operator: \"startswith\", value: \"P\" }] });\n * const result = data.filter(predicate);\n *\n * ```\n */\n// tslint:enable:max-line-length\nexport const compileFilter = <T>(descriptor: CompositeFilterDescriptor, preprocessors: Preprocessors<T> = {}): Predicate => {\n    if (!descriptor || descriptor.filters.length === 0) {\n        return () => true;\n    }\n    return transformCompositeFilter(descriptor, preprocessors);\n};\n\n// tslint:disable:max-line-length\n/**\n * Filters the provided array according to the specified [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n *\n * @param {T[]} data - The data that will be filtered.\n * @param {(CompositeFilterDescriptor | FilterDescriptor)} descriptor - The filter criteria that will be applied.\n * @returns {T[]} - The filtered data.\n *\n * @example\n * ```ts-no-run\n * import { filterBy } from '@progress/kendo-data-query';\n *\n * const data = [\n *  { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n *  { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" },\n *  { name: \"Beef\", category: \"Food\", subcategory: \"Meat\" }\n * ];\n *\n * const result = filterBy(data, {\n *     logic: 'and',\n *     filters: [\n *           { field: \"name\", operator: \"startswith\", value: \"p\", ignoreCase: true },\n *           { field: \"subcategory\", operator: \"eq\", value: \"Meat\" },\n *     ]\n * });\n *\n * // output:\n * // [{ \"name\": \"Pork\", \"category\": \"Food\", \"subcategory\": \"Meat\" }]\n * ```\n */\n// tslint:enable:max-line-length\nexport const filterBy = <T>(data: T[], descriptor: CompositeFilterDescriptor | FilterDescriptor, preprocessors: Preprocessors<T> = {}): T[] => {\n    if (!isPresent(descriptor) || (isCompositeFilterDescriptor(descriptor) && descriptor.filters.length === 0)) {\n        return data;\n    }\n\n    return data.filter(compileFilter(normalizeFilters(descriptor), preprocessors));\n};\n"],"names":["isPresent","isCompositeFilterDescriptor","normalizeFilters","transformCompositeFilter","compileFilter","descriptor","preprocessors","filters","length","filterBy","data","filter"],"mappings":"AAAA,SAASA,SAAS,QAAQ,WAAW;AACrC,SAAsDC,2BAA2B,QAAQ,gCAAgC;AACzH,SAASC,gBAAgB,QAAQ,qBAAqB;AAEtD,SAASC,wBAAwB,QAAQ,mBAAmB;AAE5D,iCAAiC;AACjC;;;;;;;;;;;;;;;CAeC,GACD,gCAAgC;AAChC,OAAO,MAAMC,gBAAgB,CAAIC,YAAuCC,gBAAkC,CAAC,CAAC;IACxG,IAAI,CAACD,cAAcA,WAAWE,OAAO,CAACC,MAAM,KAAK,GAAG;QAChD,OAAO,IAAM;IACjB;IACA,OAAOL,yBAAyBE,YAAYC;AAChD,EAAE;AAEF,iCAAiC;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,gCAAgC;AAChC,OAAO,MAAMG,WAAW,CAAIC,MAAWL,YAA0DC,gBAAkC,CAAC,CAAC;IACjI,IAAI,CAACN,UAAUK,eAAgBJ,4BAA4BI,eAAeA,WAAWE,OAAO,CAACC,MAAM,KAAK,GAAI;QACxG,OAAOE;IACX;IAEA,OAAOA,KAAKC,MAAM,CAACP,cAAcF,iBAAiBG,aAAaC;AACnE,EAAE"}

package/dist/filtering/filter-no-eval.js

@@ -3,56 +3,53 @@ import { getter } from "../accessor";
 import { isFunction, isPresent, isDate, isString, isBlank, isNumeric, isArray } from "../utils";
 const logic = {
     "or": {
-        concat: (acc, fn) => a => acc(a) || fn(a),
-        identity: () => false
+        concat: (acc, fn)=>(a)=>acc(a) || fn(a),
+        identity: ()=>false
     },
     "and": {
-        concat: (acc, fn) => a => acc(a) && fn(a),
-        identity: () => true
+        concat: (acc, fn)=>(a)=>acc(a) && fn(a),
+        identity: ()=>true
     }
 };
 const operatorsMap = {
-    contains: (a, b) => (a || "").indexOf(b) >= 0,
-    doesnotcontain: (a, b) => (a || "").indexOf(b) === -1,
-    doesnotendwith: (a, b) => (a || "").indexOf(b, (a || "").length - (b || "").length) < 0,
-    doesnotstartwith: (a, b) => (a || "").lastIndexOf(b, 0) === -1,
-    endswith: (a, b) => (a || "").indexOf(b, (a || "").length - (b || "").length) >= 0,
-    eq: (a, b) => a === b,
-    gt: (a, b) => a > b,
-    gte: (a, b) => a >= b,
-    isempty: (a) => isBlank(a) || a === '',
-    isnotempty: (a) => isPresent(a) && a !== '',
-    isnotnull: (a) => isPresent(a),
-    isnull: (a) => isBlank(a),
-    lt: (a, b) => a < b,
-    lte: (a, b) => a <= b,
-    neq: (a, b) => a != b, // tslint:disable-line:triple-equals
-    startswith: (a, b) => (a || "").lastIndexOf(b, 0) === 0,
-    in: (a, b) => b.includes(a),
-    notin: (a, b) => !b.includes(a),
-    isinteger: (a) => isNumeric(a) && Math.round(a) === a,
-    isfractional: (a) => isNumeric(a) && Math.round(a) !== a
+    contains: (a, b)=>(a || "").indexOf(b) >= 0,
+    doesnotcontain: (a, b)=>(a || "").indexOf(b) === -1,
+    doesnotendwith: (a, b)=>(a || "").indexOf(b, (a || "").length - (b || "").length) < 0,
+    doesnotstartwith: (a, b)=>(a || "").lastIndexOf(b, 0) === -1,
+    endswith: (a, b)=>(a || "").indexOf(b, (a || "").length - (b || "").length) >= 0,
+    eq: (a, b)=>a === b,
+    gt: (a, b)=>a > b,
+    gte: (a, b)=>a >= b,
+    isempty: (a)=>isBlank(a) || a === '',
+    isnotempty: (a)=>isPresent(a) && a !== '',
+    isnotnull: (a)=>isPresent(a),
+    isnull: (a)=>isBlank(a),
+    lt: (a, b)=>a < b,
+    lte: (a, b)=>a <= b,
+    neq: (a, b)=>a != b,
+    startswith: (a, b)=>(a || "").lastIndexOf(b, 0) === 0,
+    in: (a, b)=>b.includes(a),
+    notin: (a, b)=>!b.includes(a),
+    isinteger: (a)=>isNumeric(a) && Math.round(a) === a,
+    isfractional: (a)=>isNumeric(a) && Math.round(a) !== a
 };
 const dateRegExp = /^\/Date\((.*?)\)\/$/;
-const convertValue = (value, ignoreCase) => {
+const convertValue = (value, ignoreCase)=>{
     if (value != null && isString(value)) {
         const date = dateRegExp.exec(value);
         if (date) {
             return new Date(+date[1]).getTime();
-        }
-        else if (ignoreCase) {
+        } else if (ignoreCase) {
             return value.toLowerCase();
         }
-    }
-    else if (value != null && isDate(value)) {
+    } else if (value != null && isDate(value)) {
         return value.getTime();
-    }
-    else if (value != null && isArray(value)) {
-        return value.map(v => isString(v) ? v.toLowerCase() : v);
+    } else if (value != null && isArray(value)) {
+        return value.map((v)=>isString(v) ? v.toLowerCase() : v);
     }
     return value;
 };
-const typedGetter = (prop, value, ignoreCase) => {
+const typedGetter = (prop, value, ignoreCase)=>{
     if (!isPresent(value)) {
         return prop;
     }
@@ -61,53 +58,48 @@ const typedGetter = (prop, value, ignoreCase) => {
         const date = dateRegExp.exec(value);
         if (date) {
             value = new Date(+date[1]);
-        }
-        else {
-            acc = a => {
+        } else {
+            acc = (a)=>{
                 const x = prop(a);
                 if (typeof x === 'string' && ignoreCase) {
                     return x.toLowerCase();
-                }
-                else {
+                } else {
                     return isNumeric(x) ? x + "" : x;
                 }
             };
         }
     }
     if (isDate(value)) {
-        return a => {
+        return (a)=>{
             const x = acc(a);
             return isDate(x) ? x.getTime() : x;
         };
     }
     if (isArray(value) && ignoreCase) {
-        acc = a => {
+        acc = (a)=>{
             const x = prop(a);
             return isString(x) ? x.toLowerCase() : x;
         };
     }
     return acc;
 };
-const transformFilter = ({ field, ignoreCase, value, operator }, preprocessors = {}) => {
-    field = !isPresent(field) ? a => a : field;
+const transformFilter = ({ field, ignoreCase, value, operator }, preprocessors = {})=>{
+    field = !isPresent(field) ? (a)=>a : field;
     ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;
-    const itemProp = typedGetter(isFunction(field) ? field : a => {
+    const itemProp = typedGetter(isFunction(field) ? field : (a)=>{
         const value = getter(field, true)(a);
         const preprocessor = preprocessors[field];
         return preprocessor ? preprocessor(value) : value;
     }, value, ignoreCase);
     value = convertValue(value, ignoreCase);
     const op = isFunction(operator) ? operator : operatorsMap[operator];
-    return a => op(itemProp(a), value, ignoreCase);
+    return (a)=>op(itemProp(a), value, ignoreCase);
 };
 /**
  * @hidden
- */
-export const transformCompositeFilter = (filter, preprocessors = {}) => {
+ */ export const transformCompositeFilter = (filter, preprocessors = {})=>{
     const combiner = logic[filter.logic];
-    return filter.filters
-        .filter(isPresent)
-        .map(x => isCompositeFilterDescriptor(x) ? transformCompositeFilter(x, preprocessors) : transformFilter(x, preprocessors))
-        .reduce(combiner.concat, combiner.identity);
+    return filter.filters.filter(isPresent).map((x)=>isCompositeFilterDescriptor(x) ? transformCompositeFilter(x, preprocessors) : transformFilter(x, preprocessors)).reduce(combiner.concat, combiner.identity);
 };
+
 //# sourceMappingURL=filter-no-eval.js.map

package/dist/filtering/filter-no-eval.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter-no-eval.js","sourceRoot":"","sources":["../../src/filtering/filter-no-eval.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/filtering/filter-no-eval.ts"],"sourcesContent":["import { CompositeFilterDescriptor, FilterDescriptor, isCompositeFilterDescriptor } from \"./filter-descriptor.interface\";\nimport { Predicate, Preprocessors } from \"../common.interfaces\";\nimport { getter } from \"../accessor\";\nimport { isFunction, isPresent, isDate, isString, isBlank, isNumeric, isArray } from \"../utils\";\n\nconst logic = {\n    \"or\": {\n        concat: (acc, fn) => a => acc(a) || fn(a),\n        identity: () => false\n    },\n    \"and\": {\n        concat: (acc, fn) => a => acc(a) && fn(a),\n        identity: () => true\n    }\n};\n\nconst operatorsMap = {\n    contains: (a, b) => (a || \"\").indexOf(b) >= 0,\n    doesnotcontain: (a, b) => (a || \"\").indexOf(b) === -1,\n    doesnotendwith: (a, b) => (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) < 0,\n    doesnotstartwith: (a: string, b: string): boolean => (a || \"\").lastIndexOf(b, 0) === -1,\n    endswith: (a: string, b: string): boolean => (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) >= 0,\n    eq: (a, b) => a === b,\n    gt: <T>(a: T, b: T): boolean => a > b,\n    gte: <T>(a: T, b: T): boolean => a >= b,\n    isempty: (a: any) => isBlank(a) || a === '',\n    isnotempty: (a: any) => isPresent(a) && a !== '',\n    isnotnull: (a: any) => isPresent(a),\n    isnull: (a: any) => isBlank(a),\n    lt: <T>(a: T, b: T): boolean => a < b,\n    lte: <T>(a: T, b: T): boolean => a <= b,\n    neq: <T>(a: T, b: T): boolean => a != b, // tslint:disable-line:triple-equals\n    startswith: (a: string, b: string): boolean => (a || \"\").lastIndexOf(b, 0) === 0,\n    in: <T>(a: T, b: T[]): boolean => b.includes(a),\n    notin: <T>(a: T, b: T[]): boolean => !b.includes(a),\n    isinteger: (a: any) => isNumeric(a) && Math.round(a) === a,\n    isfractional: (a: any) => isNumeric(a) && Math.round(a) !== a\n};\n\nconst dateRegExp = /^\\/Date\\((.*?)\\)\\/$/;\n\nconst convertValue = (value, ignoreCase) => {\n    if (value != null && isString(value)) {\n        const date = dateRegExp.exec(value);\n        if (date) {\n            return new Date(+date[1]).getTime();\n        } else if (ignoreCase) {\n            return value.toLowerCase();\n        }\n    } else if (value != null && isDate(value)) {\n        return value.getTime();\n    } else if (value != null && isArray(value)) {\n        return value.map(v => isString(v) ? v.toLowerCase() : v);\n    }\n    return value;\n};\n\n\nconst typedGetter = (prop, value, ignoreCase) => {\n    if (!isPresent(value)) {\n        return prop;\n    }\n\n    let acc = prop;\n\n    if (isString(value)) {\n        const date = dateRegExp.exec(value);\n        if (date) {\n            value = new Date(+date[1]);\n        } else {\n            acc = a => {\n                const x = prop(a);\n                if (typeof x === 'string' && ignoreCase) {\n                    return x.toLowerCase();\n                } else {\n                    return isNumeric(x) ? x + \"\" : x;\n                }\n            };\n        }\n    }\n\n    if (isDate(value)) {\n        return a => {\n            const x = acc(a);\n            return isDate(x) ? x.getTime() : x;\n        };\n    }\n\n    if(isArray(value) && ignoreCase){\n        acc = a => {\n            const x = prop(a);\n            return isString(x) ? x.toLowerCase() : x;\n        };\n    }\n\n    return acc;\n};\n\nconst transformFilter = <T>({ field, ignoreCase, value, operator }: FilterDescriptor, preprocessors: Preprocessors<T> = {}): Predicate => {\n    field = !isPresent(field) ? a => a : field;\n\n    ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;\n\n    const itemProp = typedGetter(\n        isFunction(field) ? field : a => {\n            const value = getter(<string>field, true)(a);\n            const preprocessor = preprocessors[<string>field];\n            return preprocessor ? preprocessor(value) : value;\n        },\n        value,\n        ignoreCase\n    );\n\n    value = convertValue(value, ignoreCase);\n\n    const op = isFunction(operator) ? operator : operatorsMap[<string>operator];\n\n    return a => op(itemProp(a), value, ignoreCase);\n};\n\n/**\n * @hidden\n */\nexport const transformCompositeFilter = <T>(filter: CompositeFilterDescriptor, preprocessors: Preprocessors<T> = {}): Predicate => {\n    const combiner = logic[filter.logic];\n    return filter.filters\n        .filter(isPresent)\n        .map(x => isCompositeFilterDescriptor(x) ? transformCompositeFilter(x, preprocessors) : transformFilter(x, preprocessors))\n        .reduce(combiner.concat, combiner.identity);\n};\n"],"names":["isCompositeFilterDescriptor","getter","isFunction","isPresent","isDate","isString","isBlank","isNumeric","isArray","logic","concat","acc","fn","a","identity","operatorsMap","contains","b","indexOf","doesnotcontain","doesnotendwith","length","doesnotstartwith","lastIndexOf","endswith","eq","gt","gte","isempty","isnotempty","isnotnull","isnull","lt","lte","neq","startswith","in","includes","notin","isinteger","Math","round","isfractional","dateRegExp","convertValue","value","ignoreCase","date","exec","Date","getTime","toLowerCase","map","v","typedGetter","prop","x","transformFilter","field","operator","preprocessors","itemProp","preprocessor","op","transformCompositeFilter","filter","combiner","filters","reduce"],"mappings":"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"}

package/dist/filtering/filter.operators.js

@@ -1,41 +1,41 @@
 import { isPresent, isString, isArray } from '../utils';
 import { isCompositeFilterDescriptor } from './filter-descriptor.interface';
-const operatorMap = (key) => ({
-    "!=": "neq",
-    "<": "lt",
-    "<=": "lte",
-    "==": "eq",
-    ">": "gt",
-    ">=": "gte",
-    equal: "eq",
-    equals: "eq",
-    equalto: "eq",
-    ge: "gte",
-    greater: "gt",
-    greaterthan: "gt",
-    greaterthanequal: "gte",
-    isempty: "isempty",
-    isequalto: "eq",
-    isgreaterthan: "gt",
-    isgreaterthanorequalto: "gte",
-    islessthan: "lt",
-    islessthanorequalto: "lte",
-    isnotempty: "isnotempty",
-    isnotequalto: "neq",
-    isnull: "isnull",
-    le: "lte",
-    less: "lt",
-    lessthan: "lt",
-    lessthanequal: "lte",
-    ne: "neq",
-    notequal: "neq",
-    notequals: "neq",
-    notequalto: "neq",
-    notsubstringof: "doesnotcontain"
-}[key.toLowerCase()] || key);
-const normalizeOperator = (descriptor) => {
+const operatorMap = (key)=>({
+        "!=": "neq",
+        "<": "lt",
+        "<=": "lte",
+        "==": "eq",
+        ">": "gt",
+        ">=": "gte",
+        equal: "eq",
+        equals: "eq",
+        equalto: "eq",
+        ge: "gte",
+        greater: "gt",
+        greaterthan: "gt",
+        greaterthanequal: "gte",
+        isempty: "isempty",
+        isequalto: "eq",
+        isgreaterthan: "gt",
+        isgreaterthanorequalto: "gte",
+        islessthan: "lt",
+        islessthanorequalto: "lte",
+        isnotempty: "isnotempty",
+        isnotequalto: "neq",
+        isnull: "isnull",
+        le: "lte",
+        less: "lt",
+        lessthan: "lt",
+        lessthanequal: "lte",
+        ne: "neq",
+        notequal: "neq",
+        notequals: "neq",
+        notequalto: "neq",
+        notsubstringof: "doesnotcontain"
+    })[key.toLowerCase()] || key;
+const normalizeOperator = (descriptor)=>{
     if (descriptor.filters) {
-        descriptor.filters = descriptor.filters.map(filter => {
+        descriptor.filters = descriptor.filters.map((filter)=>{
             const result = Object.assign({}, filter);
             if (!isCompositeFilterDescriptor(filter) && isString(filter.operator)) {
                 result.operator = operatorMap(filter.operator);
@@ -47,10 +47,12 @@ const normalizeOperator = (descriptor) => {
         });
     }
 };
-const normalizeDescriptor = (descriptor) => {
+const normalizeDescriptor = (descriptor)=>{
     if (!isCompositeFilterDescriptor(descriptor)) {
         return {
-            filters: isArray(descriptor) ? descriptor : [descriptor],
+            filters: isArray(descriptor) ? descriptor : [
+                descriptor
+            ],
             logic: "and"
         };
     }
@@ -62,13 +64,13 @@ const normalizeDescriptor = (descriptor) => {
  *
  * @param {CompositeFilterDescriptor | FilterDescriptor} descriptor - The descriptor that will be normalized.
  * @returns {CompositeFilterDescriptor} - The normalized descriptor.
- */
-// tslint:enable:max-line-length
-export const normalizeFilters = (descriptor) => {
+ */ // tslint:enable:max-line-length
+export const normalizeFilters = (descriptor)=>{
     if (isPresent(descriptor)) {
         descriptor = normalizeDescriptor(descriptor);
         normalizeOperator(descriptor);
     }
     return descriptor;
 };
+
 //# sourceMappingURL=filter.operators.js.map

package/dist/filtering/filter.operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter.operators.js","sourceRoot":"","sources":["../../src/filtering/filter.operators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAA+C,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAEzH,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC1B,IAAI,EAAE,KAAK;IACX,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,KAAK;IACX,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,KAAK;IACX,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE,IAAI;IACb,EAAE,EAAE,KAAK;IACT,OAAO,EAAE,IAAI;IACb,WAAW,EAAE,IAAI;IACjB,gBAAgB,EAAE,KAAK;IACvB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,IAAI;IACf,aAAa,EAAE,IAAI;IACnB,sBAAsB,EAAE,KAAK;IAC7B,UAAU,EAAE,IAAI;IAChB,mBAAmB,EAAE,KAAK;IAC1B,UAAU,EAAE,YAAY;IACxB,YAAY,EAAE,KAAK;IACnB,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,KAAK;IACT,IAAI,EAAE,IAAI;IACV,QAAQ,EAAE,IAAI;IACd,aAAa,EAAE,KAAK;IACpB,EAAE,EAAE,KAAK;IACT,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,KAAK;IAChB,UAAU,EAAE,KAAK;IACjB,cAAc,EAAE,gBAAgB;CACnC,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,IAAI,GAAG,CAAC,CAAC;AAE7B,MAAM,iBAAiB,GAAG,CAAC,UAAqC,EAAE,EAAE;IAChE,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;QACrB,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACjD,MAAM,MAAM,GAAQ,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YAC9C,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACpE,MAAM,CAAC,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACnD,CAAC;YACD,IAAI,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtC,iBAAiB,CAAC,MAAM,CAAC,CAAC;YAC9B,CAAC;YAED,OAAO,MAAM,CAAC;QAClB,CAAC,CAAC,CAAC;IACP,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,UAAU,EAA6B,EAAE;IAClE,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,OAAO;YACH,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;YACxD,KAAK,EAAE,KAAK;SACf,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,CAAC;AACzC,CAAC,CAAC;AAEF,iCAAiC;AACjC;;;;;GAKG;AACH,gCAAgC;AAChC,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,UAAwD,EAA6B,EAAE;IACpH,IAAI,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QACxB,UAAU,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;QAC7C,iBAAiB,CAA4B,UAAU,CAAC,CAAC;IAC7D,CAAC;IACD,OAAkC,UAAU,CAAC;AACjD,CAAC,CAAC"}
+{"version":3,"sources":["../../src/filtering/filter.operators.ts"],"sourcesContent":["import { isPresent, isString, isArray } from '../utils';\nimport { CompositeFilterDescriptor, FilterDescriptor, isCompositeFilterDescriptor } from './filter-descriptor.interface';\n\nconst operatorMap = (key) => ({\n    \"!=\": \"neq\",\n    \"<\": \"lt\",\n    \"<=\": \"lte\",\n    \"==\": \"eq\",\n    \">\": \"gt\",\n    \">=\": \"gte\",\n    equal: \"eq\",\n    equals: \"eq\",\n    equalto: \"eq\",\n    ge: \"gte\",\n    greater: \"gt\",\n    greaterthan: \"gt\",\n    greaterthanequal: \"gte\",\n    isempty: \"isempty\",\n    isequalto: \"eq\",\n    isgreaterthan: \"gt\",\n    isgreaterthanorequalto: \"gte\",\n    islessthan: \"lt\",\n    islessthanorequalto: \"lte\",\n    isnotempty: \"isnotempty\",\n    isnotequalto: \"neq\",\n    isnull: \"isnull\",\n    le: \"lte\",\n    less: \"lt\",\n    lessthan: \"lt\",\n    lessthanequal: \"lte\",\n    ne: \"neq\",\n    notequal: \"neq\",\n    notequals: \"neq\",\n    notequalto: \"neq\",\n    notsubstringof: \"doesnotcontain\"\n}[key.toLowerCase()] || key);\n\nconst normalizeOperator = (descriptor: CompositeFilterDescriptor) => {\n    if (descriptor.filters) {\n        descriptor.filters = descriptor.filters.map(filter => {\n            const result: any = Object.assign({}, filter);\n            if (!isCompositeFilterDescriptor(filter) && isString(filter.operator)) {\n                result.operator = operatorMap(filter.operator);\n            }\n            if (isCompositeFilterDescriptor(filter)) {\n                normalizeOperator(result);\n            }\n\n            return result;\n        });\n    }\n};\n\nconst normalizeDescriptor = (descriptor): CompositeFilterDescriptor => {\n    if (!isCompositeFilterDescriptor(descriptor)) {\n        return {\n            filters: isArray(descriptor) ? descriptor : [descriptor],\n            logic: \"and\"\n        };\n    }\n    return Object.assign({}, descriptor);\n};\n\n// tslint:disable:max-line-length\n/**\n * Converts a [`FilterDescriptor`]({% slug api_kendo-data-query_filterdescriptor %}) into a [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}). If a `CompositeFilterDescriptor` is passed, no modifications will be made.\n *\n * @param {CompositeFilterDescriptor | FilterDescriptor} descriptor - The descriptor that will be normalized.\n * @returns {CompositeFilterDescriptor} - The normalized descriptor.\n */\n// tslint:enable:max-line-length\nexport const normalizeFilters = (descriptor: CompositeFilterDescriptor | FilterDescriptor): CompositeFilterDescriptor => {\n    if (isPresent(descriptor)) {\n        descriptor = normalizeDescriptor(descriptor);\n        normalizeOperator(<CompositeFilterDescriptor>descriptor);\n    }\n    return <CompositeFilterDescriptor>descriptor;\n};\n"],"names":["isPresent","isString","isArray","isCompositeFilterDescriptor","operatorMap","key","equal","equals","equalto","ge","greater","greaterthan","greaterthanequal","isempty","isequalto","isgreaterthan","isgreaterthanorequalto","islessthan","islessthanorequalto","isnotempty","isnotequalto","isnull","le","less","lessthan","lessthanequal","ne","notequal","notequals","notequalto","notsubstringof","toLowerCase","normalizeOperator","descriptor","filters","map","filter","result","Object","assign","operator","normalizeDescriptor","logic","normalizeFilters"],"mappings":"AAAA,SAASA,SAAS,EAAEC,QAAQ,EAAEC,OAAO,QAAQ,WAAW;AACxD,SAAsDC,2BAA2B,QAAQ,gCAAgC;AAEzH,MAAMC,cAAc,CAACC,MAAS,CAAA;QAC1B,MAAM;QACN,KAAK;QACL,MAAM;QACN,MAAM;QACN,KAAK;QACL,MAAM;QACNC,OAAO;QACPC,QAAQ;QACRC,SAAS;QACTC,IAAI;QACJC,SAAS;QACTC,aAAa;QACbC,kBAAkB;QAClBC,SAAS;QACTC,WAAW;QACXC,eAAe;QACfC,wBAAwB;QACxBC,YAAY;QACZC,qBAAqB;QACrBC,YAAY;QACZC,cAAc;QACdC,QAAQ;QACRC,IAAI;QACJC,MAAM;QACNC,UAAU;QACVC,eAAe;QACfC,IAAI;QACJC,UAAU;QACVC,WAAW;QACXC,YAAY;QACZC,gBAAgB;IACpB,CAAA,CAAC,CAACzB,IAAI0B,WAAW,GAAG,IAAI1B;AAExB,MAAM2B,oBAAoB,CAACC;IACvB,IAAIA,WAAWC,OAAO,EAAE;QACpBD,WAAWC,OAAO,GAAGD,WAAWC,OAAO,CAACC,GAAG,CAACC,CAAAA;YACxC,MAAMC,SAAcC,OAAOC,MAAM,CAAC,CAAC,GAAGH;YACtC,IAAI,CAACjC,4BAA4BiC,WAAWnC,SAASmC,OAAOI,QAAQ,GAAG;gBACnEH,OAAOG,QAAQ,GAAGpC,YAAYgC,OAAOI,QAAQ;YACjD;YACA,IAAIrC,4BAA4BiC,SAAS;gBACrCJ,kBAAkBK;YACtB;YAEA,OAAOA;QACX;IACJ;AACJ;AAEA,MAAMI,sBAAsB,CAACR;IACzB,IAAI,CAAC9B,4BAA4B8B,aAAa;QAC1C,OAAO;YACHC,SAAShC,QAAQ+B,cAAcA,aAAa;gBAACA;aAAW;YACxDS,OAAO;QACX;IACJ;IACA,OAAOJ,OAAOC,MAAM,CAAC,CAAC,GAAGN;AAC7B;AAEA,iCAAiC;AACjC;;;;;CAKC,GACD,gCAAgC;AAChC,OAAO,MAAMU,mBAAmB,CAACV;IAC7B,IAAIjC,UAAUiC,aAAa;QACvBA,aAAaQ,oBAAoBR;QACjCD,kBAA6CC;IACjD;IACA,OAAkCA;AACtC,EAAE"}

package/dist/funcs.js

@@ -1,18 +1,15 @@
 /**
  * @hidden
- */
-export const ifElse = (predicate, right, left) => value => predicate(value) ? right(value) : left(value);
+ */ export const ifElse = (predicate, right, left)=>(value)=>predicate(value) ? right(value) : left(value);
 /**
  * @hidden
  * Performs the right-to-left function composition. Functions should have a unary.
- */
-export const compose = (...args) => (data) => args.reduceRight((acc, curr) => curr(acc), data);
+ */ export const compose = (...args)=>(data)=>args.reduceRight((acc, curr)=>curr(acc), data);
 /**
  * @hidden
- */
-export const constant = x => () => x;
+ */ export const constant = (x)=>()=>x;
 /**
  * @hidden
- */
-export const identity = x => x;
+ */ export const identity = (x)=>x;
+
 //# sourceMappingURL=funcs.js.map

package/dist/funcs.js.map

@@ -1 +1 @@
-{"version":3,"file":"funcs.js","sourceRoot":"","sources":["../src/funcs.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAEzG;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;AAE/F;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AAErC;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"sources":["../src/funcs.ts"],"sourcesContent":["/**\n * @hidden\n */\nexport const ifElse = (predicate, right, left) => value => predicate(value) ? right(value) : left(value);\n\n/**\n * @hidden\n * Performs the right-to-left function composition. Functions should have a unary.\n */\nexport const compose = (...args) => (data) => args.reduceRight((acc, curr) => curr(acc), data);\n\n/**\n * @hidden\n */\nexport const constant = x => () => x;\n\n/**\n * @hidden\n */\nexport const identity = x => x;\n"],"names":["ifElse","predicate","right","left","value","compose","args","data","reduceRight","acc","curr","constant","x","identity"],"mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA,SAAS,CAACC,WAAWC,OAAOC,OAASC,CAAAA,QAASH,UAAUG,SAASF,MAAME,SAASD,KAAKC,OAAO;AAEzG;;;CAGC,GACD,OAAO,MAAMC,UAAU,CAAC,GAAGC,OAAS,CAACC,OAASD,KAAKE,WAAW,CAAC,CAACC,KAAKC,OAASA,KAAKD,MAAMF,MAAM;AAE/F;;CAEC,GACD,OAAO,MAAMI,WAAWC,CAAAA,IAAK,IAAMA,EAAE;AAErC;;CAEC,GACD,OAAO,MAAMC,WAAWD,CAAAA,IAAKA,EAAE"}