@dxos/react-ui-form 0.8.4-main.1da679c → 0.8.4-main.21d9917

package/src/components/ViewEditor/ViewEditor.tsx

@@ -2,30 +2,40 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Match, Schema } from 'effect';
-import React, { useCallback, useMemo, useState } from 'react';
+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 { type SchemaRegistry } from '@dxos/echo-db';
-import { EchoSchema, Format, type JsonProp, isMutable, toJsonSchema } from '@dxos/echo-schema';
+import { Filter, Format, Obj, Query, QueryAST, type SchemaRegistry } from '@dxos/echo';
+import { EchoSchema, type JsonProp, isMutable, toJsonSchema } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
-import { getSpace } from '@dxos/react-client/echo';
-import { Callout, IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
-import { QueryEditor, QuerySerializer, createExpression } from '@dxos/react-ui-components';
+import { Callout, IconButton, Input, 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 { inputTextLabel, mx, subtleHover } from '@dxos/react-ui-theme';
 import {
-  type DataType,
   FieldSchema,
   type FieldType,
   ProjectionModel,
   VIEW_FIELD_LIMIT,
-  typenameFromQuery,
+  type View,
+  createDirectChangeCallback,
+  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, type InputProps } from '../Form';
+import {
+  Form,
+  type FormFieldComponent,
+  type FormFieldComponentProps,
+  FormFieldLabel,
+  type FormFieldMap,
+} from '../Form';
 
 const listGrid = 'grid grid-cols-[min-content_1fr_min-content_min-content_min-content]';
 const listItemGrid = 'grid grid-cols-subgrid col-span-5';
@@ -33,65 +43,204 @@ const listItemGrid = 'grid grid-cols-subgrid col-span-5';
 export type ViewEditorProps = ThemedClassName<
   {
     schema: Schema.Schema.AnyNoContext;
-    view: DataType.View;
-    kind?: 'basic' | 'advanced';
-    registry?: SchemaRegistry;
+    view: View.View;
+    mode?: 'schema' | 'tag';
+    registry?: SchemaRegistry.SchemaRegistry;
     readonly?: boolean;
     showHeading?: boolean;
-    onQueryChanged?: (query: string) => void;
+    onQueryChanged?: (query: QueryAST.Query, target?: string) => void;
     onDelete?: (fieldId: string) => void;
-  } & Pick<FormProps<any>, 'outerSpacing'>
+  } & Pick<QueryFormProps, 'types' | 'tags'>
 >;
 
 /**
  * Schema-based object form.
  */
-export const ViewEditor = ({
-  classNames,
-  schema,
-  view,
-  kind = 'basic',
-  registry,
-  readonly,
-  showHeading = false,
-  onQueryChanged,
-  onDelete,
-  outerSpacing = true,
-}: ViewEditorProps) => {
-  const space = getSpace(view);
+export const ViewEditor = forwardRef<ProjectionModel, ViewEditorProps>(
+  (
+    {
+      classNames,
+      schema,
+      view,
+      mode = 'schema',
+      registry,
+      readonly,
+      showHeading = false,
+      types,
+      tags,
+      onQueryChanged,
+      onDelete,
+    },
+    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);
+
+      // Use createEchoChangeCallback for mutable schemas (EchoSchema), otherwise use direct mutation.
+      const change =
+        schema instanceof EchoSchema
+          ? createEchoChangeCallback(view, schema)
+          : createDirectChangeCallback(view.projection, jsonSchema);
+
+      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 queueTarget = Match.value(view.query.ast).pipe(
+      Match.when({ type: 'options' }, ({ options }) => {
+        return Option.fromNullable(options.queues).pipe(
+          Option.flatMap((queues) => Array.head(queues)),
+          Option.getOrUndefined,
+        );
+      }),
+      Match.orElse(() => undefined),
+    );
+
+    const viewSchema = useMemo(() => {
+      const base = Schema.Struct({
+        query:
+          mode === 'schema'
+            ? Format.URL.annotations({ title: 'Record type' })
+            : QueryAST.Query.annotations({ title: 'Query' }),
+      });
+
+      if (mode === 'tag') {
+        return Schema.Struct({
+          ...base.fields,
+          target: Schema.optional(Schema.String.annotations({ title: 'Target Queue' })),
+        }).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(
+      () => ({
+        query: mode === 'schema' ? getTypenameFromQuery(view.query.ast) : view.query.ast,
+        target: queueTarget,
+      }),
+      [mode, view.query.ast, queueTarget],
+    );
+
+    const fieldMap = useMemo<FormFieldMap | undefined>(
+      () => (mode === 'tag' ? customFields({ types, tags }) : undefined),
+      [mode, types, tags],
+    );
+
+    // TODO(burdon): Check if mutable.
+    const handleAdd = useCallback(() => {
+      invariant(!readonly);
+      const field = projectionModel.createFieldProjection();
+      setExpandedField(field.id);
+    }, [projectionModel, readonly]);
+
+    const handleUpdate = useCallback(
+      (values: any) => {
+        requestAnimationFrame(() => {
+          const query = mode === 'schema' ? Query.select(Filter.typename(values.query)).ast : values.query;
+          onQueryChanged?.(query, values.target);
+        });
+      },
+      [onQueryChanged, view, queueTarget, mode],
+    );
+
+    const handleDelete = useCallback(
+      (fieldId: string) => {
+        invariant(!readonly);
+        if (fieldId === expandedField) {
+          setExpandedField(undefined);
+        }
+
+        onDelete?.(fieldId);
+      },
+      [expandedField, onDelete, readonly],
+    );
+
+    return (
+      <div role='none' className={mx(classNames)}>
+        {/* If readonly is set, then the callout is not needed. */}
+        {schemaReadonly && !readonly && (
+          <Callout.Root valence='info' classNames='mlb-cardSpacingBlock'>
+            <Callout.Title>{t('system schema description')}</Callout.Title>
+          </Callout.Root>
+        )}
+
+        {/* TODO(burdon): Is the form read-only or just the schema? */}
+        <Form.Root schema={viewSchema} values={viewValues} fieldMap={fieldMap} autoSave onSave={handleUpdate}>
+          <Form.FieldSet />
+
+          <FormFieldLabel label={t('fields label')} asChild />
+          <FieldList
+            schema={schema}
+            view={view}
+            registry={registry}
+            readonly={readonly}
+            showHeading={showHeading}
+            onDelete={handleDelete}
+          />
+        </Form.Root>
+
+        {!readonly && !expandedField && (
+          <div role='none' className='mlb-cardSpacingBlock'>
+            <IconButton
+              icon='ph--plus--regular'
+              label={t('add property button label')}
+              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>
+    );
+  },
+);
+
+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);
+
   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, view.projection]);
-  const [expandedField, setExpandedField] = useState<FieldType['id']>();
 
-  const serializedQuery = Match.value(kind).pipe(
-    Match.when('basic', () => typenameFromQuery(view.query)),
-    Match.when('advanced', () => {
-      if (view.query.type !== 'select') {
-        return '';
-      }
+    // Use createEchoChangeCallback for mutable schemas (EchoSchema), otherwise use direct mutation.
+    const change =
+      schema instanceof EchoSchema
+        ? createEchoChangeCallback(view, schema)
+        : createDirectChangeCallback(view.projection, jsonSchema);
 
-      const serializer = new QuerySerializer();
-      return serializer.serialize(createExpression(view.query.filter));
-    }),
-    Match.exhaustive,
-  );
+    const model = new ProjectionModel({
+      registry: atomRegistry,
+      view,
+      baseSchema: jsonSchema,
+      change,
+    });
 
-  const viewSchema = useMemo(() => {
-    return Schema.Struct({
-      query:
-        kind === 'basic'
-          ? Format.URL.annotations({ title: 'Record type' })
-          : Schema.String.annotations({ title: 'Query' }),
-    }).pipe(Schema.mutable);
-  }, [kind]);
-  // TODO(burdon): Need to warn user of possible consequences of editing.
-  // TODO(burdon): Settings should have domain name owned by user.
-  const viewValues = useMemo(() => ({ query: serializedQuery }), [serializedQuery]);
+    return model;
+  }, [atomRegistry, schema, view]);
+
+  const [expandedField, setExpandedField] = useState<FieldType['id']>();
 
   const handleToggleField = useCallback(
     (field: FieldType) => {
@@ -100,26 +249,6 @@ export const ViewEditor = ({
     [readonly],
   );
 
-  // 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(
-    ({ query }: Schema.Schema.Type<typeof viewSchema>) => {
-      invariant(!readonly);
-      requestAnimationFrame(() => {
-        if (serializedQuery !== query && !readonly) {
-          onQueryChanged?.(query);
-        }
-      });
-    },
-    [serializedQuery, onQueryChanged, readonly],
-  );
-
   const handleDelete = useCallback(
     (fieldId: string) => {
       invariant(!readonly);
@@ -139,7 +268,9 @@ export const ViewEditor = ({
       const fields = [...view.projection.fields];
       const [moved] = fields.splice(fromIndex, 1);
       fields.splice(toIndex, 0, moved);
-      view.projection.fields = fields;
+      Obj.change(view, (v) => {
+        v.projection.fields = fields;
+      });
     },
     [view.projection.fields, readonly],
   );
@@ -162,81 +293,42 @@ export const ViewEditor = ({
     [projectionModel],
   );
 
-  const custom: Partial<Record<string, InputComponent>> = useMemo(
-    () =>
-      kind === 'advanced'
-        ? {
-            ['query' satisfies keyof Schema.Schema.Type<typeof viewSchema>]: (props: InputProps) => {
-              const handleChange = useCallback(
-                (text: string) => props.onValueChange('string', text),
-                [props.onValueChange],
-              );
-
-              // TODO(wittjosiah): Add label & input styles.
-              return <QueryEditor space={space} initialValue={props.getValue()} onChange={handleChange} />;
-            },
-          }
-        : {},
-    [],
-  );
-
   return (
-    <div role='none' className={mx(classNames)}>
-      {schemaReadonly && (
-        <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))}
-                        />
-                        {/* TODO(burdon): Remove unless implement undo. */}
+    <List.Root<FieldType>
+      items={view.projection.fields as FieldType[]}
+      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 || schemaReadonly} />
+                    <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.getFields().length <= 1)}
+                      onClick={() => (hidden ? handleShow(field.path) : handleHide(field.id))}
+                    />
+                    {!readonly && (
+                      <>
                         <List.ItemDeleteButton
                           label={t('delete field label')}
                           autoHide={false}
@@ -247,43 +339,50 @@ export const ViewEditor = ({
                         <IconButton
                           iconOnly
                           variant='ghost'
-                          label={t('toggle expand label', { ns: 'os' })}
+                          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 && (
-                        <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 && (
-        <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>
+                  {expandedField === field.id && !readonly && (
+                    <div role='none' className='col-span-5 mbs-1 mbe-1 border border-separator rounded-md'>
+                      <FieldEditor
+                        readonly={readonly || schemaReadonly}
+                        registry={registry}
+                        projection={projectionModel}
+                        field={field}
+                        onSave={handleClose}
+                      />
+                    </div>
+                  )}
+                </List.Item>
+              );
+            })}
+          </div>
+        </>
       )}
-    </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 (
+      <Input.Root>
+        <FormFieldLabel readonly={readonly} label={label} />
+        <QueryForm initialQuery={getValue()} types={types} tags={tags} onChange={handleChange} />
+      </Input.Root>
+    );
+  },
+});

