@catchpower/device-config-interaction 0.0.13

package/fesm2022/catchpower-device-config-interaction.mjs

@@ -0,0 +1,1018 @@
+import * as i0 from '@angular/core';
+import { Injectable, NgModule } from '@angular/core';
+import * as axios from 'axios';
+import * as i2 from '@angular/forms';
+import { Validators, UntypedFormGroup, UntypedFormControl } from '@angular/forms';
+
+class CpDevicesListService {
+    //constructor() {}
+    async getDevicesList(_url, auth, listVersion = '-1') {
+        //console.log('getDevicesList function TRIGGERED ', _url);
+        const headers = {
+            Authorization: 'Basic ' + btoa(auth),
+            'list-version': listVersion,
+        };
+        const response = await axios.default
+            .request({
+            method: 'get',
+            url: _url,
+            headers: headers,
+        })
+            .then((res) => {
+            if (res.status == 200) {
+                //console.log( 'get DL function SUCCESS ', JSON.stringify(res));
+                return res.data;
+            }
+            else {
+                return new Error('ERROR getting Devices List. ' + JSON.stringify(res));
+            }
+        }, (error) => {
+            return new Error('ERROR getting Devices List. ' + JSON.stringify(error));
+        });
+        return response;
+    }
+    getValueFromObj(element, name) {
+        let value = null;
+        let notInOther = true;
+        element.otherData.forEach((other) => {
+            if (other.name == name) {
+                value = other.value;
+                notInOther = false;
+            }
+        });
+        if (notInOther) {
+            element.rawData.forEach((raw) => {
+                if (raw.name == name) {
+                    value = raw.value;
+                }
+            });
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class DatasetProcessingService {
+    //constructor() {}
+    /*
+     * For use with DataView
+     *
+     */
+    getValuefromBuffer(obj, buffer) {
+        let value = 0;
+        if (obj.signed) {
+            switch (obj.length) {
+                case 8:
+                    value = buffer.getInt8(obj.position);
+                    break;
+                case 16:
+                    value = buffer.getInt16(obj.position, obj.little);
+                    break;
+                case 32:
+                    value = buffer.getInt32(obj.position, obj.little);
+                    break;
+            }
+        }
+        else {
+            switch (obj.length) {
+                case 8:
+                    value = buffer.getUint8(obj.position);
+                    break;
+                case 16:
+                    value = buffer.getUint16(obj.position, obj.little);
+                    break;
+                case 32:
+                    value = buffer.getUint32(obj.position, obj.little);
+                    break;
+            }
+        }
+        return value;
+    }
+    /*
+     * For use with DataView
+     *
+     *
+     */
+    writeValueToBuffer(obj, value, buffer) {
+        if (obj.signed) {
+            switch (obj.length) {
+                case 8:
+                    buffer.setInt8(obj.position, value);
+                    break;
+                case 16:
+                    buffer.setInt16(obj.position, value, obj.little);
+                    break;
+                case 32:
+                    buffer.setInt32(obj.position, value, obj.little);
+                    break;
+            }
+        }
+        else {
+            switch (obj.length) {
+                case 8:
+                    buffer.setUint8(obj.position, value);
+                    break;
+                case 16:
+                    buffer.setUint16(obj.position, value, obj.little);
+                    break;
+                case 32:
+                    buffer.setUint32(obj.position, value, obj.little);
+                    break;
+            }
+        }
+    }
+    runProcess(process, rawData, otherData) {
+        const values = this.getChunkValues(process.data, rawData, otherData);
+        //console.log('process values ', values);
+        let pVal = 0;
+        switch (process.type) {
+            case 'ass':
+                pVal = this.assembleProcess(values);
+                process.value = pVal;
+                return;
+            case 'com':
+                pVal = this.compareProcess(values, process);
+                process.value = pVal;
+                return;
+            case 'cal':
+                pVal = this.calculateProcess(values);
+                process.value = pVal;
+                return;
+            case 'tfm':
+                pVal = this.tfmProcess(values);
+                process.value = pVal;
+                return;
+            case 'cdt':
+                pVal = this.cdtProcess(values);
+                process.value = pVal;
+                return;
+            case 'itd':
+                pVal = this.itdProcess(values);
+                process.value = pVal;
+                return;
+            case 'its':
+                pVal = this.itsProcess(values);
+                process.value = pVal;
+                return;
+            case 'bsv':
+                pVal = this.bsvProcess(values);
+                process.value = pVal;
+                return;
+            case 'vfa':
+                pVal = this.vfaProcess(values, process);
+                process.value = pVal;
+                return;
+            case 'cts':
+                pVal = this.ctsProcess(values);
+                process.value = pVal;
+                return;
+        }
+    }
+    assembleProcess(values) {
+        let result = '';
+        values.forEach((v) => {
+            result += v;
+        });
+        return result;
+    }
+    disassembleProcess(string, values) {
+        const result = {};
+        let i = 0;
+        let length = 0;
+        values.forEach((val) => {
+            if (Object.prototype.hasOwnProperty.call(val, 'strLength')) {
+                length = val.strLength;
+            }
+            else {
+                const str = val.value;
+                length = str.length;
+            }
+            if (val.fromData == 'raw') {
+                result[val.value] = Number(string.substring(i, i + length));
+            }
+            i = i + length;
+        });
+        //console.log('Disassemble Result ', JSON.stringify(result));
+        return result;
+    }
+    compareProcess(values, process) {
+        const result = this.compareValues(values[0], values[1], values[2]);
+        let text = 'N/A';
+        if ('comTxt' in process) {
+            if (process.comTxt !== undefined) {
+                if (result) {
+                    text = process.comTxt[0];
+                }
+                else {
+                    return process.comTxt[1];
+                }
+            }
+        }
+        return text;
+    }
+    compareValues(v1, op, v2) {
+        switch (op) {
+            case '<':
+                return v1 < v2;
+            case '<=':
+                return v1 <= v2;
+            case '==':
+                return v1 == v2;
+            case '>=':
+                return v1 >= v2;
+            case '>':
+                return v1 > v2;
+            default:
+                return false;
+        }
+    }
+    calculateProcess(values) {
+        return this.calculateValues(values[0], values[1], values[2]);
+    }
+    calculateValues(v1, op, v2) {
+        switch (op) {
+            case '+':
+                return v1 + v2;
+            case '-':
+                return v1 - v2;
+            case '/':
+                return v1 / v2;
+            case '*':
+                return v1 * v2;
+            default:
+                return 0;
+        }
+    }
+    tfmProcess(values) {
+        const hours = Math.floor((values[0] * 60) / 3600);
+        const mins = Math.floor((values[0] * 60 - hours * 3600) / 60);
+        return this.displayTime(hours, mins);
+    }
+    cdtProcess(values) {
+        const hours = parseInt(values[0].substring(11, 13));
+        const mins = parseInt(values[0].substring(14, 16));
+        return this.displayTime(hours, mins);
+    }
+    //New process to pick value from array based on interger value
+    vfaProcess(values, process) {
+        const value = values[0];
+        if (process.valuesList !== undefined) {
+            if (value < process.valuesList.length) {
+                return process.valuesList[value];
+            }
+            else {
+                return 'nip';
+            }
+        }
+        else {
+            return 'n/a';
+        }
+    }
+    itdProcess(values) {
+        let hours = Math.floor((values[0] * 60) / 3600);
+        //console.log("hours ", hours);
+        const mins = Math.floor((values[0] * 60 - hours * 3600) / 60);
+        //console.log("mins ", mins);
+        let h;
+        let m;
+        if (hours > 23) {
+            hours = hours - 24;
+        }
+        if (hours < 10) {
+            h = '0' + hours;
+        }
+        else {
+            h = hours;
+        }
+        if (mins < 10) {
+            m = '0' + mins;
+        }
+        else {
+            m = mins;
+        }
+        const string = '0000-00-00T' + h + ':' + m;
+        //console.log("$%^&&^%%$$%^&&&^%%%%^^^&&&^^%^%%%^^^& dt string ", string);
+        return string;
+    }
+    dtiProcess(string, values) {
+        //console.log("dtiProcess inputs string: ", string, " Values: ", values);
+        const result = {};
+        let h;
+        let m;
+        values.forEach((val) => {
+            // h = Number(string.substr(11, 2));
+            // m = Number(string.substr(14, 2));
+            h = Number(string.substring(11, 13));
+            m = Number(string.substring(14, 16));
+            result[val.value] = h * 60 + m;
+        });
+        //console.log("date to integer Result ", JSON.stringify(result));
+        return result;
+    }
+    itsProcess(values) {
+        //console.log('itsProcess values', JSON.stringify(values));
+        const str = values[0].toString();
+        return str;
+    }
+    stiProcess(string, values) {
+        const result = {};
+        values.forEach((val) => {
+            result[val.value] = Number(string);
+        });
+        //console.log("string to integer Result ", JSON.stringify(result));
+        return result;
+    }
+    bsvProcess(values) {
+        const startValue = values[0];
+        const pos1 = values[1];
+        const pos2 = pos1 + 1;
+        const binaryStr = parseInt(startValue, 10)
+            .toString(2)
+            .padStart(4, '0');
+        return binaryStr.substring(pos1, pos2);
+    }
+    bsvRevert(string, values, bssObj) {
+        if (Object.prototype.hasOwnProperty.call(bssObj, values[0].value)) {
+            bssObj[values[0].value] = this.replaceCharAt(bssObj[values[0].value], values[1].value, string);
+        }
+        else {
+            bssObj[values[0].value] = '0000';
+            bssObj[values[0].value] = this.replaceCharAt(bssObj[values[0].value], values[1].value, string);
+        }
+        return bssObj;
+    }
+    stcProcess(value) {
+        const initArray = value.split('');
+        const resultArray = [];
+        initArray.forEach((v) => {
+            resultArray.push(v.charCodeAt(0));
+        });
+        return resultArray;
+    }
+    ctsProcess(values) {
+        // let result: string = "";
+        const ary = [];
+        values.forEach((v) => {
+            if (v >= 0) {
+                ary.push(v);
+            }
+            else {
+                ary.push(0);
+            }
+        });
+        //console.log("CTS PROCESS INPUT VALUES ", values);
+        let str = String.fromCharCode(...ary);
+        // eslint-disable-next-line no-control-regex
+        str = str.replace(/[\u0000]/g, '');
+        //str = str.replace(/[^\x20-\x7E]/g, "");
+        return str;
+    }
+    ctsRevert(otherObj, results) {
+        const valAry = this.stcProcess(otherObj.value);
+        //console.log("VAL ARRAY", valAry);
+        //console.log("PROCESS DATA", JSON.stringify(otherObj.processData));
+        let progress = 0;
+        otherObj.processData[0].data.forEach((process) => {
+            const res = {};
+            if (valAry.length >= progress) {
+                res[process.value] = valAry[progress];
+            }
+            else {
+                res[process.value] = 0;
+            }
+            results = Object.assign(results, res);
+            ++progress;
+        });
+        return results;
+    }
+    binaryStrToDecimal(str) {
+        return parseInt(str, 2);
+    }
+    replaceCharAt(string, index, char) {
+        return (string.substring(0, index) + char + string.substring(index + char.length));
+        //return string.substr(0, index) + char + string.substr(index + char.length);
+    }
+    writeFormValuesToRawObj(formValues, rawObj) {
+        // rawObj.forEach((raw) => {
+        //   if (formValues.hasOwnProperty(raw.name)) {
+        //     raw.value = Math.round(formValues[raw.name] / raw.multi);
+        //   }
+        // });
+        for (let i = 0; i < rawObj.length; i++) {
+            if (Object.prototype.hasOwnProperty.call(formValues, rawObj[i].name)) {
+                rawObj[i].value = Math.round(formValues[rawObj[i].name] / rawObj[i].multi);
+            }
+        }
+        return rawObj;
+    }
+    getPwd(rawValues) {
+        const pwdArray = [];
+        let i;
+        let name;
+        for (i = 0; i < 16; i++) {
+            if (i < 10) {
+                name = 'pass_0' + i;
+            }
+            else {
+                name = 'pass_' + i;
+            }
+            rawValues.forEach((v) => {
+                if (v.name == name) {
+                    pwdArray.push(v.value);
+                }
+            });
+        }
+        return pwdArray;
+    }
+    strToPwd(string) {
+        const pwdArray = [];
+        let i;
+        if (string == null) {
+            string = '';
+        }
+        for (i = 0; i < 16; i++) {
+            if (i < string.length) {
+                pwdArray.push(string.charCodeAt(i));
+            }
+            else {
+                pwdArray.push(0);
+            }
+        }
+        return pwdArray;
+    }
+    chkPwd(arr1, arr2) {
+        if (!Array.isArray(arr1) ||
+            !Array.isArray(arr2) ||
+            arr1.length !== arr2.length)
+            return false;
+        for (let i = 0; i < arr1.length; i++) {
+            if (arr1[i] !== arr2[i])
+                return false;
+        }
+        return true;
+    }
+    writePwdToConfig(passArray, rawObj) {
+        let i;
+        let name;
+        //console.log("Before write password ", JSON.stringify(rawObj));
+        for (i = 0; i < 16; i++) {
+            if (i < 10) {
+                name = 'pass_0' + i;
+            }
+            else {
+                name = 'pass_' + i;
+            }
+            rawObj.forEach((v) => {
+                if (v.name == name) {
+                    v.value = passArray[i];
+                }
+            });
+        }
+        //console.log("After write password ", JSON.stringify(rawObj));
+        return rawObj;
+    }
+    displayTime(hours, mins) {
+        //console.log("hours = ", hours, " mins = ", mins);
+        let m = mins;
+        let p = 'am';
+        if (mins < 10) {
+            m = '0' + mins;
+        }
+        if (hours > 11) {
+            p = 'pm';
+        }
+        if (hours == 0) {
+            hours = 12;
+        }
+        if (hours > 12) {
+            hours -= 12;
+        }
+        return hours + ':' + m + ' ' + p;
+    }
+    getChunkValues(processData, rawData, otherData) {
+        // console.log(
+        //   'GET CHUNK VALUES ',
+        //   JSON.stringify(rawData),
+        //   ' ',
+        //   JSON.stringify(otherData)
+        // );
+        let v;
+        const values = [];
+        processData.forEach((chunk) => {
+            //console.log('Process Raw chunk ', JSON.stringify(chunk));
+            switch (chunk.fromData) {
+                case 'raw':
+                    rawData.forEach((rd) => {
+                        if (rd.name == chunk.value) {
+                            //console.log('RAW chunk name: ', rd.name);
+                            v = rd.value;
+                        }
+                    });
+                    break;
+                case 'other':
+                    otherData.forEach((od) => {
+                        if (od.name == chunk.value) {
+                            v = od.value;
+                        }
+                    });
+                    break;
+                case 'no':
+                    v = chunk.value;
+                    break;
+            }
+            if (typeof chunk.strLength === 'undefined') {
+                values.push(v);
+            }
+            else {
+                const pad = v.toString().padStart(chunk.strLength, '0');
+                values.push(pad);
+            }
+        });
+        return values;
+    }
+    uint8ArrayToArray(uint8) {
+        return Array.from(uint8);
+    }
+    arrayToUint8Array(array) {
+        return Uint8Array.from(array);
+    }
+    isUint8Array(v) {
+        const isStr = Object.prototype.toString;
+        return isStr.call(v) === '[object Uint8Array]';
+    }
+    processRaw(input, configObj) {
+        let buffer;
+        if (this.isUint8Array(input)) {
+            buffer = input;
+        }
+        else {
+            buffer = this.arrayToUint8Array(input);
+        }
+        const rawDataBuffer = new DataView(buffer.buffer, 0, 254);
+        //console.log('PROCESS RAW CONFIG ', rawDataBuffer);
+        configObj.rawData.forEach((datapoint) => {
+            datapoint.value =
+                this.getValuefromBuffer(datapoint.buffer, rawDataBuffer) *
+                    datapoint.multi;
+        });
+    }
+    processOther(configObj) {
+        configObj.otherData.forEach((dataPoint) => {
+            dataPoint.processData.forEach((process) => {
+                this.runProcess(process, configObj.rawData, configObj.otherData);
+                dataPoint.value = process.value;
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CrcCheckService {
+    constructor() {
+        // checksum arrays
+        this.auchCRCHi = [
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+            0x00, 0xc1, 0x81, 0x40,
+        ];
+        this.auchCRCLo = [
+            0x00, 0xc0, 0xc1, 0x01, 0xc3, 0x03, 0x02, 0xc2, 0xc6, 0x06, 0x07, 0xc7,
+            0x05, 0xc5, 0xc4, 0x04, 0xcc, 0x0c, 0x0d, 0xcd, 0x0f, 0xcf, 0xce, 0x0e,
+            0x0a, 0xca, 0xcb, 0x0b, 0xc9, 0x09, 0x08, 0xc8, 0xd8, 0x18, 0x19, 0xd9,
+            0x1b, 0xdb, 0xda, 0x1a, 0x1e, 0xde, 0xdf, 0x1f, 0xdd, 0x1d, 0x1c, 0xdc,
+            0x14, 0xd4, 0xd5, 0x15, 0xd7, 0x17, 0x16, 0xd6, 0xd2, 0x12, 0x13, 0xd3,
+            0x11, 0xd1, 0xd0, 0x10, 0xf0, 0x30, 0x31, 0xf1, 0x33, 0xf3, 0xf2, 0x32,
+            0x36, 0xf6, 0xf7, 0x37, 0xf5, 0x35, 0x34, 0xf4, 0x3c, 0xfc, 0xfd, 0x3d,
+            0xff, 0x3f, 0x3e, 0xfe, 0xfa, 0x3a, 0x3b, 0xfb, 0x39, 0xf9, 0xf8, 0x38,
+            0x28, 0xe8, 0xe9, 0x29, 0xeb, 0x2b, 0x2a, 0xea, 0xee, 0x2e, 0x2f, 0xef,
+            0x2d, 0xed, 0xec, 0x2c, 0xe4, 0x24, 0x25, 0xe5, 0x27, 0xe7, 0xe6, 0x26,
+            0x22, 0xe2, 0xe3, 0x23, 0xe1, 0x21, 0x20, 0xe0, 0xa0, 0x60, 0x61, 0xa1,
+            0x63, 0xa3, 0xa2, 0x62, 0x66, 0xa6, 0xa7, 0x67, 0xa5, 0x65, 0x64, 0xa4,
+            0x6c, 0xac, 0xad, 0x6d, 0xaf, 0x6f, 0x6e, 0xae, 0xaa, 0x6a, 0x6b, 0xab,
+            0x69, 0xa9, 0xa8, 0x68, 0x78, 0xb8, 0xb9, 0x79, 0xbb, 0x7b, 0x7a, 0xba,
+            0xbe, 0x7e, 0x7f, 0xbf, 0x7d, 0xbd, 0xbc, 0x7c, 0xb4, 0x74, 0x75, 0xb5,
+            0x77, 0xb7, 0xb6, 0x76, 0x72, 0xb2, 0xb3, 0x73, 0xb1, 0x71, 0x70, 0xb0,
+            0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
+            0x55, 0x95, 0x94, 0x54, 0x9c, 0x5c, 0x5d, 0x9d, 0x5f, 0x9f, 0x9e, 0x5e,
+            0x5a, 0x9a, 0x9b, 0x5b, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
+            0x4b, 0x8b, 0x8a, 0x4a, 0x4e, 0x8e, 0x8f, 0x4f, 0x8d, 0x4d, 0x4c, 0x8c,
+            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
+            0x41, 0x81, 0x80, 0x40,
+        ];
+    }
+    //constructor() {}
+    _buildCRC(puchMsg, usDataLen, startIndex = 0) {
+        console.log('Start of CRC check generation.');
+        let uchCRCHi = 0xff; /* high byte of CRC initialized */
+        let uchCRCLo = 0xff; /* low byte of CRC initialized */
+        let uIndex; /* will index into CRC lookup table */
+        let bufferIndex = startIndex;
+        while (usDataLen--) {
+            uIndex = uchCRCLo ^ puchMsg[bufferIndex]; /* calculate the CRC */
+            bufferIndex++;
+            uchCRCLo = uchCRCHi ^ this.auchCRCHi[uIndex];
+            uchCRCHi = this.auchCRCLo[uIndex];
+        }
+        return [uchCRCHi, uchCRCLo];
+    }
+    /**
+     *
+     * @param sentValuePair
+     * @param receivedValuePair
+     * @returns
+     */
+    saveCheck(sentValuePair, receivedValuePair) {
+        console.log('CRC save check sent ', sentValuePair, ' recieved ', receivedValuePair);
+        if (sentValuePair[0] === receivedValuePair[0] &&
+            sentValuePair[1] === receivedValuePair[1]) {
+            console.log('CRC compare check TRUE');
+            return true;
+        }
+        else {
+            console.log('CRC compare check FALSE');
+            return false;
+        }
+    }
+    async writeCrcToCommand(commandData) {
+        console.log('WRITE CRC TO COMMAND TRIGGERED ');
+        const checkSum = this._buildCRC(commandData.byteData, commandData.byteData.length - 2);
+        console.log('###### #######    CRC16 values ', checkSum);
+        commandData.byteData[253] = checkSum[0];
+        commandData.byteData[254] = checkSum[1];
+        return commandData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CrcCheckService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CrcCheckService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CrcCheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CommandService {
+    constructor(dps, crcService) {
+        this.dps = dps;
+        this.crcService = crcService;
+    }
+    /**
+     *  For Bluetooth command send
+     * @param currentDevice
+     * @param command
+     * @param rawDataObj
+     * @returns
+     */
+    async createCommandData(currentDevice, command, rawDataObj) {
+        let opCode = 0;
+        const comandBuffer = new ArrayBuffer(currentDevice.write.bufferSize);
+        currentDevice.commands.forEach((commandObj) => {
+            //console.log('Command Name', commandObj.name);
+            if (command == commandObj.name) {
+                opCode = parseInt(commandObj.opCode);
+            }
+        });
+        //console.log('###########      $$$$$$$$$$$$     Op Code ', opCode);
+        if (rawDataObj !== undefined) {
+            //console.log('create Command Data, Raw Data Object is present.');
+            const dataView = new DataView(comandBuffer);
+            rawDataObj.forEach((raw) => {
+                this.dps.writeValueToBuffer(raw.buffer, raw.value, dataView);
+            });
+        }
+        let commandData = {
+            opCode: opCode,
+            service: currentDevice.write.service,
+            characteristic: currentDevice.write.characteristic,
+            byteData: new Uint8Array(comandBuffer),
+        };
+        commandData.byteData[0] = commandData.opCode;
+        commandData = await this.crcService.writeCrcToCommand(commandData);
+        return commandData;
+    }
+    async createCommandDataForApi(currentDevice, command, rawDataObj) {
+        let raw = undefined;
+        if (rawDataObj !== undefined) {
+            raw = rawDataObj;
+        }
+        const commandBt = this.createCommandData(currentDevice, command, raw);
+        const send = {
+            serialNumber: currentDevice.serial.toString(),
+            data: this.dps.uint8ArrayToArray((await commandBt).byteData),
+        };
+        //console.log(JSON.stringify(send));
+        return send;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommandService, deps: [{ token: DatasetProcessingService }, { token: CrcCheckService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommandService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommandService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: DatasetProcessingService }, { type: CrcCheckService }]; } });
+
+class DeviceConfigDatasetService {
+    constructor(dps, formBuilder) {
+        this.dps = dps;
+        this.formBuilder = formBuilder;
+    }
+    processConfig(buffer, config) {
+        this.dps.processRaw(buffer, config);
+        this.dps.processOther(config);
+        this.processForm(config);
+        return config;
+    }
+    processForm(config) {
+        //console.log("Starting to process form data");
+        config.formData.forEach((formSection) => {
+            formSection.dataObjs.forEach((formControl) => {
+                config.rawData.forEach((dp) => {
+                    if (formControl.dataId == dp.name) {
+                        formControl.value = dp.value;
+                    }
+                });
+                config.otherData.forEach((dp) => {
+                    if (formControl.dataId == dp.name) {
+                        formControl.value = dp.value;
+                    }
+                });
+            });
+        });
+    }
+    processResultsToFormData(formResults, config) {
+        for (let i = 0; i < config.formData.length; i++) {
+            for (let x = 0; x < config.formData[i].dataObjs.length; x++) {
+                if (Object.prototype.hasOwnProperty.call(formResults, config.formData[i].dataObjs[x].dataId)) {
+                    config.formData[i].dataObjs[x].value =
+                        formResults[config.formData[i].dataObjs[x].dataId];
+                }
+                if (Object.prototype.hasOwnProperty.call(config.formData[i].dataObjs[x], 'autoInput')) {
+                    if (config.formData[i].dataObjs[x].autoInput == true) {
+                        //console.log("auto date condition met");
+                        config.formData[i].dataObjs[x].value = this.currentDateTimeStr();
+                    }
+                }
+            }
+        }
+        //console.log("formdata object updated", JSON.stringify(config.formData));
+        return config;
+    }
+    currentDateTimeStr() {
+        const date = new Date();
+        const str = date.getFullYear() +
+            '-' +
+            (date.getMonth() + 1).toString().padStart(2, '0') +
+            '-' +
+            date.getDate().toString().padStart(2, '0') +
+            'T' +
+            date.getHours().toString().padStart(2, '0') +
+            ':' +
+            date.getMinutes().toString().padStart(2, '0');
+        return str;
+    }
+    extractBackToRaw(config) {
+        const otherToProcess = {};
+        let valuesToRaw = {};
+        let bss = {};
+        if (Object.prototype.hasOwnProperty.call(config, 'formData')) {
+            for (let i = 0; i < config.formData.length; i++) {
+                for (let x = 0; x < config.formData[i].dataObjs.length; x++) {
+                    let isRawData = false;
+                    for (let z = 0; z < config.rawData.length; z++) {
+                        if (config.rawData[z].name == config.formData[i].dataObjs[x].dataId) {
+                            valuesToRaw[config.formData[i].dataObjs[x].dataId] =
+                                config.formData[i].dataObjs[x].value;
+                            isRawData = true;
+                        }
+                    }
+                    if (isRawData == false) {
+                        otherToProcess[config.formData[i].dataObjs[x].dataId] =
+                            config.formData[i].dataObjs[x].value;
+                    }
+                }
+            }
+        }
+        else {
+            config.otherData.forEach((otherObj) => {
+                otherToProcess[otherObj.name] = otherObj.value;
+            });
+        }
+        //console.log('Other to Process ', JSON.stringify(otherToProcess));
+        config.otherData.forEach((otherObj) => {
+            const value = otherToProcess[otherObj.name];
+            // console.log(
+            //   'EXTRACT BACK TO RAW ',
+            //   ' ',
+            //   otherObj.name,
+            //   ' ',
+            //   JSON.stringify(value)
+            // );
+            otherObj.processData.forEach((pdo) => {
+                switch (pdo.type) {
+                    case 'ass':
+                        valuesToRaw = Object.assign(valuesToRaw, this.dps.disassembleProcess(value, pdo.data));
+                        return;
+                    case 'itd':
+                        valuesToRaw = Object.assign(valuesToRaw, this.dps.dtiProcess(value, pdo.data));
+                        return;
+                    case 'its':
+                        valuesToRaw = Object.assign(valuesToRaw, this.dps.stiProcess(value, pdo.data));
+                        return;
+                    case 'bsv':
+                        bss = this.dps.bsvRevert(value, pdo.data, bss);
+                        return;
+                }
+            });
+        });
+        if (Object.keys(bss).length > 0) {
+            for (const str in bss) {
+                valuesToRaw[str] = this.dps.binaryStrToDecimal(bss[str]);
+            }
+        }
+        config.rawData = this.dps.writeFormValuesToRawObj(valuesToRaw, config.rawData);
+        //console.log("rawData Obj ", JSON.stringify(config.rawData));
+        return config;
+    }
+    generateValidationRules(formField) {
+        const validators = [];
+        if (formField.required == true) {
+            validators.push(Validators.required);
+        }
+        if (Object.prototype.hasOwnProperty.call(formField, 'min')) {
+            if (formField.min !== undefined)
+                validators.push(Validators.min(formField.min));
+        }
+        if (Object.prototype.hasOwnProperty.call(formField, 'max')) {
+            if (formField.max !== undefined)
+                validators.push(Validators.max(formField.max));
+        }
+        if (Object.prototype.hasOwnProperty.call(formField, 'minLength')) {
+            if (formField.minLength !== undefined)
+                validators.push(Validators.minLength(formField.minLength));
+        }
+        if (Object.prototype.hasOwnProperty.call(formField, 'maxLength')) {
+            if (formField.maxLength !== undefined)
+                validators.push(Validators.maxLength(formField.maxLength));
+        }
+        if (Object.prototype.hasOwnProperty.call(formField, 'rex')) {
+            if (formField.rex !== undefined)
+                validators.push(Validators.pattern(formField.rex));
+        }
+        return validators;
+    }
+    generateFormGroup(config, blackList) {
+        //console.log('Generate form group TRIGGERED');
+        const configForm = new UntypedFormGroup({});
+        for (let i = 0; i < config.formData.length; i++) {
+            //console.log("FORM SECTION ", JSON.stringify(config.formData[i]));
+            for (let x = 0; x < config.formData[i].dataObjs.length; x++) {
+                if (!blackList.includes(config.formData[i].title)) {
+                    let fieldDisable = false;
+                    const validators = this.generateValidationRules(config.formData[i].dataObjs[x]);
+                    if (!config.formData[i].dataObjs[x].active) {
+                        fieldDisable = true;
+                    }
+                    //console.log('ADD CONTROL');
+                    configForm.addControl(config.formData[i].dataObjs[x].dataId, new UntypedFormControl({
+                        value: config.formData[i].dataObjs[x].value,
+                        disabled: fieldDisable,
+                    }, validators));
+                }
+            }
+        }
+        //console.log('END OF GENERATE FORMGROUP');
+        return configForm;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceConfigDatasetService, deps: [{ token: DatasetProcessingService }, { token: i2.UntypedFormBuilder }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceConfigDatasetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceConfigDatasetService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: DatasetProcessingService }, { type: i2.UntypedFormBuilder }]; } });
+
+class DeviceLiveDatasetService {
+    constructor(dps) {
+        this.dps = dps;
+    }
+    processDisplay(buffer, display) {
+        this.dps.processRaw(buffer, display);
+        this.dps.processOther(display);
+        this.processLayout(display);
+        return display;
+    }
+    processLayout(display) {
+        display.layout.forEach((section) => {
+            section.rows.forEach((row) => {
+                row.cols.forEach((col) => {
+                    let wv = '';
+                    if (typeof col.refData !== 'undefined') {
+                        display.rawData.forEach((raw) => {
+                            if (raw.name == col.refData) {
+                                if (typeof col.round !== 'undefined') {
+                                    wv = raw.value.toFixed(col.round);
+                                }
+                                else {
+                                    wv = raw.value;
+                                }
+                            }
+                        });
+                        display.otherData.forEach((other) => {
+                            if (other.name == col.refData) {
+                                wv = other.value;
+                            }
+                        });
+                        if (typeof col.prepend !== 'undefined') {
+                            wv = col.prepend + wv;
+                        }
+                        if (typeof col.append !== 'undefined') {
+                            wv = wv + col.append;
+                        }
+                        col.value = wv;
+                    }
+                });
+            });
+        });
+    }
+    async rssiData(device, rssiSignal) {
+        const result = { deviceName: 'N/A', rssi: 'N/A' };
+        if (device != null) {
+            result.deviceName = device.name;
+            const rssi = await rssiSignal();
+            if (rssi <= 0) {
+                result.rssi = rssi.toString() + ' dBa';
+            }
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceLiveDatasetService, deps: [{ token: DatasetProcessingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceLiveDatasetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeviceLiveDatasetService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: DatasetProcessingService }]; } });
+
+class CpDevicesListModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CpDevicesListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    exports: [],
+                }]
+        }] });
+
+/*
+ * Public API Surface of device-config-interaction
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CommandService, CpDevicesListModule, CpDevicesListService, CrcCheckService, DatasetProcessingService, DeviceConfigDatasetService, DeviceLiveDatasetService };
+//# sourceMappingURL=catchpower-device-config-interaction.mjs.map