@marimo-team/frontend 0.14.18-dev5 → 0.14.18-dev51

package/src/utils/__tests__/timed-cache.test.ts

@@ -0,0 +1,142 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { TimedCache } from "../timed-cache";
+
+describe("TimedCache", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("basic get/set operations", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+    cache.set("key2", "value2");
+
+    expect(cache.get("key1")).toBe("value1");
+    expect(cache.get("key2")).toBe("value2");
+    expect(cache.get("nonexistent")).toBeUndefined();
+  });
+
+  test("returns undefined for expired entries", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+    expect(cache.get("key1")).toBe("value1");
+
+    vi.advanceTimersByTime(1001);
+    expect(cache.get("key1")).toBeUndefined();
+  });
+
+  test("entries within TTL remain accessible", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+
+    // within TTL
+    vi.advanceTimersByTime(500);
+
+    expect(cache.get("key1")).toBe("value1");
+
+    // still within TTL
+    vi.advanceTimersByTime(499);
+
+    expect(cache.get("key1")).toBe("value1");
+  });
+
+  test("cleanup removes expired entries", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+    cache.set("key2", "value2");
+
+    // expire key1
+    vi.advanceTimersByTime(1001);
+
+    // new key triggers cleanup
+    cache.set("key3", "value3");
+
+    // key2 triggers cleanup
+    expect(cache.get("key2")).toBeUndefined();
+    expect(cache.get("key3")).toBe("value3");
+  });
+
+  test("mixed expiry scenarios", () => {
+    const cache = new TimedCache<number>({ ttl: 1000 });
+
+    cache.set("early", 1);
+
+    vi.advanceTimersByTime(500);
+    cache.set("mid", 2);
+
+    vi.advanceTimersByTime(500);
+    cache.set("late", 3);
+
+    // At this point: early is at 1000ms (not yet expired), mid is at 500ms, late is fresh
+    expect(cache.get("early")).toBe(1);
+    expect(cache.get("mid")).toBe(2);
+    expect(cache.get("late")).toBe(3);
+
+    // Advance 1ms more to expire early (1001ms total)
+    vi.advanceTimersByTime(1);
+
+    expect(cache.get("early")).toBeUndefined();
+    expect(cache.get("mid")).toBe(2);
+    expect(cache.get("late")).toBe(3);
+
+    // Advance another 500ms to expire mid (1001ms total)
+    vi.advanceTimersByTime(500);
+
+    expect(cache.get("mid")).toBeUndefined();
+    expect(cache.get("late")).toBe(3);
+  });
+
+  test("updating existing key resets timestamp", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+
+    // Advance time close to expiry
+    vi.advanceTimersByTime(900);
+
+    // Update the key
+    cache.set("key1", "updated_value");
+
+    // Advance time past original expiry
+    vi.advanceTimersByTime(200);
+
+    // Should still be accessible with updated value
+    expect(cache.get("key1")).toBe("updated_value");
+  });
+
+  test("clear removes all entries", () => {
+    const cache = new TimedCache<string>({ ttl: 1000 });
+
+    cache.set("key1", "value1");
+    cache.set("key2", "value2");
+    cache.set("key3", "value3");
+
+    expect(cache.get("key1")).toBe("value1");
+    expect(cache.get("key2")).toBe("value2");
+
+    cache.clear();
+
+    expect(cache.get("key1")).toBeUndefined();
+    expect(cache.get("key2")).toBeUndefined();
+    expect(cache.get("key3")).toBeUndefined();
+  });
+
+  test("zero TTL expires immediately", () => {
+    const cache = new TimedCache<string>({ ttl: 0 });
+
+    cache.set("key1", "value1");
+
+    // With TTL 0, any passage of time should expire the entry
+    vi.advanceTimersByTime(1);
+    expect(cache.get("key1")).toBeUndefined();
+  });
+});

package/src/utils/__tests__/timeout.test.ts

