@marimo-team/frontend 0.14.18-dev24 → 0.14.18-dev26

package/src/core/ai/model-registry.ts

@@ -0,0 +1,164 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import type {
+  AiModel as AiModelType,
+  AiProvider,
+  Role,
+} from "@marimo-team/llm-info";
+import { models } from "@marimo-team/llm-info/models.json";
+import { providers } from "@marimo-team/llm-info/providers.json";
+import { MultiMap } from "@/utils/multi-map";
+import { once } from "@/utils/once";
+import type { ProviderId } from "./ids/ids";
+import { AiModelId, type QualifiedModelId, type ShortModelId } from "./ids/ids";
+
+export interface AiModel extends AiModelType {
+  roles: Role[];
+  providers: ProviderId[];
+  /** Whether this is a custom model. */
+  custom: boolean;
+}
+
+const getKnownModelMap = once((): ReadonlyMap<QualifiedModelId, AiModel> => {
+  const modelMap = new Map<QualifiedModelId, AiModel>();
+  for (const model of models) {
+    const modelId = model.model as ShortModelId;
+    const modelInfo: AiModel = {
+      ...model,
+      roles: model.roles.map((role) => role as Role),
+      providers: model.providers as ProviderId[],
+      custom: false,
+    };
+
+    for (const provider of modelInfo.providers) {
+      const qualifiedModelId: QualifiedModelId = `${provider}/${modelId}`;
+      modelMap.set(qualifiedModelId, modelInfo);
+    }
+  }
+  return modelMap;
+});
+
+const getProviderMap = once((): ReadonlyMap<ProviderId, AiProvider> => {
+  const providerMap = new Map<ProviderId, AiProvider>();
+  for (const provider of providers) {
+    providerMap.set(provider.id as ProviderId, provider);
+  }
+  return providerMap;
+});
+
+export class AiModelRegistry {
+  private modelsByProviderMap = new MultiMap<ProviderId, AiModel>();
+  private modelsMap: ReadonlyMap<QualifiedModelId, AiModel>;
+  private customModels: ReadonlySet<QualifiedModelId>;
+  private displayedModels: ReadonlySet<QualifiedModelId>;
+
+  private constructor(
+    customModels: QualifiedModelId[],
+    displayedModels: QualifiedModelId[],
+  ) {
+    this.customModels = new Set(customModels);
+    this.displayedModels = new Set(displayedModels);
+    this.modelsMap = new Map<QualifiedModelId, AiModel>();
+    this.buildMaps();
+  }
+
+  static getProviderInfo(providerId: ProviderId) {
+    return getProviderMap().get(providerId);
+  }
+
+  /**
+   * @param customModels - A list of custom models to use that are not from the default list.
+   * @param displayedModels - A list of models to display in the UI. If empty, all models will be displayed.
+   *
+   * Models should be in the format of `provider_id/short_model_id`.
+   */
+  static create(opts: { customModels?: string[]; displayedModels?: string[] }) {
+    const { customModels = [], displayedModels = [] } = opts;
+    return new AiModelRegistry(
+      customModels.map((model) => AiModelId.parse(model).id),
+      displayedModels.map((model) => AiModelId.parse(model).id),
+    );
+  }
+
+  /**
+   * Builds the maps of models by provider and custom models.
+   * Custom models are added first as they are specified by the user, so we want to surface them first.
+   */
+  private buildMaps() {
+    const displayedModels = this.displayedModels;
+    const hasDisplayedModels = displayedModels.size > 0;
+    const knownModelMap = getKnownModelMap();
+    let modelsMap = new Map<QualifiedModelId, AiModel>();
+
+    // Start with known models
+    if (hasDisplayedModels) {
+      for (const model of displayedModels) {
+        if (knownModelMap.has(model)) {
+          const knownModel = knownModelMap.get(model);
+          if (knownModel) {
+            modelsMap.set(model, knownModel);
+          }
+        }
+      }
+    } else {
+      modelsMap = new Map(knownModelMap);
+    }
+
+    // Add custom models
+    for (const model of this.customModels) {
+      // Skip custom models that are not displayed
+      if (hasDisplayedModels && !displayedModels.has(model)) {
+        continue;
+      }
+
+      // If custom model conflicts with a known model, skip it
+      if (modelsMap.has(model)) {
+        continue;
+      }
+
+      const modelId = AiModelId.parse(model);
+      const modelInfo: AiModel = {
+        name: modelId.id,
+        model: modelId.shortModelId,
+        description: "Custom model",
+        providers: [modelId.providerId],
+        roles: [],
+        thinking: false,
+        custom: true,
+      };
+      modelsMap.set(model, modelInfo);
+    }
+
+    // Group by provider
+    for (const [qualifiedModelId, model] of modelsMap.entries()) {
+      const modelId = AiModelId.parse(qualifiedModelId);
+      this.modelsByProviderMap.add(modelId.providerId, model);
+    }
+
+    this.modelsMap = modelsMap;
+  }
+
+  getDisplayedModels() {
+    return this.displayedModels;
+  }
+
+  getCustomModels() {
+    return this.customModels;
+  }
+
+  getModelsByProvider(provider: ProviderId) {
+    return this.modelsByProviderMap.get(provider) || [];
+  }
+
+  getGroupedModelsByProvider() {
+    return this.modelsByProviderMap;
+  }
+
+  getModelsMap() {
+    return this.modelsMap;
+  }
+
+  getModel(qualifiedModelId: QualifiedModelId) {
+    return this.modelsMap.get(qualifiedModelId);
+  }
+}

