Add settings page for managing forecasting API key and URL via UI

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

frontend/node_modules/recharts/lib/animation/useAnimationStartSnapshot.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimationStartSnapshot = useAnimationStartSnapshot;
+var _react = require("react");
+/**
+ * Small state machine shared by animated components that need interruption-safe
+ * animations.
+ *
+ * Why this exists:
+ * Recharts stores the latest visible animation frame in mutable refs so the next
+ * animation can resume from that exact geometry. That works well, but there is a
+ * subtle trap: when an animation is interrupted, React may render several times
+ * before the new animation has actually emitted its own `animationElapsedTime=0` frame. If we keep
+ * reading and writing the same live ref during that window, the "start" value of
+ * the new animation can drift, which produces visible jumps.
+ *
+ * This hook separates those two responsibilities:
+ * - `startValue` is a frozen snapshot of the previous animation state, captured
+ *   once per animation cycle and kept stable while that cycle is being matched
+ *   and interpolated.
+ * - `previousValueRef.current` remains the mutable "latest visible frame" store
+ *   that future animations can resume from.
+ *
+ * The hook does not know anything about points, baselines, sectors, or shapes.
+ * It only manages *when* a snapshot is captured and *when* new frames are allowed
+ * to overwrite the mutable ref.
+ *
+ * Lifecycle:
+ * 1. When `animationInput` changes by reference, a new cycle begins. We capture
+ *    the current ref value into `startValue` and temporarily block writes.
+ * 2. When the new animation renders `animationElapsedTime=0`, we unlock writes. This ensures the new
+ *    animation has had a chance to render its true starting frame before any live
+ *    ref gets updated.
+ * 3. For `animationElapsedTime > 0`, callers may commit the visible frame back into the mutable ref.
+ *    Callers can still veto that with `canCommit=false` (for example when a Line
+ *    needs to wait until SVG path length has been measured).
+ * 4. At `animationElapsedTime=1`, we also refresh the frozen snapshot so subsequent rerenders in the
+ *    completed state observe the finished geometry.
+ */
+function useAnimationStartSnapshot(animationInput, previousValueRef) {
+  /*
+   * Stores the identity of the animation cycle we are currently serving.
+   * As soon as this changes, we know we need a brand new frozen snapshot.
+   */
+  var previousAnimationInputRef = (0, _react.useRef)(animationInput);
+  /*
+   * Frozen start-of-cycle value used for interpolation.
+   * This is the value callers should match against for the whole duration of the
+   * current animation, even if the live ref is updated many times afterward.
+   */
+  var startValueRef = (0, _react.useRef)(previousValueRef.current);
+  /*
+   * Prevents us from writing back into the live ref until the new animation has
+   * actually rendered its own animationElapsedTime=0 frame. This avoids "pre-start" renders from
+   * accidentally rebasing the next animation onto already-shifted geometry.
+   */
+  var isReadyToCommitRef = (0, _react.useRef)(true);
+  if (previousAnimationInputRef.current !== animationInput) {
+    // New animation cycle: capture exactly one frozen starting snapshot.
+    previousAnimationInputRef.current = animationInput;
+    startValueRef.current = previousValueRef.current;
+    // Writes stay blocked until the new cycle acknowledges its animationElapsedTime=0 frame.
+    isReadyToCommitRef.current = false;
+  }
+  var syncStepValue = (0, _react.useCallback)(function (stepValue, animationElapsedTime) {
+    var canCommit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    if (animationElapsedTime === 0) {
+      /*
+       * animationElapsedTime=0 is the handshake that says: "the new animation has now rendered its
+       * own starting frame". We do not write anything yet; we only allow later
+       * in-flight frames to be committed safely.
+       */
+      isReadyToCommitRef.current = true;
+      return;
+    }
+    if (animationElapsedTime === 1) {
+      // Keep the frozen snapshot aligned with the fully completed geometry.
+      startValueRef.current = stepValue;
+    }
+    if (animationElapsedTime > 0 && isReadyToCommitRef.current && canCommit) {
+      /*
+       * Commit the latest visible frame so a future interruption can resume from
+       * exactly what the user saw on screen most recently.
+       */
+      // eslint-disable-next-line no-param-reassign
+      previousValueRef.current = stepValue;
+    }
+  }, [previousValueRef]);
+  return {
+    startValue: startValueRef.current,
+    syncStepValue
+  };
+}