webui: add pure calibration module with unit tests

Implements Calib JS module (calibration.js) with affine transform primitives,
CalTable, and normaliseCal matching Go CalConfig.Normalise semantics; 14 node
--test cases all pass. Loads before app.js in index.html.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Client/udpstreamer/test/calibration.test.js

@@ -0,0 +1,111 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const C = require('../static/calibration.js');
+
+test('baseSignalName strips an element suffix', () => {
+  assert.strictEqual(C.baseSignalName('Adc'), 'Adc');
+  assert.strictEqual(C.baseSignalName('Adc[3]'), 'Adc');
+  assert.strictEqual(C.baseSignalName('Adc[12]'), 'Adc');
+  assert.strictEqual(C.baseSignalName('A[1]B'), 'A[1]B');
+  assert.strictEqual(C.baseSignalName(''), '');
+});
+
+test('calKey is stable and separates the two fields', () => {
+  assert.strictEqual(C.calKey('a', 'b'), C.calKey('a', 'b'));
+  assert.notStrictEqual(C.calKey('ab', 'c'), C.calKey('a', 'bc'));
+});
+
+test('normaliseCal accepts a valid entry and fills defaults', () => {
+  assert.deepStrictEqual(
+    C.normaliseCal({source: ' wave ', signal: ' Adc ', scale: 2, offset: -1, unit: ' V '}),
+    {source: 'wave', signal: 'Adc', scale: 2, offset: -1, unit: 'V'});
+  assert.deepStrictEqual(
+    C.normaliseCal({source: 'wave', signal: 'Adc'}),
+    {source: 'wave', signal: 'Adc', scale: 1, offset: 0, unit: ''});
+});
+
+test('normaliseCal strips an element suffix from the signal name', () => {
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 'Adc[3]'}).signal, 'Adc');
+});
+
+test('normaliseCal truncates an over-long unit', () => {
+  const long = 'abcdefghijklmnopqrstuvwxyz';
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', unit: long}).unit,
+                     long.slice(0, C.MAX_UNIT_LEN));
+});
+
+test('normaliseCal rejects invalid entries', () => {
+  assert.strictEqual(C.normaliseCal(null), null);
+  assert.strictEqual(C.normaliseCal({signal: 's'}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w'}), null);
+  assert.strictEqual(C.normaliseCal({source: '  ', signal: 's'}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', scale: 0}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', scale: NaN}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', scale: Infinity}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', offset: NaN}), null);
+  assert.strictEqual(C.normaliseCal({source: 'w', signal: 's', scale: '2'}), null);
+});
+
+test('applyCal and invertCal round-trip', () => {
+  const cal = {scale: 0.5, offset: -1.25, unit: 'V'};
+  assert.strictEqual(C.applyCal(10, cal), 3.75);
+  assert.strictEqual(C.invertCal(3.75, cal), 10);
+  assert.strictEqual(C.applyCal(7, C.IDENTITY), 7);
+  assert.strictEqual(C.invertCal(7, C.IDENTITY), 7);
+});
+
+test('applyCal passes non-finite samples through untouched', () => {
+  assert.ok(Number.isNaN(C.applyCal(NaN, {scale: 2, offset: 1, unit: ''})));
+});
+
+test('calRange re-orders when the scale is negative', () => {
+  assert.deepStrictEqual(C.calRange(0, 10, {scale: 2, offset: 1, unit: ''}), [1, 21]);
+  assert.deepStrictEqual(C.calRange(0, 10, {scale: -2, offset: 1, unit: ''}), [-19, 1]);
+});
+
+test('CalTable.get returns IDENTITY for an unknown signal', () => {
+  const t = new C.CalTable();
+  assert.deepStrictEqual(t.get('w', 'Adc'), C.IDENTITY);
+});
+
+test('CalTable.get resolves an element name to its base signal', () => {
+  const t = new C.CalTable();
+  t.set({source: 'w', signal: 'Adc', scale: 3, offset: 0, unit: ''});
+  assert.strictEqual(t.get('w', 'Adc[7]').scale, 3);
+});
+
+test('CalTable.set stores, overwrites, and deletes identity entries', () => {
+  const t = new C.CalTable();
+  assert.strictEqual(t.set({source: 'w', signal: 'Adc', scale: 2}), true);
+  assert.strictEqual(t.get('w', 'Adc').scale, 2);
+  t.set({source: 'w', signal: 'Adc', scale: 5});
+  assert.strictEqual(t.get('w', 'Adc').scale, 5);
+  assert.strictEqual(t.list().length, 1);
+  // Resetting to identity removes the entry entirely.
+  assert.strictEqual(t.set({source: 'w', signal: 'Adc', scale: 1, offset: 0, unit: ''}), true);
+  assert.strictEqual(t.list().length, 0);
+  // An invalid entry is refused and changes nothing.
+  assert.strictEqual(t.set({source: 'w', signal: 'Adc', scale: 0}), false);
+  assert.strictEqual(t.list().length, 0);
+});
+
+test('CalTable.replaceAll drops the previous contents', () => {
+  const t = new C.CalTable();
+  t.set({source: 'w', signal: 'Old', scale: 2});
+  t.replaceAll([
+    {source: 'w', signal: 'B', scale: 2},
+    {source: 'w', signal: 'A', scale: 3},
+    {source: 'w', signal: 'Bad', scale: 0},
+    {source: 'w', signal: 'Ident', scale: 1, offset: 0, unit: ''},
+  ]);
+  assert.deepStrictEqual(t.list().map(e => e.signal), ['A', 'B']);
+});
+
+test('CalTable.list is sorted by source then signal', () => {
+  const t = new C.CalTable();
+  t.set({source: 'z', signal: 'a', scale: 2});
+  t.set({source: 'a', signal: 'z', scale: 2});
+  t.set({source: 'a', signal: 'b', scale: 2});
+  assert.deepStrictEqual(t.list().map(e => e.source + '/' + e.signal),
+                         ['a/b', 'a/z', 'z/a']);
+});