@dxos/util 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

package/src/position.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/**
+ * Determines priority order.
+ *
+ * - `static` - Remain in natural order.
+ * - `hoist` - Placed before `static`.
+ * - `fallback` - Placed after `static`.
+ */
+export type Position = 'static' | 'hoist' | 'fallback';
+
+/**
+ * Sorting function for sorting by position.
+ */
+export const byPosition = <T extends { position?: Position }>(a: T, b: T) => {
+  const aPosition = a.position ?? 'static';
+  const bPosition = b.position ?? 'static';
+
+  if (aPosition === bPosition) {
+    return 0;
+  } else if (aPosition === 'hoist' || bPosition === 'fallback') {
+    return -1;
+  } else if (bPosition === 'hoist' || aPosition === 'fallback') {
+    return 1;
+  }
+
+  return 0;
+};

package/src/range.ts

@@ -18,3 +18,10 @@ export const rangeFromTo: {
 };
 
 type RangeMapper<T> = (n: number) => T;
+
+/**
+ * Clamps a value between a minimum and maximum value.
+ */
+export const clamp = (value: number, min: number, max: number): number => {
+  return Math.min(Math.max(value, min), max);
+};

package/src/safe-parse.ts

@@ -23,7 +23,7 @@ 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) {
+  if (data && data.length > 0) {
     try {
       return JSON.parse(data);
     } catch (err) {}

package/src/string.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/**
+ * Capitalizes the first letter of a string.
+ */
+export const capitalize = (str: string): string => {
+  if (str.length === 0) {
+    return '';
+  }
+
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};

package/src/types.test.ts

@@ -4,12 +4,12 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { nonNullable } from './types';
+import { isNonNullable } from './types';
 
 describe('types', () => {
   test('filter', async () => {
     const values = [1, 2, undefined, 3, 4];
-    const filtered: number[] = values.filter(nonNullable);
+    const filtered: number[] = values.filter(isNonNullable);
     expect(filtered).to.deep.equal([1, 2, 3, 4]);
   });
 });

package/src/types.ts

@@ -10,10 +10,34 @@ export type MaybeProvider<T, V = void> = T | ((arg: V) => T);
 
 export type MaybePromise<T> = T | Promise<T>;
 
-export type MakeOptional<Type, Key extends keyof Type> = Omit<Type, Key> & Partial<Pick<Type, Key>>;
-
 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 DeepWriteable<T> = { -readonly [K in keyof T]: T[K] extends object ? DeepWriteable<T[K]> : T[K] };
+
+/**
+ * Simplifies type (copied from effect).
+ */
+export type Simplify<A> = { [K in keyof A]: A[K] } extends infer B ? B : never;
+
+/**
+ * Replace types of specified keys.
+ */
+export type Specialize<T, U> = Simplify<Omit<T, keyof U> & U>;
+
+/**
+ * Make specified keys optional.
+ */
+// TODO(burdon): Wrapping with Simplify fails.
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
 /**
  * All types that evaluate to false when cast to a boolean.
  */
@@ -24,12 +48,8 @@ export type Falsy = false | 0 | '' | null | undefined;
  * NOTE: To filter by type:
  * items.filter((item: any): item is RangeSet<Decoration> => item instanceof RangeSet)
  */
-// TODO(burdon): Reconcile names and variants.
 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 isNotNullish = <T>(value: T | null | undefined): value is T => value !== undefined && value !== null;
-export const boolGuard = <T>(value: T | null | undefined): value is T => Boolean(value);
+export const isNonNullable = <T>(value: T | null | undefined): value is T => value != null;
 
 // TODO(burdon): Replace use of setTimeout everywhere?
 //  Would remove the need to cancel (and associated errors), but would change the operation of the code