@wix/wix-data-items-common 1.0.52

package/dist/cjs/filter/FilterTree.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_typeUtils","filterTreeValidations","errors","messages","validateFilterOrThrow","tree","failures","validateFilterTree","length","validationError","join","path","isObject","objectType","collectedErrors","key","Object","keys","value","at","isArray","push","arrayType","flatMap","x","arrayLength","startsWith","validateOperatorOrValue","isComparableValue","some","op","validateOperator","operator","comparisonOperatorType","isString","stringOperatorType","isBoolean","every","setOperatorItems","ignoreCase","matchesOperatorIgnoreCase","spec","validSpec","type","invalid","find","undefined","matchesOperatorSpecItems","regexNotAllowed","isDate","isNumber","$date","prefix","next"],"sources":["../../../src/filter/FilterTree.ts"],"sourcesContent":["import { messages, validationError } from '../errors/errors'\nimport {\n  isArray,\n  isObject,\n  isString,\n  isDate,\n  isNumber,\n  isBoolean,\n} from '../utils/type-utils'\n\nexport type FilterTree =\n  | FieldFilter\n  | { $and?: FilterTree[] }\n  | { $or?: FilterTree[] }\n  | { $not?: FilterTree | [FilterTree] } // [FilterTree] is old format\n\nexport type FieldFilter = {\n  // just value is equivalent $eq operator\n  [field: string]: Operator | Value\n}\n\ntype DateValue = Date | { $date: string }\n\ntype ComparableValue = string | number | DateValue\n\ntype Value = any\n\nexport type Operator =\n  | { $eq?: Value }\n  | { $ne?: Value }\n  | { $gt?: ComparableValue }\n  | { $gte?: ComparableValue }\n  | { $lt?: ComparableValue }\n  | { $lte?: ComparableValue }\n  | { $startsWith?: string }\n  | { $endsWith?: string }\n  | { $contains?: string }\n  | { $exists?: boolean }\n  | { $hasSome?: ComparableValue[] }\n  | { $in?: ComparableValue[] }\n  | { $hasAll?: ComparableValue[] }\n  | {\n      $matches?: {\n        specs: {\n          type: 'literal' | 'anyOf'\n          value: string\n        }[]\n        ignoreCase: true\n      }\n    }\n  | { $not?: Operator }\n\nconst { filterTreeValidations: errors } = messages\n\nexport function validateFilterOrThrow(tree: unknown): tree is FilterTree {\n  const failures = validateFilterTree(tree)\n  if (failures.length === 0) {\n    return true\n  }\n  throw validationError(`Invalid filter:${failures.join('\\n')}`)\n}\n\nexport function validateFilterTree(tree: unknown, path?: string): string[] {\n  if (!isObject(tree)) {\n    return [errors.objectType('Filter Model', tree)]\n  }\n  const collectedErrors = [] as string[]\n  for (const key of Object.keys(tree)) {\n    const value = tree[key]\n    const at = join(path, key)\n    switch (key) {\n      case '$and':\n      case '$or':\n        if (!isArray(value)) {\n          collectedErrors.push(errors.arrayType(at, value))\n        }\n        if (isArray(value)) {\n          collectedErrors.push(\n            ...value.flatMap((x) => validateFilterTree(x, at))\n          )\n        }\n        break\n      case '$not':\n        if (!isArray(value)) {\n          collectedErrors.push(...validateFilterTree(value, at))\n        }\n        if (isArray(value) && value.length !== 1) {\n          collectedErrors.push(errors.arrayLength(at, 1, value))\n        }\n        if (isArray(value) && value.length > 0) {\n          collectedErrors.push(...validateFilterTree(value[0], at))\n        }\n        break\n      default:\n        if (key.startsWith('$')) {\n          collectedErrors.push(`Unexpected operator ${at}`)\n        } else {\n          collectedErrors.push(...validateOperatorOrValue(value, at))\n        }\n    }\n  }\n  return collectedErrors\n}\n\nfunction validateOperatorOrValue(value: unknown, path: string): string[] {\n  if (\n    isObject(value) &&\n    !isComparableValue(value) &&\n    Object.keys(value).some((op) => op.startsWith('$'))\n  ) {\n    return validateOperator(value, path)\n  }\n  return []\n}\n\nfunction validateOperator(operator: unknown, path: string): string[] {\n  if (!isObject(operator)) {\n    return [errors.objectType(path, operator)]\n  }\n  const collectedErrors = [] as string[]\n  for (const key of Object.keys(operator)) {\n    const at = join(path, key)\n    const value = operator[key]\n    switch (key) {\n      case '$eq':\n      case '$ne':\n        break\n      case '$gt':\n      case '$gte':\n      case '$lt':\n      case '$lte':\n        if (!isComparableValue(value)) {\n          collectedErrors.push(errors.comparisonOperatorType(at, value))\n        }\n        break\n      case '$startsWith':\n      case '$endsWith':\n      case '$contains':\n        if (!isString(value)) {\n          collectedErrors.push(errors.stringOperatorType(at, value))\n        }\n        break\n      case '$exists':\n        if (!isBoolean(value)) {\n          collectedErrors.push(`${at} should be a Boolean`)\n        }\n        break\n      case '$hasSome':\n      case '$hasAll':\n      case '$in':\n        if (!isArray(value)) {\n          collectedErrors.push(errors.arrayType(at, value))\n        }\n        if (isArray(value) && !value.every(isComparableValue)) {\n          collectedErrors.push(errors.setOperatorItems(at, value))\n        }\n        break\n      case '$matches':\n        if (!isObject(value)) {\n          collectedErrors.push(errors.objectType(at, value))\n        }\n        if (isObject(value) && value.ignoreCase !== true) {\n          collectedErrors.push(errors.matchesOperatorIgnoreCase(value))\n        }\n        if (isObject(value) && !isArray(value.spec)) {\n          collectedErrors.push(errors.arrayType(`${at}.spec`, value.spec))\n        }\n        if (isArray(value?.spec)) {\n          const validSpec = (spec: any) => {\n            if (!isObject(spec)) {\n              return false\n            }\n            if (spec.type === 'anyOf' && spec.value === ' \\t\\n-') {\n              return true\n            }\n            return spec.type === 'literal' && isString(spec.value)\n          }\n          const invalid = value.spec.find((x: any) => !validSpec(x))\n          if (invalid !== undefined) {\n            collectedErrors.push(errors.matchesOperatorSpecItems(invalid))\n          }\n        }\n        break\n      case '$regex':\n        collectedErrors.push(errors.regexNotAllowed())\n        break\n      case '$not':\n        collectedErrors.push(...validateOperator(value, at))\n        break\n      default:\n        collectedErrors.push(`Unknown operator ${at}`)\n    }\n  }\n  return collectedErrors\n}\n\nfunction isComparableValue(x: unknown): x is ComparableValue {\n  if (isDate(x) || isString(x) || isNumber(x)) {\n    return true\n  }\n  return isObject(x) && isString(x.$date) && Object.keys(x).length === 1\n}\n\nfunction join(prefix: string | undefined, next: string) {\n  return prefix === undefined ? next : `${prefix}.${next}`\n}\n"],"mappings":"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"}

package/dist/cjs/filter/WithFilter.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=WithFilter.js.map

