@creejs/commons-lang 2.1.5 → 2.1.7

package/dist/cjs/index-dev.cjs

@@ -127,6 +127,7 @@ var TypeUtils = {
   isNumber,
   isPositive,
   isNegative,
+  isNotNegative,
   isNil,
   isNullOrUndefined,
   isNull,
@@ -140,7 +141,19 @@ var TypeUtils = {
   isStream,
   isString,
   isSymbol,
-  isPrimitive
+  isPrimitive,
+  isInt8Array,
+  isUint8Array,
+  isUint8ClampedArray,
+  isInt16Array,
+  isUint16Array,
+  isInt32Array,
+  isUint32Array,
+  isFloat32Array,
+  isFloat64Array,
+  isBigInt64Array,
+  isBigUint64Array,
+  isTypedArray
 };
 /**
    * Checks if the given value is an array.
@@ -265,6 +278,18 @@ function isPositive (value) {
   return value > 0
 }
 
+/**
+ * Checks if value is a number, and >=0
+ * @param {*} value - The value to check.
+ * @returns {boolean}
+ */
+function isNotNegative (value) {
+  if (!isNumber(value)) {
+    return false
+  }
+  return value >= 0
+}
+
 /**
  * check that a value is a Negative number.
  * @param {number} value - The value to check.
@@ -394,6 +419,106 @@ function isSymbol (value) {
   return value != null && typeof value === 'symbol'
 }
 
+/**
+ * Checks if a value is a typed array (e.g., Int8Array, Uint32Array, etc.).
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a typed array, false otherwise.
+ */
+function isTypedArray (value) {
+  return ArrayBuffer.isView(value) && value.constructor !== DataView
+}
+/**
+ * Checks if the given value is an Int8Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is an Int8Array, false otherwise.
+ */
+function isInt8Array (value) {
+  return value instanceof Int8Array
+}
+/**
+ * Checks if the given value is an instance of Uint8Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Uint8Array, false otherwise.
+ */
+function isUint8Array (value) {
+  return value instanceof Uint8Array
+}
+/**
+ * Checks if the given value is a Uint8ClampedArray.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Uint8ClampedArray, false otherwise.
+ */
+function isUint8ClampedArray (value) {
+  return value instanceof Uint8ClampedArray
+}
+/**
+ * Checks if the given value is an Int16Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is an Int16Array, false otherwise.
+ */
+function isInt16Array (value) {
+  return value instanceof Int16Array
+}
+/**
+ * Checks if the given value is a Uint16Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Uint16Array, false otherwise.
+ */
+function isUint16Array (value) {
+  return value instanceof Uint16Array
+}
+/**
+ * Checks if the given value is an Int32Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is an Int32Array, false otherwise.
+ */
+function isInt32Array (value) {
+  return value instanceof Int32Array
+}
+/**
+ * Checks if the given value is a Uint32Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Uint32Array, false otherwise.
+ */
+function isUint32Array (value) {
+  return value instanceof Uint32Array
+}
+// export function isFloat16Array (value) {
+//   return value instanceof Float16Array
+// }
+/**
+ * Checks if the given value is a Float32Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Float32Array, false otherwise.
+ */
+function isFloat32Array (value) {
+  return value instanceof Float32Array
+}
+/**
+ * Checks if the given value is a Float64Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a Float64Array, false otherwise.
+ */
+function isFloat64Array (value) {
+  return value instanceof Float64Array
+}
+/**
+ * Checks if the given value is a BigInt64Array.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a BigInt64Array, false otherwise.
+ */
+function isBigInt64Array (value) {
+  return value instanceof BigInt64Array
+}
+/**
+ * Checks if the given value is a BigUint64Array instance.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is a BigUint64Array, false otherwise.
+ */
+function isBigUint64Array (value) {
+  return value instanceof BigUint64Array
+}
+
 // 3rd
 // internal
 // owned
@@ -405,6 +530,7 @@ var TypeAssert = {
   assertNumber,
   assertPositive,
   assertNegative,
+  assertNotNegative,
   assertBoolean,
   assertObject,
   assertPlainObject,
@@ -419,7 +545,19 @@ var TypeAssert = {
   assertUndefined,
   assertString,
   assertArray,
-  assertStringOrSymbol
+  assertStringOrSymbol,
+  assertInt8Array,
+  assertUint8Array,
+  assertUint8ClampedArray,
+  assertInt16Array,
+  assertUint16Array,
+  assertInt32Array,
+  assertUint32Array,
+  assertFloat32Array,
+  assertFloat64Array,
+  assertBigInt64Array,
+  assertBigUint64Array,
+  assertTypedArray
 };
 /**
    * if value is not Array, throw error
@@ -482,6 +620,18 @@ function assertNegative (value, paramName) {
   }
 }
 
+/**
+ * Asserts that a value is 0 or Positive
+ * @param {number} value - The value to check.
+ * @param {string} [paramName] - Optional name of the parameter for error message.
+ * @throws {Error} If the value is not a number or is less than zero.
+ */
+function assertNotNegative (value, paramName) {
+  if (!isNotNegative(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not "0 or Positive": ${value}`)
+  }
+}
+
 /**
    * if value is not a string, throw error
    * @param {*} value
@@ -640,6 +790,127 @@ function assertStringOrSymbol (value, paramName) {
   }
 }
 
+/**
+ * assert if a value is a typed array (e.g., Int8Array, Uint32Array, etc.).
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertTypedArray (value, paramName) {
+  if (isTypedArray(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not TypedArray`)
+  }
+}
+/**
+ * assert if the given value is an Int8Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertInt8Array (value, paramName) {
+  if (isInt8Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Int8Array`)
+  }
+}
+/**
+ * assert if the given value is an instance of Uint8Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertUint8Array (value, paramName) {
+  if (isUint8Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Uint8Array`)
+  }
+}
+/**
+ * assert if the given value is a Uint8ClampedArray.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertUint8ClampedArray (value, paramName) {
+  if (isUint8ClampedArray(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Uint8ClampedArray`)
+  }
+}
+/**
+ * assert if the given value is an Int16Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertInt16Array (value, paramName) {
+  if (isInt16Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Int16Array`)
+  }
+}
+/**
+ * assert if the given value is a Uint16Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertUint16Array (value, paramName) {
+  if (isUint16Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Uint16Array`)
+  }
+}
+/**
+ * assert if the given value is an Int32Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertInt32Array (value, paramName) {
+  if (isInt32Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Int32Array`)
+  }
+}
+/**
+ * assert if the given value is a Uint32Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertUint32Array (value, paramName) {
+  if (isUint32Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Uint32Array`)
+  }
+}
+/**
+ * assert if the given value is a Float32Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertFloat32Array (value, paramName) {
+  if (isFloat32Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Float32Array`)
+  }
+}
+/**
+ * assert if the given value is a Float64Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertFloat64Array (value, paramName) {
+  if (isFloat64Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not Float64Array`)
+  }
+}
+/**
+ * assert if the given value is a BigInt64Array.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertBigInt64Array (value, paramName) {
+  if (isBigInt64Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not BigInt64Array`)
+  }
+}
+/**
+ * assert if the given value is a BigUint64Array instance.
+ * @param {*} value - The value to check.
+ * @param {string} paramName
+ */
+function assertBigUint64Array (value, paramName) {
+  if (isBigUint64Array(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not BigUint64Array`)
+  }
+}
+
 // 3rd
 // internal
 // owned