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

Enonic XP JavaScript Utils

// storage/indexing/constants.ts
var INDEX_CONFIG_ENABLED = "enabled";
var INDEX_CONFIG_DECIDE_BY_TYPE = "decideByType";
var INDEX_CONFIG_FULLTEXT = "fulltext";
var INDEX_CONFIG_INCLUDE_IN_ALL_TEXT = "includeInAllText";
var INDEX_CONFIG_INDEX_VALUE_PROCESSORS = "indexValueProcessors";
var INDEX_CONFIG_LANGUAGES = "languages";
var INDEX_CONFIG_N_GRAM = "nGram";
var INDEX_CONFIG_PATH = "path";
var INDEX_CONFIG_ENABLED_DEFAULT = true;
var INDEX_CONFIG_DECIDE_BY_TYPE_DEFAULT = true;
var INDEX_CONFIG_FULLTEXT_DEFAULT = false;
var INDEX_CONFIG_INCLUDE_IN_ALL_TEXT_DEFAULT = false;
var INDEX_CONFIG_N_GRAM_DEFAULT = false;
var INDEX_CONFIG_PATH_DEFAULT = false;
var INDEX_CONFIG_TEMPLATE_NONE = "none";
var INDEX_CONFIG_TEMPLATE_BY_TYPE = "byType";
var INDEX_CONFIG_TEMPLATE_FULLTEXT = "fulltext";
var INDEX_CONFIG_TEMPLATE_PATH = "path";
var INDEX_CONFIG_TEMPLATE_MINIMAL = "minimal";
var INDEX_CONFIG_TEMPLATES = [
  INDEX_CONFIG_TEMPLATE_NONE,
  INDEX_CONFIG_TEMPLATE_BY_TYPE,
  INDEX_CONFIG_TEMPLATE_FULLTEXT,
  INDEX_CONFIG_TEMPLATE_PATH,
  INDEX_CONFIG_TEMPLATE_MINIMAL
];

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

// 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/isInfinity.ts
function isInfinity(value) {
  return typeof value === "number" && !isFinite(value);
}

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

// storage/indexing/enonify.ts
function enonify(unknown) {
  function shouldBeDeleted(unknown2) {
    return unknown2 === null || typeof unknown2 === "undefined" || isFunction(unknown2) || isInfinity(unknown2) || isNumberButNaN(unknown2);
  }
  function enonifyArray(array) {
    const flattenedAndEnonified = flatten(array).map((v) => enonify(v)).filter((v) => !shouldBeDeleted(v));
    if (flattenedAndEnonified.length === 0) {
      return void 0;
    }
    if (flattenedAndEnonified.length === 1) {
      return flattenedAndEnonified[0];
    }
    return flattenedAndEnonified;
  }
  function isNumberButNaN(unknown2) {
    return typeof unknown2 === "number" && isNaN(unknown2);
  }
  if (isObject(unknown)) {
    Object.keys(unknown).forEach((k) => {
      let value = unknown[k];
      if (Array.isArray(value)) {
        value = enonifyArray(value);
      }
      if (Array.isArray(value)) {
        unknown[k] = value;
      } else {
        if (shouldBeDeleted(value)) {
          delete unknown[k];
        } else {
          unknown[k] = enonify(value);
        }
      }
    });
    return unknown;
  }
  if (Array.isArray(unknown)) {
    return enonifyArray(unknown);
  }
  if (isDate(unknown)) {
    return unknown.toISOString();
  }
  if (isNumberButNaN(unknown)) {
    return void 0;
  }
  if (isInfinity(unknown)) {
    return void 0;
  }
  return unknown;
}

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

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

// value/isGeoPointArray.ts
function isGeoPointArray(v) {
  if (!Array.isArray(v) || v.length !== 2) {
    return false;
  }
  const [lat, lon] = v;
  if (!isNumber(lat) && !isNumber(lon)) {
    return false;
  }
  if (lat < -90 || lat > 90) {
    return false;
  }
  if (lon < -180 || lon > 180) {
    return false;
  }
  return true;
}

// 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/isGeoPointString.ts
function isGeoPointString(v) {
  if (!isString(v)) {
    return false;
  }
  const array = v.split(",");
  if (array.length !== 2) {
    return false;
  }
  const [lat, lon] = array;
  if (!isString(lat) || !isString(lon)) {
    return false;
  }
  return isGeoPointArray([
    parseFloat(lat),
    parseFloat(lon)
  ]);
}

