:recycle: move some things around

src/api.js

+import { fromLiquid } from './core/utils.js'
+
+import { Container } from './core/container.js'
+import { Reading, Channel } from './core/channel'
+import { Controller } from './core/controller'
+import { InputConf } from './input.js'
+
+/**
+ * Changing level gives you back a new Container
+ * object to keep you stateless.
+ *
+ * @param {Number} amount
+ * @param {Container} container
+ * @returns {Container}
+ */
+const _changeLevel = (amount, container) => {
+    const updatedLevel =
+        fromLiquid(container.liquidVolumeFilled + amount) /
+        container.l /
+        container.w
+    return new Container(
+        container.dims,
+        updatedLevel,
+        container.label,
+        container.id,
+    )
+}
+
+/**
+ * Take in inputConf objects (see: index.js)
+ * and returns Controllers with an initial reading
+ *
+ * @param {InputConf}
+ * @returns {Controller}
+ */
+const makeController = ({ type, onRead, interval, onUpdate }) => {
+    const reader = new Reading({
+        onRead,
+        unit: 'F',
+        max: 80,
+        min: 72,
+    })
+
+    const controller = new Controller({
+        type,
+        channel: new Channel({ interval, reader }),
+    })
+    controller.onUpdate = onUpdate
+    return controller
+}
+
+const fill = ({ container, amount }) => _changeLevel(amount, container)
+const drain = ({ container, amount }) => _changeLevel(-1 * amount, container)
+
+export { fill, drain, makeController }

src/channel.js

-/**
- * @type {Reading}
- */
-class Reading {
-    constructor({ onRead, unit, min, max }) {
-        this._val = onRead
-        this.unit = unit
-        this.max = max
-        this.min = min
-        this.created = Date.now()
-    }
-    /**
-     * Reach out and grabs the value
-     * from some sensor
-     */
-    get val() {
-        return this._val()
-    }
-}
-
-/**
- * @type {Channel}
- */
-class Channel {
-    constructor({ interval = 1, reader = null }) {
-        this._interval = interval
-        this._reader = reader
-    }
-    get interval() {
-        return this._interval
-    }
-    get lastUpdate() {
-        return this._reader.created
-    }
-    get val() {
-        return this._reader.val
-    }
-    get unit() {
-        return this._reader.unit
-    }
-    get aboveRange() {
-        return this._reader.val > this._reader.max
-    }
-    get belowRange() {
-        return this._reader.val < this._reader.min
-    }
-    get inRange() {
-        return this._reader.val && !this.aboveRange && !this.belowRange
-            ? true
-            : false
-    }
-    /** Always return a new Reading instance with new Channel instances */
-    update() {
-        const reader = new Reading({
-            // !: Setup the callback to return a sensor value
-            onRead: this._reader._val,
-            unit: this._reader.unit,
-            max: this._reader.max,
-            min: this._reader.min,
-        })
-
-        const chan = new Channel({ interval: this.interval, reader })
-        return chan
-    }
-}
-
-export { Channel, Reading }

src/controller.js

 //     channelOrSensor,
 // })
 
