@enonic/js-utils/dist/esm/storage/query/index.mjs

Enonic XP JavaScript Utils

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// storage/query/aggregation/index.ts
var aggregation_exports = {};
__export(aggregation_exports, {
  stats: () => stats,
  statsParams: () => statsParams,
  terms: () => terms,
  termsParams: () => termsParams
});

// storage/query/aggregation/stats.ts
function statsParams(field) {
  const stats2 = {
    field
  };
  return stats2;
}
function stats(field) {
  const statsAggregation = {
    stats: statsParams(
      field
    )
  };
  return statsAggregation;
}

// value/isBasicObject.ts
var isBasicObject = (value) => typeof value === "object";

// value/isDate.ts
function isDate(value) {
  return Object.prototype.toString.call(value).slice(8, -1) === "Date";
}

// value/isFunction.ts
function isFunction(value) {
  return Object.prototype.toString.call(value).slice(8, -1) === "Function";
}

// value/isNumber.ts
function isNumber(value) {
  return typeof value === "number" && isFinite(value);
}

// value/isStringLiteral.ts
var isStringLiteral = (value) => typeof value === "string";

// value/isStringObject.ts
var isStringObject = (value) => value instanceof String;

// value/isString.ts
var isString = (value) => isStringLiteral(value) || isStringObject(value);

// value/isInt.ts
function isInt(value) {
  return typeof value === "number" && isFinite(value) && // TODO Is isFinite() available in Enonic XP?
  Math.floor(value) === value;
}

// value/isInteger.ts
var isInteger = "isInteger" in Number && isFunction(Number.isInteger) ? Number.isInteger : isInt;

// value/isObject.ts
var isObject = (value) => Object.prototype.toString.call(value).slice(8, -1) === "Object";

// value/isSymbol.ts
var isSymbol = (value) => typeof value === "symbol";

// value/isPropertyKey.ts
var isPropertyKey = (value) => isString(value) || isNumber(value) || isSymbol(value);

// value/isSet.ts
function isSet(value) {
  if (typeof value === "boolean") {
    return true;
  }
  return value !== null && typeof value !== "undefined";
}

// value/toStr.ts
function toStr(value, replacer, space = 4) {
  return JSON.stringify(value, replacer, space);
}

// storage/query/aggregation/terms.ts
function termsParams(field, order, size, minDocCount) {
  const terms2 = {
    field
  };
  if (order) {
    terms2.order = order;
  }
  if (size) {
    terms2.size = size;
  }
  if (minDocCount) {
    terms2.minDocCount = minDocCount;
  }
  return terms2;
}
function terms(field, ...optionalArgs) {
  let order;
  let size;
  let minDocCount;
  let aggregations;
  for (let i = 0; i < optionalArgs.length; i++) {
    const optinalArg = optionalArgs[i];
    if (isString(optinalArg)) {
      if (order) {
        throw new Error(`terms: You can only provide one optional order parameter!`);
      }
      order = optinalArg;
    } else if (isNumber(optinalArg)) {
      if (isSet(minDocCount)) {
        throw new Error(`terms: You can only provide one or two optional number parameters!`);
      }
      if (isSet(size)) {
        minDocCount = optinalArg;
      } else {
        size = optinalArg;
      }
    } else if (isObject(optinalArg)) {
      if (aggregations) {
        throw new Error(`terms: You can only provide one optional aggregations parameter!`);
      }
      aggregations = optinalArg;
    } else {
      throw new Error(`terms: Unknown optional parameter type!`);
    }
  }
  const termsAggregation = {
    terms: termsParams(
      field,
      order,
      size,
      minDocCount
    )
  };
  if (aggregations) {
    termsAggregation.aggregations = aggregations;
  }
  return termsAggregation;
}

