@marimo-team/islands 0.15.5 → 0.16.1

package/src/plugins/layout/OutlinePlugin.tsx

@@ -0,0 +1,69 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { Provider, useAtomValue } from "jotai";
+import type { JSX } from "react";
+import { z } from "zod";
+import { notebookOutline } from "@/core/cells/cells";
+import { store } from "@/core/state/jotai";
+import { OutlineList } from "../../components/editor/chrome/panels/outline/floating-outline";
+import {
+  findOutlineElements,
+  useActiveOutline,
+} from "../../components/editor/chrome/panels/outline/useActiveOutline";
+import type {
+  IStatelessPlugin,
+  IStatelessPluginProps,
+} from "../stateless-plugin";
+
+interface Data {
+  label?: string;
+}
+
+const OutlineContent: React.FC<{ label?: string }> = ({ label }) => {
+  const { items } = useAtomValue(notebookOutline);
+  const headerElements = findOutlineElements(items);
+  const { activeHeaderId, activeOccurrences } =
+    useActiveOutline(headerElements);
+
+  if (items.length === 0) {
+    return (
+      <div className="text-muted-foreground text-sm p-4 border border-dashed border-border rounded-lg">
+        No outline found. Add markdown headings to your notebook to create an
+        outline.
+      </div>
+    );
+  }
+
+  return (
+    <div className="border border-border rounded-lg">
+      {label && (
+        <div className="px-4 py-2 border-b border-border font-medium text-sm">
+          {label}
+        </div>
+      )}
+      <OutlineList
+        className="max-h-[400px]"
+        items={items}
+        activeHeaderId={activeHeaderId}
+        activeOccurrences={activeOccurrences}
+      />
+    </div>
+  );
+};
+
+export class OutlinePlugin implements IStatelessPlugin<Data> {
+  tagName = "marimo-outline";
+
+  validator = z.object({
+    label: z.string().optional(),
+  });
+
+  render(props: IStatelessPluginProps<Data>): JSX.Element {
+    const { label } = props.data;
+
+    return (
+      <Provider store={store}>
+        <OutlineContent label={label} />
+      </Provider>
+    );
+  }
+}

package/src/plugins/layout/StatPlugin.tsx

@@ -2,6 +2,7 @@
 
 import { TriangleIcon } from "lucide-react";
 import type { JSX } from "react";
+import { useLocale } from "react-aria";
 import { z } from "zod";
 import { cn } from "@/utils/cn";
 import { prettyNumber } from "@/utils/numbers";
