@dxos/react-ui-form 0.8.2-main.f081794 → 0.8.2-main.f11618f

package/src/components/Form/FormContent.tsx

@@ -1,5 +1,5 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
 import { pipe } from 'effect';
@@ -17,29 +17,29 @@ import { SelectInput } from './Defaults';
 import { type ComponentLookup } from './Form';
 import { useInputProps, useFormValues } from './FormContext';
 import { type InputComponent } from './Input';
+import { RefField, type QueryRefOptions } from './RefField';
 import { getInputComponent } from './factory';
 
-export type FormContentProps = {
-  schema: S.Schema.All;
-  path?: (string | number)[];
-  filter?: (props: SchemaProperty<any>[]) => SchemaProperty<any>[];
-  sort?: string[];
-  readonly?: boolean;
-  lookupComponent?: ComponentLookup;
-  Custom?: Partial<Record<string, InputComponent>>;
-};
-
 export type FormFieldProps = {
   property: SchemaProperty<any>;
   path?: (string | number)[];
   readonly?: boolean;
   /** Used to indicate if input should be presented inline (e.g. for array items). */
   inline?: boolean;
+  onQueryRefOptions?: QueryRefOptions;
   lookupComponent?: ComponentLookup;
   Custom?: Partial<Record<string, InputComponent>>;
 };
 
