initial, start porting Python MeterbusLib to node

src/index.ts

@@ -0,0 +1 @@
+export {MeterbusLib} from './meterbus'

src/meterbus.test.ts

@@ -0,0 +1,44 @@
+import {MeterbusLib} from './meterbus'
+
+import * as mocha from 'mocha'
+import * as chai from 'chai'
+
+const expect = chai.expect
+
+describe('The Meterbus Library', () => {
+    it('should store hexString', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("01 02 03")
+        expect(telegram.hexString).to.equal("01 02 03")
+    })
+    it('should parse the hexString into the telegram array', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("01 02 03")
+        expect(telegram.telegram).to.deep.equal([1, 2, 3])        
+    })
+    it('should detect a control frame', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("68 03")
+        telegram.parse()
+        expect(telegram.frame).instanceof(MeterbusLib.ControlFrame)
+    })
+    it('should detect a short frame', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("10")
+        telegram.parse()
+        expect(telegram.frame).instanceof(MeterbusLib.ShortFrame)
+    })
+    it('should detect a long frame', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("68 10")
+        telegram.parse()
+        expect(telegram.frame).instanceof(MeterbusLib.LongFrame)
+    })
+    it('should detect a single char frame', () => {
+        const telegram = new MeterbusLib.Telegram()
+        telegram.fromHexString("e5")
+        telegram.parse()
+        expect(telegram.frame).instanceof(MeterbusLib.SingleCharFrame)
+    })
+
+})

src/meterbus.ts

@@ -0,0 +1,75 @@
+export namespace MeterbusLib {
+    export class Frame {
+        private _telegram : number[]
+
+        constructor(telegram : number[]) {
+            this._telegram = telegram
+        }
+    }
+
+    export class ControlFrame extends Frame {
+        constructor(telegram : number[]) {
+            super(telegram)
+        }
+    }
+
+    export class ShortFrame extends Frame {
+        constructor(telegram : number[]) {
+            super(telegram)
+        }
+    }
+
+    export class LongFrame extends Frame {
+        constructor(telegram : number[]) {
+            super(telegram)
+        }
+    }
+
+    export class SingleCharFrame extends Frame {
+        constructor(telegram : number[]) {
+            super(telegram)
+        }
+    }
+
+    export class Telegram {
+        private _hexString : string
+        private _telegram : number[]
+        private _frame : Frame
+
+        constructor() {
+        }
+    
+        get hexString() : string {
+            return this._hexString
+        }
+
+        get telegram() : number[] {
+            return this._telegram
+        }
+
+        get frame() : Frame {
+            return this._frame
+        }
+
+        fromHexString(hexString : string) {
+            this._hexString = hexString
+            this._telegram = this._hexString.split(' ').map<number>((val) => {
+                return parseInt(val, 16)
+            })
+        }
+
+        parse() {
+            if (this._telegram[0] === 0x68 && this._telegram[1] === 0x03) {
+                this._frame = new ControlFrame(this._telegram)
+            } else if (this._telegram[0] === 0x68) {
+                this._frame = new LongFrame(this._telegram)
+            } else if (this._telegram[0] === 0x10) {
+                this._frame = new ShortFrame(this._telegram)
+            } else if (this._telegram[0] === 0xe5) {
+                this._frame = new SingleCharFrame(this._telegram)
+            } else {
+                throw Error('invalid start char')
+            }
+        }
+    }
+}