+/**
+ * Built-in controller types
+ *
+ * @type {{ temp: KnownControllerType; level: KnownControllerType; }}
+ */
 const controllerTypes = {
     temp: 'temperature',
     level: 'water_level',
 }
 
 /**
- * Object to link a channel to an action
+ * Object to link a Channel to an onUpdate action.
  *
- * @type {Controller} links together channels
- **/
+ * @class Controller
+ * @typedef {Controller}
+ */
 class Controller {
-    constructor({ type, channel }) {
+    constructor({ type, channel }, onUpdate) {
         this._type = type
         this.channel = channel
     }
     get inRange() {
         return this.channel.inRange
     }
+    /**
+     * Returns from Reading.val callback
+     *
+     * @returns {*}
+     */
     update() {
-        this.channel = this.channel.update()
+        this.channel = updateChannel(this.channel)
         return this.channel.val
     }
-    onUpdate() {
-        // Not implemented here
-    }
+    /**
+     * Control logic to perform.
+     *
+     * @overload
+     */
+    onUpdate() {}
 }
 
 export { Controller, controllerTypes }

src/core/channel.js

+/**
+ * Readers actually reach out and get values for a Channel.
+ * You probably should never instantiate this outside of testing.
+ *
+ * @private
+ * @class Reading
+ * @typedef {Reading}
+ */
+class Reading {
+    /**
+     * Creates an instance of Reading.
+     *
+     * @constructor
+     * @param {{ onRead: function; unit: any; min: any; max: any; }} param0
+     * @param {function} param0.onRead
+     * @param {string} param0.unit
+     * @param {*} param0.min
+     * @param {*} param0.max
+     */
+    constructor({ onRead, unit, min, max }) {
+        this._readVal = onRead
+        this.unit = unit
+        this.max = max
+        this.min = min
+        this.created = Date.now()
+    }
+    /**
+     * Reach out and grabs the value from some sensor
+     *
+     * @readonly
+     * @type {*}
+     */
+    get val() {
+        return this._readVal()
+    }
+}
+
+/**
+ *
+ * @param {{ onRead: function, unit: any; min: any; max: any; interval: any; }} param0
+ * @returns {Channel}
+ */
+const updateChannel = ({ onRead, unit, max, min, interval }) =>
+    new Channel({
+        interval,
+        reader: new Reading({
+            onRead,
+            unit,
+            max,
+            min,
+        }),
+    })
+
+/**
+ * Channels provide and interface to Readings to
+ * grab values and provide some simple getter based
+ * on the value.
+ *
+ * @class Channel
+ * @typedef {Channel}
+ */
+class Channel {
+    /**
+     * Creates an instance of Channel.
+     *
+     * @constructor
+     * @param {{ interval?: number; reader?: Reading; }} ReadParams
+     * @param {number} [ReadParams.interval=1]
+     * @param {Reading} [ReadParams.reader=null]
+     */
+    constructor({ interval = 1, reader = null }) {
+        this._interval = interval
+        this._reader = reader
+    }
+    get interval() {
+        return this._interval
+    }
+    get lastUpdate() {
+        return this._reader.created
+    }
+    get val() {
+        return this._reader.val
+    }
+    get unit() {
+        return this._reader.unit
+    }
+    get aboveRange() {
+        return this._reader.val > this._reader.max
+    }
+    get belowRange() {
+        return this._reader.val < this._reader.min
+    }
+    get inRange() {
+        return this._reader.val && !this.aboveRange && !this.belowRange
+            ? true
+            : false
+    }
+}
+
+export { updateChannel, Channel, Reading }

src/container.js → src/core/container.js

 import { nanoid } from 'nanoid'
 import { toLiquid } from './utils.js'
 
+/**
+ * A container instance represents any rectangular
+ * volume that can be filled with fluid
+ *
+ * @class Container
+ * @typedef {Container}
+ */
 class Container {
     constructor({ l, w, h }, level = 0, label, id = nanoid()) {
         this._id = id //=> "V1StGXR8_Z5jdHi6B-myT"
     get label() {
         return this._label
     }
+    get dims() {
+        return { l: this.l, w: this.w, h: this.h }
+    }
     get liquidVolumeCapacity() {
         return toLiquid(this.l * this.w * this.h)
     }

src/core/utils.js

+const US_LIQUID_GALLONS_TO_CUBIC_INCHES = 231
+const CUBIC_INCHES_TO_US_LIQUID_GALLONS = 1 / US_LIQUID_GALLONS_TO_CUBIC_INCHES
+
+const toLiquid = cubicInches => cubicInches * CUBIC_INCHES_TO_US_LIQUID_GALLONS
+const fromLiquid = gallons => gallons * US_LIQUID_GALLONS_TO_CUBIC_INCHES
+
+export { toLiquid, fromLiquid }

src/index.js

 
 import loop from './loop.js'
 import { System, makeContainerT } from './system.js'
-import { Container } from './container.js'
+import { InputConf } from './input.js'
+import { Container } from './core/container.js'
 
-class InputConf {
-    constructor(type, onRead, readInterval, onUpdate) {
-        ;(this.type = type),
-            (this.onRead = onRead),
-            (this.interval = readInterval),
-            (this.onUpdate = onUpdate)
-    }
-}
 const fromConfig = {
     tank_1: {
         inputs: [],
         const containerT = makeContainerT(
             inputs,
             outputs,
-            new Container(dims, 0, containerName)
+            new Container(dims, 0, containerName),
         )
         sys.add(containerT[2].id, containerT)
     }

src/input.js

+/**
+ * Describe a single input for a Container.
+ *
+ * @class InputConf
+ * @typedef {InputConf}
+ */
+class InputConf {
+    /**
+     * Creates an instance of InputConf.
+     *
+     * @constructor
+     * @param {KnownControllerType} type
+     * @param {function} onRead
+     * @param {number|float} readInterval
+     * @param {function} onUpdate
+     */
+    constructor(type, onRead, readInterval, onUpdate) {
+        ;(this.type = type),
+            (this.onRead = onRead),
+            (this.interval = readInterval),
+            (this.onUpdate = onUpdate)
+    }
+}
+
+export { InputConf }

src/system.js

-import { Reading, Channel } from './channel'
-import { Controller } from './controller'
+import { Container } from './core/container'
+import { makeController } from './api'
+import { InputConf } from './input'
 
 /**
  * Object that holds each container and their input and outputs
  *
- * @type {System}
+ * @typedef {System}
  */
 class System {
     constructor() {
         this.inventory[container.id] = makeContainerT(
             inputs,
             outputs,
-            container
+            container,
         )
     }
     add(id, containerT) {
     }
     inputsFor({ id }) {
         return Object.values(this.inventory).find(
-            containerT => containerT[2].id == id
+            containerT => containerT[2].id == id,
         )[0]
     }
     outputsFor({ id }) {
         return Object.values(this.inventory).find(
-            containerT => containerT[2].id == id
+            containerT => containerT[2].id == id,
         )[1]
     }
 }
 
 /**
- * Take in inputConf objects (see: index.js)
- * and returns Controllers with an initial reading
- **/
-const _makeControllerFromInputConfig = ({
-    type,
-    onRead,
-    interval,
-    onUpdate,
-}) => {
-    const reader = new Reading({
-        onRead,
-        unit: 'F',
-        max: 80,
-        min: 72,
-    })
-
-    const controller = new Controller({
-        type,
-        channel: new Channel({ interval, reader }),
-    })
-    controller.onUpdate = onUpdate
-    return controller
-}
-
+ * Associate inputs and outputs with a Container
+ *
+ * @param {Array.<InputConf>} inputs
+ * @param {*} outputs
+ * @param {Container} container
+ * @returns {Array.}
+ */
 const makeContainerT = (inputs, outputs, container) => {
-    const controllers = inputs.map(_makeControllerFromInputConfig)
+    const controllers = inputs.map(makeController)
     return [controllers, outputs, container]
 }
 

src/utils.js

-import { Container } from './container.js'
-
-const US_LIQUID_GALLONS_TO_CUBIC_INCHES = 231
-const CUBIC_INCHES_TO_US_LIQUID_GALLONS = 1 / US_LIQUID_GALLONS_TO_CUBIC_INCHES
-
-const toLiquid = cubicInches => cubicInches * CUBIC_INCHES_TO_US_LIQUID_GALLONS
-const fromLiquid = gallons => gallons * US_LIQUID_GALLONS_TO_CUBIC_INCHES
-
-const _changeLevel = (amount, container) => {
-    const updatedLevel =
-        fromLiquid(container.liquidVolumeFilled + amount) /
-        container.l /
-        container.w
-    return new Container(
-        {
-            l: container.l,
-            w: container.w,
-            h: container.h,
-        },
-        updatedLevel,
-        container.label,
-        container.id
-    )
-}
-
-// Human API
-const fill = ({ container, amount }) => _changeLevel(amount, container)
-const drain = ({ container, amount }) => _changeLevel(-1 * amount, container)
-
-const interpolate = ({ x, y, from }) => {
-    const [x1, x2] = x
-    const [y1, y2] = y
-    const to = y1 + ((y2 - y1) / (x2 - x1)) * (from - x1)
-    return to
-}
-
-export { toLiquid, fromLiquid, fill, drain, interpolate }

test/channel.spec.js

 import { expect, test } from 'vitest'
-import { Channel } from '../src/channel.js'
-import { Reading } from '../src/channel.js'
+import { updateChannel, Channel, Reading } from '../src/core/channel.js'
 
 test('channel - instantiate channel with readers correctly', () => {
     let now = Date.now()
     expect(testChan.unit).toStrictEqual('F')
 
     mockTemp = 101
-    testChan = testChan.update()
+    testChan = updateChannel(testChan)
     expect(testChan.lastUpdate > now).toStrictEqual(true)
     expect(testChan.val).toStrictEqual(101)
     expect(testChan.inRange).toStrictEqual(false)
     expect(testChan.belowRange).toStrictEqual(false)
 
     mockTemp = 49
-    testChan = testChan.update()
+    testChan = updateChannel(testChan)
     now = Date.now()
     expect(testChan.lastUpdate == now).toStrictEqual(true)
     expect(testChan.inRange).toStrictEqual(false)

test/container.spec.js

 import { expect, test } from 'vitest'
-import { Container } from '../src/container.js'
+import { Container } from '../src/core/container.js'
 
 const dims = { l: 10, w: 10, h: 10 } // inches
 const capacity = 4.329004329004329 // gallons

test/controller.spec.js

+import { expect, test } from 'vitest'
+import { Channel, Reading } from '../src/core/channel'
+import { Controller } from '../src/controller'
+
+test('controller - updates correctly', () => {
+    let mockTemp = 70
+    let testReader = new Reading({
+        onRead: () => mockTemp,
+        unit: 'F',
+        max: 100,
+        min: 50,
+    })
+    let testChan = new Channel({ interval: 1, reader: testReader })
+
+    const testController = new Controller({
+        type: 'blah',
+        channel: testChan,
+    })
+    expect(testController.inRange).toBe(true)
+    mockTemp = 101
+    testController.update()
+    expect(testController.inRange).toBe(false)
+
+    testController.onUpdate = foo => 'foo'
+    expect(testController.onUpdate('bar')).toBe('foo')
+})
+
+test('controller - onUpdate overloading works', () => {
+    let mockTemp = 70
+    let testReader = new Reading({
+        onRead: () => mockTemp,
+        unit: 'F',
+        max: 100,
+        min: 50,
+    })
+    let testChan = new Channel({ interval: 1, reader: testReader })
+
+    const testController = new Controller({
+        type: 'blah',
+        channel: testChan,
+    })
+
+    testController.onUpdate = foo => 'foo'
+    expect(testController.onUpdate('bar')).toBe('foo')
+})

test/system.spec.js

 import { expect, test } from 'vitest'
+import { Container } from '../src/core/container.js'
 import { System, makeContainerT } from '../src/system.js'
-import { Container } from '../src/container.js'
 import { controllerTypes } from '../src/controller.js'
 import { InputConf } from '../src/index.js'
 
         controllerTypes.temp,
         () => mockTemp,
         0.1,
-        () => 'tick'
+        () => 'tick',
     )
     const cT = makeContainerT([testInConf], [], testContainer)
     testSystem.add('aaa', cT)

test/utils.spec.js

 import { expect, test } from 'vitest'
-import { Container } from '../src/container.js'
-import { fill, drain } from '../src/utils.js'
+import { Container } from '../src/core/container.js'
+import { fill, drain } from '../src/api.js'
 
 const dims = { l: 10, w: 10, h: 10 } // inches
 const capacity = 4.329004329004329 // gallons