From 50bb754d8fc403b5bce68200233783aa2d5eaaf1 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Thu, 10 Oct 2024 00:40:34 +0200
Subject: [PATCH 01/31] chore: Move year selector into its own component

---
 src/pages/policy/input/ParameterEditor.jsx | 48 ++++++++++++++--------
 1 file changed, 31 insertions(+), 17 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index b0038bbaf..eaf1ec2be 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -254,22 +254,6 @@ function PeriodSetter(props) {
     dateSelectButtonLabel = `from ${moment(startDate).year()} to ${moment(endDate).year()}:`;
   }
 
-  const yearSelector = (
-    <RangePicker
-      picker="year"
-      defaultValue={[moment(startDate), null]}
-      value={[moment(startDate), isEndForever ? null : moment(endDate)]}
-      onChange={(_, yearStrings) => {
-        setStartDate(yearStrings[0].concat("-01-01"));
-        setEndDate(yearStrings[1].concat("-12-31"));
-      }}
-      disabledDate={(date) =>
-        date.isBefore(minPossibleDate) || date.isAfter(maxPossibleDate)
-      }
-      separator="→"
-    />
-  );
-
   const dateSelector = (
     <RangePicker
       defaultValue={[moment(startDate), null]}
@@ -309,7 +293,17 @@ function PeriodSetter(props) {
           marginBottom: "10px",
         }}
       />
-      {visibleDateSelector === "yearly" ? yearSelector : dateSelector}
+      {visibleDateSelector === "yearly" ? 
+          <YearSetter 
+            startDate={startDate}
+            endDate={endDate}
+            setStartDate={setStartDate}
+            setEndDate={setEndDate}
+            minPossibleDate={minPossibleDate}
+            maxPossibleDate={maxPossibleDate}
+            isEndForever={isEndForever}
+          />
+           : dateSelector}
     </div>
   );
 
@@ -331,6 +325,26 @@ function PeriodSetter(props) {
   );
 }
 
