@dxos/react-ui-form 0.8.3-staging.0fa589b → 0.8.4-main.1068cf700f

package/src/util/formatting.ts

@@ -4,11 +4,11 @@
 
 import { format as formatDate } from 'date-fns/format';
 
-import { FormatEnum, GeoLocation, TypeEnum } from '@dxos/echo-schema';
+import { Format, GeoLocation, TypeEnum } from '@dxos/echo/internal';
 
 type ValueFormatProps = {
   type: TypeEnum;
-  format?: FormatEnum | undefined;
+  format?: Format.TypeFormat | undefined;
   value: any;
   locale?: string | undefined;
 };
@@ -41,20 +41,20 @@ export const formatForDisplay = ({ type, format, value, locale = undefined }: Va
   }
 
   switch (format) {
-    case FormatEnum.Boolean: {
+    case Format.TypeFormat.Boolean: {
       return formatScalar(TypeEnum.Boolean);
     }
-    case FormatEnum.Number: {
+    case Format.TypeFormat.Number: {
       return formatScalar(TypeEnum.Number);
     }
-    case FormatEnum.String:
-    case FormatEnum.Ref: {
+    case Format.TypeFormat.String:
+    case Format.TypeFormat.Ref: {
       return formatScalar(TypeEnum.String);
     }
-    case FormatEnum.Percent: {
+    case Format.TypeFormat.Percent: {
       return `${(value as number) * 100}%`;
     }
-    case FormatEnum.Currency: {
+    case Format.TypeFormat.Currency: {
       // TODO(burdon): Get from property annotation.
       return (value as number).toLocaleString(locale, {
         style: 'currency',
@@ -63,28 +63,28 @@ export const formatForDisplay = ({ type, format, value, locale = undefined }: Va
         maximumFractionDigits: 2,
       });
     }
-    case FormatEnum.Date: {
+    case Format.TypeFormat.Date: {
       try {
         return formatDate(new Date(value as number), 'yyyy-MM-dd');
       } catch (error) {
         return 'Invalid Date';
       }
     }
-    case FormatEnum.Time: {
+    case Format.TypeFormat.Time: {
       try {
         return formatDate(new Date(value as number), 'HH:mm:ss');
       } catch (error) {
         return 'Invalid Time';
       }
     }
-    case FormatEnum.DateTime: {
+    case Format.TypeFormat.DateTime: {
       try {
         return formatDate(new Date(value as number), 'yyyy-MM-dd HH:mm:ss');
       } catch (error) {
         return 'Invalid DateTime';
       }
     }
-    case FormatEnum.GeoPoint: {
+    case Format.TypeFormat.GeoPoint: {
       if (value === null || value === undefined) {
         return '';
       }
@@ -125,31 +125,31 @@ export const formatForEditing = ({ type, format, value, locale = undefined }: Va
   }
 
   switch (format) {
-    case FormatEnum.Boolean:
-    case FormatEnum.Number:
-    case FormatEnum.String:
-    case FormatEnum.Ref: {
+    case Format.TypeFormat.Boolean:
+    case Format.TypeFormat.Number:
+    case Format.TypeFormat.String:
+    case Format.TypeFormat.Ref: {
       return formatScalar(type);
     }
-    case FormatEnum.Percent: {
+    case Format.TypeFormat.Percent: {
       return String(value * 100);
     }
-    case FormatEnum.Currency: {
+    case Format.TypeFormat.Currency: {
       return String(value);
     }
-    case FormatEnum.DateTime: {
+    case Format.TypeFormat.DateTime: {
       const date = new Date(value as number);
       return date.toISOString();
     }
-    case FormatEnum.Date: {
+    case Format.TypeFormat.Date: {
       const date = new Date(value as number);
       return date.toISOString().split('T')[0];
     }
-    case FormatEnum.Time: {
+    case Format.TypeFormat.Time: {
       const date = new Date(value as number);
       return date.toISOString().split('T')[1].split('.')[0];
     }
-    case FormatEnum.GeoPoint: {
+    case Format.TypeFormat.GeoPoint: {
       // Handle null or undefined
       if (value === null || value === undefined) {
         return '';

package/src/util/index.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './echo';
 export * from './field';
 export * from './formatting';
+export * from './properties';
 export * from './refs';
-export * from './schema';

package/src/util/properties.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import type * as SchemaAST from 'effect/SchemaAST';
+
+import { Annotation } from '@dxos/echo';
+import { type SchemaProperty, getProperties } from '@dxos/effect';
+
+/**
+ * Get the property types of an AST and filter out properties that are not form inputs.
+ */
+export const getFormProperties = (ast: SchemaAST.AST): SchemaProperty[] => {
+  return getProperties(ast).filter((prop) =>
+    Annotation.FormInputAnnotation.getFromAst(prop.type).pipe(Option.getOrElse(() => true)),
+  );
+};

package/src/util/refs.ts

@@ -2,37 +2,31 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type SchemaAST } from 'effect';
+import type * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatEnum, ReferenceAnnotationId } from '@dxos/echo-schema';
-import { findAnnotation } from '@dxos/effect';
-import { type SchemaProperty } from '@dxos/schema';
-
-import { findArrayElementType } from './schema';
+import { Ref } from '@dxos/echo';
+import { getArrayElementType, isArrayType } from '@dxos/effect';
 
 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 };
-  }
-
+export const getRefProps = (ast: SchemaAST.AST): RefProps | undefined => {
   // Array of references.
-  if (array) {
-    const elementType = findArrayElementType(ast);
+  if (isArrayType(ast)) {
+    const elementType = getArrayElementType(ast);
     if (elementType) {
-      const annotation = findAnnotation(elementType, ReferenceAnnotationId);
-      if (annotation) {
+      if (Ref.isRefType(elementType)) {
         return { ast: elementType, isArray: true };
       }
     }
   }
 
+  // Direct reference.
+  if (Ref.isRefType(ast)) {
+    return { ast, isArray: false };
+  }
+
   return undefined;
 };