file-obj-queue 1.0.24 → 2.0.1

package/app.js

@@ -3,128 +3,63 @@
 * Main processing app
 */
 
-let colors = require('node-console-colors'),
-    fs = require('fs'),
-    validPath = require('valid-path')
-
-class file_obj {
-    constructor(props) {
-        let t = this
-        t.id = props.id
-        t.log = props.log
-        t.name = props.name
-        t.path = props.path
-        t.absolute_path = props.absolute_path
-        t.status = 'init'
-        t.errors = false
-        t.error_msg = 'none'
-
-        t.process = t.process.bind(t)
-        t.do_checks = t.do_checks.bind(t)
-
-        if (props.check) {
-            t.do_checks()
-        }
-
-        return t
-    }
-
-    do_checks() {
-        let t = this, path_to_check,
-            last_item = t.absolute_path.split("\\").pop(),
-            check_file = t.absolute_path.split(last_item)[0], check_path = t.path.split('/')
-
-        check_file = check_file.replace(/\\/g, "/");
-        path_to_check = validPath(t.path);
-
-        if (!path_to_check.valid) {
-            t.errors = true
-            t.error_msg = `id = ${t.id} name(${t.name}) Error in ${path_to_check.data.input}: ${path_to_check.error})`
-        }
-
-        check_path.map((dat, i) => {
-            if (/^[a-zA-Z._]+$/.test(dat)) {
-                if (dat != '.')
-                    check_file += dat + '/'
-            }
-        })
-        check_file = check_file.slice(0, -1)
-        try {
-            if (!fs.existsSync(check_file)) {
-                t.errors = true
-                t.error_msg = `id = ${t.id} name(${t.name}) file (${check_file} does not exist)`
-            }
-        } catch (e) {
-            e.message = "file_obj do_checks error: " + e.message
-            throw (e)
-        }
-    }
-
-    process(callback) {
-        let t = this
-        if (t.errors)
-            callback({ error: { msg: t.error_msg } })
-        else
-            callback({ success: { msg: `id = ${t.id} name(${t.name})` } })
-    }
-}
+let colors = require('colors'),
+    base_queue = require("./base_queue/app")
+
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red',
+    success: 'green'
+});
 
 exports = module.exports = class FilesQueue {
     constructor() {
         try {
             var t = this
+            t.app_resolve = null
+            t.app_reject = null
+            t.successMsg = ''
+
             t.logMsg = t.logMsg.bind(t)
-            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
             t.getFileObject = t.getFileObject.bind(t)
-            t.json_queue = require("./local_queuejson/app")
-            t.qJson = null
 
-            t.logMsg(`FilesQueue.constructor`)
+            t.logMsg(`FilesQueue.constructor`.debug)
 
             return t
         } catch (e) {
-            e.message = "FilesQueue app.js constructor error: " + e.message
+            e.message = `FilesQueue app.js constructor error: ${e.message}`.error
             throw (e)
         }
     }
 
-    init(props = {}) {
+    process(props = {}) {
         let t = this
-        try {
-            if (t.qJson == null) {
-                if (typeof props.input_data == 'undefined')
-                    throw new Error('props.input_data is not defined')
-                try {
-                    t.logMsg(`jrm debug 1/29 8800`)
-                    t.qJson = new t.json_queue({
-                        class_obj: file_obj,
-                        appender: 'all',
-                        stats: true,
-                        debug: true,
-                        parent: t
-                    })
-                    t.logMsg(`jrm debug 1/29 8801`)
-                } catch (e) {
-                    e.message = "queuejson error: " + e.message
-                    t.logMsg(e.message)
-                    throw (e)
-                }
-                try {
-                    t.qJson.init({ input_data: props.input_data })
-                    t.qJson.process()
-                } catch (e) {
-                    e.message = "queuejson.init error: " + e.message
-                    t.logMsg(e.message)
-                    throw (e)
-                }
 
-            }
-            return t
-        } catch (e) {
-            e.message = "FilesQueue app.js init error: " + e.message
-            t.logMsg(e.message)
-            throw (e)
-        }
+        return new Promise((resolve, reject) => {
+            t.app_resolve = resolve
+            t.app_reject = reject
+
+            if (typeof props.data_to_process_array == 'undefined')
+                t.app_reject('base_queue no props.data_to_process_array')
+
+            if (typeof props.appender == 'undefined')
+                t.app_reject('base_queue no props.appender')
+
+            if (typeof props.process_objects == 'undefined')
+                t.app_reject(`props.process_objects not defined`)
+
+            props.parent = t
+            t.base_queue = new base_queue().load(props).process()
+        })
     }
 
     getFileObject() {

package/base_queue/app.js

@@ -0,0 +1,146 @@
+
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-02
+* apps.js
+*/
+
+let cc = require("colors"),
+    file_requre_data = [
+        { props: { id: 100, name: "all", path: "./lib/appenders/all.js", absolute_path: __filename, check: true } }
+    ]
+
+cc.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red'
+});
+
+
+class process_object {
+    constructor(props) {
+        let t = this
+        t.parent = props.parent
+        t.status = 'process'
+        t.objs = t.parent.getParent().getObjs()
+    }
+
+    process() {
+        let t = this
+    }
+
+    continueProcessing() {
+        let t = this
+    }
+
+    getStatus() {
+        return this.status
+    }
+
+    setStatus(v) {
+        this.status = v
+    }
+}
+
+exports = module.exports = class BaseQueue {
+    constructor(props = {}) {
+        let t = this, fname = `BaseQueue app constructor`
+        try {
+            t.parent = null
+            t.appenders_dir = './appenders/'
+            t.appender = null
+
+            t.logMsg = t.logMsg.bind(t)
+            t.init = t.init.bind(t)
+            t.load = t.load.bind(t)
+            t.process = t.process.bind(t)
+            t.set_base_promise = t.set_base_promise.bind(t)
+            t.base_promise = null
+            t.base_resolve = null
+            t.base_reject = null
+
+            t.set_base_promise()
+
+            return t
+        } catch (e) {
+            t.logMsg(`${fname}: ${e.message}`.error)
+        }
+    }
+
+    set_base_promise() {
+        let t = this, fname = `BaseQueue set_base_promise`
+
+        t.base_promise = new Promise((resolve, reject) => {
+            t.base_resolve = resolve
+            t.base_reject = reject
+        })
+
+        t.base_promise.then(function (success) {
+            t.parent.app_resolve(success)
+        }).catch(function (err) {
+            t.parent.app_reject(err)
+        })
+
+    }
+
+    init(props = {}) {
+        let t = this, fname = `BaseQueue init`
+    }
+
+    load(props = {}) {
+        let t = this, fname = `BaseQueue load`, a, app, req
+
+        if (typeof props.parent == 'undefined')
+            t.base_reject(`${fname}: props.parent not defined`)
+
+        t.parent = props.parent
+        props.parent = t
+        app = props.appender
+        a = t.appenders_dir + app + '.js'
+        req = require(a)
+        t.parent.logMsg(`${fname} loading appender(${a})`.debug)
+        t.appender = new req(props)
+        return t
+    }
+
+    process() {
+        let t = this, fname = `BaseQueue process`, res, error_count = 0
+        try {
+            t.logMsg(`${fname}`.debug)
+
+            res = t.appender.init().process().get_results_array()
+            res.map((json, i) => {
+                if (typeof json.success != "undefined")
+                    t.logMsg(`${JSON.stringify(json)}`.success)
+                if (typeof json.error != "undefined") {
+                    t.logMsg(`${JSON.stringify(json)}`.error)
+                    error_count++
+                }
+            })
+            if (error_count) {
+                res.error_count = error_count
+                t.base_reject(res)
+            } else
+                t.base_resolve(res)
+        } catch (e) {
+            t.base_reject(`${fname}: ${e.message}.`)
+        }
+    }
+
+    logMsg(msg, props = {}) {
+        let t = this
+        try {
+            console.log(msg)
+            return t
+        } catch (e) {
+            t.base_reject(`BaseQueue log: ${e.message} for message (${msg})`)
+        }
+    }
+}

package/base_queue/appenders/base.js

@@ -0,0 +1,77 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-03
+* base.js
+*/
+
+exports = module.exports = class base {
+    constructor(props) {
+        let t = this, fname = `base appenders constructor`
+        try {
+            t.parent = props.parent
+            t.parent.logMsg(`${fname}`.debug)
+            t.class_obj_array = []
+            t.data_to_process_array = []
+            t.objects_to_process = []
+            t.results_array = []
+            t.base_name_appender = ''
+
+            if (typeof props.data_to_process_array == 'undefined')
+                throw new Error(`props.data_to_process_array not defined`)
+
+            if (typeof props.process_objects == 'undefined')
+                throw new Error(`props.process_objects not defined`)
+
+            if (typeof props.appender == 'undefined')
+                throw new Error(`appender not defined)`)
+
+            t.base_name_appender = props.appender
+            t.data_to_process_array = props.data_to_process_array
+            t.objects_to_process = props.process_objects
+
+            t.init = t.init.bind(t)
+            t.get_objects_to_process = t.get_objects_to_process.bind(t)
+            t.get_data_to_process_array = t.get_data_to_process_array.bind(t)
+            t.process = t.process.bind(t)
+            t.get_results_array = t.get_results_array.bind(t)
+
+            return t
+        } catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+        }
+    }
+	
+	process (props = {}) {
+		var t = this, fname = `base.process`
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+    get_results_array () {
+        return this.results_array
+    }
+
+    get_data_to_process_array () {
+        return this.data_to_process_array
+    }
+
+    get_objects_to_process () {
+        return this.objects_to_process
+    }
+    
+	init (props = {}) {
+		var t = this, fname = `base.init`
+		try {
+
+			t.parent.logMsg(`${fname}`.debug)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/base_queue/appenders/json_all.js

@@ -0,0 +1,70 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2022-12-11
+* all.ts
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class json_all extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'json_all.constructor'
+		try {
+			t.aname = 'json_all'
+			t.main_process_objects = []
+			
+            if (t.base_name_appender != t.aname)
+                throw new Error(`(${t.base_name_appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg(`${fname}`.debug)
+			
+            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init (props = {}) {
+		var t = this, fname = `json_all.init`, gotp, gdtpa, obj
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			t.get_data_to_process_array().map((dat, i)=>{
+				dat.props.log = t.parent.logMsg
+				obj = t.get_objects_to_process()[0]
+				t.main_process_objects.push(new obj(dat.props))
+			})
+
+			super.init(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+	
+	process (props = {}) {
+		var t = this, fname = `json_all.process`
+		try {
+			t.parent.logMsg(`${fname} length(${t.main_process_objects.length})`.debug)
+
+			t.main_process_objects.map((obj, i)=>{
+				obj.process((res)=>{
+					// t.parent.logMsg(`${fname}${JSON.stringify(res)})`.debug)
+					t.results_array.push(res)
+				})
+			})
+
+			super.process(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/package.json

@@ -2,14 +2,14 @@
   "author": {
     "name": "Jim Manton"
   },
-  "version": "1.0.24",
+  "version": "2.0.1",
   "bundleDependencies": [],
   "dependencies": {
     "chai": "^4.3.7",
+    "colors": "^1.4.0",
     "diffler": "^2.0.4",
     "fs": "^0.0.1-security",
     "mocha": "^10.2.0",
-    "node-console-colors": "^1.1.4",
     "queuejson": "^9.0.11",
     "valid-path": "^2.1.0"
   },

package/test/app.js

@@ -7,10 +7,6 @@ describe('app', function () {
         application = require('../app.js')
         assert(app = new application())
     })
-
-    it('app.init is a function', function () {
-        assert(typeof app.init == 'function')
-    })
     
     it('app.logMsg is a function', function () {
         assert(typeof app.logMsg == 'function')
@@ -23,12 +19,12 @@ describe('app', function () {
 
 describe('require', function () {
 
-    it('node-console-colors', function () {
-        assert(require('node-console-colors'))
+    it('colors', function () {
+        assert(require('colors'))
     })
 
-    it('queuejson', function () {
-        assert(require('queuejson'))
+    it('base_queue', function () {
+        assert(require('../base_queue/app'))
     })
 
     it('fs', function () {

package/test/package.js

@@ -6,14 +6,14 @@ const packageMock = {
   "author": {
     "name": "Jim Manton"
   },
-  "version": "1.0.24",
+  "version": "2.0.1",
   "bundleDependencies": [],
   "dependencies": {
     "chai": "^4.3.7",
+    "colors": "^1.4.0",
     "diffler": "^2.0.4",
     "fs": "^0.0.1-security",
     "mocha": "^10.2.0",
-    "node-console-colors": "^1.1.4",
     "queuejson": "^9.0.11",
     "valid-path": "^2.1.0"
   },

package/tests/appenders/base.js

@@ -4,9 +4,9 @@
 * lib/appenders/base.js
 */
 
-var colors = require('node-console-colors')
+var colors = require('colors')
 
-class process_all_obj {
+class process_object {
     constructor(props) {
         let t = this
         t.parent = props.parent
@@ -82,7 +82,7 @@ class process_all_obj {
                 throw e
             }
         } catch (e) {
-            e.message = `process_all_obj error: ${e.message} `
+            e.message = `process_object error: ${e.message} `
             throw e
         }
     }
@@ -113,7 +113,7 @@ exports = module.exports = class base {
         t.getParent = props.getParent
         t.dt_start = null
         t.dt_end = null
-        t.process_all_obj = null
+        t.process_object = null
         t.pro_props = []
 
         t.process = t.process.bind(this)
@@ -155,15 +155,15 @@ exports = module.exports = class base {
 
     process_all = () => {
         let t = this, _continue
-        if (t.process_all_obj == null) {
-            t.process_all_obj = new process_all_obj({ parent: t })
+        if (t.process_object == null) {
+            t.process_object = new process_object({ parent: t })
         }
 
         _continue = false
         try {
-            switch (t.process_all_obj.getStatus()) {
+            switch (t.process_object.getStatus()) {
                 case 'process':
-                    t.process_all_obj.process()
+                    t.process_object.process()
                     _continue = true
                     break
                 case 'finish with errors':
@@ -175,7 +175,7 @@ exports = module.exports = class base {
                 case 'wait':
                     return
                 default:
-                    throw new Error(`status(${t.process_all_obj.getStatus()}) does not exist`)
+                    throw new Error(`status(${t.process_object.getStatus()}) does not exist`)
             }
 
             if (_continue)

package/tests/files.js

@@ -1,5 +1,7 @@
-var colors = require('node-console-colors'),
-    file_queue = require("../app.js")
+var colors = require('colors'),
+    file_queue = require("../app.js"),
+    fs = require('fs'),
+    validPath = require('valid-path')
 
 var file_data = [
     { props: { id: 100, name: "all", path: "./appenders/all.js", absolute_path: __filename, check: true } },
@@ -12,9 +14,77 @@ var file_data = [
     { props: { id: 107, name: "version", path: "./appenders/version.js", absolute_path: __filename, check: true } }
 ]
 
-console.log(`jrm debug 1/29 2200`)
-var qRequire = new file_queue().init({ input_data: file_data })  
-console.log(`jrm debug 1/29 2201`)
 
-console.log(`test complete`)
+var file_object = class file_obj {
+    constructor(props) {
+        let t = this
+        t.id = props.id
+        t.log = props.log
+        t.name = props.name
+        t.path = props.path
+        t.absolute_path = props.absolute_path
+        t.status = 'init'
+        t.errors = false
+        t.error_msg = 'none'
+
+        t.process = t.process.bind(t)
+        t.do_checks = t.do_checks.bind(t)
+
+        if (props.check) {
+            t.do_checks()
+        }
+
+        return t
+    }
+
+    do_checks() {
+        let t = this, path_to_check,
+            last_item = t.absolute_path.split("\\").pop(),
+            check_file = t.absolute_path.split(last_item)[0], check_path = t.path.split('/')
+
+        check_file = check_file.replace(/\\/g, "/");
+        path_to_check = validPath(t.path);
+
+        if (!path_to_check.valid) {
+            t.errors = true
+            t.error_msg = `id = ${t.id} name(${t.name}) Error in ${path_to_check.data.input}: ${path_to_check.error})`
+        }
+
+        check_path.map((dat, i) => {
+            if (/^[a-zA-Z._]+$/.test(dat)) {
+                if (dat != '.')
+                    check_file += dat + '/'
+            }
+        })
+        check_file = check_file.slice(0, -1)
+        try {
+            if (!fs.existsSync(check_file)) {
+                t.errors = true
+                t.error_msg = `id = ${t.id} name(${t.name}) file (${check_file} does not exist)`
+            }
+        } catch (e) {
+            e.message = "file_obj do_checks error: " + e.message
+            throw (e)
+        }
+    }
+
+    process(callback) {
+        let t = this
+        if (t.errors)
+            callback({ error: { msg: t.error_msg } })
+        else
+            callback({ success: { msg: `id = ${t.id} name(${t.name})` } })
+    }
+}
+
+var qRequire = new file_queue()
+
+qRequire.process({ appender: "json_all", 
+                    process_objects: [file_object], 
+                    data_to_process_array: file_data }).then((success)=>{
+    qRequire.logMsg(`test success: all file objects processed with no errors`.success)
+},(error)=>{
+    let add_s = (error.error_count > 1) ? 's' : ''
+    qRequire.logMsg(`${error.error_count} error${add_s} detected`.error)
+})
 

package/local_queuejson/app.js

@@ -1,236 +0,0 @@
-
-/*
-* @author Jim Manton: jrman@risebroadband.net
-* @since 2022-12-11
-* apps.js
-*/
-
-let cc = require("node-console-colors"),
-    all = require("./lib/appenders/all"),
-    file_requre_data = [
-        { props: { id: 100, name: "all", path: "./lib/appenders/all.js", absolute_path: __filename, check: true } }
-    ]
-
-exports = module.exports = class QueueJson {
-    constructor(props) {
-        let t = this, fname = `app constructor`
-        try {
-            console.log(`${fname} 4000`, { "type": "debug" });
-            t.class_obj_array = [];
-            t.appenders = [{ name: 'all', obj: null }]
-
-            t.props = props
-            t.props.getParent = t.getParent
-
-            if (typeof t.props != 'undefined' && typeof t.props.debug != 'undefined') {
-                t.debug = t.props.debug
-            } else {
-                throw new Error(`props is not defined`)
-            }
-
-            t.file_obj_queue = t.props.parent  //jrm debug 1/30
-            // t.file_obj_queue = new file_queue().init({ input_data: file_requre_data })  //jrm debug 1/29
-            console.log(`jrm debug 1/31 getFileObj 1202 (${typeof t.file_obj_queue})`)
-
-            t.init = t.init.bind(t)
-            t.process = t.process.bind(t)
-            t.getParent = t.getParent.bind(t)
-            t.logMsg = t.logMsg.bind(t)
-
-            t.logMsg(`${fname} 4001`, { "type": "debug" });
-
-            return t
-        } catch (e) {
-            t.logMsg(`${fname}: ${e}`, { "type": "error" })
-        }
-    }
-
-    getParent = () => {
-        return this
-    }
-
-    get_class_obj_array = () => {
-        return this.class_obj_array
-    }
-
-    init = (props) => {
-        let t = this, fname = `app init`, add = false, co, file_obj, obj
-        try {
-            t.logMsg(`${fname} appender(${t.props.appender})`, { "type": "debug" })
-            // t.file_obj_queue = new file_queue().init({ input_data: file_requre_data })  //jrm debug 1/31
-            t.logMsg(`${fname} jrm debug 1/31 SHOULD BE HERE`, { "type": "debug" })
-            t.all = new all(t.props)
-            return t
-
-
-            // add = true
-
-            // file_obj = t.file_obj_queue.getFileObject()
-            // if (typeof t.props != `undefined`) {
-            //     if (typeof t.props.appender != `undefined` &&
-            //         typeof t.props.appender == 'string') {
-            //         t.props.getParent = t.getParent
-            //         file_obj.map((jsObj, i) => {
-            //             if (jsObj.name == t.props.appender) {
-            //                 obj = require(jsObj.path)
-            //                 eval(`t.${jsObj.name} = new obj(t.props)`)
-            //             }
-            //         })
-            //     }
-            //     return t
-            // }
-            // return t
-
-            // process.exit(22);
-
-            try {
-                try {
-                    if (typeof props.input_data != 'undefined') {
-                        props.input_data.map((dat, i) => {
-                            add = false
-                            switch (t.props.appender) {
-                                case 'top_one':
-                                    if (i == 0)
-                                        add = true
-                                    break
-                                case 'bottom_one':
-                                    if (i == (props.input_data.length - 1))
-                                        add = true
-                                    break
-                                case 'status':
-                                case 'by_status':
-                                    try {
-                                        if (props.matching.indexOf(dat.props.status) > -1)
-                                            add = true
-                                    } catch { }
-                                    try {
-                                        if (props.non_matching.indexOf(dat.props.status) == -1)
-                                            add = true
-                                    } catch { }
-                                    break
-                                case 'name':
-                                case 'by_name':
-                                    try {
-                                        if (props.matching.indexOf(dat.props.name) > -1)
-                                            add = true
-                                    } catch { }
-                                    try {
-                                        if (props.non_matching.indexOf(dat.props.name) == -1)
-                                            add = true
-                                    } catch { }
-                                    break
-                                case 'version':
-                                    try {
-                                        if (props.matching.indexOf(dat.props.version) > -1)
-                                            add = true
-                                    } catch { }
-                                    try {
-                                        if (props.non_matching.indexOf(dat.props.version) == -1)
-                                            add = true
-                                    } catch { }
-                                    break
-
-                                default:
-                                    add = true
-                            }
-                            if (add) {
-                                co = new t.props.class_obj(dat.props)
-                                if (typeof dat.props.function_name == 'string') {
-                                    co._getFuncName = () => {
-                                        return dat.props.function_name
-                                    }
-                                }
-                                t.class_obj_array.push(co)
-                            }
-                        })
-                    } else
-                        throw new Error('no input data array defined.')
-                } catch (e) {
-                    throw e
-                }
-
-            } catch (e) {
-                throw `new class_obj: ${e}`
-            }
-
-            file_obj = t.file_obj_queue.getFileObject()
-            if (typeof t.props != `undefined`) {
-                if (typeof t.props.appender != `undefined` &&
-                    typeof t.props.appender == 'string') {
-                    t.props.getParent = t.getParent
-                    file_obj.map((jsObj, i) => {
-                        if (jsObj.name == t.props.appender) {
-                            obj = require(jsObj.path)
-                            eval(`t.${jsObj.name} = new obj(t.props)`)
-                        }
-                    })
-                }
-                return t
-            }
-            return t
-        } catch (e) {
-            t.logMsg(`${fname}: ${e}`, { "type": "error" })
-        }
-    }
-
-    logMsg = (msg, props = {}) => {
-        let t = this
-        try {
-            let t = this, tp
-            if (typeof props != 'undefined' && typeof props.type != 'undefined') {
-                switch (props.type) {
-                    case 'debug':
-                        if (!t.debug)
-                            return
-                        tp = "bg_dark_gray"
-                        break
-                    case 'error':
-                        tp = "fg_red"
-                        break
-                    case 'purple':
-                        tp = "bg_purple"
-                        break
-                    case 'success':
-                        tp = "fg_green"
-                        break
-                    case 'white':
-                        tp = "bg_white"
-                        break
-                    default:
-                        tp = 'bg_dark_gray'
-                }
-                console.log(cc.set(tp, msg))
-                return t
-            }
-            throw new Error('No props.type included')
-        } catch (e) {
-            console.log(`app log: ${e.message} for message (${msg})`)
-        }
-    }
-
-    process = () => {
-        let t = this, fname = `local_queuejson app process`
-        try {
-            return t.all.process()
-        } catch (e) {
-            t.logMsg(`${fname}: ${e.message}.`, { "type": "error" })
-        }
-
-
-        // let t = this, fname = `app process`, file_obj, jsObj, i
-        // let pro = { 'dat_array': [''] }
-        // try {
-        //     file_obj = t.file_obj_queue.getFileObject()
-        //     for (i = 0; i < file_obj.length; i++) {
-        //         jsObj = file_obj[i]
-        //         if (jsObj.name == t.props.appender) {
-        //             pro.dat_array.push(`${jsObj.name}`)
-        //             return eval(`t.${jsObj.name}.process()`)
-        //         }
-        //     }
-        //     throw new Error('no appender found to process')
-        // } catch (e) {
-        //     t.logMsg(`${fname}: ${e}`, { "type": "error" })
-        // }
-    }
-}

package/local_queuejson/lib/appenders/all.js

@@ -1,22 +0,0 @@
-/*
-* @author Jim Manton: jrman@risebroadband.net
-* @since 2022-12-11
-* all.ts
-*/
-
-var base = require('./base.js')
-
-exports = module.exports = class all extends base {
-	constructor(props) {
-		super(props)
-		var t = this
-		try {
-			t.aname = 'all'
-			t.parent.logMsg(`all constructor`, {"type": "debug"})
-			return t
-		} catch (e) {
-			t.parent.logMsg(e, {"type": "error"})
-		}
-
-	}
-}

package/local_queuejson/lib/appenders/base.js

@@ -1,80 +0,0 @@
-/*
-* @author Jim Manton: jrman@risebroadband.net
-* @since 2022-12-11
-* base.js
-*/
-
-var qObj = require("queueobj");
-
-exports = module.exports = class base {
-    constructor(props) {
-        let t = this, fname = `base constructor`
-        try {
-            t.parent = props.getParent()
-            t.resolve_array = []
-            t.reject_array = []
-
-            t.qObj = new qObj()
-            t.qObj.load({ appender: props.appender, stats: props.stats, log: t.parent.logMsg })
-
-            t.process = t.process.bind(t)
-            t.process_all = t.process_all.bind(t)
-            return t
-        } catch (e) {
-            t.parent.logMsg(`${fname}: ${e}`, { "type": "error" })
-            throw e
-        }
-    }
-
-    process = (props) => {
-        let t = this, fname = `base process`
-        try {
-            t.dt_start = new Date(); // start measuring time
-
-            t.parent.logMsg(fname, { "type": "debug" })
-            return new Promise((resolve, reject) => {
-                t.resolve_array.push(resolve)
-                t.reject_array.push(reject)
-                t.process_all()
-            });
-        } catch (e) {
-            t.parent.logMsg(`${fname}: ${e}`, { "type": "error" })
-        }
-    }
-
-    process_all = () => {
-        let t = this, fname = `base process_all`, coa
-        try {
-            t.parent.logMsg(fname, { "type": "debug" })
-
-            coa = t.parent.get_class_obj_array()
-
-            if (coa.length == 0) {
-                t.reject_array[0]({ error: 'no matching data to process' })
-            }
-
-            coa.map((dat, i) => {
-                dat.log = t.log
-                if (typeof t.qObj == 'undefined')
-                    throw new Error(`qObj does not exist`)
-
-                if (typeof dat._getFuncName == 'function') {
-                    t.parent.logMsg(`${fname}: function name(${dat._getFuncName()})`, { "type": "debug" })
-
-                    t.qObj.add(eval(`dat.${dat._getFuncName()}`))
-                } else {
-                    t.qObj.add(dat)
-                }
-            })
-
-            t.qObj.process({}).then((res) => {
-                t.resolve_array[0]({ res })
-            }, (err) => {
-                t.reject_array[0]({ err })
-            })
-        } catch (e) {
-            t.parent.logMsg(`${fname}: ${e}`, { "type": "error" })
-            throw e
-        }
-    }
-}