// value/isInstantString.ts
var REGEXP_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}(\.\d{0,9})?Z$/;
function isInstantString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_INSTANT);
  if (matches) {
    try {
      const d = new Date(Date.parse(matches[0]));
      if (v.substring(0, 19) === d.toISOString().substring(0, 19)) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// 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/isLocalDateString.ts
var REGEXP_DATE = /^\d{4}-\d{2}-\d{2}$/;
function isLocalDateString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_DATE);
  if (matches) {
    try {
      const d = new Date(Date.parse(matches[0]));
      if (v.substring(0, 10) === d.toISOString().substring(0, 10)) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// value/isLocalDateTimeString.ts
var REGEXP_DATE2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{0,9})?)?$/;
function isLocalDateTimeString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_DATE2);
  if (matches) {
    const localDateTimeStringToParse = `${matches[0].substring(0, 19)}Z`;
    try {
      const d = new Date(Date.parse(localDateTimeStringToParse));
      let inputTrimmed = v.substring(0, 19);
      if (inputTrimmed.length === 16) {
        inputTrimmed += ":00";
      }
      const parsedTrimmed = d.toJSON().substring(0, 19);
      if (inputTrimmed === parsedTrimmed) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// value/isTimeString.ts
var REGEXP_TIME = /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9](\.\d{0,9})?)?$/;
function isTimeString(v) {
  if (!isString(v)) {
    return false;
  }
  return REGEXP_TIME.test(v);
}

// value/isUuidV4String.ts
var REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
function isUuidV4String(value) {
  return isString(value) ? REGEXP.test(value) : false;
}

// storage/indexing/indexTemplateToConfig.ts
function indexTemplateToConfig({
  template,
  indexValueProcessors,
  // = [],
  languages
  // = []
}) {
  if (isObject(template)) {
    const configObject = JSON.parse(JSON.stringify(template));
    if (indexValueProcessors) {
      configObject.indexValueProcessors = indexValueProcessors;
    }
    if (languages) {
      configObject.languages = languages;
    }
    return configObject;
  }
  if (template === INDEX_CONFIG_TEMPLATE_NONE) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: false,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_BY_TYPE) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: true,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_FULLTEXT) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: true,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: true
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = true;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_PATH) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = true;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_MINIMAL) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  throw new Error(`Unknown indexing template:${template}!`);
}

// storage/indexing/path/join.ts
function join(paths, separator = "/") {
  let parts = [];
  for (let i = 0; i < paths.length; i += 1) {
    parts = parts.concat(paths[i].split(separator));
  }
  const newParts = [];
  for (let i = 0; i < parts.length; i += 1) {
    const part = parts[i];
    if (!part || part === ".") continue;
    if (part === "..") newParts.pop();
    else newParts.push(part);
  }
  if (parts[0] === "") newParts.unshift("");
  return newParts.join(separator) || (newParts.length ? separator : ".");
}

// storage/indexing/path/dirname.ts
function dirname(path, separator = "/") {
  return join([path, ".."], separator);
}

// storage/indexing/path/trimExt.ts
function trimExt(s) {
  return s.replace(/\.[^/.]+$/, "");
}