@@ -41,6 +42,8 @@ export const StatComponent: React.FC<Data> = ({
   bordered,
   direction,
 }) => {
+  const { locale } = useLocale();
+
   const renderPrettyValue = () => {
     if (value == null) {
       return <i>No value</i>;
@@ -51,7 +54,7 @@ export const StatComponent: React.FC<Data> = ({
     }
 
     if (typeof value === "number") {
-      return prettyNumber(value);
+      return prettyNumber(value, locale);
     }
 
     if (typeof value === "boolean") {

package/src/plugins/plugins.ts

@@ -45,6 +45,7 @@ import { JsonOutputPlugin } from "./layout/JsonOutputPlugin";
 import { LazyPlugin } from "./layout/LazyPlugin";
 import { MimeRendererPlugin } from "./layout/MimeRenderPlugin";
 import { MermaidPlugin } from "./layout/mermaid/MermaidPlugin";
+import { OutlinePlugin } from "./layout/OutlinePlugin";
 import { ProgressPlugin } from "./layout/ProgressPlugin";
 import { RoutesPlugin } from "./layout/RoutesPlugin";
 import { StatPlugin } from "./layout/StatPlugin";
@@ -99,6 +100,7 @@ const LAYOUT_PLUGINS: Array<IStatelessPlugin<unknown>> = [
   new MimeRendererPlugin(),
   new MermaidPlugin(),
   new NavigationMenuPlugin(),
+  new OutlinePlugin(),
   new ProgressPlugin(),
   new RoutesPlugin(),
   new StatPlugin(),

package/src/stories/cell.stories.tsx

@@ -11,7 +11,7 @@ import {
 import { defaultUserConfig } from "@/core/config/config-schema";
 import { connectionAtom } from "@/core/network/connection";
 import { requestClientAtom } from "@/core/network/requests";
-import { resolveRequestClient } from "@/core/network/resolve.ts";
+import { resolveRequestClient } from "@/core/network/resolve";
 import type { CellConfig } from "@/core/network/types";
 import { WebSocketState } from "@/core/websocket/types";
 import { MultiColumn } from "@/utils/id-tree";

package/src/stories/layout/vertical/one-column.stories.tsx

@@ -9,7 +9,7 @@ import { defaultUserConfig, parseAppConfig } from "@/core/config/config-schema";
 import { showCodeInRunModeAtom } from "@/core/meta/state";
 import { connectionAtom } from "@/core/network/connection";
 import { requestClientAtom } from "@/core/network/requests";
-import { resolveRequestClient } from "@/core/network/resolve.ts";
+import { resolveRequestClient } from "@/core/network/resolve";
 import { WebSocketState } from "@/core/websocket/types";
 import { MultiColumn } from "@/utils/id-tree";
 import type { Milliseconds, Seconds } from "@/utils/time";

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

@@ -1,5 +1,6 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { EDGE_CASE_CELL_NAMES } from "../../__tests__/mocks";
 import {
   canLinkToCell,
   createCellLink,
@@ -89,4 +90,32 @@ describe("cell-urls utilities", () => {
       expect(canLinkToCell("_")).toBe(false);
     });
   });
+
+  describe("edge case cell names with unicode and special characters", () => {
+    it.each(EDGE_CASE_CELL_NAMES)(
+      "should handle unicode cell names in createCellLink: %s",
+      (cellName) => {
+        const url = createCellLink(cellName);
+        expect(url).toContain("scrollTo=");
+        expect(url).toContain(encodeURIComponent(cellName));
+      },
+    );
+
+    it.each(EDGE_CASE_CELL_NAMES)(
+      "should round-trip unicode cell names correctly: %s",
+      (cellName) => {
+        const url = createCellLink(cellName);
+        const hash = url.split("#")[1];
+        const extracted = extractCellNameFromHash(`#${hash}`);
+        expect(extracted).toBe(cellName);
+      },
+    );
+
+    it.each(EDGE_CASE_CELL_NAMES)(
+      "should allow linking to unicode cell names: %s",
+      (cellName) => {
+        expect(canLinkToCell(cellName)).toBe(true);
+      },
+    );
+  });
 });

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

@@ -8,6 +8,8 @@ import {
   timeAgo,
 } from "../dates";
 
+const locale = "en-US";
+
 describe("dates", () => {
   // Save original timezone
   let originalTimezone: string | undefined;
@@ -25,36 +27,38 @@ describe("dates", () => {
 
   describe("prettyDate", () => {
     it("returns empty string for null or undefined", () => {
-      expect(prettyDate(null, "date")).toBe("");
-      expect(prettyDate(undefined, "date")).toBe("");
+      expect(prettyDate(null, "date", locale)).toBe("");
+      expect(prettyDate(undefined, "date", locale)).toBe("");
     });
 
     it("formats date correctly", () => {
       const date = new Date("2023-05-15T12:00:00Z");
       // Using a regex to match the pattern since exact format may vary by locale
-      expect(prettyDate(date.toISOString(), "date")).toMatch(/May 15, 2023/);
+      expect(prettyDate(date.toISOString(), "date", locale)).toMatch(
+        /May 15, 2023/,
+      );
     });
 
     it("formats datetime correctly", () => {
       const date = new Date("2023-05-15T12:00:00Z");
-      expect(prettyDate(date.toISOString(), "datetime")).toMatch(
+      expect(prettyDate(date.toISOString(), "datetime", locale)).toMatch(
         /May 15, 2023/,
       );
     });
 
     it("handles errors gracefully", () => {
-      expect(prettyDate("invalid-date", "date")).toBe("Invalid Date");
+      expect(prettyDate("invalid-date", "date", locale)).toBe("Invalid Date");
     });
 
     it("handles numeric timestamp input", () => {
       const timestamp = 1_684_152_000_000; // 2023-05-15T12:00:00Z in milliseconds
-      expect(prettyDate(timestamp, "date")).toMatch(/May 15, 2023/);
+      expect(prettyDate(timestamp, "date", locale)).toMatch(/May 15, 2023/);
     });
 
     it("preserves timezone for datetime type", () => {
       // This date is in winter time to avoid daylight saving time issues
       const date = new Date("2023-01-15T15:30:00Z");
-      expect(prettyDate(date.toISOString(), "datetime")).toMatch(
+      expect(prettyDate(date.toISOString(), "datetime", locale)).toMatch(
         /Jan 15, 2023/,
       );
     });
@@ -62,7 +66,9 @@ describe("dates", () => {
     it("drops timezone for date type by using UTC", () => {
       // Create a date that would be different days in different timezones
       const date = new Date("2023-05-15T23:30:00Z"); // Late in the day UTC
-      expect(prettyDate(date.toISOString(), "date")).toMatch(/May 15, 2023/);
+      expect(prettyDate(date.toISOString(), "date", locale)).toMatch(
+        /May 15, 2023/,
+      );
     });
 
     describe("with different locales", () => {
@@ -86,7 +92,9 @@ describe("dates", () => {
         };
 
         const date = new Date("2023-05-15T12:00:00Z");
-        expect(prettyDate(date.toISOString(), "date")).toBe("15 mai 2023");
+        expect(prettyDate(date.toISOString(), "date", locale)).toBe(
+          "15 mai 2023",
+        );
       });
     });
   });
@@ -94,34 +102,42 @@ describe("dates", () => {
   describe("exactDateTime", () => {
     it("formats date without milliseconds", () => {
       const date = new Date("2023-05-15T12:00:00.000Z");
-      expect(exactDateTime(date, undefined)).toBe("2023-05-15 12:00:00");
+      expect(exactDateTime(date, undefined, locale)).toBe(
+        "2023-05-15 12:00:00",
+      );
     });
 
     it("formats date with milliseconds", () => {
       const date = new Date("2023-05-15T12:00:00.123Z");
-      expect(exactDateTime(date, undefined)).toBe("2023-05-15 12:00:00.123");
+      expect(exactDateTime(date, undefined, locale)).toBe(
+        "2023-05-15 12:00:00.123",
+      );
     });
 
     it("formats date in UTC when renderInUTC is true", () => {
       const date = new Date("2023-05-15T12:00:00.000Z");
-      expect(exactDateTime(date, "UTC")).toBe("2023-05-15 12:00:00 UTC");
+      expect(exactDateTime(date, "UTC", locale)).toBe(
+        "2023-05-15 12:00:00 UTC",
+      );
     });
 
     it("formats date with milliseconds in UTC when renderInUTC is true", () => {
       const date = new Date("2023-05-15T12:00:00.123Z");
-      expect(exactDateTime(date, "UTC")).toBe("2023-05-15 12:00:00.123 UTC");
+      expect(exactDateTime(date, "UTC", locale)).toBe(
+        "2023-05-15 12:00:00.123 UTC",
+      );
     });
 
     it("formats date in America/New_York timezone", () => {
       const date = new Date("2023-05-15T12:00:00.000Z");
-      expect(exactDateTime(date, "America/New_York")).toBe(
+      expect(exactDateTime(date, "America/New_York", locale)).toBe(
         "2023-05-15 08:00:00 EDT",
       );
     });
 
     it("formats date with milliseconds in America/New_York timezone", () => {
       const date = new Date("2023-05-15T12:00:00.123Z");
-      expect(exactDateTime(date, "America/New_York")).toBe(
+      expect(exactDateTime(date, "America/New_York", locale)).toBe(
         "2023-05-15 08:00:00.123 EDT",
       );
     });
@@ -129,42 +145,47 @@ describe("dates", () => {
 
   describe("timeAgo", () => {
     it("returns empty string for null, undefined, or 0", () => {
-      expect(timeAgo(null)).toBe("");
-      expect(timeAgo(undefined)).toBe("");
-      expect(timeAgo(0)).toBe("");
+      expect(timeAgo(null, locale)).toBe("");
+      expect(timeAgo(undefined, locale)).toBe("");
+      expect(timeAgo(0, locale)).toBe("");
     });
 
     it("formats today's date correctly", () => {
       const today = new Date();
-      const result = timeAgo(today.toISOString());
+      const result = timeAgo(today.toISOString(), locale);
       expect(result).toMatch(/Today at/);
     });
 
     it("formats yesterday's date correctly", () => {
       const yesterday = new Date();
       yesterday.setDate(yesterday.getDate() - 1);
-      const result = timeAgo(yesterday.toISOString());
+      const result = timeAgo(yesterday.toISOString(), locale);
       expect(result).toMatch(/Yesterday at/);
     });
 
     it("formats older dates correctly", () => {
       const oldDate = new Date("2020-01-01T12:00:00Z");
-      const result = timeAgo(oldDate.toISOString());
+      const result = timeAgo(oldDate.toISOString(), locale);
       expect(result).toMatch(/Jan 1, 2020 at/);
     });
 
     it("handles errors gracefully", () => {
-      expect(timeAgo("invalid-date")).toBe("Invalid Date at Invalid Date");
+      expect(timeAgo("invalid-date", locale)).toBe(
+        "Invalid Date at Invalid Date",
+      );
     });
   });
 
   describe("getShortTimeZone", () => {
     it("returns the short timezone", () => {
-      expect(getShortTimeZone("America/New_York")).toBeOneOf(["EDT", "EST"]);
+      expect(getShortTimeZone("America/New_York", locale)).toBeOneOf([
+        "EDT",
+        "EST",
+      ]);
     });
 
     it("handles errors gracefully", () => {
-      expect(getShortTimeZone("MarimoLand")).toBe("MarimoLand");
+      expect(getShortTimeZone("MarimoLand", locale)).toBe("MarimoLand");
     });
   });
 

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

@@ -1,6 +1,7 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
 import { describe, expect, it } from "vitest";
+import { EDGE_CASE_FILENAMES } from "../../__tests__/mocks";
 import { Filenames } from "../filenames";
 
 describe("Filenames", () => {
@@ -27,4 +28,21 @@ describe("Filenames", () => {
     expect(Filenames.withoutExtension("test.txt")).toEqual("test");
     expect(Filenames.withoutExtension("test.foo.txt")).toEqual("test.foo");
   });
+
+  it.each(EDGE_CASE_FILENAMES)(
+    "should handle edge case filenames: %s",
+    (filename) => {
+      // Test all filename operations with edge cases
+      const withoutExt = Filenames.withoutExtension(filename);
+
+      expect(Filenames.toMarkdown(filename)).toEqual(`${withoutExt}.md`);
+      expect(Filenames.toHTML(filename)).toEqual(`${withoutExt}.html`);
+      expect(Filenames.toPNG(filename)).toEqual(`${withoutExt}.png`);
+      expect(Filenames.toPY(filename)).toEqual(`${withoutExt}.py`);
+
+      // Ensure operations preserve unicode and special characters in base name
+      expect(withoutExt).not.toEqual("");
+      expect(typeof withoutExt).toBe("string");
+    },
+  );
 });

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

@@ -6,24 +6,32 @@ import {
   prettyScientificNumber,
 } from "../numbers";
 
+const locale = "en-US";
+
 describe("prettyNumber", () => {
   it("should format numbers", () => {
-    expect(prettyNumber(123_456_789)).toBe("123,456,789");
-    expect(prettyNumber(1234.567_89)).toBe("1,234.57");
-    expect(prettyNumber(0)).toBe("0");
+    expect(prettyNumber(123_456_789, locale)).toBe("123,456,789");
+    expect(prettyNumber(1234.567_89, locale)).toBe("1,234.57");
+    expect(prettyNumber(0, locale)).toBe("0");
   });
 });
 
+const options = { locale };
+
 describe("prettyScientificNumber", () => {
   it("should handle special cases", () => {
-    expect(prettyScientificNumber(0)).toBe("0");
-    expect(prettyScientificNumber(Number.NaN)).toBe("NaN");
-    expect(prettyScientificNumber(Number.POSITIVE_INFINITY)).toBe("Infinity");
-    expect(prettyScientificNumber(Number.NEGATIVE_INFINITY)).toBe("-Infinity");
+    expect(prettyScientificNumber(0, options)).toBe("0");
+    expect(prettyScientificNumber(Number.NaN, options)).toBe("NaN");
+    expect(prettyScientificNumber(Number.POSITIVE_INFINITY, options)).toBe(
+      "Infinity",
+    );
+    expect(prettyScientificNumber(Number.NEGATIVE_INFINITY, options)).toBe(
+      "-Infinity",
+    );
   });
 
   it("should format decimals with scientific notation, ignoring integer part rounding", () => {
-    const opts = { shouldRound: true };
+    const opts = { shouldRound: true, locale };
     expect(prettyScientificNumber(123_456, opts)).toBe("123,456");
     expect(prettyScientificNumber(123_456.7, opts)).toBe("123,456.7");
     expect(prettyScientificNumber(12_345.6789, opts)).toBe("12,345.68");
@@ -40,10 +48,10 @@ describe("prettyScientificNumber", () => {
   });
 
   it("should not round numbers when shouldRound is false", () => {
-    expect(prettyScientificNumber(123_456)).toBe("123,456");
-    expect(prettyScientificNumber(123_456.7)).toBe("123,456.7");
-    expect(prettyScientificNumber(12_345.6789)).toBe("12,345.6789");
-    expect(prettyScientificNumber(1.234_567_891_011_12)).toBe(
+    expect(prettyScientificNumber(123_456, options)).toBe("123,456");
+    expect(prettyScientificNumber(123_456.7, options)).toBe("123,456.7");
+    expect(prettyScientificNumber(12_345.6789, options)).toBe("12,345.6789");
+    expect(prettyScientificNumber(1.234_567_891_011_12, options)).toBe(
       "1.23456789101112",
     );
   });
@@ -51,26 +59,30 @@ describe("prettyScientificNumber", () => {
 
 describe("prettyEngineeringNumber", () => {
   it("should handle special cases", () => {
-    expect(prettyEngineeringNumber(0)).toBe("0");
-    expect(prettyEngineeringNumber(-0)).toBe("0"); // Test with negative zero
-    expect(prettyEngineeringNumber(Number.NaN)).toBe("NaN");
-    expect(prettyEngineeringNumber(Number.POSITIVE_INFINITY)).toBe("Infinity");
-    expect(prettyEngineeringNumber(Number.NEGATIVE_INFINITY)).toBe("-Infinity");
+    expect(prettyEngineeringNumber(0, locale)).toBe("0");
+    expect(prettyEngineeringNumber(-0, locale)).toBe("0"); // Test with negative zero
+    expect(prettyEngineeringNumber(Number.NaN, locale)).toBe("NaN");
+    expect(prettyEngineeringNumber(Number.POSITIVE_INFINITY, locale)).toBe(
+      "Infinity",
+    );
+    expect(prettyEngineeringNumber(Number.NEGATIVE_INFINITY, locale)).toBe(
+      "-Infinity",
+    );
   });
 
   it("should format decimals with engineering notation, ignoring integer part", () => {
-    expect(prettyEngineeringNumber(123_456)).toBe("123k");
-    expect(prettyEngineeringNumber(123_456.7)).toBe("123k");
-    expect(prettyEngineeringNumber(12_345.6789)).toBe("12.3k");
-    expect(prettyEngineeringNumber(1.2345)).toBe("1.23");
-    expect(prettyEngineeringNumber(1.000_001_234)).toBe("1");
-    expect(prettyEngineeringNumber(0.12)).toBe("120m");
-    expect(prettyEngineeringNumber(0.1234)).toBe("123m");
-    expect(prettyEngineeringNumber(0.000_123_4)).toBe("123µ");
-    expect(prettyEngineeringNumber(-1.2345)).toBe("-1.23"); // Test with negative numbers
-    expect(prettyEngineeringNumber(-1.000_001_234)).toBe("-1");
-    expect(prettyEngineeringNumber(-0.12)).toBe("-120m");
-    expect(prettyEngineeringNumber(-0.1234)).toBe("-123m");
-    expect(prettyEngineeringNumber(-0.000_123_4)).toBe("-123µ");
+    expect(prettyEngineeringNumber(123_456, locale)).toBe("123k");
+    expect(prettyEngineeringNumber(123_456.7, locale)).toBe("123k");
+    expect(prettyEngineeringNumber(12_345.6789, locale)).toBe("12.3k");
+    expect(prettyEngineeringNumber(1.2345, locale)).toBe("1.23");
+    expect(prettyEngineeringNumber(1.000_001_234, locale)).toBe("1");
+    expect(prettyEngineeringNumber(0.12, locale)).toBe("120m");
+    expect(prettyEngineeringNumber(0.1234, locale)).toBe("123m");
+    expect(prettyEngineeringNumber(0.000_123_4, locale)).toBe("123µ");
+    expect(prettyEngineeringNumber(-1.2345, locale)).toBe("-1.23"); // Test with negative numbers
+    expect(prettyEngineeringNumber(-1.000_001_234, locale)).toBe("-1");
+    expect(prettyEngineeringNumber(-0.12, locale)).toBe("-120m");
+    expect(prettyEngineeringNumber(-0.1234, locale)).toBe("-123m");
+    expect(prettyEngineeringNumber(-0.000_123_4, locale)).toBe("-123µ");
   });
 });

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

@@ -0,0 +1,187 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+import { describe, expect, it, vi } from "vitest";
+import { memoizeLastValue, once } from "../once";
+
+describe("once", () => {
+  it("should call function only once", () => {
+    const fn = vi.fn(() => "result");
+    const onceFn = once(fn);
+
+    const result1 = onceFn();
+    const result2 = onceFn();
+
+    expect(result1).toBe("result");
+    expect(result2).toBe("result");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return the same result on subsequent calls", () => {
+    let counter = 0;
+    const fn = () => ++counter;
+    const onceFn = once(fn);
+
+    expect(onceFn()).toBe(1);
+    expect(onceFn()).toBe(1);
+    expect(onceFn()).toBe(1);
+  });
+});
+
+describe("memoizeLastValue", () => {
+  it("should memoize result for same arguments", () => {
+    const fn = vi.fn((a: number, b: string) => `${a}-${b}`);
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn(1, "test");
+    const result2 = memoizedFn(1, "test");
+
+    expect(result1).toBe("1-test");
+    expect(result2).toBe("1-test");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should recompute for different arguments", () => {
+    const fn = vi.fn((a: number) => a * 2);
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn(5);
+    const result2 = memoizedFn(10);
+    const result3 = memoizedFn(5); // Should recompute since args changed from previous call
+
+    expect(result1).toBe(10);
+    expect(result2).toBe(20);
+    expect(result3).toBe(10);
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it("should handle no arguments", () => {
+    const fn = vi.fn(() => "no-args");
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn();
+    const result2 = memoizedFn();
+
+    expect(result1).toBe("no-args");
+    expect(result2).toBe("no-args");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should handle single argument", () => {
+    const fn = vi.fn((x: number) => x + 1);
+    const memoizedFn = memoizeLastValue(fn);
+
+    expect(memoizedFn(5)).toBe(6);
+    expect(memoizedFn(5)).toBe(6);
+    expect(memoizedFn(3)).toBe(4);
+
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle multiple arguments", () => {
+    const fn = vi.fn((a: number, b: string, c: boolean) => ({ a, b, c }));
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn(1, "hello", true);
+    const result2 = memoizedFn(1, "hello", true);
+    const result3 = memoizedFn(1, "hello", false);
+
+    expect(result1).toEqual({ a: 1, b: "hello", c: true });
+    expect(result2).toEqual({ a: 1, b: "hello", c: true });
+    expect(result3).toEqual({ a: 1, b: "hello", c: false });
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should use shallow comparison for objects", () => {
+    const fn = vi.fn((obj: { x: number }) => obj.x * 2);
+    const memoizedFn = memoizeLastValue(fn);
+
+    const obj1 = { x: 5 };
+    const obj2 = { x: 5 }; // Different reference but same content
+
+    const result1 = memoizedFn(obj1);
+    const result2 = memoizedFn(obj1); // Same reference
+    const result3 = memoizedFn(obj2); // Different reference
+
+    expect(result1).toBe(10);
+    expect(result2).toBe(10);
+    expect(result3).toBe(10);
+    expect(fn).toHaveBeenCalledTimes(2); // obj1 (twice with same ref) and obj2 (different ref)
+  });
+
+  it("should handle arrays", () => {
+    const fn = vi.fn((arr: number[]) => arr.reduce((sum, x) => sum + x, 0));
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn([1, 2, 3]);
+    const result2 = memoizedFn([1, 2, 3]); // Different array reference but same content
+    const result3 = memoizedFn([1, 2, 4]); // Different content
+
+    expect(result1).toBe(6);
+    expect(result2).toBe(6);
+    expect(result3).toBe(7);
+    expect(fn).toHaveBeenCalledTimes(3); // Each call has different array reference
+  });
+
+  it("should handle mixed argument types", () => {
+    const fn = vi.fn(
+      (num: number, str: string, arr: number[], obj: { key: string }) =>
+        `${num}-${str}-${arr.length}-${obj.key}`,
+    );
+    const memoizedFn = memoizeLastValue(fn);
+
+    const arr = [1, 2, 3];
+    const obj = { key: "test" };
+
+    const result1 = memoizedFn(42, "hello", arr, obj);
+    const result2 = memoizedFn(42, "hello", arr, obj); // Same references
+    const result3 = memoizedFn(42, "hello", [1, 2, 3], { key: "test" }); // Different references
+
+    expect(result1).toBe("42-hello-3-test");
+    expect(result2).toBe("42-hello-3-test");
+    expect(result3).toBe("42-hello-3-test");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle undefined and null arguments", () => {
+    const fn = vi.fn((a?: string, b?: null) => `${a}-${b}`);
+    const memoizedFn = memoizeLastValue(fn);
+
+    const result1 = memoizedFn(undefined, null);
+    const result2 = memoizedFn(undefined, null);
+    const result3 = memoizedFn("test", null);
+
+    expect(result1).toBe("undefined-null");
+    expect(result2).toBe("undefined-null");
+    expect(result3).toBe("test-null");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should preserve function context", () => {
+    const context = {
+      value: 10,
+      fn: vi.fn(function (this: { value: number }, multiplier: number) {
+        return this.value * multiplier;
+      }),
+    };
+
+    const memoizedFn = memoizeLastValue(context.fn);
+
+    const result1 = memoizedFn.call(context, 2);
+    const result2 = memoizedFn.call(context, 2);
+
+    expect(result1).toBe(20);
+    expect(result2).toBe(20);
+    expect(context.fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("should handle functions that throw errors", () => {
+    const error = new Error("test error");
+    const fn = vi.fn(() => {
+      throw error;
+    });
+    const memoizedFn = memoizeLastValue(fn);
+
+    expect(() => memoizedFn()).toThrow("test error");
+    expect(() => memoizedFn()).toThrow("test error"); // Should throw cached error
+    expect(fn).toHaveBeenCalledTimes(1); // Error should be memoized too
+  });
+});