@marimo-team/islands 0.23.15-dev33 → 0.23.15-dev4

package/dist/{toDate-CKpRx4TS.js → toDate-CWNNlFEX.js}

@@ -5,7 +5,8 @@ import { t as __commonJSMin } from "./chunk-BNovOVIE.js";
 import { _ as Logger } from "./button-BacYv-bE.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
-import { T as atom, a as KnownQueryParams, g as store, v as waitFor, y as isIslands } from "./useTheme-Df_vGflw.js";
+import { r as KnownQueryParams } from "./constants-T20xxyNf.js";
+import { S as atom, g as isIslands, h as waitFor, p as store } from "./useTheme-6eZ3GOTS.js";
 import { t as invariant } from "./invariant-wRzNXIsJ.js";
 var CircleQuestionMark = createLucideIcon("circle-question-mark", [
   ["circle", {
@@ -515,9 +516,9 @@ var RuntimeManager = class {
     return isWasm() || isIslands() || isStaticNotebook();
   }
   formatHttpURL({ path: e = "", searchParams: b, restrictToKnownQueryParams: x = true }) {
-    let S = this.httpURL, C = new URLSearchParams(window.location.search);
+    let S = this.httpURL, w = new URLSearchParams(window.location.search);
     if (b) for (let [e2, x2] of b.entries()) S.searchParams.set(e2, x2);
-    for (let [e2, b2] of C.entries()) x && !Object.values(KnownQueryParams).includes(e2) || S.searchParams.set(e2, b2);
+    for (let [e2, b2] of w.entries()) x && !Object.values(KnownQueryParams).includes(e2) || S.searchParams.set(e2, b2);
     return S.pathname = `${S.pathname.replace(/\/$/, "")}/${e.replace(/^\//, "")}`, S.hash = "", S;
   }
   formatWsURL(e, b) {

package/dist/{useAsyncData-BSOyAbac.js → useAsyncData-KfHB8wQR.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { A as useEvent_default } from "./useTheme-Df_vGflw.js";
+import { D as useEvent_default } from "./useTheme-6eZ3GOTS.js";
 import { t as invariant } from "./invariant-wRzNXIsJ.js";
 var import_compiler_runtime = require_compiler_runtime(), import_react = /* @__PURE__ */ __toESM(require_react(), 1), Result = {
   error(e, s) {

package/dist/{useDeepCompareMemoize-BTLeWzuR.js → useDeepCompareMemoize-nJMtxhm4.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
-import { k as dequal } from "./useTheme-Df_vGflw.js";
+import { E as dequal } from "./useTheme-6eZ3GOTS.js";
 var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 function useDeepCompareMemoize(e) {
   let i = import_react.useRef(e);

package/dist/{useLifecycle-C6wHjkhW.js → useLifecycle-DegSo0lV.js}

@@ -4,7 +4,7 @@ import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
-import { C as useSetAtom, T as atom } from "./useTheme-Df_vGflw.js";
+import { S as atom, b as useSetAtom } from "./useTheme-6eZ3GOTS.js";
 var Calendar = createLucideIcon("calendar", [
   ["path", {
     d: "M8 2v4",

package/dist/{useTheme-Df_vGflw.js → useTheme-6eZ3GOTS.js}

@@ -736,39 +736,7 @@ atom((e) => e(appConfigAtom).width), atom((e) => {
   var _a;
   return ((_a = e(resolvedMarimoConfigAtom).server) == null ? void 0 : _a.disable_file_downloads) ?? false;
 });
-const Constants = {
-  githubPage: "https://github.com/marimo-team/marimo",
-  releasesPage: "https://github.com/marimo-team/marimo/releases",
-  issuesPage: "https://github.com/marimo-team/marimo/issues",
-  feedbackForm: "https://marimo.io/feedback",
-  discordLink: "https://marimo.io/discord?ref=notebook",
-  docsPage: "https://docs.marimo.io",
-  youtube: "https://www.youtube.com/@marimo-team",
-  molab: "https://molab.marimo.io"
-}, KnownQueryParams = {
-  showCode: "show-code",
-  includeCode: "include-code",
-  sessionId: "session_id",
-  kiosk: "kiosk",
-  vscode: "vscode",
-  filePath: "file",
-  accessToken: "access_token",
-  viewAs: "view-as",
-  showChrome: "show-chrome",
-  theme: "theme"
-}, CSSClasses = { outputArea: "output-area" };
-var import_compiler_runtime = require_compiler_runtime();
-const THEMES = [
-  "light",
-  "dark",
-  "system"
-];
-function themeFromQueryParam() {
-  if (typeof window > "u") return;
-  let e = new URLSearchParams(window.location.search).get(KnownQueryParams.theme);
-  return THEMES.includes(e) ? e : void 0;
-}
-var themeAtom = atom((e) => {
+var import_compiler_runtime = require_compiler_runtime(), themeAtom = atom((e) => {
   if (isIslands()) {
     if (document.body.classList.contains("dark-mode") || document.body.classList.contains("dark") || document.body.dataset.theme === "dark" || document.body.dataset.mode === "dark" || getVsCodeTheme() === "dark") return "dark";
     let e2 = window.getComputedStyle(document.body), A = e2.getPropertyValue("color-scheme").trim();
@@ -780,7 +748,7 @@ var themeAtom = atom((e) => {
     }
     return "light";
   }
-  return themeFromQueryParam() ?? e(resolvedMarimoConfigAtom).display.theme;
+  return e(resolvedMarimoConfigAtom).display.theme;
 }), prefersDarkModeAtom = atom(false);
 function setupThemeListener() {
   if (typeof window > "u" || !window.matchMedia) return;
@@ -825,34 +793,31 @@ function useTheme() {
   return e[1] === j ? M = e[2] : (M = { theme: j }, e[1] = j, e[2] = M), M;
 }
 export {
-  useEvent_default as A,
-  useSetAtom as C,
-  buildStore as D,
-  createStore as E,
-  getBuildingBlocks as O,
-  useAtomValue as S,
-  atom as T,
-  useJotaiEffect as _,
-  KnownQueryParams as a,
-  Provider as b,
-  autoInstantiateAtom as c,
-  resolvedMarimoConfigAtom as d,
-  useResolvedMarimoConfig as f,
-  store as g,
-  createDeepEqualAtom as h,
-  Constants as i,
-  dequal as k,
-  getResolvedMarimoConfig as l,
-  AppConfigSchema as m,
+  createStore as C,
+  useEvent_default as D,
+  dequal as E,
+  atom as S,
+  getBuildingBlocks as T,
+  Provider as _,
+  autoInstantiateAtom as a,
+  useSetAtom as b,
+  resolvedMarimoConfigAtom as c,
+  AppConfigSchema as d,
+  createDeepEqualAtom as f,
+  isIslands as g,
+  waitFor as h,
+  aiModelConfiguredAtom as i,
+  useResolvedMarimoConfig as l,
+  useJotaiEffect as m,
   useTheme as n,
-  aiFeaturesEnabledAtom as o,
-  userConfigAtom as p,
-  CSSClasses as r,
-  aiModelConfiguredAtom as s,
+  getResolvedMarimoConfig as o,
+  store as p,
+  aiFeaturesEnabledAtom as r,
+  localeAtom as s,
   resolvedThemeAtom as t,
-  localeAtom as u,
-  waitFor as v,
-  useStore as w,
-  useAtom as x,
-  isIslands as y
+  userConfigAtom as u,
+  useAtom as v,
+  buildStore as w,
+  useStore as x,
+  useAtomValue as y
 };

package/dist/{vega-component-DNHEV0u0.js → vega-component-DzyyM9fc.js}

@@ -2,23 +2,23 @@ import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { _ as Logger, c as Objects, g as cn, h as Events } from "./button-BacYv-bE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { c as asRemoteURL, v as CircleQuestionMark } from "./toDate-CKpRx4TS.js";
+import { c as asRemoteURL, v as CircleQuestionMark } from "./toDate-CWNNlFEX.js";
 import "./react-dom-BTJzcVJ9.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
 import "./zod-CijjQh4u.js";
 import { n as ErrorBanner } from "./error-banner-DFPfz_Qf.js";
 import { t as Tooltip } from "./tooltip-Czds6Qr8.js";
-import { t as debounce_default } from "./debounce-BOD3DbfP.js";
-import { A as useEvent_default, n as useTheme } from "./useTheme-Df_vGflw.js";
+import { i as debounce_default } from "./constants-T20xxyNf.js";
+import { D as useEvent_default, n as useTheme } from "./useTheme-6eZ3GOTS.js";
 import { s as uniq } from "./arrays-sEtDRoG4.js";
-import { a as isValid, i as AlertTitle, n as Alert, t as arrow } from "./formats-BX3uDQbB.js";
+import { a as isValid, i as AlertTitle, n as Alert, t as arrow } from "./formats-Dzx4J_z1.js";
 import { n as formats } from "./vega-loader.browser-CZ-J8Py3.js";
 import { a as getContainerWidth, n as vegaLoadData, s as tooltipHandler } from "./loader-Boph2xIS.js";
 import { t as j } from "./react-vega-B0sAlDTL.js";
 import "./defaultLocale-u-3osm0P.js";
 import "./defaultLocale-BoHTsDG6.js";
-import { t as useAsyncData } from "./useAsyncData-BSOyAbac.js";
-import { t as useDeepCompareMemoize } from "./useDeepCompareMemoize-BTLeWzuR.js";
+import { t as useAsyncData } from "./useAsyncData-KfHB8wQR.js";
+import { t as useDeepCompareMemoize } from "./useDeepCompareMemoize-nJMtxhm4.js";
 import { t as Semaphore } from "./semaphore-CNDGTzkX.js";
 var import_compiler_runtime = require_compiler_runtime(), import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 function fixRelativeUrl(e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.23.15-dev33",
+  "version": "0.23.15-dev4",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/chat/__tests__/chat-utils.test.ts

@@ -2,11 +2,7 @@
 
 import type { UIMessage } from "ai";
 import { describe, expect, it } from "vitest";
-import {
-  hasPendingToolCalls,
-  hasUnresolvedToolCalls,
-  shouldFlushQueue,
-} from "../chat-utils";
+import { hasPendingToolCalls } from "../chat-utils";
 
 /**
  * `hasPendingToolCalls` powers `sendAutomaticallyWhen` in `mo.ui.chat`:
@@ -85,23 +81,6 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 
-  it("returns true when the user denied a tool approval", () => {
-    expect(
-      hasPendingToolCalls([
-        userMessage("delete it"),
-        assistantToolMessage([
-          {
-            type: "tool-delete_file",
-            toolCallId: "call-1",
-            state: "output-denied",
-            input: { path: "secrets.env" },
-            approval: { id: "approval-1", approved: false },
-          } as unknown as UIMessage["parts"][number],
-        ]),
-      ]),
-    ).toBe(true);
-  });
-
   it("returns true when a tool reached a terminal output state", () => {
     expect(
       hasPendingToolCalls([
@@ -288,225 +267,3 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 });
-
-describe("hasUnresolvedToolCalls", () => {
-  it("returns false when there are no messages", () => {
-    expect(hasUnresolvedToolCalls([])).toBe(false);
-  });
-
-  it("returns true while approval is still requested", () => {
-    expect(
-      hasUnresolvedToolCalls([
-        userMessage("delete it"),
-        assistantToolMessage([
-          {
-            type: "tool-delete_file",
-            toolCallId: "call-1",
-            state: "approval-requested",
-            input: { path: "secrets.env" },
-            approval: { id: "approval-1" },
-          } as unknown as UIMessage["parts"][number],
-        ]),
-      ]),
-    ).toBe(true);
-  });
-
-  it("returns true while a tool is still running", () => {
-    expect(
-      hasUnresolvedToolCalls([
-        userMessage("run it"),
-        assistantToolMessage([
-          {
-            type: "tool-run_query",
-            toolCallId: "call-1",
-            state: "input-available",
-            input: { sql: "select 1" },
-          } as unknown as UIMessage["parts"][number],
-        ]),
-      ]),
-    ).toBe(true);
-  });
-
-  it("returns false once tools are ready to round-trip", () => {
-    expect(
-      hasUnresolvedToolCalls([
-        userMessage("run it"),
-        assistantToolMessage([
-          {
-            type: "tool-run_query",
-            toolCallId: "call-1",
-            state: "output-available",
-            input: { sql: "select 1" },
-            output: 1,
-          } as unknown as UIMessage["parts"][number],
-        ]),
-      ]),
-    ).toBe(false);
-  });
-
-  it("returns false once the user denied a tool approval", () => {
-    expect(
-      hasUnresolvedToolCalls([
-        userMessage("delete it"),
-        assistantToolMessage([
-          {
-            type: "tool-delete_file",
-            toolCallId: "call-1",
-            state: "output-denied",
-            input: { path: "secrets.env" },
-            approval: { id: "approval-1", approved: false },
-          } as unknown as UIMessage["parts"][number],
-        ]),
-      ]),
-    ).toBe(false);
-  });
-});
-
-describe("shouldFlushQueue", () => {
-  it("flushes when the turn completed without error or pending tools", () => {
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: false,
-        hasUnresolvedToolCalls: false,
-      }),
-    ).toBe(true);
-  });
-
-  it("does not flush on error", () => {
-    expect(
-      shouldFlushQueue({
-        isError: true,
-        isAbort: false,
-        hasPendingToolCalls: false,
-        hasUnresolvedToolCalls: false,
-      }),
-    ).toBe(false);
-  });
-
-  it("does not flush while a tool round-trip is still pending", () => {
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: true,
-        hasUnresolvedToolCalls: false,
-      }),
-    ).toBe(false);
-  });
-
-  it("does not flush while approval is still requested", () => {
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: false,
-        hasUnresolvedToolCalls: true,
-      }),
-    ).toBe(false);
-  });
-
-  it("flushes on abort even when a tool is still streaming", () => {
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: true,
-        hasPendingToolCalls: false,
-        hasUnresolvedToolCalls: true,
-      }),
-    ).toBe(true);
-  });
-
-  it("does not flush on abort when the run ended in error", () => {
-    expect(
-      shouldFlushQueue({
-        isError: true,
-        isAbort: true,
-        hasPendingToolCalls: false,
-        hasUnresolvedToolCalls: true,
-      }),
-    ).toBe(false);
-  });
-
-  it("flushes once trailing text is present and tools are resolved", () => {
-    const messages = [
-      userMessage("run it"),
-      assistantToolMessage([
-        {
-          type: "tool-run_query",
-          toolCallId: "call-1",
-          state: "output-available",
-          input: {},
-          output: 1,
-        } as unknown as UIMessage["parts"][number],
-        { type: "text", text: "Done." },
-      ]),
-    ];
-
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: hasPendingToolCalls(messages),
-        hasUnresolvedToolCalls: hasUnresolvedToolCalls(messages),
-      }),
-    ).toBe(true);
-  });
-
-  it("blocks flush while text trails a still-running tool, then allows it after resolution", () => {
-    const running = [
-      userMessage("run it"),
-      assistantToolMessage([
-        {
-          type: "tool-run_query",
-          toolCallId: "call-1",
-          state: "input-available",
-          input: {},
-        } as unknown as UIMessage["parts"][number],
-        { type: "text", text: "Running your query..." },
-      ]),
-    ];
-    const resolved = [
-      userMessage("run it"),
-      assistantToolMessage([
-        {
-          type: "tool-run_query",
-          toolCallId: "call-1",
-          state: "output-available",
-          input: {},
-          output: 1,
-        } as unknown as UIMessage["parts"][number],
-        { type: "text", text: "Running your query..." },
-      ]),
-    ];
-
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: hasPendingToolCalls(running),
-        hasUnresolvedToolCalls: hasUnresolvedToolCalls(running),
-      }),
-    ).toBe(false);
-    expect(
-      shouldFlushQueue({
-        isError: false,
-        isAbort: false,
-        hasPendingToolCalls: hasPendingToolCalls(resolved),
-        hasUnresolvedToolCalls: hasUnresolvedToolCalls(resolved),
-      }),
-    ).toBe(true);
-  });
-
-  it("does not flush on error even when tools are also pending", () => {
-    expect(
-      shouldFlushQueue({
-        isError: true,
-        isAbort: false,
-        hasPendingToolCalls: true,
-        hasUnresolvedToolCalls: true,
-      }),
-    ).toBe(false);
-  });
-});