@snapdm/preconditions/index.cjs

General purpose preconditions for typesafe Typescript libraries

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function isDefined(value) {
  return value !== null && value !== void 0;
}
function isTruthy(value) {
  return !!value;
}
function isFalsy(value) {
  return !value;
}
function isUndefined(value) {
  return value === void 0;
}
function isNull(value) {
  return value === null;
}
function isBoolean(value) {
  return typeof value === "boolean";
}
function isString(value) {
  return typeof value === "string";
}
function isNumber(value) {
  return typeof value === "number";
}
function isBigInt(value) {
  return typeof value === "bigint";
}
function isFunction(value) {
  return typeof value === "function";
}
function isObject(value) {
  return typeof value === "object";
}
function isType(value, type) {
  return value instanceof type;
}

class PreconditionFailedError extends Error {
  constructor(message) {
    super(message);
    this.name = "PreconditionFailedError";
  }
}
function assert(condition, message) {
  if (!condition) {
    throw new PreconditionFailedError(message);
  }
}
function assertPredicate(condition, value, message) {
  assert(condition(value), message);
}
function assertIsDefined(value, message) {
  assertPredicate(isDefined, value, message);
}
function assertIsUndefined(value, message) {
  assertPredicate(isUndefined, value, message);
}
function assertIsNull(value, message) {
  assertPredicate(isNull, value, message);
}
function assertIsBoolean(value, message) {
  assertPredicate(isBoolean, value, message);
}
function assertIsString(value, message) {
  assertPredicate(isString, value, message);
}
function assertIsNumber(value, message) {
  assertPredicate(isNumber, value, message);
}
function assertIsBigInt(value, message) {
  assertPredicate(isBigInt, value, message);
}
function assertIsFunction(value, message) {
  assertPredicate(isFunction, value, message);
}
function assertIsObject(value, message) {
  assertPredicate(isObject, value, message);
}
function assertIsType(value, type, message) {
  assert(isType(value, type), message);
}

function checkIsDefined(value, message) {
  assertIsDefined(value, message);
  return value;
}

exports.PreconditionFailedError = PreconditionFailedError;
exports.assert = assert;
exports.assertIsBigInt = assertIsBigInt;
exports.assertIsBoolean = assertIsBoolean;
exports.assertIsDefined = assertIsDefined;
exports.assertIsFunction = assertIsFunction;
exports.assertIsNull = assertIsNull;
exports.assertIsNumber = assertIsNumber;
exports.assertIsObject = assertIsObject;
exports.assertIsString = assertIsString;
exports.assertIsType = assertIsType;
exports.assertIsUndefined = assertIsUndefined;
exports.assertPredicate = assertPredicate;
exports.checkIsDefined = checkIsDefined;
exports.isBigInt = isBigInt;
exports.isBoolean = isBoolean;
exports.isDefined = isDefined;
exports.isFalsy = isFalsy;
exports.isFunction = isFunction;
exports.isNull = isNull;
exports.isNumber = isNumber;
exports.isObject = isObject;
exports.isString = isString;
exports.isTruthy = isTruthy;
exports.isType = isType;
exports.isUndefined = isUndefined;
//# sourceMappingURL=index.cjs.map