@marimo-team/frontend 0.16.0 → 0.16.2

package/src/utils/id-tree.tsx

@@ -23,11 +23,15 @@ export type CellIndex = number & { __brand?: "CellIndex" };
  * Tree data structure for handling ids with nested children
  */
 export class TreeNode<T> {
-  constructor(
-    public value: T,
-    public isCollapsed: boolean,
-    public children: Array<TreeNode<T>>,
-  ) {}
+  public value: T;
+  public isCollapsed: boolean;
+  public children: Array<TreeNode<T>>;
+
+  constructor(value: T, isCollapsed: boolean, children: Array<TreeNode<T>>) {
+    this.value = value;
+    this.isCollapsed = isCollapsed;
+    this.children = children;
+  }
 
   /**
    * Recursively count the number of nodes in the tree
@@ -102,10 +106,13 @@ export class TreeNode<T> {
 let uniqueId = 0;
 
 export class CollapsibleTree<T> {
-  private constructor(
-    public readonly nodes: Array<TreeNode<T>>,
-    public readonly id: CellColumnId,
-  ) {}
+  public readonly nodes: Array<TreeNode<T>>;
+  public readonly id: CellColumnId;
+
+  private constructor(nodes: Array<TreeNode<T>>, id: CellColumnId) {
+    this.nodes = nodes;
+    this.id = id;
+  }
 
   static from<T>(ids: T[]): CollapsibleTree<T> {
     const id = `tree_${uniqueId++}` as CellColumnId;
@@ -592,7 +599,11 @@ export class CollapsibleTree<T> {
 }
 
 export class MultiColumn<T> {
-  constructor(private readonly columns: ReadonlyArray<CollapsibleTree<T>>) {
+  private readonly columns: ReadonlyArray<CollapsibleTree<T>>;
+
+  constructor(columns: ReadonlyArray<CollapsibleTree<T>>) {
+    this.columns = columns;
+
     // Ensure there is always at least one column
     if (columns.length === 0) {
       this.columns = [CollapsibleTree.from([])];

package/src/utils/localStorage.ts

@@ -12,7 +12,10 @@ interface Storage<T> {
 }
 
 export class TypedLocalStorage<T> implements Storage<T> {
-  constructor(private defaultValue: T) {}
+  private defaultValue: T;
+  constructor(defaultValue: T) {
+    this.defaultValue = defaultValue;
+  }
 
   get(key: string): T {
     try {
@@ -33,10 +36,16 @@ export class TypedLocalStorage<T> implements Storage<T> {
 }
 
 export class ZodLocalStorage<T> implements Storage<T> {
+  private schema: ZodType<T, ZodTypeDef, unknown>;
+  private getDefaultValue: () => T;
+
   constructor(
-    private schema: ZodType<T, ZodTypeDef, unknown>,
-    private getDefaultValue: () => T,
-  ) {}
+    schema: ZodType<T, ZodTypeDef, unknown>,
+    getDefaultValue: () => T,
+  ) {
+    this.schema = schema;
+    this.getDefaultValue = getDefaultValue;
+  }
 
   get(key: string): T {
     try {

package/src/utils/numbers.ts

@@ -1,6 +1,6 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
-export function prettyNumber(value: unknown): string {
+export function prettyNumber(value: unknown, locale: string): string {
   if (value === undefined || value === null) {
     return "";
   }
@@ -18,7 +18,7 @@ export function prettyNumber(value: unknown): string {
   }
 
   if (typeof value === "number" || typeof value === "bigint") {
-    return value.toLocaleString(undefined, {
+    return value.toLocaleString(locale, {
       minimumFractionDigits: 0,
       maximumFractionDigits: 2,
     });
@@ -45,9 +45,9 @@ function scientificSpecialCase(value: number): string | null {
 export function prettyScientificNumber(
   value: number,
   opts: {
-    // Default to false
-    shouldRound?: boolean;
-  } = {},
+    shouldRound?: boolean; // Default to false
+    locale: string;
+  },
 ): string {
   // Handle special cases first
   const specialCase = scientificSpecialCase(value);
@@ -58,7 +58,7 @@ export function prettyScientificNumber(
   // Determine if the number should be in scientific notation
   const absValue = Math.abs(value);
   if (absValue < 1e-2 || absValue >= 1e6) {
-    return new Intl.NumberFormat(undefined, {
+    return new Intl.NumberFormat(opts.locale, {
       minimumFractionDigits: 1,
       maximumFractionDigits: 1,
       notation: "scientific",
@@ -67,18 +67,18 @@ export function prettyScientificNumber(
       .toLowerCase();
   }
 
-  const { shouldRound } = opts;
+  const { shouldRound, locale } = opts;
 
   if (shouldRound) {
     // Number has an integer part, format with 2 decimal places
-    return new Intl.NumberFormat(undefined, {
+    return new Intl.NumberFormat(locale, {
       minimumFractionDigits: 0,
       maximumFractionDigits: 2,
     }).format(value);
   }
 
   // Don't round
-  return value.toLocaleString(undefined, {
+  return value.toLocaleString(locale, {
     minimumFractionDigits: 0,
     maximumFractionDigits: 100,
   });
@@ -104,14 +104,14 @@ const prefixes = {
   "-24": "y",
 };
 
-export function prettyEngineeringNumber(value: number): string {
+export function prettyEngineeringNumber(value: number, locale: string): string {
   // Handle special cases first
   const specialCase = scientificSpecialCase(value);
   if (specialCase !== null) {
     return specialCase;
   }
 
-  const [mant, exp] = new Intl.NumberFormat("en-us", {
+  const [mant, exp] = new Intl.NumberFormat(locale, {
     notation: "engineering",
     maximumSignificantDigits: 3,
   })

package/src/utils/once.ts

@@ -1,5 +1,7 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
+import { arrayShallowEquals } from "./arrays";
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function once<T extends (...args: any[]) => any>(fn: T): T {
   let result: ReturnType<T>;
@@ -15,3 +17,33 @@ export function once<T extends (...args: any[]) => any>(fn: T): T {
     return result;
   } as T;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function memoizeLastValue<T extends (...args: any[]) => any>(fn: T): T {
+  let result: ReturnType<T>;
+  let lastArgs: Parameters<T> | undefined;
+  let lastError: unknown;
+  let hasError = false;
+
+  return function (
+    this: ThisParameterType<T>,
+    ...args: Parameters<T>
+  ): ReturnType<T> {
+    if (lastArgs === undefined || !arrayShallowEquals(args, lastArgs)) {
+      try {
+        result = fn.apply(this, args) as ReturnType<T>;
+        hasError = false;
+        lastError = undefined;
+      } catch (error) {
+        hasError = true;
+        lastError = error;
+      }
+      lastArgs = args;
+    }
+
+    if (hasError) {
+      throw lastError;
+    }
+    return result;
+  } as T;
+}

package/src/utils/paths.ts

@@ -32,7 +32,10 @@ export const Paths = {
 };
 
 export class PathBuilder {
-  constructor(public readonly deliminator: "/" | "\\") {}
+  public readonly deliminator: string;
+  constructor(deliminator: "/" | "\\") {
+    this.deliminator = deliminator;
+  }
 
   static guessDeliminator(path: string): PathBuilder {
     return path.includes("/") ? new PathBuilder("/") : new PathBuilder("\\");

package/src/utils/pluralize.ts

@@ -1,10 +1,13 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
 export class PluralWord {
-  constructor(
-    public singular: string,
-    public _plural?: string,
-  ) {}
+  public singular: string;
+  public _plural?: string;
+
+  constructor(singular: string, _plural?: string) {
+    this.singular = singular;
+    this._plural = _plural;
+  }
 
   public pluralize(count: number) {
     return count === 1 ? this.singular : this.plural;
@@ -16,7 +19,11 @@ export class PluralWord {
 }
 
 export class PluralWords {
-  constructor(private words: PluralWord[]) {}
+  private words: PluralWord[];
+
+  constructor(words: PluralWord[]) {
+    this.words = words;
+  }
 
   static of(...words: Array<PluralWord | string>) {
     return new PluralWords(

package/src/utils/python-poet/poet.ts

@@ -25,7 +25,10 @@ function asString(value: string | PythonCode): string {
 }
 
 export class Variable implements PythonCode {
-  constructor(public name: string) {}
+  name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
 
   toCode(): string {
     return this.name;
@@ -38,10 +41,12 @@ interface LiteralOptions {
 }
 
 export class Literal implements PythonCode {
-  constructor(
-    public readonly value: unknown,
-    public readonly opts: LiteralOptions = {},
-  ) {}
+  public readonly value: unknown;
+  public readonly opts: LiteralOptions;
+  constructor(value: unknown, opts: LiteralOptions = {}) {
+    this.value = value;
+    this.opts = opts;
+  }
 
   static from(value: unknown, opts: LiteralOptions = {}): Literal {
     return new Literal(value, opts);
@@ -114,10 +119,13 @@ export class Literal implements PythonCode {
 }
 
 export class VariableDeclaration implements PythonCode {
-  constructor(
-    public name: string,
-    public value: string | PythonCode,
-  ) {}
+  public name: string;
+  public value: string | PythonCode;
+
+  constructor(name: string, value: string | PythonCode) {
+    this.name = name;
+    this.value = value;
+  }
 
   toCode(): string {
     const right = asString(this.value);
@@ -129,10 +137,13 @@ export class VariableDeclaration implements PythonCode {
 }
 
 export class FunctionArg implements PythonCode {
-  constructor(
-    public name: string,
-    public value: string | PythonCode,
-  ) {}
+  public name: string;
+  public value: string | PythonCode;
+
+  constructor(name: string, value: string | PythonCode) {
+    this.name = name;
+    this.value = value;
+  }
 
   toCode(): string {
     return `${this.name}=${asString(this.value)}`;
@@ -141,12 +152,16 @@ export class FunctionArg implements PythonCode {
 
 export class FunctionCall implements PythonCode {
   private args: PythonCode[];
+  public name: string;
+  public multiLine: boolean;
 
   constructor(
-    public name: string,
+    name: string,
     args: PythonCode[] | Record<string, PythonCode>,
-    public multiLine = false,
+    multiLine = false,
   ) {
+    this.name = name;
+    this.multiLine = multiLine;
     this.args = objectToArgs(args);
   }
 

package/src/utils/time.ts

@@ -5,6 +5,8 @@ export type Milliseconds = number & { __type__: "milliseconds" };
 export type Seconds = number & { __type__: "seconds" };
 
 export class Time {
+  private readonly ms: Milliseconds;
+
   static fromMilliseconds(ms: Milliseconds): Time;
   static fromMilliseconds(ms: Milliseconds | null): Time | null;
   static fromMilliseconds(ms: Milliseconds | null): Time | null {
@@ -27,7 +29,9 @@ export class Time {
     return new Time(Date.now() as Milliseconds);
   }
 
-  private constructor(private readonly ms: Milliseconds) {}
+  private constructor(ms: Milliseconds) {
+    this.ms = ms;
+  }
 
   toMilliseconds(): Milliseconds {
     return this.ms;