// storage/query/dsl/index.ts
var dsl_exports = {};
__export(dsl_exports, {
  DSL_EXPRESSION_VALUE_TYPE_DATE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2,
  DSL_EXPRESSION_VALUE_TYPE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_TIME2,
  and: () => and,
  bool: () => bool,
  fulltext: () => fulltext,
  inQuery: () => inQuery,
  isBooleanDslExpression: () => isBooleanDslExpression_default,
  isExistsDslExpression: () => isExistsDslExpression,
  isFulltextDslExpression: () => isFulltextDslExpression,
  isInDslExpression: () => isInDslExpression,
  isLikeDslExpression: () => isLikeDslExpression,
  isMatchAllDslExpression: () => isMatchAllDslExpression,
  isNgramDslExpression: () => isNgramDslExpression,
  isPathMatchDslExpression: () => isPathMatchDslExpression,
  isQueryDsl: () => isQueryDsl,
  isRangeDslExpression: () => isRangeDslExpression,
  isStemmedDslExpression: () => isStemmedDslExpression,
  isTermDslExpression: () => isTermDslExpression,
  like: () => like,
  must: () => must,
  mustNot: () => mustNot,
  ngram: () => ngram,
  not: () => not,
  or: () => or,
  pathMatch: () => pathMatch,
  range: () => range,
  should: () => should,
  sort: () => sort,
  stemmed: () => stemmed,
  term: () => term
});

// object/hasOwnProperty.ts
function hasOwnProperty(obj, propKey) {
  if (!isBasicObject(obj)) {
    throw new Error(`First parameter to hasOwnProperty must be a basic Object! ${toStr(obj)}`);
  }
  if (!isPropertyKey(propKey)) {
    throw new Error(`Second parameter to hasOwnProperty must be a PropertyKey (string|number|symbol)! ${toStr(propKey)}`);
  }
  return obj.hasOwnProperty(propKey);
}

// array/forceArray.ts
function forceArray(data) {
  return Array.isArray(data) ? data : [data];
}

// storage/query/dsl/isDslQueryType.ts
var DSL_EXPRESSION_VALUE_TYPE_DATE_TIME = "dateTime";
var DSL_EXPRESSION_VALUE_TYPE_TIME = "time";
function isDslQueryType(value) {
  return isString(value) && (value === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME || value === DSL_EXPRESSION_VALUE_TYPE_TIME);
}

// storage/query/dsl/isInDslExpression.ts
function isInDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && hasOwnProperty(value, "values") && isString(value.field) && Array.isArray(value.values) && (hasOwnProperty(value, "type") ? isDslQueryType(value.type) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isExistsDslExpression.ts
function isExistsDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && isString(value.field) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// array/includes.ts
function sameValueZero(x, y) {
  return x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y);
}
function includes(array, searchElement, fromIndex = 0) {
  if (array == null) {
    throw new TypeError('"array" is null or not defined');
  }
  const o = Object(array);
  const len = o.length >>> 0;
  if (len === 0) {
    return false;
  }
  const n = fromIndex | 0;
  let k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
  while (k < len) {
    if (sameValueZero(o[k], searchElement)) {
      return true;
    }
    k++;
  }
  return false;
}

// storage/query/constants.ts
var FILTER_CLAUSE_MUST = "must";
var FILTER_CLAUSE_MUST_NOT = "mustNot";
var FILTER_CLAUSE_SHOULD = "should";
var FILTER_CLAUSES = [
  FILTER_CLAUSE_MUST,
  FILTER_CLAUSE_MUST_NOT,
  FILTER_CLAUSE_SHOULD
];
var QUERY_FUNCTION_FULLTEXT = "fulltext";
var QUERY_FUNCTION_NGRAM = "ngram";
var QUERY_FUNCTION_RANGE = "range";
var QUERY_FUNCTION_PATH_MATCH = "pathMatch";
var QUERY_FUNCTION_STEMMED = "stemmed";
var QUERY_OPERATOR_AND = "AND";
var QUERY_OPERATOR_OR = "OR";
var QUERY_OPERATORS = [
  QUERY_OPERATOR_AND,
  QUERY_OPERATOR_OR
];

// storage/query/dsl/isDslOperator.ts
function isDslOperator(value) {
  return isString(value) && includes(QUERY_OPERATORS, value);
}

