use ranges for tone params

.vscode/settings.json

@@ -1,4 +1,9 @@
 {
     "deno.enable": true,
-    "deno.unstable": true
+    "deno.unstable": true,
+    "deno.codeLens.testArgs": [
+        "--allow-all",
+        "--no-check",
+        "--no-lock"
+    ]
 }

src/app.js

@@ -90,8 +90,8 @@ const Deep =()=>
 {
     const [State, Dispatch] = React.useContext(StoreContext);
     return html`
-    <${UI.Button} onClick=${()=>Dispatch({Name:"Stim", Data:5})}>
+    <${UI.Button} onClick=${()=>Dispatch({Name:"Stim", Data:1})} disabled=${State.Stim.Value == State.Stim.Max}>
-        ${State.Stim}
+        ${State.Stim.Value}
     <//>`;
 }
 

src/store.js

@@ -26,45 +26,24 @@ export const ColumnLookup =(inFrequency)=>
 };
 
 
-
-/** @typedef {{Min:number, Max:number}} Limit */
-/** @typedef {(inValue:number, inLimit:Limit)=>number} LimitUse */
-/** @type {Record<string, Limit>} */
-export const ToneLimit =
-{
-    Freq: { Min: 0,   Max: ColumnMapping.length-1 },
-    Stim: { Min: -10, Max: 120 },
-    Chan: { Min: 0,   Max: 1},
-};
-/** @type {LimitUse} */
-export const LimitCut =(inValue, inLimit)=>
-{
-    if(inValue < inLimit.Min){ return inLimit.Min; }
-    else if(inValue > inLimit.Max) { return inLimit.Max; }
-    else{ return inValue; }
-};
-/** @type {LimitUse} */
-export const LimitMap =(inValue, inLimit)=>(inValue-inLimit.Min)/(inLimit.Max-inLimit.Min);
-
-
 /** @type {(freq:TestFrequency, chan:number, user:boolean)=>TestFrequencySample|undefined} */
 export const MarkGet =(freq, chan, user)=> freq[/** @type {"UserL"|"UserR"|"TestL"|"TestR"} */ (`${user ? "User" : "Test"}${chan ? "R" : "L"}`)];
 
 /** @type {(freq:TestFrequency, chan:number, mark:TestFrequencySample|undefined)=>TestFrequencySample|undefined} */
 export const MarkSet =(freq, chan, mark)=> freq[ chan ? "UserR" : "UserL" ] = mark;
 
-
+/** @typedef {{Min:number, Max:number, Value:number, Step:number}} Range */
 /** @typedef {{Stim:number, Resp:boolean}} TestFrequencySample */
 /** @typedef {{Hz:number, TestL:TestFrequencySample, TestR:TestFrequencySample, UserL?:TestFrequencySample, UserR?:TestFrequencySample}} TestFrequency */
 /** @typedef {{Name:string, Plot:Array<TestFrequency>}} Test */
 /** @typedef {{Test?:Test, Freq?:TestFrequency, Mark?:TestFrequencySample}} Context */
-/** @typedef {{Chan:number, Freq:number, Stim:number, Live:Context, Draw:{UserL:DrawGroup, UserR:DrawGroup, TestL:DrawGroup, TestR:DrawGroup}, Tests:Array<Test>}} State */
+/** @typedef {{Chan:Range, Freq:Range, Stim:Range, Live:Context, Draw:{UserL:DrawGroup, UserR:DrawGroup, TestL:DrawGroup, TestR:DrawGroup}, Tests:Array<Test>}} State */
 /** @type {State} */
 export const Initial =
 {
-    Chan: 0,
+    Chan: { Min:0,   Max:1,   Value:0,  Step:1 },
-    Freq: 3,
+    Freq: { Min:2,   Max:8,   Value:2,  Step:1 },
-    Stim: 30,
+    Stim: { Min:-10, Max:120, Value:30, Step:5 },
     Live:
     {
         Test: undefined,
@@ -90,34 +69,6 @@ export const Initial =
     ]
 };
 