package/src/core/cells/cells.ts

@@ -1658,7 +1658,7 @@ export const useCellHandle = (cellId: CellId) =>
 export const getAllEditorViews = () => {
   const { cellIds, cellHandles } = store.get(notebookAtom);
   return cellIds.inOrderIds
-    .map((cellId) => cellHandles[cellId]?.current?.editorView)
+    .map((cellId) => cellHandles[cellId]?.current?.editorViewOrNull)
     .filter(Boolean);
 };
 

package/src/core/cells/effects.ts

@@ -9,7 +9,7 @@ import { store } from "../state/jotai";
 import type { CellId } from "./ids";
 
 const debounceSyncCellIds = debounce((request: UpdateCellIdsRequest) => {
-  getRequestClient().syncCellIds(request);
+  return getRequestClient().syncCellIds(request);
 }, 400);
 
 export const CellEffects = {

package/src/plugins/layout/carousel/CarouselPlugin.tsx

@@ -1,7 +1,6 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
 import React, { type JSX } from "react";
-import swiperCssKeyboard from "swiper/css/keyboard?inline";
 import swiperCssNavigation from "swiper/css/navigation?inline";
 import swiperCssPagination from "swiper/css/pagination?inline";
 import swiperCssScrollbar from "swiper/css/scrollbar?inline";
@@ -30,7 +29,6 @@ export class CarouselPlugin implements IStatelessPlugin<Data> {
   cssStyles = [
     swiperCss,
     swiperCssVirtual,
-    swiperCssKeyboard,
     swiperCssNavigation,
     swiperCssPagination,
     swiperCssScrollbar,

package/src/utils/__tests__/multi-map.test.ts

@@ -0,0 +1,295 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MultiMap } from "../multi-map";
+
+describe("MultiMap", () => {
+  let multiMap: MultiMap<string, number>;
+
+  beforeEach(() => {
+    multiMap = new MultiMap<string, number>();
+  });
+
+  describe("constructor", () => {
+    it("should create an empty MultiMap", () => {
+      expect(multiMap.size).toBe(0);
+    });
+  });
+
+  describe("get", () => {
+    it("should return empty array for non-existent key", () => {
+      expect(multiMap.get("nonexistent")).toEqual([]);
+    });
+
+    it("should return values for existing key", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      expect(multiMap.get("key1")).toEqual([1, 2]);
+    });
+  });
+
+  describe("set", () => {
+    it("should set values for a key", () => {
+      multiMap.set("key1", [1, 2, 3]);
+      expect(multiMap.get("key1")).toEqual([1, 2, 3]);
+    });
+
+    it("should overwrite existing values", () => {
+      multiMap.add("key1", 1);
+      multiMap.set("key1", [4, 5, 6]);
+      expect(multiMap.get("key1")).toEqual([4, 5, 6]);
+    });
+
+    it("should set empty array", () => {
+      multiMap.set("key1", []);
+      expect(multiMap.get("key1")).toEqual([]);
+      expect(multiMap.has("key1")).toBe(true);
+    });
+  });
+
+  describe("add", () => {
+    it("should add value to new key", () => {
+      multiMap.add("key1", 1);
+      expect(multiMap.get("key1")).toEqual([1]);
+    });
+
+    it("should add value to existing key", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      expect(multiMap.get("key1")).toEqual([1, 2]);
+    });
+
+    it("should handle multiple keys", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key2", 2);
+      multiMap.add("key1", 3);
+      expect(multiMap.get("key1")).toEqual([1, 3]);
+      expect(multiMap.get("key2")).toEqual([2]);
+    });
+  });
+
+  describe("has", () => {
+    it("should return false for non-existent key", () => {
+      expect(multiMap.has("nonexistent")).toBe(false);
+    });
+
+    it("should return true for existing key", () => {
+      multiMap.add("key1", 1);
+      expect(multiMap.has("key1")).toBe(true);
+    });
+
+    it("should return true for key with empty array", () => {
+      multiMap.set("key1", []);
+      expect(multiMap.has("key1")).toBe(true);
+    });
+  });
+
+  describe("delete", () => {
+    it("should return false for non-existent key", () => {
+      expect(multiMap.delete("nonexistent")).toBe(false);
+    });
+
+    it("should delete existing key and return true", () => {
+      multiMap.add("key1", 1);
+      expect(multiMap.delete("key1")).toBe(true);
+      expect(multiMap.has("key1")).toBe(false);
+      expect(multiMap.get("key1")).toEqual([]);
+    });
+
+    it("should not affect other keys", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key2", 2);
+      multiMap.delete("key1");
+      expect(multiMap.has("key2")).toBe(true);
+      expect(multiMap.get("key2")).toEqual([2]);
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear empty MultiMap", () => {
+      multiMap.clear();
+      expect(multiMap.size).toBe(0);
+    });
+
+    it("should clear all keys and values", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key2", 2);
+      multiMap.clear();
+      expect(multiMap.size).toBe(0);
+      expect(multiMap.has("key1")).toBe(false);
+      expect(multiMap.has("key2")).toBe(false);
+    });
+  });
+
+  describe("keys", () => {
+    it("should return empty iterator for empty MultiMap", () => {
+      const keys = [...multiMap.keys()];
+      expect(keys).toEqual([]);
+    });
+
+    it("should return all keys", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key2", 2);
+      multiMap.add("key3", 3);
+      const keys = [...multiMap.keys()];
+      expect(keys.sort()).toEqual(["key1", "key2", "key3"]);
+    });
+  });
+
+  describe("values", () => {
+    it("should return empty iterator for empty MultiMap", () => {
+      const values = [...multiMap.values()];
+      expect(values).toEqual([]);
+    });
+
+    it("should return all value arrays", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      multiMap.add("key2", 3);
+      const values = [...multiMap.values()];
+      expect(values).toHaveLength(2);
+      expect(values).toContainEqual([1, 2]);
+      expect(values).toContainEqual([3]);
+    });
+  });
+
+  describe("entries", () => {
+    it("should return empty iterator for empty MultiMap", () => {
+      const entries = [...multiMap.entries()];
+      expect(entries).toEqual([]);
+    });
+
+    it("should return all key-value pairs", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      multiMap.add("key2", 3);
+      const entries = [...multiMap.entries()];
+      expect(entries).toHaveLength(2);
+      expect(entries).toContainEqual(["key1", [1, 2]]);
+      expect(entries).toContainEqual(["key2", [3]]);
+    });
+  });
+
+  describe("forEach", () => {
+    it("should not call callback for empty MultiMap", () => {
+      const callback = vi.fn();
+      multiMap.forEach(callback);
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it("should call callback for each key-value pair", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      multiMap.add("key2", 3);
+
+      const callback = vi.fn();
+      multiMap.forEach(callback);
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenCalledWith([1, 2], "key1", expect.any(Map));
+      expect(callback).toHaveBeenCalledWith([3], "key2", expect.any(Map));
+    });
+  });
+
+  describe("flatValues", () => {
+    it("should return empty array for empty MultiMap", () => {
+      expect(multiMap.flatValues()).toEqual([]);
+    });
+
+    it("should flatten all values into single array", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 2);
+      multiMap.add("key2", 3);
+      multiMap.add("key3", 4);
+      multiMap.add("key3", 5);
+
+      const flattened = multiMap.flatValues();
+      expect(flattened.sort()).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it("should handle empty arrays in values", () => {
+      multiMap.set("key1", []);
+      multiMap.add("key2", 1);
+      multiMap.add("key2", 2);
+
+      const flattened = multiMap.flatValues();
+      expect(flattened.sort()).toEqual([1, 2]);
+    });
+  });
+
+  describe("size", () => {
+    it("should return 0 for empty MultiMap", () => {
+      expect(multiMap.size).toBe(0);
+    });
+
+    it("should return number of keys", () => {
+      multiMap.add("key1", 1);
+      expect(multiMap.size).toBe(1);
+
+      multiMap.add("key1", 2);
+      expect(multiMap.size).toBe(1);
+
+      multiMap.add("key2", 3);
+      expect(multiMap.size).toBe(2);
+    });
+
+    it("should update when keys are deleted", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key2", 2);
+      expect(multiMap.size).toBe(2);
+
+      multiMap.delete("key1");
+      expect(multiMap.size).toBe(1);
+
+      multiMap.clear();
+      expect(multiMap.size).toBe(0);
+    });
+  });
+
+  describe("different key and value types", () => {
+    it("should work with number keys and string values", () => {
+      const numberKeyMap = new MultiMap<number, string>();
+      numberKeyMap.add(1, "one");
+      numberKeyMap.add(1, "uno");
+      numberKeyMap.add(2, "two");
+
+      expect(numberKeyMap.get(1)).toEqual(["one", "uno"]);
+      expect(numberKeyMap.get(2)).toEqual(["two"]);
+      expect(numberKeyMap.flatValues()).toEqual(["one", "uno", "two"]);
+    });
+
+    it("should work with object keys and values", () => {
+      interface TestObj {
+        id: number;
+        name: string;
+      }
+
+      const objMap = new MultiMap<string, TestObj>();
+      const obj1 = { id: 1, name: "test1" };
+      const obj2 = { id: 2, name: "test2" };
+
+      objMap.add("group1", obj1);
+      objMap.add("group1", obj2);
+
+      expect(objMap.get("group1")).toEqual([obj1, obj2]);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle undefined and null values", () => {
+      const nullMap = new MultiMap<string, null | undefined>();
+      nullMap.add("key1", null);
+      nullMap.add("key1", undefined);
+
+      expect(nullMap.get("key1")).toEqual([null, undefined]);
+    });
+
+    it("should handle duplicate values", () => {
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 1);
+      multiMap.add("key1", 1);
+
+      expect(multiMap.get("key1")).toEqual([1, 1, 1]);
+    });
+  });
+});