+function YearSetter(props) {
+  const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
+
+  return (
+    <RangePicker
+      picker="year"
+      defaultValue={[moment(startDate), null]}
+      value={[moment(startDate), isEndForever ? null : moment(endDate)]}
+      onChange={(_, yearStrings) => {
+        setStartDate(yearStrings[0].concat("-01-01"));
+        setEndDate(yearStrings[1].concat("-12-31"));
+      }}
+      disabledDate={(date) =>
+        date.isBefore(minPossibleDate) || date.isAfter(maxPossibleDate)
+      }
+      separator="→"
+    />
+  )
+}
+
 function ValueSetter(props) {
   const {
     startDate,

From c9167457ba954ed1b4324e7308c03475192fcf29 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Thu, 17 Oct 2024 23:49:04 +0200
Subject: [PATCH 02/31] feat: Add input settings button (non-functional)

---
 src/pages/policy/input/ParameterEditor.jsx | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index eaf1ec2be..f7829f197 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -25,7 +25,7 @@ import {
 import { IntervalMap } from "algorithms/IntervalMap";
 import { cmpDates, nextDay, prevDay } from "lang/stringDates";
 import moment from "dayjs";
-import { LeftOutlined, RightOutlined, UndoOutlined } from "@ant-design/icons";
+import { LeftOutlined, RightOutlined, SettingOutlined, UndoOutlined } from "@ant-design/icons";
 import style from "../../../style";
 const { RangePicker } = DatePicker;
 
@@ -135,7 +135,7 @@ export default function ParameterEditor(props) {
           </p>
           <div
             style={{
-              width: "100%",
+              width: "fit-content",
               display: "flex",
               flexDirection: "row",
               justifyContent: "flex-start",
@@ -172,6 +172,7 @@ export default function ParameterEditor(props) {
               reformMap={reformMap}
               baseMap={baseMap}
             />
+            <SettingsButton />
           </div>
         </div>
         {!parameter.economy && (
@@ -530,6 +531,20 @@ function AdvancedValueSetter(props) {
   );
 }
 
+function SettingsButton() {
+  return (
+    <Tooltip title="Input settings">
+      <Button
+        style={{
+          aspectRatio: 1,
+        }}
+      >
+        <SettingOutlined />
+      </Button>
+    </Tooltip>
+  );
+}
+
 /**
  * Checks whether or not an input date is a boundary date -
  * the first or last day of a fixed period (e.g., Jan. 1 or

From 4d2d93809b65143d43b734fe77a0ada2b8b0cc52 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 00:09:52 +0200
Subject: [PATCH 03/31] feat: SettingsPanel (non-functional)

---
 src/pages/policy/input/ParameterEditor.jsx | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index f7829f197..180d01ed8 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -172,7 +172,7 @@ export default function ParameterEditor(props) {
               reformMap={reformMap}
               baseMap={baseMap}
             />
-            <SettingsButton />
+            <SettingsPanel />
           </div>
         </div>
         {!parameter.economy && (
@@ -531,9 +531,13 @@ function AdvancedValueSetter(props) {
   );
 }
 
-function SettingsButton() {
+function SettingsPanel() {
   return (
-    <Tooltip title="Input settings">
+    <Popover 
+      content={<p>Test value</p>} 
+      placement="bottomRight" 
+      trigger="click"
+    >
       <Button
         style={{
           aspectRatio: 1,
@@ -541,7 +545,7 @@ function SettingsButton() {
       >
         <SettingOutlined />
       </Button>
-    </Tooltip>
+    </Popover>
   );
 }
 

From 0ba35f2ec67c45024124f793f270e0267be16ebd Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 00:38:23 +0200
Subject: [PATCH 04/31] feat: Re-enable year selector

---
 src/pages/policy/input/ParameterEditor.jsx | 81 ++++++++++++++++------
 1 file changed, 60 insertions(+), 21 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 180d01ed8..8c5d194bf 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -6,7 +6,6 @@ import {
   DatePicker,
   InputNumber,
   Popover,
-  Segmented,
   Space,
   Switch,
   Tooltip,
@@ -38,6 +37,14 @@ const { RangePicker } = DatePicker;
  * @param {String} props.parameterName
  * @returns {import("react-markdown/lib/react-markdown").ReactElement}
  */
+
+const DATE_INPUT_MODES = {
+  DEFAULT: "default",
+  YEARLY: "yearly",
+  DATE: "date",
+  TEN_YEAR: "ten-year"
+};
+
 export default function ParameterEditor(props) {
   const { metadata, policy, parameterName } = props;
   const parameter = metadata.parameters[parameterName];
@@ -57,6 +64,7 @@ export default function ParameterEditor(props) {
   const [startDate, setStartDate] = useState(defaultStartDate);
   const [endDate, setEndDate] = useState(defaultEndDate);
   const [paramChartWidth, setParamChartWidth] = useState(0);
+  const [dateInputMode, setDateInputMode] = useState(DATE_INPUT_MODES.YEARLY);
 
   useEffect(() => {
     if (chartContainerRef.current) {
@@ -150,6 +158,7 @@ export default function ParameterEditor(props) {
                 endDate={endDate}
                 setStartDate={setStartDate}
                 setEndDate={setEndDate}
+                inputMode={dateInputMode}
               />
               {startDate !== defaultStartDate || endDate !== defaultEndDate ? (
                 <Button
@@ -172,7 +181,9 @@ export default function ParameterEditor(props) {
               reformMap={reformMap}
               baseMap={baseMap}
             />
-            <SettingsPanel />
+            <SettingsPanel 
+              setDateInputMode={setDateInputMode}
+            />
           </div>
         </div>
         {!parameter.economy && (
@@ -223,14 +234,15 @@ export default function ParameterEditor(props) {
 }
 
 function PeriodSetter(props) {
-  const { metadata, startDate, endDate, setStartDate, setEndDate } = props;
-
-  const [visibleDateSelector, setVisibleDateSelector] = useState("yearly");
-
-  function handleSegmentedChange(value) {
-    setVisibleDateSelector(value);
-  }
-
+  const { 
+    inputMode,
+    metadata,
+    startDate,
+    endDate,
+    setStartDate,
+    setEndDate
+  } = props;
+  
   const FOREVER_DATE = String(defaultForeverYear).concat("-12-31");
 
   // Array of selectable years, sorted in ascending order
@@ -243,6 +255,41 @@ function PeriodSetter(props) {
   ).concat("-12-31");
   const isEndForever = endDate === FOREVER_DATE;
 
+  const sharedProps = {
+    startDate,
+    endDate,
+    setStartDate,
+    setEndDate,
+    minPossibleDate,
+    maxPossibleDate,
+    isEndForever
+  };
+
+  if (inputMode === DATE_INPUT_MODES.YEARLY) {
+    return <YearPeriodSetter {...sharedProps} />
+  } 
+  
+  /*
+  else if (inputMode = DATE_INPUT_MODES.DATE) {
+    return <DateSetter {...sharedProps} />
+  } 
+    */
+  
+  /*
+  else if (inputMode = DATE_INPUT_MODES.TEN_YEAR) {
+    return <TenYearPeriodSetter {...sharedProps} />
+  } else {
+    return <DefaultPeriodSetter {...sharedProps} />
+  }
+    */
+}
+
+/*
+function PeriodSetterOld(props) {
+  const { metadata, startDate, endDate, setStartDate, setEndDate, inputMode } = props;
+
+
+
   let dateSelectButtonLabel = "";
   const isFullYearSet =
     checkBoundaryDate(startDate, "start") && checkBoundaryDate(endDate, "end");
@@ -278,16 +325,7 @@ function PeriodSetter(props) {
     >
       <Segmented
         block
-        options={[
-          {
-            label: "Yearly",
-            value: "yearly",
-          },
-          {
-            label: "Advanced",
-            value: "date",
-          },
-        ]}
+        options={MODES}
         width="100%"
         onChange={handleSegmentedChange}
         style={{
@@ -325,8 +363,9 @@ function PeriodSetter(props) {
     </Popover>
   );
 }
+  */
 
-function YearSetter(props) {
+function YearPeriodSetter(props) {
   const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
 
   return (

From be226a343da5033ed25af13c39436ff3eb633ef1 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 00:53:54 +0200
Subject: [PATCH 05/31] feat: Input mode selector

---
 src/pages/policy/input/ParameterEditor.jsx | 50 +++++++++++++++++++++-
 1 file changed, 49 insertions(+), 1 deletion(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 8c5d194bf..fc29cbcee 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -6,6 +6,7 @@ import {
   DatePicker,
   InputNumber,
   Popover,
+  Radio,
   Space,
   Switch,
   Tooltip,
@@ -571,9 +572,56 @@ function AdvancedValueSetter(props) {
 }
 
 function SettingsPanel() {
+
+  const modeOptions = [
+    {
+      label: "Default",
+      value: DATE_INPUT_MODES.DEFAULT
+    },
+    {
+      label: "Yearly",
+      value: DATE_INPUT_MODES.YEARLY
+    },
+    {
+      label: "Date",
+      value: DATE_INPUT_MODES.DATE
+    },
+    {
+      label: "10-Year",
+      value: DATE_INPUT_MODES.TEN_YEAR
+    }
+  ]
+
+  const popoverContent = (
+    <div
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "flex-start",
+        justifyContent: "flex-start",
+      }}
+    >
+      <p
+        style={{
+          margin: 0,
+          fontSize: "0.8rem",
+          marginBottom: 0,
+          paddingBottom: 0,
+          color: style.colors.DARK_GRAY
+        }}
+      >Input Mode</p>
+      <Radio.Group 
+        optionType="button" 
+        options={modeOptions} 
+        defaultValue={modeOptions[0].value}
+        buttonStyle="solid"
+      />
+    </div>
+  );
+
   return (
     <Popover 
-      content={<p>Test value</p>} 
+      content={popoverContent} 
       placement="bottomRight" 
       trigger="click"
     >

From d052a7586a690f395d4a3114e7126dee7d41acbc Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 00:56:22 +0200
Subject: [PATCH 06/31] feat: Add date input mode change handler

---
 src/pages/policy/input/ParameterEditor.jsx | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index fc29cbcee..1faafbcf1 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -571,7 +571,12 @@ function AdvancedValueSetter(props) {
   );
 }
 
-function SettingsPanel() {
+function SettingsPanel(props) {
+  const { setDateInputMode } = props;
+
+  const handleModeChange = (e) => {
+    setDateInputMode(e.target.value);
+  };
 
   const modeOptions = [
     {
@@ -615,6 +620,7 @@ function SettingsPanel() {
         options={modeOptions} 
         defaultValue={modeOptions[0].value}
         buttonStyle="solid"
+        onChange={handleModeChange}
       />
     </div>
   );

From e6c80d5d06111d05e596579b2b5c7766f541aa57 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 01:01:58 +0200
Subject: [PATCH 07/31] fix: Re-rig date period selector

---
 src/pages/policy/input/ParameterEditor.jsx | 35 ++++++++++++++--------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 1faafbcf1..1f0c16f36 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -268,7 +268,9 @@ function PeriodSetter(props) {
 
   if (inputMode === DATE_INPUT_MODES.YEARLY) {
     return <YearPeriodSetter {...sharedProps} />
-  } 
+  } else if (inputMode === DATE_INPUT_MODES.DATE) {
+    return <DatePeriodSetter {...sharedProps} />
+  }
   
   /*
   else if (inputMode = DATE_INPUT_MODES.DATE) {
@@ -304,18 +306,6 @@ function PeriodSetterOld(props) {
   }
 
   const dateSelector = (
-    <RangePicker
-      defaultValue={[moment(startDate), null]}
-      value={[moment(startDate), isEndForever ? null : moment(endDate)]}
-      onChange={(_, dateStrings) => {
-        setStartDate(dateStrings[0]);
-        setEndDate(dateStrings[1]);
-      }}
-      disabledDate={(date) =>
-        date.isBefore(minPossibleDate) || date.isAfter(maxPossibleDate)
-      }
-      separator="→"
-    />
   );
 
   const popoverContent = (
@@ -386,6 +376,25 @@ function YearPeriodSetter(props) {
   )
 }
 
+function DatePeriodSetter(props) {
+  const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
+
+  return (
+    <RangePicker
+      defaultValue={[moment(startDate), null]}
+      value={[moment(startDate), isEndForever ? null : moment(endDate)]}
+      onChange={(_, dateStrings) => {
+        setStartDate(dateStrings[0]);
+        setEndDate(dateStrings[1]);
+      }}
+      disabledDate={(date) =>
+        date.isBefore(minPossibleDate) || date.isAfter(maxPossibleDate)
+      }
+      separator="→"
+    />
+  );
+}
+
 function ValueSetter(props) {
   const {
     startDate,

From 9a556f7ac23530a236619d02cdab09f4cef9f0cb Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 01:55:34 +0200
Subject: [PATCH 08/31] feat: DefaultPeriodSetter

---
 src/pages/policy/input/ParameterEditor.jsx | 81 +++++++++++++++++++++-
 1 file changed, 80 insertions(+), 1 deletion(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 1f0c16f36..db6aaff42 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -7,6 +7,7 @@ import {
   InputNumber,
   Popover,
   Radio,
+  Select,
   Space,
   Switch,
   Tooltip,
@@ -27,6 +28,7 @@ import { cmpDates, nextDay, prevDay } from "lang/stringDates";
 import moment from "dayjs";
 import { LeftOutlined, RightOutlined, SettingOutlined, UndoOutlined } from "@ant-design/icons";
 import style from "../../../style";
+import { defaultYear } from "../../../data/constants";
 const { RangePicker } = DatePicker;
 
 /**
@@ -67,6 +69,11 @@ export default function ParameterEditor(props) {
   const [paramChartWidth, setParamChartWidth] = useState(0);
   const [dateInputMode, setDateInputMode] = useState(DATE_INPUT_MODES.YEARLY);
 
+  useEffect(() => {
+    // eslint-disable-next-line no-console
+    console.log("startDate: ", startDate)
+  }, [startDate]);
+
   useEffect(() => {
     if (chartContainerRef.current) {
       // This piece of code may be unstable if items above Display are edited;
@@ -263,13 +270,17 @@ function PeriodSetter(props) {
     setEndDate,
     minPossibleDate,
     maxPossibleDate,
-    isEndForever
+    isEndForever,
+    possibleYears,
+    FOREVER_DATE
   };
 
   if (inputMode === DATE_INPUT_MODES.YEARLY) {
     return <YearPeriodSetter {...sharedProps} />
   } else if (inputMode === DATE_INPUT_MODES.DATE) {
     return <DatePeriodSetter {...sharedProps} />
+  } else {
+    return <DefaultPeriodSetter {...sharedProps} />
   }
   
   /*
@@ -356,6 +367,74 @@ function PeriodSetterOld(props) {
 }
   */
 
+function DefaultPeriodSetter(props) {
+  const {
+    startDate,
+    setStartDate,
+    setEndDate,
+    possibleYears,
+    FOREVER_DATE
+  } = props;
+
+  let defaultStartYear = null;
+  if (startDate) {
+    defaultStartYear = new Date(startDate).getFullYear();
+  } else if (possibleYears.includes(defaultYear)) {
+    defaultStartYear = defaultYear;
+  } else {
+    defaultStartYear = possibleYears[0];
+  }
+
+  // When this component mounts, set the start date to Jan. 1 of
+  // either the reform year or the default year, and set end to FOREVER_DATE
+  useEffect(() => {
+    setStartDate(String(defaultStartYear).concat("-01-01"));
+    setEndDate(FOREVER_DATE);
+  }, [FOREVER_DATE, defaultStartYear, setStartDate, setEndDate]);
+
+  // eslint-disable-next-line no-console
+  console.log(defaultStartYear);
+
+  function handleStartYearChange(value) {
+    setStartDate(String(value).concat("-01-01"));
+  }
+
+  // Manipulate possibleYears Array-type into options
+  // Array of Object-types for the Select component
+  const options = possibleYears.map((year) => {
+    return {
+      label: year,
+      value: year
+    };
+  });
+
+  return (
+    <div
+      style={{
+        width: "100%",
+        display: "flex",
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "flex-start",
+        // The below keeps the font in line with
+        // the selector components
+        fontSize: "14px",
+        padding: "0 12px",
+        gap: "4px"
+      }}
+    >
+      <p style={{marginBottom: 0}}>from</p>
+      <Select
+        options={options}
+        defaultValue={defaultStartYear}
+        onChange={handleStartYearChange}
+      />
+      <p style={{marginBottom: 0}}>onward:</p>
+    </div>
+  );
+
+}
+
 function YearPeriodSetter(props) {
   const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
 

From 241f0363e2853385102b5edb387144fcb8a8a7ef Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 01:57:40 +0200
Subject: [PATCH 09/31] fix: Tweaks

---
 src/pages/policy/input/ParameterEditor.jsx | 23 ++--------------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index db6aaff42..7c25d06b3 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -67,12 +67,7 @@ export default function ParameterEditor(props) {
   const [startDate, setStartDate] = useState(defaultStartDate);
   const [endDate, setEndDate] = useState(defaultEndDate);
   const [paramChartWidth, setParamChartWidth] = useState(0);
-  const [dateInputMode, setDateInputMode] = useState(DATE_INPUT_MODES.YEARLY);
-
-  useEffect(() => {
-    // eslint-disable-next-line no-console
-    console.log("startDate: ", startDate)
-  }, [startDate]);
+  const [dateInputMode, setDateInputMode] = useState(DATE_INPUT_MODES.DEFAULT);
 
   useEffect(() => {
     if (chartContainerRef.current) {
@@ -168,17 +163,6 @@ export default function ParameterEditor(props) {
                 setEndDate={setEndDate}
                 inputMode={dateInputMode}
               />
-              {startDate !== defaultStartDate || endDate !== defaultEndDate ? (
-                <Button
-                  icon={<UndoOutlined />}
-                  onClick={() => {
-                    setStartDate(defaultStartDate);
-                    setEndDate(defaultEndDate);
-                  }}
-                />
-              ) : (
-                <Button icon={<UndoOutlined />} disabled />
-              )}
             </Space.Compact>
             <ValueSetter
               startDate={startDate}
@@ -392,9 +376,6 @@ function DefaultPeriodSetter(props) {
     setEndDate(FOREVER_DATE);
   }, [FOREVER_DATE, defaultStartYear, setStartDate, setEndDate]);
 
-  // eslint-disable-next-line no-console
-  console.log(defaultStartYear);
-
   function handleStartYearChange(value) {
     setStartDate(String(value).concat("-01-01"));
   }
@@ -420,7 +401,7 @@ function DefaultPeriodSetter(props) {
         // the selector components
         fontSize: "14px",
         padding: "0 12px",
-        gap: "4px"
+        gap: "10px"
       }}
     >
       <p style={{marginBottom: 0}}>from</p>

From 1849838e6406d64bb53c7842450504324ddf2f12 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 21:56:07 +0200
Subject: [PATCH 10/31] feat: Skeleton of ten-year input method

---
 src/pages/policy/input/ParameterEditor.jsx | 221 ++++++++++++++++++++-
 1 file changed, 214 insertions(+), 7 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 7c25d06b3..cfa9f9a10 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -162,6 +162,8 @@ export default function ParameterEditor(props) {
                 setStartDate={setStartDate}
                 setEndDate={setEndDate}
                 inputMode={dateInputMode}
+                parameterName={parameterName}
+                reformMap={reformMap}
               />
             </Space.Compact>
             <ValueSetter
@@ -232,7 +234,9 @@ function PeriodSetter(props) {
     startDate,
     endDate,
     setStartDate,
-    setEndDate
+    setEndDate,
+    parameterName,
+    reformMap,
   } = props;
   
   const FOREVER_DATE = String(defaultForeverYear).concat("-12-31");
@@ -259,12 +263,21 @@ function PeriodSetter(props) {
     FOREVER_DATE
   };
 
-  if (inputMode === DATE_INPUT_MODES.YEARLY) {
-    return <YearPeriodSetter {...sharedProps} />
-  } else if (inputMode === DATE_INPUT_MODES.DATE) {
-    return <DatePeriodSetter {...sharedProps} />
-  } else {
-    return <DefaultPeriodSetter {...sharedProps} />
+  const tenYearProps = {
+    parameterName,
+    metadata,
+    reformMap
+  };
+
+  switch (inputMode) {
+    case DATE_INPUT_MODES.YEARLY:
+      return <YearPeriodSetter {...sharedProps} />;
+    case DATE_INPUT_MODES.DATE:
+      return <DatePeriodSetter {...sharedProps} />;
+    case DATE_INPUT_MODES.TEN_YEAR:
+      return <TenYearPeriodSetter {...sharedProps} {...tenYearProps} />;
+    default:
+      return <DefaultPeriodSetter {...sharedProps} />;
   }
   
   /*
@@ -455,6 +468,200 @@ function DatePeriodSetter(props) {
   );
 }
 
+function TenYearPeriodSetter(props) {
+  const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, reformMap, metadata } = props;
+
+  // Handler that iterates over each entry, validates that
+  // all values are valid, then updates each value one by one
+
+  // Iterate over possibleYears, beginning with
+  // defaultYear, and return up to 10 input
+  // components
+  const yearInputs = possibleYears.map((year, index) => {
+    if (year >= defaultYear && year <= defaultYear + 9) {
+      return (
+        <div
+          key={String(year).concat("-input")}
+          style={{
+            display: "flex",
+            flexDirection: "row",
+            alignItems: "center",
+            justifyContent: "flex-start",
+            gap: "10px",
+            fontSize: "14px",
+            padding: "0 12px",
+          }}
+        >
+          <p style={{marginBottom: 0}}>{year}:</p>
+          <OneYearValueSetter 
+            year={year}
+            parameterName={parameterName}
+            metadata={metadata}
+            reformMap={reformMap}
+          />
+        </div>
+      );
+    }
+  });
+
+  // Submit button (no setting without clicking)
+
+  return (
+    <div
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        gap: "10px",
+      }}
+    >
+      {yearInputs}
+      <Button
+        type="primary"
+        style={{
+          width: "max-content",
+        }}
+      >
+        Submit
+      </Button>
+    </div>
+  );
+}
+
+function OneYearValueSetter(props) {
+  const {
+    /*
+    startDate,
+    endDate,
+    */
+    year,
+    parameterName,
+    metadata,
+    reformMap,
+    /*
+    baseMap,
+    */
+    policy,
+  } = props;
+
+  const startDate = String(year).concat("-01-01");
+  const endDate = String(year).concat("-12-31");
+
+  const startValue = reformMap.get(startDate);
+  // const [searchParams, setSearchParams] = useSearchParams();
+  const [value, setValue] = useState(startValue);
+  const parameter = metadata.parameters[parameterName];
+
+  function changeHandler(value) {
+    /*
+    reformMap.set(startDate, nextDay(endDate), value);
+    let data = {};
+    reformMap.minus(baseMap).forEach(([k1, k2, v]) => {
+      data[`${k1}.${prevDay(k2)}`] = v;
+    });
+    const newReforms = { ...policy.reform.data };
+    if (
+      Object.keys(data).length === 0 &&
+      Object.keys(newReforms).length === 1
+    ) {
+      let newSearch = copySearchParams(searchParams);
+      newSearch.delete("reform");
+      setSearchParams(newSearch);
+    } else {
+      newReforms[parameterName] = data;
+      getNewPolicyId(metadata.countryId, newReforms).then((result) => {
+        if (result.status !== "ok") {
+          console.error(
+            "ParameterEditor: In attempting to fetch new " +
+              "policy, the following error occurred: " +
+              result.message,
+          );
+        } else {
+          let newSearch = copySearchParams(searchParams);
+          newSearch.set("reform", result.policy_id);
+          setSearchParams(newSearch);
+        }
+      });
+    }
+    */
+  }
+
+  const isPercent = parameter.unit === "/1";
+  const scale = isPercent ? 100 : 1;
+  const isCurrency = Object.keys(currencyMap).includes(parameter.unit);
+  const maximumFractionDigits = isCurrency ? 2 : 16;
+
+  // This is necessary because technically, OneYearValueSetter does not
+  // unmount when we change between parameters, leading to the possibility
+  // for a stale "value" state in this controlled component
+  useEffect(() => {
+    setValue(Number(startValue) * scale);
+  }, [parameterName, startValue, scale]);
+
+  if (parameter.unit === "bool" || parameter.unit === "abolition") {
+    return (
+      <div style={{ padding: 10 }}>
+        <Switch
+          key={"input for" + parameter.parameter}
+          defaultChecked={startValue}
+          onChange={(value) => changeHandler(!!value)}
+        />
+      </div>
+    );
+  } else {
+    return (
+      <Space.Compact block>
+        <InputNumber
+          style={{
+            width: "125px",
+          }}
+          key={"input for" + parameter.parameter}
+          {...(isCurrency
+            ? {
+                addonBefore: currencyMap[parameter.unit],
+              }
+            : {})}
+          {...(isPercent
+            ? {
+                addonAfter: "%",
+              }
+            : {})}
+          formatter={(value, { userTyping }) => {
+            const n = +value;
+            const isInteger = Number.isInteger(n);
+            return n.toLocaleString(localeCode(metadata.countryId), {
+              minimumFractionDigits: userTyping || isInteger ? 0 : 2,
+              maximumFractionDigits: userTyping ? 16 : maximumFractionDigits,
+            });
+          }}
+          defaultValue={Number(startValue) * scale}
+          value={value}
+          onChange={(value) => setValue(value)}
+          /*
+          onPressEnter={() => {
+            changeHandler(+value.toFixed(maximumFractionDigits) / scale);
+          }}
+          */
+        />
+        {!isPercent && (
+          <AdvancedValueSetter
+            changeHandler={changeHandler}
+            setValue={setValue}
+          />
+        )}
+      </Space.Compact>
+    );
+  }
+  /*
+  return (
+    <InputNumber
+      style={{
+        width: "125px",
+      }}
+    />
+  );
+  */
+}
+
 function ValueSetter(props) {
   const {
     startDate,

From b3f367efe2da70a9cdf90a88abc939aeaf321061 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 22:26:57 +0200
Subject: [PATCH 11/31] feat: Stateful logic for ten-year input values

---
 src/pages/policy/input/ParameterEditor.jsx | 67 ++++++++++++++++------
 1 file changed, 50 insertions(+), 17 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index cfa9f9a10..4d94dd53c 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -471,14 +471,44 @@ function DatePeriodSetter(props) {
 function TenYearPeriodSetter(props) {
   const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, reformMap, metadata } = props;
 
+  const NUMBER_OF_YEARS = 10;
+  const [valueMap, setValueMap] = useState(populateValueMap());
+
+  // Populate map before rendering anything
+  function populateValueMap() {
+
+    const valueMap = new Map();
+    possibleYears.forEach((year) => {
+      if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
+        const startDate = String(year).concat("-01-01");
+        const startValue = reformMap.get(startDate);
+        console.log(year, startDate, startValue);
+        valueMap.set(year, startValue);
+      }
+    });
+    return valueMap;
+  }
+
+  // This is necessary because technically, TenYearPeriodSetter does not
+  // unmount when we change between parameters, leading to the possibility
+  // for a stale "value" state in this controlled component
+  useEffect(() => {
+    setValueMap(populateValueMap());
+  }, [parameterName]);
+
   // Handler that iterates over each entry, validates that
   // all values are valid, then updates each value one by one
 
   // Iterate over possibleYears, beginning with
   // defaultYear, and return up to 10 input
   // components
-  const yearInputs = possibleYears.map((year, index) => {
-    if (year >= defaultYear && year <= defaultYear + 9) {
+  const yearInputs = possibleYears.map((year) => {
+    if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
+
+      const startDate = String(year).concat("-01-01");
+      const startValue = reformMap.get(startDate);
+      // setValueMap((prev) => prev.set(year, startValue));
+
       return (
         <div
           key={String(year).concat("-input")}
@@ -498,6 +528,8 @@ function TenYearPeriodSetter(props) {
             parameterName={parameterName}
             metadata={metadata}
             reformMap={reformMap}
+            valueMap={valueMap}
+            setValueMap={setValueMap}
           />
         </div>
       );
@@ -536,7 +568,9 @@ function OneYearValueSetter(props) {
     year,
     parameterName,
     metadata,
-    reformMap,
+    // reformMap,
+    valueMap,
+    setValueMap,
     /*
     baseMap,
     */
@@ -544,14 +578,19 @@ function OneYearValueSetter(props) {
   } = props;
 
   const startDate = String(year).concat("-01-01");
-  const endDate = String(year).concat("-12-31");
+  // const endDate = String(year).concat("-12-31");
 
-  const startValue = reformMap.get(startDate);
+  const startValue = valueMap.get(startDate);
   // const [searchParams, setSearchParams] = useSearchParams();
-  const [value, setValue] = useState(startValue);
+  // const [value, setValue] = useState(startValue);
   const parameter = metadata.parameters[parameterName];
 
   function changeHandler(value) {
+    setValueMap((prev) => {
+      const newMap = new Map(prev);
+      newMap.set(year, value);
+      return newMap;
+    });
     /*
     reformMap.set(startDate, nextDay(endDate), value);
     let data = {};
@@ -590,18 +629,12 @@ function OneYearValueSetter(props) {
   const isCurrency = Object.keys(currencyMap).includes(parameter.unit);
   const maximumFractionDigits = isCurrency ? 2 : 16;
 
-  // This is necessary because technically, OneYearValueSetter does not
-  // unmount when we change between parameters, leading to the possibility
-  // for a stale "value" state in this controlled component
-  useEffect(() => {
-    setValue(Number(startValue) * scale);
-  }, [parameterName, startValue, scale]);
 
   if (parameter.unit === "bool" || parameter.unit === "abolition") {
     return (
       <div style={{ padding: 10 }}>
         <Switch
-          key={"input for" + parameter.parameter}
+          key={"input for" + parameter.parameter + year}
           defaultChecked={startValue}
           onChange={(value) => changeHandler(!!value)}
         />
@@ -614,7 +647,7 @@ function OneYearValueSetter(props) {
           style={{
             width: "125px",
           }}
-          key={"input for" + parameter.parameter}
+          key={"input for" + parameter.parameter + year}
           {...(isCurrency
             ? {
                 addonBefore: currencyMap[parameter.unit],
@@ -634,8 +667,8 @@ function OneYearValueSetter(props) {
             });
           }}
           defaultValue={Number(startValue) * scale}
-          value={value}
-          onChange={(value) => setValue(value)}
+          value={valueMap.get(year)}
+          onChange={changeHandler}
           /*
           onPressEnter={() => {
             changeHandler(+value.toFixed(maximumFractionDigits) / scale);
@@ -645,7 +678,7 @@ function OneYearValueSetter(props) {
         {!isPercent && (
           <AdvancedValueSetter
             changeHandler={changeHandler}
-            setValue={setValue}
+            setValue={(value) => setValueMap((prev) => prev.set(year, value))}
           />
         )}
       </Space.Compact>

From 036a5bc8a141e548864372551b652f0a2377b8d8 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 22:30:33 +0200
Subject: [PATCH 12/31] fix: Minor fixes, remove old code

---
 src/pages/policy/input/ParameterEditor.jsx | 100 +--------------------
 1 file changed, 1 insertion(+), 99 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 4d94dd53c..d2b6db653 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -279,91 +279,8 @@ function PeriodSetter(props) {
     default:
       return <DefaultPeriodSetter {...sharedProps} />;
   }
-  
-  /*
-  else if (inputMode = DATE_INPUT_MODES.DATE) {
-    return <DateSetter {...sharedProps} />
-  } 
-    */
-  
-  /*
-  else if (inputMode = DATE_INPUT_MODES.TEN_YEAR) {
-    return <TenYearPeriodSetter {...sharedProps} />
-  } else {
-    return <DefaultPeriodSetter {...sharedProps} />
-  }
-    */
 }
 
-/*
-function PeriodSetterOld(props) {
-  const { metadata, startDate, endDate, setStartDate, setEndDate, inputMode } = props;
-
-
-
-  let dateSelectButtonLabel = "";
-  const isFullYearSet =
-    checkBoundaryDate(startDate, "start") && checkBoundaryDate(endDate, "end");
-
-  if (!isFullYearSet) {
-    dateSelectButtonLabel = `from ${moment(startDate).format("MMMM Do, YYYY")} to ${moment(endDate).format("MMMM Do, YYYY")}:`;
-  } else if (isEndForever) {
-    dateSelectButtonLabel = `from ${moment(startDate).year()} onward:`;
-  } else {
-    dateSelectButtonLabel = `from ${moment(startDate).year()} to ${moment(endDate).year()}:`;
-  }
-
-  const dateSelector = (
-  );
-
-  const popoverContent = (
-    <div
-      style={{
-        width: "100%",
-      }}
-    >
-      <Segmented
-        block
-        options={MODES}
-        width="100%"
-        onChange={handleSegmentedChange}
-        style={{
-          marginBottom: "10px",
-        }}
-      />
-      {visibleDateSelector === "yearly" ? 
-          <YearSetter 
-            startDate={startDate}
-            endDate={endDate}
-            setStartDate={setStartDate}
-            setEndDate={setEndDate}
-            minPossibleDate={minPossibleDate}
-            maxPossibleDate={maxPossibleDate}
-            isEndForever={isEndForever}
-          />
-           : dateSelector}
-    </div>
-  );
-
-  return (
-    <Popover trigger="click" content={popoverContent} placement="bottom">
-      <Tooltip title="Click to edit parameter timespan">
-        <Space.Compact>
-          <Button
-            type="default"
-            style={{
-              width: "max-content",
-            }}
-          >
-            {dateSelectButtonLabel}
-          </Button>
-        </Space.Compact>
-      </Tooltip>
-    </Popover>
-  );
-}
-  */
-
 function DefaultPeriodSetter(props) {
   const {
     startDate,
@@ -482,7 +399,6 @@ function TenYearPeriodSetter(props) {
       if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
         const startDate = String(year).concat("-01-01");
         const startValue = reformMap.get(startDate);
-        console.log(year, startDate, startValue);
         valueMap.set(year, startValue);
       }
     });
@@ -505,10 +421,6 @@ function TenYearPeriodSetter(props) {
   const yearInputs = possibleYears.map((year) => {
     if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
 
-      const startDate = String(year).concat("-01-01");
-      const startValue = reformMap.get(startDate);
-      // setValueMap((prev) => prev.set(year, startValue));
-
       return (
         <div
           key={String(year).concat("-input")}
@@ -629,7 +541,6 @@ function OneYearValueSetter(props) {
   const isCurrency = Object.keys(currencyMap).includes(parameter.unit);
   const maximumFractionDigits = isCurrency ? 2 : 16;
 
-
   if (parameter.unit === "bool" || parameter.unit === "abolition") {
     return (
       <div style={{ padding: 10 }}>
@@ -667,7 +578,7 @@ function OneYearValueSetter(props) {
             });
           }}
           defaultValue={Number(startValue) * scale}
-          value={valueMap.get(year)}
+          value={valueMap.get(year) * scale}
           onChange={changeHandler}
           /*
           onPressEnter={() => {
@@ -684,15 +595,6 @@ function OneYearValueSetter(props) {
       </Space.Compact>
     );
   }
-  /*
-  return (
-    <InputNumber
-      style={{
-        width: "125px",
-      }}
-    />
-  );
-  */
 }
 
 function ValueSetter(props) {

From 7de110139508b47524c5002797e12ac5d677f84d Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 22:53:09 +0200
Subject: [PATCH 13/31] feat: Create new policy using ten-year input

---
 src/pages/policy/input/ParameterEditor.jsx | 83 +++++++++++++---------
 1 file changed, 48 insertions(+), 35 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index d2b6db653..21f8c26fe 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -163,7 +163,9 @@ export default function ParameterEditor(props) {
                 setEndDate={setEndDate}
                 inputMode={dateInputMode}
                 parameterName={parameterName}
+                baseMap={baseMap}
                 reformMap={reformMap}
+                policy={policy}
               />
             </Space.Compact>
             <ValueSetter
@@ -236,7 +238,9 @@ function PeriodSetter(props) {
     setStartDate,
     setEndDate,
     parameterName,
+    baseMap,
     reformMap,
+    policy
   } = props;
   
   const FOREVER_DATE = String(defaultForeverYear).concat("-12-31");
@@ -266,7 +270,9 @@ function PeriodSetter(props) {
   const tenYearProps = {
     parameterName,
     metadata,
-    reformMap
+    baseMap,
+    reformMap,
+    policy
   };
 
   switch (inputMode) {
@@ -386,10 +392,11 @@ function DatePeriodSetter(props) {
 }
 
 function TenYearPeriodSetter(props) {
-  const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, reformMap, metadata } = props;
+  const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, baseMap, reformMap, metadata, policy } = props;
 
   const NUMBER_OF_YEARS = 10;
   const [valueMap, setValueMap] = useState(populateValueMap());
+  const [searchParams, setSearchParams] = useSearchParams();
 
   // Populate map before rendering anything
   function populateValueMap() {
@@ -414,6 +421,44 @@ function TenYearPeriodSetter(props) {
 
   // Handler that iterates over each entry, validates that
   // all values are valid, then updates each value one by one
+  function handleSubmit() {
+
+    let data = {}
+    for (const [year, value] of valueMap) {
+      const startDate = String(year).concat("-01-01");
+      const endDate = String(year).concat("-12-31");
+      reformMap.set(startDate, nextDay(endDate), value);
+      data = {};
+      reformMap.minus(baseMap).forEach(([k1, k2, v]) => {
+        data[`${k1}.${prevDay(k2)}`] = v;
+      }); 
+    }
+
+    const newReforms = { ...policy.reform.data };
+    if (
+      Object.keys(data).length === 0 &&
+      Object.keys(newReforms).length === 1
+    ) {
+      let newSearch = copySearchParams(searchParams);
+      newSearch.delete("reform");
+      setSearchParams(newSearch);
+    } else {
+      newReforms[parameterName] = data;
+      getNewPolicyId(metadata.countryId, newReforms).then((result) => {
+        if (result.status !== "ok") {
+          console.error(
+            "ParameterEditor: In attempting to fetch new " +
+              "policy, the following error occurred: " +
+              result.message,
+          );
+        } else {
+          let newSearch = copySearchParams(searchParams);
+          newSearch.set("reform", result.policy_id);
+          setSearchParams(newSearch);
+        }
+      });
+    }
+  }
 
   // Iterate over possibleYears, beginning with
   // defaultYear, and return up to 10 input
@@ -448,8 +493,6 @@ function TenYearPeriodSetter(props) {
     }
   });
 
-  // Submit button (no setting without clicking)
-
   return (
     <div
       style={{
@@ -464,6 +507,7 @@ function TenYearPeriodSetter(props) {
         style={{
           width: "max-content",
         }}
+        onClick={handleSubmit}
       >
         Submit
       </Button>
@@ -503,37 +547,6 @@ function OneYearValueSetter(props) {
       newMap.set(year, value);
       return newMap;
     });
-    /*
-    reformMap.set(startDate, nextDay(endDate), value);
-    let data = {};
-    reformMap.minus(baseMap).forEach(([k1, k2, v]) => {
-      data[`${k1}.${prevDay(k2)}`] = v;
-    });
-    const newReforms = { ...policy.reform.data };
-    if (
-      Object.keys(data).length === 0 &&
-      Object.keys(newReforms).length === 1
-    ) {
-      let newSearch = copySearchParams(searchParams);
-      newSearch.delete("reform");
-      setSearchParams(newSearch);
-    } else {
-      newReforms[parameterName] = data;
-      getNewPolicyId(metadata.countryId, newReforms).then((result) => {
-        if (result.status !== "ok") {
-          console.error(
-            "ParameterEditor: In attempting to fetch new " +
-              "policy, the following error occurred: " +
-              result.message,
-          );
-        } else {
-          let newSearch = copySearchParams(searchParams);
-          newSearch.set("reform", result.policy_id);
-          setSearchParams(newSearch);
-        }
-      });
-    }
-    */
   }
 
   const isPercent = parameter.unit === "/1";

From 7014ad54c24565c2617b222788531fc7fd5c1f2f Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 23:24:02 +0200
Subject: [PATCH 14/31] fix: Fixes to policy creation for ten-year component

---
 src/pages/policy/input/ParameterEditor.jsx | 36 ++++++----------------
 1 file changed, 9 insertions(+), 27 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 21f8c26fe..98a4f8029 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -517,43 +517,30 @@ function TenYearPeriodSetter(props) {
 
 function OneYearValueSetter(props) {
   const {
-    /*
-    startDate,
-    endDate,
-    */
     year,
     parameterName,
     metadata,
-    // reformMap,
     valueMap,
     setValueMap,
-    /*
-    baseMap,
-    */
-    policy,
   } = props;
 
-  const startDate = String(year).concat("-01-01");
-  // const endDate = String(year).concat("-12-31");
-
-  const startValue = valueMap.get(startDate);
-  // const [searchParams, setSearchParams] = useSearchParams();
-  // const [value, setValue] = useState(startValue);
+  const startValue = valueMap.get(year);
   const parameter = metadata.parameters[parameterName];
 
+  const isPercent = parameter.unit === "/1";
+  const scale = isPercent ? 100 : 1;
+  const isCurrency = Object.keys(currencyMap).includes(parameter.unit);
+  const maximumFractionDigits = isCurrency ? 2 : 16;
+
   function changeHandler(value) {
     setValueMap((prev) => {
+      const scaledValue = +value.toFixed(maximumFractionDigits) / scale;
       const newMap = new Map(prev);
-      newMap.set(year, value);
+      newMap.set(year, scaledValue);
       return newMap;
     });
   }
 
-  const isPercent = parameter.unit === "/1";
-  const scale = isPercent ? 100 : 1;
-  const isCurrency = Object.keys(currencyMap).includes(parameter.unit);
-  const maximumFractionDigits = isCurrency ? 2 : 16;
-
   if (parameter.unit === "bool" || parameter.unit === "abolition") {
     return (
       <div style={{ padding: 10 }}>
@@ -590,14 +577,9 @@ function OneYearValueSetter(props) {
               maximumFractionDigits: userTyping ? 16 : maximumFractionDigits,
             });
           }}
-          defaultValue={Number(startValue) * scale}
+          defaultValue={startValue * scale}
           value={valueMap.get(year) * scale}
           onChange={changeHandler}
-          /*
-          onPressEnter={() => {
-            changeHandler(+value.toFixed(maximumFractionDigits) / scale);
-          }}
-          */
         />
         {!isPercent && (
           <AdvancedValueSetter

From 3fd8f860c92051fa8dc1de5989bbf74f392135bf Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 23:26:17 +0200
Subject: [PATCH 15/31] feat: Conditionally display ValueSetter

---
 src/pages/policy/input/ParameterEditor.jsx | 30 +++++++++++++---------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 98a4f8029..145afe2c1 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -168,18 +168,24 @@ export default function ParameterEditor(props) {
                 policy={policy}
               />
             </Space.Compact>
-            <ValueSetter
-              startDate={startDate}
-              endDate={endDate}
-              parameterName={parameterName}
-              policy={policy}
-              metadata={metadata}
-              reformMap={reformMap}
-              baseMap={baseMap}
-            />
-            <SettingsPanel 
-              setDateInputMode={setDateInputMode}
-            />
+            {
+              dateInputMode !== DATE_INPUT_MODES.TEN_YEAR && (
+                <>
+                  <ValueSetter
+                    startDate={startDate}
+                    endDate={endDate}
+                    parameterName={parameterName}
+                    policy={policy}
+                    metadata={metadata}
+                    reformMap={reformMap}
+                    baseMap={baseMap}
+                  />
+                  <SettingsPanel 
+                    setDateInputMode={setDateInputMode}
+                  />
+                </>
+              )
+            }
           </div>
         </div>
         {!parameter.economy && (

From d476b5eefc06c7f3e081fc2e044660787c83ec56 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Fri, 18 Oct 2024 23:27:37 +0200
Subject: [PATCH 16/31] fix: Properly display SettingsPanel

---
 src/pages/policy/input/ParameterEditor.jsx | 26 ++++++++++------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 145afe2c1..8c9256a25 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -170,22 +170,20 @@ export default function ParameterEditor(props) {
             </Space.Compact>
             {
               dateInputMode !== DATE_INPUT_MODES.TEN_YEAR && (
-                <>
-                  <ValueSetter
-                    startDate={startDate}
-                    endDate={endDate}
-                    parameterName={parameterName}
-                    policy={policy}
-                    metadata={metadata}
-                    reformMap={reformMap}
-                    baseMap={baseMap}
-                  />
-                  <SettingsPanel 
-                    setDateInputMode={setDateInputMode}
-                  />
-                </>
+                <ValueSetter
+                  startDate={startDate}
+                  endDate={endDate}
+                  parameterName={parameterName}
+                  policy={policy}
+                  metadata={metadata}
+                  reformMap={reformMap}
+                  baseMap={baseMap}
+                />
               )
             }
+            <SettingsPanel 
+              setDateInputMode={setDateInputMode}
+            />
           </div>
         </div>
         {!parameter.economy && (

From 972cb9a510f807dd534e9a0a0935fc081c96162d Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Sat, 19 Oct 2024 00:21:23 +0200
Subject: [PATCH 17/31] fix: Improve design of infinity input

---
 src/pages/policy/input/ParameterEditor.jsx | 152 ++++++++++++---------
 1 file changed, 86 insertions(+), 66 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 8c9256a25..1e2e94628 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -26,7 +26,7 @@ import {
 import { IntervalMap } from "algorithms/IntervalMap";
 import { cmpDates, nextDay, prevDay } from "lang/stringDates";
 import moment from "dayjs";
-import { LeftOutlined, RightOutlined, SettingOutlined, UndoOutlined } from "@ant-design/icons";
+import { DownOutlined, EllipsisOutlined, FunctionOutlined, LeftOutlined, RightOutlined, SettingOutlined, UndoOutlined, UpOutlined } from "@ant-design/icons";
 import style from "../../../style";
 import { defaultYear } from "../../../data/constants";
 const { RangePicker } = DatePicker;
@@ -154,20 +154,18 @@ export default function ParameterEditor(props) {
               gap: "10px",
             }}
           >
-            <Space.Compact>
-              <PeriodSetter
-                metadata={metadata}
-                startDate={startDate}
-                endDate={endDate}
-                setStartDate={setStartDate}
-                setEndDate={setEndDate}
-                inputMode={dateInputMode}
-                parameterName={parameterName}
-                baseMap={baseMap}
-                reformMap={reformMap}
-                policy={policy}
-              />
-            </Space.Compact>
+            <PeriodSetter
+              metadata={metadata}
+              startDate={startDate}
+              endDate={endDate}
+              setStartDate={setStartDate}
+              setEndDate={setEndDate}
+              inputMode={dateInputMode}
+              parameterName={parameterName}
+              baseMap={baseMap}
+              reformMap={reformMap}
+              policy={policy}
+            />
             {
               dateInputMode !== DATE_INPUT_MODES.TEN_YEAR && (
                 <ValueSetter
@@ -713,70 +711,92 @@ function ValueSetter(props) {
 function AdvancedValueSetter(props) {
   const { changeHandler, setValue } = props;
 
-  const [isExpanded, setIsExpanded] = useState(false);
-
-  function handleExpand() {
-    setIsExpanded((prev) => !prev);
-  }
-
   function handleValueInput(value) {
     setValue(value);
     changeHandler(value);
   }
 
+  const popoverContent = (
+    <div
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "flex-start",
+        justifyContent: "flex-start",
+        width: "100%",
+      }}
+    >
+      <p
+        style={{
+          margin: 0,
+          fontSize: "0.8rem",
+          marginBottom: 0,
+          paddingBottom: 0,
+          color: style.colors.DARK_GRAY
+        }}
+      >Custom values</p>
+      <Button
+        style={{
+          fontSize: "14px",
+          aspectRatio: 1,
+          fontFamily: style.fonts.BODY_FONT,
+          marginBottom: "5px",
+          textAlign: "left",
+          width: "100%"
+        }}
+        onClick={() => handleValueInput(Infinity)}
+      >
+        <span
+          style={{
+            fontSize: "1.2rem"
+          }}
+        >
+          &infin;&nbsp;
+        </span>
+        Infinity
+      </Button>
+      <Button
+        style={{
+          fontSize: "14px",
+          aspectRatio: 1,
+          fontFamily: style.fonts.BODY_FONT,
+          textAlign: "left",
+          width: "100%"
+        }}
+        onClick={() => handleValueInput(-Infinity)}
+      >
+        <span
+          style={{
+            fontSize: "1.2rem"
+          }}
+        >
+          -&infin;&nbsp;
+        </span>
+        -Infinity
+      </Button>
+    </div>
+  );
+
   return (
     <>
-      {isExpanded ? (
-        <Space.Compact>
-          <Tooltip title="Infinity">
-            <Button
-              style={{
-                fontSize: "1.2rem",
-                aspectRatio: 1,
-                fontFamily: style.fonts.BODY_FONT,
-              }}
-              onClick={() => handleValueInput(Infinity)}
-            >
-              &infin;
-            </Button>
-          </Tooltip>
-          <Tooltip title="Negative infinity">
-            <Button
-              style={{
-                fontSize: "1.2rem",
-                aspectRatio: 1,
-                fontFamily: style.fonts.BODY_FONT,
-              }}
-              onClick={() => handleValueInput(-Infinity)}
-            >
-              -&infin;
-            </Button>
-          </Tooltip>
-          <Tooltip title="Close options">
-            <Button
-              style={{
-                aspectRatio: 1,
-                backgroundColor: style.colors.TEAL_LIGHT,
-              }}
-              onClick={handleExpand}
-            >
-              <LeftOutlined />
-            </Button>
-          </Tooltip>
-        </Space.Compact>
-      ) : (
-        <Tooltip title="More input options">
+      <Tooltip title="More input options">
+        <Popover 
+          content={popoverContent} 
+          placement="bottomRight" 
+          trigger="click"
+          overlayStyle={{
+            minWidth: "150px"
+          }}
+        >
           <Button
             style={{
               aspectRatio: 1,
-              backgroundColor: style.colors.TEAL_LIGHT,
             }}
-            onClick={handleExpand}
           >
-            <RightOutlined />
+            <EllipsisOutlined />
           </Button>
-        </Tooltip>
-      )}
+        </Popover>
+      </Tooltip>
     </>
   );
 }

From 52c9ea7e90d62247999c708d24aa8d62ad94488a Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Sat, 19 Oct 2024 01:12:42 +0200
Subject: [PATCH 18/31] fix: Improve styling

---
 src/pages/policy/input/ParameterEditor.jsx | 62 +++++++++++++++++-----
 1 file changed, 48 insertions(+), 14 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 1e2e94628..3808f5609 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -109,6 +109,8 @@ export default function ParameterEditor(props) {
     description = "";
   }
 
+  const gridColumns = dateInputMode === DATE_INPUT_MODES.TEN_YEAR ? "auto min-content" : "auto min-content min-content";
+
   return (
     <CenteredMiddleColumn
       marginTop="5%"
@@ -146,12 +148,12 @@ export default function ParameterEditor(props) {
           </p>
           <div
             style={{
-              width: "fit-content",
-              display: "flex",
-              flexDirection: "row",
-              justifyContent: "flex-start",
-              alignItems: "center",
-              gap: "10px",
+              width: "100%",
+              maxWidth: "480px",
+              minWidth: "430px",
+              display: "grid",
+              gridTemplateColumns: gridColumns,
+              gap: "10px"
             }}
           >
             <PeriodSetter
@@ -338,7 +340,7 @@ function DefaultPeriodSetter(props) {
         // The below keeps the font in line with
         // the selector components
         fontSize: "14px",
-        padding: "0 12px",
+        padding: "0 0 0 12px",
         gap: "10px"
       }}
     >
@@ -465,9 +467,9 @@ function TenYearPeriodSetter(props) {
   // Iterate over possibleYears, beginning with
   // defaultYear, and return up to 10 input
   // components
-  const yearInputs = possibleYears.map((year) => {
-    if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
-
+  const yearInputs = possibleYears.filter((year) => 
+    year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS
+  ).map((year) => {
       return (
         <div
           key={String(year).concat("-input")}
@@ -478,7 +480,6 @@ function TenYearPeriodSetter(props) {
             justifyContent: "flex-start",
             gap: "10px",
             fontSize: "14px",
-            padding: "0 12px",
           }}
         >
           <p style={{marginBottom: 0}}>{year}:</p>
@@ -492,18 +493,50 @@ function TenYearPeriodSetter(props) {
           />
         </div>
       );
-    }
-  });
+    });
+
+  // This will give us the first half of the year inputs (if NUMBER_OF_YEARS is even)
+  // or the first half, plus 1, if NUMBER_OF_YEARS is odd
+   const yearInputsLeft = yearInputs.slice(0, Math.ceil(NUMBER_OF_YEARS / 2));
+   const yearInputsRight = yearInputs.slice(Math.ceil(NUMBER_OF_YEARS / 2));
 
   return (
     <div
       style={{
         display: "flex",
         flexDirection: "column",
+        paddingLeft: "12px",
         gap: "10px",
       }}
     >
-      {yearInputs}
+      <div
+        style={{
+          display: "flex",
+          gap: "10px",
+          width: "100%",
+          flexDirection: "row",
+          justifyContent: "space-between",
+        }}
+      >
+        <div
+          style={{
+            display: "flex",
+            flexDirection: "column",
+            gap: "10px",
+          }}
+        >
+          {yearInputsLeft}
+        </div>
+        <div
+          style={{
+            display: "flex",
+            flexDirection: "column",
+            gap: "10px",
+          }}
+        >
+          {yearInputsRight}
+        </div>
+      </div>
       <Button
         type="primary"
         style={{
@@ -864,6 +897,7 @@ function SettingsPanel(props) {
       <Button
         style={{
           aspectRatio: 1,
+          width: "100%"
         }}
       >
         <SettingOutlined />

From 3539719b6043f27f75dbf2dd90c41f7321a49c89 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 17:55:29 +0200
Subject: [PATCH 19/31] fix: Divide up year inputs by number of possible years

---
 src/pages/policy/input/ParameterEditor.jsx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 3808f5609..60c722b5c 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -495,10 +495,10 @@ function TenYearPeriodSetter(props) {
       );
     });
 
-  // This will give us the first half of the year inputs (if NUMBER_OF_YEARS is even)
-  // or the first half, plus 1, if NUMBER_OF_YEARS is odd
-   const yearInputsLeft = yearInputs.slice(0, Math.ceil(NUMBER_OF_YEARS / 2));
-   const yearInputsRight = yearInputs.slice(Math.ceil(NUMBER_OF_YEARS / 2));
+  // This will give us the first half of the year inputs (if length of yearInputs is even)
+  // or the first half, plus 1, if length of yearInputs is odd
+   const yearInputsLeft = yearInputs.slice(0, Math.ceil(yearInputs.length / 2));
+   const yearInputsRight = yearInputs.slice(Math.ceil(yearInputs.length / 2));
 
   return (
     <div

From 582053ab123ea406bf3e9aa581e90c7d3f50ecbb Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 17:58:19 +0200
Subject: [PATCH 20/31] fix: Rename Ten-Year to Multi-Year

---
 src/pages/policy/input/ParameterEditor.jsx | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 60c722b5c..f99438138 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -45,7 +45,7 @@ const DATE_INPUT_MODES = {
   DEFAULT: "default",
   YEARLY: "yearly",
   DATE: "date",
-  TEN_YEAR: "ten-year"
+  MULTI_YEAR: "multi-year"
 };
 
 export default function ParameterEditor(props) {
@@ -109,7 +109,7 @@ export default function ParameterEditor(props) {
     description = "";
   }
 
-  const gridColumns = dateInputMode === DATE_INPUT_MODES.TEN_YEAR ? "auto min-content" : "auto min-content min-content";
+  const gridColumns = dateInputMode === DATE_INPUT_MODES.MULTI_YEAR ? "auto min-content" : "auto min-content min-content";
 
   return (
     <CenteredMiddleColumn
@@ -169,7 +169,7 @@ export default function ParameterEditor(props) {
               policy={policy}
             />
             {
-              dateInputMode !== DATE_INPUT_MODES.TEN_YEAR && (
+              dateInputMode !== DATE_INPUT_MODES.MULTI_YEAR && (
                 <ValueSetter
                   startDate={startDate}
                   endDate={endDate}
@@ -284,8 +284,8 @@ function PeriodSetter(props) {
       return <YearPeriodSetter {...sharedProps} />;
     case DATE_INPUT_MODES.DATE:
       return <DatePeriodSetter {...sharedProps} />;
-    case DATE_INPUT_MODES.TEN_YEAR:
-      return <TenYearPeriodSetter {...sharedProps} {...tenYearProps} />;
+    case DATE_INPUT_MODES.MULTI_YEAR:
+      return <MultiYearPeriodSetter {...sharedProps} {...tenYearProps} />;
     default:
       return <DefaultPeriodSetter {...sharedProps} />;
   }
@@ -395,7 +395,7 @@ function DatePeriodSetter(props) {
   );
 }
 
-function TenYearPeriodSetter(props) {
+function MultiYearPeriodSetter(props) {
   const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, baseMap, reformMap, metadata, policy } = props;
 
   const NUMBER_OF_YEARS = 10;
@@ -416,7 +416,7 @@ function TenYearPeriodSetter(props) {
     return valueMap;
   }
 
-  // This is necessary because technically, TenYearPeriodSetter does not
+  // This is necessary because technically, MultiYearPeriodSetter does not
   // unmount when we change between parameters, leading to the possibility
   // for a stale "value" state in this controlled component
   useEffect(() => {
@@ -855,8 +855,8 @@ function SettingsPanel(props) {
       value: DATE_INPUT_MODES.DATE
     },
     {
-      label: "10-Year",
-      value: DATE_INPUT_MODES.TEN_YEAR
+      label: "Multi-Year",
+      value: DATE_INPUT_MODES.MULTI_YEAR
     }
   ]
 

From bbadc8de9cb89f1375f3d6801bd67dec8e007520 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 18:00:51 +0200
Subject: [PATCH 21/31] fix: Change case of labels

---
 src/pages/policy/input/ParameterEditor.jsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index f99438138..b8eb20123 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -855,7 +855,7 @@ function SettingsPanel(props) {
       value: DATE_INPUT_MODES.DATE
     },
     {
-      label: "Multi-Year",
+      label: "Multi-year",
       value: DATE_INPUT_MODES.MULTI_YEAR
     }
   ]
@@ -877,7 +877,7 @@ function SettingsPanel(props) {
           paddingBottom: 0,
           color: style.colors.DARK_GRAY
         }}
-      >Input Mode</p>
+      >Input mode</p>
       <Radio.Group 
         optionType="button" 
         options={modeOptions} 

From c6e5f2120f8f54fda821a00005ddadf0a424dfc6 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 18:13:19 +0200
Subject: [PATCH 22/31] fix: Improve spacing

---
 src/pages/policy/input/ParameterEditor.jsx | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index b8eb20123..c8958c776 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -109,7 +109,7 @@ export default function ParameterEditor(props) {
     description = "";
   }
 
-  const gridColumns = dateInputMode === DATE_INPUT_MODES.MULTI_YEAR ? "auto min-content" : "auto min-content min-content";
+  const gridColumns = dateInputMode === DATE_INPUT_MODES.MULTI_YEAR ? "auto min-content" : "auto auto min-content";
 
   return (
     <CenteredMiddleColumn
@@ -149,11 +149,10 @@ export default function ParameterEditor(props) {
           <div
             style={{
               width: "100%",
-              maxWidth: "480px",
-              minWidth: "430px",
               display: "grid",
               gridTemplateColumns: gridColumns,
-              gap: "10px"
+              gap: "10px",
+              padding: "0px 50px 0px 12px"
             }}
           >
             <PeriodSetter
@@ -340,7 +339,6 @@ function DefaultPeriodSetter(props) {
         // The below keeps the font in line with
         // the selector components
         fontSize: "14px",
-        padding: "0 0 0 12px",
         gap: "10px"
       }}
     >
@@ -505,14 +503,13 @@ function MultiYearPeriodSetter(props) {
       style={{
         display: "flex",
         flexDirection: "column",
-        paddingLeft: "12px",
         gap: "10px",
       }}
     >
       <div
         style={{
           display: "flex",
-          gap: "10px",
+          gap: "20px",
           width: "100%",
           flexDirection: "row",
           justifyContent: "space-between",
@@ -591,7 +588,7 @@ function OneYearValueSetter(props) {
       <Space.Compact block>
         <InputNumber
           style={{
-            width: "125px",
+            width: "100%",
           }}
           key={"input for" + parameter.parameter + year}
           {...(isCurrency
@@ -702,7 +699,7 @@ function ValueSetter(props) {
       <Space.Compact block>
         <InputNumber
           style={{
-            width: "125px",
+            width: "100%",
           }}
           key={"input for" + parameter.parameter}
           {...(isCurrency

From ded758412fcd5b28fac6a6b222d368d04d42999c Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 20:03:28 +0200
Subject: [PATCH 23/31] fix: Remove deprecated key in TypeScript setup

---
 src/__tests__/algorithms/Bisection.test.js   | 135 +---
 src/__tests__/algorithms/IntervalMap.test.js | 708 +++++++++----------
 src/algorithms/Bisection.js                  |  44 +-
 src/algorithms/IntervalMap.js                | 281 ++++----
 tsconfig.json                                |   1 -
 5 files changed, 509 insertions(+), 660 deletions(-)

diff --git a/src/__tests__/algorithms/Bisection.test.js b/src/__tests__/algorithms/Bisection.test.js
index c02ae90c9..ea9434f42 100644
--- a/src/__tests__/algorithms/Bisection.test.js
+++ b/src/__tests__/algorithms/Bisection.test.js
@@ -1,110 +1,31 @@
 import { bisect } from "algorithms/Bisection";
 describe("bisection", function () {
-  test("small cases", function () {
-    expect(
-      bisect([], 1, function (a) {
-        return a - 1;
-      }),
-    ).toBe(0);
-    expect(
-      bisect([1], 1, function (a) {
-        return a - 1;
-      }),
-    ).toBe(0);
-    expect(
-      bisect([1], 2, function (a) {
-        return a - 2;
-      }),
-    ).toBe(1);
-    expect(
-      bisect(
-        [1],
-        1,
-        function (a) {
-          return a - 1;
-        },
-        0,
-        1,
-        true,
-      ),
-    ).toBe(1);
-  });
-  var a = [0, 1, 2, 3, 4, 5];
-  test.each(a)("identity", function (e) {
-    expect(
-      bisect(a, e, function (o) {
-        return o - e;
-      }),
-    ).toBe(e);
-  });
-  test.each(a)("successor 1", function (e) {
-    expect(
-      bisect(a, e + 0.5, function (o) {
-        return o - e - 0.5;
-      }),
-    ).toBe(e + 1);
-  });
-  test.each(a)("successor 2", function (e) {
-    expect(
-      bisect(
-        a,
-        e,
-        function (o) {
-          return o - e;
-        },
-        0,
-        a.length,
-        true,
-      ),
-    ).toBe(e + 1);
-  });
-  test.each(a)("successor 3", function (e) {
-    expect(
-      bisect(
-        a,
-        e + 0.5,
-        function (o) {
-          return o - e - 0.5;
-        },
-        0,
-        a.length,
-        true,
-      ),
-    ).toBe(e + 1);
-  });
-  test("duplicates", function () {
-    var a = [0, 1, 2, 3, 3, 3, 6, 7];
-    expect(
-      bisect(a, 3, function (e) {
-        return e - 3;
-      }),
-    ).toBe(3);
-    expect(
-      bisect(
-        a,
-        3,
-        function (e) {
-          return e - 3;
-        },
-        0,
-        a.length,
-        true,
-      ),
-    ).toBe(6);
-  });
-  test("unknown", function () {
-    var a = [-2, -1];
-    expect(
-      bisect(
-        a,
-        1,
-        function (e) {
-          return e - 1;
-        },
-        0,
-        a.length,
-        false,
-      ),
-    ).toBe(a.length);
-  });
+    test("small cases", function () {
+        expect(bisect([], 1, function (a) { return a - 1; })).toBe(0);
+        expect(bisect([1], 1, function (a) { return a - 1; })).toBe(0);
+        expect(bisect([1], 2, function (a) { return a - 2; })).toBe(1);
+        expect(bisect([1], 1, function (a) { return a - 1; }, 0, 1, true)).toBe(1);
+    });
+    var a = [0, 1, 2, 3, 4, 5];
+    test.each(a)("identity", function (e) {
+        expect(bisect(a, e, function (o) { return o - e; })).toBe(e);
+    });
+    test.each(a)("successor 1", function (e) {
+        expect(bisect(a, e + 0.5, function (o) { return o - e - 0.5; })).toBe(e + 1);
+    });
+    test.each(a)("successor 2", function (e) {
+        expect(bisect(a, e, function (o) { return o - e; }, 0, a.length, true)).toBe(e + 1);
+    });
+    test.each(a)("successor 3", function (e) {
+        expect(bisect(a, e + 0.5, function (o) { return o - e - 0.5; }, 0, a.length, true)).toBe(e + 1);
+    });
+    test("duplicates", function () {
+        var a = [0, 1, 2, 3, 3, 3, 6, 7];
+        expect(bisect(a, 3, function (e) { return e - 3; })).toBe(3);
+        expect(bisect(a, 3, function (e) { return e - 3; }, 0, a.length, true)).toBe(6);
+    });
+    test("unknown", function () {
+        var a = [-2, -1];
+        expect(bisect(a, 1, function (e) { return e - 1; }, 0, a.length, false)).toBe(a.length);
+    });
 });
diff --git a/src/__tests__/algorithms/IntervalMap.test.js b/src/__tests__/algorithms/IntervalMap.test.js
index cfd6a6473..e72de2775 100644
--- a/src/__tests__/algorithms/IntervalMap.test.js
+++ b/src/__tests__/algorithms/IntervalMap.test.js
@@ -1,392 +1,364 @@
 import { IntervalMap } from "algorithms/IntervalMap";
-var keyCmp = function (x, y) {
-  return x - y;
-};
-var valueEq = function (x, y) {
-  return x === y;
-};
+var keyCmp = function (x, y) { return x - y; };
+var valueEq = function (x, y) { return x === y; };
 function f(i) {
-  return String.fromCharCode(97 + i);
+    return String.fromCharCode(97 + i);
 }
 function array(n) {
-  var a = [];
-  for (var i = 0; i < n; i++) {
-    a.push([i, f(i)]);
-  }
-  return a;
+    var a = [];
+    for (var i = 0; i < n; i++) {
+        a.push([i, f(i)]);
+    }
+    return a;
 }
 function randArray(n, m) {
-  var rand = function () {
-    return Math.floor(Math.random() * m);
-  };
-  var a = [];
-  for (var i = 0; i < n; i++) {
-    a.push([i, f(rand())]);
-  }
-  return a;
+    var rand = function () { return Math.floor(Math.random() * m); };
+    var a = [];
+    for (var i = 0; i < n; i++) {
+        a.push([i, f(rand())]);
+    }
+    return a;
 }
 function keys(n) {
-  var a = [];
-  for (var i = 0; i < n; i++) {
-    a.push(i);
-  }
-  return a;
+    var a = [];
+    for (var i = 0; i < n; i++) {
+        a.push(i);
+    }
+    return a;
 }
 function hasDuplicates(a) {
-  var s = new Set(a);
-  return s.size < a.length;
+    var s = new Set(a);
+    return s.size < a.length;
 }
 function hasConsecutiveDuplicates(a) {
-  for (var i = 0; i + 1 < a.length; i++) {
-    if (a[i] === a[i + 1]) return true;
-  }
-  return false;
+    for (var i = 0; i + 1 < a.length; i++) {
+        if (a[i] === a[i + 1])
+            return true;
+    }
+    return false;
 }
 function isSorted(a) {
-  for (var i = 0; i + 1 < a.length; i++) {
-    if (a[i] > a[i + 1]) return false;
-  }
-  return true;
+    for (var i = 0; i + 1 < a.length; i++) {
+        if (a[i] > a[i + 1])
+            return false;
+    }
+    return true;
 }
 describe("construct", function () {
-  test("an empty map", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    expect(m.size()).toBe(0);
-    expect(m.keys()).toStrictEqual([]);
-    expect(m.values()).toStrictEqual([]);
-    expect(m.toArray()).toStrictEqual([]);
-  });
-  test.concurrent.each([5, 25, 125])(
-    "nonempty maps without repeated keys or values in initializer",
-    function (size) {
-      var a = array(size);
-      var m = new IntervalMap(a, keyCmp, valueEq);
-      expect(m.size()).toBe(size);
-      expect(m.toArray()).toStrictEqual(a);
-    },
-  );
-  test.concurrent.each([5, 25, 125])(
-    "nonempty maps with repeated keys in initializer",
-    function (size) {
-      var a = array(size);
-      a.concat(a);
-      var m = new IntervalMap(a, keyCmp, valueEq);
-      expect(hasDuplicates(m.keys())).toBe(false);
-      expect(m.size()).toBe(size);
-    },
-  );
-  test.concurrent.each([
-    [5, 2],
-    [5, 5],
-    [25, 5],
-    [25, 25],
-    [125, 5],
-  ])(
-    "nonempty maps with repeated values in initializer",
-    function (size, numValues) {
-      var a = randArray(size, numValues);
-      var m = new IntervalMap(a, keyCmp, valueEq);
-      expect(hasConsecutiveDuplicates(m.values())).toBe(false);
-      expect(m.size()).toBeLessThanOrEqual(size);
-    },
-  );
-  test.concurrent.each([5, 25, 125])(
-    "nonempty maps without unsorted initializer",
-    function (size) {
-      var a = array(size);
-      a.reverse();
-      var m = new IntervalMap(a, keyCmp, valueEq);
-      expect(isSorted(m.keys())).toBe(true);
-      expect(m.size()).toBe(size);
-    },
-  );
+    test("an empty map", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        expect(m.size()).toBe(0);
+        expect(m.keys()).toStrictEqual([]);
+        expect(m.values()).toStrictEqual([]);
+        expect(m.toArray()).toStrictEqual([]);
+    });
+    test.concurrent.each([5, 25, 125])("nonempty maps without repeated keys or values in initializer", function (size) {
+        var a = array(size);
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        expect(m.size()).toBe(size);
+        expect(m.toArray()).toStrictEqual(a);
+    });
+    test.concurrent.each([5, 25, 125])("nonempty maps with repeated keys in initializer", function (size) {
+        var a = array(size);
+        a.concat(a);
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        expect(hasDuplicates(m.keys())).toBe(false);
+        expect(m.size()).toBe(size);
+    });
+    test.concurrent.each([
+        [5, 2],
+        [5, 5],
+        [25, 5],
+        [25, 25],
+        [125, 5],
+    ])("nonempty maps with repeated values in initializer", function (size, numValues) {
+        var a = randArray(size, numValues);
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        expect(hasConsecutiveDuplicates(m.values())).toBe(false);
+        expect(m.size()).toBeLessThanOrEqual(size);
+    });
+    test.concurrent.each([5, 25, 125])("nonempty maps without unsorted initializer", function (size) {
+        var a = array(size);
+        a.reverse();
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        expect(isSorted(m.keys())).toBe(true);
+        expect(m.size()).toBe(size);
+    });
 });
-describe("get values from", function () {
-  var n = 10;
-  var a = array(n);
-  test("empty map", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    expect(m.get(0)).toBeUndefined();
-  });
-  test.each(keys(n))("nonempty map", function (key) {
-    var m = new IntervalMap(a, keyCmp, valueEq);
-    expect(m.get(key)).toBe(f(key));
-    expect(m.get(key + 0.5)).toBe(f(key));
-  });
+describe("get values from ", function () {
+    var n = 10;
+    var a = array(n);
+    test("empty map", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        expect(m.get(0)).toBeUndefined();
+    });
+    test.each(keys(n))("nonempty map", function (key) {
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        expect(m.get(key)).toBe(f(key));
+        expect(m.get(key + 0.5)).toBe(f(key));
+    });
 });
 describe("set", function () {
-  test("empty intervals", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    expect(m.set(0, 0, "a").toArray()).toStrictEqual([]);
-    expect(m.set(0, -1, "a").toArray()).toStrictEqual([]);
-  });
-  test("one interval", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    expect(m.set(-1, 1, "a").toArray()).toStrictEqual([
-      [-1, "a"],
-      [1, undefined],
-    ]);
-  });
-  test("disjoint intervals", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-2, -1, "a").set(1, 2, "b");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [-1, undefined],
-      [1, "b"],
-      [2, undefined],
-    ]);
-  });
-  test("disjoint intervals in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(1, 2, "b").set(-2, -1, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [-1, undefined],
-      [1, "b"],
-      [2, undefined],
-    ]);
-  });
-  test("disjoint intervals in reverse order with an undefined value", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(1, 2, "b").set(-2, -1, undefined);
-    expect(m.toArray()).toStrictEqual([
-      [1, "b"],
-      [2, undefined],
-    ]);
-  });
-  test("adjacent intervals", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 0, "a").set(0, 1, "b");
-    expect(m.toArray()).toStrictEqual([
-      [-1, "a"],
-      [0, "b"],
-      [1, undefined],
-    ]);
-  });
-  test("adjacent intervals in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(0, 1, "b").set(-1, 0, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-1, "a"],
-      [0, "b"],
-      [1, undefined],
-    ]);
-  });
-  test("adjacent intervals with same value", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 0, "a").set(0, 1, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-1, "a"],
-      [1, undefined],
-    ]);
-  });
-  test("adjacent intervals with same value in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(0, 1, "a").set(-1, 0, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-1, "a"],
-      [1, undefined],
-    ]);
-  });
-  test("intersecting intervals", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-2, 1, "a").set(-1, 2, "b");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [-1, "b"],
-      [2, undefined],
-    ]);
-  });
-  test("intersecting intervals in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 2, "b").set(-2, 1, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [1, "b"],
-      [2, undefined],
-    ]);
-  });
-  test("intersecting intervals with same value", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-2, 1, "a").set(-1, 2, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [2, undefined],
-    ]);
-  });
-  test("intersecting intervals with same value in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 2, "a").set(-2, 1, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [2, undefined],
-    ]);
-  });
-  test("nested intervals", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-2, 2, "a").set(-1, 1, "b");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [-1, "b"],
-      [1, "a"],
-      [2, undefined],
-    ]);
-  });
-  test("nested intervals in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 1, "b").set(-2, 2, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-2, "a"],
-      [2, undefined],
-    ]);
-  });
-  test("nested intervals with same value", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-3, 3, "a").set(-2, 2, "a").set(-1, 1, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-3, "a"],
-      [3, undefined],
-    ]);
-  });
-  test("nested intervals with same value in reverse order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 1, "a").set(-2, 2, "a").set(-3, 3, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-3, "a"],
-      [3, undefined],
-    ]);
-  });
-  test("nested intervals with same value in third order", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    m.set(-1, 1, "a").set(-3, 3, "a").set(-2, 2, "a");
-    expect(m.toArray()).toStrictEqual([
-      [-3, "a"],
-      [3, undefined],
-    ]);
-  });
-  test("overwrite many intervals", function () {
-    var a = array(10).concat([[10, "a"]]);
-    var m = new IntervalMap(a, keyCmp, valueEq);
-    m.set(0.5, 10.5, "a");
-    expect(m.toArray()).toStrictEqual([[0, "a"]]);
-  });
+    test("empty intervals", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        expect(m.set(0, 0, "a").toArray()).toStrictEqual([]);
+        expect(m.set(0, -1, "a").toArray()).toStrictEqual([]);
+    });
+    test("one interval", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        expect(m.set(-1, 1, "a").toArray()).toStrictEqual([
+            [-1, "a"],
+            [1, undefined],
+        ]);
+    });
+    test("disjoint intervals", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-2, -1, "a").set(1, 2, "b");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [-1, undefined],
+            [1, "b"],
+            [2, undefined],
+        ]);
+    });
+    test("disjoint intervals in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(1, 2, "b").set(-2, -1, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [-1, undefined],
+            [1, "b"],
+            [2, undefined],
+        ]);
+    });
+    test("disjoint intervals in reverse order with an undefined value", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(1, 2, "b").set(-2, -1, undefined);
+        expect(m.toArray()).toStrictEqual([
+            [1, "b"],
+            [2, undefined],
+        ]);
+    });
+    test("adjacent intervals", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 0, "a").set(0, 1, "b");
+        expect(m.toArray()).toStrictEqual([
+            [-1, "a"],
+            [0, "b"],
+            [1, undefined],
+        ]);
+    });
+    test("adjacent intervals in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(0, 1, "b").set(-1, 0, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-1, "a"],
+            [0, "b"],
+            [1, undefined],
+        ]);
+    });
+    test("adjacent intervals with same value", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 0, "a").set(0, 1, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-1, "a"],
+            [1, undefined],
+        ]);
+    });
+    test("adjacent intervals with same value in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(0, 1, "a").set(-1, 0, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-1, "a"],
+            [1, undefined],
+        ]);
+    });
+    test("intersecting intervals", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-2, 1, "a").set(-1, 2, "b");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [-1, "b"],
+            [2, undefined],
+        ]);
+    });
+    test("intersecting intervals in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 2, "b").set(-2, 1, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [1, "b"],
+            [2, undefined],
+        ]);
+    });
+    test("intersecting intervals with same value", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-2, 1, "a").set(-1, 2, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [2, undefined],
+        ]);
+    });
+    test("intersecting intervals with same value in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 2, "a").set(-2, 1, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [2, undefined],
+        ]);
+    });
+    test("nested intervals", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-2, 2, "a").set(-1, 1, "b");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [-1, "b"],
+            [1, "a"],
+            [2, undefined],
+        ]);
+    });
+    test("nested intervals in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 1, "b").set(-2, 2, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-2, "a"],
+            [2, undefined],
+        ]);
+    });
+    test("nested intervals with same value", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-3, 3, "a").set(-2, 2, "a").set(-1, 1, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-3, "a"],
+            [3, undefined],
+        ]);
+    });
+    test("nested intervals with same value in reverse order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 1, "a").set(-2, 2, "a").set(-3, 3, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-3, "a"],
+            [3, undefined],
+        ]);
+    });
+    test("nested intervals with same value in third order", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        m.set(-1, 1, "a").set(-3, 3, "a").set(-2, 2, "a");
+        expect(m.toArray()).toStrictEqual([
+            [-3, "a"],
+            [3, undefined],
+        ]);
+    });
+    test("overwrite many intervals", function () {
+        var a = array(10).concat([[10, "a"]]);
+        var m = new IntervalMap(a, keyCmp, valueEq);
+        m.set(0.5, 10.5, "a");
+        expect(m.toArray()).toStrictEqual([[0, "a"]]);
+    });
 });
 describe("copy", function () {
-  test("an empty map and check independence", function () {
-    var m = new IntervalMap([], keyCmp, valueEq);
-    var copy = m.copy();
-    m.set(0, 1, "a");
-    copy.set(0, 1, "b");
-    expect(m.get(0.5)).toBe("a");
-    expect(copy.get(0.5)).toBe("b");
-    expect(m.size()).toStrictEqual(2);
-    expect(copy.size()).toStrictEqual(2);
-  });
+    test("an empty map and check independence", function () {
+        var m = new IntervalMap([], keyCmp, valueEq);
+        var copy = m.copy();
+        m.set(0, 1, "a");
+        copy.set(0, 1, "b");
+        expect(m.get(0.5)).toBe("a");
+        expect(copy.get(0.5)).toBe("b");
+        expect(m.size()).toStrictEqual(2);
+        expect(copy.size()).toStrictEqual(2);
+    });
 });
 describe("compute difference for", function () {
-  test("one set op", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(0, 1, "a");
-    expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
-  });
-  test("two disjoint set ops", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-2, -1, "a").set(1, 2, "b");
-    expect(m2.minus(m1)).toStrictEqual([
-      [-2, -1, "a"],
-      [1, 2, "b"],
-    ]);
-  });
-  test("two adjacent set ops", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "b");
-    expect(m2.minus(m1)).toStrictEqual([
-      [-1, 0, "a"],
-      [0, 1, "b"],
-    ]);
-  });
-  test("two adjacent set ops with the same value", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "a");
-    expect(m2.minus(m1)).toStrictEqual([[-1, 1, "a"]]);
-  });
-  test("two intersecting set ops", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "b");
-    expect(m2.minus(m1)).toStrictEqual([
-      [-2, -1, "a"],
-      [-1, 2, "b"],
-    ]);
-  });
-  test("two intersecting set ops in reverse order", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-1, 2, "b").set(-2, 1, "a");
-    expect(m2.minus(m1)).toStrictEqual([
-      [-2, 1, "a"],
-      [1, 2, "b"],
-    ]);
-  });
-  test("two intersecting set ops with same value", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "a");
-    expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
-  });
-  test("two intersecting set ops with same value in reverse order", function () {
-    var m1 = new IntervalMap([], keyCmp, valueEq);
-    var m2 = m1.copy().set(-1, 2, "a").set(-2, 1, "a");
-    expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
-  });
-  test("set ops with no effect", function () {
-    var m1 = new IntervalMap(
-      [
-        [1, "a"],
-        [2, "b"],
-      ],
-      keyCmp,
-      valueEq,
-    );
-    var m2 = m1.copy().set(1, 1.5, "a").set(3, 4, "b");
-    expect(m2.minus(m1)).toStrictEqual([]);
-  });
-  test("one inexact set op", function () {
-    var m1 = new IntervalMap(
-      [
-        [1, "a"],
-        [2, "b"],
-      ],
-      keyCmp,
-      valueEq,
-    );
-    var m2 = m1.copy().set(0, 1.5, "a");
-    expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
-  });
-  test("another inexact set op", function () {
-    var m1 = new IntervalMap(
-      [
-        [1, "a"],
-        [2, "b"],
-      ],
-      keyCmp,
-      valueEq,
-    );
-    var m2 = m1.copy().set(1.5, 3, "b");
-    expect(m2.minus(m1)).toStrictEqual([[1.5, 2, "b"]]);
-  });
-  test("one set on a base map with many steps", function () {
-    var a = array(10);
-    var m1 = new IntervalMap(a, keyCmp, valueEq);
-    var m2 = m1.copy().set(0.5, 9, "a");
-    expect(m2.minus(m1)).toStrictEqual([[1, 9, "a"]]);
-  });
-  test("multiple sets overwritten by a final set", function () {
-    var m1 = new IntervalMap([[1, "a"]], keyCmp, valueEq);
-    var m2 = m1
-      .copy()
-      .set(2, 3, "b")
-      .set(3, 4, "c")
-      .set(4, 5, "d")
-      .set(1.5, 4, "a");
-    expect(m2.minus(m1)).toStrictEqual([[4, 5, "d"]]);
-  });
+    test("one set op", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(0, 1, "a");
+        expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
+    });
+    test("two disjoint set ops", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-2, -1, "a").set(1, 2, "b");
+        expect(m2.minus(m1)).toStrictEqual([
+            [-2, -1, "a"],
+            [1, 2, "b"],
+        ]);
+    });
+    test("two adjacent set ops", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "b");
+        expect(m2.minus(m1)).toStrictEqual([
+            [-1, 0, "a"],
+            [0, 1, "b"],
+        ]);
+    });
+    test("two adjacent set ops with the same value", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "a");
+        expect(m2.minus(m1)).toStrictEqual([[-1, 1, "a"]]);
+    });
+    test("two intersecting set ops", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "b");
+        expect(m2.minus(m1)).toStrictEqual([
+            [-2, -1, "a"],
+            [-1, 2, "b"],
+        ]);
+    });
+    test("two intersecting set ops in reverse order", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-1, 2, "b").set(-2, 1, "a");
+        expect(m2.minus(m1)).toStrictEqual([
+            [-2, 1, "a"],
+            [1, 2, "b"],
+        ]);
+    });
+    test("two intersecting set ops with same value", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "a");
+        expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
+    });
+    test("two intersecting set ops with same value in reverse order", function () {
+        var m1 = new IntervalMap([], keyCmp, valueEq);
+        var m2 = m1.copy().set(-1, 2, "a").set(-2, 1, "a");
+        expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
+    });
+    test("set ops with no effect", function () {
+        var m1 = new IntervalMap([
+            [1, "a"],
+            [2, "b"],
+        ], keyCmp, valueEq);
+        var m2 = m1.copy().set(1, 1.5, "a").set(3, 4, "b");
+        expect(m2.minus(m1)).toStrictEqual([]);
+    });
+    test("one inexact set op", function () {
+        var m1 = new IntervalMap([
+            [1, "a"],
+            [2, "b"],
+        ], keyCmp, valueEq);
+        var m2 = m1.copy().set(0, 1.5, "a");
+        expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
+    });
+    test("another inexact set op", function () {
+        var m1 = new IntervalMap([
+            [1, "a"],
+            [2, "b"],
+        ], keyCmp, valueEq);
+        var m2 = m1.copy().set(1.5, 3, "b");
+        expect(m2.minus(m1)).toStrictEqual([[1.5, 2, "b"]]);
+    });
+    test("one set on a base map with many steps", function () {
+        var a = array(10);
+        var m1 = new IntervalMap(a, keyCmp, valueEq);
+        var m2 = m1.copy().set(0.5, 9, "a");
+        expect(m2.minus(m1)).toStrictEqual([[1, 9, "a"]]);
+    });
+    test("multiple sets overwritten by a final set", function () {
+        var m1 = new IntervalMap([[1, "a"]], keyCmp, valueEq);
+        var m2 = m1
+            .copy()
+            .set(2, 3, "b")
+            .set(3, 4, "c")
+            .set(4, 5, "d")
+            .set(1.5, 4, "a");
+        expect(m2.minus(m1)).toStrictEqual([[4, 5, "d"]]);
+    });
 });
