@dxos/util 0.3.11-main.fbbdc2a → 0.3.11-main.fc97a54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/util",
-  "version": "0.3.11-main.fbbdc2a",
+  "version": "0.3.11-main.fc97a54",
   "description": "Temporary bucket for misc functions, which should graduate into separate packages.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,13 +16,13 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/debug": "0.3.11-main.fbbdc2a",
-    "@dxos/invariant": "0.3.11-main.fbbdc2a",
-    "@dxos/keys": "0.3.11-main.fbbdc2a",
-    "@dxos/node-std": "0.3.11-main.fbbdc2a"
+    "@dxos/debug": "0.3.11-main.fc97a54",
+    "@dxos/keys": "0.3.11-main.fc97a54",
+    "@dxos/invariant": "0.3.11-main.fc97a54",
+    "@dxos/node-std": "0.3.11-main.fc97a54"
   },
   "devDependencies": {
-    "@dxos/crypto": "0.3.11-main.fbbdc2a"
+    "@dxos/crypto": "0.3.11-main.fc97a54"
   },
   "publishConfig": {
     "access": "public"

package/src/defer.test.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { describe, test } from '@dxos/test';
+
+import { defer, deferAsync } from './defer';
+
+describe('defer', () => {
+  test('defer', () => {
+    const events: string[] = [];
+
+    {
+      using _ = defer(() => events.push('1'));
+      events.push('2');
+    }
+
+    expect(events).to.deep.eq(['2', '1']);
+  });
+
+  test('deferAsync', async () => {
+    const events: string[] = [];
+
+    {
+      await using _ = deferAsync(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        events.push('1');
+      });
+      events.push('2');
+    }
+    events.push('3');
+
+    expect(events).to.deep.eq(['2', '1', '3']);
+  });
+});

package/src/defer.ts

@@ -0,0 +1,54 @@
+/**
+ * Run function on scope exit.
+ *
+ * @example
+ * ```ts
+ * {
+ *   using _ = defer(() => console.log('exiting'));
+ *
+ *   ...
+ * }
+ */
+//
+// Copyright 2024 DXOS.org
+//
+
+export const defer = (fn: () => void): Disposable => new DeferGuard(fn);
+
+class DeferGuard {
+  /**
+   * @internal
+   */
+  constructor(private readonly _fn: () => void) {}
+
+  [Symbol.dispose]() {
+    const result = this._fn();
+    if ((result as any) instanceof Promise) {
+      throw new Error('Async functions in defer are not supported. Use deferAsync instead.');
+    }
+  }
+}
+
+/**
+ * Run async function on scope exit.
+ *
+ * @example
+ * ```ts
+ * {
+ *   await using _ = deferAsync(async () => console.log('exiting'));
+ *
+ *   ...
+ * }
+ */
+export const deferAsync = (fn: () => Promise<void>): AsyncDisposable => new DeferAsyncGuard(fn);
+
+class DeferAsyncGuard implements AsyncDisposable {
+  /**
+   * @internal
+   */
+  constructor(private readonly _fn: () => Promise<void>) {}
+
+  async [Symbol.asyncDispose]() {
+    await this._fn();
+  }
+}

package/src/index.ts

@@ -18,6 +18,7 @@ export * from './random';
 export * from './range';
 export * from './reducers';
 export * from './safe-instanceof';
+export * from './safe-parse-json';
 export * from './sort';
 export * from './tracer';
 export * from './types';
@@ -26,3 +27,5 @@ export * from './instance-id';
 export * from './sum';
 export * from './for-each-async';
 export * from './weak';
+export * from './map-values';
+export * from './defer';

package/src/map-values.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const mapValues = <T, U>(obj: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U> => {
+  const result: Record<string, U> = {};
+  Object.keys(obj).forEach((key) => {
+    result[key] = fn(obj[key], key);
+  });
+  return result;
+};

package/src/platform.ts

@@ -28,3 +28,29 @@ export const iosCheck = () => {
 // From https://stackoverflow.com/a/23522755/2804332
 export const safariCheck = () =>
   typeof navigator !== 'undefined' && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+/**
+ * Retrieve the host platform in a best-effort way with normalized output.
+ */
+// From https://flaming.codes/posts/how-to-determine-os-in-browser.
+export const getHostPlatform = () => {
+  if (!('navigator' in window)) {
+    return 'unknown';
+  }
+
+  // Use the modern 'web hints' provied by
+  // 'userAgentData' if available, else use
+  // the deprecated 'platform' as fallback.
+  const platform = ((navigator as any).userAgentData?.platform || navigator.platform)?.toLowerCase();
+  if (platform.startsWith('win')) {
+    return 'windows';
+  } else if (platform.startsWith('mac')) {
+    return 'macos';
+  } else if (platform.startsWith('ipad') || platform.startsWith('iphone') || platform.startsWith('ipod')) {
+    return 'ios';
+  } else if (platform.startsWith('linux')) {
+    return 'linux';
+  } else {
+    return 'unknown';
+  }
+};

package/src/safe-parse-json.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const safeParseJson: {
+  <T extends object>(data: string | undefined | null, defaultValue: T): T;
+  <T extends object>(data: string | undefined | null): T | undefined;
+} = <T extends object>(data: string | undefined | null, defaultValue?: T) => {
+  if (data) {
+    try {
+      return JSON.parse(data);
+    } catch (err) {}
+  }
+  return defaultValue;
+};

package/src/types.ts

@@ -2,23 +2,12 @@
 // Copyright 2020 DXOS.org
 //
 
-export const boolGuard = <T>(value: T | null | undefined): value is T => Boolean(value);
-
 export type AsyncCallback<T> = (param: T) => Promise<void>;
 
 export type Provider<T> = () => T;
 
 export type MaybePromise<T> = T | Promise<T>;
 
-export const isNotNullOrUndefined = <T>(x: T): x is Exclude<T, null | undefined> => x != null;
-
-/**
- * Use with filter chaining instead of filter(Boolean) to preserve type.
- * NOTE: To filter by type:
- * items.filter((item: any): item is RangeSet<Decoration> => item instanceof RangeSet)
- */
-export const nonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined;
-
 /**
  * All types that evaluate to false when cast to a boolean.
  */
@@ -29,6 +18,17 @@ export type Falsy = false | 0 | '' | null | undefined;
  */
 export type MaybeFunction<T> = T | (() => T);
 
+/**
+ * Use with filter chaining instead of filter(Boolean) to preserve type.
+ * NOTE: To filter by type:
+ * items.filter((item: any): item is RangeSet<Decoration> => item instanceof RangeSet)
+ */
+// TODO(burdon): Reconcile names.
+export const isNotFalsy = <T>(value: T): value is Exclude<T, Falsy> => !!value;
+export const nonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined;
+export const isNotNullOrUndefined = <T>(value: T): value is Exclude<T, null | undefined> => value != null;
+export const boolGuard = <T>(value: T | null | undefined): value is T => Boolean(value);
+
 /**
  * Get value from a provider.
  */