@creejs/commons-lang 2.1.24 → 2.1.26

package/dist/esm/index-dev.js

@@ -158,14 +158,14 @@ function constructorName (value) {
 
 /**
  * Assigns default values from source objects to target object for undefined properties.
- * @param {Object<string, any>} target - The target object to assign defaults to
- * @param {...Object<string, any>} sources - Source objects containing default values
- * @returns {Object<string, any>} The modified target object with defaults applied
- * @throws {TypeError} If target is null or undefined
+ * 1. No Deep-Copy, only first level properties are assigned.
+ * @param {{[key:string]:any}} target - The target object to assign defaults to
+ * @param {...{[key:string]:any}|undefined} sources - Source objects containing default values
+ * @returns {{[key:string]:any}} The modified target object with defaults applied
  */
 function defaults (target, ...sources) {
   if (target == null) {
-    throw new TypeError('"target" must not be null or undefined')
+    throw new TypeError('"target" Should Not Nil')
   }
   for (const source of sources) {
     if (source == null) {
@@ -1145,11 +1145,13 @@ function isEmpty (str) {
 /**
  * Asserts that the given string is not empty.
  * @param {string} str - The string to check.
+ * @param {string} [paramName]
+ *
  * @throws {Error} Throws an error if the string is empty.
  */
-function assertNotEmpty (str) {
+function assertNotEmpty (str, paramName) {
   if (isEmpty(str)) {
-    throw new Error(`Empty String: ${str}`)
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ''}IsEmpty String: ${str}`)
   }
 }
 
@@ -1170,11 +1172,12 @@ function isBlank (str) {
 /**
  * Asserts that the given string is not blank.
  * @param {string} str - The string to check.
+ * @param {string} [paramName]
  * @throws {Error} Throws an error if the string is blank.
  */
-function assertNotBlank (str) {
+function assertNotBlank (str, paramName) {
   if (isBlank(str)) {
-    throw new Error(`Blank String: ${str}`)
+    throw new Error(`${paramName ? '"' + paramName + '" ' : ''}Is Blank: ${str}`)
   }
 }
 
@@ -2038,6 +2041,9 @@ async function parallelAllSettled (tasks, maxParallel = 5) {
  * 2. Maybe multiple tasks are executed as a bulk block, and all of them resolved.
  *    * only the first fulfilled value is returned
  *    * other results are dropped
+ * 3. Notice:
+ *    * In Beginning, we start bulk(maxParallel) of tasks
+ *    * One task failed, it will start next task immediately, Not Wait for the bulk(maxParallel) to complete
  * @param {Array<Function|Promise<any>>} tasks - Array of async functions to execute
  * @param {number} [maxParallel=5] - Maximum number of tasks to run in parallel
  * @returns {Promise<any>} Resolves with the result of the first successfully completed task
@@ -2075,12 +2081,13 @@ async function parallelAny (tasks, maxParallel = 5) {
       // @ts-ignore
       taskPromise = returnValuePromised(task);
     } else {
-      errors.push(new TypeError(`Invalid task: ${task}`));
-      takeTaskAndRun();
-      return
+      taskPromise = Promise.reject(new TypeError(`Invalid task: ${typeof task}, Only Promise or Function allowed`));
     }
+
     taskPromise.then(/** @type {any} */ rtnVal => {
-      deferred.resolve(rtnVal);
+      runningTasksCount--; // DO Not put in finally
+      // any task resolved,  whole parallelAny resolved
+      deferred.resolve(rtnVal); // This may be called many times: In worst case, "maxParallel" times
     }).catch(e => {
       errors.push(e);
       // No task left, and No successful execution, reject with errors
@@ -2090,13 +2097,13 @@ async function parallelAny (tasks, maxParallel = 5) {
           return
         }
       }
-      takeTaskAndRun();
-    }).finally(() => {
-      runningTasksCount--;
+      runningTasksCount--; // DO Not put in finally, must reduce before takeTaskAndRun()
+      takeTaskAndRun(); // start next task
     });
   }
-  // start tasks until maxParallel
-  while (runningTasksCount < maxParallel) {
+  // start tasks until maxParallel or no more task
+  const parallelCount = Math.min(tasks.length, maxParallel);
+  for (let i = 0; i < parallelCount; i++) {
     takeTaskAndRun();
   }
   return deferred.promise
@@ -2524,6 +2531,7 @@ const s2ns = 1_000_000_000;
 var TimeUtils = {
   s2ns,
   ms2ns,
+  timestamp,
   timestamp64,
   lapseNano,
   lapseMillis,
@@ -2532,8 +2540,9 @@ var TimeUtils = {
 };
 
 /**
- * Gets the current timestamp in nanoseconds (if running in Node.js) or milliseconds (in browser).
- * Uses `process.hrtime.bigint()` for high-resolution timestamps in Node.js, falls back to `Date.now()` in browsers.
+ * Gets the current timestamp in nanoseconds
+ * * If "performance" API is available, uses performance timeOrigin + now()
+ * * Else fall back to `Date.now()` to get milliseconds and convert to nanoseconds
  * @returns {bigint} Current timestamp as a BigInt
  */
 function timestamp64 () {
@@ -2548,6 +2557,24 @@ function timestamp64 () {
   return BigInt(Date.now() * ms2ns)
 }
 
+/**
+ * Gets the current timestamp in milliseconds
+ * * If "performance" API is available, uses performance timeOrigin + now(), then convert to milliseconds
+ * * Else fall back to `Date.now()`
+ * @returns {number} Current timestamp in milliseconds
+ */
+function timestamp () {
+  // sinon can not fake performance.timeOrigin, so we have to check it
+  if (typeof performance !== 'undefined' && typeof performance.timeOrigin === 'number') {
+    // timeOrigin specifies the high resolution millisecond timestamp, eg. 1756350801931.159
+    const base = performance.timeOrigin;
+    // the current high resolution millisecond timestamp, eg.31767926.416357
+    const now = performance.now();
+    return Math.ceil((base + now) / ms2ns)
+  }
+  return Date.now()
+}
+
 /**
  * Calculates the time elapsed in nanoseconds between the given timestamp and now.
  * @param {bigint} start - start timestamp64, in nanoseconds.