@dxos/util 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/uint8array.ts

@@ -35,3 +35,47 @@ export const bufferToArray = (buffer: Buffer): Uint8Array => {
 export const stringToArray = (string: string): Uint8Array => bufferToArray(Buffer.from(string, 'hex'));
 
 export const arrayToString = (array: Uint8Array): string => arrayToBuffer(array).toString('hex');
+
+/**
+ * JSON-safe representation of a `Uint8Array`, per the IPLD DAG-JSON spec.
+ * https://ipld.io/specs/codecs/dag-json/spec/#bytes
+ *
+ * Bytes are encoded as `{ "/": { "bytes": "<base64-no-padding>" } }`.
+ * Distinguishable from encoded references `{ "/": "<string>" }` by the type of the `/` value.
+ */
+export type EncodedUint8Array = { '/': { bytes: string } };
+
+const toUnpaddedBase64 = (bytes: Uint8Array): string => arrayToBuffer(bytes).toString('base64').replace(/=+$/, '');
+
+/**
+ * Encode a `Uint8Array` as the DAG-JSON bytes form `{ '/': { bytes: '<base64-no-padding>' } }`.
+ */
+export const encodeUint8ArrayToJson = (bytes: Uint8Array): EncodedUint8Array => ({
+  '/': { bytes: toUnpaddedBase64(bytes) },
+});
+
+/**
+ * Type-guard that returns true iff `value` is the DAG-JSON bytes form produced by
+ * {@link encodeUint8ArrayToJson} — an object with exactly one key `'/'` whose value is an
+ * object with exactly one string key `bytes`.
+ */
+export const isEncodedUint8Array = (value: unknown): value is EncodedUint8Array => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return false;
+  }
+  if (Object.keys(value).length !== 1) {
+    return false;
+  }
+  const inner = (value as any)['/'];
+  if (typeof inner !== 'object' || inner === null || Array.isArray(inner)) {
+    return false;
+  }
+  return Object.keys(inner).length === 1 && typeof inner.bytes === 'string';
+};
+
+/**
+ * Decode a DAG-JSON bytes form (as produced by {@link encodeUint8ArrayToJson}) back to a
+ * `Uint8Array`. The base64 string is tolerated with or without padding.
+ */
+export const decodeUint8ArrayFromJson = (encoded: EncodedUint8Array): Uint8Array =>
+  bufferToArray(Buffer.from(encoded['/'].bytes, 'base64'));

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}`,
     };
   };
 };

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 {