@dxos/react-ui-form 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/components/ViewEditor/ViewEditor.tsx

@@ -2,54 +2,53 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Array, Match, Option, Schema } from 'effect';
-import React, { forwardRef, useCallback, useImperativeHandle, useMemo, useState } from 'react';
-
-import { type SchemaRegistry } from '@dxos/echo-db';
-import { EchoSchema, Format, type JsonProp, isMutable, toJsonSchema } from '@dxos/echo-schema';
+import { RegistryContext } from '@effect-atom/atom-react';
+import * as Array from 'effect/Array';
+import * as Match from 'effect/Match';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import React, { forwardRef, useCallback, useContext, useImperativeHandle, useMemo, useState } from 'react';
+
+import { Entity, Feed, Filter, Format, Obj, Query, QueryAST, Ref, type SchemaRegistry } from '@dxos/echo';
+import { View } from '@dxos/echo';
+import { EchoSchema, type JsonProp, isMutable, toJsonSchema } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
-import {
-  Callout,
-  IconButton,
-  Input,
-  type ThemedClassName,
-  useDensityContext,
-  useElevationContext,
-  useThemeContext,
-  useTranslation,
-} from '@dxos/react-ui';
-import { Editor, createBasicExtensions, createThemeExtensions } from '@dxos/react-ui-editor';
+import { useObject, useQuery } from '@dxos/react-client/echo';
+import { IconButton, Input, Message, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { QueryForm, type QueryFormProps } from '@dxos/react-ui-components';
 import { List } from '@dxos/react-ui-list';
-import { cardSpacing } from '@dxos/react-ui-stack';
-import { inputTheme } from '@dxos/react-ui-theme';
-import { inputTextLabel, mx, subtleHover } from '@dxos/react-ui-theme';
 import {
-  type DataType,
-  FieldSchema,
-  type FieldType,
+  ParentLabelAnnotation,
   ProjectionModel,
   VIEW_FIELD_LIMIT,
-  typenameFromQuery,
+  createEchoChangeCallback,
+  getTypenameFromQuery,
 } from '@dxos/schema';
+import { mx, osTranslations, subtleHover } from '@dxos/ui-theme';
 
-import { translationKey } from '../../translations';
-import { FieldEditor } from '../FieldEditor';
-import { Form, type FormProps, type InputComponent, InputHeader, type InputProps } from '../Form';
+import { translationKey } from '#translations';
 
-const listGrid = 'grid grid-cols-[min-content_1fr_min-content_min-content_min-content]';
-const listItemGrid = 'grid grid-cols-subgrid col-span-5';
+import { FieldEditor } from '../FieldEditor';
+import {
+  Form,
+  type FormFieldComponent,
+  type FormFieldComponentProps,
+  FormFieldLabel,
+  type FormFieldMap,
+  type FormRootProps,
+} from '../Form';
 
 export type ViewEditorProps = ThemedClassName<
   {
     schema: Schema.Schema.AnyNoContext;
-    view: DataType.View;
-    mode?: 'schema' | 'query';
-    registry?: SchemaRegistry;
-    readonly?: boolean;
+    view: View.View;
+    mode?: 'schema' | 'tag';
+    registry?: SchemaRegistry.SchemaRegistry;
     showHeading?: boolean;
-    onQueryChanged?: (query: string, target?: string) => void;
+    onQueryChanged?: (query: QueryAST.Query, target?: string) => void;
     onDelete?: (fieldId: string) => void;
-  } & Pick<FormProps<any>, 'outerSpacing'>
+  } & Pick<QueryFormProps, 'types' | 'tags'> &
+    Pick<FormRootProps<any>, 'readonly' | 'db'>
 >;
 
 /**
@@ -63,317 +62,360 @@ export const ViewEditor = forwardRef<ProjectionModel, ViewEditorProps>(
       view,
       mode = 'schema',
       registry,
+      db,
       readonly,
       showHeading = false,
+      types,
+      tags,
       onQueryChanged,
       onDelete,
-      outerSpacing = true,
     },
     forwardedRef,
   ) => {
+    const atomRegistry = useContext(RegistryContext);
     const schemaReadonly = !isMutable(schema);
     const { t } = useTranslation(translationKey);
+
     const projectionModel = useMemo(() => {
       // Use reactive and mutable version of json schema when schema is mutable.
       const jsonSchema = schema instanceof EchoSchema ? schema.jsonSchema : toJsonSchema(schema);
-      return new ProjectionModel(jsonSchema, view.projection);
-    }, [schema, JSON.stringify(view.projection)]);
+
+      // Always use createEchoChangeCallback since the view is ECHO-backed.
+      // Pass schema only when mutable to allow schema mutations.
+      const change = createEchoChangeCallback(view, schema instanceof EchoSchema ? schema : undefined);
+
+      const model = new ProjectionModel({
+        registry: atomRegistry,
+        view,
+        baseSchema: jsonSchema,
+        change,
+      });
+
+      return model;
+    }, [atomRegistry, schema, view]);
+
     useImperativeHandle(forwardedRef, () => projectionModel, [projectionModel]);
-    const [expandedField, setExpandedField] = useState<FieldType['id']>();
-
-    const serializedQuery = Match.value(mode).pipe(
-      Match.when('schema', () => typenameFromQuery(view.query.ast)),
-      Match.when('query', () => {
-        if (view.query.string) {
-          return view.query.string;
-        } else {
-          return 'Serializing query AST is not currently supported.';
-        }
-      }),
-      Match.exhaustive,
-    );
 
     const queueTarget = Match.value(view.query.ast).pipe(
-      Match.when({ type: 'options' }, ({ options }) => {
-        return Option.fromNullable(options.queues).pipe(
+      Match.when({ type: 'from' }, ({ from }) => {
+        if (from._tag !== 'scope') {
+          return undefined;
+        }
+        return Option.fromNullable(from.scope.queues).pipe(
           Option.flatMap((queues) => Array.head(queues)),
+          Option.map(String),
           Option.getOrUndefined,
         );
       }),
       Match.orElse(() => undefined),
     );
 
+    const feeds = useQuery(db, Filter.type(Feed.Feed));
+
+    const targetRef = useMemo(() => {
+      if (!queueTarget) {
+        return undefined;
+      }
+      const feed = feeds.find((feed) => Feed.getQueueDxn(feed)?.toString() === queueTarget);
+      return feed ? Ref.fromDXN(Entity.getDXN(feed)) : undefined;
+    }, [queueTarget, feeds]);
+
     const viewSchema = useMemo(() => {
       const base = Schema.Struct({
         query:
           mode === 'schema'
             ? Format.URL.annotations({ title: 'Record type' })
-            : Schema.String.annotations({ title: 'Query' }),
+            : QueryAST.Query.annotations({ title: 'Query' }),
       });
 
-      if (mode === 'query') {
+      if (mode === 'tag') {
         return Schema.Struct({
-          name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
           ...base.fields,
-          target: Schema.optional(Schema.String.annotations({ title: 'Target Queue' })),
+          // TODO(wittjosiah): Replace Type.Feed with Dataset.Dataset when Ref.Ref supports unions.
+          target: Ref.Ref(Feed.Feed).pipe(
+            Schema.annotations({ title: 'Target Feed' }),
+            ParentLabelAnnotation.set(true),
+            Schema.optional,
+          ),
         }).pipe(Schema.mutable);
       }
 
       return base.pipe(Schema.mutable);
     }, [mode]);
+
     // TODO(burdon): Need to warn user of possible consequences of editing.
     // TODO(burdon): Settings should have domain name owned by user.
     const viewValues = useMemo(
-      () => ({ name: view.name, query: serializedQuery, target: queueTarget }),
-      [view.name, serializedQuery, queueTarget],
+      () => ({
+        query: mode === 'schema' ? getTypenameFromQuery(view.query.ast) : view.query.ast,
+        target: targetRef,
+      }),
+      [mode, view.query.ast, targetRef],
     );
 
-    const handleToggleField = useCallback(
-      (field: FieldType) => {
-        setExpandedField((prevExpandedFieldId) => (prevExpandedFieldId === field.id ? undefined : field.id));
-      },
-      [readonly],
+    const fieldMap = useMemo<FormFieldMap | undefined>(
+      () => (mode === 'tag' ? customFields({ types, tags }) : undefined),
+      [mode, types, tags],
     );
 
-    // TODO(burdon): Check if mutable; variant of useCallback that return undefined if readonly?
-
-    const handleAdd = useCallback(() => {
-      invariant(!readonly);
-      const field = projectionModel.createFieldProjection();
-      setExpandedField(field.id);
-    }, [schema, projectionModel, readonly]);
-
     const handleUpdate = useCallback(
-      (values: Schema.Schema.Type<typeof viewSchema>) => {
-        invariant(!readonly);
-        requestAnimationFrame(() => {
-          if ('name' in values && view.name !== values.name) {
-            view.name = values.name;
+      (values: any) => {
+        const targetValue = values.target;
+        let queueDxn: string | undefined;
+
+        if (Ref.isRef(targetValue)) {
+          const feedDxn = targetValue.dxn.toString();
+          const feed = feeds.find((feed) => Obj.getDXN(feed).toString() === feedDxn);
+          if (feed) {
+            queueDxn = Feed.getQueueDxn(feed)?.toString();
           }
+        }
 
-          const queryChanged = serializedQuery !== values.query;
-          const targetValue = 'target' in values ? values.target : undefined;
-          const targetChanged = 'target' in values && values.target && queueTarget !== targetValue;
-
-          if ((queryChanged || targetChanged) && !readonly) {
-            onQueryChanged?.(values.query, targetValue);
-          }
-        });
+        // TODO(wittjosiah): Deep-clone the AST to plain JS or ECHO proxy arrays become objects with numeric keys.
+        const query =
+          mode === 'schema'
+            ? Query.select(Filter.typename(values.query)).ast
+            : JSON.parse(JSON.stringify(values.query));
+        onQueryChanged?.(query, queueDxn);
       },
-      [serializedQuery, onQueryChanged, readonly, view, queueTarget],
+      [onQueryChanged, mode, feeds],
     );
 
     const handleDelete = useCallback(
       (fieldId: string) => {
         invariant(!readonly);
-        if (fieldId === expandedField) {
-          setExpandedField(undefined);
-        }
-
         onDelete?.(fieldId);
       },
-      [expandedField, onDelete, readonly],
+      [onDelete, readonly],
     );
 
-    const handleMove = useCallback(
-      (fromIndex: number, toIndex: number) => {
-        invariant(!readonly);
+    return (
+      <div role='none' className={mx(classNames)}>
+        {/* If readonly is set, then the callout is not needed. */}
+        {schemaReadonly && !readonly && (
+          <Message.Root valence='info' classNames='my-form-padding'>
+            <Message.Title>{t('system-schema.description')}</Message.Title>
+          </Message.Root>
+        )}
+
+        {/* TODO(burdon): Is the form read-only or just the schema? */}
+        <Form.Root schema={viewSchema} values={viewValues} fieldMap={fieldMap} db={db} onValuesChanged={handleUpdate}>
+          <Form.FieldSet />
+
+          <FormFieldLabel label={t('fields.label')} asChild />
+          <FieldList
+            schema={schema}
+            view={view}
+            registry={registry}
+            readonly={readonly}
+            showHeading={showHeading}
+            onDelete={handleDelete}
+          />
+        </Form.Root>
+      </div>
+    );
+  },
+);
+
+type FieldListProps = Pick<ViewEditorProps, 'schema' | 'view' | 'registry' | 'readonly' | 'showHeading' | 'onDelete'>;
+
+const FieldList = ({ schema, view, registry, readonly, showHeading = false, onDelete }: FieldListProps) => {
+  const atomRegistry = useContext(RegistryContext);
+  const schemaReadonly = !isMutable(schema);
+  const { t } = useTranslation(translationKey);
+
+  // Subscribe to view changes for reactivity.
+  const [viewSnapshot] = useObject(view);
+
+  const projectionModel = useMemo(() => {
+    // Use reactive and mutable version of json schema when schema is mutable.
+    const jsonSchema = schema instanceof EchoSchema ? schema.jsonSchema : toJsonSchema(schema);
+
+    // Always use createEchoChangeCallback since the view is ECHO-backed.
+    // Pass schema only when mutable to allow schema mutations.
+    const change = createEchoChangeCallback(view, schema instanceof EchoSchema ? schema : undefined);
+
+    const model = new ProjectionModel({
+      registry: atomRegistry,
+      view,
+      baseSchema: jsonSchema,
+      change,
+    });
+
+    return model;
+  }, [atomRegistry, schema, view]);
+
+  const [expandedField, setExpandedField] = useState<View.FieldType['id']>();
+
+  const handleAdd = useCallback(() => {
+    invariant(!readonly);
+    const field = projectionModel.createFieldProjection();
+    setExpandedField(field.id);
+  }, [projectionModel, readonly]);
+
+  const handleToggleField = useCallback(
+    (field: View.FieldType) => {
+      setExpandedField((prevExpandedFieldId) => (prevExpandedFieldId === field.id ? undefined : field.id));
+    },
+    [readonly],
+  );
+
+  const handleDelete = useCallback(
+    (fieldId: string) => {
+      invariant(!readonly);
+      if (fieldId === expandedField) {
+        setExpandedField(undefined);
+      }
+
+      onDelete?.(fieldId);
+    },
+    [expandedField, onDelete, readonly],
+  );
+
+  const handleMove = useCallback(
+    (fromIndex: number, toIndex: number) => {
+      invariant(!readonly);
+      Obj.update(view, (view) => {
         // NOTE(ZaymonFC): Using arrayMove here causes a race condition with the kanban model.
         const fields = [...view.projection.fields];
         const [moved] = fields.splice(fromIndex, 1);
         fields.splice(toIndex, 0, moved);
         view.projection.fields = fields;
-      },
-      [view.projection.fields, readonly],
-    );
-
-    const handleClose = useCallback(() => setExpandedField(undefined), []);
+      });
+    },
+    [view, readonly],
+  );
 
