@marimo-team/islands 0.23.14-dev6 → 0.23.14-dev61

package/src/core/wasm/__tests__/PyodideLoader.test.ts

@@ -1,72 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { describe, expect, it } from "vitest";
-import { shouldShowSpinner } from "../PyodideLoader";
-
-describe("shouldShowSpinner", () => {
-  it("shows the spinner when there are no cells yet (Pyodide hasn't parsed)", () => {
-    expect(
-      shouldShowSpinner({
-        hasCells: false,
-        hasOutput: false,
-        mode: "read",
-        codeHidden: false,
-      }),
-    ).toBe(true);
-
-    expect(
-      shouldShowSpinner({
-        hasCells: false,
-        hasOutput: true,
-        mode: "edit",
-        codeHidden: false,
-      }),
-    ).toBe(true);
-  });
-
-  it("renders children once cells exist with code visible", () => {
-    // run mode, code visible, no outputs yet — the user can read the code
-    expect(
-      shouldShowSpinner({
-        hasCells: true,
-        hasOutput: false,
-        mode: "read",
-        codeHidden: false,
-      }),
-    ).toBe(false);
-  });
-
-  it("renders children once cells exist with cached outputs (snapshot case)", () => {
-    expect(
-      shouldShowSpinner({
-        hasCells: true,
-        hasOutput: true,
-        mode: "read",
-        codeHidden: true,
-      }),
-    ).toBe(false);
-  });
-
-  it("keeps the spinner up in headless run mode with no outputs", () => {
-    // read mode + code hidden + no outputs = nothing visible to render
-    expect(
-      shouldShowSpinner({
-        hasCells: true,
-        hasOutput: false,
-        mode: "read",
-        codeHidden: true,
-      }),
-    ).toBe(true);
-  });
-
-  it("never blocks edit mode once cells exist", () => {
-    expect(
-      shouldShowSpinner({
-        hasCells: true,
-        hasOutput: false,
-        mode: "edit",
-        codeHidden: true,
-      }),
-    ).toBe(false);
-  });
-});

package/src/core/wasm/__tests__/state.test.ts

@@ -1,124 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { createRef } from "react";
-import { describe, expect, it } from "vitest";
-import { cellId } from "@/__tests__/branded";
-import type { NotebookState } from "@/core/cells/cells";
-import { initialNotebookState, notebookAtom } from "@/core/cells/cells";
-import { createCell, createCellRuntimeState } from "@/core/cells/types";
-import type { OutputMessage } from "@/core/kernel/messages";
-import { store } from "@/core/state/jotai";
-import { CollapsibleTree, MultiColumn } from "@/utils/id-tree";
-import { hasAnyOutputAtom } from "../state";
-
-describe("hasAnyOutputAtom", () => {
-  const createNotebookState = (
-    outputs: (OutputMessage | null)[],
-  ): NotebookState => ({
-    ...initialNotebookState(),
-    cellIds: new MultiColumn([
-      CollapsibleTree.from(outputs.map((_, i) => cellId(`${i}`))),
-    ]),
-    cellData: Object.fromEntries(
-      outputs.map((_, i) => [
-        cellId(`${i}`),
-        createCell({ id: cellId(`${i}`) }),
-      ]),
-    ),
-    cellRuntime: Object.fromEntries(
-      outputs.map((output, i) => [
-        `${i}`,
-        createCellRuntimeState({
-          output,
-          status: "queued",
-          outline: { items: [] },
-        }),
-      ]),
-    ),
-    cellHandles: Object.fromEntries(
-      outputs.map((_, i) => [cellId(`${i}`), createRef()]),
-    ),
-  });
-
-  it("should return false when there are no outputs", () => {
-    store.set(notebookAtom, createNotebookState([null, null]));
-    expect(store.get(hasAnyOutputAtom)).toBe(false);
-  });
-
-  it("should return false when all outputs are empty", () => {
-    store.set(
-      notebookAtom,
-      createNotebookState([
-        { channel: "output", mimetype: "text/plain", data: "", timestamp: 0 },
-        { channel: "output", mimetype: "text/plain", data: "", timestamp: 0 },
-      ]),
-    );
-    expect(store.get(hasAnyOutputAtom)).toBe(false);
-  });
-
-  it("should return true when there is at least one non-empty output", () => {
-    store.set(
-      notebookAtom,
-      createNotebookState([
-        { channel: "output", mimetype: "text/plain", data: "", timestamp: 0 },
-        {
-          channel: "output",
-          mimetype: "text/plain",
-          data: "hello",
-          timestamp: 0,
-        },
-      ]),
-    );
-    expect(store.get(hasAnyOutputAtom)).toBe(true);
-  });
-
-  it("should handle various output types", () => {
-    store.set(
-      notebookAtom,
-      createNotebookState([
-        {
-          channel: "output",
-          mimetype: "application/json",
-          data: { foo: "bar" },
-          timestamp: 0,
-        },
-        { channel: "output", mimetype: "text/plain", data: "", timestamp: 0 },
-      ]),
-    );
-    expect(store.get(hasAnyOutputAtom)).toBe(true);
-  });
-
-  it("should return true when all outputs are idle", () => {
-    const notebookState = createNotebookState([null, null]);
-    const cellId0 = cellId("0");
-    const cellId1 = cellId("1");
-    // Some idle cell, so returns false
-    store.set(notebookAtom, {
-      ...notebookState,
-      cellRuntime: {
-        ...notebookState.cellRuntime,
-        [cellId0]: {
-          ...notebookState.cellRuntime[cellId0],
-          status: "idle",
-        },
-      },
-    });
-    expect(store.get(hasAnyOutputAtom)).toBe(false);
-
-    // All cells are idle, so returns true
-    store.set(notebookAtom, {
-      ...notebookState,
-      cellRuntime: {
-        [cellId0]: {
-          ...notebookState.cellRuntime[cellId0],
-          status: "idle",
-        },
-        [cellId1]: {
-          ...notebookState.cellRuntime[cellId1],
-          status: "idle",
-        },
-      },
-    });
-    expect(store.get(hasAnyOutputAtom)).toBe(true);
-  });
-});

package/src/plugins/impl/anywidget/schemas.ts

@@ -1,32 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-import { z } from "zod";
-
-const BufferPathSchema = z.array(z.array(z.union([z.string(), z.number()])));
-const StateSchema = z.record(z.string(), z.any());
-
-export const AnyWidgetMessageSchema = z.discriminatedUnion("method", [
-  z.object({
-    method: z.literal("open"),
-    state: StateSchema,
-    buffer_paths: BufferPathSchema.optional(),
-  }),
-  z.object({
-    method: z.literal("update"),
-    state: StateSchema,
-    buffer_paths: BufferPathSchema.optional(),
-  }),
-  z.object({
-    method: z.literal("custom"),
-    content: z.any(),
-  }),
-  z.object({
-    method: z.literal("echo_update"),
-    buffer_paths: BufferPathSchema,
-    state: StateSchema,
-  }),
-  z.object({
-    method: z.literal("close"),
-  }),
-]);
-
-export type AnyWidgetMessage = z.infer<typeof AnyWidgetMessageSchema>;