@enonic/js-utils/dist/esm/value/index.mjs

Enonic XP JavaScript Utils

// value/isBigInt.ts
function isBigInt(value) {
  return typeof value === "bigint";
}

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

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

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

// value/isDateString.ts
function isDateString(value) {
  return typeof value === "string" && !isNaN(Date.parse(value));
}

// value/isFalse.ts
function isFalse(value) {
  return value === false;
}

// 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/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/isGeoPoint.ts
function isGeoPoint(v) {
  return isString(v) ? isGeoPointString(v) : isGeoPointArray(v);
}

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

// 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/isNonNegativeIntegerString.ts
function isNonNegativeIntegerString(s) {
  if (!isString(s) || !s.length || s.length > 1 && s.charCodeAt(0) === 48) {
    return false;
  }
  for (let i = s.length - 1; i >= 0; i--) {
    const d = s.charCodeAt(i);
    if (d < 48 || d > 57) {
      return false;
    }
  }
  return true;
}

// value/isNotSet.ts
var isNotSet = (value) => value === null || typeof value === "undefined";

// value/isNull.ts
function isNull(value) {
  return value === null;
}

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

// value/isPositiveInteger.ts
function isPositiveInteger(v) {
  if (!isInt(v) || v < 0) {
    return false;
  }
  return true;
}

// 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/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/isTime.ts
function isTime(v) {
  return isDate(v) || isTimeString(v);
}

// value/isTrue.ts
function isTrue(value) {
  return value === true;
}

// value/isUndefined.ts
function isUndefined(value) {
  return typeof value === "undefined";
}

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

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

// value/index.ts
function isNotFalse(value) {
  return value !== false;
}
function isNotTrue(value) {
  return value !== true;
}
export {
  isBasicObject,
  isBigInt,
  isBoolean,
  isDate,
  isDateString,
  isFalse,
  isFunction,
  isGeoPoint,
  isGeoPointArray,
  isGeoPointString,
  isInfinity,
  isInstantString,
  isInt,
  isInteger,
  isLocalDateString,
  isLocalDateTimeString,
  isNonNegativeIntegerString,
  isNotFalse,
  isNotSet,
  isNotTrue,
  isNull,
  isNumber,
  isObject,
  isPositiveInteger,
  isPropertyKey,
  isSet,
  isString,
  isStringLiteral,
  isStringObject,
  isSymbol,
  isTime,
  isTimeString,
  isTrue,
  isUndefined,
  isUuidV4String,
  toStr
};