@creejs/commons-lang 2.1.7 → 2.1.9

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
   }
@@ -153,7 +153,8 @@ var TypeUtils = {
   isFloat64Array,
   isBigInt64Array,
   isBigUint64Array,
-  isTypedArray
+  isTypedArray,
+  isArrayBuffer
 };
 /**
    * Checks if the given value is an array.
@@ -483,7 +484,7 @@ function isInt32Array (value) {
 function isUint32Array (value) {
   return value instanceof Uint32Array
 }
-// export function isFloat16Array (value) {
+// function isFloat16Array (value) {
 //   return value instanceof Float16Array
 // }
 /**
@@ -519,6 +520,15 @@ function isBigUint64Array (value) {
   return value instanceof BigUint64Array
 }
 
+/**
+ * Checks if the given value is an ArrayBuffer.
+ * @param {*} value - The value to check.
+ * @returns {boolean} True if the value is an ArrayBuffer, false otherwise.
+ */
+function isArrayBuffer (value) {
+  return value instanceof ArrayBuffer
+}
+
 // 3rd
 // internal
 // owned
@@ -557,7 +567,8 @@ var TypeAssert = {
   assertFloat64Array,
   assertBigInt64Array,
   assertBigUint64Array,
-  assertTypedArray
+  assertTypedArray,
+  assertArrayBuffer
 };
 /**
    * if value is not Array, throw error
@@ -911,6 +922,18 @@ function assertBigUint64Array (value, paramName) {
   }
 }
 
+/**
+ * Asserts that the given value is an ArrayBuffer.
+ * @param {*} value - The value to check.
+ * @param {string} [paramName] - Optional parameter name for error message.
+ * @throws {Error} Throws an error if the value is not an ArrayBuffer.
+ */
+function assertArrayBuffer (value, paramName) {
+  if (!isArrayBuffer(value)) {
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ' '}Not ArrayBuffer`)
+  }
+}
+
 // 3rd
 // internal
 // owned
@@ -1861,6 +1884,154 @@ 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
+}
+
+var ArrayBufferUtils = {
+  readString,
+  writeString
+};
+
+// module vars
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+/**
+ * Reads a string from an ArrayBuffer at the specified offset and length.
+ * 1. if offset >= buffer.byteLength, return undefined
+ * 2. if length is not specified, read all bytes from offset to the end of buffer
+ * 3. if length is specified
+ *   * if offset + length >= buffer.byteLength, return a Uint8Array from offset to the end of buffer
+ *   * if offset + length < buffer.byteLength, return a Uint8Array from offset to offset + length
+ * @param {ArrayBuffer} buffer - The buffer to read from.
+ * @param {number} [offset=0] - The offset in bytes to start reading from.
+ * @param {number} [length] - The number of bytes to read.
+ * @returns {string|undefined} The decoded string.
+ */
+function readString (buffer, offset = 0, length) {
+  assertArrayBuffer(buffer);
+  assertNotNegative(offset);
+  if (offset >= buffer.byteLength) {
+    return undefined
+  }
+  let uint8Array = null;
+  if (length != null) {
+    assertPositive(length);
+    if (offset + length >= buffer.byteLength) {
+      uint8Array = new Uint8Array(buffer, offset);
+    } else {
+      uint8Array = new Uint8Array(buffer, offset, length);
+    }
+  } else {
+    uint8Array = new Uint8Array(buffer, offset);
+  }
+
+  // An ArrayBuffer, a TypedArray, or a DataView object containing the encoded text to decode.
+  return textDecoder.decode(uint8Array)
+}
+
+/**
+ * Writes a string to an ArrayBuffer at the specified offset.
+ * @param {ArrayBuffer} buffer - The buffer to write to
+ * @param {string} str - The string to write
+ * @param {number} [offset=0] - The offset in bytes to start writing
+ * @returns {void}
+ */
+function writeString (buffer, str, offset = 0) {
+  assertArrayBuffer(buffer, 'buffer');
+  assertString(str, 'str');
+  assertNotNegative(offset, 'offset');
+  const uint8Array = textEncoder.encode(str);
+  const strByteLength = uint8Array.byteLength;
+  if (offset + strByteLength > buffer.byteLength) {
+    throw new Error(`offset + str.byteLength > buffer.byteLength:${offset + strByteLength} > ${buffer.byteLength}`)
+  }
+  const dataView = new Uint8Array(buffer, offset, uint8Array.byteLength);
+  dataView.set(uint8Array);
+}
+
 /**
  * @module Lang
  * @description Core language utilities for type checking, string manipulation, and common operations.
@@ -1879,9 +2050,12 @@ var index = {
   Exec: ExecUtils,
   ClassProxyUtils,
   InstanceProxyUtils,
-  ReflectUtils
+  ReflectUtils,
+  TypedArrayUtils,
+  ArrayBufferUtils
 };
 
+exports.ArrayBufferUtils = ArrayBufferUtils;
 exports.ClassProxyUtils = ClassProxyUtils;
 exports.Exec = ExecUtils;
 exports.ExecUtils = ExecUtils;
@@ -1894,5 +2068,6 @@ exports.StringUtils = StringUtils;
 exports.Type = TypeUtils;
 exports.TypeAssert = TypeAssert;
 exports.TypeUtils = TypeUtils;
+exports.TypedArrayUtils = TypedArrayUtils;
 exports.default = index;
 //# sourceMappingURL=index-dev.cjs.map