@dxos/react-ui-form 0.8.2-main.5ca3450 → 0.8.2-main.600d381

package/src/components/Form/FormContent.tsx

@@ -16,8 +16,10 @@ 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 { RefField } from './RefField';
 import { getInputComponent } from './factory';
+import { type QueryRefOptions } from '../../hooks';
+import { getRefProps } from '../../util';
 
 export type FormFieldProps = {
   property: SchemaProperty<any>;
@@ -48,6 +50,10 @@ export const FormField = ({
     [examples, description],
   );
 
+  //
+  // Registry and Custom.
+  //
+
   const FoundComponent = lookupComponent?.({
     prop: name,
     schema: Schema.make(ast),
@@ -81,10 +87,40 @@ export const FormField = ({
     );
   }
 
+  //
+  // Refs.
+  //
+
+  const refProps = getRefProps(property);
+  if (refProps) {
+    return (
+      <RefField
+        ast={refProps.ast}
+        array={refProps.isArray}
+        type={type}
+        format={format}
+        label={label}
+        placeholder={placeholder}
+        disabled={readonly}
+        inputOnly={inline}
+        onQueryRefOptions={onQueryRefOptions}
+        {...inputProps}
+      />
+    );
+  }
+
+  //
+  // Arrays.
+  //
+
   if (array) {
     return <ArrayField property={property} path={path} inputProps={inputProps} readonly={readonly} Custom={Custom} />;
   }
 
+  //
+  // Standard Inputs.
+  //
+
   const InputComponent = getInputComponent(type, format);
   if (InputComponent) {
     return (
@@ -102,6 +138,10 @@ export const FormField = ({
     );
   }
 
+  //
+  // Select.
+  //
+
   if (options) {
     return (
       <div role='none'>
@@ -119,21 +159,9 @@ export const FormField = ({
     );
   }
 
-  // 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}
-      />
-    );
-  }
+  //
+  // Nested Objects.
+  //
 
   if (type === 'object') {
     const baseNode = findNode(ast, isDiscriminatedUnion);

package/src/components/Form/FormContext.tsx

@@ -76,7 +76,9 @@ export const FormProvider = ({
       const keyIsEnter = event.key === 'Enter';
       const modifierUsed = event.ctrlKey || event.altKey || event.metaKey || event.shiftKey;
       const inputIsTextarea = (event.target as HTMLElement).tagName.toLowerCase() === 'textarea';
-      const inputOptOut = (event.target as HTMLElement).hasAttribute('data-no-submit');
+      const inputOptOut =
+        (event.target as HTMLElement).hasAttribute('data-no-submit') ||
+        (event.target as HTMLElement).closest('[data-no-submit]') !== null;
 
       // Regular inputs: Submit on Enter (no modifiers).
       const shouldSubmitRegularInput = !inputIsTextarea && keyIsEnter && !modifierUsed;

package/src/components/Form/Input.tsx

@@ -37,15 +37,9 @@ export const InputHeader = ({ children, error }: InputHeaderProps) => {
     <div role='none' className='flex justify-between items-center mb-1'>
       {children}
       {error && (
-        <Tooltip.Root>
-          <Tooltip.Trigger asChild>
-            <Icon icon='ph--warning--regular' size={4} classNames={errorText} />
-          </Tooltip.Trigger>
-          <Tooltip.Content side='bottom'>
-            <Tooltip.Arrow />
-            {error}
-          </Tooltip.Content>
-        </Tooltip.Root>
+        <Tooltip.Trigger asChild content={error} side='bottom'>
+          <Icon icon='ph--warning--regular' size={4} classNames={errorText} />
+        </Tooltip.Trigger>
       )}
     </div>
   );

package/src/components/Form/RefField.tsx

@@ -3,7 +3,7 @@
 //
 
 import { type SchemaAST } from 'effect';
-import React, { useEffect, useState } from 'react';
+import React, { useCallback, useMemo, type FocusEvent } from 'react';
 
 import {
   Expando,
@@ -11,117 +11,170 @@ import {
   Ref,
   ReferenceAnnotationId,
   type ReferenceAnnotationValue,
-  type TypeAnnotation,
 } from '@dxos/echo-schema';
-import { findAnnotation, type SimpleType } from '@dxos/effect';
+import { findAnnotation } from '@dxos/effect';
 import { DXN } from '@dxos/keys';
-import { refFromDXN } 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: SchemaAST.AST;
-  type: SimpleType;
-  label: string;
-  readonly?: boolean;
-  placeholder?: string;
-  inline?: boolean;
+import { Input } from '@dxos/react-ui';
+import { TagPicker, type TagPickerMode, type TagPickerItemData } from '@dxos/react-ui-tag-picker';
+import { isNonNullable } from '@dxos/util';
+
+import { TextInput } from './Defaults';
+import { InputHeader, type InputProps } from './Input';
+import { type QueryRefOptions, useQueryRefOptions } from '../../hooks';
+
+type RefFieldProps = InputProps & {
+  ast?: SchemaAST.AST;
+  array?: boolean;
   onQueryRefOptions?: QueryRefOptions;
-  inputProps: FormInputStateProps;
 };
 
 export const RefField = ({
-  ast,
   type,
   label,
-  readonly,
+  disabled,
   placeholder,
-  inline,
+  inputOnly,
+  array,
+  ast,
+  getValue,
+  onBlur,
   onQueryRefOptions,
-  inputProps,
+  onValueChange,
+  ...restInputProps
 }: 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 refTypeInfo = useMemo(
+    () => (ast ? findAnnotation<ReferenceAnnotationValue>(ast, ReferenceAnnotationId) : undefined),
+    [ast],
+  );
+  const { options: availableOptions, loading: _loading } = useQueryRefOptions({ refTypeInfo, onQueryRefOptions });
+
+  if ((refTypeInfo && refTypeInfo?.typename === getTypeAnnotation(Expando)?.typename) || !onQueryRefOptions) {
+    // If ref type is expando, fall back to taking a DXN in string format.
+    return (
+      <RefFieldFallback
+        {...{ type, label, placeholder, disabled, inputOnly, getValue, onBlur, onValueChange, ...restInputProps }}
+      />
+    );
+  }
+
+  const handleGetValue = useCallback((): TagPickerItemData[] => {
+    const formValue = getValue();
 
-    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);
+    const unknownToRefOption = (val: unknown) => {
+      if (Ref.isRef(val)) {
+        const dxnString = val.dxn.toString();
+        const matchingOption = availableOptions.find((option) => option.id === dxnString);
+        if (matchingOption) {
+          return matchingOption;
+        }
       }
+      return undefined;
     };
 
-    void fetchOptions();
-  }, [refTypeInfo, onQueryRefOptions]);
+    if (array && Array.isArray(formValue)) {
+      return formValue.map(unknownToRefOption).filter(isNonNullable) ?? [];
+    }
 
-  if (!refTypeInfo) {
-    return null;
-  }
+    const option = unknownToRefOption(formValue);
+    if (option) {
+      return [option];
+    }
 
-  // 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);
-      }
-    };
+    return [];
+  }, [getValue, availableOptions, array]);
 
-    const handleGetValue = () => {
-      const formValue = getValue();
-      if (typeof formValue === 'string') {
-        return formValue;
+  const handleSearch = useCallback(
+    (text: string, ids: string[]): TagPickerItemData[] =>
+      availableOptions
+        .filter((option) => !ids.includes(option.id))
+        .filter((option) => option.label.toLowerCase().includes(text.toLowerCase()))
+        .map((option) => ({ id: option.id, label: option.label, hue: option.hue as any })),
+    [availableOptions],
+  );
+
+  const handleUpdate = useCallback(
+    (ids: string[]) => {
+      if (ids.length === 0) {
+        onValueChange('object', undefined);
+        return;
       }
-      if (Ref.isRef(formValue)) {
-        return formValue.dxn.toString();
+
+      const refs = ids
+        .map((id) => {
+          const item = availableOptions.find((option) => option.id === id);
+          if (item) {
+            const dxn = DXN.parse(item.id);
+            return Ref.fromDXN(dxn);
+          }
+          return null;
+        })
+        .filter(isNonNullable);
+
+      if (array) {
+        onValueChange('object', refs);
+      } else {
+        onValueChange('object', refs[0]);
       }
+    },
+    [availableOptions, array, onValueChange],
+  );
 
-      return undefined;
-    };
+  const tagPickerMode: TagPickerMode = useMemo(() => (array ? 'multi-select' : 'single-select'), [array]);
 
-    return (
-      <TextInput
-        type={type}
-        label={label}
-        disabled={readonly}
-        placeholder={placeholder}
-        inputOnly={inline}
-        getValue={handleGetValue as <V>() => V | undefined}
-        onValueChange={handleOnValueChange}
-        {...restInputProps}
-      />
-    );
+  if (!refTypeInfo) {
+    return null;
   }
 
+  const { status, error } = restInputProps.getStatus();
+
+  return (
+    <Input.Root validationValence={status}>
+      {!inputOnly && (
+        <InputHeader error={error}>
+          <Input.Label>{label}</Input.Label>
+        </InputHeader>
+      )}
+      <div data-no-submit>
+        <TagPicker
+          items={handleGetValue()}
+          mode={tagPickerMode}
+          onBlur={(event) => onBlur(event as unknown as FocusEvent<HTMLElement>)}
+          onUpdate={handleUpdate}
+          onSearch={handleSearch}
+          classNames='rounded-sm bg-input p-1.5'
+        />
+      </div>
+      {inputOnly && <Input.DescriptionAndValidation>{error}</Input.DescriptionAndValidation>}
+    </Input.Root>
+  );
+};
+
+const RefFieldFallback = ({
+  type,
+  label,
+  disabled,
+  placeholder,
+  inputOnly,
+  getValue,
+  onValueChange,
+  ...restInputProps
+}: InputProps) => {
+  const handleOnValueChange = (_type: any, dxnString: string) => {
+    const dxn = DXN.tryParse(dxnString);
+    if (dxn) {
+      onValueChange?.('object', Ref.fromDXN(dxn));
+    } else if (dxnString === '') {
+      onValueChange?.('object', undefined);
+    } else {
+      onValueChange?.('string', dxnString);
+    }
+  };
+
   const handleGetValue = () => {
     const formValue = getValue();
-
+    if (typeof formValue === 'string') {
+      return formValue;
+    }
     if (Ref.isRef(formValue)) {
       return formValue.dxn.toString();
     }
@@ -129,23 +182,15 @@ export const RefField = ({
     return undefined;
   };
 
-  const handleValueChanged = (_type: any, dxnString: string) => {
-    const dxn = DXN.parse(dxnString);
-    const ref = refFromDXN(dxn);
-
-    onValueChange('object', ref);
-  };
-
   return (
-    <SelectInput
+    <TextInput
       type={type}
       label={label}
-      disabled={readonly || loading}
-      placeholder={loading ? 'Loading options...' : placeholder}
-      inputOnly={inline}
+      disabled={disabled}
+      placeholder={placeholder}
+      inputOnly={inputOnly}
       getValue={handleGetValue as <V>() => V | undefined}
-      onValueChange={handleValueChanged}
-      options={refOptions}
+      onValueChange={handleOnValueChange}
       {...restInputProps}
     />
   );

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

@@ -47,7 +47,7 @@ const DefaultStory = () => {
 const meta: Meta = {
   title: 'ui/react-ui-form/SelectOptionsInput',
   component: SelectOptionInput,
-  decorators: [withTheme, withLayout({ tooltips: true })],
+  decorators: [withTheme, withLayout()],
   parameters: { translations },
 };
 

package/src/components/Form/factory.tsx

@@ -12,7 +12,7 @@ import { GeoPointInput } from './custom';
 /**
  * Get property input component.
  */
-export const getInputComponent = (type: SimpleType, format?: FormatEnum): InputComponent | undefined => {
+export const getInputComponent = (type: SimpleType, format?: FormatEnum | string): InputComponent | undefined => {
   switch (format) {
     case FormatEnum.GeoPoint:
       return GeoPointInput;

package/src/components/Form/index.ts

@@ -7,4 +7,3 @@ export * from './Defaults';
 export * from './Form';
 export * from './FormContext';
 export * from './Input';
-export { type QueryRefOptions } from './RefField';

package/src/components/ViewEditor/ViewEditor.stories.tsx

@@ -82,7 +82,7 @@ const meta: Meta<typeof ViewEditor> = {
   title: 'ui/react-ui-form/ViewEditor',
   component: ViewEditor,
   render: DefaultStory,
-  decorators: [withClientProvider({ createSpace: true }), withLayout({ fullscreen: true, tooltips: true }), withTheme],
+  decorators: [withClientProvider({ createSpace: true }), withLayout({ fullscreen: true }), withTheme],
   parameters: {
     translations,
   },

package/src/hooks/index.ts

@@ -1,6 +1,7 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
 export * from './useForm';
 export * from './useRefQueryLookupHandler';
+export * from './useQueryRefOptions';

package/src/hooks/useQueryRefOptions.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { type TypeAnnotation } from '@dxos/echo-schema';
+import { type DXN } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type TagPickerItemData } from '@dxos/react-ui-tag-picker';
+import { type MaybePromise } from '@dxos/util';
+
+export type RefOption = { dxn: DXN; label?: string };
+export type QueryRefOptions = (type: TypeAnnotation) => MaybePromise<RefOption[]>;
+
+type UseQueryRefOptionsProps = { refTypeInfo: TypeAnnotation | undefined; onQueryRefOptions?: QueryRefOptions };
+
+/**
+ * Hook to query reference options based on type information.
+ * Used internally within forms to fetch and format reference options for reference fields.
+ */
+export const useQueryRefOptions = ({ refTypeInfo, onQueryRefOptions }: UseQueryRefOptionsProps) => {
+  const [options, setOptions] = useState<TagPickerItemData[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!refTypeInfo || !onQueryRefOptions) {
+      return;
+    }
+
+    const fetchOptions = async () => {
+      setLoading(true);
+      try {
+        const fetchedOptions = await onQueryRefOptions(refTypeInfo);
+        setOptions(
+          fetchedOptions.map((option) => {
+            const dxn = option.dxn.toString() as string;
+            return { id: dxn, label: option.label ?? dxn, hue: 'neutral' as any };
+          }),
+        );
+      } catch (error) {
+        log.error('Failed to fetch ref options:', error);
+        setOptions([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    void fetchOptions();
+  }, [refTypeInfo, onQueryRefOptions]);
+
+  return { options, loading };
+};

package/src/hooks/useRefQueryLookupHandler.ts

@@ -8,11 +8,9 @@ import { getDXN, type TypeAnnotation } from '@dxos/echo-schema';
 import { Filter, type Space } from '@dxos/react-client/echo';
 import { isNonNullable } from '@dxos/util';
 
-import { type QueryRefOptions } from '../components';
+import { type QueryRefOptions } from './useQueryRefOptions';
 
-type UseRefQueryLookupProps = {
-  space?: Space;
-};
+type UseRefQueryLookupProps = { space?: Space };
 
 export const useRefQueryLookupHandler = ({ space }: UseRefQueryLookupProps): QueryRefOptions => {
   const handleRefQueryLookup = useCallback(

package/src/util/index.ts

@@ -1,6 +1,8 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
 export * from './field';
 export * from './formatting';
+export * from './refs';
+export * from './schema';

package/src/util/refs.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type SchemaAST } from 'effect';
+
+import { FormatEnum, ReferenceAnnotationId } from '@dxos/echo-schema';
+import { findAnnotation } from '@dxos/effect';
+import { type SchemaProperty } from '@dxos/schema';
+
+import { findArrayElementType } from './schema';
+
+type RefProps = {
+  ast: SchemaAST.AST;
+  isArray: boolean;
+};
+
+export const getRefProps = (property: SchemaProperty<any>): RefProps | undefined => {
+  const { ast, format, array } = property;
+
+  // Direct reference.
+  if (format === FormatEnum.Ref) {
+    return { ast, isArray: false };
+  }
+
+  // Array of references.
+  if (array) {
+    const elementType = findArrayElementType(ast);
+    if (elementType) {
+      const annotation = findAnnotation(elementType, ReferenceAnnotationId);
+      if (annotation) {
+        return { ast: elementType, isArray: true };
+      }
+    }
+  }
+
+  return undefined;
+};

package/src/util/schema.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SchemaAST } from 'effect';
+
+import { findNode } from '@dxos/effect';
+
+export const findArrayElementType = (ast: SchemaAST.AST) => {
+  const tupleType = findNode(ast, SchemaAST.isTupleType);
+  const elementType = (tupleType as SchemaAST.TupleType | undefined)?.rest[0]?.type;
+
+  return elementType;
+};