// storage/indexing/stemming.ts
var STEMMING_LANGUAGE_CODE_ARABIC = "ar";
var STEMMING_LANGUAGE_CODE_BULGARIAN = "bg";
var STEMMING_LANGUAGE_CODE_BENGALI = "bn";
var STEMMING_LANGUAGE_CODE_CATALAN = "ca";
var STEMMING_LANGUAGE_CODE_CZECH = "cs";
var STEMMING_LANGUAGE_CODE_DANISH = "da";
var STEMMING_LANGUAGE_CODE_GERMAN = "de";
var STEMMING_LANGUAGE_CODE_GREEK = "el";
var STEMMING_LANGUAGE_CODE_ENGLISH = "en";
var STEMMING_LANGUAGE_CODE_BASQUE = "eu";
var STEMMING_LANGUAGE_CODE_PERSIAN = "fa";
var STEMMING_LANGUAGE_CODE_FINNISH = "fi";
var STEMMING_LANGUAGE_CODE_FRENCH = "fr";
var STEMMING_LANGUAGE_CODE_IRISH = "ga";
var STEMMING_LANGUAGE_CODE_GALICIAN = "gl";
var STEMMING_LANGUAGE_CODE_HINDI = "in";
var STEMMING_LANGUAGE_CODE_HUNGARIAN = "hu";
var STEMMING_LANGUAGE_CODE_ARMENIAN = "hy";
var STEMMING_LANGUAGE_CODE_INDONESIAN = "id";
var STEMMING_LANGUAGE_CODE_ITALIAN = "it";
var STEMMING_LANGUAGE_CODE_JAPANESE = "ja";
var STEMMING_LANGUAGE_CODE_KOREAN = "ko";
var STEMMING_LANGUAGE_CODE_SORANI = "ku";
var STEMMING_LANGUAGE_CODE_LITHUANIAN = "lt";
var STEMMING_LANGUAGE_CODE_LATVIAN = "lv";
var STEMMING_LANGUAGE_CODE_DUTCH = "nl";
var STEMMING_LANGUAGE_CODE_NORWEGIAN = "no";
var STEMMING_LANGUAGE_CODE_PORTUGUESE = "pt";
var STEMMING_LANGUAGE_CODE_BRAZILIAN = "pt-br";
var STEMMING_LANGUAGE_CODE_ROMANIAN = "ro";
var STEMMING_LANGUAGE_CODE_RUSSIAN = "ru";
var STEMMING_LANGUAGE_CODE_SPANISH = "es";
var STEMMING_LANGUAGE_CODE_SWEDISH = "sv";
var STEMMING_LANGUAGE_CODE_TURKISH = "tr";
var STEMMING_LANGUAGE_CODE_THAI = "th";
var STEMMING_LANGUAGE_CODE_CHINESE = "zh";
var STEMMING_LANGUAGE_CODES = [
  STEMMING_LANGUAGE_CODE_ARABIC,
  STEMMING_LANGUAGE_CODE_BULGARIAN,
  STEMMING_LANGUAGE_CODE_BENGALI,
  STEMMING_LANGUAGE_CODE_CATALAN,
  STEMMING_LANGUAGE_CODE_CZECH,
  STEMMING_LANGUAGE_CODE_DANISH,
  STEMMING_LANGUAGE_CODE_GERMAN,
  STEMMING_LANGUAGE_CODE_GREEK,
  STEMMING_LANGUAGE_CODE_ENGLISH,
  STEMMING_LANGUAGE_CODE_BASQUE,
  STEMMING_LANGUAGE_CODE_PERSIAN,
  STEMMING_LANGUAGE_CODE_FINNISH,
  STEMMING_LANGUAGE_CODE_FRENCH,
  STEMMING_LANGUAGE_CODE_IRISH,
  STEMMING_LANGUAGE_CODE_GALICIAN,
  STEMMING_LANGUAGE_CODE_HINDI,
  STEMMING_LANGUAGE_CODE_HUNGARIAN,
  STEMMING_LANGUAGE_CODE_ARMENIAN,
  STEMMING_LANGUAGE_CODE_INDONESIAN,
  STEMMING_LANGUAGE_CODE_ITALIAN,
  STEMMING_LANGUAGE_CODE_JAPANESE,
  STEMMING_LANGUAGE_CODE_KOREAN,
  STEMMING_LANGUAGE_CODE_SORANI,
  STEMMING_LANGUAGE_CODE_LITHUANIAN,
  STEMMING_LANGUAGE_CODE_LATVIAN,
  STEMMING_LANGUAGE_CODE_DUTCH,
  STEMMING_LANGUAGE_CODE_NORWEGIAN,
  STEMMING_LANGUAGE_CODE_PORTUGUESE,
  STEMMING_LANGUAGE_CODE_BRAZILIAN,
  STEMMING_LANGUAGE_CODE_ROMANIAN,
  STEMMING_LANGUAGE_CODE_RUSSIAN,
  STEMMING_LANGUAGE_CODE_SPANISH,
  STEMMING_LANGUAGE_CODE_SWEDISH,
  STEMMING_LANGUAGE_CODE_TURKISH,
  STEMMING_LANGUAGE_CODE_THAI,
  STEMMING_LANGUAGE_CODE_CHINESE
];
var STEMMING_LANGUAGES = [
  {
    code: STEMMING_LANGUAGE_CODE_ARABIC,
    language: "Arabic"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BULGARIAN,
    language: "Bulgarian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BENGALI,
    language: "Bengali"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CATALAN,
    language: "Catalan"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CZECH,
    language: "Czech"
  },
  {
    code: STEMMING_LANGUAGE_CODE_DANISH,
    language: "Danish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GERMAN,
    language: "German"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GREEK,
    language: "Greek"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ENGLISH,
    language: "English"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BASQUE,
    language: "Basque"
  },
  {
    code: STEMMING_LANGUAGE_CODE_PERSIAN,
    language: "Persian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_FINNISH,
    language: "Finnish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_FRENCH,
    language: "French"
  },
  {
    code: STEMMING_LANGUAGE_CODE_IRISH,
    language: "Irish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GALICIAN,
    language: "Galician"
  },
  {
    code: STEMMING_LANGUAGE_CODE_HINDI,
    language: "Hindi"
  },
  {
    code: STEMMING_LANGUAGE_CODE_HUNGARIAN,
    language: "Hungarian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ARMENIAN,
    language: "Armenian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_INDONESIAN,
    language: "Indonesian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ITALIAN,
    language: "Italian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_JAPANESE,
    language: "Japanese"
  },
  {
    code: STEMMING_LANGUAGE_CODE_KOREAN,
    language: "Korean"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SORANI,
    language: "Sorani"
  },
  {
    code: STEMMING_LANGUAGE_CODE_LITHUANIAN,
    language: "Lithuanian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_LATVIAN,
    language: "Latvian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_DUTCH,
    language: "Dutch"
  },
  {
    code: STEMMING_LANGUAGE_CODE_NORWEGIAN,
    language: "Norwegian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_PORTUGUESE,
    language: "Portuguese"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BRAZILIAN,
    language: "Brazilian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ROMANIAN,
    language: "Romanian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_RUSSIAN,
    language: "Russian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SPANISH,
    language: "Spanish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SWEDISH,
    language: "Swedish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_TURKISH,
    language: "Turkish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_THAI,
    language: "Thai"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CHINESE,
    language: "Chinese"
  }
];

