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

Enonic XP JavaScript Utils

// storage/query/constants.ts
var QUERY_OPERATOR_OR = "OR";

// string/includes.ts
function includes(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;
}

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

// 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);

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

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

// 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;

// 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}` : ""}`;
  });
}

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

// 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 (includes(fields, "^")) {
      return true;
    }
  } else {
    throw new Error(`fieldsContainBoost: fields is not array, object or string!`);
  }
  return false;
}

// 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/or.ts
function or(...args) {
  const flattened = flatten(args);
  return {
    should: flattened
  };
}

// 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 (includes(fields, ",")) {
        return fulltextOrNgram(
          fOrN,
          fields.split(","),
          query,
          operator,
          boost
        );
      } else if (includes(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/ngram.ts
function ngram(fields, query, operator = QUERY_OPERATOR_OR, boost) {
  return fulltextOrNgram("ngram", fields, query, operator, boost);
}
export {
  ngram
};