-/*
-const minified =
-[
-    1,
-    [
-        [20, 30, 50, 40, 60, 80],[20, 30, 50, 40, 60, 80]
-    ]
-];
-const Expand =(inMin)=>
-{
-    const outTests = [];
-    const inFreq = inMin[0];
-    for(let i=1; i<inMin.length; i++)
-    {
-        let inTest = inMin[i];
-        let inTestName = inTest[0];
-
-        const outTest = {
-            Name:inTest[0],
-            Plot:[]
-        };
-        outTests.push(outTest);
-        const outFreq = {Hz:0, TestL:{Stim:0, Resp:true}, TestR:{Stim:0, Resp:true}, UserL:undefined, UserR:undefined};
-
-    }
-}
-*/
-
 /** @typedef {{Name:"Mark", Data:boolean|null}} ActionMark */
 /** @typedef {{Name:"Test", Data:number}} ActionTest */
 /** @typedef {{Name:"Chan", Data:number}} ActionChan */
@@ -131,7 +82,7 @@ const Update =
 {
     Freq(inState)
     {
-        const column = ColumnMapping[inState.Freq];
+        const column = ColumnMapping[inState.Freq.Value];
         if(column && inState.Live.Test)
         {
             const hz = column[0];
@@ -153,7 +104,7 @@ const Update =
         const freq = inState.Live.Freq;
         if(freq)
         {
-            inState.Live.Mark = MarkGet(freq, inState.Chan, true);
+            inState.Live.Mark = MarkGet(freq, inState.Chan.Value, true);
             return true;
         }
         return false;
@@ -164,8 +115,8 @@ const Update =
 /** @typedef {{Points:Array<DrawPoint>, Paths:Array<Array<DrawPoint>>}} DrawGroup */
 /** @typedef {{Left:DrawGroup, Right:DrawGroup}} DrawChart */
 /** @typedef {{User?:DrawChart, Test?:DrawChart}} DrawTest */
-/** @type {(inTest:Test, inChannel:number, inIsUser:boolean)=>DrawGroup} */
+/** @type {(inTest:Test, inChan:number, inStim:Range, inIsUser:boolean)=>DrawGroup} */
-export function Congtiguous(inTest, inChannel, inIsUser)
+export function Congtiguous(inTest, inChan, inStim, inIsUser)
 {
     /** @type {DrawGroup} */
     const output = {Points:[], Paths:[]};
@@ -177,7 +128,7 @@ export function Congtiguous(inTest, inChannel, inIsUser)
     for(let i=0; i<inTest.Plot.length; i++)
     {
         plot = inTest.Plot[i];
-        const mark = MarkGet(plot, inChannel, inIsUser);
+        const mark = MarkGet(plot, inChan, inIsUser);
         if(mark)
         {
             const lookup = ColumnLookup(plot.Hz);
@@ -186,7 +137,7 @@ export function Congtiguous(inTest, inChannel, inIsUser)
                 /** @type {DrawPoint} */
                 const point = {
                     X: lookup[1]*100,
-                    Y: LimitMap(mark.Stim, ToneLimit.Stim)*100,
+                    Y: (mark.Stim - inStim.Min)/(inStim.Max - inStim.Min) * 100,
                     Mark: mark
                 };
                 output.Points.push(point);
@@ -224,25 +175,29 @@ export function Reducer(inState, inAction)
         Update.Freq(clone);
         Update.Mark(clone);
         clone.Draw = {
-            UserL: Congtiguous(clone.Live.Test, 0, true ),
+            UserL: Congtiguous(clone.Live.Test, 0, clone.Stim, true ),
-            UserR: Congtiguous(clone.Live.Test, 1, true ),
+            UserR: Congtiguous(clone.Live.Test, 1, clone.Stim, true ),
-            TestL: Congtiguous(clone.Live.Test, 0, false),
+            TestL: Congtiguous(clone.Live.Test, 0, clone.Stim, false),
-            TestR: Congtiguous(clone.Live.Test, 1, false)
+            TestR: Congtiguous(clone.Live.Test, 1, clone.Stim, false)
         };
     }
     else if (Name == "Mark")
     {
         if(clone.Live.Test && clone.Live.Freq)
         {
-            clone.Live.Mark = MarkSet(clone.Live.Freq, clone.Chan, Data !== null ? {Stim:clone.Stim, Resp:Data} : undefined);
+            clone.Live.Mark = MarkSet(clone.Live.Freq, clone.Chan.Value, Data !== null ? {Stim:clone.Stim.Value, Resp:Data} : undefined);
 
             clone.Draw = {...clone.Draw};
-            clone.Draw[clone.Chan == 0 ? "UserL" : "UserR"] = Congtiguous(clone.Live.Test, clone.Chan, true);
+            clone.Draw[clone.Chan.Value == 0 ? "UserL" : "UserR"] = Congtiguous(clone.Live.Test, clone.Chan.Value, clone.Stim, true);
         }
     }
     else if( Name=="Stim" || Name=="Chan" || Name=="Freq")
     {
-        clone[Name] = LimitCut(clone[Name]+Data, ToneLimit[Name]);
+        const tone = {...clone[Name]};
+        tone.Value += Data*tone.Step;
+        if(tone.Value < tone.Min){ tone.Value = tone.Min; }
+        if(tone.Value > tone.Max){ tone.Value = tone.Max; }
+        clone[Name] = tone;
         if(Name != "Stim")
         {
             Update.Freq(clone);
@@ -251,4 +206,32 @@ export function Reducer(inState, inAction)
     }
 
     return clone;
-}
+}
+
+/*
+const minified =
+[
+    1,
+    [
+        [20, 30, 50, 40, 60, 80],[20, 30, 50, 40, 60, 80]
+    ]
+];
+const Expand =(inMin)=>
+{
+    const outTests = [];
+    const inFreq = inMin[0];
+    for(let i=1; i<inMin.length; i++)
+    {
+        let inTest = inMin[i];
+        let inTestName = inTest[0];
+
+        const outTest = {
+            Name:inTest[0],
+            Plot:[]
+        };
+        outTests.push(outTest);
+        const outFreq = {Hz:0, TestL:{Stim:0, Resp:true}, TestR:{Stim:0, Resp:true}, UserL:undefined, UserR:undefined};
+
+    }
+}
+*/

test/store_test.js

@@ -1,38 +1,18 @@
 import { assertEquals } from "https://deno.land/std@0.166.0/testing/asserts.ts";
-import { Reducer, ColumnMapping, Congtiguous } from "../src/store.js";
+import { Reducer, ColumnMapping, Congtiguous, Initial } from "../src/store.js";
-
-let state = {
-    Chan: 0,
-    Freq: 1,
-    Stim: 20,
-    Live:
-    {
-        Test: undefined,
-        Freq: undefined,
-        Mark: undefined
-    },
-    Draw:
-    {
-        UserL:{Points:[], Paths:[]},
-        UserR:{Points:[], Paths:[]},
-        TestL:{Points:[], Paths:[]},
-        TestR:{Points:[], Paths:[]}
-    },
-    Tests: [
-        {
-            Name: "Patient A  Asymmetric Notch",
-            Plot:
-            [
-                { Hz: 500,  TestL: { Stim: 30, Resp: true }, TestR: { Stim: 50, Resp: true } },
-                { Hz: 1000, TestL: { Stim: 50, Resp: true }, TestR: { Stim: 55, Resp: true } }
-            ]
-        }
-    ]
-};
 
+let state = {...Initial};
 
 Deno.test("Initialize", async(t)=>
 {
+
+    await t.step("Tone Parameters Initialized", ()=>
+    {
+        assertEquals(state.Chan.Value, 0);
+        assertEquals(state.Freq.Value, 2);
+        assertEquals(state.Stim.Value, 30);
+    });
+
     await t.step("A test exists with 500 and 1k hz plots", ()=>
     {
         assertEquals(state.Tests.length > 0, true);
@@ -45,28 +25,38 @@ Deno.test("Initialize", async(t)=>
     await t.step("Dispatch Test, Freq, Stim, and Chan updates", ()=>
     {
         state = Reducer(state, {Name:"Test", Data:0});
-        state = Reducer(state, {Name:"Freq", Data:1});
+
-        state = Reducer(state, {Name:"Stim", Data:5});
         state = Reducer(state, {Name:"Chan", Data:1});
+        state = Reducer(state, {Name:"Freq", Data:1});
+        state = Reducer(state, {Name:"Stim", Data:1});
     });
 
     await t.step("Freq, Stim, and Chan have the correct values", ()=>
     {
-        assertEquals(state.Stim, 25);
+        assertEquals(state.Chan.Value, 1);
-        assertEquals(state.Freq, 2);
+        assertEquals(state.Freq.Value, 3);
-        assertEquals(state.Chan, 1);
+        assertEquals(state.Stim.Value, 35);
     });
 
     await t.step("Live context values are correct", ()=>
     {
         assertEquals(state.Live.Test, state.Tests[0]);
-        assertEquals(state.Live.Freq.Hz, ColumnMapping[state.Freq][0]);
+        assertEquals(state.Live.Freq.Hz, ColumnMapping[state.Freq.Value][0]);
         assertEquals(state.Live.Mark, undefined, "(User) Mark is undefined");
     });
 });
 
 Deno.test("Make Marks", async(t)=>
 {
+    let state = {...Initial};
+    
+    await t.step("Tone Parameters Initialized", ()=>
+    {
+        assertEquals(state.Chan.Value, 0);
+        assertEquals(state.Freq.Value, 2);
+        assertEquals(state.Stim.Value, 30);
+    });
+
     await t.step("Dispatch Mark create", ()=>
     {
         state = Reducer(state, {Name:"Mark", Data:true});
@@ -74,36 +64,18 @@ Deno.test("Make Marks", async(t)=>
 
     await t.step("Check marked value", ()=>
     {
-        assertEquals(state.Live.Freq.UserR !== undefined, true, `there will be a user mark for the right channel`);
+        assertEquals(state.Live.Freq.UserL !== undefined, true, `there will be a user mark for the left channel`);
-        assertEquals(state.Live.Freq.UserL === undefined, true, `the left channel user mark will be undefined`);
+        assertEquals(state.Live.Freq.UserR === undefined, true, `but not the right`);
-        assertEquals(state.Live.Mark.Stim, state.Stim);
+        assertEquals(state.Live.Mark.Stim, state.Stim.Value);
         assertEquals(state.Live.Mark.Resp, true);
     });
 
-    await t.step("Dispatch Mark delete", ()=>
-    {
-        state = Reducer(state, {Name:"Mark", Data:null});
-    });
-
-    await t.step("Check marked value", ()=>
-    {
-        assertEquals(state.Live.Freq.UserR === undefined, true);
-        assertEquals(state.Live.Freq.UserL === undefined, true);
-        assertEquals(state.Live.Mark, undefined);
-    });
-
     await t.step("Dispatch Freq, Stim, and Chan updates", ()=>
     {
+        state = Reducer(state, {Name:"Test", Data:0});
         state = Reducer(state, {Name:"Freq", Data:1});
-        state = Reducer(state, {Name:"Stim", Data:5});
+        state = Reducer(state, {Name:"Stim", Data:1});
-        state = Reducer(state, {Name:"Chan", Data:0});
+        state = Reducer(state, {Name:"Chan", Data:1});
-    });
-
-    await t.step("Live context values are correct", ()=>
-    {
-        assertEquals(state.Live.Test, state.Tests[0]);
-        assertEquals(state.Live.Freq.Hz, ColumnMapping[state.Freq][0]);
-        assertEquals(state.Live.Mark, undefined);
     });
 
     await t.step("Dispatch Mark create", ()=>
@@ -114,10 +86,19 @@ Deno.test("Make Marks", async(t)=>
     await t.step("Check marked value", ()=>
     {
         assertEquals(state.Live.Freq.UserR !== undefined, true, `there will be a user mark for the right channel`);
-        assertEquals(state.Live.Freq.UserL === undefined, true, `the left channel user mark will be undefined`);
+        assertEquals(state.Live.Freq.UserL !== undefined, true, `and the left`);
-        assertEquals(state.Live.Mark.Stim, state.Stim);
+        assertEquals(state.Live.Mark.Stim, state.Stim.Value);
         assertEquals(state.Live.Mark.Resp, false);
     });
+
+    await t.step("Live context values are correct", ()=>
+    {
+        assertEquals(state.Live.Test, state.Tests[0]);
+        assertEquals(state.Live.Freq.Hz, ColumnMapping[state.Freq.Value][0]);
+        assertEquals(state.Live.Mark.Stim, state.Stim.Value);
+    });
+
+    console.log(state.Draw);
 });
 
 Deno.test("Contiguous Lines", ()=>
@@ -135,7 +116,7 @@ Deno.test("Contiguous Lines", ()=>
         ]
     }
 
-    const {Points, Paths} = Congtiguous(model, 0, true);
+    const {Points, Paths} = Congtiguous(model, 0, Initial.Stim, true);
     assertEquals(Points.length, 6);
     assertEquals(Paths.length, 2);
     assertEquals(Paths[0].length, 2);