@dxos/react-ui-form 0.7.3-main.2dd075e → 0.7.3-staging.0905f03

package/src/components/Form/Input.tsx

@@ -4,23 +4,24 @@
 
 import React, { type FC, type PropsWithChildren } from 'react';
 
-import { type BaseObject, type FormatEnum, type PropertyKey } from '@dxos/echo-schema';
+import { type BaseObject, type FormatEnum } from '@dxos/echo-schema';
 import { type SimpleType } from '@dxos/effect';
 import { Icon, Tooltip } from '@dxos/react-ui';
 import { errorText } from '@dxos/react-ui-theme';
 
-import { type FormHandler } from '../../hooks';
+import { type FormPath, type FormHandler } from '../../hooks';
 
 /**
  * Props passed to input components.
  */
 export type InputProps<T extends BaseObject> = {
-  property: PropertyKey<T>;
+  property: FormPath<T>;
   type: SimpleType;
   format?: FormatEnum;
-  label: string;
+  label?: string;
   disabled?: boolean;
   placeholder?: string;
+  inputOnly?: boolean;
 } & Pick<FormHandler<T>, 'getStatus' | 'getValue' | 'onValueChange' | 'onBlur'>;
 
 /**

package/src/components/ViewEditor/ViewEditor.tsx

@@ -60,7 +60,7 @@ export const ViewEditor = ({
       name: view.name,
       // TODO(burdon): Need to warn user of possible consequences of editing.
       // TODO(burdon): Settings should have domain name owned by user.
-      typename: view.query.typename,
+      typename: view.query.type,
     };
   }, [view]);
 
@@ -68,7 +68,7 @@ export const ViewEditor = ({
     ({ name, typename }: ViewMetaType) => {
       requestAnimationFrame(() => {
         view.name = name;
-        view.query.typename = typename;
+        view.query.type = typename;
         schema.updateTypename(typename);
       });
     },

package/src/hooks/useForm.ts

@@ -9,6 +9,10 @@ import { type SimpleType, type S } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { validateSchema, type ValidationError } from '@dxos/schema';
+import { type MaybePromise } from '@dxos/util';
+
+// TODO(ZaymonFC): Where should this live?
+export type FormPath<T extends object = {}> = PropertyKey<T> | `${PropertyKey<T>}.${number}`;
 
 /**
  * Return type from `useForm` hook.
@@ -19,9 +23,9 @@ export type FormHandler<T extends BaseObject> = {
   //
 
   values: T;
-  errors: Record<PropertyKey<T>, string>;
-  touched: Record<PropertyKey<T>, boolean>;
-  changed: Record<PropertyKey<T>, boolean>;
+  errors: Record<FormPath<T>, string>;
+  touched: Record<FormPath<T>, boolean>;
+  changed: Record<FormPath<T>, boolean>;
   canSave: boolean;
   handleSave: () => void;
 
@@ -29,9 +33,9 @@ export type FormHandler<T extends BaseObject> = {
   // Form input component helpers.
   //
 
-  getStatus: (property: PropertyKey<T>) => { status?: 'error'; error?: string };
-  getValue: <V>(property: PropertyKey<T>) => V;
-  onValueChange: <V>(property: PropertyKey<T>, type: SimpleType, value: V) => void;
+  getStatus: (property: FormPath<T>) => { status?: 'error'; error?: string };
+  getValue: <V>(property: FormPath<T>) => V;
+  onValueChange: <V>(property: FormPath<T>, type: SimpleType, value: V) => void;
   onBlur: (event: FocusEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
 };
 
@@ -74,7 +78,7 @@ export interface FormOptions<T extends BaseObject> {
   /**
    * Called when the form is submitted and passes validation.
    */