diff --git a/src/algorithms/Bisection.js b/src/algorithms/Bisection.js
index ec9eaf3ec..ecfd5ccf7 100644
--- a/src/algorithms/Bisection.js
+++ b/src/algorithms/Bisection.js
@@ -1,25 +1,23 @@
 export function bisect(a, x, cmpToX, lo, hi, findRightMost) {
-  if (lo === void 0) {
-    lo = 0;
-  }
-  if (hi === void 0) {
-    hi = a.length;
-  }
-  if (findRightMost === void 0) {
-    findRightMost = false;
-  }
-  if (hi <= lo) return lo;
-  if (hi === lo + 1) {
-    var c_1 = cmpToX(a[lo]);
-    if (c_1 < 0) return hi;
-    if (c_1 > 0) return lo;
-    if (c_1 === 0 && findRightMost) return hi;
-    return lo;
-  }
-  var mid = Math.floor((lo + hi) / 2.0);
-  var c = cmpToX(a[mid]);
-  if (c < 0 || (c === 0 && findRightMost)) {
-    return bisect(a, x, cmpToX, mid + 1, hi, findRightMost);
-  }
-  return bisect(a, x, cmpToX, lo, mid, findRightMost);
+    if (lo === void 0) { lo = 0; }
+    if (hi === void 0) { hi = a.length; }
+    if (findRightMost === void 0) { findRightMost = false; }
+    if (hi <= lo)
+        return lo;
+    if (hi === lo + 1) {
+        var c_1 = cmpToX(a[lo]);
+        if (c_1 < 0)
+            return hi;
+        if (c_1 > 0)
+            return lo;
+        if (c_1 === 0 && findRightMost)
+            return hi;
+        return lo;
+    }
+    var mid = Math.floor((lo + hi) / 2.0);
+    var c = cmpToX(a[mid]);
+    if (c < 0 || (c === 0 && findRightMost)) {
+        return bisect(a, x, cmpToX, mid + 1, hi, findRightMost);
+    }
+    return bisect(a, x, cmpToX, lo, mid, findRightMost);
 }
