@haravan-tech/util v1.0.0

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.

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

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

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

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

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

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