-    const handleHide = useCallback(
-      (fieldId: string) => {
-        setExpandedField(undefined);
-        projectionModel.hideFieldProjection(fieldId);
-      },
-      [projectionModel],
-    );
+  const handleClose = useCallback(() => setExpandedField(undefined), []);
 
-    const handleShow = useCallback(
-      (property: string) => {
-        setExpandedField(undefined);
-        projectionModel.showFieldProjection(property as JsonProp);
-      },
-      [projectionModel],
-    );
+  const handleHide = useCallback(
+    (fieldId: string) => {
+      setExpandedField(undefined);
+      projectionModel.hideFieldProjection(fieldId);
+    },
+    [projectionModel],
+  );
 
-    const custom: Partial<Record<string, InputComponent>> = useMemo(
-      () =>
-        mode === 'query'
-          ? {
-              ['query' satisfies keyof Schema.Schema.Type<typeof viewSchema>]: (props: InputProps) => {
-                const { themeMode } = useThemeContext();
-                const density = useDensityContext();
-                const elevation = useElevationContext();
-
-                // TODO(wittjosiah): Including props.onValueChange in deps causes infinite loop.
-                const handleChange = useCallback((text: string) => props.onValueChange('string', text), []);
-
-                const extensions = useMemo(
-                  () => [
-                    createBasicExtensions({ placeholder: t('query placeholder') }),
-                    createThemeExtensions({ themeMode }),
-                  ],
-                  [],
-                );
-
-                // TODO(wittjosiah): This is probably not the right way to do these styles.
-                return (
-                  <Input.Root>
-                    <InputHeader label={props.label} />
-                    <Editor
-                      classNames={mx(
-                        inputTheme.input({ density, elevation }),
-                        'flex items-center',
-                        'focus-within:bg-focusSurface focus-within:border-separator focus-within:hover:bg-focusSurface',
-                      )}
-                      extensions={extensions}
-                      value={props.getValue()}
-                      onChange={handleChange}
+  const handleShow = useCallback(
+    (property: string) => {
+      setExpandedField(undefined);
+      projectionModel.showFieldProjection(property as JsonProp);
+    },
+    [projectionModel],
+  );
+
+  if (!viewSnapshot) {
+    return null;
+  }
+
+  return (
+    <List.Root<View.FieldType>
+      items={viewSnapshot.projection.fields as View.FieldType[]}
+      isItem={Schema.is(View.FieldSchema)}
+      getId={(field) => field.id}
+      onMove={readonly ? undefined : handleMove}
+      readonly={readonly}
+    >
+      {({ items: fields }) => (
+        <>
+          {showHeading && <h3 className='text-sm'>{t('field-path.label')}</h3>}
+          <div role='list' className='grid grid-cols-[min-content_1fr_min-content_min-content_min-content]'>
+            {fields?.map((field) => {
+              const hidden = field.visible === false;
+              return (
+                <List.Item<View.FieldType>
+                  key={field.id}
+                  item={field}
+                  classNames={'grid grid-cols-subgrid col-span-5'}
+                  aria-expanded={expandedField === field.id}
+                >
+                  <div
+                    role='none'
+                    className={mx(
+                      subtleHover,
+                      'grid grid-cols-subgrid col-span-5',
+                      'rounded-xs cursor-pointer min-h-10',
+                    )}
+                  >
+                    <List.ItemDragHandle disabled={readonly || schemaReadonly} />
+                    <List.ItemTitle classNames={hidden && 'text-subdued'} onClick={() => handleToggleField(field)}>
+                      {field.path}
+                    </List.ItemTitle>
+                    <List.ItemIconButton
+                      label={t(hidden ? 'show-field.label' : 'hide-field.label')}
+                      data-testid={hidden ? 'show-field-button' : 'hide-field-button'}
+                      icon={hidden ? 'ph--eye-closed--regular' : 'ph--eye--regular'}
+                      autoHide={false}
+                      disabled={readonly || (!hidden && projectionModel.getFields().length <= 1)}
+                      onClick={() => (hidden ? handleShow(field.path) : handleHide(field.id))}
                     />
-                    {/* TODO(wittjosiah): Support query editor.
-                    <QueryEditor
-                      classNames={mx(
-                        inputTheme.input({ density, elevation }),
-                        'flex items-center',
-                        'focus-within:bg-focusSurface focus-within:border-separator focus-within:hover:bg-focusSurface',
-                      )}
-                      space={space}
-                      value={props.getValue()}
-                      onChange={handleChange}
-                    /> */}
-                  </Input.Root>
-                );
-              },
-            }
-          : {},
-      [],
+                    {!readonly && (
+                      <>
+                        <List.ItemDeleteButton
+                          label={t('delete-field.label')}
+                          autoHide={false}
+                          disabled={readonly || schemaReadonly || viewSnapshot.projection.fields.length <= 1}
+                          onClick={() => handleDelete(field.id)}
+                          data-testid='field.delete'
+                        />
+                        <List.ItemIconButton
+                          iconOnly
+                          variant='ghost'
+                          label={t('toggle-expand.label', { ns: osTranslations })}
+                          icon={expandedField === field.id ? 'ph--caret-down--regular' : 'ph--caret-right--regular'}
+                          onClick={() => handleToggleField(field)}
+                          data-testid='field.toggle'
+                        />
+                      </>
+                    )}
+                  </div>
+                  {expandedField === field.id && !readonly && (
+                    <div role='none' className='col-span-full mt-1 mb-1 border border-separator rounded-md'>
+                      <FieldEditor
+                        readonly={readonly || schemaReadonly}
+                        registry={registry}
+                        projection={projectionModel}
+                        field={field}
+                        onSave={handleClose}
+                      />
+                    </div>
+                  )}
+                </List.Item>
+              );
+            })}
+          </div>
+          {!readonly && !expandedField && (
+            <div role='none' className='my-form-padding'>
+              <IconButton
+                icon='ph--plus--regular'
+                label={t('add-property-button.label')}
+                onClick={handleAdd}
+                disabled={viewSnapshot.projection.fields.length >= VIEW_FIELD_LIMIT}
+                classNames='w-full'
+              />
+            </div>
+          )}
+        </>
+      )}
+    </List.Root>
+  );
+};
+
+const customFields = ({
+  types,
+  tags,
+}: Pick<ViewEditorProps, 'types' | 'tags'>): Record<string, FormFieldComponent> => ({
+  query: ({ type, readonly, label, getValue, onValueChange }: FormFieldComponentProps) => {
+    const handleChange = useCallback<NonNullable<QueryFormProps['onChange']>>(
+      (query) => onValueChange(type, query.ast),
+      [onValueChange],
     );
 
     return (
-      <div role='none' className={mx(classNames)}>
-        {schemaReadonly && mode === 'schema' && (
-          <Callout.Root valence='info' classNames={['mlb-cardSpacingBlock', outerSpacing && 'mli-cardSpacingInline']}>
-            <Callout.Title>{t('system schema description')}</Callout.Title>
-          </Callout.Root>
-        )}
-
-        {/* TODO(burdon): Is the form read-only or just the schema? */}
-        {/* TODO(burdon): Readonly fields should take up the same space as editable fields (just be ghosted). */}
-        <Form<Schema.Schema.Type<typeof viewSchema>>
-          autoSave
-          schema={viewSchema}
-          values={viewValues}
-          readonly={readonly ? 'disabled-input' : false}
-          onSave={handleUpdate}
-          outerSpacing={outerSpacing}
-          Custom={custom}
-        />
-
-        <div role='none' className={outerSpacing ? cardSpacing : 'mlb-cardSpacingBlock'}>
-          <h2 className={mx(inputTextLabel)}>{t('fields label')}</h2>
-
-          <List.Root<FieldType>
-            items={view.projection.fields}
-            isItem={Schema.is(FieldSchema)}
-            getId={(field) => field.id}
-            onMove={readonly ? undefined : handleMove}
-            readonly={readonly}
-          >
-            {({ items: fields }) => (
-              <>
-                {showHeading && <h3 className='text-sm'>{t('field path label')}</h3>}
-                <div role='list' className={listGrid}>
-                  {fields?.map((field) => {
-                    const hidden = field.visible === false;
-                    return (
-                      <List.Item<FieldType>
-                        key={field.id}
-                        item={field}
-                        classNames={listItemGrid}
-                        aria-expanded={expandedField === field.id}
-                      >
-                        <div
-                          role='none'
-                          className={mx(subtleHover, listItemGrid, 'rounded-sm cursor-pointer min-bs-10')}
-                        >
-                          <List.ItemDragHandle disabled={readonly} />
-                          <List.ItemTitle
-                            classNames={hidden && 'text-subdued'}
-                            onClick={() => handleToggleField(field)}
-                          >
-                            {field.path}
-                          </List.ItemTitle>
-                          <List.ItemButton
-                            label={t(hidden ? 'show field label' : 'hide field label')}
-                            data-testid={hidden ? 'show-field-button' : 'hide-field-button'}
-                            icon={hidden ? 'ph--eye-closed--regular' : 'ph--eye--regular'}
-                            autoHide={false}
-                            disabled={readonly || (!hidden && projectionModel.fields.length <= 1)}
-                            onClick={() => (hidden ? handleShow(field.path) : handleHide(field.id))}
-                          />
-                          {mode === 'schema' && (
-                            <>
-                              <List.ItemDeleteButton
-                                label={t('delete field label')}
-                                autoHide={false}
-                                disabled={readonly || schemaReadonly || view.projection.fields.length <= 1}
-                                onClick={() => handleDelete(field.id)}
-                                data-testid='field.delete'
-                              />
-                              <IconButton
-                                iconOnly
-                                variant='ghost'
-                                label={t('toggle expand label', { ns: 'os' })}
-                                icon={
-                                  expandedField === field.id ? 'ph--caret-down--regular' : 'ph--caret-right--regular'
-                                }
-                                onClick={() => handleToggleField(field)}
-                              />
-                            </>
-                          )}
-                        </div>
-                        {expandedField === field.id && mode === 'schema' && (
-                          <div role='none' className='col-span-5 mbs-1 mbe-1 border border-separator rounded-md'>
-                            <FieldEditor
-                              readonly={readonly || schemaReadonly ? 'disabled-input' : false}
-                              projection={projectionModel}
-                              field={field}
-                              registry={registry}
-                              onSave={handleClose}
-                            />
-                          </div>
-                        )}
-                      </List.Item>
-                    );
-                  })}
-                </div>
-              </>
-            )}
-          </List.Root>
-        </div>
-
-        {!readonly && !expandedField && mode === 'schema' && (
-          <div role='none' className={outerSpacing ? cardSpacing : 'mlb-cardSpacingBlock'}>
-            <IconButton
-              icon='ph--plus--regular'
-              label={t('button add property')}
-              onClick={readonly ? undefined : handleAdd}
-              // TODO(burdon): Show field limit in ux (not tooltip).
-              disabled={view.projection.fields.length >= VIEW_FIELD_LIMIT}
-              classNames='is-full'
-            />
-          </div>
-        )}
-      </div>
+      <Input.Root>
+        <FormFieldLabel readonly={readonly} label={label} />
+        <QueryForm initialQuery={getValue()} types={types} tags={tags} onChange={handleChange} />
+      </Input.Root>
     );
   },
-);
+});