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/es-toolkit/dist/compat/function/memoize.d.ts

@@ -0,0 +1,120 @@
+//#region src/compat/function/memoize.d.ts
+interface MapCache {
+  /**
+   * Removes the value associated with the specified key from the cache.
+   *
+   * @param key - The key of the value to remove
+   * @returns `true` if an element was removed, `false` if the key wasn't found
+   *
+   * @example
+   * ```typescript
+   * cache.set('user', { id: 123, name: 'John' });
+   * cache.delete('user'); // Returns true
+   * cache.delete('unknown'); // Returns false
+   * ```
+   */
+  delete(key: any): boolean;
+  /**
+   * Retrieves the value associated with the specified key from the cache.
+   *
+   * @param key - The key of the value to retrieve
+   * @returns The cached value or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * cache.set('user', { id: 123, name: 'John' });
+   * cache.get('user'); // Returns { id: 123, name: 'John' }
+   * cache.get('unknown'); // Returns undefined
+   * ```
+   */
+  get(key: any): any;
+  /**
+   * Checks if the cache contains a value for the specified key.
+   *
+   * @param key - The key to check for existence
+   * @returns `true` if the key exists in the cache, otherwise `false`
+   *
+   * @example
+   * ```typescript
+   * cache.set('user', { id: 123, name: 'John' });
+   * cache.has('user'); // Returns true
+   * cache.has('unknown'); // Returns false
+   * ```
+   */
+  has(key: any): boolean;
+  /**
+   * Stores a value in the cache with the specified key.
+   * If the key already exists, its value is updated.
+   *
+   * @param key - The key to associate with the value
+   * @param value - The value to store in the cache
+   * @returns The cache instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * cache.set('user', { id: 123, name: 'John' })
+   *      .set('settings', { theme: 'dark' });
+   * ```
+   */
+  set(key: any, value: any): this;
+  /**
+   * Removes all key-value pairs from the cache.
+   * This method is optional as some cache implementations may be immutable.
+   *
+   * @example
+   * ```typescript
+   * cache.set('user', { id: 123, name: 'John' });
+   * cache.set('settings', { theme: 'dark' });
+   * cache.clear(); // Cache is now empty
+   * ```
+   */
+  clear?(): void;
+}
+/**
+ * Constructor interface for creating a new MapCache instance.
+ * This defines the shape of a constructor that can create cache objects
+ * conforming to the MapCache interface.
+ *
+ * @example
+ * ```typescript
+ * class CustomCache implements MapCache {
+ *   // Cache implementation
+ * }
+ *
+ * const CacheConstructor: MapCacheConstructor = CustomCache;
+ * const cache = new CacheConstructor();
+ * ```
+ */
+interface MapCacheConstructor {
+  new (): MapCache;
+}
+/**
+ * Represents a function that has been memoized.
+ * A memoized function maintains the same signature as the original function
+ * but adds a cache property to store previously computed results.
+ *
+ * @template T - The type of the original function being memoized
+ */
+interface MemoizedFunction {
+  /**
+   * The cache storing previously computed results
+   */
+  cache: MapCache;
+}
+/**
+ * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+ * storing the result based on the arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+ * the this binding of the memoized function.
+ *
+ * @template T - The type of the original function being memoized
+ * @param func The function to have its output memoized.
+ * @param [resolver] The function to resolve the cache key.
+ * @return {MemoizedFunction<T>} Returns the new memoizing function.
+ */
+declare function memoize<T extends (...args: any) => any>(func: T, resolver?: (...args: Parameters<T>) => any): T & MemoizedFunction;
+declare namespace memoize {
+  var Cache: MapCacheConstructor;
+}
+//#endregion
+export { memoize };