@dxos/react-ui-form 0.7.5-labs.e27f9b9 → 0.7.5-main.2567c87

package/src/components/FieldEditor/FieldEditor.tsx

@@ -20,7 +20,7 @@ import {
 } from '@dxos/schema';
 
 import { translationKey } from '../../translations';
-import { Form, type FormProps, type InputComponent, SelectInput, SelectOptionInput } from '../Form';
+import { Form, type FormProps, type InputComponent, SelectInput } from '../Form';
 
 export type FieldEditorProps = {
   view: ViewType;
@@ -95,7 +95,7 @@ export const FieldEditor = ({ view, projection, field, registry, onSave, onCance
           return { ...props, ..._props, type };
         }
 
-        return _props as PropertyType;
+        return props;
       });
     },
     [schemas, props.format, props.referenceSchema],
@@ -129,10 +129,10 @@ export const FieldEditor = ({ view, projection, field, registry, onSave, onCance
     onSave();
   }, [onSave]);
 
-  const Custom: Partial<Record<string, InputComponent>> = useMemo(
+  const Custom: Partial<Record<string, InputComponent<PropertyType>>> = useMemo(
     () => ({
       ['format' satisfies keyof PropertyType]: (props) => (
-        <SelectInput
+        <SelectInput<PropertyType>
           {...props}
           options={FormatEnums.filter((value) => value !== FormatEnum.None).map((value) => ({
             value,
@@ -141,7 +141,7 @@ export const FieldEditor = ({ view, projection, field, registry, onSave, onCance
         />
       ),
       ['referenceSchema' satisfies keyof PropertyType]: (props) => (
-        <SelectInput
+        <SelectInput<PropertyType>
           {...props}
           options={schemas.map((schema) => ({
             value: schema.typename,
@@ -149,7 +149,7 @@ export const FieldEditor = ({ view, projection, field, registry, onSave, onCance
         />
       ),
       ['referencePath' satisfies keyof PropertyType]: (props) => (
-        <SelectInput
+        <SelectInput<PropertyType>
           {...props}
           options={
             referenceSchema
@@ -160,7 +160,6 @@ export const FieldEditor = ({ view, projection, field, registry, onSave, onCance
           }
         />
       ),
-      ['options' satisfies keyof PropertyType]: (props) => <SelectOptionInput {...props} />,
     }),
     [t, schemas, referenceSchema],
   );

package/src/components/Form/Defaults.tsx

@@ -4,11 +4,13 @@
 
 import React from 'react';
 
+import { type BaseObject } from '@dxos/echo-schema';
 import { Input, Select } from '@dxos/react-ui';
 
 import { type InputProps, InputHeader } from './Input';
 
-export const TextInput = ({
+export const TextInput = <T extends BaseObject>({
+  property,
   type,
   label,
   inputOnly,
@@ -18,8 +20,8 @@ export const TextInput = ({
   getValue,
   onValueChange,
   onBlur,
-}: InputProps) => {
-  const { status, error } = getStatus();
+}: InputProps<T>) => {
+  const { status, error } = getStatus?.(property);
 
   return (
     <Input.Root validationValence={status}>
@@ -31,8 +33,8 @@ export const TextInput = ({
       <Input.TextInput
         disabled={disabled}
         placeholder={placeholder}
-        value={getValue() ?? ''}
-        onChange={(event) => onValueChange(type, event.target.value)}
+        value={getValue(property) ?? ''}
+        onChange={(event) => onValueChange(property, type, event.target.value)}
         onBlur={onBlur}
       />
       {inputOnly && <Input.Validation>{error}</Input.Validation>}
@@ -40,7 +42,8 @@ export const TextInput = ({
   );
 };
 
-export const NumberInput = ({
+export const NumberInput = <T extends BaseObject>({
+  property,
   type,
   label,
   inputOnly,
@@ -50,8 +53,8 @@ export const NumberInput = ({
   getValue,
   onValueChange,
   onBlur,
-}: InputProps) => {
-  const { status, error } = getStatus();
+}: InputProps<T>) => {
+  const { status, error } = getStatus?.(property);
 
   return (
     <Input.Root validationValence={status}>
@@ -64,8 +67,8 @@ export const NumberInput = ({
         type='number'
         disabled={disabled}
         placeholder={placeholder}
-        value={getValue() ?? 0}
-        onChange={(event) => onValueChange(type, event.target.value)}
+        value={getValue(property) ?? 0}
+        onChange={(event) => onValueChange(property, type, event.target.value)}
         onBlur={onBlur}
       />
       {inputOnly && <Input.DescriptionAndValidation>{error}</Input.DescriptionAndValidation>}
@@ -73,11 +76,17 @@ export const NumberInput = ({
   );
 };
 
-export const BooleanInput = ({ type, label, inputOnly, getStatus, getValue, onValueChange }: InputProps) => {
-  const { status, error } = getStatus();
+export const BooleanInput = <T extends BaseObject>({
+  property,
+  type,
+  label,
+  inputOnly,
+  getStatus,
+  getValue,
+  onValueChange,
+}: InputProps<T>) => {
+  const { status, error } = getStatus?.(property);
 
-  // TODO(burdon): Runtime error:
-  //  Warning: Unknown event handler property `onCheckedChange`. It will be ignored.
   return (
     <Input.Root validationValence={status}>
       {!inputOnly && (
@@ -85,17 +94,21 @@ export const BooleanInput = ({ type, label, inputOnly, getStatus, getValue, onVa
           <Input.Label>{label}</Input.Label>
         </InputHeader>
       )}
-      <Input.Switch checked={getValue()} onCheckedChange={(value) => onValueChange(type, value)} />
+      <Input.Switch
+        checked={getValue<boolean>(property)}
+        onCheckedChange={(value) => onValueChange(property, type, value)}
+      />
       {inputOnly && <Input.DescriptionAndValidation>{error}</Input.DescriptionAndValidation>}
     </Input.Root>
   );
 };
 
-export type SelectInputOptions = InputProps & {
+export type SelectInputOptions<T extends BaseObject> = InputProps<T> & {
   options?: Array<{ value: string | number; label?: string }>;
 };
 
-export const SelectInput = ({
+export const SelectInput = <T extends BaseObject>({
+  property,
   type,
   label,
   inputOnly,
@@ -105,8 +118,8 @@ export const SelectInput = ({
   getStatus,
   getValue,
   onValueChange,
-}: SelectInputOptions) => {
-  const { status, error } = getStatus();
+}: SelectInputOptions<T>) => {
+  const { status, error } = getStatus?.(property);
 
   return (
     <Input.Root validationValence={status}>
@@ -115,7 +128,7 @@ export const SelectInput = ({
           <Input.Label>{label}</Input.Label>
         </InputHeader>
       )}
-      <Select.Root value={getValue()} onValueChange={(value) => onValueChange(type, value)}>
+      <Select.Root value={getValue(property)} onValueChange={(value) => onValueChange(property, type, value)}>
         {/* TODO(burdon): Placeholder not working? */}
         <Select.TriggerButton classNames='is-full' disabled={disabled} placeholder={placeholder} />
         <Select.Portal>

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

@@ -36,7 +36,7 @@ type TestType = S.Schema.Type<typeof TestSchema>;
 
 type StoryProps<T extends BaseObject> = { schema: S.Schema<T> } & FormProps<T>;
 
-const DefaultStory = <T extends BaseObject>({ schema, values: initialValues, ...props }: StoryProps<T>) => {
+const DefaultStory = <T extends BaseObject>({ schema, values: initialValues }: StoryProps<T>) => {
   const [values, setValues] = useState(initialValues);
   const handleSave = useCallback<NonNullable<FormProps<T>['onSave']>>((values) => {
     setValues(values);
@@ -45,7 +45,7 @@ const DefaultStory = <T extends BaseObject>({ schema, values: initialValues, ...
   return (
     <TestLayout json={{ values, schema: schema.ast.toJSON() }}>
       <TestPanel>
-        <Form<T> schema={schema} values={values} onSave={handleSave} {...props} />
+        <Form<T> schema={schema} values={values} onSave={handleSave} />
       </TestPanel>
     </TestLayout>
   );
@@ -78,6 +78,7 @@ export const Default: Story<TestType> = {
   },
 };
 
+// TODO(burdon): Should accept partial values.
 export const Org: Story<Testing.OrgSchemaType> = {
   args: {
     schema: Testing.OrgSchema,
@@ -88,17 +89,6 @@ export const Org: Story<Testing.OrgSchemaType> = {
   },
 };
 
-export const OrgAutoSave: Story<Testing.OrgSchemaType> = {
-  args: {
-    schema: Testing.OrgSchema,
-    values: {
-      name: 'DXOS',
-      // website: 'https://dxos.org',
-    },
-    autoSave: true,
-  },
-};
-
 // TODO(burdon): Type issue with employer reference.
 // TODO(burdon): Test table/form with compound values (e.g., address).
 // export const Contact: Story<Testing.ContactSchemaType> = {
@@ -124,7 +114,7 @@ const ShapeSchema = S.Struct({
       }),
       S.Struct({
         type: S.Literal('square').annotations({ [AST.TitleAnnotationId]: 'Type' }),
-        size: S.optional(S.Number.pipe(S.nonNegative()).annotations({ [AST.TitleAnnotationId]: 'Size' })),
+        size: S.optional(S.Number.annotations({ [AST.TitleAnnotationId]: 'Size' })),
       }),
     ).annotations({ [AST.TitleAnnotationId]: 'Shape' }),
   ),
@@ -149,7 +139,7 @@ const DiscriminatedUnionStory = ({ values: initialValues }: DiscriminatedUnionSt
           onSave={handleSave}
           Custom={{
             ['shape.type' as const]: (props) => (
-              <SelectInput
+              <SelectInput<ShapeType>
                 {...props}
                 options={['circle', 'square'].map((value) => ({
                   value,

package/src/components/Form/Form.tsx

@@ -2,28 +2,29 @@
 // Copyright 2024 DXOS.org
 //
 
-import React, { type ReactElement, useEffect, useMemo } from 'react';
+import { pipe } from 'effect';
+import { capitalize } from 'effect/String';
+import React, { useEffect, useMemo } from 'react';
 
-import { type BaseObject, type S, type PropertyKey } from '@dxos/echo-schema';
-import { type ThemedClassName } from '@dxos/react-ui';
+import { AST, type BaseObject, S, type PropertyKey, type FormatEnum } from '@dxos/echo-schema';
+import { findNode, getDiscriminatedType, isDiscriminatedUnion, SimpleType } from '@dxos/effect';
+import { log } from '@dxos/log';
+import { IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
-import { type SchemaProperty } from '@dxos/schema';
+import { getSchemaProperties, type SchemaProperty } from '@dxos/schema';
+import { isNotFalsy } from '@dxos/util';
 
-import { FormActions } from './FormActions';
-import { FormFields } from './FormContent';
-import { FormProvider } from './FormContext';
-import { type InputProps, type InputComponent } from './Input';
-import { type FormOptions } from '../../hooks';
+import { SelectInput } from './Defaults';
+import { InputHeader, type InputProps, type InputComponent } from './Input';
+import { getInputComponent } from './factory';
+import { type FormHandler, type FormOptions, useForm } from '../../hooks';
+import { translationKey } from '../../translations';
 
-export type PropsFilter<T extends BaseObject> = (props: SchemaProperty<T>[]) => SchemaProperty<T>[];
+// TODO(burdon): Rename package react-ui-form; delete react-ui-card.
 
-export type ComponentLookup = (args: {
-  prop: string;
-  schema: S.Schema<any>;
-  inputProps: InputProps;
-}) => ReactElement | undefined;
+const padding = 'px-2';
 
-export type CustomInputMap = Partial<Record<string, InputComponent>>;
+export type PropsFilter<T extends BaseObject> = (props: SchemaProperty<T>[]) => SchemaProperty<T>[];
 
 export type FormProps<T extends BaseObject> = ThemedClassName<
   {
@@ -41,21 +42,29 @@ export type FormProps<T extends BaseObject> = ThemedClassName<
     autoSave?: boolean;
     testId?: string;
     onCancel?: () => void;
-    lookupComponent?: ComponentLookup;
+
+    lookupComponent?: (args: {
+      prop: string;
+      schema: S.Schema<any>;
+      inputProps: InputProps<T>;
+    }) => React.ReactElement | undefined;
     /**
      * Map of custom renderers for specific properties.
-     * Prefer lookupComponent for plugin specific input surfaces.
+     * @deprecated Use lookupComponent instead.
      */
-    Custom?: CustomInputMap;
+    Custom?: Partial<Record<string, InputComponent<T>>>;
   } & Pick<FormOptions<T>, 'schema' | 'onValuesChanged' | 'onValidate' | 'onSave'>
 >;
 
+/**
+ * General purpose form component that displays field controls based on the given schema.
+ */
+// TODO(burdon): Area to show general validation errors.
 export const Form = <T extends BaseObject>({
   classNames,
   schema,
   values: initialValues,
   path = [],
-  autoFocus,
   readonly,
   filter,
   sort,
@@ -69,38 +78,338 @@ export const Form = <T extends BaseObject>({
   Custom,
 }: FormProps<T>) => {
   const onValid = useMemo(() => (autoSave ? onSave : undefined), [autoSave, onSave]);
+  const { canSave, values, errors, handleSave, ...inputProps } = useForm<T>({
+    schema,
+    initialValues,
+    onValuesChanged,
+    onValidate,
+    onValid,
+    onSave,
+  });
+
+  // Filter and sort props.
+  // TODO(burdon): Move into useForm?
+  const properties = useMemo(() => {
+    const props = getSchemaProperties<T>(schema.ast, values);
+    const filtered = filter ? filter(props) : props;
+    const findIndex = (props: PropertyKey<T>[], prop: PropertyKey<T>) => {
+      const idx = props.findIndex((p) => p === prop);
+      return idx === -1 ? Infinity : idx;
+    };
+
+    return sort ? filtered.sort(({ name: a }, { name: b }) => findIndex(sort, a) - findIndex(sort, b)) : filtered;
+  }, [schema, filter, values]);
 
-  // TODO(burdon): Hack to select first input.
+  // TODO(burdon): Highlight in UX.
   useEffect(() => {
-    if (autoFocus) {
-      const input = document.querySelector('input');
-      if (input) {
-        input.focus();
-      }
+    if (errors && Object.keys(errors).length) {
+      log.warn('validation', { errors });
     }
-  }, [autoFocus]);
+  }, [errors]);
 
   return (
-    <FormProvider
-      schema={schema}
-      initialValues={initialValues}
-      onValuesChanged={onValuesChanged}
-      onValidate={onValidate}
-      onValid={onValid}
-      onSave={onSave}
-    >
-      <div role='none' className={mx('p-2', classNames)} data-testid={testId}>
-        <FormFields
-          schema={schema}
-          path={path}
-          readonly={readonly}
-          filter={filter}
-          sort={sort}
-          lookupComponent={lookupComponent}
-          Custom={Custom}
+    <div role='form' className={mx('flex flex-col w-full gap-2 py-2', classNames)} data-testid={testId}>
+      {properties
+        .map((property) => {
+          const { ast, name, type, format, title, description, examples, options, array } = property;
+          const key = [...path, name];
+          const label = title ?? pipe(name, capitalize);
+          const placeholder = examples?.length ? `Example: "${examples[0]}"` : description;
+
+          const FoundComponent = lookupComponent?.({
+            prop: name,
+            schema: S.make(ast),
+            inputProps: {
+              property: name,
+              type,
+              format,
+              label,
+              disabled: readonly,
+              placeholder,
+              ...inputProps,
+            },
+          });
+
+          if (FoundComponent) {
+            return (
+              <div key={name} role='none' className={padding}>
+                {FoundComponent}
+              </div>
+            );
+          }
+
+          // Get generic input.
+          // TODO(ZaymonFC): We might need to switch this to using globs since we're now indexing into arrays.
+          let InputComponent = Custom?.[key.join('.')];
+          if (!InputComponent) {
+            // Select.
+            if (options) {
+              return (
+                <div key={name} role='none' className={padding}>
+                  <SelectInput
+                    type={type}
+                    format={format}
+                    property={name}
+                    disabled={readonly}
+                    label={label}
+                    options={options.map((option) => ({ value: option, label: String(option) }))}
+                    placeholder={placeholder}
+                    {...inputProps}
+                  />
+                </div>
+              );
+            }
+
+            InputComponent = getInputComponent<T>(type, format);
+
+            // TODO(ZaymonFC): Array handling is inelegant. We need to push this complexity down into SDK/Schema.
+            if (array) {
+              return (
+                <ArrayField
+                  key={name}
+                  name={name}
+                  type={type}
+                  array={true}
+                  label={label}
+                  ast={ast}
+                  values={values}
+                  format={format}
+                  readonly={readonly}
+                  placeholder={placeholder}
+                  inputProps={inputProps}
+                  Custom={Custom}
+                />
+              );
+            }
+          }
+
+          if (!InputComponent) {
+            // Recursively render form.
+            if (type === 'object') {
+              const baseNode = findNode(ast, isDiscriminatedUnion);
+              const typeLiteral = baseNode
+                ? getDiscriminatedType(baseNode, values[name] as any)
+                : findNode(ast, AST.isTypeLiteral);
+
+              if (typeLiteral) {
+                const schema = S.make(typeLiteral);
+                return (
+                  <div key={name} role='none'>
+                    <div className={padding}>{label}</div>
+                    <Form<any>
+                      schema={schema}
+                      path={key}
+                      values={values[name] ?? {}}
+                      onValuesChanged={(childValues) => {
+                        inputProps.onValueChange(name, 'object', childValues);
+                      }}
+                      Custom={Custom as any}
+                    />
+                  </div>
+                );
+              }
+            }
+
+            log('no renderer for property', { name, type });
+            return null;
+          }
+
+          return (
+            <div key={name} role='none' className={padding}>
+              <InputComponent
+                type={type}
+                format={format}
+                property={name}
+                disabled={readonly}
+                label={label}
+                placeholder={placeholder}
+                {...inputProps}
+              />
+            </div>
+          );
+        })
+        .filter(isNotFalsy)}
+      {(onCancel || onSave) && !autoSave && (
+        <FormActions onCancel={onCancel} onSubmit={handleSave} canSubmit={canSave} readonly={readonly} />
+      )}
+    </div>
+  );
+};
+
+type ArrayFieldProps<T extends BaseObject> = {
+  name: PropertyKey<T>;
+  type: SimpleType;
+  array: true;
+  label: string;
+  ast: AST.AST;
+  values: Record<string, any>;
+  format?: FormatEnum;
+  readonly?: boolean;
+  placeholder?: string;
+  inputProps: Pick<FormHandler<T>, 'getStatus' | 'getValue' | 'onValueChange' | 'onBlur'>;
+  Custom?: Partial<Record<string, InputComponent<T>>>;
+};
+
+const ArrayField = <T extends BaseObject>({
+  name,
+  type,
+  label,
+  ast,
+  values,
+  format,
+  readonly,
+  placeholder,
+  inputProps,
+  Custom,
+}: ArrayFieldProps<T>) => {
+  const { t } = useTranslation(translationKey);
+  const arrayValues = (values[name] ?? []) as any[];
+  const key = [name];
+
+  // TODO(ZaymonFC): Should this unwrapping happen at a lower level?
+  const tupleType = findNode(ast, AST.isTupleType);
+  const elementType = (tupleType as AST.TupleType | undefined)?.rest[0]?.type;
+
+  if (type === 'object' && elementType) {
+    const baseNode = findNode(elementType, isDiscriminatedUnion);
+    const typeLiteral = baseNode
+      ? getDiscriminatedType(baseNode, values[name] as any)
+      : findNode(elementType, AST.isTypeLiteral);
+
+    if (typeLiteral) {
+      const schema = S.make(typeLiteral);
+
+      return (
+        <div key={name} role='none' className={mx(padding)}>
+          <InputHeader>{label}</InputHeader>
+          <div role='none' className='flex flex-col gap-1'>
+            {arrayValues.map((value, index) => {
+              return (
+                <div key={index} role='none' className='flex items-center gap-1'>
+                  <div role='none' className='flex-1'>
+                    <Form<any>
+                      schema={schema}
+                      path={[...key, `[${index}]`]}
+                      values={value}
+                      onValuesChanged={(childValues) => {
+                        const newValues = [...arrayValues];
+                        newValues[index] = childValues;
+                        inputProps.onValueChange(name, 'object', newValues);
+                      }}
+                      Custom={Custom as any}
+                    />
+                  </div>
+                  <IconButton
+                    icon='ph--trash--regular'
+                    iconOnly
+                    label={t('button remove')}
+                    onClick={() => {
+                      const newValues = arrayValues.filter((_, i) => i !== index);
+                      inputProps.onValueChange(name, type, newValues);
+                    }}
+                  />
+                </div>
+              );
+            })}
+          </div>
+          <div role='none' className='flex justify-between items-center plb-1'>
+            <IconButton
+              icon='ph--plus--regular'
+              iconOnly
+              label={t('button add')}
+              onClick={() => {
+                const newValues = [...arrayValues, {}];
+                inputProps.onValueChange(name, type, newValues);
+              }}
+            />
+          </div>
+        </div>
+      );
+    }
+    return (
+      <div key={name} role='none'>
+        Nested form not supported in arrays, yet.
+      </div>
+    );
+  }
+
+  const InputComponent = getInputComponent<T>(type, format);
+  if (!InputComponent) {
+    return null;
+  }
+
+  return (
+    <div role='none' key='meta-input' className={mx(padding)}>
+      <InputHeader>{label}</InputHeader>
+      <div role='none' className='flex flex-col gap-1'>
+        {arrayValues.map((_, index) => (
+          <div key={index} role='none' className='flex items-start gap-1'>
+            <div role='none' className='flex-1'>
+              <InputComponent
+                type={type}
+                format={format}
+                label={label}
+                inputOnly
+                property={`${name}[${index}]` as PropertyKey<T>}
+                disabled={readonly}
+                placeholder={placeholder}
+                {...inputProps}
+              />
+            </div>
+            <IconButton
+              icon='ph--trash--regular'
+              iconOnly
+              label={t('button remove')}
+              onClick={() => {
+                const newValues = arrayValues.filter((_, i) => i !== index);
+                inputProps.onValueChange(name, type, newValues);
+              }}
+            />
+          </div>
+        ))}
+      </div>
+      <div role='none' className='flex justify-between items-center plb-1'>
+        <IconButton
+          icon='ph--plus--regular'
+          iconOnly
+          label={t('button add')}
+          onClick={() => {
+            const newValues = [...arrayValues, SimpleType.getDefaultValue(type)];
+            inputProps.onValueChange(name, type, newValues);
+          }}
         />
-        {(onCancel || onSave) && !autoSave && <FormActions onCancel={onCancel} readonly={readonly} />}
       </div>
-    </FormProvider>
+    </div>
+  );
+};
+
+type FormActionsProps = {
+  readonly?: boolean;
+  canSubmit: boolean;
+  onCancel?: () => void;
+  onSubmit: () => void;
+};
+
+export const FormActions = ({ onCancel, onSubmit, canSubmit, readonly }: FormActionsProps) => {
+  const { t } = useTranslation(translationKey);
+
+  return (
+    <div role='none' className='flex justify-center'>
+      <div role='none' className={mx(onCancel && !readonly && 'grid grid-cols-2 gap-2')}>
+        {onCancel && !readonly && (
+          <IconButton data-testid='cancel-button' icon='ph--x--regular' label={t('button cancel')} onClick={onCancel} />
+        )}
+        {onSubmit && (
+          <IconButton
+            type='submit'
+            data-testid='save-button'
+            disabled={!canSubmit}
+            icon='ph--check--regular'
+            label={t('button save')}
+            onClick={onSubmit}
+          />
+        )}
+      </div>
+    </div>
   );
 };