package/src/utils/multi-map.ts

@@ -0,0 +1,71 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+/**
+ * MultiMap: a Map<K, V[]> with convenient helpers.
+ */
+export class MultiMap<K, V> {
+  private map = new Map<K, V[]>();
+
+  get(key: K): V[] {
+    return this.map.get(key) ?? [];
+  }
+
+  set(key: K, values: V[]): void {
+    this.map.set(key, values);
+  }
+
+  add(key: K, value: V): void {
+    if (this.map.has(key)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.map.get(key)!.push(value);
+    } else {
+      this.map.set(key, [value]);
+    }
+  }
+
+  has(key: K): boolean {
+    return this.map.has(key);
+  }
+
+  delete(key: K): boolean {
+    return this.map.delete(key);
+  }
+
+  clear(): void {
+    this.map.clear();
+  }
+
+  keys(): IterableIterator<K> {
+    return this.map.keys();
+  }
+
+  values(): IterableIterator<V[]> {
+    return this.map.values();
+  }
+
+  entries(): IterableIterator<[K, V[]]> {
+    return this.map.entries();
+  }
+
+  forEach(callback: (values: V[], key: K, map: Map<K, V[]>) => void): void {
+    this.map.forEach(callback);
+  }
+
+  /**
+   * Flatten all values into a single array.
+   */
+  flatValues(): V[] {
+    const result: V[] = [];
+    for (const arr of this.map.values()) {
+      result.push(...arr);
+    }
+    return result;
+  }
+
+  /**
+   * Number of keys in the MultiMap.
+   */
+  get size(): number {
+    return this.map.size;
+  }
+}

