@marimo-team/frontend 0.22.1-dev2 → 0.22.1-dev21

package/src/plugins/impl/vega/__tests__/utils.test.ts

@@ -33,4 +33,72 @@ describe("getContainerWidth", () => {
   it("should return undefined when width is explicitly undefined", () => {
     expect(getContainerWidth({ width: undefined })).toBeUndefined();
   });
+
+  it("should find width in nested facet spec", () => {
+    expect(
+      getContainerWidth({
+        $schema: "https://vega.github.io/schema/vega-lite/v6.json",
+        facet: { column: { field: "Origin", type: "nominal" } },
+        spec: {
+          mark: "point",
+          encoding: {},
+          width: "container",
+        },
+      }),
+    ).toBe("container");
+  });
+
+  it("should find width in nested repeat spec", () => {
+    expect(
+      getContainerWidth({
+        $schema: "https://vega.github.io/schema/vega-lite/v6.json",
+        repeat: { row: ["A", "B"] },
+        spec: {
+          mark: "point",
+          encoding: {},
+          width: "container",
+        },
+      }),
+    ).toBe("container");
+  });
+
+  it("should return undefined for nested spec without width", () => {
+    expect(
+      getContainerWidth({
+        facet: { column: { field: "Origin" } },
+        spec: { mark: "point", encoding: {} },
+      }),
+    ).toBeUndefined();
+  });
+
+  it("should return undefined for hconcat (width on sub-specs)", () => {
+    expect(
+      getContainerWidth({
+        hconcat: [{ width: "container" }, { width: "container" }],
+      }),
+    ).toBeUndefined();
+  });
+
+  it("should return undefined for vconcat (width on sub-specs)", () => {
+    expect(
+      getContainerWidth({
+        vconcat: [{ width: "container" }, { width: "container" }],
+      }),
+    ).toBeUndefined();
+  });
+
+  it("should return undefined for compiled Vega spec (width as signal)", () => {
+    expect(
+      getContainerWidth({
+        $schema: "https://vega.github.io/schema/vega/v6.json",
+        autosize: { contains: "padding", type: "fit-x" },
+        signals: [
+          {
+            name: "width",
+            init: "isFinite(containerSize()[0]) ? containerSize()[0] : 300",
+          },
+        ],
+      }),
+    ).toBeUndefined();
+  });
 });

package/src/plugins/impl/vega/utils.ts

@@ -6,13 +6,22 @@ import type { DataType, FieldTypes, VegaDataType } from "./vega-loader";
 export type ContainerWidth = number | "container";
 
 /**
- * Get the container width from a VegaLite spec.
- * @param spec - The VegaLite spec.
- * @returns The container width.
+ * Get the container width from a Vega-Lite spec.
+ *
+ * For unit specs, `width` is at the top level. For facet/repeat specs,
+ * `width` is nested inside `spec`. This does not handle hconcat/vconcat and Vega spec
+ * where the width may be a signal. These cases are covered by
+ * the CSS fallback `.vega-embed:has(> .chart-wrapper.fit-x)`.
  */
 export function getContainerWidth(spec: unknown): ContainerWidth | undefined {
-  if (typeof spec === "object" && spec !== null && "width" in spec) {
-    return spec.width as ContainerWidth | undefined;
+  if (typeof spec === "object" && spec !== null) {
+    if ("width" in spec) {
+      return spec.width as ContainerWidth | undefined;
+    }
+    // Faceted/repeated spec
+    if ("spec" in spec) {
+      return getContainerWidth(spec.spec);
+    }
   }
   return undefined;
 }

package/src/plugins/impl/vega/vega.css

@@ -4,7 +4,8 @@
   max-width: 100%;
 }
 
-.vega-embed[data-container-width="container"] {
+.vega-embed[data-container-width="container"],
+.vega-embed:has(> .chart-wrapper.fit-x) {
   width: 100%;
 }
 

package/src/utils/json/base64.ts

@@ -71,7 +71,6 @@ function base64ToUint8ArrayFallback(bytes: string): Uint8Array {
  * Uses native Uint8Array.fromBase64 if available, otherwise falls back to manual implementation.
  */
 export const base64ToUint8Array: (bytes: Base64String) => Uint8Array =
-  // @ts-expect-error - Uint8Array.fromBase64 types coming in TypeScript 5.10+
   Uint8Array.fromBase64 ?? base64ToUint8ArrayFallback;
 
 /**
@@ -100,10 +99,8 @@ function uint8ArrayToBase64Fallback(binary: Uint8Array): Base64String {
  * Uses native Uint8Array.prototype.toBase64 if available, otherwise falls back to manual implementation.
  */
 export const uint8ArrayToBase64: (binary: Uint8Array) => Base64String =
-  // @ts-expect-error - Uint8Array.prototype.toBase64 types coming in TypeScript 5.10+
-  Uint8Array.prototype.toBase64
-    ? // @ts-expect-error - Uint8Array.prototype.toBase64 types coming in TypeScript 5.10+
-      (binary) => binary.toBase64()
+  "toBase64" in Uint8Array.prototype
+    ? (binary) => binary.toBase64() as Base64String
     : uint8ArrayToBase64Fallback;
 
 /**

package/src/utils/time.ts

@@ -1,8 +1,10 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-export type Milliseconds = number & { __type__: "milliseconds" };
+import type { TypedNumber } from "./typed";
 
-export type Seconds = number & { __type__: "seconds" };
+export type Milliseconds = TypedNumber<"milliseconds">;
+
+export type Seconds = TypedNumber<"seconds">;
 
 export class Time {
   private readonly ms: Milliseconds;

package/src/utils/typed.ts

@@ -5,13 +5,13 @@
  * This is a compile-time type only and does not exist at runtime.
  * It is used to distinguish between different types of numbers.
  */
-export type TypedNumber<T> = number & { __type__: T };
+export type TypedNumber<T> = number & { __brand: T };
 
 /**
  * A typed string.
  * This is a compile-time type only and does not exist at runtime.
  * It is used to distinguish between different types of strings.
  */
-export type TypedString<T> = string & { __type__: T };
+export type TypedString<T> = string & { __brand: T };
 
 export type Identified<T> = { id: string } & T;