@haravan-tech/util

util : object

Kind: global namespace

• util : object
  • .collection : object
    • .setOptions(target, options, properties) ⇒ object
  • .date : object
    • .nowLS([locale]) ⇒ string
    • .isValidDate(val) ⇒ boolean
  • .lang : object
    • .to(promise) ⇒ Array.<any>
    • .toResolve(callbackBasedAPI) ⇒ promise
    • .PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

util.collection : object

Kind: static namespace of util

collection.setOptions(target, options, properties) ⇒ object

Merge all options properties to target, Array value will be assign

Kind: static method of collection
Returns: object - target
Note: This method mutates object.

Param	Type	Description
target	object
options	*
properties	Array.<string> | object	use to pick from options before merging, should contain all options properties.\ If pass an object, properties will be extracted by Object.keys()

util.date : object

Kind: static namespace of util

• .date : object
  • .nowLS([locale]) ⇒ string
  • .isValidDate(val) ⇒ boolean

date.nowLS([locale]) ⇒ string

Get current time locale string

Kind: static method of date
Returns: string - current time locale string

Param	Type
[locale]	string

Example

nowLS() => '3/2/2019, 11:48:26 AM'

date.isValidDate(val) ⇒ boolean

Check whether val is a valid date

Kind: static method of date

Param	Type	Description
val	string | number | Date	val to check

util.lang : object

Kind: static namespace of util

• .lang : object
  • .to(promise) ⇒ Array.<any>
  • .toResolve(callbackBasedAPI) ⇒ promise
  • .PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

lang.to(promise) ⇒ Array.<any>

change the way handle promise

Kind: static method of lang
Returns: Array.<any> - [error, result]

Param	Type
promise	Object

Example

 // To handle mongoose error, instead of try catch :
 try {
  let store = await StoresModel.findOne({ id : 1000 });
 }
 catch (err) {
   // handle mongoose error
 }
 // You can :
 let [err, store] = await to(StoresModel.findOne({ id : 1000 }));
 if (err) {
  // handle mongoose error
 }

lang.toResolve(callbackBasedAPI) ⇒ promise

Wrap a callback-based-API with a promise that only resolve all callback arguments, and doesn't reject anything

Kind: static method of lang
Returns: promise - Promisified API

Param	Type	Description
callbackBasedAPI	function	The function that you want to wrap

Example

 // assume you have an function
 function callbackBasedAPI(a1, a2, ..., aN, callback) {
    // do something ...
    callback(err, res1, res2, ..., resN);
 }
 
 // and want to receive all callback argument in one call through async/await, like :
 let [err, res1, res2, ..., resN] = await callbackBasedAPI(a1, a2, ..., aN);
 
 // so can easily handle error :
 if (err) {
    handleError(err);
 }
 
 // just wrap it with before use
 let callbackBasedAPI = toResolve(callbackBasedAPI);

lang.PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

Applies the function iteratee to each item in coll after timeout, which's increased by step

Kind: static method of lang
Returns: promise - like Promise.all result

Param	Type	Description
coll	array	A collection to iterate over
iteratee	function	An async function to apply to each item in coll. Apply with (thisArg, item, index)
step	number	Amount of milisecond that timeout increase after each item
thisArg	object	The this pointer of iteratee

Example

  await PromiseAllStep(['hello', 'world', 'from', 'Vietnam !'], async word => console.log(word), 200); 
  Will print :
    hello    // after 0ms
    world    // after 200ms
    from     // after 400ms
    Vietnam  // after 600ms