diff --git a/src/algorithms/IntervalMap.js b/src/algorithms/IntervalMap.js
index 3e67ec8d9..14fa45d19 100644
--- a/src/algorithms/IntervalMap.js
+++ b/src/algorithms/IntervalMap.js
@@ -1,167 +1,126 @@
 import { bisect } from "./Bisection";
 function copyArray(array) {
-  return array.map(function (element) {
-    return [element[0], element[1]];
-  });
+    return array.map(function (element) { return [element[0], element[1]]; });
 }
 var IntervalMap = (function () {
-  function IntervalMap(array, keyCmp, valueEq) {
-    this.array = [];
-    var copy = copyArray(array);
-    copy.sort(function (a, b) {
-      return keyCmp(a[0], b[0]);
-    });
-    var prevValue;
-    for (var _i = 0, copy_1 = copy; _i < copy_1.length; _i++) {
-      var _a = copy_1[_i],
-        key = _a[0],
-        value = _a[1];
-      if (!valueEq(value, prevValue)) {
-        this.array.push([key, value]);
-        prevValue = value;
-      }
+    function IntervalMap(array, keyCmp, valueEq) {
+        this.array = [];
+        var copy = copyArray(array);
+        copy.sort(function (a, b) { return keyCmp(a[0], b[0]); });
+        var prevValue;
+        for (var _i = 0, copy_1 = copy; _i < copy_1.length; _i++) {
+            var _a = copy_1[_i], key = _a[0], value = _a[1];
+            if (!valueEq(value, prevValue)) {
+                this.array.push([key, value]);
+                prevValue = value;
+            }
+        }
+        this.keyCmp = keyCmp;
+        this.valueEq = valueEq;
     }
-    this.keyCmp = keyCmp;
-    this.valueEq = valueEq;
-  }
-  IntervalMap.prototype.size = function () {
-    return this.array.length;
-  };
-  IntervalMap.prototype.get = function (key) {
-    var array = this.array;
-    var n = array.length;
-    var keyCmp = this.keyCmp;
-    if (n === 0) return;
-    var idx = bisect(
-      array,
-      key,
-      function (a) {
-        return keyCmp(a[0], key);
-      },
-      0,
-      n,
-      false,
-    );
-    if (idx === n) {
-      return array[idx - 1][1];
-    }
-    if (keyCmp(array[idx][0], key) === 0) {
-      return array[idx][1];
-    }
-    if (idx > 0) {
-      return array[idx - 1][1];
-    }
-    return;
-  };
-  IntervalMap.prototype.set = function (key1, key2, value) {
-    var array = this.array;
-    var n = array.length;
-    var keyCmp = this.keyCmp;
-    var valueEq = this.valueEq;
-    if (keyCmp(key1, key2) >= 0) return this;
-    if (n === 0) {
-      array.push([key1, value], [key2, undefined]);
-      return this;
-    }
-    var idx1 = bisect(
-      array,
-      key1,
-      function (a) {
-        return keyCmp(a[0], key1);
-      },
-      0,
-      array.length,
-      false,
-    );
-    if (idx1 === n) {
-      var v = array[n - 1][1];
-      if (!valueEq(value, v)) {
-        array.push([key1, value], [key2, v]);
-      }
-      return this;
-    }
-    var idx2 =
-      bisect(
-        array,
-        key2,
-        function (a) {
-          return keyCmp(a[0], key2);
-        },
-        0,
-        array.length,
-        true,
-      ) - 1;
-    if (idx2 === -1) {
-      if (!valueEq(value, undefined)) {
-        array.splice(0, 0, [key1, value], [key2, undefined]);
-      }
-      return this;
-    }
-    var insert1 = !(idx1 > 0 && valueEq(array[idx1 - 1][1], value));
-    var insert2 = !valueEq(array[idx2][1], value);
-    if (insert1 && insert2) {
-      array.splice(
-        idx1,
-        idx2 - idx1 + 1,
-        [key1, value],
-        [key2, array[idx2][1]],
-      );
-    } else if (insert1) {
-      array.splice(idx1, idx2 - idx1 + 1, [key1, value]);
-    } else if (insert2) {
-      array.splice(idx1, idx2 - idx1 + 1, [key2, array[idx2][1]]);
-    } else {
-      array.splice(idx1, idx2 - idx1 + 1);
-    }
-    return this;
-  };
-  IntervalMap.prototype.keys = function () {
-    return this.array.map(function (element) {
-      return element[0];
-    });
-  };
-  IntervalMap.prototype.values = function () {
-    return this.array.map(function (element) {
-      return element[1];
-    });
-  };
-  IntervalMap.prototype.toArray = function () {
-    return copyArray(this.array);
-  };
-  IntervalMap.prototype.copy = function () {
-    return new IntervalMap(this.array, this.keyCmp, this.valueEq);
-  };
-  IntervalMap.prototype.minus = function (baseMap) {
-    var _this = this;
-    var keys = this.keys().concat(baseMap.keys());
-    keys.sort(this.keyCmp);
-    var equalValues = keys.map(function (key) {
-      return _this.valueEq(_this.get(key), baseMap.get(key));
-    });
-    var idx = 0;
-    var diff = [];
-    while (idx + 1 < keys.length) {
-      if (!equalValues[idx]) {
-        diff.push([keys[idx], keys[idx + 1], this.get(keys[idx])]);
-      }
-      idx += 1;
-    }
-    var i = 0;
-    var mergedDiff = [];
-    while (i < diff.length) {
-      var _a = diff[i],
-        st = _a[0],
-        en = _a[1],
-        val = _a[2];
-      while (i + 1 < diff.length && this.valueEq(diff[i][2], diff[i + 1][2])) {
-        en = diff[i + 1][1];
-        i += 1;
-      }
-      mergedDiff.push([st, en, val]);
-      i += 1;
-    }
-    return mergedDiff;
-  };
-  return IntervalMap;
-})();
+    IntervalMap.prototype.size = function () {
+        return this.array.length;
+    };
+    IntervalMap.prototype.get = function (key) {
+        var array = this.array;
+        var n = array.length;
+        var keyCmp = this.keyCmp;
+        if (n === 0)
+            return;
+        var idx = bisect(array, key, function (a) { return keyCmp(a[0], key); }, 0, n, false);
+        if (idx === n) {
+            return array[idx - 1][1];
+        }
+        if (keyCmp(array[idx][0], key) === 0) {
+            return array[idx][1];
+        }
+        if (idx > 0) {
+            return array[idx - 1][1];
+        }
+        return;
+    };
+    IntervalMap.prototype.set = function (key1, key2, value) {
+        var array = this.array;
+        var n = array.length;
+        var keyCmp = this.keyCmp;
+        var valueEq = this.valueEq;
+        if (keyCmp(key1, key2) >= 0)
+            return this;
+        if (n === 0) {
+            array.push([key1, value], [key2, undefined]);
+            return this;
+        }
+        var idx1 = bisect(array, key1, function (a) { return keyCmp(a[0], key1); }, 0, array.length, false);
+        if (idx1 === n) {
+            var v = array[n - 1][1];
+            if (!valueEq(value, v)) {
+                array.push([key1, value], [key2, v]);
+            }
+            return this;
+        }
+        var idx2 = bisect(array, key2, function (a) { return keyCmp(a[0], key2); }, 0, array.length, true) - 1;
+        if (idx2 === -1) {
+            if (!valueEq(value, undefined)) {
+                array.splice(0, 0, [key1, value], [key2, undefined]);
+            }
+            return this;
+        }
+        var insert1 = !(idx1 > 0 && valueEq(array[idx1 - 1][1], value));
+        var insert2 = !valueEq(array[idx2][1], value);
+        if (insert1 && insert2) {
+            array.splice(idx1, idx2 - idx1 + 1, [key1, value], [key2, array[idx2][1]]);
+        }
+        else if (insert1) {
+            array.splice(idx1, idx2 - idx1 + 1, [key1, value]);
+        }
+        else if (insert2) {
+            array.splice(idx1, idx2 - idx1 + 1, [key2, array[idx2][1]]);
+        }
+        else {
+            array.splice(idx1, idx2 - idx1 + 1);
+        }
+        return this;
+    };
+    IntervalMap.prototype.keys = function () {
+        return this.array.map(function (element) { return element[0]; });
+    };
+    IntervalMap.prototype.values = function () {
+        return this.array.map(function (element) { return element[1]; });
+    };
+    IntervalMap.prototype.toArray = function () {
+        return copyArray(this.array);
+    };
+    IntervalMap.prototype.copy = function () {
+        return new IntervalMap(this.array, this.keyCmp, this.valueEq);
+    };
+    IntervalMap.prototype.minus = function (baseMap) {
+        var _this = this;
+        var keys = this.keys().concat(baseMap.keys());
+        keys.sort(this.keyCmp);
+        var equalValues = keys.map(function (key) {
+            return _this.valueEq(_this.get(key), baseMap.get(key));
+        });
+        var idx = 0;
+        var diff = [];
+        while (idx + 1 < keys.length) {
+            if (!equalValues[idx]) {
+                diff.push([keys[idx], keys[idx + 1], this.get(keys[idx])]);
+            }
+            idx += 1;
+        }
+        var i = 0;
+        var mergedDiff = [];
+        while (i < diff.length) {
+            var _a = diff[i], st = _a[0], en = _a[1], val = _a[2];
+            while (i + 1 < diff.length && this.valueEq(diff[i][2], diff[i + 1][2])) {
+                en = diff[i + 1][1];
+                i += 1;
+            }
+            mergedDiff.push([st, en, val]);
+            i += 1;
+        }
+        return mergedDiff;
+    };
+    return IntervalMap;
+}());
 export { IntervalMap };