// storage/query/dsl/isFulltextDslExpression.ts
function isFulltextDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "fields") && hasOwnProperty(value, "query") && Array.isArray(value.fields) && value.fields.every(isString) && isString(value.query) && (hasOwnProperty(value, "operator") ? isDslOperator(value.operator) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isLikeDslExpression.ts
function isLikeDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && hasOwnProperty(value, "value") && isString(value.field) && isString(value.value) && (hasOwnProperty(value, "type") ? isDslQueryType(value.type) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isMatchAllDslExpression.ts
function isMatchAllDslExpression(value) {
  return isObject(value) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isNgramDslExpression.ts
function isNgramDslExpression(value) {
  return isFulltextDslExpression(value);
}

// storage/query/dsl/isPathMatchDslExpression.ts
function isPathMatchDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && hasOwnProperty(value, "path") && isString(value.field) && isString(value.path) && (hasOwnProperty(value, "minimumMatch") ? isNumber(value.minimumMatch) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isRangeDslExpression.ts
function isRangeDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && isString(value.field) && ["lt", "lte", "gt", "gte"].some((key) => hasOwnProperty(value, key)) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isStemmedDslExpression.ts
function isStemmedDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "fields") && hasOwnProperty(value, "language") && hasOwnProperty(value, "query") && Array.isArray(value.fields) && value.fields.every(isString) && isString(value.language) && isString(value.query) && (hasOwnProperty(value, "operator") ? isDslOperator(value.operator) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isTermDslExpression.ts
function isTermDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && hasOwnProperty(value, "value") && isString(value.field) && (hasOwnProperty(value, "type") ? isDslQueryType(value.type) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isQueryDsl.ts
var COMPOUND_PROPERTIES = [
  "must",
  "mustNot",
  "should",
  "filter"
];
function isBooleanDslExpression(value) {
  return isObject(value) && COMPOUND_PROPERTIES.every(
    (prop) => hasOwnProperty(value, prop) ? forceArray(value[prop]).every((item) => isQueryDsl(item)) : true
    // prop is optional
  ) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}
function isQueryDsl(value) {
  return isObject(value) && (hasOwnProperty(value, "boolean") && isBooleanDslExpression(value.boolean) || hasOwnProperty(value, "exists") && isExistsDslExpression(value.exists) || hasOwnProperty(value, "fulltext") && isFulltextDslExpression(value.fulltext) || hasOwnProperty(value, "in") && isInDslExpression(value.in) || hasOwnProperty(value, "like") && isLikeDslExpression(value.like) || hasOwnProperty(value, "matchAll") && isMatchAllDslExpression(value.matchAll) || hasOwnProperty(value, "ngram") && isNgramDslExpression(value.ngram) || hasOwnProperty(value, "pathMatch") && isPathMatchDslExpression(value.pathMatch) || hasOwnProperty(value, "range") && isRangeDslExpression(value.range) || hasOwnProperty(value, "stemmed") && isStemmedDslExpression(value.stemmed) || hasOwnProperty(value, "term") && isTermDslExpression(value.term));
}

// storage/query/dsl/isBooleanDslExpression.ts
var isBooleanDslExpression_default = isBooleanDslExpression;

// array/flatten.ts
function flatten(arr, d = 1) {
  return d > 0 ? arr.reduce((acc, val) => acc.concat(
    Array.isArray(val) ? flatten(val, d - 1) : val
  ), []) : arr.slice();
}

// storage/query/dsl/and.ts
function and(...args) {
  const flattened = flatten(args);
  return {
    must: flattened
  };
}
var must = and;

// storage/query/dsl/bool.ts
function bool(compoundExpression) {
  return {
    boolean: compoundExpression
  };
}

// string/includes.ts
function includes2(string, searchString, position) {
  if (searchString instanceof RegExp) {
    throw new TypeError("second argument must not be a RegExp");
  }
  if (position === void 0) {
    position = 0;
  }
  return string.indexOf(searchString, position) !== -1;
}

// storage/query/buildFields.ts
function buildFieldsArray(fields) {
  return forceArray(fields).map((stringOrObj) => {
    let boost;
    let field;
    if (isObject(stringOrObj)) {
      boost = stringOrObj.boost || void 0;
      field = stringOrObj.field;
    } else {
      field = stringOrObj;
    }
    return `${field}${boost && boost !== 1 ? `^${boost}` : ""}`;
  });
}
function buildFields(fields) {
  return `'${buildFieldsArray(fields).join(",")}'`;
}

// storage/query/dsl/fieldsContainBoost.ts
function fieldsContainBoost(fields) {
  if (Array.isArray(fields)) {
    return fields.some((field) => fieldsContainBoost(field));
  } else if (isObject(fields)) {
    const { boost } = fields;
    if (boost && boost !== 1) {
      return true;
    }
  } else if (isString(fields)) {
    if (includes2(fields, "^")) {
      return true;
    }
  } else {
    throw new Error(`fieldsContainBoost: fields is not array, object or string!`);
  }
  return false;
}

// storage/query/dsl/or.ts
function or(...args) {
  const flattened = flatten(args);
  return {
    should: flattened
  };
}
var should = or;

// storage/query/dsl/fulltextOrNgram.ts
function fulltextOrNgram(fOrN, fields, query, operator = QUERY_OPERATOR_OR, boost) {
  if (fieldsContainBoost(fields)) {
    if (Array.isArray(fields)) {
      return bool(or(fields.map((field) => fulltextOrNgram(
        fOrN,
        field,
        query,
        operator,
        boost
      ))));
    } else if (isObject(fields)) {
      const { boost: fieldBoost, field } = fields;
      if (fieldBoost && fieldBoost !== 1) {
        if (boost && boost !== 1) {
          boost = boost * fieldBoost;
        } else {
          boost = fieldBoost;
        }
      }
      return fulltextOrNgram(
        fOrN,
        field,
        query,
        operator,
        boost
      );
    } else if (isString(fields)) {
      if (includes2(fields, ",")) {
        return fulltextOrNgram(
          fOrN,
          fields.split(","),
          query,
          operator,
          boost
        );
      } else if (includes2(fields, "^")) {
        const caretIndex = fields.indexOf("^");
        const field = fields.substring(0, caretIndex);
        const fieldBoost = parseFloat(fields.substring(caretIndex + 1));
        if (fieldBoost && fieldBoost !== 1) {
          if (boost && boost !== 1) {
            boost = boost * fieldBoost;
          } else {
            boost = fieldBoost;
          }
        }
        return fulltextOrNgram(
          fOrN,
          field,
          query,
          operator,
          boost
        );
      }
    } else {
      throw new Error(`${fOrN}: fields is not array, object or string!`);
    }
  }
  const innerObj = {
    fields: buildFieldsArray(fields),
    query,
    operator: operator.toUpperCase()
  };
  if (boost && boost !== 1) {
    innerObj.boost = boost;
  }
  if (fOrN === "fulltext") {
    return {
      fulltext: innerObj
    };
  } else if (fOrN === "ngram") {
    return {
      ngram: innerObj
    };
  }
  throw new Error(`first parameter must be 'fulltext' or 'ngram'`);
}

// storage/query/dsl/fulltext.ts
function fulltext(fields, query, operator = QUERY_OPERATOR_OR, boost) {
  return fulltextOrNgram("fulltext", fields, query, operator, boost);
}

// storage/query/dsl/term.ts
var DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2 = "dateTime";
var DSL_EXPRESSION_VALUE_TYPE_TIME2 = "time";
function term(field, value, boost, type) {
  const term2 = {
    field,
    value
  };
  if (boost) {
    term2.boost = boost;
  }
  if (type === DSL_EXPRESSION_VALUE_TYPE_TIME2 || type === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2) {
    term2.type = type;
  }
  return {
    term: term2
  };
}

// storage/query/dsl/inQuery.ts
function inQuery(field, values, boost, type) {
  const obj = {
    field,
    values
  };
  if (boost) {
    obj.boost = boost;
  }
  if (type === DSL_EXPRESSION_VALUE_TYPE_TIME2 || type === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2) {
    obj.type = type;
  }
  return {
    in: obj
  };
}

// storage/query/dsl/like.ts
function like(field, value, boost, type) {
  const like2 = {
    field,
    value
  };
  if (boost) {
    like2.boost = boost;
  }
  if (type === DSL_EXPRESSION_VALUE_TYPE_TIME2 || type === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2) {
    like2.type = type;
  }
  return {
    like: like2
  };
}

// storage/query/dsl/ngram.ts
function ngram(fields, query, operator = QUERY_OPERATOR_OR, boost) {
  return fulltextOrNgram("ngram", fields, query, operator, boost);
}

// storage/query/dsl/not.ts
function not(...args) {
  const flattened = flatten(args);
  return {
    mustNot: flattened
  };
}
var mustNot = not;

// storage/query/dsl/pathMatch.ts
function pathMatch(field, path, minimumMatch, boost) {
  const pathMatch2 = {
    field,
    path
  };
  if (minimumMatch) {
    pathMatch2.minimumMatch = minimumMatch;
  }
  if (boost) {
    pathMatch2.boost = boost;
  }
  return {
    pathMatch: pathMatch2
  };
}

// storage/query/dsl/range.ts
function ifDateCastToISOString(v) {
  if (isDate(v)) {
    return v.toISOString();
  }
  return v;
}
function range(field, limits = {}, boost, type) {
  const range2 = {
    field
  };
  if (limits.gt) {
    range2.gt = ifDateCastToISOString(limits.gt);
  }
  if (limits.gte) {
    range2.gte = ifDateCastToISOString(limits.gte);
  }
  if (limits.lt) {
    range2.lt = ifDateCastToISOString(limits.lt);
  }
  if (limits.lte) {
    range2.lte = ifDateCastToISOString(limits.lte);
  }
  if (boost) {
    range2.boost = boost;
  }
  if (type === DSL_EXPRESSION_VALUE_TYPE_TIME2 || type === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2) {
    range2.type = type;
  }
  return {
    range: range2
  };
}

// storage/indexing/stemming.ts
var STEMMING_LANGUAGE_CODE_ENGLISH = "en";

// storage/query/dsl/stemmed.ts
function stemmed(fields, query, operator = QUERY_OPERATOR_OR, language = STEMMING_LANGUAGE_CODE_ENGLISH, boost) {
  if (fieldsContainBoost(fields)) {
    if (Array.isArray(fields)) {
      return bool(or(fields.map((field) => stemmed(
        field,
        query,
        operator,
        language,
        boost
      ))));
    } else if (isObject(fields)) {
      const { boost: fieldBoost, field } = fields;
      if (fieldBoost && fieldBoost !== 1) {
        if (boost && boost !== 1) {
          boost = boost * fieldBoost;
        } else {
          boost = fieldBoost;
        }
      }
      return stemmed(
        field,
        query,
        operator,
        language,
        boost
      );
    } else if (isString(fields)) {
      if (includes2(fields, ",")) {
        return stemmed(
          fields.split(","),
          query,
          operator,
          language,
          boost
        );
      } else if (includes2(fields, "^")) {
        const caretIndex = fields.indexOf("^");
        const field = fields.substring(0, caretIndex);
        const fieldBoost = parseFloat(fields.substring(caretIndex + 1));
        if (fieldBoost && fieldBoost !== 1) {
          if (boost && boost !== 1) {
            boost = boost * fieldBoost;
          } else {
            boost = fieldBoost;
          }
        }
        return stemmed(
          field,
          query,
          operator,
          language,
          boost
        );
      }
    } else {
      throw new Error("stemmed: fields is not array, object or string!");
    }
  }
  const innerObj = {
    fields: buildFieldsArray(fields),
    query,
    operator: operator.toUpperCase(),
    language
  };
  if (boost) {
    innerObj.boost = boost;
  }
  return {
    stemmed: innerObj
  };
}

// storage/query/sort.ts
var ASC = "ASC";
var DESC = "DESC";
var SORT_CREATED = `createdTime ${DESC}`;
var SORT_DISPLAYNAME = `displayName ${ASC}`;
var SORT_MANUAL = `_manualordervalue ${DESC}, _timestamp ${DESC}`;
var SORT_MODIFIED = `modifiedTime ${DESC}`;
function isDirection(s) {
  return s === ASC || s === DESC;
}

// storage/query/dsl/sort.ts
function sort(...args) {
  const sort2 = [];
  let param = {};
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (isDirection(arg)) {
      if (!param.field || param.direction) {
        throw new Error(`sort: direction:${arg} is optional, but must come after field parameter!`);
      }
      param.direction = arg;
    } else {
      if (param.field) {
        sort2.push(JSON.parse(JSON.stringify(param)));
        param = {
          field: arg
        };
      } else {
        param.field = arg;
      }
    }
    if (i === args.length - 1) {
      sort2.push(param);
    }
  }
  return sort2.length === 1 ? sort2[0] : sort2;
}

// storage/query/filter/index.ts
var filter_exports = {};
__export(filter_exports, {
  isBooleanFilter: () => isBooleanFilter,
  isExistsFilter: () => isExistsFilter,
  isFilter: () => isFilter,
  isHasValueFilter: () => isHasValueFilter,
  isIdsFilter: () => isIdsFilter,
  isNotExistsFilter: () => isNotExistsFilter
});

// storage/query/filter/isExistsFilter.ts
function isExistsFilter(value) {
  return isObject(value) && hasOwnProperty(value, "exists") && isObject(value.exists) && hasOwnProperty(value.exists, "field") && isString(value.exists.field);
}

// storage/query/filter/isHasValueFilter.ts
function isHasValueFilter(value) {
  return isObject(value) && hasOwnProperty(value, "hasValue") && isObject(value.hasValue) && hasOwnProperty(value.hasValue, "field") && isString(value.hasValue.field) && hasOwnProperty(value.hasValue, "values") && Array.isArray(value.hasValue.values);
}

// storage/query/filter/isIdsFilter.ts
function isIdsFilter(value) {
  return isObject(value) && hasOwnProperty(value, "ids") && isObject(value.ids) && hasOwnProperty(value.ids, "values") && Array.isArray(value.ids.values) && value.ids.values.every((v) => isString(v));
}

// storage/query/filter/isNotExistsFilter.ts
function isNotExistsFilter(value) {
  return isObject(value) && hasOwnProperty(value, "notExists") && isObject(value.notExists) && hasOwnProperty(value.notExists, "field") && isString(value.notExists.field);
}

// storage/query/filter/isBooleanFilter.ts
function isBooleanFilter(value) {
  return isObject(value) && hasOwnProperty(value, "boolean") && isObject(value.boolean) && FILTER_CLAUSES.every((clause) => {
    const obj = value.boolean;
    if (hasOwnProperty(obj, clause)) {
      const oneOrMoreFilter = obj[clause];
      if (Array.isArray(oneOrMoreFilter)) {
        for (let i = 0; i < oneOrMoreFilter.length; i++) {
          const item = oneOrMoreFilter[i];
          if (!isFilter(item)) {
            return false;
          }
        }
      } else if (!isFilter(oneOrMoreFilter)) {
        return false;
      }
    }
    return true;
  });
}
function isFilter(value) {
  return isBooleanFilter(value) || isExistsFilter(value) || isNotExistsFilter(value) || isHasValueFilter(value) || isIdsFilter(value);
}

// storage/query/addQueryFilter.ts
function addQueryFilter({
  clause = FILTER_CLAUSE_MUST,
  filter,
  filters: incomingFilters
}) {
  const returnedFilters = incomingFilters ? JSON.parse(JSON.stringify(incomingFilters)) : {};
  if (Array.isArray(returnedFilters)) {
    returnedFilters.push(addQueryFilter({
      clause,
      filter
      // filters: {}
    }));
    return returnedFilters;
  }
  if (!isExistsFilter(returnedFilters) && !isNotExistsFilter(returnedFilters) && !isHasValueFilter(returnedFilters) && !isIdsFilter(returnedFilters)) {
    if (!returnedFilters.boolean) {
      returnedFilters.boolean = {};
    }
  }
  if (isBooleanFilter(returnedFilters)) {
    if (!returnedFilters.boolean[clause]) {
      returnedFilters.boolean[clause] = filter;
    } else if (Array.isArray(returnedFilters.boolean[clause])) {
      returnedFilters.boolean[clause].push(filter);
    } else {
      returnedFilters.boolean[clause] = [
        // TypeScript unable to narrow type of object properties https://github.com/microsoft/TypeScript/issues/33391
        returnedFilters.boolean[clause],
        filter
      ];
    }
  }
  return returnedFilters;
}

// storage/query/and.ts
function and2(...args) {
  const flattened = flatten(args);
  if (Array.isArray(flattened)) {
    if (flattened.length === 1) {
      return `${QUERY_OPERATOR_AND} ${flattened}`;
    }
    return flattened.join(` ${QUERY_OPERATOR_AND} `);
  }
  return `${QUERY_OPERATOR_AND} ${flattened}`;
}

// storage/query/fulltextOrNgram.ts
function fulltextOrNgram2(fOrN, fields, searchString, operator = QUERY_OPERATOR_OR) {
  return `${fOrN}(${buildFields(fields)},'${searchString}'${operator.toUpperCase() === QUERY_OPERATOR_AND ? `,'${QUERY_OPERATOR_AND}'` : ""})`;
}

// storage/query/fulltext.ts
function fulltext2(fields, searchString, operator = QUERY_OPERATOR_OR) {
  return fulltextOrNgram2("fulltext", fields, searchString, operator);
}

// storage/query/group.ts
function group(s) {
  return `(${s})`;
}

// storage/query/ngram.ts
function ngram2(fields, searchString, operator = QUERY_OPERATOR_OR) {
  return fulltextOrNgram2("ngram", fields, searchString, operator);
}

// storage/query/or.ts
function or2(...args) {
  const flattened = flatten(args);
  if (Array.isArray(flattened)) {
    if (flattened.length === 1) {
      return `${QUERY_OPERATOR_OR} ${flattened}`;
    }
    return flattened.join(` ${QUERY_OPERATOR_OR} `);
  }
  return `${QUERY_OPERATOR_OR} ${flattened}`;
}

// storage/query/stemmed.ts
function stemmed2(fields, searchString, operator = QUERY_OPERATOR_OR, language = STEMMING_LANGUAGE_CODE_ENGLISH) {
  return `stemmed(${buildFields(fields)},'${searchString}','${operator.toUpperCase() === QUERY_OPERATOR_AND ? QUERY_OPERATOR_AND : QUERY_OPERATOR_OR}','${language}')`;
}
export {
  DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2 as DSL_EXPRESSION_VALUE_TYPE_DATE_TIME,
  DSL_EXPRESSION_VALUE_TYPE_TIME2 as DSL_EXPRESSION_VALUE_TYPE_TIME,
  FILTER_CLAUSES,
  FILTER_CLAUSE_MUST,
  FILTER_CLAUSE_MUST_NOT,
  FILTER_CLAUSE_SHOULD,
  QUERY_FUNCTION_FULLTEXT,
  QUERY_FUNCTION_NGRAM,
  QUERY_FUNCTION_PATH_MATCH,
  QUERY_FUNCTION_RANGE,
  QUERY_FUNCTION_STEMMED,
  QUERY_OPERATOR_AND,
  QUERY_OPERATOR_OR,
  SORT_CREATED,
  SORT_DISPLAYNAME,
  SORT_MANUAL,
  SORT_MODIFIED,
  addQueryFilter,
  aggregation_exports as aggregation,
  and2 as and,
  dsl_exports as dsl,
  filter_exports as filter,
  fulltext2 as fulltext,
  group,
  isBooleanDslExpression_default as isBooleanDslExpression,
  isBooleanFilter,
  isExistsDslExpression,
  isExistsFilter,
  isFilter,
  isFulltextDslExpression,
  isHasValueFilter,
  isIdsFilter,
  isInDslExpression,
  isLikeDslExpression,
  isMatchAllDslExpression,
  isNgramDslExpression,
  isNotExistsFilter,
  isPathMatchDslExpression,
  isQueryDsl,
  isRangeDslExpression,
  isStemmedDslExpression,
  isTermDslExpression,
  ngram2 as ngram,
  or2 as or,
  stemmed2 as stemmed
};