@dxos/util 0.8.3 → 0.8.4-main.05e74ebcff

package/src/unit.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export type Unit = {
+  symbol: string;
+  quotient: number;
+  precision?: number;
+};
+
+export type UnitValue<T> = {
+  unit: Unit;
+  value: number;
+  formattedValue: T;
+  toString: () => string;
+};
+
+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,
+      toString: () => `${formattedValue}${unit.symbol}`,
+    };
+  };
+};
+
+const MS_SECONDS = 1_000;
+const MS_MINUTES = 60 * MS_SECONDS;
+const MS_HOURS = 60 * MS_MINUTES;
+
+export const Unit: Record<string, UnitFormat> = {
+  // General.
+  Percent: createFormat({ symbol: '%', quotient: 1 / 100, precision: 2 }),
+  Thousand: createFormat({ symbol: 'k', quotient: 1_000, precision: 2 }),
+
+  // Bytes (note KB vs KiB).
+  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 }),
+  Minute: createFormat({ symbol: 'm', quotient: MS_MINUTES }),
+  Second: createFormat({ symbol: 's', quotient: MS_SECONDS, precision: 1 }),
+  Millisecond: createFormat({ symbol: 'ms', quotient: 1 }),
+  Duration: (n: number) => {
+    const hours = Math.floor(n / MS_HOURS);
+    const minutes = Math.floor((n % MS_HOURS) / MS_MINUTES);
+    if (hours) {
+      const formattedValue = minutes ? `${hours}h ${minutes}m` : `${hours}h`;
+      return {
+        unit: { symbol: 'h', quotient: MS_HOURS },
+        value: hours,
+        formattedValue,
+        toString: () => formattedValue,
+      };
+    }
+
+    if (minutes) {
+      const seconds = (n - MS_MINUTES * minutes) / MS_SECONDS;
+      const formattedValue = seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
+      return {
+        unit: { symbol: 'm', quotient: MS_MINUTES },
+        value: minutes,
+        formattedValue,
+        toString: () => formattedValue,
+      };
+    }
+
+    const seconds = n >= MS_SECONDS;
+    if (seconds) {
+      return Unit.Second(n);
+    }
+
+    return Unit.Millisecond(n);
+  },
+} as const;

package/src/url.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from 'vitest';
+
+import { createUrl } from './url';
+
+describe('url', () => {
+  it('should create a url', ({ expect }) => {
+    const url = createUrl('https://example.com', {
+      i1: undefined,
+      i2: null,
+      p1: true,
+      p2: false,
+      p3: 'dxos',
+      p4: 100,
+    });
+
+    expect(url.toString()).toBe('https://example.com/?p1=true&p2=false&p3=dxos&p4=100');
+  });
+});

package/src/url.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/**
+ * Normalize construction of URLs.
+ */
+export const createUrl = (url: URL | string, search?: Record<string, any | undefined>): URL => {
+  const base = typeof url === 'string' ? new URL(url) : url;
+  if (search) {
+    base.search = new URLSearchParams(Object.entries(search).filter(([_, value]) => value != null)).toString();
+  }
+
+  return base;
+};

package/src/weak.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { test, expect, describe } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
 import { WeakDictionary } from './weak';
 

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 {