@creejs/commons-lang 2.1.6 → 2.1.8

package/dist/cjs/index-dev.cjs

@@ -12,7 +12,7 @@ var LangUtils = {
   defaults,
   extend,
   extends: extend,
-  equals,
+  equals: equals$1,
   isBrowser,
   isNode
 };
@@ -80,7 +80,7 @@ function extend (target, ...sources) {
  * @param {*} value2 - Second value to compare
  * @returns {boolean} True if values are equal, false otherwise
  */
-function equals (value1, value2) {
+function equals$1 (value1, value2) {
   if (value1 === value2) {
     return true
   }
@@ -141,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.
@@ -407,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
@@ -433,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
@@ -666,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
@@ -1616,6 +1861,92 @@ var ReflectUtils = {
   getMethodsOfObject: getMethods
 };
 
+// internal
+
+
+// owned
+
+/**
+ * @typedef {
+    Int8Array|
+    Uint8Array|
+    Uint8ClampedArray|
+    Int16Array|
+    Uint16Array|
+    Int32Array|
+    Uint32Array|
+    Float32Array|
+    Float64Array|
+    BigInt64Array|
+    BigUint64Array
+  } TypedArray
+ */
+
+var TypedArrayUtils = {
+  startsWith,
+  isSameType,
+  equals
+};
+
+/**
+ * Checks if a string starts with the specified substring.
+ * @param {TypedArray} src - The source string to check.
+ * @param {TypedArray} searching - The substring to search for at the start of `src`.
+ * @returns {boolean} True if `src` starts with `searching`, false otherwise.
+ * @throws {Error} If either `src` or `searching` is null or undefined.
+ */
+function startsWith (src, searching) {
+  assertNotNil(src, 'src');
+  assertNotNil(searching, 'searching');
+
+  const header = src.subarray(0, searching.length);
+  return equals(header, searching)
+}
+
+/**
+ * Checks if two values have the same constructor type.
+ * @param {*} src - The source value to compare.
+ * @param {*} target - The target value to compare against.
+ * @returns {boolean} True if both values have the same constructor type, false otherwise.
+ * @throws Will throw if either src or target is null/undefined.
+ */
+function isSameType (src, target) {
+  assertNotNil(src, 'src');
+  assertNotNil(target, 'target');
+  return constructorName(src) === constructorName(target)
+}
+
+/**
+ * Checks if two typed arrays are equal by comparing their contents.
+ * 1. Must be Same Type
+ * 2. Must have Same Length
+ * 3. Must have same contents
+ * @param {TypedArray} src - The source typed array to compare.
+ * @param {TypedArray} target - The target typed array to compare against.
+ * @returns {boolean} True if the typed arrays are equal, false otherwise.
+ * @throws {Error} If either `src` or `target` is null or undefined.
+ */
+function equals (src, target) {
+  assertNotNil(src, 'src');
+  assertNotNil(target, 'target');
+  if (!isSameType(src, target)) {
+    return false
+  }
+  if (src.byteLength !== target.byteLength) {
+    return false
+  }
+
+  const view1 = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  const view2 = new DataView(target.buffer, target.byteOffset, target.byteLength);
+
+  for (let i = 0; i < src.byteLength; i++) {
+    if (view1.getUint8(i) !== view2.getUint8(i)) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * @module Lang
  * @description Core language utilities for type checking, string manipulation, and common operations.
@@ -1634,7 +1965,8 @@ var index = {
   Exec: ExecUtils,
   ClassProxyUtils,
   InstanceProxyUtils,
-  ReflectUtils
+  ReflectUtils,
+  TypedArrayUtils
 };
 
 exports.ClassProxyUtils = ClassProxyUtils;
@@ -1649,5 +1981,6 @@ exports.StringUtils = StringUtils;
 exports.Type = TypeUtils;
 exports.TypeAssert = TypeAssert;
 exports.TypeUtils = TypeUtils;
+exports.TypedArrayUtils = TypedArrayUtils;
 exports.default = index;
 //# sourceMappingURL=index-dev.cjs.map