// constants.ts
var DOT_SIGN = ".";

// storage/indexing/uniqueId.ts
function uniqueId({
  repoId,
  branchId,
  nodeId,
  versionKey
}) {
  if (!repoId) {
    throw new TypeError("uniqueId: Missing required named parameter repoId!");
  }
  if (!nodeId) {
    throw new TypeError("uniqueId: Missing required named parameter nodeId!");
  }
  const parts = [repoId];
  if (branchId) {
    parts.push(branchId);
  }
  parts.push(nodeId);
  if (versionKey) {
    parts.push(versionKey);
  }
  return parts.join(DOT_SIGN);
}

// array/findIndex.ts
function findIndex(array, callbackFn) {
  const length = array.length >>> 0;
  for (let i = 0; i < length; i++) {
    if (callbackFn(array[i], i, array)) {
      return i;
    }
  }
  return -1;
}

// storage/indexing/updateIndexConfigs.ts
function updateIndexConfigs({
  configs,
  updates = []
}) {
  const dereffedConfigs = JSON.parse(JSON.stringify(configs));
  for (let i = 0; i < updates.length; i++) {
    const anUpdate = updates[i];
    const j = findIndex(
      dereffedConfigs,
      //({path}: IndexConfigsItem) => path === anUpdate.path
      (item) => item.path === anUpdate.path
    );
    if (j !== -1) {
      dereffedConfigs.splice(j, 1, anUpdate);
    } else {
      dereffedConfigs.push(anUpdate);
    }
  }
  dereffedConfigs.sort(
    (a, b) => a.path > b.path ? 1 : -1
  );
  return dereffedConfigs;
}

// storage/indexing/valueType/constants.ts
var VALUE_TYPE_ANY = "any";
var VALUE_TYPE_BOOLEAN = "boolean";
var VALUE_TYPE_DOUBLE = "double";
var VALUE_TYPE_GEO_POINT = "geoPoint";
var VALUE_TYPE_INSTANT = "instant";
var VALUE_TYPE_LOCAL_DATE = "localDate";
var VALUE_TYPE_LOCAL_DATE_TIME = "localDateTime";
var VALUE_TYPE_LOCAL_TIME = "localTime";
var VALUE_TYPE_LONG = "long";
var VALUE_TYPE_REFERENCE = "reference";
var VALUE_TYPE_SET = "set";
var VALUE_TYPE_STRING = "string";