diff --git a/tsconfig.json b/tsconfig.json
index a3c6d968f..bd14625d5 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -17,7 +17,6 @@
     "strictNullChecks": true,
     "strictPropertyInitialization": true,
     "useUnknownInCatchVariables": true,
-    "noImplicitUseStrict": true,
     "ignoreDeprecations": "5.0"
   },
   "include": ["src/**/*.ts"]

From 9a5013b8e0d171585d43931c597206d124956091 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 20:08:17 +0200
Subject: [PATCH 24/31] fix: Prevent null value from crashing
 OneYearValueSetter

---
 src/pages/policy/input/ParameterEditor.jsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index c8958c776..9b98805bc 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -609,9 +609,9 @@ function OneYearValueSetter(props) {
               maximumFractionDigits: userTyping ? 16 : maximumFractionDigits,
             });
           }}
-          defaultValue={startValue * scale}
+          defaultValue={Number(startValue) * scale}
           value={valueMap.get(year) * scale}
-          onChange={changeHandler}
+          onChange={(value) => changeHandler(Number(value))}
         />
         {!isPercent && (
           <AdvancedValueSetter

From 112fcd5edccd49ba63aa3b742b4a637716c892a5 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 20:43:59 +0200
Subject: [PATCH 25/31] fix: Remove unused code

---
 src/pages/policy/input/ParameterEditor.jsx | 52 +---------------------
 1 file changed, 2 insertions(+), 50 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 9b98805bc..98e63537b 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -26,7 +26,7 @@ import {
 import { IntervalMap } from "algorithms/IntervalMap";
 import { cmpDates, nextDay, prevDay } from "lang/stringDates";
 import moment from "dayjs";
-import { DownOutlined, EllipsisOutlined, FunctionOutlined, LeftOutlined, RightOutlined, SettingOutlined, UndoOutlined, UpOutlined } from "@ant-design/icons";
+import { EllipsisOutlined, SettingOutlined } from "@ant-design/icons";
 import style from "../../../style";
 import { defaultYear } from "../../../data/constants";
 const { RangePicker } = DatePicker;
@@ -394,7 +394,7 @@ function DatePeriodSetter(props) {
 }
 
 function MultiYearPeriodSetter(props) {
-  const { startDate, endDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName, baseMap, reformMap, metadata, policy } = props;
+  const { possibleYears, parameterName, baseMap, reformMap, metadata, policy } = props;
 
   const NUMBER_OF_YEARS = 10;
   const [valueMap, setValueMap] = useState(populateValueMap());
@@ -903,52 +903,4 @@ function SettingsPanel(props) {
   );
 }
 
-/**
- * Checks whether or not an input date is a boundary date -
- * the first or last day of a fixed period (e.g., Jan. 1 or
- * Dec. 31)
- * @param {String} date
- * @param {("start"|"end")} variant The date type - either a
- * period's start or its end date
- * @returns {Boolean} Whether or not the date is a boundary date
- */
-function checkBoundaryDate(date, variant) {
-  // Define boundary dates and types
-  // Note that month is 0-indexed in moment
-  const boundaries = [
-    {
-      type: "start",
-      month: 0,
-      date: 1,
-    },
-    {
-      type: "end",
-      month: 11,
-      date: 31,
-    },
-  ];
-
-  // Take the date and define it in terms of moment package
-  const momentDate = moment(date);
-
-  // Duplicate its year for testing purposes
-  const testYear = momentDate.year();
-
-  // For each boundary defined above
-  for (const boundary of boundaries) {
-    // Set up a test date using the test year and the boundary's defined
-    // month and date
-    const testDate = moment()
-      .year(testYear)
-      .month(boundary.month)
-      .date(boundary.date);
-    // If the date is a boundary date, return true
-    if (boundary.type === variant && testDate.isSame(momentDate, "date")) {
-      return true;
-    }
-  }
-  // If we've found no boundary dates, return false
-  return false;
-}
-
 export const ParamChartWidthContext = createContext((obj) => obj);

From 2af3528cd2e2a26994c23897bd09811388c83935 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 20:44:53 +0200
Subject: [PATCH 26/31] fix: Remove unsafe data declaration

---
 src/pages/policy/input/ParameterEditor.jsx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 98e63537b..ae1b2119e 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -425,27 +425,28 @@ function MultiYearPeriodSetter(props) {
   // all values are valid, then updates each value one by one
   function handleSubmit() {
 
-    let data = {}
+    let allData = {};
     for (const [year, value] of valueMap) {
       const startDate = String(year).concat("-01-01");
       const endDate = String(year).concat("-12-31");
       reformMap.set(startDate, nextDay(endDate), value);
-      data = {};
+      let data = {};
       reformMap.minus(baseMap).forEach(([k1, k2, v]) => {
         data[`${k1}.${prevDay(k2)}`] = v;
       }); 
+      allData = { ...allData, ...data };
     }
 
     const newReforms = { ...policy.reform.data };
     if (
-      Object.keys(data).length === 0 &&
+      Object.keys(allData).length === 0 &&
       Object.keys(newReforms).length === 1
     ) {
       let newSearch = copySearchParams(searchParams);
       newSearch.delete("reform");
       setSearchParams(newSearch);
     } else {
-      newReforms[parameterName] = data;
+      newReforms[parameterName] = allData;
       getNewPolicyId(metadata.countryId, newReforms).then((result) => {
         if (result.status !== "ok") {
           console.error(

From 5ffe4de3dbcb9c920041a9edc13dbf81505d1658 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 20:56:42 +0200
Subject: [PATCH 27/31] fix: Properly pass callback of populateValueMap

---
 src/pages/policy/input/ParameterEditor.jsx | 32 ++++++++++++++++------
 1 file changed, 23 insertions(+), 9 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index ae1b2119e..8e6c54f1b 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -13,7 +13,7 @@ import {
   Tooltip,
 } from "antd";
 import { getNewPolicyId } from "../../../api/parameters";
-import { createContext, useEffect, useRef, useState } from "react";
+import { createContext, useCallback, useEffect, useRef, useState } from "react";
 import { useSearchParams } from "react-router-dom";
 import { copySearchParams } from "../../../api/call";
 import { capitalize, localeCode } from "../../../lang/format";
@@ -396,12 +396,9 @@ function DatePeriodSetter(props) {
 function MultiYearPeriodSetter(props) {
   const { possibleYears, parameterName, baseMap, reformMap, metadata, policy } = props;
 
-  const NUMBER_OF_YEARS = 10;
-  const [valueMap, setValueMap] = useState(populateValueMap());
-  const [searchParams, setSearchParams] = useSearchParams();
-
   // Populate map before rendering anything
-  function populateValueMap() {
+  // function populateValueMap() {
+  const populateValueMap = useCallback(() => {
 
     const valueMap = new Map();
     possibleYears.forEach((year) => {
@@ -412,14 +409,31 @@ function MultiYearPeriodSetter(props) {
       }
     });
     return valueMap;
-  }
+  }, [possibleYears, reformMap]);
+
+  const NUMBER_OF_YEARS = 10;
+  const [valueMap, setValueMap] = useState(populateValueMap());
+  const [searchParams, setSearchParams] = useSearchParams();
+  const paramRef = useRef(parameterName);
+
 
   // This is necessary because technically, MultiYearPeriodSetter does not
   // unmount when we change between parameters, leading to the possibility
   // for a stale "value" state in this controlled component
+
+  // We're using a ref here because each time the changeHandler is called,
+  // it updates reformMap. This then re-renders the callback above, causing
+  // valueMap to be re-populated with stale data, creating a visual bug.
+  // All of this wouldn't be necessary if we either 1. didn't add populateValueMap
+  // as an effect hook dep (but then we'd be overriding linting) or 2. fully
+  // unmounted the component when we changed pages (but that'd require far
+  // more work)
   useEffect(() => {
-    setValueMap(populateValueMap());
-  }, [parameterName]);
+    if (paramRef.current !== parameterName) {
+      setValueMap(populateValueMap());
+      paramRef.current = parameterName;
+    }
+  }, [parameterName, populateValueMap]);
 
   // Handler that iterates over each entry, validates that
   // all values are valid, then updates each value one by one

From a01a299a17948d7ae0e31e0e9a87991d01a7e8cd Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 21:03:59 +0200
Subject: [PATCH 28/31] chore: Lint

---
 src/__tests__/algorithms/Bisection.test.js   | 135 +++-
 src/__tests__/algorithms/IntervalMap.test.js | 708 ++++++++++---------
 src/algorithms/Bisection.js                  |  44 +-
 src/algorithms/IntervalMap.js                | 281 ++++----
 src/pages/policy/input/ParameterEditor.jsx   | 173 ++---
 5 files changed, 747 insertions(+), 594 deletions(-)

diff --git a/src/__tests__/algorithms/Bisection.test.js b/src/__tests__/algorithms/Bisection.test.js
index ea9434f42..c02ae90c9 100644
--- a/src/__tests__/algorithms/Bisection.test.js
+++ b/src/__tests__/algorithms/Bisection.test.js
@@ -1,31 +1,110 @@
 import { bisect } from "algorithms/Bisection";
 describe("bisection", function () {
-    test("small cases", function () {
-        expect(bisect([], 1, function (a) { return a - 1; })).toBe(0);
-        expect(bisect([1], 1, function (a) { return a - 1; })).toBe(0);
-        expect(bisect([1], 2, function (a) { return a - 2; })).toBe(1);
-        expect(bisect([1], 1, function (a) { return a - 1; }, 0, 1, true)).toBe(1);
-    });
-    var a = [0, 1, 2, 3, 4, 5];
-    test.each(a)("identity", function (e) {
-        expect(bisect(a, e, function (o) { return o - e; })).toBe(e);
-    });
-    test.each(a)("successor 1", function (e) {
-        expect(bisect(a, e + 0.5, function (o) { return o - e - 0.5; })).toBe(e + 1);
-    });
-    test.each(a)("successor 2", function (e) {
-        expect(bisect(a, e, function (o) { return o - e; }, 0, a.length, true)).toBe(e + 1);
-    });
-    test.each(a)("successor 3", function (e) {
-        expect(bisect(a, e + 0.5, function (o) { return o - e - 0.5; }, 0, a.length, true)).toBe(e + 1);
-    });
-    test("duplicates", function () {
-        var a = [0, 1, 2, 3, 3, 3, 6, 7];
-        expect(bisect(a, 3, function (e) { return e - 3; })).toBe(3);
-        expect(bisect(a, 3, function (e) { return e - 3; }, 0, a.length, true)).toBe(6);
-    });
-    test("unknown", function () {
-        var a = [-2, -1];
-        expect(bisect(a, 1, function (e) { return e - 1; }, 0, a.length, false)).toBe(a.length);
-    });
+  test("small cases", function () {
+    expect(
+      bisect([], 1, function (a) {
+        return a - 1;
+      }),
+    ).toBe(0);
+    expect(
+      bisect([1], 1, function (a) {
+        return a - 1;
+      }),
+    ).toBe(0);
+    expect(
+      bisect([1], 2, function (a) {
+        return a - 2;
+      }),
+    ).toBe(1);
+    expect(
+      bisect(
+        [1],
+        1,
+        function (a) {
+          return a - 1;
+        },
+        0,
+        1,
+        true,
+      ),
+    ).toBe(1);
+  });
+  var a = [0, 1, 2, 3, 4, 5];
+  test.each(a)("identity", function (e) {
+    expect(
+      bisect(a, e, function (o) {
+        return o - e;
+      }),
+    ).toBe(e);
+  });
+  test.each(a)("successor 1", function (e) {
+    expect(
+      bisect(a, e + 0.5, function (o) {
+        return o - e - 0.5;
+      }),
+    ).toBe(e + 1);
+  });
+  test.each(a)("successor 2", function (e) {
+    expect(
+      bisect(
+        a,
+        e,
+        function (o) {
+          return o - e;
+        },
+        0,
+        a.length,
+        true,
+      ),
+    ).toBe(e + 1);
+  });
+  test.each(a)("successor 3", function (e) {
+    expect(
+      bisect(
+        a,
+        e + 0.5,
+        function (o) {
+          return o - e - 0.5;
+        },
+        0,
+        a.length,
+        true,
+      ),
+    ).toBe(e + 1);
+  });
+  test("duplicates", function () {
+    var a = [0, 1, 2, 3, 3, 3, 6, 7];
+    expect(
+      bisect(a, 3, function (e) {
+        return e - 3;
+      }),
+    ).toBe(3);
+    expect(
+      bisect(
+        a,
+        3,
+        function (e) {
+          return e - 3;
+        },
+        0,
+        a.length,
+        true,
+      ),
+    ).toBe(6);
+  });
+  test("unknown", function () {
+    var a = [-2, -1];
+    expect(
+      bisect(
+        a,
+        1,
+        function (e) {
+          return e - 1;
+        },
+        0,
+        a.length,
+        false,
+      ),
+    ).toBe(a.length);
+  });
 });
diff --git a/src/__tests__/algorithms/IntervalMap.test.js b/src/__tests__/algorithms/IntervalMap.test.js
index e72de2775..cfd6a6473 100644
--- a/src/__tests__/algorithms/IntervalMap.test.js
+++ b/src/__tests__/algorithms/IntervalMap.test.js
@@ -1,364 +1,392 @@
 import { IntervalMap } from "algorithms/IntervalMap";
-var keyCmp = function (x, y) { return x - y; };
-var valueEq = function (x, y) { return x === y; };
+var keyCmp = function (x, y) {
+  return x - y;
+};
+var valueEq = function (x, y) {
+  return x === y;
+};
 function f(i) {
-    return String.fromCharCode(97 + i);
+  return String.fromCharCode(97 + i);
 }
 function array(n) {
-    var a = [];
-    for (var i = 0; i < n; i++) {
-        a.push([i, f(i)]);
-    }
-    return a;
+  var a = [];
+  for (var i = 0; i < n; i++) {
+    a.push([i, f(i)]);
+  }
+  return a;
 }
 function randArray(n, m) {
-    var rand = function () { return Math.floor(Math.random() * m); };
-    var a = [];
-    for (var i = 0; i < n; i++) {
-        a.push([i, f(rand())]);
-    }
-    return a;
+  var rand = function () {
+    return Math.floor(Math.random() * m);
+  };
+  var a = [];
+  for (var i = 0; i < n; i++) {
+    a.push([i, f(rand())]);
+  }
+  return a;
 }
 function keys(n) {
-    var a = [];
-    for (var i = 0; i < n; i++) {
-        a.push(i);
-    }
-    return a;
+  var a = [];
+  for (var i = 0; i < n; i++) {
+    a.push(i);
+  }
+  return a;
 }
 function hasDuplicates(a) {
-    var s = new Set(a);
-    return s.size < a.length;
+  var s = new Set(a);
+  return s.size < a.length;
 }
 function hasConsecutiveDuplicates(a) {
-    for (var i = 0; i + 1 < a.length; i++) {
-        if (a[i] === a[i + 1])
-            return true;
-    }
-    return false;
+  for (var i = 0; i + 1 < a.length; i++) {
+    if (a[i] === a[i + 1]) return true;
+  }
+  return false;
 }
 function isSorted(a) {
-    for (var i = 0; i + 1 < a.length; i++) {
-        if (a[i] > a[i + 1])
-            return false;
-    }
-    return true;
+  for (var i = 0; i + 1 < a.length; i++) {
+    if (a[i] > a[i + 1]) return false;
+  }
+  return true;
 }
 describe("construct", function () {
-    test("an empty map", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        expect(m.size()).toBe(0);
-        expect(m.keys()).toStrictEqual([]);
-        expect(m.values()).toStrictEqual([]);
-        expect(m.toArray()).toStrictEqual([]);
-    });
-    test.concurrent.each([5, 25, 125])("nonempty maps without repeated keys or values in initializer", function (size) {
-        var a = array(size);
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        expect(m.size()).toBe(size);
-        expect(m.toArray()).toStrictEqual(a);
-    });
-    test.concurrent.each([5, 25, 125])("nonempty maps with repeated keys in initializer", function (size) {
-        var a = array(size);
-        a.concat(a);
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        expect(hasDuplicates(m.keys())).toBe(false);
-        expect(m.size()).toBe(size);
-    });
-    test.concurrent.each([
-        [5, 2],
-        [5, 5],
-        [25, 5],
-        [25, 25],
-        [125, 5],
-    ])("nonempty maps with repeated values in initializer", function (size, numValues) {
-        var a = randArray(size, numValues);
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        expect(hasConsecutiveDuplicates(m.values())).toBe(false);
-        expect(m.size()).toBeLessThanOrEqual(size);
-    });
-    test.concurrent.each([5, 25, 125])("nonempty maps without unsorted initializer", function (size) {
-        var a = array(size);
-        a.reverse();
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        expect(isSorted(m.keys())).toBe(true);
-        expect(m.size()).toBe(size);
-    });
+  test("an empty map", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    expect(m.size()).toBe(0);
+    expect(m.keys()).toStrictEqual([]);
+    expect(m.values()).toStrictEqual([]);
+    expect(m.toArray()).toStrictEqual([]);
+  });
+  test.concurrent.each([5, 25, 125])(
+    "nonempty maps without repeated keys or values in initializer",
+    function (size) {
+      var a = array(size);
+      var m = new IntervalMap(a, keyCmp, valueEq);
+      expect(m.size()).toBe(size);
+      expect(m.toArray()).toStrictEqual(a);
+    },
+  );
+  test.concurrent.each([5, 25, 125])(
+    "nonempty maps with repeated keys in initializer",
+    function (size) {
+      var a = array(size);
+      a.concat(a);
+      var m = new IntervalMap(a, keyCmp, valueEq);
+      expect(hasDuplicates(m.keys())).toBe(false);
+      expect(m.size()).toBe(size);
+    },
+  );
+  test.concurrent.each([
+    [5, 2],
+    [5, 5],
+    [25, 5],
+    [25, 25],
+    [125, 5],
+  ])(
+    "nonempty maps with repeated values in initializer",
+    function (size, numValues) {
+      var a = randArray(size, numValues);
+      var m = new IntervalMap(a, keyCmp, valueEq);
+      expect(hasConsecutiveDuplicates(m.values())).toBe(false);
+      expect(m.size()).toBeLessThanOrEqual(size);
+    },
+  );
+  test.concurrent.each([5, 25, 125])(
+    "nonempty maps without unsorted initializer",
+    function (size) {
+      var a = array(size);
+      a.reverse();
+      var m = new IntervalMap(a, keyCmp, valueEq);
+      expect(isSorted(m.keys())).toBe(true);
+      expect(m.size()).toBe(size);
+    },
+  );
 });
-describe("get values from ", function () {
-    var n = 10;
-    var a = array(n);
-    test("empty map", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        expect(m.get(0)).toBeUndefined();
-    });
-    test.each(keys(n))("nonempty map", function (key) {
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        expect(m.get(key)).toBe(f(key));
-        expect(m.get(key + 0.5)).toBe(f(key));
-    });
+describe("get values from", function () {
+  var n = 10;
+  var a = array(n);
+  test("empty map", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    expect(m.get(0)).toBeUndefined();
+  });
+  test.each(keys(n))("nonempty map", function (key) {
+    var m = new IntervalMap(a, keyCmp, valueEq);
+    expect(m.get(key)).toBe(f(key));
+    expect(m.get(key + 0.5)).toBe(f(key));
+  });
 });
 describe("set", function () {
-    test("empty intervals", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        expect(m.set(0, 0, "a").toArray()).toStrictEqual([]);
-        expect(m.set(0, -1, "a").toArray()).toStrictEqual([]);
-    });
-    test("one interval", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        expect(m.set(-1, 1, "a").toArray()).toStrictEqual([
-            [-1, "a"],
-            [1, undefined],
-        ]);
-    });
-    test("disjoint intervals", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-2, -1, "a").set(1, 2, "b");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [-1, undefined],
-            [1, "b"],
-            [2, undefined],
-        ]);
-    });
-    test("disjoint intervals in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(1, 2, "b").set(-2, -1, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [-1, undefined],
-            [1, "b"],
-            [2, undefined],
-        ]);
-    });
-    test("disjoint intervals in reverse order with an undefined value", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(1, 2, "b").set(-2, -1, undefined);
-        expect(m.toArray()).toStrictEqual([
-            [1, "b"],
-            [2, undefined],
-        ]);
-    });
-    test("adjacent intervals", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 0, "a").set(0, 1, "b");
-        expect(m.toArray()).toStrictEqual([
-            [-1, "a"],
-            [0, "b"],
-            [1, undefined],
-        ]);
-    });
-    test("adjacent intervals in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(0, 1, "b").set(-1, 0, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-1, "a"],
-            [0, "b"],
-            [1, undefined],
-        ]);
-    });
-    test("adjacent intervals with same value", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 0, "a").set(0, 1, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-1, "a"],
-            [1, undefined],
-        ]);
-    });
-    test("adjacent intervals with same value in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(0, 1, "a").set(-1, 0, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-1, "a"],
-            [1, undefined],
-        ]);
-    });
-    test("intersecting intervals", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-2, 1, "a").set(-1, 2, "b");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [-1, "b"],
-            [2, undefined],
-        ]);
-    });
-    test("intersecting intervals in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 2, "b").set(-2, 1, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [1, "b"],
-            [2, undefined],
-        ]);
-    });
-    test("intersecting intervals with same value", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-2, 1, "a").set(-1, 2, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [2, undefined],
-        ]);
-    });
-    test("intersecting intervals with same value in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 2, "a").set(-2, 1, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [2, undefined],
-        ]);
-    });
-    test("nested intervals", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-2, 2, "a").set(-1, 1, "b");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [-1, "b"],
-            [1, "a"],
-            [2, undefined],
-        ]);
-    });
-    test("nested intervals in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 1, "b").set(-2, 2, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-2, "a"],
-            [2, undefined],
-        ]);
-    });
-    test("nested intervals with same value", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-3, 3, "a").set(-2, 2, "a").set(-1, 1, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-3, "a"],
-            [3, undefined],
-        ]);
-    });
-    test("nested intervals with same value in reverse order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 1, "a").set(-2, 2, "a").set(-3, 3, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-3, "a"],
-            [3, undefined],
-        ]);
-    });
-    test("nested intervals with same value in third order", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        m.set(-1, 1, "a").set(-3, 3, "a").set(-2, 2, "a");
-        expect(m.toArray()).toStrictEqual([
-            [-3, "a"],
-            [3, undefined],
-        ]);
-    });
-    test("overwrite many intervals", function () {
-        var a = array(10).concat([[10, "a"]]);
-        var m = new IntervalMap(a, keyCmp, valueEq);
-        m.set(0.5, 10.5, "a");
-        expect(m.toArray()).toStrictEqual([[0, "a"]]);
-    });
+  test("empty intervals", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    expect(m.set(0, 0, "a").toArray()).toStrictEqual([]);
+    expect(m.set(0, -1, "a").toArray()).toStrictEqual([]);
+  });
+  test("one interval", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    expect(m.set(-1, 1, "a").toArray()).toStrictEqual([
+      [-1, "a"],
+      [1, undefined],
+    ]);
+  });
+  test("disjoint intervals", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-2, -1, "a").set(1, 2, "b");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [-1, undefined],
+      [1, "b"],
+      [2, undefined],
+    ]);
+  });
+  test("disjoint intervals in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(1, 2, "b").set(-2, -1, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [-1, undefined],
+      [1, "b"],
+      [2, undefined],
+    ]);
+  });
+  test("disjoint intervals in reverse order with an undefined value", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(1, 2, "b").set(-2, -1, undefined);
+    expect(m.toArray()).toStrictEqual([
+      [1, "b"],
+      [2, undefined],
+    ]);
+  });
+  test("adjacent intervals", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 0, "a").set(0, 1, "b");
+    expect(m.toArray()).toStrictEqual([
+      [-1, "a"],
+      [0, "b"],
+      [1, undefined],
+    ]);
+  });
+  test("adjacent intervals in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(0, 1, "b").set(-1, 0, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-1, "a"],
+      [0, "b"],
+      [1, undefined],
+    ]);
+  });
+  test("adjacent intervals with same value", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 0, "a").set(0, 1, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-1, "a"],
+      [1, undefined],
+    ]);
+  });
+  test("adjacent intervals with same value in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(0, 1, "a").set(-1, 0, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-1, "a"],
+      [1, undefined],
+    ]);
+  });
+  test("intersecting intervals", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-2, 1, "a").set(-1, 2, "b");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [-1, "b"],
+      [2, undefined],
+    ]);
+  });
+  test("intersecting intervals in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 2, "b").set(-2, 1, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [1, "b"],
+      [2, undefined],
+    ]);
+  });
+  test("intersecting intervals with same value", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-2, 1, "a").set(-1, 2, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [2, undefined],
+    ]);
+  });
+  test("intersecting intervals with same value in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 2, "a").set(-2, 1, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [2, undefined],
+    ]);
+  });
+  test("nested intervals", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-2, 2, "a").set(-1, 1, "b");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [-1, "b"],
+      [1, "a"],
+      [2, undefined],
+    ]);
+  });
+  test("nested intervals in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 1, "b").set(-2, 2, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-2, "a"],
+      [2, undefined],
+    ]);
+  });
+  test("nested intervals with same value", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-3, 3, "a").set(-2, 2, "a").set(-1, 1, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-3, "a"],
+      [3, undefined],
+    ]);
+  });
+  test("nested intervals with same value in reverse order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 1, "a").set(-2, 2, "a").set(-3, 3, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-3, "a"],
+      [3, undefined],
+    ]);
+  });
+  test("nested intervals with same value in third order", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    m.set(-1, 1, "a").set(-3, 3, "a").set(-2, 2, "a");
+    expect(m.toArray()).toStrictEqual([
+      [-3, "a"],
+      [3, undefined],
+    ]);
+  });
+  test("overwrite many intervals", function () {
+    var a = array(10).concat([[10, "a"]]);
+    var m = new IntervalMap(a, keyCmp, valueEq);
+    m.set(0.5, 10.5, "a");
+    expect(m.toArray()).toStrictEqual([[0, "a"]]);
+  });
 });
 describe("copy", function () {
-    test("an empty map and check independence", function () {
-        var m = new IntervalMap([], keyCmp, valueEq);
-        var copy = m.copy();
-        m.set(0, 1, "a");
-        copy.set(0, 1, "b");
-        expect(m.get(0.5)).toBe("a");
-        expect(copy.get(0.5)).toBe("b");
-        expect(m.size()).toStrictEqual(2);
-        expect(copy.size()).toStrictEqual(2);
-    });
+  test("an empty map and check independence", function () {
+    var m = new IntervalMap([], keyCmp, valueEq);
+    var copy = m.copy();
+    m.set(0, 1, "a");
+    copy.set(0, 1, "b");
+    expect(m.get(0.5)).toBe("a");
+    expect(copy.get(0.5)).toBe("b");
+    expect(m.size()).toStrictEqual(2);
+    expect(copy.size()).toStrictEqual(2);
+  });
 });
 describe("compute difference for", function () {
-    test("one set op", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(0, 1, "a");
-        expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
-    });
-    test("two disjoint set ops", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-2, -1, "a").set(1, 2, "b");
-        expect(m2.minus(m1)).toStrictEqual([
-            [-2, -1, "a"],
-            [1, 2, "b"],
-        ]);
-    });
-    test("two adjacent set ops", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "b");
-        expect(m2.minus(m1)).toStrictEqual([
-            [-1, 0, "a"],
-            [0, 1, "b"],
-        ]);
-    });
-    test("two adjacent set ops with the same value", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "a");
-        expect(m2.minus(m1)).toStrictEqual([[-1, 1, "a"]]);
-    });
-    test("two intersecting set ops", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "b");
-        expect(m2.minus(m1)).toStrictEqual([
-            [-2, -1, "a"],
-            [-1, 2, "b"],
-        ]);
-    });
-    test("two intersecting set ops in reverse order", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-1, 2, "b").set(-2, 1, "a");
-        expect(m2.minus(m1)).toStrictEqual([
-            [-2, 1, "a"],
-            [1, 2, "b"],
-        ]);
-    });
-    test("two intersecting set ops with same value", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "a");
-        expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
-    });
-    test("two intersecting set ops with same value in reverse order", function () {
-        var m1 = new IntervalMap([], keyCmp, valueEq);
-        var m2 = m1.copy().set(-1, 2, "a").set(-2, 1, "a");
-        expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
-    });
-    test("set ops with no effect", function () {
-        var m1 = new IntervalMap([
-            [1, "a"],
-            [2, "b"],
-        ], keyCmp, valueEq);
-        var m2 = m1.copy().set(1, 1.5, "a").set(3, 4, "b");
-        expect(m2.minus(m1)).toStrictEqual([]);
-    });
-    test("one inexact set op", function () {
-        var m1 = new IntervalMap([
-            [1, "a"],
-            [2, "b"],
-        ], keyCmp, valueEq);
-        var m2 = m1.copy().set(0, 1.5, "a");
-        expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
-    });
-    test("another inexact set op", function () {
-        var m1 = new IntervalMap([
-            [1, "a"],
-            [2, "b"],
-        ], keyCmp, valueEq);
-        var m2 = m1.copy().set(1.5, 3, "b");
-        expect(m2.minus(m1)).toStrictEqual([[1.5, 2, "b"]]);
-    });
-    test("one set on a base map with many steps", function () {
-        var a = array(10);
-        var m1 = new IntervalMap(a, keyCmp, valueEq);
-        var m2 = m1.copy().set(0.5, 9, "a");
-        expect(m2.minus(m1)).toStrictEqual([[1, 9, "a"]]);
-    });
-    test("multiple sets overwritten by a final set", function () {
-        var m1 = new IntervalMap([[1, "a"]], keyCmp, valueEq);
-        var m2 = m1
-            .copy()
-            .set(2, 3, "b")
-            .set(3, 4, "c")
-            .set(4, 5, "d")
-            .set(1.5, 4, "a");
-        expect(m2.minus(m1)).toStrictEqual([[4, 5, "d"]]);
-    });
+  test("one set op", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(0, 1, "a");
+    expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
+  });
+  test("two disjoint set ops", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-2, -1, "a").set(1, 2, "b");
+    expect(m2.minus(m1)).toStrictEqual([
+      [-2, -1, "a"],
+      [1, 2, "b"],
+    ]);
+  });
+  test("two adjacent set ops", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "b");
+    expect(m2.minus(m1)).toStrictEqual([
+      [-1, 0, "a"],
+      [0, 1, "b"],
+    ]);
+  });
+  test("two adjacent set ops with the same value", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-1, 0, "a").set(0, 1, "a");
+    expect(m2.minus(m1)).toStrictEqual([[-1, 1, "a"]]);
+  });
+  test("two intersecting set ops", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "b");
+    expect(m2.minus(m1)).toStrictEqual([
+      [-2, -1, "a"],
+      [-1, 2, "b"],
+    ]);
+  });
+  test("two intersecting set ops in reverse order", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-1, 2, "b").set(-2, 1, "a");
+    expect(m2.minus(m1)).toStrictEqual([
+      [-2, 1, "a"],
+      [1, 2, "b"],
+    ]);
+  });
+  test("two intersecting set ops with same value", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-2, 1, "a").set(-1, 2, "a");
+    expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
+  });
+  test("two intersecting set ops with same value in reverse order", function () {
+    var m1 = new IntervalMap([], keyCmp, valueEq);
+    var m2 = m1.copy().set(-1, 2, "a").set(-2, 1, "a");
+    expect(m2.minus(m1)).toStrictEqual([[-2, 2, "a"]]);
+  });
+  test("set ops with no effect", function () {
+    var m1 = new IntervalMap(
+      [
+        [1, "a"],
+        [2, "b"],
+      ],
+      keyCmp,
+      valueEq,
+    );
+    var m2 = m1.copy().set(1, 1.5, "a").set(3, 4, "b");
+    expect(m2.minus(m1)).toStrictEqual([]);
+  });
+  test("one inexact set op", function () {
+    var m1 = new IntervalMap(
+      [
+        [1, "a"],
+        [2, "b"],
+      ],
+      keyCmp,
+      valueEq,
+    );
+    var m2 = m1.copy().set(0, 1.5, "a");
+    expect(m2.minus(m1)).toStrictEqual([[0, 1, "a"]]);
+  });
+  test("another inexact set op", function () {
+    var m1 = new IntervalMap(
+      [
+        [1, "a"],
+        [2, "b"],
+      ],
+      keyCmp,
+      valueEq,
+    );
+    var m2 = m1.copy().set(1.5, 3, "b");
+    expect(m2.minus(m1)).toStrictEqual([[1.5, 2, "b"]]);
+  });
+  test("one set on a base map with many steps", function () {
+    var a = array(10);
+    var m1 = new IntervalMap(a, keyCmp, valueEq);
+    var m2 = m1.copy().set(0.5, 9, "a");
+    expect(m2.minus(m1)).toStrictEqual([[1, 9, "a"]]);
+  });
+  test("multiple sets overwritten by a final set", function () {
+    var m1 = new IntervalMap([[1, "a"]], keyCmp, valueEq);
+    var m2 = m1
+      .copy()
+      .set(2, 3, "b")
+      .set(3, 4, "c")
+      .set(4, 5, "d")
+      .set(1.5, 4, "a");
+    expect(m2.minus(m1)).toStrictEqual([[4, 5, "d"]]);
+  });
 });
