@code-o-mat/globals/lib/assertions/js-types.js

Abstract Package to support CodeOMat series of apps.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.assertIsKeyOrNONE = exports.assertIsKey = exports.assertIsIntOrNONE = exports.assertIsInt = exports.assertIsSymbolOrNONE = exports.assertIsSymbol = exports.assertIsStringOrNONE = exports.assertIsString = exports.assertIsObjectOrNONE = exports.assertIsObject = exports.assertIsNumberOrNONE = exports.assertIsNumber = exports.assertIsFunctionOrNONE = exports.assertIsFunction = exports.assertIsBooleanOrNONE = exports.assertIsBoolean = exports.assertIsArrayOrNONE = exports.assertIsArray = void 0;

var _values = require("../constants/values");

var _baseAssertions = require("./base-assertions");

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var assertIsArray = function assertIsArray(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Array";
  (0, _baseAssertions.assert)(Array.isArray(value) === true, message);
};

exports.assertIsArray = assertIsArray;

var assertIsArrayOrNONE = function assertIsArrayOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Array";
  (0, _baseAssertions.assert)(value === _values.NONE || Array.isArray(value) === true, message);
};

exports.assertIsArrayOrNONE = assertIsArrayOrNONE;

var assertIsBoolean = function assertIsBoolean(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Binary";
  (0, _baseAssertions.assert)(typeof value === 'boolean', message);
};

exports.assertIsBoolean = assertIsBoolean;

var assertIsBooleanOrNONE = function assertIsBooleanOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Binary";
  (0, _baseAssertions.assert)(value === _values.NONE || typeof value === 'boolean', message);
};

exports.assertIsBooleanOrNONE = assertIsBooleanOrNONE;

var assertIsFunction = function assertIsFunction(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Function";
  (0, _baseAssertions.assert)(typeof value === 'function', message);
};

exports.assertIsFunction = assertIsFunction;

var assertIsFunctionOrNONE = function assertIsFunctionOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Function";
  (0, _baseAssertions.assert)(value === _values.NONE || typeof value === 'function', message);
};

exports.assertIsFunctionOrNONE = assertIsFunctionOrNONE;

var assertIsNumber = function assertIsNumber(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Number";
  (0, _baseAssertions.assert)(typeof value === 'number', message);
};

exports.assertIsNumber = assertIsNumber;

var assertIsNumberOrNONE = function assertIsNumberOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Number";
  (0, _baseAssertions.assert)(value === _values.NONE || typeof value === 'number', message);
};

exports.assertIsNumberOrNONE = assertIsNumberOrNONE;

var assertIsObject = function assertIsObject(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Object";
  (0, _baseAssertions.assert)(_typeof(value) === 'object', message);
};

exports.assertIsObject = assertIsObject;

var assertIsObjectOrNONE = function assertIsObjectOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Object";
  (0, _baseAssertions.assert)(value === _values.NONE || _typeof(value) === 'object', message);
};

exports.assertIsObjectOrNONE = assertIsObjectOrNONE;

var assertIsString = function assertIsString(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid String";
  (0, _baseAssertions.assert)(typeof value === 'string', message);
};

exports.assertIsString = assertIsString;

var assertIsStringOrNONE = function assertIsStringOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid String";
  (0, _baseAssertions.assert)(value === _values.NONE || typeof value === 'string', message);
};

exports.assertIsStringOrNONE = assertIsStringOrNONE;

var assertIsSymbol = function assertIsSymbol(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Symbol";
  (0, _baseAssertions.assert)(_typeof(value) === 'symbol', message);
};

exports.assertIsSymbol = assertIsSymbol;

var assertIsSymbolOrNONE = function assertIsSymbolOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Symbol";
  (0, _baseAssertions.assert)(value === _values.NONE || _typeof(value) === 'symbol', message);
};

exports.assertIsSymbolOrNONE = assertIsSymbolOrNONE;

var assertIsInt = function assertIsInt(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Integer";
  (0, _baseAssertions.assert)(Number.isInteger(value), message);
};

exports.assertIsInt = assertIsInt;

var assertIsIntOrNONE = function assertIsIntOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Integer";
  (0, _baseAssertions.assert)(value === _values.NONE || Number.isInteger(value), message);
};

exports.assertIsIntOrNONE = assertIsIntOrNONE;

var assertIsKey = function assertIsKey(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Key";

  var ty = _typeof(value);

  (0, _baseAssertions.assert)(ty === 'string' || ty === 'symbol', message);
};

exports.assertIsKey = assertIsKey;

var assertIsKeyOrNONE = function assertIsKeyOrNONE(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid Key";

  var ty = _typeof(value);

  (0, _baseAssertions.assert)(value === _values.NONE || ty === 'string' || ty === 'symbol', message);
};

exports.assertIsKeyOrNONE = assertIsKeyOrNONE;