@creejs/commons-lang 1.0.8 → 1.0.10

package/types/promise-utils.d.ts

@@ -5,23 +5,11 @@
  * @param {string} [timeoutMessage]
  * @returns {{promise: Promise<*>, reject: function, resolve: function}}
  */
-export function defer(timeout?: number, timeoutMessage?: string): {
+export function defer(timeout?: number | undefined, timeoutMessage?: string | undefined): {
     promise: Promise<any>;
     reject: Function;
     resolve: Function;
 };
-/**
-   * Delays a promise by a specified time.
-   * 1. delay(), wait 1ms
-   * 2. delay(1000), wait 1000ms
-   * 3. delay(promise), after promise settled, wait 1000ms
-   * 4. delay(promise, 2000), after promise settled, wait 2000ms
-   *
-   * @param {Promise<*>|number|undefined} [promise] - The input promise to delay
-   * @param {number|undefined} [ms] - Minimum delay in milliseconds (default: 1)
-   * @returns {Promise} A new promise that settles after the delay period
-   */
-export function delay(promise?: Promise<any> | number | undefined, ms?: number | undefined): Promise<any>;
 /**
  * Creates a timeout wrapper around a promise that rejects if the promise doesn't resolve within the given time.
  * @param {Promise<*>} promise - The promise to wrap with a timeout
@@ -30,7 +18,7 @@ export function delay(promise?: Promise<any> | number | undefined, ms?: number |
  * @returns {Promise<*>} A new promise that either resolves with the original promise's value, rejects with original promise's error or timeout error
  * @throws {TypeError} If input is not a promise or timeout is not a number
  */
-export function timeout(promise: Promise<any>, time?: number, message?: string): Promise<any>;
+export function timeout(promise: Promise<any>, time?: number | undefined, message?: string | undefined): Promise<any>;
 /**
  * Excutes All promises in parallel and returns an array of results.
  *
@@ -54,9 +42,21 @@ export function allSettled(promises: Promise<any>): Array<{
    * @returns {Promise<*>}
    */
 export function returnValuePromised(task: Function): Promise<any>;
+/**
+   * Delays a promise by a specified time.
+   * 1. delay(), wait 1ms
+   * 2. delay(1000), wait 1000ms
+   * 3. delay(promise), after promise settled, wait 1000ms
+   * 4. delay(promise, 2000), after promise settled, wait 2000ms
+   *
+   * @param {Promise<*>|number|undefined} [promise] - The input promise to delay
+   * @param {number|undefined} [ms] - Minimum delay in milliseconds (default: 1)
+   * @returns {Promise} A new promise that settles after the delay period
+   */
+export function delay(promise?: Promise<any> | number | undefined, ms?: number | undefined): Promise<any>;
 /**
    * Fast-Fail mode to execute Tasks(functions) in series (one after another) and returns their results in order.
-   * 1. function are executed one by one
+   * 1. export function are executed one by one
    * 2. Fast Fail: if any tasks fail, the whole chain is rejected with the first error
    * 3. if an element is not function, rejects the whole chain with Error(Not Function)
    * @param {Function[]} promises
@@ -82,9 +82,9 @@ export function seriesAllSettled(tasks: Function[]): Promise<Array<{
    * @param {Function[]} tasks
    * @param {number} [maxParallel=5]
    * @returns {Promise<Array>} Array of resolved values from all promises
-   * @throws {TypeError} If input is not an array of function or maxParallel is not a number
+   * @throws {TypeError} If input is not an array of export function or maxParallel is not a number
    */
-export function parallel(tasks: Function[], maxParallel?: number): Promise<any[]>;
+export function parallel(tasks: Function[], maxParallel?: number | undefined): Promise<any[]>;
 /**
    * AllSettled Mode to execute tasks in parallel with a maximum concurrency limit
    * 1. tasks are executed in parallel with a maximum concurrency limit
@@ -92,6 +92,18 @@ export function parallel(tasks: Function[], maxParallel?: number): Promise<any[]
    * @param {Function[]} tasks
    * @param {number} [maxParallel=5] - Maximum number of tasks to run in parallel
    * @returns {Promise<Array>} Array of resolved values from all promises
-   * @throws {TypeError} If input is not an array of function or maxParallel is not a number
+   * @throws {TypeError} If input is not an array of export function or maxParallel is not a number
    */
-export function parallelAllSettled(tasks: Function[], maxParallel?: number): Promise<any[]>;
+export function parallelAllSettled(tasks: Function[], maxParallel?: number | undefined): Promise<any[]>;
+declare namespace _default {
+    export { defer };
+    export { delay };
+    export { timeout };
+    export { allSettled };
+    export { returnValuePromised };
+    export { series };
+    export { seriesAllSettled };
+    export { parallel };
+    export { parallelAllSettled };
+}
+export default _default;

package/types/string-utils.d.ts

@@ -48,7 +48,7 @@ export function decapitalize(str: string): string;
  * @returns {string[]} An array of string chunks with fixed length.
  * @throws {Error} If `str` is not a string or `length` is not a number.
  */
-export function splitWithFixedLength(str: string, length: number, padding?: string): string[];
+export function splitWithFixedLength(str: string, length: number, padding?: string | undefined): string[];
 /**
  * Splits a string into chunks using the specified markers.
  * 1. If no markers are provided, defaults to comma (',').
@@ -150,3 +150,23 @@ export function substringBetweenGreedy(str: string, startMarker: string, endMark
  * @throws {Error} If any input is not a string
  */
 export function substringsBetween(str: string, startMarker: string, endMarker: string): string[];
+declare namespace _default {
+    export { isEmpty };
+    export { assertNotEmpty };
+    export { isBlank };
+    export { assertNotBlank };
+    export { capitalize };
+    export { decapitalize };
+    export { splitWithFixedLength };
+    export { split };
+    export { findMarkerPositions };
+    export { findMarkerPositionsRegex };
+    export { substringBefore };
+    export { substringBeforeLast };
+    export { substringAfter };
+    export { substringAfterLast };
+    export { substringBetween };
+    export { substringBetweenGreedy };
+    export { substringsBetween };
+}
+export default _default;

package/types/type-assert.d.ts

@@ -1,3 +1,19 @@
+/**
+   * if value is not Array, throw error
+   * @param {*} value
+   * @param {string} [paramName] - The name of the parameter to check
+   * @returns {void}
+   * @throws {Error}
+   */
+export function assertArray(value: any, paramName?: string | undefined): void;
+/**
+   * if value is not a string, throw error
+   * @param {*} value
+   * @param {string} [paramName] - The name of the parameter to check
+   * @returns {void}
+   * @throws {Error}
+   */
+export function assertString(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Number, throw error
    * @param {*} value
@@ -5,21 +21,21 @@
    * @returns {void}
    * @throws {Error}
    */
-export function assertNumber(value: any, paramName?: string): void;
+export function assertNumber(value: any, paramName?: string | undefined): void;
 /**
  * Asserts that a value is a positive number.
  * @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 or equal to zero.
  */
-export function assertPositive(value: number, paramName?: string): void;
+export function assertPositive(value: number, paramName?: string | undefined): void;
 /**
  * Asserts that a value is a Negative number.
  * @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 or equal to zero.
  */
-export function assertNegative(value: number, paramName?: string): void;
+export function assertNegative(value: number, paramName?: string | undefined): void;
 /**
    * if value is not a string, throw error
    * @param {*} value
@@ -27,7 +43,7 @@ export function assertNegative(value: number, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertBoolean(value: any, paramName?: string): void;
+export function assertBoolean(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Object, throw error
    * @param {*} value
@@ -35,7 +51,7 @@ export function assertBoolean(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertObject(value: any, paramName?: string): void;
+export function assertObject(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a PlainObject, throw error
    * @param {*} value
@@ -43,7 +59,7 @@ export function assertObject(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertPlainObject(value: any, paramName?: string): void;
+export function assertPlainObject(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Symbol, throw error
    * @param {*} value
@@ -51,7 +67,7 @@ export function assertPlainObject(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertSymbol(value: any, paramName?: string): void;
+export function assertSymbol(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Function, throw error
    * @param {*} value
@@ -59,7 +75,7 @@ export function assertSymbol(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertFunction(value: any, paramName?: string): void;
+export function assertFunction(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Class instance, throw error
    * @param {*} value
@@ -67,7 +83,7 @@ export function assertFunction(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertInstance(value: any, paramName?: string): void;
+export function assertInstance(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a string, throw error
    * @param {*} value
@@ -75,7 +91,7 @@ export function assertInstance(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertPromise(value: any, paramName?: string): void;
+export function assertPromise(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Null or Undefined, throw error
    * @param {*} value
@@ -83,14 +99,14 @@ export function assertPromise(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertNil(value: any, paramName?: string): void;
+export function assertNil(value: any, paramName?: string | undefined): void;
 /**
  * Asserts that the given value is not nil.
  * @param {*} value - The value to check
  * @param {string} [paramName] - The name of the parameter to check
  * @throws {Error} Throws an error if the value is nil
  */
-export function assertNotNil(value: any, paramName?: string): void;
+export function assertNotNil(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Null, throw error
    * @param {*} value
@@ -98,14 +114,14 @@ export function assertNotNil(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertNull(value: any, paramName?: string): void;
+export function assertNull(value: any, paramName?: string | undefined): void;
 /**
  * Asserts that the given value is not null.
  * @param {*} value - The value to check
  * @param {string} [paramName] - The name of the parameter to check
  * @throws {Error} Throws an error if the value is null
  */
-export function assertNotNull(value: any, paramName?: string): void;
+export function assertNotNull(value: any, paramName?: string | undefined): void;
 /**
    * if value is not a Undefined, throw error
    * @param {*} value
@@ -113,27 +129,32 @@ export function assertNotNull(value: any, paramName?: string): void;
    * @returns {void}
    * @throws {Error}
    */
-export function assertUndefined(value: any, paramName?: string): void;
-/**
-   * if value is not a string, throw error
-   * @param {*} value
-   * @param {string} [paramName] - The name of the parameter to check
-   * @returns {void}
-   * @throws {Error}
-   */
-export function assertString(value: any, paramName?: string): void;
-/**
-   * if value is not Array, throw error
-   * @param {*} value
-   * @param {string} [paramName] - The name of the parameter to check
-   * @returns {void}
-   * @throws {Error}
-   */
-export function assertArray(value: any, paramName?: string): void;
+export function assertUndefined(value: any, paramName?: string | undefined): void;
 /**
  * Asserts that the given value is either a string or a symbol.
  * @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 a string or symbol.
  */
-export function assertStringOrSymbol(value: any, paramName?: string): void;
+export function assertStringOrSymbol(value: any, paramName?: string | undefined): void;
+declare namespace _default {
+    export { assertNumber };
+    export { assertPositive };
+    export { assertNegative };
+    export { assertBoolean };
+    export { assertObject };
+    export { assertPlainObject };
+    export { assertSymbol };
+    export { assertFunction };
+    export { assertInstance };
+    export { assertPromise };
+    export { assertNil };
+    export { assertNotNil };
+    export { assertNull };
+    export { assertNotNull };
+    export { assertUndefined };
+    export { assertString };
+    export { assertArray };
+    export { assertStringOrSymbol };
+}
+export default _default;

package/types/type-utils.d.ts

@@ -1,7 +1,3 @@
-/**
- * @module TypeUtils
- * @description Utility functions for type checking and validation.
- */
 /**
    * Checks if the given value is an array.
    * @param {*} value - The value to check.
@@ -20,6 +16,18 @@ export function isBoolean(value: any): boolean;
    * @returns {boolean} True if the value is a Buffer, false otherwise.
    */
 export function isBuffer(value: any): boolean;
+/**
+   * Checks if the given value is a Date.
+   * @param {*} value - The value to check.
+   * @returns {boolean} True if the value is a Date, false otherwise.
+   */
+export function isDate(value: any): boolean;
+/**
+   * Checks if the given value is an instance of Error.
+   * @param {*} value - The value to check.
+   * @returns {boolean} True if the value is an Error, false otherwise.
+   */
+export function isError(value: any): boolean;
 /**
    * Checks if the given value is a function.
    * @param {*} value - The value to check.
@@ -38,18 +46,6 @@ export function isInstance(value: any): boolean;
    * @returns {boolean} True if the value is isIterable, false otherwise.
    */
 export function isIterable(value: any): boolean;
-/**
-   * Checks if the given value is a Date.
-   * @param {*} value - The value to check.
-   * @returns {boolean} True if the value is a Date, false otherwise.
-   */
-export function isDate(value: any): boolean;
-/**
-   * Checks if the given value is an instance of Error.
-   * @param {*} value - The value to check.
-   * @returns {boolean} True if the value is an Error, false otherwise.
-   */
-export function isError(value: any): boolean;
 /**
    * Checks if a value is Map
    * @param {*} value - The value to check.
@@ -62,23 +58,6 @@ export function isMap(value: any): boolean;
    * @returns {boolean} True if the value is WeakMap, otherwise false.
    */
 export function isWeakMap(value: any): boolean;
-/**
-   * Checks if a value is a number.
-   * @param {*} value - The value to check.
-   * @returns {boolean} True if the value is a number, false otherwise.
-   */
-export function isNumber(value: any): boolean;
-/**
- * check that a value is a positive number.
- * @param {number} value - The value to check.
- * @returns {boolean}
- */
-export function isPositive(value: number): boolean;
-/**
- * check that a value is a Negative number.
- * @param {number} value - The value to check.
- */
-export function isNegative(value: number): boolean;
 /**
    * Checks if a value is null or undefined.
    * 1. value == null
@@ -94,6 +73,17 @@ export function isNil(value: any): boolean;
    * @returns {boolean} True if the value is null or undefined, otherwise false.
    */
 export function isNullOrUndefined(value: any): boolean;
+/**
+ * check that a value is a positive number.
+ * @param {number} value - The value to check.
+ * @returns {boolean}
+ */
+export function isPositive(value: number): boolean;
+/**
+ * check that a value is a Negative number.
+ * @param {number} value - The value to check.
+ */
+export function isNegative(value: number): boolean;
 /**
    * Checks if the given value is exactly null.
    * @param {*} value - The value to check.
@@ -107,17 +97,30 @@ export function isNull(value: any): boolean;
    */
 export function isUndefined(value: any): boolean;
 /**
-   * Checks if a value is a plain object (created by the Object constructor).
+   * Checks if a value is a number.
    * @param {*} value - The value to check.
-   * @returns {boolean} True if the value is a plain object, false otherwise.
+   * @returns {boolean} True if the value is a number, false otherwise.
    */
-export function isPlainObject(value: any): boolean;
+export function isNumber(value: any): boolean;
 /**
    * Checks if a value is an object (and not null).
    * @param {*} value - The value to check
    * @returns {boolean} True if the value is an object (not null), false otherwise
    */
 export function isObject(value: any): boolean;
+/**
+   * Checks if a value is a plain object (created by the Object constructor).
+   * @param {*} value - The value to check.
+   * @returns {boolean} True if the value is a plain object, false otherwise.
+   */
+export function isPlainObject(value: any): boolean;
+/**
+   * check if value is primitive: string, number, boolean
+   * 1. null/undefined returns false
+   * @param {*} value
+   * @returns {boolean}
+   */
+export function isPrimitive(value: any): boolean;
 /**
    * Checks if a value is a Promise.
    * @param {*} value - The value to check.
@@ -160,10 +163,33 @@ export function isString(value: any): boolean;
    * @returns {boolean} True if the value is a Symbol, false otherwise.
    */
 export function isSymbol(value: any): boolean;
-/**
-   * check if value is primitive: string, number, boolean
-   * 1. null/undefined returns false
-   * @param {*} value
-   * @returns {boolean}
-   */
-export function isPrimitive(value: any): boolean;
+declare namespace _default {
+    export { isArray };
+    export { isBoolean };
+    export { isBuffer };
+    export { isFunction };
+    export { isInstance };
+    export { isIterable };
+    export { isDate };
+    export { isError };
+    export { isMap };
+    export { isWeakMap };
+    export { isNumber };
+    export { isPositive };
+    export { isNegative };
+    export { isNil };
+    export { isNullOrUndefined };
+    export { isNull };
+    export { isUndefined };
+    export { isPlainObject };
+    export { isObject };
+    export { isPromise };
+    export { isRegExp };
+    export { isSet };
+    export { isWeakSet };
+    export { isStream };
+    export { isString };
+    export { isSymbol };
+    export { isPrimitive };
+}
+export default _default;

package/lib/class-proxy-utils.js

@@ -1,66 +0,0 @@
-'use strict'
-
-const { isPlainObject } = require('./type-utils')
-
-/**
- * @module ClassProxyUtils
- */
-
-/**
- * Creates a Proxy Class for given class.
- * @template {object} T
- * @param {Function} cls - The class to proxycls - The class to proxy
- * @param {ProxyHandler<T>} [propertyHandler = {}] - Proxy Property Handler
- * @param {boolean} [sealed=true] - Whether to seal the instance
- * @returns {Function} A proxied classA proxied instance of the class
- */
-function proxy (cls, propertyHandler, sealed = true) {
-  if (typeof cls !== 'function') {
-    throw new TypeError(`Not Class: type=${typeof cls}, value=${JSON.stringify(cls)}`)
-  }
-  if (propertyHandler != null) {
-    if (!isPlainObject(propertyHandler)) {
-      throw new TypeError(`Not PropertyHandler: type=${typeof propertyHandler}, value=${JSON.stringify(propertyHandler)}`)
-    }
-    const { get, set } = propertyHandler
-    if (get != null && typeof get !== 'function') {
-      throw new TypeError(`Not PropertyHandler.get: type=${typeof get}, value=${JSON.stringify(get)}`)
-    }
-    if (set != null && typeof set !== 'function') {
-      throw new TypeError(`Not PropertyHandler.set: type=${typeof set}, value=${JSON.stringify(set)}`)
-    }
-  }
-  const construcHandler = {
-    /**
-     * Creates a proxied instance of a class, optionally sealing it.
-     * @param {Function} constructor - The class constructor to instantiate.
-     * @param {any[]} args - Arguments to pass to the constructor.
-     * @param {Function} [newTarget] - The constructor that was originally called by `new`.
-     * @returns {Proxy} A proxied instance of the constructed class.
-     */
-    construct (constructor, args, newTarget) {
-      const clsInstance = Reflect.construct(constructor, args)
-      return new Proxy(sealed ? Object.preventExtensions(clsInstance) : clsInstance, propertyHandler ?? {})
-    }
-  }
-  return new Proxy(cls, construcHandler)
-}
-
-/**
- * Creates a proxied instance of a class with custom property handling.
- * @template {object} T
- * @param {Function} cls - The class to proxy
- * @param {any[]} args - Arguments to pass to the constructor
- * @param {ProxyHandler<T>} propertyHandler - Handler for property access/mutation
- * @param {boolean} [sealed=true] - Whether the proxy should be sealed
- * @returns {T} Proxied class instance
- */
-function newProxyInstance (cls, args, propertyHandler, sealed = true) {
-  const proxyCls = proxy(cls, propertyHandler, sealed)
-  return Reflect.construct(proxyCls, args ?? [])
-}
-
-module.exports = {
-  proxy,
-  newProxyInstance
-}

package/lib/exec-utils.js

@@ -1,58 +0,0 @@
-'use strict'
-/**
- * @module ExecUtils
- * @description Utils about how to execute task functions.
- */
-
-// @ts-ignore
-const { assertFunction, assertArray } = require('./type-assert')
-const { isPromise } = require('./type-utils')
-
-/**
-   * Executes a task silently, suppressing any errors or rejections.
-   * @param {Function} task - The function to execute.
-   * @returns {Promise<*>|*} The return value of the task, or a Promise if the task is asynchronous.
-   */
-function quiet (task) {
-  assertFunction(task)
-  try {
-    const rtnVal = task()
-    if (isPromise(rtnVal)) {
-      return rtnVal.catch(() => {
-        // do nothing
-      })
-    }
-    return rtnVal
-  } catch (e) {
-    // do nothing
-  }
-}
-
-/**
-   * Executes a task quietly, capturing any errors and passing them to the errorKeeper.
-   * 1. Handles both synchronous and asynchronous (Promise) tasks.
-   * @param {Function} task - The function to execute.
-   * @param {Error[]} errorKeeper - The array to store any caught errors.
-   * @returns {Promise<*>|*} The return value of the task, or a Promise if the task is asynchronous.
-   */
-function quietKeepError (task, errorKeeper) {
-  assertFunction(task)
-  assertArray(errorKeeper)
-  try {
-    const rtnVal = task()
-    if (isPromise(rtnVal)) {
-      // @ts-ignore
-      return rtnVal.catch(e => errorKeeper.push(e))
-    }
-    return rtnVal
-  } catch (e) {
-    // @ts-ignore
-    errorKeeper.push(e)
-  }
-}
-const ExecUtils = {
-  quiet,
-  quietKeepError
-}
-
-module.exports = ExecUtils

package/lib/index.js

@@ -1,30 +0,0 @@
-'use strict'
-
-/**
- * @module Lang
- * @description Core language utilities for type checking, string manipulation, and common operations.
- */
-
-const LangUtils = require('./lang-utils')
-const StringUtils = require('./string-utils')
-const TypeUtils = require('./type-utils')
-const TypeAssert = require('./type-assert')
-const ExecUtils = require('./exec-utils')
-const PromiseUtils = require('./promise-utils')
-const ClassProxyUtils = require('./class-proxy-utils')
-const InstanceProxyUtils = require('./instance-proxy-utils')
-
-module.exports = {
-  LangUtils,
-  StringUtils,
-  TypeUtils,
-  TypeAssert,
-  ExecUtils,
-  PromiseUtils,
-  Lang: LangUtils,
-  String: StringUtils,
-  Type: TypeUtils,
-  Exec: ExecUtils,
-  ClassProxyUtils,
-  InstanceProxyUtils
-}

package/lib/instance-proxy-utils.js

@@ -1,27 +0,0 @@
-'use strict'
-
-const { isObject, isNil, isArray } = require('./type-utils')
-
-/**
- * @module InstanceProxyUtils
- */
-
-/**
- * Creates a proxy wrapper around an object instance with optional property handler.
- * @template {object} T
- * @param {T} instance - The target object to proxy
- * @param {ProxyHandler<T>} [propertyHandler] - Optional proxy handler for property access
- * @param {boolean} [sealed=true] - Whether to prevent extensions on the target object
- * @returns {T} The proxied object instance
- * @throws {TypeError} If instance is not an object
- */
-function proxy (instance, propertyHandler, sealed = true) {
-  if (isNil(instance) || !isObject(instance) || isArray(instance)) {
-    throw new TypeError(`Not Object: type=${typeof instance}, value=${JSON.stringify(instance)}`)
-  }
-  return new Proxy(sealed ? Object.preventExtensions(instance) : instance, propertyHandler ?? {})
-}
-
-module.exports = {
-  proxy
-}