diff --git a/src/algorithms/Bisection.js b/src/algorithms/Bisection.js
index ecfd5ccf7..ec9eaf3ec 100644
--- a/src/algorithms/Bisection.js
+++ b/src/algorithms/Bisection.js
@@ -1,23 +1,25 @@
 export function bisect(a, x, cmpToX, lo, hi, findRightMost) {
-    if (lo === void 0) { lo = 0; }
-    if (hi === void 0) { hi = a.length; }
-    if (findRightMost === void 0) { findRightMost = false; }
-    if (hi <= lo)
-        return lo;
-    if (hi === lo + 1) {
-        var c_1 = cmpToX(a[lo]);
-        if (c_1 < 0)
-            return hi;
-        if (c_1 > 0)
-            return lo;
-        if (c_1 === 0 && findRightMost)
-            return hi;
-        return lo;
-    }
-    var mid = Math.floor((lo + hi) / 2.0);
-    var c = cmpToX(a[mid]);
-    if (c < 0 || (c === 0 && findRightMost)) {
-        return bisect(a, x, cmpToX, mid + 1, hi, findRightMost);
-    }
-    return bisect(a, x, cmpToX, lo, mid, findRightMost);
+  if (lo === void 0) {
+    lo = 0;
+  }
+  if (hi === void 0) {
+    hi = a.length;
+  }
+  if (findRightMost === void 0) {
+    findRightMost = false;
+  }
+  if (hi <= lo) return lo;
+  if (hi === lo + 1) {
+    var c_1 = cmpToX(a[lo]);
+    if (c_1 < 0) return hi;
+    if (c_1 > 0) return lo;
+    if (c_1 === 0 && findRightMost) return hi;
+    return lo;
+  }
+  var mid = Math.floor((lo + hi) / 2.0);
+  var c = cmpToX(a[mid]);
+  if (c < 0 || (c === 0 && findRightMost)) {
+    return bisect(a, x, cmpToX, mid + 1, hi, findRightMost);
+  }
+  return bisect(a, x, cmpToX, lo, mid, findRightMost);
 }
