@marimo-team/islands 0.25.3-dev28 → 0.25.3-dev281

package/src/utils/createReducer.ts

@@ -1,52 +1,52 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* oxlint-disable typescript/no-explicit-any */
 
 import { atom, useSetAtom } from "jotai";
 import type { Reducer } from "react";
 import { Logger } from "@/utils/Logger";
 
-export type NoInfer<T> = [T][T extends any ? 0 : never];
-
-type Dispatch<RH> = (action: ReducerActionOf<RH>) => void;
-type IfUnknown<T, Y, N> = unknown extends T ? Y : N;
+type ReducerHandlers<State, Payloads> = {
+  [Type in keyof Payloads]: (state: State, payload: Payloads[Type]) => State;
+};
 
-type ReducerHandler<State, Payload> = (state: State, payload: Payload) => State;
+type ReducerConstraints<State> = Record<
+  string,
+  (state: State, payload: never) => State
+>;
+
+type PayloadsOf<RH> = {
+  [Type in keyof RH]: RH[Type] extends (
+    state: never,
+    payload: infer Payload,
+  ) => unknown
+    ? Payload
+    : never;
+};
 
-interface ReducerHandlers<State> {
-  [k: string]: ReducerHandler<State, any>;
-}
+type Dispatch<Payloads> = (action: ReducerActionOf<Payloads>) => void;
 
