@dxos/util 0.8.4-main.72ec0f3 → 0.8.4-main.765dc60934

package/src/types.ts

@@ -10,15 +10,33 @@ export type MaybeProvider<T, V = void> = T | ((arg: V) => T);
 
 export type MaybePromise<T> = T | Promise<T>;
 
-export type GuardedType<T> = T extends (value: any) => value is infer R ? R : never;
-
-export type DeepReadonly<T> = {
-  readonly [P in keyof T]: T[P] extends Record<string, any>
-    ? DeepReadonly<T[P]>
-    : T[P] extends Array<infer U>
-      ? ReadonlyArray<DeepReadonly<U>>
-      : T[P];
-};
+export type GuardedType<T> = T extends ((value: any) => value is infer R) ? R : never;
+
+/**
+ * Removes readonly modifiers from top-level properties of T.
+ * Also converts readonly arrays at the top level to mutable arrays.
+ * For nested properties, mutability depends on the schema definition.
+ */
+export type ToMutable<T> = T extends object
+  ? { -readonly [K in keyof T]: T[K] extends readonly (infer U)[] ? U[] : T[K] }
+  : T;
+
+export type Intersection<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]
+  ? First & Intersection<Rest>
+  : unknown;
+
+/**
+ * Recursively makes all properties of T readonly.
+ * Primitives (including branded types like `string & { __brand: true }`) are returned as-is.
+ * Arrays become ReadonlyArrays with deeply readonly elements.
+ */
+export type DeepReadonly<T> = T extends string | number | boolean | bigint | symbol | null | undefined
+  ? T // Primitives (including branded primitives) stay as-is.
+  : T extends Array<infer U>
+    ? ReadonlyArray<DeepReadonly<U>>
+    : T extends object
+      ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
+      : T;
 
 export type DeepWriteable<T> = { -readonly [K in keyof T]: T[K] extends object ? DeepWriteable<T[K]> : T[K] };
 
@@ -104,9 +122,19 @@ export const sortKeys = <T extends object>(obj: T): T =>
     }, {} as T);
 
 /**
- * Swap position of element within array.
+ * Move element within array.
  */
-export const arrayMove = <T>(array: T[], from: number, to: number): Array<T> => {
+export const arrayMove = <T>(array: T[], from: number, to: number): T[] => {
   array.splice(to < 0 ? array.length + to : to, 0, array.splice(from, 1)[0]);
   return array;
 };
+
+/**
+ * Swap position of element within array.
+ */
+export function arraySwap<T>(array: T[], from: number, to: number): T[] {
+  const current = array[from];
+  array[from] = array[to];
+  array[to] = current;
+  return array;
+}

package/src/unit.ts

@@ -20,11 +20,15 @@ export type UnitFormat<T = any> = (n: number, precision?: number) => UnitValue<T
 const createFormat = (unit: Unit): UnitFormat<string> => {
   return (n: number, precision = unit.precision ?? 0) => {
     const value = n / unit.quotient;
+    const formattedValue = value.toLocaleString('en-US', {
+      minimumFractionDigits: precision,
+      maximumFractionDigits: precision,
+    });
     return {
       unit,
       value,
-      formattedValue: value.toFixed(precision),
-      toString: () => `${value.toFixed(precision)}${unit.symbol}`,
+      formattedValue,
+      toString: () => `${formattedValue}${unit.symbol}`,
     };
   };
 };
@@ -42,6 +46,7 @@ export const Unit: Record<string, UnitFormat> = {
   Gigabyte: createFormat({ symbol: 'GB', quotient: 1_000 * 1_000 * 1_000, precision: 2 }),
   Megabyte: createFormat({ symbol: 'MB', quotient: 1_000 * 1_000, precision: 2 }),
   Kilobyte: createFormat({ symbol: 'KB', quotient: 1_000, precision: 2 }),
+  Byte: createFormat({ symbol: 'B', quotient: 1 }),
 
   // Time.
   Hour: createFormat({ symbol: 'h', quotient: MS_HOURS }),

package/src/weak.ts

@@ -7,13 +7,20 @@
  */
 export class WeakDictionary<K, V extends object> implements Map<K, V> {
   private readonly _internal = new Map<K, WeakRef<V>>();
-  private readonly _finalization = new FinalizationRegistry((cleanUpCallback: () => void) => {
-    cleanUpCallback();
+  private readonly _finalization = new FinalizationRegistry<{ key: K; ref: WeakRef<V> }>(({ key, ref }) => {
+    if (this._internal.get(key) === ref) {
+      this._internal.delete(key);
+    }
   });
 
   constructor(entries?: [K, V][]) {
-    this._internal = new Map(entries?.map(([key, value]) => [key, new WeakRef(value)]));
-    entries?.forEach(([key, value]) => this._register(key, value));
+    if (entries) {
+      for (const [key, value] of entries) {
+        const ref = new WeakRef(value);
+        this._internal.set(key, ref);
+        this._register(key, value, ref);
+      }
+    }
   }
 
   *entries(): SetIterator<[K, V]> {
@@ -55,11 +62,48 @@ export class WeakDictionary<K, V extends object> implements Map<K, V> {
   }
 
   set(key: K, value: V): this {
-    this._internal.set(key, new WeakRef(value));
-    this._register(key, value);
+    const previous = this._internal.get(key)?.deref();
+    if (previous) {
+      this._unregister(previous);
+    }
+    const ref = new WeakRef(value);
+    this._internal.set(key, ref);
+    this._register(key, value, ref);
     return this;
   }
 
+  /**
+   * Returns the value for the given key if present, otherwise inserts and returns the default value.
+   * @param key - The key to look up or insert.
+   * @param defaultValue - The value to insert if the key is not present.
+   * @returns The existing or newly inserted value.
+   */
+  getOrInsert(key: K, defaultValue: V): V {
+    const existing = this.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+    this.set(key, defaultValue);
+    return defaultValue;
+  }
+
+  /**
+   * Returns the value for the given key if present, otherwise computes, inserts, and returns a new value.
+   * The callback is only invoked when the key is missing.
+   * @param key - The key to look up or insert.
+   * @param callbackfn - Function to compute the value if the key is not present.
+   * @returns The existing or newly computed value.
+   */
+  getOrInsertComputed(key: K, callbackfn: (key: K) => V): V {
+    const existing = this.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const value = callbackfn(key);
+    this.set(key, value);
+    return value;
+  }
+
   has(key: K): boolean {
     return this._internal.has(key) && this._internal.get(key)!.deref() !== undefined;
   }
@@ -96,14 +140,8 @@ export class WeakDictionary<K, V extends object> implements Map<K, V> {
     });
   }
 
-  private _register(key: K, value: V): void {
-    this._finalization.register(
-      value,
-      () => {
-        this._internal.delete(key);
-      },
-      value,
-    );
+  private _register(key: K, value: V, ref: WeakRef<V>): void {
+    this._finalization.register(value, { key, ref }, value);
   }
 
   private _unregister(value: V): void {

package/dist/types/src/explicit-resource-management-polyfill.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=explicit-resource-management-polyfill.d.ts.map

package/dist/types/src/explicit-resource-management-polyfill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"explicit-resource-management-polyfill.d.ts","sourceRoot":"","sources":["../../../src/explicit-resource-management-polyfill.ts"],"names":[],"mappings":""}

package/src/explicit-resource-management-polyfill.ts

@@ -1,13 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-Symbol.dispose ??= Symbol('Symbol.dispose');
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');