diff --git a/src/algorithms/IntervalMap.js b/src/algorithms/IntervalMap.js
index 14fa45d19..3e67ec8d9 100644
--- a/src/algorithms/IntervalMap.js
+++ b/src/algorithms/IntervalMap.js
@@ -1,126 +1,167 @@
 import { bisect } from "./Bisection";
 function copyArray(array) {
-    return array.map(function (element) { return [element[0], element[1]]; });
+  return array.map(function (element) {
+    return [element[0], element[1]];
+  });
 }
 var IntervalMap = (function () {
-    function IntervalMap(array, keyCmp, valueEq) {
-        this.array = [];
-        var copy = copyArray(array);
-        copy.sort(function (a, b) { return keyCmp(a[0], b[0]); });
-        var prevValue;
-        for (var _i = 0, copy_1 = copy; _i < copy_1.length; _i++) {
-            var _a = copy_1[_i], key = _a[0], value = _a[1];
-            if (!valueEq(value, prevValue)) {
-                this.array.push([key, value]);
-                prevValue = value;
-            }
-        }
-        this.keyCmp = keyCmp;
-        this.valueEq = valueEq;
+  function IntervalMap(array, keyCmp, valueEq) {
+    this.array = [];
+    var copy = copyArray(array);
+    copy.sort(function (a, b) {
+      return keyCmp(a[0], b[0]);
+    });
+    var prevValue;
+    for (var _i = 0, copy_1 = copy; _i < copy_1.length; _i++) {
+      var _a = copy_1[_i],
+        key = _a[0],
+        value = _a[1];
+      if (!valueEq(value, prevValue)) {
+        this.array.push([key, value]);
+        prevValue = value;
+      }
     }
-    IntervalMap.prototype.size = function () {
-        return this.array.length;
-    };
-    IntervalMap.prototype.get = function (key) {
-        var array = this.array;
-        var n = array.length;
-        var keyCmp = this.keyCmp;
-        if (n === 0)
-            return;
-        var idx = bisect(array, key, function (a) { return keyCmp(a[0], key); }, 0, n, false);
-        if (idx === n) {
-            return array[idx - 1][1];
-        }
-        if (keyCmp(array[idx][0], key) === 0) {
-            return array[idx][1];
-        }
-        if (idx > 0) {
-            return array[idx - 1][1];
-        }
-        return;
-    };
-    IntervalMap.prototype.set = function (key1, key2, value) {
-        var array = this.array;
-        var n = array.length;
-        var keyCmp = this.keyCmp;
-        var valueEq = this.valueEq;
-        if (keyCmp(key1, key2) >= 0)
-            return this;
-        if (n === 0) {
-            array.push([key1, value], [key2, undefined]);
-            return this;
-        }
-        var idx1 = bisect(array, key1, function (a) { return keyCmp(a[0], key1); }, 0, array.length, false);
-        if (idx1 === n) {
-            var v = array[n - 1][1];
-            if (!valueEq(value, v)) {
-                array.push([key1, value], [key2, v]);
-            }
-            return this;
-        }
-        var idx2 = bisect(array, key2, function (a) { return keyCmp(a[0], key2); }, 0, array.length, true) - 1;
-        if (idx2 === -1) {
-            if (!valueEq(value, undefined)) {
-                array.splice(0, 0, [key1, value], [key2, undefined]);
-            }
-            return this;
-        }
-        var insert1 = !(idx1 > 0 && valueEq(array[idx1 - 1][1], value));
-        var insert2 = !valueEq(array[idx2][1], value);
-        if (insert1 && insert2) {
-            array.splice(idx1, idx2 - idx1 + 1, [key1, value], [key2, array[idx2][1]]);
-        }
-        else if (insert1) {
-            array.splice(idx1, idx2 - idx1 + 1, [key1, value]);
-        }
-        else if (insert2) {
-            array.splice(idx1, idx2 - idx1 + 1, [key2, array[idx2][1]]);
-        }
-        else {
-            array.splice(idx1, idx2 - idx1 + 1);
-        }
-        return this;
-    };
-    IntervalMap.prototype.keys = function () {
-        return this.array.map(function (element) { return element[0]; });
-    };
-    IntervalMap.prototype.values = function () {
-        return this.array.map(function (element) { return element[1]; });
-    };
-    IntervalMap.prototype.toArray = function () {
-        return copyArray(this.array);
-    };
-    IntervalMap.prototype.copy = function () {
-        return new IntervalMap(this.array, this.keyCmp, this.valueEq);
-    };
-    IntervalMap.prototype.minus = function (baseMap) {
-        var _this = this;
-        var keys = this.keys().concat(baseMap.keys());
-        keys.sort(this.keyCmp);
-        var equalValues = keys.map(function (key) {
-            return _this.valueEq(_this.get(key), baseMap.get(key));
-        });
-        var idx = 0;
-        var diff = [];
-        while (idx + 1 < keys.length) {
-            if (!equalValues[idx]) {
-                diff.push([keys[idx], keys[idx + 1], this.get(keys[idx])]);
-            }
-            idx += 1;
-        }
-        var i = 0;
-        var mergedDiff = [];
-        while (i < diff.length) {
-            var _a = diff[i], st = _a[0], en = _a[1], val = _a[2];
-            while (i + 1 < diff.length && this.valueEq(diff[i][2], diff[i + 1][2])) {
-                en = diff[i + 1][1];
-                i += 1;
-            }
-            mergedDiff.push([st, en, val]);
-            i += 1;
-        }
-        return mergedDiff;
-    };
-    return IntervalMap;
-}());
+    this.keyCmp = keyCmp;
+    this.valueEq = valueEq;
+  }
+  IntervalMap.prototype.size = function () {
+    return this.array.length;
+  };
+  IntervalMap.prototype.get = function (key) {
+    var array = this.array;
+    var n = array.length;
+    var keyCmp = this.keyCmp;
+    if (n === 0) return;
+    var idx = bisect(
+      array,
+      key,
+      function (a) {
+        return keyCmp(a[0], key);
+      },
+      0,
+      n,
+      false,
+    );
+    if (idx === n) {
+      return array[idx - 1][1];
+    }
+    if (keyCmp(array[idx][0], key) === 0) {
+      return array[idx][1];
+    }
+    if (idx > 0) {
+      return array[idx - 1][1];
+    }
+    return;
+  };
+  IntervalMap.prototype.set = function (key1, key2, value) {
+    var array = this.array;
+    var n = array.length;
+    var keyCmp = this.keyCmp;
+    var valueEq = this.valueEq;
+    if (keyCmp(key1, key2) >= 0) return this;
+    if (n === 0) {
+      array.push([key1, value], [key2, undefined]);
+      return this;
+    }
+    var idx1 = bisect(
+      array,
+      key1,
+      function (a) {
+        return keyCmp(a[0], key1);
+      },
+      0,
+      array.length,
+      false,
+    );
+    if (idx1 === n) {
+      var v = array[n - 1][1];
+      if (!valueEq(value, v)) {
+        array.push([key1, value], [key2, v]);
+      }
+      return this;
+    }
+    var idx2 =
+      bisect(
+        array,
+        key2,
+        function (a) {
+          return keyCmp(a[0], key2);
+        },
+        0,
+        array.length,
+        true,
+      ) - 1;
+    if (idx2 === -1) {
+      if (!valueEq(value, undefined)) {
+        array.splice(0, 0, [key1, value], [key2, undefined]);
+      }
+      return this;
+    }
+    var insert1 = !(idx1 > 0 && valueEq(array[idx1 - 1][1], value));
+    var insert2 = !valueEq(array[idx2][1], value);
+    if (insert1 && insert2) {
+      array.splice(
+        idx1,
+        idx2 - idx1 + 1,
+        [key1, value],
+        [key2, array[idx2][1]],
+      );
+    } else if (insert1) {
+      array.splice(idx1, idx2 - idx1 + 1, [key1, value]);
+    } else if (insert2) {
+      array.splice(idx1, idx2 - idx1 + 1, [key2, array[idx2][1]]);
+    } else {
+      array.splice(idx1, idx2 - idx1 + 1);
+    }
+    return this;
+  };
+  IntervalMap.prototype.keys = function () {
+    return this.array.map(function (element) {
+      return element[0];
+    });
+  };
+  IntervalMap.prototype.values = function () {
+    return this.array.map(function (element) {
+      return element[1];
+    });
+  };
+  IntervalMap.prototype.toArray = function () {
+    return copyArray(this.array);
+  };
+  IntervalMap.prototype.copy = function () {
+    return new IntervalMap(this.array, this.keyCmp, this.valueEq);
+  };
+  IntervalMap.prototype.minus = function (baseMap) {
+    var _this = this;
+    var keys = this.keys().concat(baseMap.keys());
+    keys.sort(this.keyCmp);
+    var equalValues = keys.map(function (key) {
+      return _this.valueEq(_this.get(key), baseMap.get(key));
+    });
+    var idx = 0;
+    var diff = [];
+    while (idx + 1 < keys.length) {
+      if (!equalValues[idx]) {
+        diff.push([keys[idx], keys[idx + 1], this.get(keys[idx])]);
+      }
+      idx += 1;
+    }
+    var i = 0;
+    var mergedDiff = [];
+    while (i < diff.length) {
+      var _a = diff[i],
+        st = _a[0],
+        en = _a[1],
+        val = _a[2];
+      while (i + 1 < diff.length && this.valueEq(diff[i][2], diff[i + 1][2])) {
+        en = diff[i + 1][1];
+        i += 1;
+      }
+      mergedDiff.push([st, en, val]);
+      i += 1;
+    }
+    return mergedDiff;
+  };
+  return IntervalMap;
+})();
 export { IntervalMap };
diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 8e6c54f1b..326286b36 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -45,7 +45,7 @@ const DATE_INPUT_MODES = {
   DEFAULT: "default",
   YEARLY: "yearly",
   DATE: "date",
-  MULTI_YEAR: "multi-year"
+  MULTI_YEAR: "multi-year",
 };
 
 export default function ParameterEditor(props) {
@@ -109,7 +109,10 @@ export default function ParameterEditor(props) {
     description = "";
   }
 
-  const gridColumns = dateInputMode === DATE_INPUT_MODES.MULTI_YEAR ? "auto min-content" : "auto auto min-content";
+  const gridColumns =
+    dateInputMode === DATE_INPUT_MODES.MULTI_YEAR
+      ? "auto min-content"
+      : "auto auto min-content";
 
   return (
     <CenteredMiddleColumn
@@ -152,7 +155,7 @@ export default function ParameterEditor(props) {
               display: "grid",
               gridTemplateColumns: gridColumns,
               gap: "10px",
-              padding: "0px 50px 0px 12px"
+              padding: "0px 50px 0px 12px",
             }}
           >
             <PeriodSetter
@@ -167,22 +170,18 @@ export default function ParameterEditor(props) {
               reformMap={reformMap}
               policy={policy}
             />
-            {
-              dateInputMode !== DATE_INPUT_MODES.MULTI_YEAR && (
-                <ValueSetter
-                  startDate={startDate}
-                  endDate={endDate}
-                  parameterName={parameterName}
-                  policy={policy}
-                  metadata={metadata}
-                  reformMap={reformMap}
-                  baseMap={baseMap}
-                />
-              )
-            }
-            <SettingsPanel 
-              setDateInputMode={setDateInputMode}
-            />
+            {dateInputMode !== DATE_INPUT_MODES.MULTI_YEAR && (
+              <ValueSetter
+                startDate={startDate}
+                endDate={endDate}
+                parameterName={parameterName}
+                policy={policy}
+                metadata={metadata}
+                reformMap={reformMap}
+                baseMap={baseMap}
+              />
+            )}
+            <SettingsPanel setDateInputMode={setDateInputMode} />
           </div>
         </div>
         {!parameter.economy && (
@@ -233,7 +232,7 @@ export default function ParameterEditor(props) {
 }
 
 function PeriodSetter(props) {
-  const { 
+  const {
     inputMode,
     metadata,
     startDate,
@@ -243,9 +242,9 @@ function PeriodSetter(props) {
     parameterName,
     baseMap,
     reformMap,
-    policy
+    policy,
   } = props;
-  
+
   const FOREVER_DATE = String(defaultForeverYear).concat("-12-31");
 
   // Array of selectable years, sorted in ascending order
@@ -267,7 +266,7 @@ function PeriodSetter(props) {
     maxPossibleDate,
     isEndForever,
     possibleYears,
-    FOREVER_DATE
+    FOREVER_DATE,
   };
 
   const tenYearProps = {
@@ -275,7 +274,7 @@ function PeriodSetter(props) {
     metadata,
     baseMap,
     reformMap,
-    policy
+    policy,
   };
 
   switch (inputMode) {
@@ -291,13 +290,8 @@ function PeriodSetter(props) {
 }
 
 function DefaultPeriodSetter(props) {
-  const {
-    startDate,
-    setStartDate,
-    setEndDate,
-    possibleYears,
-    FOREVER_DATE
-  } = props;
+  const { startDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE } =
+    props;
 
   let defaultStartYear = null;
   if (startDate) {
@@ -324,7 +318,7 @@ function DefaultPeriodSetter(props) {
   const options = possibleYears.map((year) => {
     return {
       label: year,
-      value: year
+      value: year,
     };
   });
 
@@ -339,23 +333,30 @@ function DefaultPeriodSetter(props) {
         // The below keeps the font in line with
         // the selector components
         fontSize: "14px",
-        gap: "10px"
+        gap: "10px",
       }}
     >
-      <p style={{marginBottom: 0}}>from</p>
+      <p style={{ marginBottom: 0 }}>from</p>
       <Select
         options={options}
         defaultValue={defaultStartYear}
         onChange={handleStartYearChange}
       />
-      <p style={{marginBottom: 0}}>onward:</p>
+      <p style={{ marginBottom: 0 }}>onward:</p>
     </div>
   );
-
 }
 
 function YearPeriodSetter(props) {
-  const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
+  const {
+    startDate,
+    endDate,
+    setStartDate,
+    setEndDate,
+    minPossibleDate,
+    maxPossibleDate,
+    isEndForever,
+  } = props;
 
   return (
     <RangePicker
@@ -371,11 +372,19 @@ function YearPeriodSetter(props) {
       }
       separator="→"
     />
-  )
+  );
 }
 
 function DatePeriodSetter(props) {
-  const { startDate, endDate, setStartDate, setEndDate, minPossibleDate, maxPossibleDate, isEndForever } = props;
+  const {
+    startDate,
+    endDate,
+    setStartDate,
+    setEndDate,
+    minPossibleDate,
+    maxPossibleDate,
+    isEndForever,
+  } = props;
 
   return (
     <RangePicker
@@ -394,12 +403,12 @@ function DatePeriodSetter(props) {
 }
 
 function MultiYearPeriodSetter(props) {
-  const { possibleYears, parameterName, baseMap, reformMap, metadata, policy } = props;
+  const { possibleYears, parameterName, baseMap, reformMap, metadata, policy } =
+    props;
 
   // Populate map before rendering anything
   // function populateValueMap() {
   const populateValueMap = useCallback(() => {
-
     const valueMap = new Map();
     possibleYears.forEach((year) => {
       if (year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS) {
@@ -416,7 +425,6 @@ function MultiYearPeriodSetter(props) {
   const [searchParams, setSearchParams] = useSearchParams();
   const paramRef = useRef(parameterName);
 
-
   // This is necessary because technically, MultiYearPeriodSetter does not
   // unmount when we change between parameters, leading to the possibility
   // for a stale "value" state in this controlled component
@@ -438,7 +446,6 @@ function MultiYearPeriodSetter(props) {
   // Handler that iterates over each entry, validates that
   // all values are valid, then updates each value one by one
   function handleSubmit() {
-
     let allData = {};
     for (const [year, value] of valueMap) {
       const startDate = String(year).concat("-01-01");
@@ -447,7 +454,7 @@ function MultiYearPeriodSetter(props) {
       let data = {};
       reformMap.minus(baseMap).forEach(([k1, k2, v]) => {
         data[`${k1}.${prevDay(k2)}`] = v;
-      }); 
+      });
       allData = { ...allData, ...data };
     }
 
@@ -480,9 +487,11 @@ function MultiYearPeriodSetter(props) {
   // Iterate over possibleYears, beginning with
   // defaultYear, and return up to 10 input
   // components
-  const yearInputs = possibleYears.filter((year) => 
-    year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS
-  ).map((year) => {
+  const yearInputs = possibleYears
+    .filter(
+      (year) => year >= defaultYear && year < defaultYear + NUMBER_OF_YEARS,
+    )
+    .map((year) => {
       return (
         <div
           key={String(year).concat("-input")}
@@ -495,8 +504,8 @@ function MultiYearPeriodSetter(props) {
             fontSize: "14px",
           }}
         >
-          <p style={{marginBottom: 0}}>{year}:</p>
-          <OneYearValueSetter 
+          <p style={{ marginBottom: 0 }}>{year}:</p>
+          <OneYearValueSetter
             year={year}
             parameterName={parameterName}
             metadata={metadata}
@@ -510,8 +519,8 @@ function MultiYearPeriodSetter(props) {
 
   // This will give us the first half of the year inputs (if length of yearInputs is even)
   // or the first half, plus 1, if length of yearInputs is odd
-   const yearInputsLeft = yearInputs.slice(0, Math.ceil(yearInputs.length / 2));
-   const yearInputsRight = yearInputs.slice(Math.ceil(yearInputs.length / 2));
+  const yearInputsLeft = yearInputs.slice(0, Math.ceil(yearInputs.length / 2));
+  const yearInputsRight = yearInputs.slice(Math.ceil(yearInputs.length / 2));
 
   return (
     <div
@@ -563,13 +572,7 @@ function MultiYearPeriodSetter(props) {
 }
 
 function OneYearValueSetter(props) {
-  const {
-    year,
-    parameterName,
-    metadata,
-    valueMap,
-    setValueMap,
-  } = props;
+  const { year, parameterName, metadata, valueMap, setValueMap } = props;
 
   const startValue = valueMap.get(year);
   const parameter = metadata.parameters[parameterName];
@@ -777,9 +780,11 @@ function AdvancedValueSetter(props) {
           fontSize: "0.8rem",
           marginBottom: 0,
           paddingBottom: 0,
-          color: style.colors.DARK_GRAY
+          color: style.colors.DARK_GRAY,
         }}
-      >Custom values</p>
+      >
+        Custom values
+      </p>
       <Button
         style={{
           fontSize: "14px",
@@ -787,13 +792,13 @@ function AdvancedValueSetter(props) {
           fontFamily: style.fonts.BODY_FONT,
           marginBottom: "5px",
           textAlign: "left",
-          width: "100%"
+          width: "100%",
         }}
         onClick={() => handleValueInput(Infinity)}
       >
         <span
           style={{
-            fontSize: "1.2rem"
+            fontSize: "1.2rem",
           }}
         >
           &infin;&nbsp;
@@ -806,13 +811,13 @@ function AdvancedValueSetter(props) {
           aspectRatio: 1,
           fontFamily: style.fonts.BODY_FONT,
           textAlign: "left",
-          width: "100%"
+          width: "100%",
         }}
         onClick={() => handleValueInput(-Infinity)}
       >
         <span
           style={{
-            fontSize: "1.2rem"
+            fontSize: "1.2rem",
           }}
         >
           -&infin;&nbsp;
@@ -825,12 +830,12 @@ function AdvancedValueSetter(props) {
   return (
     <>
       <Tooltip title="More input options">
-        <Popover 
-          content={popoverContent} 
-          placement="bottomRight" 
+        <Popover
+          content={popoverContent}
+          placement="bottomRight"
           trigger="click"
           overlayStyle={{
-            minWidth: "150px"
+            minWidth: "150px",
           }}
         >
           <Button
@@ -856,21 +861,21 @@ function SettingsPanel(props) {
   const modeOptions = [
     {
       label: "Default",
-      value: DATE_INPUT_MODES.DEFAULT
+      value: DATE_INPUT_MODES.DEFAULT,
     },
     {
       label: "Yearly",
-      value: DATE_INPUT_MODES.YEARLY
+      value: DATE_INPUT_MODES.YEARLY,
     },
     {
       label: "Date",
-      value: DATE_INPUT_MODES.DATE
+      value: DATE_INPUT_MODES.DATE,
     },
     {
       label: "Multi-year",
-      value: DATE_INPUT_MODES.MULTI_YEAR
-    }
-  ]
+      value: DATE_INPUT_MODES.MULTI_YEAR,
+    },
+  ];
 
   const popoverContent = (
     <div
@@ -887,12 +892,14 @@ function SettingsPanel(props) {
           fontSize: "0.8rem",
           marginBottom: 0,
           paddingBottom: 0,
-          color: style.colors.DARK_GRAY
+          color: style.colors.DARK_GRAY,
         }}
-      >Input mode</p>
-      <Radio.Group 
-        optionType="button" 
-        options={modeOptions} 
+      >
+        Input mode
+      </p>
+      <Radio.Group
+        optionType="button"
+        options={modeOptions}
         defaultValue={modeOptions[0].value}
         buttonStyle="solid"
         onChange={handleModeChange}
@@ -901,15 +908,11 @@ function SettingsPanel(props) {
   );
 
   return (
-    <Popover 
-      content={popoverContent} 
-      placement="bottomRight" 
-      trigger="click"
-    >
+    <Popover content={popoverContent} placement="bottomRight" trigger="click">
       <Button
         style={{
           aspectRatio: 1,
-          width: "100%"
+          width: "100%",
         }}
       >
         <SettingOutlined />

From b23745995c06b69d78b8b978435ce5d2d220b2fe Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 21:43:43 +0200
Subject: [PATCH 29/31] fix: Correct bug in DefaultPeriodSetter

---
 src/pages/policy/input/ParameterEditor.jsx | 29 +++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index 326286b36..a6e3ca05a 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -267,10 +267,10 @@ function PeriodSetter(props) {
     isEndForever,
     possibleYears,
     FOREVER_DATE,
+    parameterName
   };
 
   const tenYearProps = {
-    parameterName,
     metadata,
     baseMap,
     reformMap,
@@ -290,26 +290,24 @@ function PeriodSetter(props) {
 }
 
 function DefaultPeriodSetter(props) {
-  const { startDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE } =
+  const { startDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName } =
     props;
 
-  let defaultStartYear = null;
-  if (startDate) {
-    defaultStartYear = new Date(startDate).getFullYear();
-  } else if (possibleYears.includes(defaultYear)) {
-    defaultStartYear = defaultYear;
-  } else {
-    defaultStartYear = possibleYears[0];
-  }
+  const startYear = new Date(startDate).getFullYear();
 
-  // When this component mounts, set the start date to Jan. 1 of
-  // either the reform year or the default year, and set end to FOREVER_DATE
+  const [value, setValue] = useState(startYear);
+
+  // When this component mounts or param name changes, set the start date to Jan. 1 of
+  // the startDate value's year and set end to FOREVER_DATE
   useEffect(() => {
-    setStartDate(String(defaultStartYear).concat("-01-01"));
+    setStartDate(String(value).concat("-01-01"));
     setEndDate(FOREVER_DATE);
-  }, [FOREVER_DATE, defaultStartYear, setStartDate, setEndDate]);
+  }, [FOREVER_DATE, value, setStartDate, setEndDate, parameterName]);
 
+  // On change, set the start date to Jan. 1 of the selected year
+  // and update value
   function handleStartYearChange(value) {
+    setValue(value);
     setStartDate(String(value).concat("-01-01"));
   }
 
@@ -339,7 +337,8 @@ function DefaultPeriodSetter(props) {
       <p style={{ marginBottom: 0 }}>from</p>
       <Select
         options={options}
-        defaultValue={defaultStartYear}
+        defaultValue={startYear}
+        value={value}
         onChange={handleStartYearChange}
       />
       <p style={{ marginBottom: 0 }}>onward:</p>

From 1bccbe42883387e312fd596ca1669fde051a3183 Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 21:55:14 +0200
Subject: [PATCH 30/31] fix: Add endDate as effect hook dep

---
 src/pages/policy/input/ParameterEditor.jsx | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index a6e3ca05a..a91414ca6 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -290,19 +290,20 @@ function PeriodSetter(props) {
 }
 
 function DefaultPeriodSetter(props) {
-  const { startDate, setStartDate, setEndDate, possibleYears, FOREVER_DATE, parameterName } =
+  const { startDate, setStartDate, endDate, setEndDate, possibleYears, FOREVER_DATE, parameterName } =
     props;
 
   const startYear = new Date(startDate).getFullYear();
 
   const [value, setValue] = useState(startYear);
 
-  // When this component mounts or param name changes, set the start date to Jan. 1 of
+  // When this component mounts, or param name changes, or ParameterEditor
+  // updates endDate (this happens in select few cases), set the start date to Jan. 1 of
   // the startDate value's year and set end to FOREVER_DATE
   useEffect(() => {
     setStartDate(String(value).concat("-01-01"));
     setEndDate(FOREVER_DATE);
-  }, [FOREVER_DATE, value, setStartDate, setEndDate, parameterName]);
+  }, [endDate, parameterName, FOREVER_DATE, value, setStartDate, setEndDate ]);
 
   // On change, set the start date to Jan. 1 of the selected year
   // and update value

From 580a3c56df42cf010dd971f844b0498589b6eeba Mon Sep 17 00:00:00 2001
From: Anthony Volk <anth.volk@gmail.com>
Date: Mon, 21 Oct 2024 22:07:05 +0200
Subject: [PATCH 31/31] chore: Lint

---
 src/pages/policy/input/ParameterEditor.jsx | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/pages/policy/input/ParameterEditor.jsx b/src/pages/policy/input/ParameterEditor.jsx
index a91414ca6..44e448f8b 100644
--- a/src/pages/policy/input/ParameterEditor.jsx
+++ b/src/pages/policy/input/ParameterEditor.jsx
@@ -267,7 +267,7 @@ function PeriodSetter(props) {
     isEndForever,
     possibleYears,
     FOREVER_DATE,
-    parameterName
+    parameterName,
   };
 
   const tenYearProps = {
@@ -290,8 +290,15 @@ function PeriodSetter(props) {
 }
 
 function DefaultPeriodSetter(props) {
-  const { startDate, setStartDate, endDate, setEndDate, possibleYears, FOREVER_DATE, parameterName } =
-    props;
+  const {
+    startDate,
+    setStartDate,
+    endDate,
+    setEndDate,
+    possibleYears,
+    FOREVER_DATE,
+    parameterName,
+  } = props;
 
   const startYear = new Date(startDate).getFullYear();
 
@@ -303,7 +310,7 @@ function DefaultPeriodSetter(props) {
   useEffect(() => {
     setStartDate(String(value).concat("-01-01"));
     setEndDate(FOREVER_DATE);
-  }, [endDate, parameterName, FOREVER_DATE, value, setStartDate, setEndDate ]);
+  }, [endDate, parameterName, FOREVER_DATE, value, setStartDate, setEndDate]);
 
   // On change, set the start date to Jan. 1 of the selected year
   // and update value