-  onSave?: (values: T, meta: { changed: FormHandler<T>['changed'] }) => void;
+  onSave?: (values: T, meta: { changed: FormHandler<T>['changed'] }) => MaybePromise<void>;
 }
 
 /**
@@ -94,9 +98,10 @@ export const useForm = <T extends BaseObject>({
     setValues(initialValues);
   }, [initialValues]);
 
-  const [touched, setTouched] = useState<Record<PropertyKey<T>, boolean>>(createKeySet(initialValues, false));
-  const [changed, setChanged] = useState<Record<PropertyKey<T>, boolean>>(createKeySet(initialValues, false));
-  const [errors, setErrors] = useState<Record<PropertyKey<T>, string>>({} as Record<PropertyKey<T>, string>);
+  const [touched, setTouched] = useState<Record<FormPath<T>, boolean>>(createKeySet(initialValues, false));
+  const [changed, setChanged] = useState<Record<FormPath<T>, boolean>>(createKeySet(initialValues, false));
+  const [errors, setErrors] = useState<Record<FormPath<T>, string>>({} as Record<FormPath<T>, string>);
+  const [saving, setSaving] = useState(false);
 
   //
   // Validation.
@@ -132,15 +137,21 @@ export const useForm = <T extends BaseObject>({
    */
   const canSave = useMemo(
     () =>
+      !saving &&
       Object.keys(values).every(
         (property) => touched[property as PropertyKey<T>] === false || !errors[property as PropertyKey<T>],
       ),
-    [values, touched, errors],
+    [values, touched, errors, saving],
   );
 
-  const handleSave = useCallback(() => {
+  const handleSave = useCallback(async () => {
     if (validate(values)) {
-      onSave?.(values, { changed });
+      setSaving(true);
+      try {
+        await onSave?.(values, { changed });
+      } finally {
+        setSaving(false);
+      }
     }
   }, [values, validate, onSave]);
 
@@ -149,7 +160,7 @@ export const useForm = <T extends BaseObject>({
   //
 
   const getStatus = useCallback<FormHandler<T>['getStatus']>(
-    (property: PropertyKey<T>) => ({
+    (property: FormPath<T>) => ({
       status: errors[property] ? 'error' : undefined,
       error: errors[property] ? errors[property] : undefined,
     }),
@@ -157,12 +168,12 @@ export const useForm = <T extends BaseObject>({
   );
 
   // TODO(burdon): Use path to extract hierarchical value.
-  const getValue = <V>(property: PropertyKey<T>): V => {
-    return values[property] as V;
+  const getValue = <V>(property: FormPath<T>): V => {
+    return getByPath(values, property);
   };
 
   // TODO(burdon): Use path to set hierarchical value.
-  const onValueChange = (property: PropertyKey<T>, type: SimpleType, value: any) => {
+  const onValueChange = (property: FormPath<T>, type: SimpleType, value: any) => {
     let parsedValue = value;
     try {
       if (type === 'number') {
@@ -173,7 +184,7 @@ export const useForm = <T extends BaseObject>({
       parsedValue = undefined;
     }
 
-    const newValues = { ...values, [property]: parsedValue };
+    const newValues = setByPath(values, property, parsedValue);
     setValues(newValues);
     setChanged((prev) => ({ ...prev, [property]: true }));
     onValuesChanged?.(newValues);
@@ -219,19 +230,34 @@ export const useForm = <T extends BaseObject>({
   } satisfies FormHandler<T>;
 };
 
-const createKeySet = <T extends BaseObject, V>(obj: T, value: V): Record<PropertyKey<T>, V> => {
+const createKeySet = <T extends BaseObject, V>(obj: T, value: V): Record<FormPath<T>, V> => {
   invariant(obj);
-  return Object.keys(obj).reduce((acc, key) => ({ ...acc, [key]: value }), {} as Record<PropertyKey<T>, V>);
+  return Object.keys(obj).reduce((acc, key) => ({ ...acc, [key]: value }), {} as Record<FormPath<T>, V>);
 };
 
 const flatMap = <T extends BaseObject>(errors: ValidationError[]) => {
   return errors.reduce(
     (result, { path, message }) => {
       if (!(path in result)) {
-        result[path as PropertyKey<T>] = message;
+        result[path as FormPath<T>] = message;
       }
       return result;
     },
-    {} as Record<PropertyKey<T>, string>,
+    {} as Record<FormPath<T>, string>,
   );
 };
+
+// TODO(ZaymonFC): Move to util?
+const getByPath = <T extends object, V>(obj: T, path: FormPath<T>): V => {
+  const [key, index] = path.split('.');
+  return index === undefined ? (obj[key as keyof T] as V) : ((obj[key as keyof T] as any[])[parseInt(index)] as V);
+};
+
+const setByPath = <T extends object>(obj: T, path: FormPath<T>, value: any): T => {
+  const [key, index] = path.split('.');
+  const newValue =
+    index === undefined
+      ? value
+      : [...(obj[key as keyof T] as any[])].map((v, i) => (i === parseInt(index) ? value : v));
+  return { ...obj, [key]: newValue };
+};