@@ -0,0 +1,153 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { retryWithTimeout } from "../timeout";
+
+describe("retryWithTimeout", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it("should be called immediately when function returns true on first call and no initial delay", async () => {
+    const mockFn = vi.fn().mockReturnValue(true);
+    retryWithTimeout(mockFn, { retries: 3, delay: 1000 });
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // Should not call again after success
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should be called with initial delay", async () => {
+    const mockFn = vi.fn().mockReturnValue(true);
+    retryWithTimeout(mockFn, { retries: 3, delay: 1000, initialDelay: 1000 });
+
+    // Function should not be called immediately
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    // After first delay, function should be called and succeed
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // Should not call again after success
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should retry when function returns false initially", async () => {
+    const mockFn = vi
+      .fn()
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+
+    retryWithTimeout(mockFn, {
+      retries: 3,
+      delay: 1000,
+      initialDelay: 1000,
+    });
+
+    // Function should not be called immediately
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    // After first delay
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // After second delay
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    // After third delay - should succeed and stop
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(3);
+
+    // Should not call again after success
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(3);
+  });
+
+  it("should stop retrying after max retries reached", async () => {
+    const mockFn = vi.fn().mockReturnValue(false);
+
+    retryWithTimeout(mockFn, {
+      retries: 2,
+      delay: 1000,
+      initialDelay: 1000,
+    });
+
+    // Function should not be called immediately
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    // After first delay
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // After second delay
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    // Should not call again after max retries
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle zero retries", async () => {
+    const mockFn = vi.fn().mockReturnValue(false);
+
+    retryWithTimeout(mockFn, { retries: 0, delay: 1000 });
+
+    // Function should not be called immediately
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    // Should not call again
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(0);
+  });
+
+  it("should handle zero delay", async () => {
+    const mockFn = vi.fn().mockReturnValueOnce(false).mockReturnValueOnce(true);
+
+    retryWithTimeout(mockFn, { retries: 3, delay: 0 });
+
+    // Called immediately
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // After zero delay - should call and succeed
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    // Should not call again after success
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle function that throws an error", async () => {
+    const mockFn = vi
+      .fn()
+      .mockImplementationOnce(() => {
+        throw new Error("Test error");
+      })
+      .mockReturnValueOnce(true);
+
+    // Should not throw - the function handles errors gracefully
+    expect(() => {
+      retryWithTimeout(mockFn, { retries: 3, delay: 1000 });
+    }).not.toThrow();
+
+    // Function should be called but does not throw an error
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // After first delay - should call and succeed
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    // Should not call again after success
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/__tests__/traceback.test.ts

@@ -0,0 +1,34 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { describe, expect, test } from "vitest";
+import { Tracebacks } from "@/__mocks__/tracebacks";
+import { extractAllTracebackInfo } from "../traceback";
+
+describe("traceback", () => {
+  test("extracts cell-link", () => {
+    const errors = extractAllTracebackInfo(Tracebacks.raw);
+    expect(errors).toMatchInlineSnapshot(`
+      [
+        {
+          "cellId": "Hbol",
+          "lineNumber": 4,
+        },
+        {
+          "cellId": "Hbol",
+          "lineNumber": 2,
+        },
+      ]
+    `);
+  });
+
+  test("extracts cell-link from assertion", () => {
+    const info = extractAllTracebackInfo(Tracebacks.assertion);
+    expect(info).toMatchInlineSnapshot(`
+      [
+        {
+          "cellId": "Hbol",
+          "lineNumber": 1,
+        },
+      ]
+    `);
+  });
+});

package/src/utils/__tests__/url.test.ts

@@ -0,0 +1,100 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { beforeAll, describe, expect, test } from "vitest";
+import { asURL } from "../url";
+
+describe("asURL function", () => {
+  describe("when document.baseURI is not set", () => {
+    // Mock document.baseURI
+    beforeAll(() => {
+      Object.defineProperty(document, "baseURI", {
+        value: "https://example.com/",
+        writable: true,
+      });
+    });
+
+    test('should handle relative path starting with "./"', () => {
+      const path = "./path/to/resource";
+      const result = asURL(path);
+      expect(result.toString()).toBe("https://example.com/path/to/resource");
+    });
+
+    test('should handle absolute path starting with "/"', () => {
+      const path = "/path/to/resource";
+      const result = asURL(path);
+      expect(result.toString()).toBe("https://example.com/path/to/resource");
+    });
+
+    test("should handle full URL", () => {
+      const fullPath = "https://example.com/path/to/resource";
+      const result = asURL(fullPath);
+      expect(result.toString()).toBe(fullPath);
+    });
+
+    test('should handle relative path without "./"', () => {
+      const path = "path/to/resource";
+      const result = asURL(path);
+      expect(result.toString()).toBe("https://example.com/path/to/resource");
+    });
+
+    test("relative with query params", () => {
+      const path = "path/to/resource?query=param";
+      const result = asURL(path);
+      expect(result.toString()).toBe(
+        "https://example.com/path/to/resource?query=param",
+      );
+    });
+
+    test("just query params", () => {
+      const path = "?query=param";
+      const result = asURL(path);
+      expect(result.toString()).toBe("https://example.com/?query=param");
+    });
+  });
+
+  describe("when document.baseURI is set", () => {
+    // Mock document.baseURI
+    beforeAll(() => {
+      Object.defineProperty(document, "baseURI", {
+        value: "https://example.com/base/",
+        writable: true,
+      });
+    });
+
+    test('should handle relative path starting with "./"', () => {
+      const result = asURL("./path/to/resource");
+      expect(result.toString()).toBe(
+        "https://example.com/base/path/to/resource",
+      );
+    });
+
+    test('should handle absolute path starting with "/"', () => {
+      const result = asURL("/path/to/resource");
+      expect(result.toString()).toBe("https://example.com/path/to/resource");
+    });
+
+    test("should handle full URL", () => {
+      const fullPath = "https://example.com/path/to/resource";
+      const result = asURL(fullPath);
+      expect(result.toString()).toBe(fullPath);
+    });
+
+    test('should handle relative path without "./"', () => {
+      const result = asURL("path/to/resource");
+      expect(result.toString()).toBe(
+        "https://example.com/base/path/to/resource",
+      );
+    });
+
+    test("relative with query params", () => {
+      const result = asURL("path/to/resource?query=param");
+      expect(result.toString()).toBe(
+        "https://example.com/base/path/to/resource?query=param",
+      );
+    });
+
+    test("just query params", () => {
+      const result = asURL("?query=param");
+      expect(result.toString()).toBe("https://example.com/base/?query=param");
+    });
+  });
+});

package/src/utils/__tests__/urls.test.ts

@@ -0,0 +1,10 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { isUrl } from "../urls";
+
+describe("isUrl", () => {
+  it("should return true for a valid URL", () => {
+    expect(isUrl("https://example.com")).toBe(true);
+    expect(isUrl("curl -X GET http://example.com")).toBe(false);
+  });
+});

package/src/utils/__tests__/versions.test.ts

@@ -0,0 +1,63 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import {
+  cleanPythonModuleName,
+  reverseSemverSort,
+  semverSort,
+} from "../versions";
+
+describe("semverSort", () => {
+  it("should sort versions correctly", () => {
+    const versions = ["1.0.0", "1.0.1", "1.0.10", "1.0.2"];
+    const sortedVersions = versions.sort(semverSort);
+    expect(sortedVersions).toEqual(["1.0.0", "1.0.1", "1.0.2", "1.0.10"]);
+  });
+
+  it("should handle pre-release versions correctly", () => {
+    const versions = ["1.0.0-alpha", "1.0.0", "1.0.0-beta", "1.0.0-rc.1"];
+    const sortedVersions = versions.sort(semverSort);
+    expect(sortedVersions).toEqual([
+      "1.0.0-alpha",
+      "1.0.0-beta",
+      "1.0.0-rc.1",
+      "1.0.0",
+    ]);
+  });
+
+  it("should handle versions with different number of segments", () => {
+    const versions = ["1.0", "1.0.0", "1.0.1", "1.0.10"];
+    const sortedVersions = versions.sort(semverSort);
+    expect(sortedVersions).toEqual(["1.0", "1.0.0", "1.0.1", "1.0.10"]);
+  });
+
+  it("should handle versions with build metadata correctly", () => {
+    const versions = [
+      "1.0.0+001",
+      "1.0.0+20130313144700",
+      "1.0.0+exp.sha.5114f85",
+    ];
+    const sortedVersions = versions.sort(semverSort);
+    expect(sortedVersions).toEqual([
+      "1.0.0+001",
+      "1.0.0+20130313144700",
+      "1.0.0+exp.sha.5114f85",
+    ]);
+  });
+
+  it("reverseSemverSort", () => {
+    const versions = ["1.0.0", "1.0.1", "1.0.10", "1.0.2"];
+    const sortedVersions = versions.sort(reverseSemverSort);
+    expect(sortedVersions).toEqual(["1.0.10", "1.0.2", "1.0.1", "1.0.0"]);
+  });
+});
+
+it("cleanPythonModuleName", () => {
+  expect(cleanPythonModuleName("pandas[excel]")).toBe("pandas");
+  expect(cleanPythonModuleName("ibis-framework[duckdb]")).toBe(
+    "ibis-framework",
+  );
+  expect(cleanPythonModuleName("package[opt1,opt2]")).toBe("package");
+
+  expect(cleanPythonModuleName(" pandas[excel] ")).toBe("pandas");
+  expect(cleanPythonModuleName("\tpkg[opt]\n")).toBe("pkg");
+});

package/src/utils/__tests__/waitForWs.test.ts

@@ -0,0 +1,76 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { waitForWs } from "../waitForWs";
+
+describe("waitForWs", () => {
+  let originalWebSocket: typeof WebSocket;
+  let mockWs: any;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    originalWebSocket = global.WebSocket;
+    mockWs = {
+      close: vi.fn(),
+      onopen: null,
+      onerror: null,
+    };
+    global.WebSocket = vi.fn(() => mockWs) as any;
+  });
+
+  afterEach(() => {
+    global.WebSocket = originalWebSocket;
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it("resolves immediately on successful connection", async () => {
+    const url = "ws://test.com";
+    const promise = waitForWs(url);
+
+    // Simulate successful connection
+    mockWs.onopen();
+
+    await expect(promise).resolves.toBe(url);
+    expect(mockWs.close).toHaveBeenCalled();
+    expect(global.WebSocket).toHaveBeenCalledTimes(1);
+    expect(global.WebSocket).toHaveBeenCalledWith(url);
+  });
+
+  it("retries on failure with linear backoff", async () => {
+    const url = "ws://test.com";
+    const promise = waitForWs(url, 3);
+
+    // First attempt fails
+    mockWs.onerror(new Event("error"));
+    await vi.advanceTimersByTimeAsync(1000);
+
+    // Second attempt fails
+    mockWs.onerror(new Event("error"));
+    await vi.advanceTimersByTimeAsync(2000);
+
+    // Third attempt succeeds
+    mockWs.onopen();
+
+    await expect(promise).resolves.toBe(url);
+    expect(global.WebSocket).toHaveBeenCalledTimes(3);
+    expect(mockWs.close).toHaveBeenCalledTimes(3);
+  });
+
+  it("throws after max retries", async () => {
+    const url = "ws://test.com";
+    const promise = waitForWs(url, 2).catch((error) => error);
+
+    // First attempt fails
+    mockWs.onerror(new Event("error"));
+    await vi.advanceTimersByTimeAsync(1000);
+
+    // Second attempt fails
+    mockWs.onerror(new Event("error"));
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect((await promise).message).toBe(`Failed to connect to ${url}`);
+    expect(global.WebSocket).toHaveBeenCalledTimes(2);
+    expect(mockWs.close).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/arrays.ts

@@ -0,0 +1,75 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { invariant } from "./invariant";
+import { clamp } from "./math";
+
+export function arrayDelete<T>(array: T[], index: number): T[] {
+  const result = [...array];
+  result.splice(index, 1);
+  return result;
+}
+
+export function arrayInsert<T>(array: T[], index: number, value: T): T[] {
+  index = clamp(index, 0, array.length);
+  const result = [...array];
+  result.splice(index, 0, value);
+  return result;
+}
+
+export function arrayMove<T>(array: T[], from: number, to: number): T[] {
+  const result = [...array];
+  const [value] = result.splice(from, 1);
+  result.splice(to, 0, value);
+  return result;
+}
+
+export function arrayInsertMany<T>(
+  array: T[],
+  index: number,
+  values: T[],
+): T[] {
+  if (array.length === 0) {
+    return values;
+  }
+  // Clamp index to the end of the array
+  index = clamp(index, 0, array.length);
+  const result = [...array];
+  result.splice(index, 0, ...values);
+  return result;
+}
+
+export function arrayShallowEquals<T>(a: T[], b: T[]): boolean {
+  if (a === b) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0, l = a.length; i < l; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export const Arrays = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  EMPTY: [] as any,
+  zip: <T, U>(a: T[], b: U[]): Array<[T, U]> => {
+    invariant(a.length === b.length, "Arrays must be the same length");
+    return a.map((item, i) => [item, b[i]]);
+  },
+};
+
+export function arrayToggle<T>(arr: T[], item: T): T[] {
+  if (!arr) {
+    return [item];
+  }
+  const index = arr.indexOf(item);
+  if (index === -1) {
+    return [...arr, item];
+  }
+  const result = [...arr];
+  result.splice(index, 1);
+  return result;
+}

package/src/utils/assertExists.ts

@@ -0,0 +1,12 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+export function assertExists<T>(
+  x: T | null | undefined,
+  message?: string,
+): asserts x is T {
+  if (x === undefined || x === null) {
+    if (message) {
+      throw new Error(message);
+    }
+    throw new Error(`Expected value but got ${x}`);
+  }
+}

package/src/utils/assertNever.ts

@@ -0,0 +1,20 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { invariant } from "./invariant";
+import { Logger } from "./Logger";
+
+/**
+ * Type-safe exhaustiveness check for discriminated unions.
+ */
+export function assertNever(x: never): never {
+  invariant(false, `Unexpected object: ${x}`);
+}
+
+/**
+ * Like assertNever, but logs the unexpected object to the console.
+ * Useful for exhaustiveness checks but without throwing an error.
+ */
+export function logNever(x: never): void {
+  Logger.warn(`Unexpected object: ${JSON.stringify(x)}`);
+  // biome-ignore lint/correctness/noVoidTypeReturn: <explanation>
+  return x;
+}