package/src/components/index.ts

@@ -5,4 +5,5 @@
 export * from './ControlSection';
 export * from './FieldEditor';
 export * from './Form';
+export * from './ObjectPicker';
 export * from './ViewEditor';

package/src/components/testing.tsx

@@ -5,25 +5,27 @@
 import React, { type PropsWithChildren } from 'react';
 
 import { type ThemedClassName } from '@dxos/react-ui';
-import { Card } from '@dxos/react-ui-stack';
+import { Card } from '@dxos/react-ui-mosaic';
 import { JsonFilter } from '@dxos/react-ui-syntax-highlighter';
-import { mx, textBlockWidth } from '@dxos/react-ui-theme';
+import { textBlockWidth } from '@dxos/ui-theme';
 
 type TestLayoutProps = ThemedClassName<PropsWithChildren<{ json?: any }>>;
 
 export const TestLayout = ({ classNames, children, json }: TestLayoutProps) => {
   return (
-    <div className='w-full h-full grid grid-cols-[1fr_1fr] gap-2 overflow-hidden'>
-      <div className={mx('p-4 justify-center overflow-y-auto', classNames)}>{children}</div>
-      <JsonFilter data={json} classNames='w-full text-xs' testId='debug' />
+    <div className='is-full bs-full grid grid-cols-[1fr_1fr] p-4 gap-4 overflow-hidden'>
+      <TestPanel classNames={['flex flex-col bs-full overflow-y-auto', classNames]}>{children}</TestPanel>
+      <TestPanel classNames={'overflow-hidden'}>
+        <JsonFilter testId='debug' data={json} classNames='bs-full text-xs' />
+      </TestPanel>
     </div>
   );
 };
 
 type TestPanelProps = ThemedClassName<PropsWithChildren>;
 
-export const TestPanel = ({ classNames, children }: TestPanelProps) => {
-  return <Card.StaticRoot classNames={[textBlockWidth, classNames]}>{children}</Card.StaticRoot>;
+const TestPanel = ({ classNames, children }: TestPanelProps) => {
+  return <Card.Root classNames={['bs-full overflow-y-auto', textBlockWidth, classNames]}>{children}</Card.Root>;
 };
 
 // Symbol for accessing debug objects in tests.

package/src/hooks/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './useForm';
-export * from './useRefQueryLookupHandler';
-export * from './useQueryRefOptions';
+export * from './useFormHandler';
+export * from './useKeyHandler';