-type ReducerActions<RH extends ReducerHandlers<any>> = {
-  [Type in keyof RH]: RH[Type] extends ReducerHandler<any, infer Payload>
-    ? IfUnknown<Payload, () => void, (payload: Payload) => void>
-    : never;
+type ReducerActions<Payloads> = {
+  [Type in keyof Payloads]: unknown extends Payloads[Type]
+    ? () => void
+    : (payload: Payloads[Type]) => void;
 };
 
 /** Helper for typing middleware that receives dispatched actions. */
 export type DispatchedActionOf<T> = {
-  [Key in keyof T]: T[Key] extends (payload: infer P) => any
+  [Key in keyof T]: T[Key] extends (payload: infer P) => unknown
     ? { type: Key; payload: P }
     : never;
 }[keyof T & string];
 
-type ReducerActionOf<RH> = {
-  [Type in keyof RH]: RH[Type] extends ReducerHandler<any, infer Payload>
-    ? { type: Type; payload: Payload }
-    : never;
-}[keyof RH & string];
+type ReducerActionOf<
+  Payloads,
+  Key extends keyof Payloads & string = keyof Payloads & string,
+> = {
+  [Type in Key]: { type: Type; payload: Payloads[Type] };
+}[Key];
 
-export interface ReducerCreatorResult<
-  State,
-  RH extends ReducerHandlers<State>,
-> {
-  /**
-   * The reducer function.
-   */
-  reducer: Reducer<State, any>;
-  /**
-   * Given a dispatch function, returns an object containing all the actions.
-   */
-  createActions: (dispatch: Dispatch<RH>) => ReducerActions<RH>;
+export interface ReducerCreatorResult<State, Payloads> {
+  reducer: Reducer<State, ReducerActionOf<Payloads>>;
+  createActions: (dispatch: Dispatch<Payloads>) => ReducerActions<Payloads>;
 }
 
 /**
@@ -54,93 +54,129 @@ export interface ReducerCreatorResult<
  */
 export function createReducer<
   State,
-  RH extends ReducerHandlers<NoInfer<State>>,
->(initialState: () => State, reducers: RH): ReducerCreatorResult<State, RH> {
+  RH extends ReducerConstraints<NoInfer<State>>,
+>(
+  initialState: () => State,
+  reducers: RH & ReducerHandlers<NoInfer<State>, PayloadsOf<RH>>,
+): ReducerCreatorResult<State, PayloadsOf<RH>> {
+  type Payloads = PayloadsOf<RH>;
+  const handlers: ReducerHandlers<State, Payloads> = reducers;
   return {
-    reducer: (state, action: ReducerActionOf<RH>) => {
+    reducer: (state, action) => {
       state = state || initialState();
-      if (action.type in reducers) {
-        return reducers[action.type](state, action.payload);
+      if (action.type in handlers) {
+        return handlers[action.type](state, action.payload);
       }
 
       Logger.error(`Action type ${action.type} is not defined in reducers.`);
       return state;
     },
-    createActions: (dispatch: Dispatch<RH>) => {
-      const actions = {} as ReducerActions<RH>;
-      for (const type in reducers) {
-        (actions as any)[type] = (payload: any) => {
-          dispatch({ type, payload } as any);
-        };
+    createActions: (dispatch) => {
+      const actions: {
+        [Key in keyof Payloads]?: (payload: Payloads[Key]) => void;
+      } = {};
+      const addAction = <Key extends keyof Payloads & string>(type: Key) => {
+        actions[type] = (payload) => dispatch({ type, payload });
+      };
+      for (const type in handlers) {
+        addAction(type);
       }
-      return actions;
+      // The loop fills every key; payload-free creators receive undefined.
+      return actions as ReducerActions<Payloads>;
     },
   };
 }
 
-type Middleware<State, RH> = (
+type Middleware<State, Payloads> = (
   prevState: State,
   newState: State,
-  action: ReducerActionOf<RH>,
+  action: ReducerActionOf<Payloads>,
 ) => void;
 
 export function createReducerAndAtoms<
   State,
-  RH extends ReducerHandlers<NoInfer<State>>,
+  RH extends ReducerConstraints<NoInfer<State>>,
 >(
   initialState: () => State,
-  reducers: RH,
-  middleware?: Middleware<State, NoInfer<RH>>[],
+  reducers: RH & ReducerHandlers<NoInfer<State>, PayloadsOf<RH>>,
+  middleware?: NoInfer<Middleware<State, PayloadsOf<RH>>[]>,
 ) {
+  type Payloads = PayloadsOf<RH>;
   const allMiddleware = [...(middleware ?? [])];
-  const addMiddleware = (mw: Middleware<State, RH>) => {
+  const addMiddleware = (mw: Middleware<State, Payloads>) => {
     allMiddleware.push(mw);
   };
-  const { reducer, createActions } = createReducer(initialState, reducers);
+  const { reducer, createActions } = createReducer<State, RH>(
+    initialState,
+    reducers,
+  );
 
-  const reducerWithMiddleware = (state: State, action: ReducerActionOf<RH>) => {
+  const reduceSafely = (state: State, action: ReducerActionOf<Payloads>) => {
     try {
-      const newState = reducer(state, action);
-      for (const mw of allMiddleware) {
-        try {
-          mw(state, newState, action);
-        } catch (error) {
-          Logger.error(`Error in middleware for action ${action.type}:`, error);
-        }
-      }
-      return newState;
+      return reducer(state, action);
     } catch (error) {
       Logger.error(`Error in reducer for action ${action.type}:`, error);
       return state;
     }
   };
 
+  const runMiddleware = (
+    prev: State,
+    next: State,
+    action: ReducerActionOf<Payloads>,
+  ) => {
+    for (const mw of allMiddleware) {
+      try {
+        mw(prev, next, action);
+      } catch (error) {
+        Logger.error(`Error in middleware for action ${action.type}:`, error);
+      }
+    }
+  };
+
+  const reducerWithMiddleware = (
+    state: State,
+    action: ReducerActionOf<Payloads>,
+  ) => {
+    const next = reduceSafely(state, action);
+    runMiddleware(state, next, action);
+    return next;
+  };
+
   const valueAtom = atom(initialState());
-  // map of SetAtom => Actions
-  const actionsMap = new WeakMap();
+  type ActionsCache = WeakMap<
+    ReturnType<typeof useSetAtom<typeof valueAtom>>,
+    ReducerActions<Payloads>
+  >;
+  const actionsMap: ActionsCache = new WeakMap();
+  const plainActionsMap: ActionsCache = new WeakMap();
 
   function useActions(
     options: { skipMiddleware?: boolean } = {},
-  ): ReducerActions<RH> {
+  ): ReducerActions<Payloads> {
     const setState = useSetAtom(valueAtom);
+    const skipMiddleware = options.skipMiddleware === true;
+    const cache = skipMiddleware ? plainActionsMap : actionsMap;
 
-    if (options.skipMiddleware === true) {
-      return createActions((action: ReducerActionOf<RH>) => {
-        setState((state: State) => reducer(state, action));
-      });
+    const cachedActions = cache.get(setState);
+    if (cachedActions) {
+      return cachedActions;
     }
-
-    if (!actionsMap.has(setState)) {
-      actionsMap.set(
-        setState,
-        createActions((action: ReducerActionOf<RH>) => {
-          setState((state: State) => reducerWithMiddleware(state, action));
-        }),
-      );
-    }
-
-    // oxlint-disable-next-line typescript/no-non-null-assertion
-    return actionsMap.get(setState)!;
+    const actions = createActions((action) => {
+      // Middleware runs after the write commits so it observes the new state.
+      let prev: State | undefined;
+      let next: State | undefined;
+      setState((state: State) => {
+        prev = state;
+        next = reduceSafely(state, action);
+        return next;
+      });
+      if (!skipMiddleware && prev !== undefined && next !== undefined) {
+        runMiddleware(prev, next, action);
+      }
+    });
+    cache.set(setState, actions);
+    return actions;
   }
 
   return {

package/src/utils/download.ts

@@ -12,6 +12,7 @@ import { captureExternalIframes } from "./iframe";
 import { Logger } from "./Logger";
 import { ProgressState } from "./progress";
 import { ToastProgress } from "./toast-progress";
+import { asURL } from "./url";
 
 const FINISH_TOAST_DURATION_MS = 1200;
 type ToastConfig = Omit<Parameters<typeof toast>[0], "id">;
@@ -177,20 +178,80 @@ export async function downloadHTMLAsImage(opts: {
   }
 }
 
+// mo.download supports arbitrary file formats, so a MIME allowlist is too restrictive.
+const NON_DOWNLOAD_DATA_TYPES = new Set([
+  "text/html",
+  "text/xml",
+  "application/xml",
+  "text/jscript",
+  "text/livescript",
+  "text/vbscript",
+]);
+
+export function isDownloadUrl(url: unknown): url is string {
+  if (typeof url !== "string" || !url.trim()) {
+    return false;
+  }
+  try {
+    const parsed = asURL(url);
+    switch (parsed.protocol) {
+      case "http:":
+      case "https:":
+      case "blob:":
+        return true;
+      case "data:": {
+        const comma = parsed.pathname.indexOf(",");
+        if (comma === -1) {
+          return false;
+        }
+        const mimeType = parsed.pathname
+          .slice(0, comma)
+          .split(";", 1)[0]
+          .trim()
+          .toLowerCase();
+        // An omitted MIME type defaults to text/plain.
+        if (!mimeType) {
+          return true;
+        }
+        return (
+          /^[\w!#$%&'*+.^`|~-]+\/[\w!#$%&'*+.^`|~-]+$/.test(mimeType) &&
+          !NON_DOWNLOAD_DATA_TYPES.has(mimeType) &&
+          // Include versioned and x- aliases without enumerating each version.
+          !/^(?:text|application)\/(?:x-)?(?:java|ecma)script(?:\d+(?:\.\d+)*)?$/.test(
+            mimeType,
+          ) &&
+          !mimeType.endsWith("+xml")
+        );
+      }
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
 export function downloadByURL(url: string, filename?: string) {
+  if (!isDownloadUrl(url)) {
+    throw new Error("Unsupported download URL");
+  }
   const a = document.createElement("a");
   a.href = url;
-  if (filename) {
-    a.download = filename;
+  a.download = filename ?? "";
+  try {
+    a.click();
+  } finally {
+    a.remove();
   }
-  a.click();
-  a.remove();
 }
 
 export function downloadBlob(blob: Blob, filename: string) {
   const url = URL.createObjectURL(blob);
-  downloadByURL(url, filename);
-  URL.revokeObjectURL(url);
+  try {
+    downloadByURL(url, filename);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
 }
 
 export function downloadExportedFile({

package/src/utils/maps.ts

@@ -1,10 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-/* oxlint-disable typescript/no-explicit-any */
 
 import { Logger } from "./Logger";
 
-type NoInfer<T> = [T][T extends any ? 0 : never];
-
 export const Maps = {
   /**
    * keyBy for Map, with duplicate key detection.

package/src/utils/numbers.ts

@@ -23,6 +23,31 @@ export const maxFractionalDigits = memoizeLastValue((locale: string) => {
   return 0;
 });
 
+const getScientificFormatter = memoizeLastValue(
+  (locale: string, maximumFractionDigits = 1) =>
+    new Intl.NumberFormat(locale, {
+      minimumFractionDigits: 1,
+      maximumFractionDigits,
+      notation: "scientific",
+    }),
+);
+
+const getRoundedFormatter = memoizeLastValue(
+  (locale: string, maximumFractionDigits = 2) =>
+    new Intl.NumberFormat(locale, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits,
+    }),
+);
+
+const getEngineeringFormatter = memoizeLastValue(
+  (locale: string) =>
+    new Intl.NumberFormat(locale, {
+      notation: "engineering",
+      maximumSignificantDigits: 3,
+    }),
+);
+
 /** Decimal places needed to display `n` without float noise. */
 export function countFractionDigits(n: number): number {
   if (!Number.isFinite(n) || n === 0) {
@@ -35,7 +60,7 @@ export function countFractionDigits(n: number): number {
 
 /** Max fraction digits to display a set of step values cleanly. */
 export function maxFractionDigitsForSteps(
-  steps: number[],
+  steps: readonly number[],
   minGap: number,
 ): number {
   let max = countFractionDigits(minGap);
@@ -45,6 +70,41 @@ export function maxFractionDigitsForSteps(
   return max;
 }
 
+/** Infer display precision from a slider's regular or custom steps. */
+export function fractionDigitsForSlider(
+  step?: number,
+  steps?: readonly number[] | null,
+  origin?: number,
+  values?: readonly number[],
+): number {
+  const originDigits = origin == null ? 0 : countFractionDigits(origin);
+
+  if (steps && steps.length > 0) {
+    let minGap = Number.POSITIVE_INFINITY;
+    for (let i = 1; i < steps.length; i++) {
+      const gap = Math.abs(steps[i] - steps[i - 1]);
+      if (gap > 0 && gap < minGap) {
+        minGap = gap;
+      }
+    }
+
+    return Math.max(
+      originDigits,
+      maxFractionDigitsForSteps(steps, Number.isFinite(minGap) ? minGap : 0),
+    );
+  }
+
+  if (step == null || !Number.isFinite(step) || step <= 0) {
+    return Math.max(
+      2,
+      originDigits,
+      ...(values ?? []).map(countFractionDigits),
+    );
+  }
+
+  return Math.max(originDigits, countFractionDigits(step));
+}
+
 /** Round away float noise so step-based inputs stay on a clean decimal grid. */
 export function roundToFractionDigits(n: number, digits: number): number {
   return Number(n.toFixed(digits));
@@ -96,6 +156,7 @@ export function prettyScientificNumber(
   value: number,
   opts: {
     shouldRound?: boolean; // Default to false
+    maximumFractionDigits?: number;
     locale: string;
   },
 ): string {
@@ -108,23 +169,28 @@ export function prettyScientificNumber(
   // Determine if the number should be in scientific notation
   const absValue = Math.abs(value);
   if (absValue < 1e-2 || absValue >= 1e6) {
-    return new Intl.NumberFormat(opts.locale, {
-      minimumFractionDigits: 1,
-      maximumFractionDigits: 1,
-      notation: "scientific",
-    })
+    // Scientific notation counts digits after the decimal in the mantissa.
+    const digits =
+      opts.maximumFractionDigits === undefined
+        ? 1
+        : Math.max(
+            1,
+            Math.min(
+              maxFractionalDigits(opts.locale),
+              opts.maximumFractionDigits + Math.floor(Math.log10(absValue)),
+            ),
+          );
+    return getScientificFormatter(opts.locale, digits)
       .format(value)
       .toLowerCase();
   }
 
   const { shouldRound, locale } = opts;
 
-  if (shouldRound) {
-    // Number has an integer part, format with 2 decimal places
-    return new Intl.NumberFormat(locale, {
-      minimumFractionDigits: 0,
-      maximumFractionDigits: 2,
-    }).format(value);
+  if (shouldRound || opts.maximumFractionDigits !== undefined) {
+    return getRoundedFormatter(locale, opts.maximumFractionDigits ?? 2).format(
+      value,
+    );
   }
 
   // Don't round
@@ -161,12 +227,7 @@ export function prettyEngineeringNumber(value: number, locale: string): string {
     return specialCase;
   }
 
-  const [mant, exp] = new Intl.NumberFormat(locale, {
-    notation: "engineering",
-    maximumSignificantDigits: 3,
-  })
-    .format(value)
-    .split("E");
+  const [mant, exp] = getEngineeringFormatter(locale).format(value).split("E");
 
   if (exp in prefixes) {
     return mant + prefixes[exp as keyof typeof prefixes];

package/src/utils/objects.ts

@@ -89,13 +89,9 @@ export const Objects = {
     obj: Record<K, V>,
     predicate: (value: V, key: K) => boolean,
   ): Record<K, V> {
-    const result: Record<K, V> = {} as Record<K, V>;
-    for (const [key, value] of Objects.entries(obj)) {
-      if (predicate(value, key)) {
-        result[key] = obj[key];
-      }
-    }
-    return result;
+    return Objects.fromEntries(
+      Objects.entries(obj).filter(([key, value]) => predicate(value, key)),
+    );
   },
 
   omit<V extends object, K extends keyof V>(
@@ -106,8 +102,7 @@ export const Objects = {
     return Objects.filter(obj, (_, key) => !set.has(key));
   },
 
-  // oxlint-disable-next-line typescript/no-explicit-any
-  pick<V extends Record<string, any>, K extends string>(
+  pick<V extends Record<string, unknown>, K extends string>(
     obj: V,
     keys: readonly K[],
   ): Pick<V, K & keyof V> {

package/src/utils/time.ts

@@ -31,6 +31,11 @@ export class Time {
     return new Time(Date.now() as Milliseconds);
   }
 
+  /** The instant an ISO 8601 timestamp names. */
+  public static parse(iso: string): Time {
+    return new Time(Date.parse(iso) as Milliseconds);
+  }
+
   private constructor(ms: Milliseconds) {
     this.ms = ms;
   }
@@ -39,6 +44,11 @@ export class Time {
     return this.ms;
   }
 
+  /** How long after `start` this instant is. */
+  public since(start: Time): Milliseconds {
+    return (this.ms - start.ms) as Milliseconds;
+  }
+
   public toSeconds(): Seconds {
     return (this.ms / 1000) as Seconds;
   }

package/src/utils/tracer.ts

@@ -1,6 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-/* oxlint-disable typescript/no-explicit-any */
 /* oxlint-disable no-console -- for debugging */
 
 import { Logger } from "./Logger";
@@ -61,12 +60,17 @@ export class Tracer {
     }
   }
 
-  public wrapAsync<T extends (...args: any[]) => Promise<any>>(
+  public wrapAsync<T extends (...args: never[]) => Promise<unknown>>(
     fn: T,
     name?: string,
+    attributes?: Record<string, unknown>,
+  ): T;
+  public wrapAsync<Args extends unknown[], Result>(
+    fn: (...args: Args) => Promise<Result>,
+    name?: string,
     attributes: Record<string, unknown> = {},
-  ): T {
-    return (async (...args) => {
+  ): (...args: Args) => Promise<Result> {
+    return async (...args) => {
       const span = this.startSpan(name || fn.name, attributes);
       try {
         const result = await fn(...args);
@@ -76,7 +80,7 @@ export class Tracer {
         this.endSpan(span, "error");
         throw error;
       }
-    }) as T;
+    };
   }
 
   public logSpans(): void {

package/src/utils/zod-utils.ts

@@ -2,9 +2,7 @@
 
 import z from "zod";
 
-export function isZodArray<T>(
-  schema: z.ZodType,
-): schema is z.ZodArray<z.ZodType> {
+export function isZodArray(schema: z.ZodType): schema is z.ZodArray<z.ZodType> {
   return schema instanceof z.ZodArray;
 }