queueobj 7.2.4 → 8.0.0

package/README.md

@@ -7,9 +7,9 @@ Included tag appenders:
 * func_all - asynchronous - process custom functions to added objects.
 * top_one - asynchronous - process only the object in the 0(zero) position of the process array.
 * bottom_one - asynchronous - process only the object in the last position of the process array.
-* sync - synchronous - process array objects in various ways: by items, by Ids as well as custom functions.
 * sync_all - synchronous - queue and process all objects by items as well as custom functions.
 * status - synchronous - queue and process all objects by status.
+* version - synchronous - queue and process all objects by version.
 
 Installation
 ---------
@@ -30,9 +30,9 @@ node test_all
 node test_top_one
 node test_bottom_one
 node test_func_all
-node test_sync
 node test_sync_all
 node test_status
+node test_version
 
 ```
 

package/app.js

@@ -10,7 +10,8 @@ var colors = require('colors'),
     bottom_one = require('./lib/appenders/bottom_one'),
     sync = require('./lib/appenders/sync'),
     sync_all = require('./lib/appenders/sync_all'),
-    status = require('./lib/appenders/status')
+    status = require('./lib/appenders/status'),
+    version = require('./lib/appenders/version')
 
 class QueueObj {
 
@@ -24,8 +25,8 @@ class QueueObj {
             t.top_one = null
             t.bottom_one = null
             t.array = null
-            t.sync = null
             t.status = null
+            t.version = null
             t.stats = false
             t.sync_all = null
             t.func_all = null
@@ -47,10 +48,10 @@ class QueueObj {
         }
     }
 
-    getStats (){
+    getStats() {
         return this.stats
     }
-    
+
     getObjectById(id) {
         let t = this, i
         for (i = 0; i < t.objs.length; i++) {
@@ -75,13 +76,25 @@ class QueueObj {
         return null
     }
 
+    getObjectByVersion(version) {
+        let t = this, i
+        for (i = 0; i < t.objs.length; i++) {
+            if (typeof t.objs[i] != 'undefined' &&
+                typeof t.objs[i].version != 'undefined' &&
+                t.objs[i].version == version) {
+                return t.objs[i]
+            }
+        }
+        return null
+    }
+
     count() {
-        return t.objs.length
+        return this.objs.length
     }
 
     get(num) {
-        if (num < t.objs.length)
-            return t.objs[num]
+        if (num < this.objs.length)
+            return this.objs[num]
         return false
     }
 
@@ -101,12 +114,12 @@ class QueueObj {
         try {
             var t = this
             t.props = props
-            t.stats = (typeof props.stats != 'undefined') ?  props.stats : false;
+            t.stats = (typeof props.stats != 'undefined') ? props.stats : false;
             if (typeof props != `undefined` &&
                 typeof props.appender != `undefined` &&
                 typeof props.appender == 'string') {
                 props.getParent = t.getParent
-                switch (props.appender) {  
+                switch (props.appender) {
                     case 'all':
                         t.all = new all(props)
                         break
@@ -125,9 +138,11 @@ class QueueObj {
                     case 'status':
                         t.status = new status(props)
                         break
-                    case 'sync':
+                    case 'version':
+                        t.version = new version(props)
+                        break
                     case 'sync_all':
-                        t.sync = new sync(props)
+                        t.sync_all = new sync_all(props)
                         break
                     default:
                         throw new Error(`appender(${props.appender}) not found`)
@@ -142,13 +157,55 @@ class QueueObj {
     }
 
     add(obj) {
+        var t = this
         try {
-            var t = this
+            if (t.all != null) {
+                obj.getType = (o) => {
+                    return 'all'
+                }
+            }
+            if (t.top_one != null) {
+                obj.getType = (o) => {
+                    return 'top_one'
+                }
+            }
+            if (t.bottom_one != null) {
+                t.objs = []
+                obj.getType = (o) => {
+                    return 'bottom_one'
+                }
+            }
+            if (t.func_all != null) {
+                obj.getType = (o) => {
+                    return 'func_all'
+                }
+            }
+            if (t.sync_all != null) {
+                obj.getType = (o) => {
+                    return 'sync_all'
+                }
+            }
+            if (typeof obj.status != 'undefined') {
+                obj.getType = (o) => {
+                    return o.status
+                }
+            }
+            if (typeof obj.version != 'undefined') {
+                obj.getType = (o) => {
+                    return o.version
+                }
+            }
+            if (t.top_one != null) {
+                if (t.objs.length == 0) {
+                    t.objs.push(obj)
+                }
+                return t
+            }
             t.objs.push(obj)
             return t
         } catch (e) {
             e.message = "queueObj app.js add error: " + e.message
-            console.log(e.message)
+            console.log(e.message.red)
             throw (e)
         }
     }
@@ -163,57 +220,68 @@ class QueueObj {
 
     process() {
         try {
-            var t = this, pro = { items: [] }
-            switch (t.props.appender) {
+            var t = this, pro = { dat_array: [] }
+            switch (t.props.appender) {  
                 case 'all':
-                    t.objs.map((item, i) => {
-                        pro.items.push(i)
-                    })
+                    pro.dat_array.push('all')
                     t.all.await(pro)
                     return t.all.process()
                 case 'top_one':
-                    pro.items = [0]
+                    pro.dat_array.push('top_one')
+                    t.top_one.await(pro)
                     return t.top_one.process()
                 case 'bottom_one':
-                    pro.items = [pro.items.length - 1]
+                    pro.dat_array.push('bottom_one')
+                    t.bottom_one.await(pro)
                     return t.bottom_one.process()
                 case 'func_all':
-                    t.objs.map((item, i) => {
-                        pro.items.push(i)
-                    })
+                    pro.dat_array.push('func_all')
                     t.func_all.await(pro)
                     return t.func_all.process()
                 case 'sync':
-                    return t.sync.process()
+                case 'sync_all':
+                    pro.dat_array.push('sync_all')
+                    t.sync_all.await(pro)
+                    return t.sync_all.process()
                 case 'status':
                     return t.status.process()
-                case 'sync_all':
-                    t.objs.map((item, i) => {
-                        pro.items.push(i)
-                    })
-                    t.sync.await(pro).then(res => {
-                        console.log(`done with ${JSON.stringify(pro)}: (${res})`.green)
-                    }, err => {
-                        console.log(`error ${JSON.stringify(pro)}: (${err})`.red)
-                    })
-                    return t.sync.process()
+                case 'version':
+                    return t.version.process()
+                // case 'sync_all':
+                //     t.objs.map((item, i) => {
+                //         pro.items.push(i)
+                //     })
+                //     t.sync.await(pro).then(res => {
+                //         console.log(`done with ${JSON.stringify(pro)}: (${res})`.green)
+                //     }, err => {
+                //         console.log(`error ${JSON.stringify(pro)}: (${err})`.red)
+                //     })
+                //     return t.sync.process()
                 default:
                     throw new Error(`nothing to process`)
             }
         } catch (e) {
             e.message = "queueObj app.js load error: " + e.message
-            console.log(e.message)
+            console.log(e.message.red)
             throw (e)
         }
     }
 
     await(props) {
+        var t = this, pro
         try {
-            var t = this
-            if (t.sync != null)
+            if (t.sync != null) {
+                pro = { dat_array: props.items }
                 return t.sync.await(props)
-            if (t.status != null)
-                return t.status.await(props)
+            }
+            if (t.status != null) {
+                pro = { dat_array: props.status }
+                return t.status.await(pro)
+            }
+            if (t.version != null) {
+                pro = { dat_array: props.version }
+                return t.version.await(pro)
+            }
         } catch (e) {
             e.message = "queueObj app.js load error: " + e.message
             console.log(e.message)

package/lib/appenders/base.js

@@ -9,12 +9,11 @@ var colors = require('colors')
 exports = module.exports = class base {
     constructor(props) {
         let t = this
-        t.props_array = []
+        t.await_array = []
         t.resolve_array = []
         t.reject_array = []
-        t.status_props_array = []
-        t.process_item = -1
-        t.process_array_item = -1
+        t.process_objs_item = 0
+        t.process_props_item = 0
         t.any_errors = false
         t.getParent = props.getParent
         t.dt_start = null
@@ -24,9 +23,10 @@ exports = module.exports = class base {
         t.process_all = t.process_all.bind(this)
     }
 
+
     await(props) {
         let t = this
-        t.props_array.push(props)
+        t.await_array.push(props)
         return new Promise((resolve, reject) => {
             t.resolve_array.push(resolve)
             t.reject_array.push(reject)
@@ -35,16 +35,16 @@ exports = module.exports = class base {
 
     process() {
         let t = this
-        t.process_item = 0
-        t.process_array_item = 0
+        t.process_objs_item = 0
+        t.process_props_item = 0
+        t.await_item = 0
         t.dt_start = new Date(); // start measuring time
-        // t.props_array = []
+        // t.await_array = []
         // t.resolve_array = []
         // t.reject_array = []
         // t.status_props_array = []
 
         return new Promise((resolve, reject) => {
-            t.props_array.push({ the: 'end' })
             t.resolve_array.push(resolve)
             t.reject_array.push(reject)
             t.process_all()
@@ -60,94 +60,105 @@ exports = module.exports = class base {
     }
 
     process_all() {
-        let t = this, obj, xItems = null, pro, itm, msg
-        t.props_array.map((props, i) => {
-            if (i == t.process_item) {
-                if (typeof props != 'undefined' && typeof props.the != 'undefined' && props.the == 'end') {
-                    if (t.any_errors)
-                        t.reject_array[i](`there were errors`)
-                    else {
-                        t.dt_end = new Date();
-                        t.resolve_array[i](t.getStats())
-                    }
+        let t = this, obj, pro, itm, msg, itm_type, props_type, datA
+        try {
+            try {
+                if (t.process_objs_item >= t.getParent().getObjs().length) {
+                    t.await_item++
+                    t.resolve_array[t.resolve_array.length - 1](t.getStats())
                     return
                 }
+            } catch (e) {
+                return
+            }
+            try {
+                datA = t.await_array[t.await_item].dat_array
+            } catch (e) {
+                return
+            }
+            try {
 
-                if (typeof props != 'undefined') {
-                    if (typeof props.items != 'undefined') {
-                        xItems = props.items
-                        itm = 'items'
-                    }
-                    if (typeof props.byIds != 'undefined') {
-                        xItems = props.byIds
-                        itm = 'byIds'
-                    }
-                    if (typeof props.status != 'undefined') {
-                        xItems = []
-                        if (t.status_props_array.length == 0) {
-                            t.getParent().getObjs().map((aItem, i) => {
-                                xItems.push(i)
-                            })
-                        }
-                        itm = 'status'
-                    }
-                }
-
-                if (xItems != null) {
-                    xItems.map((pItem, x) => {
-                        if (x == t.process_array_item) {
-                            try {
-                                switch (itm) {
-                                    case 'status':
-                                    case 'items':
-                                        obj = t.getParent().getItemToProcess(pItem)
-                                        break
-                                    case 'byIds':
-                                        obj = t.getParent().getObjectById(pItem);
-                                        break
-                                }
-                            } catch (e) {
-                                console.log(`base error: (${e.message})`.red)
-                            }
-                            pro = (typeof obj == 'function') ? obj : obj.process;
-                            if (itm == 'status') {
-                                if (typeof pro != 'undefined' &&
-                                    typeof obj.status != 'undefined' &&
-                                    props.status.indexOf(obj.status) > -1) {
-                                    //do nothing
-                                } else {
-                                    t.process_array_item++
-                                    if (t.process_array_item < xItems.length)
-                                        t.process_all()
-                                    return
-                                }
+                datA.map((dat_item, i) => {
+                    if (i == t.process_props_item) {
+                        if (t.process_props_item < datA.length) {
+                            if ((t.await_item) >= t.await_array.length) {
+                                t.resolve_array[t.resolve_array.length - 1](t.getStats())
+                                return
                             }
+                            t.getParent().getObjs().map((pItem, x) => {
+                                if (x == t.process_objs_item) {
+                                    try {
+                                        obj = t.getParent().getItemToProcess(x)
+                                    } catch (e) {
+                                        e.message = `base error: (${e.message})`
+                                        throw e
+                                    }
+                                    if (typeof obj != 'undefined' && typeof obj.getType != 'function') {
+                                        obj.getType = (o) => { return t.aname }
+                                    }
+                                    if (obj.getType(obj) == dat_item) {
+                                        try {
+                                            pro = (typeof obj == 'function') ? obj : obj.process;
+                                        } catch (e) {
+                                            console.log(`pro error: (${e.message})`.red)
+                                            throw e
+                                        }
 
-                            pro((obj_props) => {
-                                if (typeof obj_props != 'undefined' &&
-                                    typeof obj_props.error != 'undefined' &&
-                                    typeof obj_props.error.msg != 'undefined' &&
-                                    typeof obj_props.error.msg == 'string') {
-                                    msg = `error: ${obj_props.error.msg}`
-                                    msg += (typeof obj.id != 'undefined') ? ` id(${obj.id})` : ``;
-                                    t.any_errors = true
-                                    t.reject_array[t.process_item](msg)
-                                }
-                                t.process_array_item++
-                                if (t.process_array_item < xItems.length)
-                                    t.process_all()
-                                else {
-                                    t.dt_end = new Date();
-                                    t.resolve_array[t.process_item](t.getStats())
-                                    t.process_item++
-                                    t.process_array_item = 0
+                                        pro((obj_props) => {
+                                            try {
+
+                                                if (typeof obj_props != 'undefined' &&
+                                                    typeof obj_props.error != 'undefined' &&
+                                                    typeof obj_props.error.msg != 'undefined' &&
+                                                    typeof obj_props.error.msg == 'string') {
+                                                    msg = `error: ${obj_props.error.msg}`
+                                                    msg += (typeof obj.id != 'undefined') ? ` id(${obj.id})` : ``;
+                                                    t.any_errors = true
+                                                    t.reject_array[t.process_props_item](msg)
+                                                }
+                                                t.process_objs_item++
+                                                if (t.process_props_item < datA.length) {
+                                                    t.process_all()
+                                                } else {
+                                                    t.dt_end = new Date();
+                                                    t.resolve_array[t.process_props_item - 1](t.getStats())
+                                                    t.process_props_item = 0
+                                                    t.process_objs_item = 0
+                                                }
+                                            } catch (e) {
+                                                console.log(`proessing error: (${e.message})`.red)
+                                                throw e
+                                            }
+                                        })
+                                    } else {
+                                        t.process_objs_item++
+                                        if (t.process_objs_item >= t.getParent().getObjs().length) {
+                                            t.resolve_array[t.resolve_array.length - 1](t.getStats())
+                                        }
+                                    }
+                                } else {
+                                    if (t.process_objs_item >= t.getParent().getObjs().length) {
+                                        t.process_objs_item = 0
+                                        t.process_props_item++
+                                        if (t.process_props_item >= datA.length) {
+                                            t.await_item++
+                                            t.process_props_item = 0
+                                            if (t.await_item <= t.await_array.length)
+                                                t.process_all()
+                                        }
+                                    }
                                 }
                             })
                         }
-                    })
-                }
+                    }
+                })
+            } catch (e) {
+                e.message = `await error: ${e.message}`
+                throw e
             }
-        })
+        } catch (e) {
+            console.log(`process_all error: ${e.message}`.red)
+        }
     }
 }
 

package/lib/appenders/version.js

@@ -0,0 +1,17 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2021-03-22
+* lib/appenders/status.js
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class version extends base {
+    constructor(props) {
+        super(props)
+        var t = this
+        t.aname = 'version'
+		t.pro_types = ['version']
+        return t
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "author": {
     "name": "Jim Manton"
   },
-  "version": "7.2.4",
+  "version": "8.0.0",
   "bundleDependencies": false,
   "dependencies": {
     "chai": "^4.3.3",

package/test/package.js

@@ -6,7 +6,7 @@ const packageMock = {
   "author": {
     "name": "Jim Manton"
   },
-  "version": "7.2.4",
+  "version": "8.0.0",
   "bundleDependencies": false,
   "dependencies": {
     "chai": "^4.3.3",

package/test_bottom_one.js

@@ -23,24 +23,10 @@ class test3 {
     }
 }
 
-let qObj = new queue(), props = { appender: 'bottom_one' }
+let qObj = new queue(), props = { appender: 'bottom_one', stats: true}
 
-qObj.load(props).add(new test1()).add(new test2()).add(new test3())
-
-qObj.process().then(res => {
-    console.log(`done with 3rd obj`.green)
-})
-
-qObj.process().then(res => {
-    console.log(`done with 2nd obj`.green)
-})
-
-qObj.process().then(res => {
-    console.log(`done with 1st obj`.green)
-})
-
-qObj.process().then(res => {
-    console.log(`done with 1st obj`.green)
+qObj.load(props).add(new test1()).add(new test2(qObj)).add(new test3()).process({}).then(res => {
+  console.log(res)
 }, err => {
-    console.log(err.red)   
+  console.log(`errors with bottom item processing: (${err})`.red)
 })

package/test_func_all.js

@@ -41,6 +41,6 @@ let tst1 = new test1(),
     tst3 = new test3(qObj, tst4)
 
 qObj.load(props).add(tst1.some_function).add(tst2.a_func).add(tst3.cool).process().then(res => {
-    console.log(`done`)
+    console.log(`success processing`.green)
 })
 

package/test_status.js

@@ -36,9 +36,9 @@ class test2 {
         let t = this, msg = `some kinda problem here`
         console.log(`processing test2`.cyan)
         t.status = "error"
-        callback({error: {msg: msg}})  //this will show errors
-        //t.status = "done"
-        //callback()  //this will show no errors
+        // callback({error: {msg: msg}})  //this will show errors
+        t.status = "done"
+        callback()  //this will show no errors
     }
 
     ping() {
@@ -56,12 +56,10 @@ class test3 {
     }
 
     process(callback) {
-        setTimeout(()=>{
-            console.log(`processing test3`.cyan)
-            console.log(`some async process`)
-            this.status = "done"
-            callback()
-        }, 2000)
+        console.log(`processing test3`.cyan)
+        console.log(`some async process`)
+        this.status = "done"
+        callback()
     }
 }
 
@@ -70,10 +68,13 @@ class test4 {
         let t = this
         t.id = 400
         t.status = "new"
+
+        t.process = t.process.bind(t)
     }
 
     process(callback) {
         console.log(`processing test4`.cyan)
+        this.status = "done"
         callback()
     }
 }

package/test_sync_all.js

@@ -69,7 +69,7 @@ let qObj = new queue(), props = { appender: 'sync_all' }
 qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(tst4.custom_function)
 
 qObj.process().then(res => {
-    console.log(`done with all sync processing: (${res})`.bold.italic.white)
+    console.log(`done with all sync processing: (${res})`.bold.italic.blue)
 }, err => {
     console.log(`errors with all sync processing: (${err})`.red)
 })

package/test_top_one.js

@@ -23,14 +23,10 @@ class test3 {
   }
 }
 
-let qObj = new queue(), props = { appender: 'top_one'}
+let qObj = new queue(), props = { appender: 'top_one', stats: true}
 
-qObj.load(props).add(new test1()).add(new test2()).add(new test3())
-
-qObj.process().then(res => {
-  console.log(`done with 1st obj`.green)
-})
-
-qObj.process().then(res => {
-  console.log(`done with 2nd obj`.green)
+qObj.load(props).add(new test1()).add(new test2(qObj)).add(new test3()).process({}).then(res => {
+  console.log(res)
+}, err => {
+  console.log(`errors with top item processing: (${err})`.red)
 })

package/test_version.js

@@ -0,0 +1,122 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2021-03-22
+* test_status.js
+*/
+
+var colors = require('colors')
+var queue = require("./app.js");
+
+class test1 {
+    constructor() {
+        let t = this
+        t.id = 100
+        t.version = "dev"
+
+        t.process = t.process.bind(t)
+    }
+
+    process(callback) {
+        let t = this
+        console.log(`processing test1 version(${t.version})`.cyan)
+        this.status = "done"
+        callback()
+    }
+}
+
+class test2 {
+    constructor() {
+        let t = this
+        t.id = 200
+        t.version = "dev"
+
+        t.process = t.process.bind(t)
+    }
+
+    process(callback) {
+        let t = this, msg = `some kinda error is detected here`
+        console.log(`processing test2 version(${t.version})`.cyan)
+        // callback({error: {msg: msg}})  //this will show errors
+        callback()  //this will have no errors
+    }
+
+    ping() {
+        console.log('hello from test2'.rainbow)
+    }
+}
+
+class test3 {
+    constructor() {
+        let t = this
+        t.id = 300
+        t.version = "test"
+
+        t.process = t.process.bind(t)
+    }
+
+    process(callback) {
+        let t = this
+        console.log(`processing test3 version(${t.version})`.cyan)
+        console.log(`some async process`)
+        callback()
+    }
+}
+
+class test4 {
+    constructor() {
+        let t = this
+        t.id = 400
+        t.version = "prod"
+
+        t.process = t.process.bind(t)
+    }
+
+    process(callback) {
+        let t = this
+        console.log(`processing test4 version(${t.version})`.cyan)
+        callback()
+    }
+}
+
+class test5 {
+    constructor() {
+        let t = this
+        t.id = 500
+        t.version = "v1234"
+
+        t.process = t.process.bind(t)
+    }
+
+    process(callback) {
+        let t = this
+        console.log(`processing test5 version(${t.version})`.cyan)
+        callback()
+    }
+}
+let qObj = new queue(), props = { appender: 'version' }
+
+qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(new test4()).add(new test5())
+
+qObj.await({ version: ['dev', 'test'] }).then(res => {
+    console.log(`1) done with version['dev', 'test']: (${res})`.green)
+}, err => {
+    console.log(`1) error['dev', 'test']: (${err})`.red)
+})
+
+qObj.await({ version: ['prod'] }).then(res => {
+    console.log(`2) done with version['prod']: (${res})`.green)
+}, err => {
+    console.log(`2) error['prod']: (${err})`.red)
+})
+
+qObj.await({ version: ['v1234'] }).then(res => {
+    console.log(`3) done with version['v1234']: (${res})`.green)
+}, err => {
+    console.log(`3) error['v1234']: (${err})`.red)
+})
+
+qObj.process().then(res => {
+    console.log(`4) done with version synchronous processing: (${res})`.bold.italic.blue)
+}, err => {
+    console.log(`4) errors with version synchronous processing: (${err})`.red)
+})

package/test_sync.js

@@ -1,121 +0,0 @@
-/*
-* @author Jim Manton: jrman@risebroadband.net
-* @since 2021-03-22
-* test_sync.js
-*/
-
-var colors = require('colors')
-var queue = require("./app.js");
-
-class test1 {
-    constructor() {
-        this.id = 100
-    }
-
-    process(callback) {
-        console.log(`processing test1`.cyan)
-        callback()
-    }
-}
-
-class test2 {
-    constructor() {
-        this.id = 200
-    }
-
-    process(callback) {
-        let msg = `some kinda problem here`
-        console.log(`processing test2`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
-    }
-
-    ping() {
-        console.log('hello from test2'.rainbow)
-    }
-}
-
-class test3 {
-    constructor() {
-        this.id = 300
-    }
-
-    process(callback) {
-        setTimeout(()=>{
-            console.log(`processing test3`.cyan)
-            console.log(`some async process`)
-            callback()
-        }, 2000)
-    }
-}
-
-class test4 {
-    constructor() {
-        let t = this
-        t.id = 400
-        t.custom_function = t.custom_function.bind(this)
-    }
-
-    custom_function(callback) {
-        let msg = `custom func problem here id(${this.id})`
-        console.log(`processing test4`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
-    }
-}
-let tst4 = new test4()
-let qObj = new queue(), props = { appender: 'sync', stats: false }
-
-qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(tst4.custom_function)
-
-qObj.await({ items: [0, 1] }).then(res => {
-    console.log(`1) done with items[0,1]: (${res})`.green)
-}, err => {
-    console.log(`1) error[0, 1]: (${err})`.red)
-})
-
-qObj.await({ items: [1, 2] }).then(res => {
-    console.log(`2) done with items[1,2]: (${res})`.green)
-}, err => {
-    console.log(`2) error[1,2]: (${err})`.red)
-})
-
-qObj.await({ items: [2, 1, 2] }).then(res => {
-    console.log(`3) done with items[2,1,2]: (${res})`.green)
-}, err => {
-    console.log(`3) error[2, 1, 2]: (${err})`.red)
-})
-
-qObj.await({ items: [2, 3] }).then(res => {
-    console.log(`4) done with item[2, 3]: (${res})`.green)
-}, err => {
-    console.log(`4) error[2, 3]: (${err})`.red)
-})
-
-qObj.await({ items: [0] }).then(res => {
-    console.log(`5) done with item[0]: (${res})`.green)
-}, err => {
-    console.log(err.red)
-})
-
-qObj.getObjectById(200).ping()
-
-qObj.await({ byIds: [300, 200, 100] }).then(res => {
-    console.log(`6) done with byId: [300, 200, 100] (${res})`.bold.italic.underline.yellow)
-}, err => {
-    console.log(`6) error[300, 200, 100]: (${err})`.red)
-})
-
-qObj.await({ byIds: [100, 300] }).then(res => {
-    console.log(`7) done with byId: [100, 300] (${res})`.bold.italic.underline.yellow)
-}, err => {
-    console.log(`7) error[100, 300]: (${err})`.red)
-})
-
-qObj.process().then(res => {
-    console.log(`8) done with all sync processing: (${res})`.bold.italic.white)
-}, err => {
-    console.log(`8) errors with all sync processing: (${err})`.red)
-})
-
-