-export const FormField = ({ property, path, readonly, inline, lookupComponent, Custom }: FormFieldProps) => {
+export const FormField = ({
+  property,
+  path,
+  readonly,
+  inline,
+  onQueryRefOptions,
+  lookupComponent,
+  Custom,
+}: FormFieldProps) => {
   const inputProps = useInputProps(path);
   const { ast, name, type, format, title, description, options, examples, array } = property;
 
@@ -120,6 +120,22 @@ export const FormField = ({ property, path, readonly, inline, lookupComponent, C
     );
   }
 
+  // TODO(ZaymonFC): Extract this to it's own component.
+  if (format === 'ref') {
+    return (
+      <RefField
+        ast={ast}
+        type={type}
+        label={label}
+        readonly={readonly}
+        placeholder={placeholder}
+        inline={inline}
+        onQueryRefOptions={onQueryRefOptions}
+        inputProps={inputProps}
+      />
+    );
+  }
+
   if (type === 'object') {
     const baseNode = findNode(ast, isDiscriminatedUnion);
     const typeLiteral = baseNode
@@ -129,8 +145,15 @@ export const FormField = ({ property, path, readonly, inline, lookupComponent, C
     if (typeLiteral) {
       return (
         <div role='none'>
-          {!inline && <div>{label}</div>}
-          <FormFields schema={S.make(typeLiteral)} path={path} readonly={readonly} Custom={Custom} />
+          {!inline && <h3 className='text-lg mbs-2 mbe-1'>{label}</h3>}
+          <FormFields
+            schema={S.make(typeLiteral)}
+            path={path}
+            readonly={readonly}
+            onQueryRefOptions={onQueryRefOptions}
+            Custom={Custom}
+            lookupComponent={lookupComponent}
+          />
         </div>
       );
     }
@@ -139,7 +162,27 @@ export const FormField = ({ property, path, readonly, inline, lookupComponent, C
   return null;
 };
 
-export const FormFields = ({ schema, path, filter, sort, readonly, lookupComponent, Custom }: FormContentProps) => {
+export type FormContentProps = {
+  schema: S.Schema.All;
+  path?: (string | number)[];
+  filter?: (props: SchemaProperty<any>[]) => SchemaProperty<any>[];
+  sort?: string[];
+  readonly?: boolean;
+  onQueryRefOptions?: QueryRefOptions;
+  lookupComponent?: ComponentLookup;
+  Custom?: Partial<Record<string, InputComponent>>;
+};
+
+export const FormFields = ({
+  schema,
+  path,
+  filter,
+  sort,
+  readonly,
+  onQueryRefOptions,
+  lookupComponent,
+  Custom,
+}: FormContentProps) => {
   const values = useFormValues(path);
 
   const properties = useMemo(() => {
@@ -159,6 +202,7 @@ export const FormFields = ({ schema, path, filter, sort, readonly, lookupCompone
               property={property}
               path={[...(path ?? []), property.name]}
               readonly={readonly}
+              onQueryRefOptions={onQueryRefOptions}
               lookupComponent={lookupComponent}
               Custom={Custom}
             />

package/src/components/Form/FormContext.tsx

@@ -2,7 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { createContext, useContext, useEffect, useMemo, type FocusEvent, type PropsWithChildren } from 'react';
+import React, {
+  createContext,
+  type RefObject,
+  useContext,
+  useEffect,
+  useMemo,
+  type FocusEvent,
+  type PropsWithChildren,
+} from 'react';
 
 import { raise } from '@dxos/debug';
 import { type BaseObject, getValue } from '@dxos/echo-schema';
@@ -53,7 +61,7 @@ export const FormProvider = ({
   ...formOptions
 }: PropsWithChildren<
   FormOptions<any> & {
-    formRef?: React.RefObject<HTMLDivElement>;
+    formRef?: RefObject<HTMLDivElement>;
     autoSave?: boolean;
   }
 >) => {

package/src/components/Form/RefField.tsx

@@ -0,0 +1,151 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useEffect, useState } from 'react';
+
+import {
+  type AST,
+  Expando,
+  getTypeAnnotation,
+  ReferenceAnnotationId,
+  type ReferenceAnnotationValue,
+  type TypeAnnotation,
+} from '@dxos/echo-schema';
+import { findAnnotation, type SimpleType } from '@dxos/effect';
+import { DXN } from '@dxos/keys';
+import { refFromDXN, RefImpl } from '@dxos/live-object';
+import { log } from '@dxos/log';
+import { type MaybePromise } from '@dxos/util';
+
+import { SelectInput, TextInput } from './Defaults';
+import { type FormInputStateProps } from './FormContext';
+
+export type QueryRefOptions = (type: TypeAnnotation) => MaybePromise<{ dxn: DXN; label?: string }[]>;
+
+type RefFieldProps = {
+  ast: AST.AST;
+  type: SimpleType;
+  label: string;
+  readonly?: boolean;
+  placeholder?: string;
+  inline?: boolean;
+  onQueryRefOptions?: QueryRefOptions;
+  inputProps: FormInputStateProps;
+};
+
+export const RefField = ({
+  ast,
+  type,
+  label,
+  readonly,
+  placeholder,
+  inline,
+  onQueryRefOptions,
+  inputProps,
+}: RefFieldProps) => {
+  const { getValue, onValueChange, ...restInputProps } = inputProps;
+  const refTypeInfo = findAnnotation<ReferenceAnnotationValue>(ast, ReferenceAnnotationId);
+  const [refOptions, setRefOptions] = useState<Array<{ value: string; label?: string }>>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!refTypeInfo || !onQueryRefOptions) {
+      return;
+    }
+
+    const fetchOptions = async () => {
+      setLoading(true);
+      try {
+        const options = await onQueryRefOptions(refTypeInfo);
+        setRefOptions(
+          options.map((option) => ({
+            label: option.label,
+            value: option.dxn.toString(),
+          })),
+        );
+      } catch (error) {
+        log.error('Failed to fetch ref options:', error);
+        setRefOptions([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    void fetchOptions();
+  }, [refTypeInfo, onQueryRefOptions]);
+
+  if (!refTypeInfo) {
+    return null;
+  }
+
+  // If ref type is expando, fall back to taking a DXN in string format.
+  if (refTypeInfo.typename === getTypeAnnotation(Expando)?.typename || !onQueryRefOptions) {
+    const handleOnValueChange = (_type: any, dxnString: string) => {
+      const dxn = DXN.tryParse(dxnString);
+      if (dxn) {
+        onValueChange?.('object', refFromDXN(dxn));
+      } else if (dxnString === '') {
+        onValueChange?.('object', undefined);
+      } else {
+        onValueChange?.('string', dxnString);
+      }
+    };
+
+    const handleGetValue = () => {
+      const formValue = getValue();
+      if (typeof formValue === 'string') {
+        return formValue;
+      }
+      if (formValue instanceof RefImpl) {
+        return formValue.dxn.toString();
+      }
+
+      return undefined;
+    };
+
+    return (
+      <TextInput
+        type={type}
+        label={label}
+        disabled={readonly}
+        placeholder={placeholder}
+        inputOnly={inline}
+        getValue={handleGetValue as <V>() => V | undefined}
+        onValueChange={handleOnValueChange}
+        {...restInputProps}
+      />
+    );
+  }
+
+  const handleGetValue = () => {
+    const formValue = getValue();
+
+    if (formValue instanceof RefImpl) {
+      return formValue.dxn.toString();
+    }
+
+    return undefined;
+  };
+
+  const handleValueChanged = (_type: any, dxnString: string) => {
+    const dxn = DXN.parse(dxnString);
+    const ref = refFromDXN(dxn);
+
+    onValueChange('object', ref);
+  };
+
+  return (
+    <SelectInput
+      type={type}
+      label={label}
+      disabled={readonly || loading}
+      placeholder={loading ? 'Loading options...' : placeholder}
+      inputOnly={inline}
+      getValue={handleGetValue as <V>() => V | undefined}
+      onValueChange={handleValueChanged}
+      options={refOptions}
+      {...restInputProps}
+    />
+  );
+};

package/src/components/Form/custom/GeoPointInput.tsx

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import React, { useCallback, useState, useEffect, useMemo } from 'react';
+import React, { useCallback, useState, useEffect, useMemo, type ChangeEvent } from 'react';
 
 import { type GeoPoint, GeoLocation } from '@dxos/echo-schema';
 import { Input, useTranslation } from '@dxos/react-ui';
@@ -28,7 +28,7 @@ export const GeoPointInput = ({ type, label, disabled, getStatus, getValue, onVa
 
   const handleCoordinateChange = useCallback(
     (coordinateType: keyof Pick<GeoLocation, 'longitude' | 'latitude'>, setText: (text: string) => void) =>
-      (event: React.ChangeEvent<HTMLInputElement>) => {
+      (event: ChangeEvent<HTMLInputElement>) => {
         const inputText = event.target.value;
         setText(inputText);
         if (inputText !== '' && inputText !== '-') {

package/src/components/Form/custom/SelectOptionsInput.tsx

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback, useEffect, useState, type ChangeEvent, useRef } from 'react';
+import React, { type ChangeEvent, type KeyboardEvent, useCallback, useEffect, useState, useRef } from 'react';
 
 import { type SelectOption } from '@dxos/echo-schema';
 import { PublicKey } from '@dxos/keys';
@@ -89,7 +89,7 @@ export const SelectOptionInput = ({ type, label, disabled, getStatus, getValue,
     [options, type, onValueChange],
   );
 
-  const handleKeyDown = useCallback((e: React.KeyboardEvent<HTMLInputElement>) => {
+  const handleKeyDown = useCallback((e: KeyboardEvent<HTMLInputElement>) => {
     if (e.key === 'Enter') {
       setSelectedId(null);
     }

package/src/util/formatting.ts

@@ -64,13 +64,25 @@ export const formatForDisplay = ({ type, format, value, locale = undefined }: Va
       });
     }
     case FormatEnum.Date: {
-      return formatDate(new Date(value as number), 'yyyy-MM-dd');
+      try {
+        return formatDate(new Date(value as number), 'yyyy-MM-dd');
+      } catch (error) {
+        return 'Invalid Date';
+      }
     }
     case FormatEnum.Time: {
-      return formatDate(new Date(value as number), 'HH:mm:ss');
+      try {
+        return formatDate(new Date(value as number), 'HH:mm:ss');
+      } catch (error) {
+        return 'Invalid Time';
+      }
     }
     case FormatEnum.DateTime: {
-      return formatDate(new Date(value as number), 'yyyy-MM-dd HH:mm:ss');
+      try {
+        return formatDate(new Date(value as number), 'yyyy-MM-dd HH:mm:ss');
+      } catch (error) {
+        return 'Invalid DateTime';
+      }
     }
     case FormatEnum.GeoPoint: {
       if (value === null || value === undefined) {