package/dist/assets/_baseMap-lEtQfieX.js

@@ -1 +0,0 @@
-import{b as m}from"./_baseEach-H5Qk1V2B.js";import{x as s}from"./index-dvYU8Vev.js";function e(r,o){var a=-1,t=s(r)?Array(r.length):[];return m(r,function(n,f,i){t[++a]=o(n,f,i)}),t}export{e as b};

package/dist/assets/channel-CJdgPvjM.js

@@ -1 +0,0 @@
-import{U as s,C as o}from"./mermaid-DuiiiGkf.js";const n=(a,r)=>s.lang.round(o.parse(a)[r]);export{n as c};

package/dist/assets/classDiagram-M3E45YP4-Tb8oQ03C.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as t,C as o}from"./chunk-SZ463SBG-CO9fYjVe.js";import{_ as e}from"./mermaid-DuiiiGkf.js";import"./transform-B8bpuzxV.js";import"./chunk-E2GYISFI-C7n5SQvq.js";import"./chunk-BFAMUDN2-B0dcgdMs.js";import"./chunk-SKB7J2MH-DX71TF_n.js";import"./index-dvYU8Vev.js";import"./step-BwsUM5iJ.js";import"./timer-BwIYMJWC.js";var i={parser:t,get db(){return new o},renderer:s,styles:a,init:e(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{i as diagram};

package/dist/assets/classDiagram-v2-YAWTLIQI-Tb8oQ03C.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as t,C as o}from"./chunk-SZ463SBG-CO9fYjVe.js";import{_ as e}from"./mermaid-DuiiiGkf.js";import"./transform-B8bpuzxV.js";import"./chunk-E2GYISFI-C7n5SQvq.js";import"./chunk-BFAMUDN2-B0dcgdMs.js";import"./chunk-SKB7J2MH-DX71TF_n.js";import"./index-dvYU8Vev.js";import"./step-BwsUM5iJ.js";import"./timer-BwIYMJWC.js";var i={parser:t,get db(){return new o},renderer:s,styles:a,init:e(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{i as diagram};

package/dist/assets/clone-DygFoMzB.js

@@ -1 +0,0 @@
-import{b as n}from"./_baseUniq-UAmxGez2.js";function o(r){return n(r,4)}export{o as c};