// storage/indexing/valueType/detectValueType.ts
function detectCommonValueType(array) {
  let anyStringCount = 0;
  let geoPointArrayCount = 0;
  let objectCount = 0;
  let commonValueType;
  for (let i = 0; i < array.length; i++) {
    const value = array[i];
    if (isGeoPointArray(value)) {
      if (!commonValueType) {
        commonValueType = VALUE_TYPE_GEO_POINT;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (commonValueType === VALUE_TYPE_DOUBLE || commonValueType === VALUE_TYPE_GEO_POINT) {
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
      geoPointArrayCount++;
    } else if (Array.isArray(value)) {
      throw new Error("TODO: Enonic XP doesn't support Matrixes!");
    } else if (isBoolean(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_BOOLEAN) {
        commonValueType = VALUE_TYPE_BOOLEAN;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
    } else if (isDate(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_INSTANT) {
        commonValueType = VALUE_TYPE_INSTANT;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
    } else if (isNumber(value)) {
      if (!commonValueType) {
        commonValueType = VALUE_TYPE_DOUBLE;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (commonValueType === VALUE_TYPE_DOUBLE) {
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      } else if (geoPointArrayCount) {
        commonValueType = VALUE_TYPE_DOUBLE;
      }
    } else if (isObject(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_SET) {
        commonValueType = VALUE_TYPE_SET;
      } else {
        return VALUE_TYPE_ANY;
      }
      objectCount++;
    } else if (isString(value)) {
      if (isGeoPointString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_GEO_POINT) {
          commonValueType = VALUE_TYPE_GEO_POINT;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isInstantString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_INSTANT) {
          commonValueType = VALUE_TYPE_INSTANT;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isLocalDateString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_DATE) {
          commonValueType = VALUE_TYPE_LOCAL_DATE;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isLocalDateTimeString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_DATE_TIME) {
          commonValueType = VALUE_TYPE_LOCAL_DATE_TIME;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isTimeString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_TIME) {
          commonValueType = VALUE_TYPE_LOCAL_TIME;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isUuidV4String(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_REFERENCE) {
          commonValueType = VALUE_TYPE_REFERENCE;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else {
        commonValueType = VALUE_TYPE_STRING;
      }
      anyStringCount++;
    } else {
      return VALUE_TYPE_ANY;
    }
  }
  return commonValueType;
}
function detectValueType(value) {
  if (isGeoPointArray(value)) {
    return VALUE_TYPE_GEO_POINT;
  }
  if (Array.isArray(value)) {
    if (!value.length) {
      return VALUE_TYPE_ANY;
    }
    return detectCommonValueType(value);
  }
  if (isBoolean(value)) {
    return VALUE_TYPE_BOOLEAN;
  }
  if (isDate(value)) {
    return VALUE_TYPE_INSTANT;
  }
  if (isNumber(value)) {
    return VALUE_TYPE_DOUBLE;
  }
  if (isObject(value)) {
    return VALUE_TYPE_SET;
  }
  if (isString(value)) {
    if (isGeoPointString(value)) {
      return VALUE_TYPE_GEO_POINT;
    }
    if (isInstantString(value)) {
      return VALUE_TYPE_INSTANT;
    }
    if (isLocalDateString(value)) {
      return VALUE_TYPE_LOCAL_DATE;
    }
    if (isLocalDateTimeString(value)) {
      return VALUE_TYPE_LOCAL_DATE_TIME;
    }
    if (isTimeString(value)) {
      return VALUE_TYPE_LOCAL_TIME;
    }
    if (isUuidV4String(value)) {
      return VALUE_TYPE_REFERENCE;
    }
    return VALUE_TYPE_STRING;
  }
  return VALUE_TYPE_ANY;
}
export {
  INDEX_CONFIG_DECIDE_BY_TYPE,
  INDEX_CONFIG_DECIDE_BY_TYPE_DEFAULT,
  INDEX_CONFIG_ENABLED,
  INDEX_CONFIG_ENABLED_DEFAULT,
  INDEX_CONFIG_FULLTEXT,
  INDEX_CONFIG_FULLTEXT_DEFAULT,
  INDEX_CONFIG_INCLUDE_IN_ALL_TEXT,
  INDEX_CONFIG_INCLUDE_IN_ALL_TEXT_DEFAULT,
  INDEX_CONFIG_INDEX_VALUE_PROCESSORS,
  INDEX_CONFIG_LANGUAGES,
  INDEX_CONFIG_N_GRAM,
  INDEX_CONFIG_N_GRAM_DEFAULT,
  INDEX_CONFIG_PATH,
  INDEX_CONFIG_PATH_DEFAULT,
  INDEX_CONFIG_TEMPLATES,
  INDEX_CONFIG_TEMPLATE_BY_TYPE,
  INDEX_CONFIG_TEMPLATE_FULLTEXT,
  INDEX_CONFIG_TEMPLATE_MINIMAL,
  INDEX_CONFIG_TEMPLATE_NONE,
  INDEX_CONFIG_TEMPLATE_PATH,
  STEMMING_LANGUAGES,
  STEMMING_LANGUAGE_CODES,
  STEMMING_LANGUAGE_CODE_ARABIC,
  STEMMING_LANGUAGE_CODE_ARMENIAN,
  STEMMING_LANGUAGE_CODE_BASQUE,
  STEMMING_LANGUAGE_CODE_BENGALI,
  STEMMING_LANGUAGE_CODE_BRAZILIAN,
  STEMMING_LANGUAGE_CODE_BULGARIAN,
  STEMMING_LANGUAGE_CODE_CATALAN,
  STEMMING_LANGUAGE_CODE_CHINESE,
  STEMMING_LANGUAGE_CODE_CZECH,
  STEMMING_LANGUAGE_CODE_DANISH,
  STEMMING_LANGUAGE_CODE_DUTCH,
  STEMMING_LANGUAGE_CODE_ENGLISH,
  STEMMING_LANGUAGE_CODE_FINNISH,
  STEMMING_LANGUAGE_CODE_FRENCH,
  STEMMING_LANGUAGE_CODE_GALICIAN,
  STEMMING_LANGUAGE_CODE_GERMAN,
  STEMMING_LANGUAGE_CODE_GREEK,
  STEMMING_LANGUAGE_CODE_HINDI,
  STEMMING_LANGUAGE_CODE_HUNGARIAN,
  STEMMING_LANGUAGE_CODE_INDONESIAN,
  STEMMING_LANGUAGE_CODE_IRISH,
  STEMMING_LANGUAGE_CODE_ITALIAN,
  STEMMING_LANGUAGE_CODE_JAPANESE,
  STEMMING_LANGUAGE_CODE_KOREAN,
  STEMMING_LANGUAGE_CODE_LATVIAN,
  STEMMING_LANGUAGE_CODE_LITHUANIAN,
  STEMMING_LANGUAGE_CODE_NORWEGIAN,
  STEMMING_LANGUAGE_CODE_PERSIAN,
  STEMMING_LANGUAGE_CODE_PORTUGUESE,
  STEMMING_LANGUAGE_CODE_ROMANIAN,
  STEMMING_LANGUAGE_CODE_RUSSIAN,
  STEMMING_LANGUAGE_CODE_SORANI,
  STEMMING_LANGUAGE_CODE_SPANISH,
  STEMMING_LANGUAGE_CODE_SWEDISH,
  STEMMING_LANGUAGE_CODE_THAI,
  STEMMING_LANGUAGE_CODE_TURKISH,
  VALUE_TYPE_ANY,
  VALUE_TYPE_BOOLEAN,
  VALUE_TYPE_DOUBLE,
  VALUE_TYPE_GEO_POINT,
  VALUE_TYPE_INSTANT,
  VALUE_TYPE_LOCAL_DATE,
  VALUE_TYPE_LOCAL_DATE_TIME,
  VALUE_TYPE_LOCAL_TIME,
  VALUE_TYPE_LONG,
  VALUE_TYPE_REFERENCE,
  VALUE_TYPE_SET,
  VALUE_TYPE_STRING,
  detectCommonValueType,
  detectValueType,
  dirname,
  enonify,
  indexTemplateToConfig,
  join,
  trimExt,
  uniqueId,
  updateIndexConfigs
};