package/dist/cjs/filter/WithFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../../src/filter/WithFilter.ts"],"sourcesContent":["type Comparable = string | number | Date\n\n/**\n * Type that allow filter construction.\n * All construction methods return copy of self\n */\nexport default interface WithFilter<Self extends WithFilter<Self>> {\n  /**\n   * Filter JSON, possibly invalid\n   * @internal\n   */\n  readonly filterTree: Record<string, any>\n\n  /**\n   * Validation errors, if empty filterTree is valid\n   * @internal\n   */\n  readonly invalidArguments: string[]\n\n  /**\n   * Refines a query or filter to match items whose specified property value equals the specified value.\n   *\n   * The `eq()` function refines this filter to only\n   * match items where the value of the specified property equals the specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type does not match the same number stored as a Number type.\n   *\n   * Matching strings with `eq()` is case sensitive, so `\"text\"` is not equal to `\"Text\"`.\n   *\n   * If `field` points to a collection field of type Array, `eq()` includes the item\n   * as long as at least one Array element matches the specified `value`.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object representing the refined query.\n   */\n  eq(field: string, value: any): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value does not equal the specified value.\n   *\n   * The `ne()` function refines this filter to only\n   * match items where the value of the specified property does not equal the specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type is considered not equal to the same number stored as a Number type.\n   *\n   * Matching strings with `ne()` is case sensitive, so `\"text\"` is not equal to `\"Text\"`.\n   *\n   * If the value of the `field` property is an Array, `ne()` includes items\n   * in which none of the elements of the Array match the specified `value`.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object representing the refined query.\n   */\n  ne(field: string, value: any): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value is greater than or equal to the specified\n   * value.\n   *\n   * The `ge()` function refines this filter to only\n   * match items where the value of the specified property is greater than or\n   * equal to the specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type does not match the same number stored as a Number type.\n   *\n   * If a property contains a number as a String, that value will be compared\n   * alphabetically and not numerically. Items that do not have a value for the\n   * specified property are ranked lowest.\n   *\n   * The following types of properties can be compared:\n   * - Number: Compares numerically.\n   * - Date: Compares JavaScript Date objects.\n   * - String: Compares lexicographically,\n   *   so `\"abc\"` is greater than or equal to `\"ABC\"` (because of the greater than),\n   *   but `\"ABC\"` is not greater than or equal to `\"abc\"`.\n   * - Reference: Compares by the ID of the referenced item as a String.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object representing the refined query.\n   */\n  ge(field: string, value: Comparable): Self\n\n  /**\n   * Alias for `ge()`\n   * @internal\n   */\n  gte(field: string, value: Comparable): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value is greater than the specified value.\n   *\n   * The `gt()` function refines this filter to only match\n   * items where the value of the specified property is greater than the specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type does not match the same number stored as a Number type.\n   *\n   * If a property contains a number as a String, that value will be compared\n   * alphabetically and not numerically. Items that do not have a value for the\n   * specified property are ranked lowest.\n   *\n   * The following types of properties can be compared:\n   * - Number: Compares numerically.\n   * - Date: Compares JavaScript Date objects.\n   * - String: Compares lexicographically, so `\"text\"` is greater than `\"Text\"`.\n   * - Reference: Compares by the ID of the referenced item as a String.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object with the query definition, based on the supplied parameters.\n   */\n  gt(field: string, value: Comparable): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value is less than or equal to the specified\n   * value.\n   *\n   * The `le()` function refines this filter to only match\n   * items where the value of the specified property is less than or equal to the\n   * specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type does not match the same number stored as a Number type.\n   *\n   * If a property contains a number as a String, that value will be compared\n   * alphabetically and not numerically. Items that do not have a value for the\n   * specified property are ranked lowest.\n   *\n   * The following types of properties can be compared:\n   * - Number: Compares numerically.\n   * - Date: Compares JavaScript Date objects.\n   * - String: Compares lexicographically,\n   *   so `\"ABC\"` is less than or equal to `\"abc\"` (because of the less than),\n   *   but `\"abc\"` is not less than or equal to `\"ABC\"`.\n   * - Reference: Compares by the ID of the referenced item as a String.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object representing the refined query.\n   */\n  le(field: string, value: Comparable): Self\n\n  /**\n   * Alias for `le()`\n   * @internal\n   */\n  lte(field: string, value: Comparable): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value is less than the specified value.\n   *\n   * The `lt()` function refines this filter to only match\n   * items where the value of the specified property is less than the specified `value`.\n   *\n   * It only matches values of the same type. For example, a number value stored\n   * as a String type does not match the same number stored as a Number type.\n   *\n   * If a property contains a number as a String, that value will be compared\n   * alphabetically and not numerically. Items that do not have a value for the\n   * specified property are ranked lowest.\n   *\n   * The following types of properties can be compared:\n   * - Number: Compares numerically.\n   * - Date: Compares JavaScript Date objects.\n   * - String: Compares lexicographically, so `\"Text\"` is less than `\"text\"`.\n   * - Reference: Compares by the ID of the referenced item as a String.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param value - The value to match against.\n   * @requiredField value\n   * @returns An object with the query definition, based on the supplied parameters.\n   */\n  lt(field: string, value: Comparable): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property has any value.\n   *\n   * The `isNotEmpty()` function refines this filter to only match items where the\n   * value of the specified property is not `null` or `undefined`.\n   *\n   * If the property contains any value at all for a given item, including the\n   * empty string or an invalid value, that item will match the query.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property in which to check for a value.\n   * @requiredField field\n   * @returns An object representing the refined query.\n   */\n  isNotEmpty(field: string): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property does not exist or does not have any value.\n   *\n   * The `isEmpty()` function refines this filter to only match items where the\n   * value of the specified property is `null` or `undefined` or the property does\n   * not exist.\n   *\n   * If the property contains any value at all for a given item, including the\n   * empty string or an invalid value, that item will match the query.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property in which to check for a value.\n   * @requiredField field\n   * @returns An object representing the refined query.\n   */\n  isEmpty(field: string): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value starts with a specified string.\n   *\n   * The `startsWith()` function refines this filter to\n   * only match items where the value of the specified property starts with the\n   * defined `string`. Matching with `startsWith()` is not case sensitive, so `\"TEXT\"` starts\n   * with `\"tex\"`.\n   *\n   * You can only use `startsWith()` with a property whose value is a String or Reference.\n   * When using a Reference, `startsWith()` matches by the ID of the referenced item as Strings.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with the `value` parameter.\n   * @requiredField field\n   * @param value - The string to look for at the beginning of the specified property value.\n   * @requiredField value\n   * @returns A `WixDataQuery` object representing the refined query.\n   */\n  startsWith(field: string, value: string): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value ends with a specified string.\n   *\n   * The `endsWith()` function refines this filter to only\n   * match items where the value of the specified property ends with the specified\n   * `string`. Matching with `endsWith()` is not case sensitive, so `\"TEXT\"` ends\n   * with `\"ext\"`.\n   *\n   * You can only use `endsWith()` with a property whose value is a String or Reference.\n   * When using a Reference, `endsWith()` matches by the ID of the referenced item as Strings.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with the string.\n   * @requiredField field\n   * @param value - The string to look for at the end of the specified property value.\n   * @requiredField value\n   * @returns A `WixDataQuery` object representing the refined query.\n   */\n  endsWith(field: string, value: string): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value contains a specified string.\n   *\n   * The `contains()` function refines this filter to\n   * only match items where the value of the specified property contains the\n   * specified `string`. Matching with `contains()` is not case sensitive, so\n   * `\"text\"` does contain `\"Tex\"`.\n   *\n   * You can use `contains()` with a property whose value is a String or a Reference.\n   * For properties of type reference it is recommended that you use the [`eq()`](#eq)\n   * function instead of `contains()`. With properties that are References, `contains()`\n   * matches by the ID of the referenced item as a String.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with the string.\n   * @requiredField field\n   * @param value - The string to look for inside the specified property value.\n   * @requiredField value\n   * @returns An object representing the refined query.\n   */\n  contains(field: string, value: string): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value equals any of the specified `values`\n   * parameters.\n   *\n   * The `hasSome()` function refines this filter to\n   * only match items where the value of the specified property equals any of\n   * the specified values.\n   *\n   * Matching strings with `hasSome()` is case sensitive, so `\"text\"` is not equal to `\"Text\"`.\n   *\n   * If the value of the specified property is an array, `hasSome()` will match\n   * if any of the elements of that array match any of the specified values.\n   *\n   * If the specified property contains multiple references, pass item IDs in the\n   * `value` property. In such a case, `hasSome()` will match if any of the\n   * multiple references match any of the specified ID values.\n   *\n   * You can specify a list of values to match by providing an array of\n   * String, Number, or Date types as the `value` parameters.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param values - The values to match against.\n   * @requiredField values\n   * @returns An object representing the refined query.\n   */\n  hasSome(field: string, ...values: Comparable[]): Self\n\n  /**\n   * Overload for `hasSome()`\n   * @public\n   * @documentationMaturity preview\n   */\n  hasSome(field: string, values: Comparable[]): Self\n\n  /**\n   * Alias for `hasSome()`\n   * @internal\n   */\n  in(field: string, ...values: Comparable[]): Self\n\n  /**\n   * Alias for `hasSome()`\n   * @internal\n   */\n  in(field: string, values: Comparable[]): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property values equals all of the specified `value`\n   * parameters.\n   *\n   * The `hasAll()` function refines this filter to\n   * only match items where the value of the specified property equals all of\n   * the specified values.\n   *\n   * Matching strings with `hasAll()` is case sensitive, so `\"text\"` is not equal to `\"Text\"`.\n   *\n   * If the value of the specified property is an array, `hasAll()` will match\n   * if there is a match in the elements of that array for all of the specified\n   * values.\n   *\n   * You can specify a list of values to match by providing an array of\n   * String, Number, or Date types as the `value` parameters.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with `value`.\n   * @requiredField field\n   * @param values - The values to match against.\n   * @requiredField values\n   * @returns An object representing the refined query.\n   */\n  hasAll(field: string, ...values: Comparable[]): Self\n\n  /**\n   * Overload for `hasAll()`\n   * @public\n   * @documentationMaturity preview\n   */\n  hasAll(field: string, values: Comparable[]): Self\n\n  /**\n   * Exists filter.\n   * @returns `current $and (field $exists value)`\n   * @internal\n   */\n  exists(field: string, value: boolean): Self\n\n  /**\n   * Adds an `or` condition to the query or filter.\n   *\n   * The `or()` function adds an inclusive `or` condition to this filter. A query or filter\n   * with an `or` returns all the items that match the query or filter as defined up to\n   * the `or` function, the items that match the query or filter passed to the `or`\n   * function, and the items that match both.\n   *\n   * The collections used by both the initial query and the query passed\n   * to the `or` function must be the same.\n   *\n   * The 'or()' function is designed to work with 2 or more queries or filters.\n   * If you use it on its own, it will return all the items in a collection.\n   * @public\n   * @documentationMaturity preview\n   * @param filter - A filter to add to the initial filter as an `or` condition.\n   * @requiredField filter\n   * @returns An object representing the refined query.\n   */\n  or(filter: WithFilter<any>): Self\n\n  /**\n   * Adds an `and` condition to the query or filter.\n   *\n   * The `and()` function adds an and condition to this query. A query or filter with an `and` returns all the items\n   * that match the query or filter as defined up to the `and` function and also match the query or filter passed to\n   * the `and` function.\n   *\n   * Note that when chaining multiple `WixDataFilter` functions to a query an and condition is assumed. In such cases,\n   * you do not need to add a call to the `and()` function. For example, this query returns results where status is\n   * active **and** age is greater than 25.\n   * ```js\n   * wixData.query(\"myCollection\").eq(\"status\", \"active\").gt(\"age\", 25);\n   * ```\n   *\n   * The `and()` function is needed when performing compound queries. For example, the final query in this set of\n   * queries returns results where status is either pending or rejected **and** age is either less than 25 or greater\n   * than 65.\n   * ```js\n   * let statusQuery = wixData\n   *   .query(\"myCollection\")\n   *   .eq(\"status\", \"pending\")\n   *   .or(wixData.query(\"myCollection\").eq(\"status\", \"rejected\"));\n   *\n   * let ageQuery = wixData\n   *   .query(\"myCollection\")\n   *   .lt(\"age\", 25)\n   *   .or(wixData.query(\"myCollection\").gt(\"age\", 65));\n   *\n   * let statusAndAgeQuery = statusQuery.and(ageQuery);\n   * ```\n   *\n   * The collections referenced by both the initial query and the query passed to the `and` function must be the same.\n   *\n   * The `and()` function is designed to work with 2 or more queries or filters. If you use it on its own, it will\n   * return all the items in a collection.\n   * @public\n   * @documentationMaturity preview\n   * @param filter - A filter to add to the initial query as an `and` condition.\n   * @requiredField filter\n   * @returns An object representing the refined query.\n   */\n  and(filter: WithFilter<any>): Self\n\n  /**\n   * Adds a `not` condition to the query or filter.\n   *\n   * The `not()` function adds a `not` condition to this filter. A query or filter with a `not`\n   * returns all the items that match the query or filter as defined up to the `not`\n   * function, but don't match the query or filter passed to the `not` function.\n   *\n   * If the query or filter only contains a `not()` function, it returns all the items\n   * that don't match the query defined by the `not` method.\n   *\n   * The collections referenced by both the initial query and the query passed\n   * to the `not` function must be the same.\n   * @public\n   * @documentationMaturity preview\n   * @param filter - A filter to add to the initial filter as a `not` condition.\n   * @requiredField filter\n   * @returns An object representing the refined query.\n   */\n  not(filter: WithFilter<any>): Self\n\n  /**\n   * Refines a query or filter to match items whose specified property value is within a specified range.\n   *\n   * The `between()` function refines this query to only match items where the value of the specified property is\n   * greater than or equal to `rangeStart` and less than `rangeEnd`.\n   *\n   * It only matches values of the same type. For example, a number value stored as a String type does not match the\n   * same number stored as a Number type.\n   *\n   * If a property contains a number as a String, that value will be compared alphabetically and not numerically. Items\n   * that do not have a value for the specified property are ranked lowest.\n   *\n   * The following types of properties can be compared:\n   * - Number: Compares numerically.\n   * - Date: Compares JavaScript Date objects.\n   * - String: Compares lexicographically, so\n   *   - `\"A\"` and `\"M\"` are between `\"A\"` and `\"Z\"`, but `\"a\"`, `\"m\"`, `\"z\"` and `\"Z\"` are not.\n   *   - `\"A\"`, `\"M\"`, `\"Z\"`, and `\"a\"` are between `\"A\"` and `\"z\"`, but `\"z\"` is not.\n   * @public\n   * @documentationMaturity preview\n   * @param field - The property whose value will be compared with rangeStart and rangeEnd.\n   * @requiredField field\n   * @param rangeStart - The beginning value of the range to match against.\n   * @requiredField rangeStart\n   * @param rangeEnd - The ending value of the range to match against.\n   * @requiredField rangeEnd\n   * @returns An object representing the refined query.\n   */\n  between<T extends Comparable>(field: string, rangeStart: T, rangeEnd: T): Self\n}\n"],"mappings":""}

package/dist/cjs/filter/filterBuilder.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = exports.PlatformizedFilterBuilder = exports.FilterBuilder = void 0;
+exports.filterBuilderFactory = filterBuilderFactory;
+exports.platformizedFilterBuilder = platformizedFilterBuilder;
+var _filterMixin = _interopRequireDefault(require("./filterMixin"));
+class FilterBuilder extends (0, _filterMixin.default)() {
+  get constructorName() {
+    return 'FilterBuilder';
+  }
+  _build() {
+    return this.getFilterModel();
+  }
+}
+exports.FilterBuilder = FilterBuilder;
+class PlatformizedFilterBuilder extends (0, _filterMixin.default)() {
+  in(...args) {
+    return this._AndSetOperand('$in', '.in', args);
+  }
+  exists(...args) {
+    return this._binaryAnd('$exists', '.exists', args);
+  }
+  gte(field, value) {
+    return this.ge(field, value);
+  }
+  lte(field, value) {
+    return this.le(field, value);
+  }
+  build() {
+    return this.getFilterModel();
+  }
+  hasAnyFilter() {
+    var _this$filterTree;
+    if (this.filterTree === null || this.filterTree === undefined) {
+      return false;
+    }
+    if (!Object.keys(this.filterTree).every(x => x === '$and')) {
+      return false;
+    }
+    return (((_this$filterTree = this.filterTree) == null || (_this$filterTree = _this$filterTree.$and) == null ? void 0 : _this$filterTree.length) ?? 0) > 0;
+  }
+}
+exports.PlatformizedFilterBuilder = PlatformizedFilterBuilder;
+function platformizedFilterBuilder(options = {}) {
+  return new PlatformizedFilterBuilder(options);
+}
+function filterBuilderFactory() {
+  return new FilterBuilder({});
+}
+var _default = exports.default = filterBuilderFactory;
+//# sourceMappingURL=filterBuilder.js.map

package/dist/cjs/filter/filterBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_filterMixin","_interopRequireDefault","require","FilterBuilder","filterMixin","constructorName","_build","getFilterModel","exports","PlatformizedFilterBuilder","in","args","_AndSetOperand","exists","_binaryAnd","gte","field","value","ge","lte","le","build","hasAnyFilter","_this$filterTree","filterTree","undefined","Object","keys","every","x","$and","length","platformizedFilterBuilder","options","filterBuilderFactory","_default","default"],"sources":["../../../src/filter/filterBuilder.ts"],"sourcesContent":["import filterMixin from './filterMixin'\nimport WithFilter from './WithFilter'\n\nexport class FilterBuilder extends filterMixin() {\n  get constructorName() {\n    return 'FilterBuilder'\n  }\n\n  _build() {\n    return this.getFilterModel()\n  }\n}\n\nexport class PlatformizedFilterBuilder\n  extends filterMixin()\n  implements WithFilter<PlatformizedFilterBuilder>\n{\n  in(...args: any[]) {\n    return this._AndSetOperand('$in', '.in', args)\n  }\n\n  exists(...args: any[]) {\n    return this._binaryAnd('$exists', '.exists', args)\n  }\n\n  gte(field: any, value: any) {\n    return this.ge(field, value)\n  }\n\n  lte(field: any, value: any) {\n    return this.le(field, value)\n  }\n\n  build() {\n    return this.getFilterModel()\n  }\n\n  hasAnyFilter(): boolean {\n    if (this.filterTree === null || this.filterTree === undefined) {\n      return false\n    }\n    if (!Object.keys(this.filterTree).every((x) => x === '$and')) {\n      return false\n    }\n    return (this.filterTree?.$and?.length ?? 0) > 0\n  }\n}\n\nexport function platformizedFilterBuilder(options = {}) {\n  return new PlatformizedFilterBuilder(options)\n}\n\nexport function filterBuilderFactory() {\n  return new FilterBuilder({})\n}\n\nexport default filterBuilderFactory\n"],"mappings":";;;;;;;AAAA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AAGO,MAAMC,aAAa,SAAS,IAAAC,oBAAW,EAAC,CAAC,CAAC;EAC/C,IAAIC,eAAeA,CAAA,EAAG;IACpB,OAAO,eAAe;EACxB;EAEAC,MAAMA,CAAA,EAAG;IACP,OAAO,IAAI,CAACC,cAAc,CAAC,CAAC;EAC9B;AACF;AAACC,OAAA,CAAAL,aAAA,GAAAA,aAAA;AAEM,MAAMM,yBAAyB,SAC5B,IAAAL,oBAAW,EAAC,CAAC,CAEvB;EACEM,EAAEA,CAAC,GAAGC,IAAW,EAAE;IACjB,OAAO,IAAI,CAACC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAED,IAAI,CAAC;EAChD;EAEAE,MAAMA,CAAC,GAAGF,IAAW,EAAE;IACrB,OAAO,IAAI,CAACG,UAAU,CAAC,SAAS,EAAE,SAAS,EAAEH,IAAI,CAAC;EACpD;EAEAI,GAAGA,CAACC,KAAU,EAAEC,KAAU,EAAE;IAC1B,OAAO,IAAI,CAACC,EAAE,CAACF,KAAK,EAAEC,KAAK,CAAC;EAC9B;EAEAE,GAAGA,CAACH,KAAU,EAAEC,KAAU,EAAE;IAC1B,OAAO,IAAI,CAACG,EAAE,CAACJ,KAAK,EAAEC,KAAK,CAAC;EAC9B;EAEAI,KAAKA,CAAA,EAAG;IACN,OAAO,IAAI,CAACd,cAAc,CAAC,CAAC;EAC9B;EAEAe,YAAYA,CAAA,EAAY;IAAA,IAAAC,gBAAA;IACtB,IAAI,IAAI,CAACC,UAAU,KAAK,IAAI,IAAI,IAAI,CAACA,UAAU,KAAKC,SAAS,EAAE;MAC7D,OAAO,KAAK;IACd;IACA,IAAI,CAACC,MAAM,CAACC,IAAI,CAAC,IAAI,CAACH,UAAU,CAAC,CAACI,KAAK,CAAEC,CAAC,IAAKA,CAAC,KAAK,MAAM,CAAC,EAAE;MAC5D,OAAO,KAAK;IACd;IACA,OAAO,CAAC,EAAAN,gBAAA,OAAI,CAACC,UAAU,cAAAD,gBAAA,GAAfA,gBAAA,CAAiBO,IAAI,qBAArBP,gBAAA,CAAuBQ,MAAM,KAAI,CAAC,IAAI,CAAC;EACjD;AACF;AAACvB,OAAA,CAAAC,yBAAA,GAAAA,yBAAA;AAEM,SAASuB,yBAAyBA,CAACC,OAAO,GAAG,CAAC,CAAC,EAAE;EACtD,OAAO,IAAIxB,yBAAyB,CAACwB,OAAO,CAAC;AAC/C;AAEO,SAASC,oBAAoBA,CAAA,EAAG;EACrC,OAAO,IAAI/B,aAAa,CAAC,CAAC,CAAC,CAAC;AAC9B;AAAC,IAAAgC,QAAA,GAAA3B,OAAA,CAAA4B,OAAA,GAEcF,oBAAoB"}

package/dist/cjs/filter/filterMixin.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = exports.FilterValidator = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeUtils = require("../utils/type-utils");
+var _baseValidator = require("../errors/base-validator");
+var _errors = require("../errors/errors");
+var _filterBuilder = require("@wix/filter-builder");
+const filterMixin = (Base = class {}) => class extends (0, _filterBuilder.filterMixin)(Base) {
+  constructor(origin) {
+    super(origin);
+    (0, _defineProperty2.default)(this, "validateCollectionName", void 0);
+    this.validateCollectionName = (origin == null ? void 0 : origin.validateCollectionName) ?? true;
+  }
+  or(otherQuery) {
+    const orQuery = super.or.apply(this, arguments);
+    return this._validateCollectionName(orQuery, otherQuery, '.or');
+  }
+  and(otherQuery) {
+    const andQuery = super.and.apply(this, arguments);
+    return this._validateCollectionName(andQuery, otherQuery, '.and');
+  }
+  not(otherQuery) {
+    const notQuery = super.not.apply(this, arguments);
+    return this._validateCollectionName(notQuery, otherQuery, '.not');
+  }
+  _validateCollectionName(query, originalQuery, operationName) {
+    if (query.invalidArguments.length > 0 || !this.validateCollectionName) {
+      return query;
+    }
+    const withCollectionName = withCollectionNameIfUnset(originalQuery, this.collectionName);
+    const [newInvalidArguments, valid] = new FilterValidator(operationName, query.invalidArguments, this.constructor, this.constructorName ?? this.constructor.name).isForCollection(withCollectionName, this.collectionName).validateAndAggregate();
+    if (!valid) {
+      return this._copy(this.filterTree, newInvalidArguments);
+    }
+    return query;
+  }
+
+  // used only from data binding router internally
+  _matchesUrlized(field, operand) {
+    const [newInvalidArguments, valid] = this._filterValidator('._matchesUrlized').arityIsTwo(arguments).validFieldName(field).typeIsString(operand).validateAndAggregate();
+    if (valid) {
+      const newFilterTree = this._makeNewFilter(field,
+      // @ts-ignore-next-line
+      ...createMatchesOrInFilter(operand));
+      return this._copy(newFilterTree, newInvalidArguments);
+    }
+    return this._copy(this.filterTree, newInvalidArguments);
+  }
+  getFilterModel() {
+    if (this.invalidArguments.length > 0) {
+      throw (0, _errors.validationError)(_errors.messages.filterBuilderInvalid(this.invalidArguments));
+    }
+    return super.getFilterModel();
+  }
+  _filterValidator(filterOperatorName) {
+    return new FilterValidator(filterOperatorName, this.invalidArguments, this.constructor, this.constructorName ?? this.constructor.name);
+  }
+};
+function createMatchesOrInFilter(operand) {
+  if (looksLikeAnInteger(operand)) {
+    // eslint-disable-next-line radix
+    return ['$in', [operand, Number.parseInt(operand)]];
+  } else {
+    return ['$matches', {
+      ignoreCase: true,
+      spec: createMatchSpec(operand)
+    }];
+  }
+  function looksLikeAnInteger(str) {
+    return /^-?[0-9]{1,16}$/.test(str);
+  }
+}
+function createMatchSpec(fieldValue) {
+  const literals = fieldValue.split('-');
+  const result = [];
+  for (let i = 0; i < literals.length - 1; i++) {
+    appendLiteralSegment(result, literals[i]);
+    appendAnyOfSegment(result);
+  }
+  appendLiteralSegment(result, literals[literals.length - 1]);
+  return result;
+  function appendLiteralSegment(res, literalValue) {
+    if (literalValue.length !== 0) {
+      res.push({
+        type: 'literal',
+        value: literalValue
+      });
+    }
+  }
+  function appendAnyOfSegment(res) {
+    res.push({
+      type: 'anyOf',
+      value: ' \t\n-'
+    });
+  }
+}
+class FilterValidator extends _baseValidator.AggregatingValidator {
+  constructor(operatorName, previousInvalidArguments, ctor, constructorName) {
+    super(previousInvalidArguments);
+    this.operatorName = operatorName;
+    this.ctor = ctor;
+    this.constructorName = constructorName;
+  }
+  typeIsString(value) {
+    return this.addValidation(() => (0, _typeUtils.isString)(value), () => _errors.messages.filterValidations.typeIsString(this.operatorName, value));
+  }
+  typeIsStringNumberOrDate(value) {
+    return this.addValidation(() => isDateStringOrNumber(value), () => _errors.messages.filterValidations.typeIsStringNumberOrDate(this.operatorName, value));
+  }
+  sameType(first, second) {
+    return this.addValidation(() => (0, _typeUtils.typeForDisplay)(first) === (0, _typeUtils.typeForDisplay)(second), () => _errors.messages.filterValidations.sameType(this.operatorName, first, second));
+  }
+  typeIsStringNumberOrDateForAll(values) {
+    return this.addValidation(() => values.every(isDateStringOrNumber), () => _errors.messages.filterValidations.typeIsStringNumberOrDateForAll(this.operatorName));
+  }
+  validFieldName(field) {
+    return this.addValidation(() => (0, _typeUtils.isString)(field), () => _errors.messages.filterValidations.validFieldName(this.operatorName, field));
+  }
+  isInstanceOfSameClass(obj) {
+    return this.addValidation(() => obj instanceof this.ctor, () => _errors.messages.filterValidations.isInstanceOfSameClass(this.operatorName, this.constructorName, obj));
+  }
+  isForCollection(otherFilterBuilder, expectedCollectionName) {
+    return this.addValidation(() => otherFilterBuilder.collectionName === expectedCollectionName, () => _errors.messages.filterValidations.isForCollection(this.operatorName, this.constructorName, otherFilterBuilder.collectionName));
+  }
+}
+exports.FilterValidator = FilterValidator;
+function isDateStringOrNumber(value) {
+  return (0, _typeUtils.isString)(value) || (0, _typeUtils.isNumber)(value) || (0, _typeUtils.isDate)(value);
+}
+function withCollectionNameIfUnset(filter, name) {
+  if (!filter || !filter.constructor) {
+    return filter;
+  }
+  const collectionName = filter.collectionName ? filter.collectionName : name;
+  return new filter.constructor({
+    ...filter,
+    collectionName
+  });
+}
+var _default = exports.default = filterMixin;
+//# sourceMappingURL=filterMixin.js.map

package/dist/cjs/filter/filterMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typeUtils","require","_baseValidator","_errors","_filterBuilder","filterMixin","Base","genericFilterMixin","constructor","origin","_defineProperty2","default","validateCollectionName","or","otherQuery","orQuery","apply","arguments","_validateCollectionName","and","andQuery","not","notQuery","query","originalQuery","operationName","invalidArguments","length","withCollectionName","withCollectionNameIfUnset","collectionName","newInvalidArguments","valid","FilterValidator","constructorName","name","isForCollection","validateAndAggregate","_copy","filterTree","_matchesUrlized","field","operand","_filterValidator","arityIsTwo","validFieldName","typeIsString","newFilterTree","_makeNewFilter","createMatchesOrInFilter","getFilterModel","validationError","messages","filterBuilderInvalid","filterOperatorName","looksLikeAnInteger","Number","parseInt","ignoreCase","spec","createMatchSpec","str","test","fieldValue","literals","split","result","i","appendLiteralSegment","appendAnyOfSegment","res","literalValue","push","type","value","AggregatingValidator","operatorName","previousInvalidArguments","ctor","addValidation","isString","filterValidations","typeIsStringNumberOrDate","isDateStringOrNumber","sameType","first","second","typeForDisplay","typeIsStringNumberOrDateForAll","values","every","isInstanceOfSameClass","obj","otherFilterBuilder","expectedCollectionName","exports","isNumber","isDate","filter","_default"],"sources":["../../../src/filter/filterMixin.ts"],"sourcesContent":["import { typeForDisplay, isDate, isString, isNumber } from '../utils/type-utils'\nimport { AggregatingValidator } from '../errors/base-validator'\nimport { messages, validationError } from '../errors/errors'\nimport {\n  filterMixin as genericFilterMixin,\n  Validator,\n} from '@wix/filter-builder'\n\nconst filterMixin = (Base: any = class {}) =>\n  class extends genericFilterMixin(Base) {\n    readonly validateCollectionName: boolean\n\n    constructor(origin?: {\n      validateCollectionName?: boolean\n      filterTree?: object\n      invalidArguments?: string[]\n      encoder?: Function\n    }) {\n      super(origin)\n      this.validateCollectionName = origin?.validateCollectionName ?? true\n    }\n\n    or(otherQuery: any) {\n      const orQuery = super.or.apply(this, arguments as any)\n      return this._validateCollectionName(orQuery, otherQuery, '.or')\n    }\n\n    and(otherQuery: any) {\n      const andQuery = super.and.apply(this, arguments as any)\n      return this._validateCollectionName(andQuery, otherQuery, '.and')\n    }\n\n    not(otherQuery: any) {\n      const notQuery = super.not.apply(this, arguments as any)\n      return this._validateCollectionName(notQuery, otherQuery, '.not')\n    }\n\n    _validateCollectionName(\n      query: any,\n      originalQuery: any,\n      operationName: string\n    ) {\n      if (query.invalidArguments.length > 0 || !this.validateCollectionName) {\n        return query\n      }\n      const withCollectionName = withCollectionNameIfUnset(\n        originalQuery,\n        this.collectionName\n      )\n      const [newInvalidArguments, valid] = new FilterValidator(\n        operationName,\n        query.invalidArguments,\n        this.constructor,\n        this.constructorName ?? this.constructor.name\n      )\n        .isForCollection(withCollectionName, this.collectionName)\n        .validateAndAggregate()\n\n      if (!valid) {\n        return this._copy(this.filterTree, newInvalidArguments)\n      }\n      return query\n    }\n\n    // used only from data binding router internally\n    _matchesUrlized(field: any, operand: any) {\n      const [newInvalidArguments, valid] = this._filterValidator(\n        '._matchesUrlized'\n      )\n        .arityIsTwo(arguments)\n        .validFieldName(field)\n        .typeIsString(operand)\n        .validateAndAggregate()\n\n      if (valid) {\n        const newFilterTree = this._makeNewFilter(\n          field,\n          // @ts-ignore-next-line\n          ...createMatchesOrInFilter(operand)\n        )\n        return this._copy(newFilterTree, newInvalidArguments)\n      }\n\n      return this._copy(this.filterTree, newInvalidArguments)\n    }\n\n    getFilterModel() {\n      if (this.invalidArguments.length > 0) {\n        throw validationError(\n          messages.filterBuilderInvalid(this.invalidArguments)\n        )\n      }\n      return super.getFilterModel()\n    }\n\n    _filterValidator(filterOperatorName: string): Validator {\n      return new FilterValidator(\n        filterOperatorName,\n        this.invalidArguments,\n        this.constructor,\n        this.constructorName ?? this.constructor.name\n      )\n    }\n  }\n\nfunction createMatchesOrInFilter(operand: string) {\n  if (looksLikeAnInteger(operand)) {\n    // eslint-disable-next-line radix\n    return ['$in', [operand, Number.parseInt(operand)]]\n  } else {\n    return [\n      '$matches',\n      {\n        ignoreCase: true,\n        spec: createMatchSpec(operand),\n      },\n    ]\n  }\n\n  function looksLikeAnInteger(str: string) {\n    return /^-?[0-9]{1,16}$/.test(str)\n  }\n}\ninterface MatchSpec {\n  type: string\n  value: string\n}\n\nfunction createMatchSpec(fieldValue: string) {\n  const literals = fieldValue.split('-')\n  const result: MatchSpec[] = []\n\n  for (let i = 0; i < literals.length - 1; i++) {\n    appendLiteralSegment(result, literals[i])\n    appendAnyOfSegment(result)\n  }\n  appendLiteralSegment(result, literals[literals.length - 1])\n\n  return result\n\n  function appendLiteralSegment(res: MatchSpec[], literalValue: string) {\n    if (literalValue.length !== 0) {\n      res.push({ type: 'literal', value: literalValue })\n    }\n  }\n\n  function appendAnyOfSegment(res: MatchSpec[]) {\n    res.push({ type: 'anyOf', value: ' \\t\\n-' })\n  }\n}\n\nexport class FilterValidator extends AggregatingValidator {\n  constructor(\n    public operatorName: string,\n    previousInvalidArguments: string[],\n    private ctor: any,\n    private constructorName: string\n  ) {\n    super(previousInvalidArguments)\n  }\n\n  typeIsString(value: any) {\n    return this.addValidation(\n      () => isString(value),\n      () => messages.filterValidations.typeIsString(this.operatorName, value)\n    )\n  }\n\n  typeIsStringNumberOrDate(value: any) {\n    return this.addValidation(\n      () => isDateStringOrNumber(value),\n      () =>\n        messages.filterValidations.typeIsStringNumberOrDate(\n          this.operatorName,\n          value\n        )\n    )\n  }\n\n  sameType(first: any, second: any) {\n    return this.addValidation(\n      () => typeForDisplay(first) === typeForDisplay(second),\n      () =>\n        messages.filterValidations.sameType(this.operatorName, first, second)\n    )\n  }\n\n  typeIsStringNumberOrDateForAll(values: any) {\n    return this.addValidation(\n      () => values.every(isDateStringOrNumber),\n      () =>\n        messages.filterValidations.typeIsStringNumberOrDateForAll(\n          this.operatorName\n        )\n    )\n  }\n\n  validFieldName(field: any) {\n    return this.addValidation(\n      () => isString(field),\n      () => messages.filterValidations.validFieldName(this.operatorName, field)\n    )\n  }\n\n  isInstanceOfSameClass(obj: any) {\n    return this.addValidation(\n      () => obj instanceof this.ctor,\n      () =>\n        messages.filterValidations.isInstanceOfSameClass(\n          this.operatorName,\n          this.constructorName,\n          obj\n        )\n    )\n  }\n\n  isForCollection(otherFilterBuilder: any, expectedCollectionName: any) {\n    return this.addValidation(\n      () => otherFilterBuilder.collectionName === expectedCollectionName,\n      () =>\n        messages.filterValidations.isForCollection(\n          this.operatorName,\n          this.constructorName,\n          otherFilterBuilder.collectionName\n        )\n    )\n  }\n}\n\nfunction isDateStringOrNumber(value: any) {\n  return isString(value) || isNumber(value) || isDate(value)\n}\n\nfunction withCollectionNameIfUnset(filter: any, name: string) {\n  if (!filter || !filter.constructor) {\n    return filter\n  }\n\n  const collectionName = filter.collectionName ? filter.collectionName : name\n\n  return new filter.constructor({ ...filter, collectionName })\n}\n\nexport default filterMixin\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AAKA,MAAMI,WAAW,GAAGA,CAACC,IAAS,GAAG,MAAM,EAAE,KACvC,cAAc,IAAAC,0BAAkB,EAACD,IAAI,CAAC,CAAC;EAGrCE,WAAWA,CAACC,MAKX,EAAE;IACD,KAAK,CAACA,MAAM,CAAC;IAAA,IAAAC,gBAAA,CAAAC,OAAA;IACb,IAAI,CAACC,sBAAsB,GAAG,CAAAH,MAAM,oBAANA,MAAM,CAAEG,sBAAsB,KAAI,IAAI;EACtE;EAEAC,EAAEA,CAACC,UAAe,EAAE;IAClB,MAAMC,OAAO,GAAG,KAAK,CAACF,EAAE,CAACG,KAAK,CAAC,IAAI,EAAEC,SAAgB,CAAC;IACtD,OAAO,IAAI,CAACC,uBAAuB,CAACH,OAAO,EAAED,UAAU,EAAE,KAAK,CAAC;EACjE;EAEAK,GAAGA,CAACL,UAAe,EAAE;IACnB,MAAMM,QAAQ,GAAG,KAAK,CAACD,GAAG,CAACH,KAAK,CAAC,IAAI,EAAEC,SAAgB,CAAC;IACxD,OAAO,IAAI,CAACC,uBAAuB,CAACE,QAAQ,EAAEN,UAAU,EAAE,MAAM,CAAC;EACnE;EAEAO,GAAGA,CAACP,UAAe,EAAE;IACnB,MAAMQ,QAAQ,GAAG,KAAK,CAACD,GAAG,CAACL,KAAK,CAAC,IAAI,EAAEC,SAAgB,CAAC;IACxD,OAAO,IAAI,CAACC,uBAAuB,CAACI,QAAQ,EAAER,UAAU,EAAE,MAAM,CAAC;EACnE;EAEAI,uBAAuBA,CACrBK,KAAU,EACVC,aAAkB,EAClBC,aAAqB,EACrB;IACA,IAAIF,KAAK,CAACG,gBAAgB,CAACC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAACf,sBAAsB,EAAE;MACrE,OAAOW,KAAK;IACd;IACA,MAAMK,kBAAkB,GAAGC,yBAAyB,CAClDL,aAAa,EACb,IAAI,CAACM,cACP,CAAC;IACD,MAAM,CAACC,mBAAmB,EAAEC,KAAK,CAAC,GAAG,IAAIC,eAAe,CACtDR,aAAa,EACbF,KAAK,CAACG,gBAAgB,EACtB,IAAI,CAAClB,WAAW,EAChB,IAAI,CAAC0B,eAAe,IAAI,IAAI,CAAC1B,WAAW,CAAC2B,IAC3C,CAAC,CACEC,eAAe,CAACR,kBAAkB,EAAE,IAAI,CAACE,cAAc,CAAC,CACxDO,oBAAoB,CAAC,CAAC;IAEzB,IAAI,CAACL,KAAK,EAAE;MACV,OAAO,IAAI,CAACM,KAAK,CAAC,IAAI,CAACC,UAAU,EAAER,mBAAmB,CAAC;IACzD;IACA,OAAOR,KAAK;EACd;;EAEA;EACAiB,eAAeA,CAACC,KAAU,EAAEC,OAAY,EAAE;IACxC,MAAM,CAACX,mBAAmB,EAAEC,KAAK,CAAC,GAAG,IAAI,CAACW,gBAAgB,CACxD,kBACF,CAAC,CACEC,UAAU,CAAC3B,SAAS,CAAC,CACrB4B,cAAc,CAACJ,KAAK,CAAC,CACrBK,YAAY,CAACJ,OAAO,CAAC,CACrBL,oBAAoB,CAAC,CAAC;IAEzB,IAAIL,KAAK,EAAE;MACT,MAAMe,aAAa,GAAG,IAAI,CAACC,cAAc,CACvCP,KAAK;MACL;MACA,GAAGQ,uBAAuB,CAACP,OAAO,CACpC,CAAC;MACD,OAAO,IAAI,CAACJ,KAAK,CAACS,aAAa,EAAEhB,mBAAmB,CAAC;IACvD;IAEA,OAAO,IAAI,CAACO,KAAK,CAAC,IAAI,CAACC,UAAU,EAAER,mBAAmB,CAAC;EACzD;EAEAmB,cAAcA,CAAA,EAAG;IACf,IAAI,IAAI,CAACxB,gBAAgB,CAACC,MAAM,GAAG,CAAC,EAAE;MACpC,MAAM,IAAAwB,uBAAe,EACnBC,gBAAQ,CAACC,oBAAoB,CAAC,IAAI,CAAC3B,gBAAgB,CACrD,CAAC;IACH;IACA,OAAO,KAAK,CAACwB,cAAc,CAAC,CAAC;EAC/B;EAEAP,gBAAgBA,CAACW,kBAA0B,EAAa;IACtD,OAAO,IAAIrB,eAAe,CACxBqB,kBAAkB,EAClB,IAAI,CAAC5B,gBAAgB,EACrB,IAAI,CAAClB,WAAW,EAChB,IAAI,CAAC0B,eAAe,IAAI,IAAI,CAAC1B,WAAW,CAAC2B,IAC3C,CAAC;EACH;AACF,CAAC;AAEH,SAASc,uBAAuBA,CAACP,OAAe,EAAE;EAChD,IAAIa,kBAAkB,CAACb,OAAO,CAAC,EAAE;IAC/B;IACA,OAAO,CAAC,KAAK,EAAE,CAACA,OAAO,EAAEc,MAAM,CAACC,QAAQ,CAACf,OAAO,CAAC,CAAC,CAAC;EACrD,CAAC,MAAM;IACL,OAAO,CACL,UAAU,EACV;MACEgB,UAAU,EAAE,IAAI;MAChBC,IAAI,EAAEC,eAAe,CAAClB,OAAO;IAC/B,CAAC,CACF;EACH;EAEA,SAASa,kBAAkBA,CAACM,GAAW,EAAE;IACvC,OAAO,iBAAiB,CAACC,IAAI,CAACD,GAAG,CAAC;EACpC;AACF;AAMA,SAASD,eAAeA,CAACG,UAAkB,EAAE;EAC3C,MAAMC,QAAQ,GAAGD,UAAU,CAACE,KAAK,CAAC,GAAG,CAAC;EACtC,MAAMC,MAAmB,GAAG,EAAE;EAE9B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,QAAQ,CAACrC,MAAM,GAAG,CAAC,EAAEwC,CAAC,EAAE,EAAE;IAC5CC,oBAAoB,CAACF,MAAM,EAAEF,QAAQ,CAACG,CAAC,CAAC,CAAC;IACzCE,kBAAkB,CAACH,MAAM,CAAC;EAC5B;EACAE,oBAAoB,CAACF,MAAM,EAAEF,QAAQ,CAACA,QAAQ,CAACrC,MAAM,GAAG,CAAC,CAAC,CAAC;EAE3D,OAAOuC,MAAM;EAEb,SAASE,oBAAoBA,CAACE,GAAgB,EAAEC,YAAoB,EAAE;IACpE,IAAIA,YAAY,CAAC5C,MAAM,KAAK,CAAC,EAAE;MAC7B2C,GAAG,CAACE,IAAI,CAAC;QAAEC,IAAI,EAAE,SAAS;QAAEC,KAAK,EAAEH;MAAa,CAAC,CAAC;IACpD;EACF;EAEA,SAASF,kBAAkBA,CAACC,GAAgB,EAAE;IAC5CA,GAAG,CAACE,IAAI,CAAC;MAAEC,IAAI,EAAE,OAAO;MAAEC,KAAK,EAAE;IAAS,CAAC,CAAC;EAC9C;AACF;AAEO,MAAMzC,eAAe,SAAS0C,mCAAoB,CAAC;EACxDnE,WAAWA,CACFoE,YAAoB,EAC3BC,wBAAkC,EAC1BC,IAAS,EACT5C,eAAuB,EAC/B;IACA,KAAK,CAAC2C,wBAAwB,CAAC;IAAA,KALxBD,YAAoB,GAApBA,YAAoB;IAAA,KAEnBE,IAAS,GAATA,IAAS;IAAA,KACT5C,eAAuB,GAAvBA,eAAuB;EAGjC;EAEAY,YAAYA,CAAC4B,KAAU,EAAE;IACvB,OAAO,IAAI,CAACK,aAAa,CACvB,MAAM,IAAAC,mBAAQ,EAACN,KAAK,CAAC,EACrB,MAAMtB,gBAAQ,CAAC6B,iBAAiB,CAACnC,YAAY,CAAC,IAAI,CAAC8B,YAAY,EAAEF,KAAK,CACxE,CAAC;EACH;EAEAQ,wBAAwBA,CAACR,KAAU,EAAE;IACnC,OAAO,IAAI,CAACK,aAAa,CACvB,MAAMI,oBAAoB,CAACT,KAAK,CAAC,EACjC,MACEtB,gBAAQ,CAAC6B,iBAAiB,CAACC,wBAAwB,CACjD,IAAI,CAACN,YAAY,EACjBF,KACF,CACJ,CAAC;EACH;EAEAU,QAAQA,CAACC,KAAU,EAAEC,MAAW,EAAE;IAChC,OAAO,IAAI,CAACP,aAAa,CACvB,MAAM,IAAAQ,yBAAc,EAACF,KAAK,CAAC,KAAK,IAAAE,yBAAc,EAACD,MAAM,CAAC,EACtD,MACElC,gBAAQ,CAAC6B,iBAAiB,CAACG,QAAQ,CAAC,IAAI,CAACR,YAAY,EAAES,KAAK,EAAEC,MAAM,CACxE,CAAC;EACH;EAEAE,8BAA8BA,CAACC,MAAW,EAAE;IAC1C,OAAO,IAAI,CAACV,aAAa,CACvB,MAAMU,MAAM,CAACC,KAAK,CAACP,oBAAoB,CAAC,EACxC,MACE/B,gBAAQ,CAAC6B,iBAAiB,CAACO,8BAA8B,CACvD,IAAI,CAACZ,YACP,CACJ,CAAC;EACH;EAEA/B,cAAcA,CAACJ,KAAU,EAAE;IACzB,OAAO,IAAI,CAACsC,aAAa,CACvB,MAAM,IAAAC,mBAAQ,EAACvC,KAAK,CAAC,EACrB,MAAMW,gBAAQ,CAAC6B,iBAAiB,CAACpC,cAAc,CAAC,IAAI,CAAC+B,YAAY,EAAEnC,KAAK,CAC1E,CAAC;EACH;EAEAkD,qBAAqBA,CAACC,GAAQ,EAAE;IAC9B,OAAO,IAAI,CAACb,aAAa,CACvB,MAAMa,GAAG,YAAY,IAAI,CAACd,IAAI,EAC9B,MACE1B,gBAAQ,CAAC6B,iBAAiB,CAACU,qBAAqB,CAC9C,IAAI,CAACf,YAAY,EACjB,IAAI,CAAC1C,eAAe,EACpB0D,GACF,CACJ,CAAC;EACH;EAEAxD,eAAeA,CAACyD,kBAAuB,EAAEC,sBAA2B,EAAE;IACpE,OAAO,IAAI,CAACf,aAAa,CACvB,MAAMc,kBAAkB,CAAC/D,cAAc,KAAKgE,sBAAsB,EAClE,MACE1C,gBAAQ,CAAC6B,iBAAiB,CAAC7C,eAAe,CACxC,IAAI,CAACwC,YAAY,EACjB,IAAI,CAAC1C,eAAe,EACpB2D,kBAAkB,CAAC/D,cACrB,CACJ,CAAC;EACH;AACF;AAACiE,OAAA,CAAA9D,eAAA,GAAAA,eAAA;AAED,SAASkD,oBAAoBA,CAACT,KAAU,EAAE;EACxC,OAAO,IAAAM,mBAAQ,EAACN,KAAK,CAAC,IAAI,IAAAsB,mBAAQ,EAACtB,KAAK,CAAC,IAAI,IAAAuB,iBAAM,EAACvB,KAAK,CAAC;AAC5D;AAEA,SAAS7C,yBAAyBA,CAACqE,MAAW,EAAE/D,IAAY,EAAE;EAC5D,IAAI,CAAC+D,MAAM,IAAI,CAACA,MAAM,CAAC1F,WAAW,EAAE;IAClC,OAAO0F,MAAM;EACf;EAEA,MAAMpE,cAAc,GAAGoE,MAAM,CAACpE,cAAc,GAAGoE,MAAM,CAACpE,cAAc,GAAGK,IAAI;EAE3E,OAAO,IAAI+D,MAAM,CAAC1F,WAAW,CAAC;IAAE,GAAG0F,MAAM;IAAEpE;EAAe,CAAC,CAAC;AAC9D;AAAC,IAAAqE,QAAA,GAAAJ,OAAA,CAAApF,OAAA,GAEcN,WAAW"}

package/dist/cjs/filter/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+var _FilterTree = require("./FilterTree");
+exports.validateFilterTree = _FilterTree.validateFilterTree;
+exports.validateFilterOrThrow = _FilterTree.validateFilterOrThrow;
+var _WithFilter = _interopRequireDefault(require("./WithFilter"));
+exports.WithFilter = _WithFilter.default;
+var _filterBuilder = require("./filterBuilder");
+exports.filterBuilderFactory = _filterBuilder.filterBuilderFactory;
+exports.platformizedFilterBuilder = _filterBuilder.platformizedFilterBuilder;
+exports.PlatformizedFilterBuilder = _filterBuilder.PlatformizedFilterBuilder;
+var _filterMixin = _interopRequireDefault(require("./filterMixin"));
+exports.filterMixin = _filterMixin.default;
+//# sourceMappingURL=index.js.map

package/dist/cjs/filter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FilterTree","require","exports","validateFilterTree","validateFilterOrThrow","_WithFilter","_interopRequireDefault","WithFilter","default","_filterBuilder","filterBuilderFactory","platformizedFilterBuilder","PlatformizedFilterBuilder","_filterMixin","filterMixin"],"sources":["../../../src/filter/index.ts"],"sourcesContent":["import { validateFilterTree, validateFilterOrThrow } from './FilterTree'\nimport type { FilterTree } from './FilterTree'\nimport WithFilter from './WithFilter'\nimport {\n  filterBuilderFactory,\n  platformizedFilterBuilder,\n  PlatformizedFilterBuilder,\n} from './filterBuilder'\nimport filterMixin from './filterMixin'\n\nexport type { FilterTree }\nexport {\n  validateFilterTree,\n  validateFilterOrThrow,\n  WithFilter,\n  filterBuilderFactory,\n  platformizedFilterBuilder,\n  PlatformizedFilterBuilder,\n  filterMixin,\n}\n"],"mappings":";;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAwEC,OAAA,CAAAC,kBAAA,GAAAH,WAAA,CAAAG,kBAAA;AAAAD,OAAA,CAAAE,qBAAA,GAAAJ,WAAA,CAAAI,qBAAA;AAExE,IAAAC,WAAA,GAAAC,sBAAA,CAAAL,OAAA;AAAqCC,OAAA,CAAAK,UAAA,GAAAF,WAAA,CAAAG,OAAA;AACrC,IAAAC,cAAA,GAAAR,OAAA;AAIwBC,OAAA,CAAAQ,oBAAA,GAAAD,cAAA,CAAAC,oBAAA;AAAAR,OAAA,CAAAS,yBAAA,GAAAF,cAAA,CAAAE,yBAAA;AAAAT,OAAA,CAAAU,yBAAA,GAAAH,cAAA,CAAAG,yBAAA;AACxB,IAAAC,YAAA,GAAAP,sBAAA,CAAAL,OAAA;AAAuCC,OAAA,CAAAY,WAAA,GAAAD,YAAA,CAAAL,OAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+var _exportNames = {
+  encode: true,
+  decode: true,
+  isObject: true,
+  isArray: true,
+  isDate: true,
+  isNumber: true,
+  isBoolean: true,
+  isString: true,
+  isFunction: true,
+  typeForDisplay: true,
+  isUndefined: true,
+  isNull: true,
+  clone: true,
+  base64url: true,
+  filterBuilderFactory: true,
+  platformizedFilterBuilder: true,
+  PlatformizedFilterBuilder: true,
+  filterMixin: true,
+  validateFilterTree: true,
+  validateFilterOrThrow: true,
+  WithFilter: true,
+  optimiseQuery: true,
+  wixDataEncoder: true,
+  messages: true,
+  codes: true,
+  wixDataError: true,
+  validationError: true,
+  BulkError: true,
+  apiValidator: true,
+  AggregatingValidator: true,
+  RejectingValidator: true,
+  sortMixin: true,
+  WixDataApi: true,
+  WixDataBulkPatch: true,
+  WixDataQuery: true,
+  WixDataPatch: true,
+  WixDataResult: true,
+  QueryValidator: true,
+  WixDataOptions: true,
+  WixDataReadOptions: true,
+  WixDataReadWithProjectionOptions: true,
+  WixDataUpdateOptions: true,
+  WixDataQueryOptions: true,
+  WixDataItem: true,
+  WixDataReference: true,
+  WixDataBulkError: true,
+  WixDataBulkResult: true,
+  WixDataAggregate: true,
+  QueryBase: true,
+  WixDataFilter: true
+};
+var _utils = require("./utils");
+exports.encode = _utils.encode;
+exports.decode = _utils.decode;
+exports.isObject = _utils.isObject;
+exports.isArray = _utils.isArray;
+exports.isDate = _utils.isDate;
+exports.isNumber = _utils.isNumber;
+exports.isBoolean = _utils.isBoolean;
+exports.isString = _utils.isString;
+exports.isFunction = _utils.isFunction;
+exports.typeForDisplay = _utils.typeForDisplay;
+exports.isUndefined = _utils.isUndefined;
+exports.isNull = _utils.isNull;
+exports.clone = _utils.clone;
+exports.base64url = _utils.base64url;
+var _filter = require("./filter");
+exports.filterBuilderFactory = _filter.filterBuilderFactory;
+exports.platformizedFilterBuilder = _filter.platformizedFilterBuilder;
+exports.PlatformizedFilterBuilder = _filter.PlatformizedFilterBuilder;
+exports.filterMixin = _filter.filterMixin;
+exports.validateFilterTree = _filter.validateFilterTree;
+exports.validateFilterOrThrow = _filter.validateFilterOrThrow;
+exports.WithFilter = _filter.WithFilter;
+var _filterBuilder = require("@wix/filter-builder");
+exports.optimiseQuery = _filterBuilder.optimiseQuery;
+exports.wixDataEncoder = _filterBuilder.wixDataEncoder;
+var _errors = require("./errors");
+exports.messages = _errors.messages;
+exports.codes = _errors.codes;
+exports.wixDataError = _errors.wixDataError;
+exports.validationError = _errors.validationError;
+exports.BulkError = _errors.BulkError;
+exports.apiValidator = _errors.apiValidator;
+exports.AggregatingValidator = _errors.AggregatingValidator;
+exports.RejectingValidator = _errors.RejectingValidator;
+var _sortMixin = _interopRequireDefault(require("./sort/sortMixin"));
+exports.sortMixin = _sortMixin.default;
+var _api = require("./api");
+exports.WixDataApi = _api.WixDataApi;
+exports.WixDataBulkPatch = _api.WixDataBulkPatch;
+exports.WixDataQuery = _api.WixDataQuery;
+exports.WixDataPatch = _api.WixDataPatch;
+exports.WixDataResult = _api.WixDataResult;
+exports.QueryValidator = _api.QueryValidator;
+exports.WixDataOptions = _api.WixDataOptions;
+exports.WixDataReadOptions = _api.WixDataReadOptions;
+exports.WixDataReadWithProjectionOptions = _api.WixDataReadWithProjectionOptions;
+exports.WixDataUpdateOptions = _api.WixDataUpdateOptions;
+exports.WixDataQueryOptions = _api.WixDataQueryOptions;
+exports.WixDataItem = _api.WixDataItem;
+exports.WixDataReference = _api.WixDataReference;
+exports.WixDataBulkError = _api.WixDataBulkError;
+exports.WixDataBulkResult = _api.WixDataBulkResult;
+exports.WixDataAggregate = _api.WixDataAggregate;
+exports.QueryBase = _api.QueryBase;
+exports.WixDataFilter = _api.WixDataFilter;
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  exports[key] = _types[key];
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_utils","require","exports","encode","decode","isObject","isArray","isDate","isNumber","isBoolean","isString","isFunction","typeForDisplay","isUndefined","isNull","clone","base64url","_filter","filterBuilderFactory","platformizedFilterBuilder","PlatformizedFilterBuilder","filterMixin","validateFilterTree","validateFilterOrThrow","WithFilter","_filterBuilder","optimiseQuery","wixDataEncoder","_errors","messages","codes","wixDataError","validationError","BulkError","apiValidator","AggregatingValidator","RejectingValidator","_sortMixin","_interopRequireDefault","sortMixin","default","_api","WixDataApi","WixDataBulkPatch","WixDataQuery","WixDataPatch","WixDataResult","QueryValidator","WixDataOptions","WixDataReadOptions","WixDataReadWithProjectionOptions","WixDataUpdateOptions","WixDataQueryOptions","WixDataItem","WixDataReference","WixDataBulkError","WixDataBulkResult","WixDataAggregate","QueryBase","WixDataFilter","_types","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames"],"sources":["../../src/index.ts"],"sourcesContent":["import {\n  encode,\n  decode,\n  isObject,\n  isArray,\n  isDate,\n  isNumber,\n  isBoolean,\n  isString,\n  isFunction,\n  typeForDisplay,\n  isUndefined,\n  isNull,\n  clone,\n  base64url,\n} from './utils'\nimport type { FilterTree } from './filter'\nimport {\n  filterBuilderFactory,\n  platformizedFilterBuilder,\n  PlatformizedFilterBuilder,\n  filterMixin,\n  validateFilterTree,\n  validateFilterOrThrow,\n  WithFilter,\n} from './filter'\nimport { optimiseQuery, wixDataEncoder } from '@wix/filter-builder'\nimport {\n  messages,\n  codes,\n  wixDataError,\n  validationError,\n  BulkError,\n  apiValidator,\n  AggregatingValidator,\n  RejectingValidator,\n} from './errors'\nimport sortMixin from './sort/sortMixin'\nimport {\n  WixDataApi,\n  WixDataBulkPatch,\n  WixDataQuery,\n  WixDataPatch,\n  WixDataResult,\n  QueryValidator,\n  WixDataOptions,\n  WixDataReadOptions,\n  WixDataReadWithProjectionOptions,\n  WixDataUpdateOptions,\n  WixDataQueryOptions,\n  WixDataItem,\n  WixDataReference,\n  WixDataBulkError,\n  WixDataBulkResult,\n  WixDataAggregate,\n  QueryBase,\n  WixDataFilter,\n} from './api'\nimport type { HttpApiClientFactory, RequestInterceptor } from './types'\nimport type { WixDataItemOrId } from './api'\n\nexport type {\n  FilterTree,\n  HttpApiClientFactory,\n  RequestInterceptor,\n  WixDataItemOrId,\n}\nexport * from './types'\nexport {\n  encode,\n  decode,\n  isObject,\n  isArray,\n  isDate,\n  isNumber,\n  isBoolean,\n  isString,\n  isFunction,\n  typeForDisplay,\n  isUndefined,\n  isNull,\n  clone,\n  base64url,\n  filterMixin,\n  filterBuilderFactory,\n  platformizedFilterBuilder,\n  PlatformizedFilterBuilder,\n  optimiseQuery,\n  validateFilterOrThrow,\n  validateFilterTree,\n  wixDataEncoder,\n  WithFilter,\n  messages,\n  codes,\n  wixDataError,\n  validationError,\n  BulkError,\n  apiValidator,\n  AggregatingValidator,\n  RejectingValidator,\n  sortMixin,\n  WixDataApi,\n  WixDataBulkPatch,\n  WixDataQuery,\n  WixDataPatch,\n  WixDataResult,\n  QueryValidator,\n  WixDataOptions,\n  WixDataReadOptions,\n  WixDataReadWithProjectionOptions,\n  WixDataUpdateOptions,\n  WixDataQueryOptions,\n  WixDataItem,\n  WixDataReference,\n  WixDataBulkError,\n  WixDataBulkResult,\n  WixDataAggregate,\n  QueryBase,\n  WixDataFilter,\n}\n"],"mappings":"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"}

package/dist/cjs/sort/sortMixin.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = exports.SortValidator = exports.Sort = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("../utils");
+var _errors = require("../errors");
+const sortMixin = (Base = class {}) => class extends Base {
+  constructor(obj = {}) {
+    super(obj);
+    (0, _defineProperty2.default)(this, "orderBy", void 0);
+    (0, _defineProperty2.default)(this, "invalidArguments", void 0);
+    this.orderBy = obj.orderBy || [];
+    this.invalidArguments = obj.invalidArguments || [];
+  }
+  ascending(...fields) {
+    return this._sortClause('asc', '.ascending', fields);
+  }
+  descending(...fields) {
+    return this._sortClause('desc', '.descending', fields);
+  }
+  getSortModel() {
+    if (this.invalidArguments.length > 0) {
+      throw (0, _errors.validationError)(_errors.messages.sortBuilderInvalid(this.invalidArguments));
+    }
+    return this.orderBy;
+  }
+  setSortModel(sortModel) {
+    return this._copySort(sortModel, []);
+  }
+  _sortClause(operatorSymbol, operatorName, args) {
+    let orderBy = [];
+    if (this.orderBy) {
+      orderBy = (0, _utils.clone)(this.orderBy);
+    }
+    const appendClause = createAppendClauseFn(orderBy, operatorSymbol);
+    const effectiveArgs = (0, _utils.isArray)(args[0]) && args.length === 1 ? args[0] : Array.prototype.slice.call(args, 0);
+    const [newInvalidArguments, valid] = this._sortValidator(operatorName).arityIsAtLeastOne(args).allStrings(effectiveArgs).validateAndAggregate();
+    if (valid) {
+      effectiveArgs.forEach(appendClause);
+    }
+    return this._copySort(orderBy, newInvalidArguments);
+  }
+  _sortValidator(operatorName) {
+    return new SortValidator(operatorName, this.invalidArguments);
+  }
+  _copySort(orderBy, invalidArguments) {
+    return new this.constructor({
+      ...this,
+      orderBy,
+      invalidArguments
+    });
+  }
+};
+function createAppendClauseFn(destination, direction) {
+  return field => {
+    const spec = {
+      [field]: direction
+    };
+    destination.push(spec);
+  };
+}
+class SortValidator extends _errors.AggregatingValidator {
+  constructor(operatorName, previousInvalidArguments) {
+    super(previousInvalidArguments);
+    this.operatorName = operatorName;
+  }
+  allStrings(effectiveArgs) {
+    return this.addValidation(() => effectiveArgs.every(_utils.isString), () => {
+      return _errors.messages.sortValidations.typeIsStringOrArrayOfStrings(this.operatorName, effectiveArgs);
+    });
+  }
+}
+exports.SortValidator = SortValidator;
+class Sort extends sortMixin() {}
+exports.Sort = Sort;
+var _default = exports.default = sortMixin;
+//# sourceMappingURL=sortMixin.js.map

package/dist/cjs/sort/sortMixin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_utils","require","_errors","sortMixin","Base","constructor","obj","_defineProperty2","default","orderBy","invalidArguments","ascending","fields","_sortClause","descending","getSortModel","length","validationError","messages","sortBuilderInvalid","setSortModel","sortModel","_copySort","operatorSymbol","operatorName","args","clone","appendClause","createAppendClauseFn","effectiveArgs","isArray","Array","prototype","slice","call","newInvalidArguments","valid","_sortValidator","arityIsAtLeastOne","allStrings","validateAndAggregate","forEach","SortValidator","destination","direction","field","spec","push","AggregatingValidator","previousInvalidArguments","addValidation","every","isString","sortValidations","typeIsStringOrArrayOfStrings","exports","Sort","_default"],"sources":["../../../src/sort/sortMixin.ts"],"sourcesContent":["import { clone, isString, isArray } from '../utils'\nimport { AggregatingValidator, messages, validationError } from '../errors'\n\nexport type Direction = 'asc' | 'desc'\nexport interface OrderBySpec {\n  [field: string]: Direction\n}\nexport type OrderBy = OrderBySpec[]\n\ninterface WithConstructor {\n  // eslint-disable-next-line @typescript-eslint/prefer-function-type\n  new (...args: any): any\n}\n\nconst sortMixin = (Base: WithConstructor = class {}) =>\n  class extends Base {\n    orderBy: OrderBy\n    invalidArguments: string[]\n\n    constructor(obj: any = {}) {\n      super(obj)\n      this.orderBy = obj.orderBy || []\n      this.invalidArguments = obj.invalidArguments || []\n    }\n\n    ascending(...fields: any[]) {\n      return this._sortClause('asc', '.ascending', fields)\n    }\n\n    descending(...fields: any[]) {\n      return this._sortClause('desc', '.descending', fields)\n    }\n\n    getSortModel() {\n      if (this.invalidArguments.length > 0) {\n        throw validationError(\n          messages.sortBuilderInvalid(this.invalidArguments)\n        )\n      }\n      return this.orderBy\n    }\n\n    setSortModel(sortModel: any[]) {\n      return this._copySort(sortModel, [])\n    }\n\n    _sortClause(operatorSymbol: Direction, operatorName: string, args: any[]) {\n      let orderBy: OrderBy = []\n      if (this.orderBy) {\n        orderBy = clone(this.orderBy)\n      }\n\n      const appendClause = createAppendClauseFn(orderBy, operatorSymbol)\n      const effectiveArgs =\n        isArray(args[0]) && args.length === 1\n          ? args[0]\n          : Array.prototype.slice.call(args, 0)\n      const [newInvalidArguments, valid] = this._sortValidator(operatorName)\n        .arityIsAtLeastOne(args)\n        .allStrings(effectiveArgs)\n        .validateAndAggregate()\n\n      if (valid) {\n        effectiveArgs.forEach(appendClause)\n      }\n\n      return this._copySort(orderBy, newInvalidArguments)\n    }\n\n    _sortValidator(operatorName: string) {\n      return new SortValidator(operatorName, this.invalidArguments)\n    }\n\n    _copySort(orderBy: OrderBy, invalidArguments: string[]) {\n      return new (this.constructor as WithConstructor)({\n        ...this,\n        orderBy,\n        invalidArguments,\n      })\n    }\n  }\n\nfunction createAppendClauseFn(destination: OrderBy, direction: Direction) {\n  return (field: string) => {\n    const spec: OrderBySpec = { [field]: direction }\n    destination.push(spec)\n  }\n}\n\nexport class SortValidator extends AggregatingValidator {\n  constructor(public operatorName: string, previousInvalidArguments: string[]) {\n    super(previousInvalidArguments)\n  }\n\n  allStrings(effectiveArgs: any[]) {\n    return this.addValidation(\n      () => effectiveArgs.every(isString),\n      () => {\n        return messages.sortValidations.typeIsStringOrArrayOfStrings(\n          this.operatorName,\n          effectiveArgs\n        )\n      }\n    )\n  }\n}\n\nexport class Sort extends sortMixin() {}\n\nexport default sortMixin\n"],"mappings":"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"}

package/dist/cjs/test-types.d.js

@@ -0,0 +1,2 @@
+/// <reference types="@wix/jest-yoshi-preset/types" />
+//# sourceMappingURL=test-types.d.js.map

package/dist/cjs/test-types.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/test-types.d.ts"],"sourcesContent":["/// <reference types=\"@wix/jest-yoshi-preset/types\" />\n"],"mappings":"AAAA"}

package/dist/cjs/types/api.js

@@ -0,0 +1,4 @@
+"use strict";
+
+exports.__esModule = true;
+//# sourceMappingURL=api.js.map

package/dist/cjs/types/api.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../../src/types/api.ts"],"sourcesContent":["import {\n  AggregateDataItemsRequest,\n  AggregateDataItemsResponse,\n  BulkInsertDataItemReferencesRequest,\n  BulkInsertDataItemReferencesResponse,\n  BulkInsertDataItemsRequest,\n  BulkInsertDataItemsResponse,\n  BulkPatchDataItemsRequest,\n  BulkPatchDataItemsResponse,\n  BulkRemoveDataItemReferencesRequest,\n  BulkRemoveDataItemReferencesResponse,\n  BulkRemoveDataItemsRequest,\n  BulkRemoveDataItemsResponse,\n  BulkSaveDataItemsRequest,\n  BulkSaveDataItemsResponse,\n  BulkUpdateDataItemsRequest,\n  BulkUpdateDataItemsResponse,\n  CountDataItemsRequest,\n  CountDataItemsResponse,\n  GetDataItemRequest,\n  GetDataItemResponse,\n  InsertDataItemRequest,\n  InsertDataItemResponse,\n  IsReferencedDataItemRequest,\n  IsReferencedDataItemResponse,\n  PatchDataItemRequest,\n  PatchDataItemResponse,\n  QueryDataItemsRequest,\n  QueryDataItemsResponse,\n  QueryDistinctValuesRequest,\n  QueryDistinctValuesResponse,\n  QueryReferencedDataItemsRequest,\n  QueryReferencedDataItemsResponse,\n  RemoveDataItemRequest,\n  RemoveDataItemResponse,\n  ReplaceDataItemReferencesRequest,\n  ReplaceDataItemReferencesResponse,\n  SaveDataItemRequest,\n  SaveDataItemResponse,\n  TruncateDataItemsRequest,\n  TruncateDataItemsResponse,\n  UpdateDataItemRequest,\n  UpdateDataItemResponse,\n} from './data-item-types'\n\nexport interface HttpApiClient {\n  getDataItem(r: GetDataItemRequest): Promise<HttpResponse<GetDataItemResponse>>\n\n  insertDataItem(\n    r: InsertDataItemRequest\n  ): Promise<HttpResponse<InsertDataItemResponse>>\n\n  saveDataItem(\n    r: SaveDataItemRequest\n  ): Promise<HttpResponse<SaveDataItemResponse>>\n\n  updateDataItem(\n    r: UpdateDataItemRequest\n  ): Promise<HttpResponse<UpdateDataItemResponse>>\n\n  patchDataItem(\n    r: PatchDataItemRequest\n  ): Promise<HttpResponse<PatchDataItemResponse>>\n\n  removeDataItem(\n    r: RemoveDataItemRequest\n  ): Promise<HttpResponse<RemoveDataItemResponse>>\n\n  countDataItems(\n    r: CountDataItemsRequest\n  ): Promise<HttpResponse<CountDataItemsResponse>>\n\n  queryDistinctValues(\n    r: QueryDistinctValuesRequest\n  ): Promise<HttpResponse<QueryDistinctValuesResponse>>\n\n  queryDataItems(\n    r: QueryDataItemsRequest\n  ): Promise<HttpResponse<QueryDataItemsResponse>>\n\n  aggregateDataItems(\n    r: AggregateDataItemsRequest\n  ): Promise<HttpResponse<AggregateDataItemsResponse>>\n\n  bulkInsertDataItems(\n    r: BulkInsertDataItemsRequest\n  ): Promise<HttpResponse<BulkInsertDataItemsResponse>>\n\n  bulkUpdateDataItems(\n    r: BulkUpdateDataItemsRequest\n  ): Promise<HttpResponse<BulkUpdateDataItemsResponse>>\n\n  bulkPatchDataItems(\n    r: BulkPatchDataItemsRequest\n  ): Promise<HttpResponse<BulkPatchDataItemsResponse>>\n\n  bulkSaveDataItems(\n    r: BulkSaveDataItemsRequest\n  ): Promise<HttpResponse<BulkSaveDataItemsResponse>>\n\n  bulkRemoveDataItems(\n    r: BulkRemoveDataItemsRequest\n  ): Promise<HttpResponse<BulkRemoveDataItemsResponse>>\n\n  queryReferencedDataItems(\n    r: QueryReferencedDataItemsRequest\n  ): Promise<HttpResponse<QueryReferencedDataItemsResponse>>\n\n  bulkInsertDataItemReferences(\n    r: BulkInsertDataItemReferencesRequest\n  ): Promise<HttpResponse<BulkInsertDataItemReferencesResponse>>\n\n  replaceDataItemReferences(\n    r: ReplaceDataItemReferencesRequest\n  ): Promise<HttpResponse<ReplaceDataItemReferencesResponse>>\n\n  bulkRemoveDataItemReferences(\n    r: BulkRemoveDataItemReferencesRequest\n  ): Promise<HttpResponse<BulkRemoveDataItemReferencesResponse>>\n\n  isReferencedDataItem(\n    r: IsReferencedDataItemRequest\n  ): Promise<HttpResponse<IsReferencedDataItemResponse>>\n\n  truncateDataItems(\n    r: TruncateDataItemsRequest\n  ): Promise<HttpResponse<TruncateDataItemsResponse>>\n}\n\nexport interface HttpResponse<T> {\n  data: T\n}\n\nexport interface Request {\n  data?: any\n  url?: string\n  methodFqn?: string\n  method?: string\n}\n\nexport type RequestInterceptor<R extends Request> = (req: R) => R\n\nexport type HttpApiClientFactory<R extends Request> = (\n  requestInterceptor: RequestInterceptor<R>\n) => HttpApiClient\n"],"mappings":""}