@creejs/commons-lang 2.1.24 → 2.1.26

package/dist/umd/index.dev.js

@@ -164,14 +164,14 @@
 
   /**
    * 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) {
@@ -1151,11 +1151,13 @@
   /**
    * 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}`)
     }
   }
 
@@ -1176,11 +1178,12 @@
   /**
    * 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}`)
     }
   }
 
@@ -2044,6 +2047,9 @@
    * 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
@@ -2081,12 +2087,13 @@
         // @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
@@ -2096,13 +2103,13 @@
             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
@@ -2530,6 +2537,7 @@
   var TimeUtils = {
     s2ns,
     ms2ns,
+    timestamp,
     timestamp64,
     lapseNano,
     lapseMillis,
@@ -2538,8 +2546,9 @@
   };
 
   /**
-   * 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 () {
@@ -2554,6 +2563,24 @@
     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.