Remove ExtenedMap, ToggleSet, and observable versions (#3310)

- Switch to helper functions instead. They don't impact the prototype
  tree and it means that we don't need to introduce versions that are
  both observable and "normal"

- Tidy <ItemListLayout> and hiddenTableColumns to not need
  pre-initialization

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/common/catalog/catalog-category-registry.ts

@@ -4,15 +4,16 @@
  */
 
 import { action, computed, observable, makeObservable } from "mobx";
-import { Disposer, ExtendedMap, iter } from "../utils";
-import { CatalogCategory, CatalogEntityData, CatalogEntityKindData } from "./catalog-entity";
+import type { Disposer } from "../utils";
+import { strictSet, iter, getOrInsertMap } from "../utils";
 import { once } from "lodash";
+import { CatalogCategory, CatalogEntityData, CatalogEntityKindData } from "./catalog-entity";
 
 export type CategoryFilter = (category: CatalogCategory) => any;
 
 export class CatalogCategoryRegistry {
   protected categories = observable.set<CatalogCategory>();
-  protected groupKinds = new ExtendedMap<string, ExtendedMap<string, CatalogCategory>>();
+  protected groupKinds = new Map<string, Map<string, CatalogCategory>>();
   protected filters = observable.set<CategoryFilter>([], {
     deep: false,
   });
@@ -22,14 +23,14 @@ export class CatalogCategoryRegistry {
   }
 
   @action add(category: CatalogCategory): Disposer {
+    const byGroup = getOrInsertMap(this.groupKinds, category.spec.group);
+
     this.categories.add(category);
-    this.groupKinds
-      .getOrInsert(category.spec.group, ExtendedMap.new)
-      .strictSet(category.spec.names.kind, category);
+    strictSet(byGroup, category.spec.names.kind, category);
 
     return () => {
       this.categories.delete(category);
-      this.groupKinds.get(category.spec.group).delete(category.spec.names.kind);
+      byGroup.delete(category.spec.names.kind);
     };
   }
 

src/common/utils/collection-functions.ts

@@ -21,8 +21,8 @@ export function getOrInsert<K, V>(map: Map<K, V>, key: K, value: V): V {
 }
 
 /**
- * Like `getOrInsert` but specifically for when `V` is `Map<any, any>` so that
- * the typings are inferred.
+ * Like `getOrInsert` but specifically for when `V` is `Map<MK, MV>` so that
+ * the typings are inferred correctly.
  */
 export function getOrInsertMap<K, MK, MV>(map: Map<K, Map<MK, MV>>, key: K): Map<MK, MV> {
   return getOrInsert(map, key, new Map<MK, MV>());
@@ -37,11 +37,39 @@ export function getOrInsertSet<K, SK>(map: Map<K, Set<SK>>, key: K): Set<SK> {
 }
 
 /**
- * Like `getOrInsert` but with delayed creation of the item
+ * Like `getOrInsert` but with delayed creation of the item. Which is useful
+ * if it is very expensive to create the initial value.
  */
-export function getOrInsertWith<K, V>(map: Map<K, V>, key: K, value: () => V): V {
+export function getOrInsertWith<K, V>(map: Map<K, V>, key: K, builder: () => V): V {
   if (!map.has(key)) {
-    map.set(key, value());
+    map.set(key, builder());
+  }
+
+  return map.get(key);
+}
+
+/**
+ * Set the value associated with `key` iff there was not a previous value
+ * @param map The map to interact with
+ * @throws if `key` already in map
+ * @returns `this` so that `strictSet` can be chained
+ */
+export function strictSet<K, V>(map: Map<K, V>, key: K, val: V): typeof map {
+  if (map.has(key)) {
+    throw new TypeError("Duplicate key in map");
+  }
+
+  return map.set(key, val);
+}
+
+/**
+ * Get the value associated with `key`
+ * @param map The map to interact with
+ * @throws if `key` did not a value associated with it
+ */
+export function strictGet<K, V>(map: Map<K, V>, key: K): V {
+  if (!map.has(key)) {
+    throw new TypeError("key not in map");
   }
 
   return map.get(key);

src/common/utils/extended-map.ts

@@ -1,70 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { action, ObservableMap, runInAction } from "mobx";
-
-export function multiSet<T, V>(map: Map<T, V>, newEntries: [T, V][]): void {
-  runInAction(() => {
-    for (const [key, val] of newEntries) {
-      map.set(key, val);
-    }
-  });
-}
-
-export class ExtendedMap<K, V> extends Map<K, V> {
-  static new<K, V>(entries?: readonly (readonly [K, V])[] | null): ExtendedMap<K, V> {
-    return new ExtendedMap<K, V>(entries);
-  }
-
-  /**
-   * Get the value behind `key`. If it was not present, first insert the value returned by `getVal`
-   * @param key The key to insert into the map with
-   * @param getVal A function that returns a new instance of `V`.
-   * @returns The value in the map
-   */
-  getOrInsert(key: K, getVal: () => V): V {
-    if (this.has(key)) {
-      return this.get(key);
-    }
-
-    return this.set(key, getVal()).get(key);
-  }
-
-  /**
-   * Set the value associated with `key` iff there was not a previous value
-   * @throws if `key` already in map
-   * @returns `this` so that `strictSet` can be chained
-   */
-  strictSet(key: K, val: V): this {
-    if (this.has(key)) {
-      throw new TypeError("Duplicate key in map");
-    }
-
-    return this.set(key, val);
-  }
-
-  /**
-   * Get the value associated with `key`
-   * @throws if `key` did not a value associated with it
-   */
-  strictGet(key: K): V {
-    if (!this.has(key)) {
-      throw new TypeError("key not in map");
-    }
-
-    return this.get(key);
-  }
-}
-
-export class ExtendedObservableMap<K, V> extends ObservableMap<K, V> {
-  @action
-  getOrInsert(key: K, getVal: () => V): V {
-    if (this.has(key)) {
-      return this.get(key);
-    }
-
-    return this.set(key, getVal()).get(key);
-  }
-}

src/common/utils/index.ts

@@ -25,7 +25,6 @@ export * from "./delay";
 export * from "./disposer";
 export * from "./downloadFile";
 export * from "./escapeRegExp";
-export * from "./extended-map";
 export * from "./formatDuration";
 export * from "./getRandId";
 export * from "./hash-set";