@dxos/react-ui-form 0.8.4-main.c85a9c8dae → 0.8.4-main.d05539e30a

package/src/util/field-type.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { getAnnotation, isLiteralUnion } from '@dxos/effect';
+
+/**
+ * Detected field type for a schema property.
+ */
+export type SettingsFieldType = 'boolean' | 'string' | 'number' | 'select' | 'struct';
+
+export type SelectOption = {
+  value: string | number;
+  label?: string;
+};
+
+/**
+ * Detect the field type from an Effect Schema AST node.
+ */
+export const detectFieldType = (ast: SchemaAST.AST): SettingsFieldType | undefined => {
+  if (isLiteralUnion(ast)) {
+    return 'select';
+  }
+  if (SchemaAST.isTypeLiteral(ast)) {
+    return 'struct';
+  }
+
+  switch (ast._tag) {
+    case 'BooleanKeyword':
+      return 'boolean';
+    case 'StringKeyword':
+      return 'string';
+    case 'NumberKeyword':
+      return 'number';
+  }
+
+  return undefined;
+};
+
+/**
+ * Extract select options from a literal union AST node.
+ * Reads title annotations from individual literals for labels.
+ */
+export const getSelectOptionsFromAst = (ast: SchemaAST.AST): SelectOption[] | undefined => {
+  if (!isLiteralUnion(ast)) {
+    return undefined;
+  }
+
+  return (ast as SchemaAST.Union<SchemaAST.Literal>).types.flatMap((literalNode) => {
+    const value = literalNode.literal;
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      return [];
+    }
+    const title = getAnnotation<string>(SchemaAST.TitleAnnotationId, false)(literalNode);
+    const label = title ?? (typeof value === 'string' ? value.charAt(0).toUpperCase() + value.slice(1) : String(value));
+    return [{ value, label }];
+  });
+};

package/src/util/index.ts

@@ -3,6 +3,7 @@
 //
 
 export * from './field';
+export * from './field-type';
 export * from './formatting';
 export * from './properties';
 export * from './refs';

package/src/util/properties.test.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Annotation, JsonSchema, Type } from '@dxos/echo';
+
+import { getFormProperties } from './properties';
+
+describe('getFormProperties', () => {
+  test('filters out keyword fields annotated FormInputAnnotation.set(false)', ({ expect }) => {
+    const TestSchema = Schema.Struct({
+      name: Schema.optional(Schema.String),
+      hidden: Schema.String.pipe(Annotation.FormInputAnnotation.set(false)),
+    }).pipe(Type.object({ typename: 'org.dxos.test.keyword-hidden', version: '0.1.0' }));
+
+    const names = getFormProperties(TestSchema.ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('hidden');
+  });
+
+  test('filters out struct fields annotated FormInputAnnotation.set(false)', ({ expect }) => {
+    // Regression: JsonSchema fields are a Schema.Struct; encodedBoundAST strips
+    // annotations from non-keyword inner types, which previously bypassed the
+    // form-input filter (e.g., Routine.input).
+    const TestSchema = Schema.Struct({
+      name: Schema.optional(Schema.String),
+      schema: JsonSchema.JsonSchema.pipe(Annotation.FormInputAnnotation.set(false)),
+    }).pipe(Type.object({ typename: 'org.dxos.test.struct-hidden', version: '0.1.0' }));
+
+    const names = getFormProperties(TestSchema.ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('schema');
+  });
+
+  test('filters out array fields annotated FormInputAnnotation.set(false)', ({ expect }) => {
+    const TestSchema = Schema.Struct({
+      name: Schema.optional(Schema.String),
+      context: Schema.Array(Schema.Any).pipe(Annotation.FormInputAnnotation.set(false)),
+    }).pipe(Type.object({ typename: 'org.dxos.test.array-hidden', version: '0.1.0' }));
+
+    const names = getFormProperties(TestSchema.ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('context');
+  });
+
+  test('preserves annotation when chained with .annotations()', ({ expect }) => {
+    // Regression: `.pipe(FormInputAnnotation.set(false)).annotations({...})` must
+    // not lose the form-input annotation.
+    const TestSchema = Schema.Struct({
+      name: Schema.optional(Schema.String),
+      hidden: JsonSchema.JsonSchema.pipe(Annotation.FormInputAnnotation.set(false)).annotations({
+        description: 'Hidden field',
+      }),
+    }).pipe(Type.object({ typename: 'org.dxos.test.chained-hidden', version: '0.1.0' }));
+
+    const names = getFormProperties(TestSchema.ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('hidden');
+  });
+});

package/src/util/properties.ts

@@ -3,16 +3,27 @@
 //
 
 import * as Option from 'effect/Option';
-import type * as SchemaAST from 'effect/SchemaAST';
+import * 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.
+ *
+ * The `FormInputAnnotation` is read from the raw property signature's AST (before
+ * `encodedBoundAST` is applied by `getProperties`), because `encodedBoundAST` strips
+ * annotations from non-keyword inner types (e.g., `Schema.Struct`, `Schema.Array`).
+ * Without this, fields like `Routine.input` (a JsonSchema struct) annotated
+ * `FormInputAnnotation.set(false)` would still render in the form.
  */
 export const getFormProperties = (ast: SchemaAST.AST): SchemaProperty[] => {
-  return getProperties(ast).filter((prop) =>
-    Annotation.FormInputAnnotation.getFromAst(prop.type).pipe(Option.getOrElse(() => true)),
+  const hidden = new Set(
+    SchemaAST.getPropertySignatures(ast)
+      .filter(
+        (prop) => Annotation.FormInputAnnotation.getFromAst(prop.type).pipe(Option.getOrElse(() => true)) === false,
+      )
+      .map((prop) => prop.name),
   );
+  return getProperties(ast).filter((prop) => !hidden.has(prop.name));
 };

package/src/util/refs.ts

@@ -5,11 +5,13 @@
 import type * as SchemaAST from 'effect/SchemaAST';
 
 import { Ref } from '@dxos/echo';
-import { getArrayElementType, isArrayType } from '@dxos/effect';
+import { type ReferenceAnnotationValue, ReferenceAnnotationId } from '@dxos/echo/internal';
+import { findAnnotation, getArrayElementType, isArrayType } from '@dxos/effect';
 
 type RefProps = {
   ast: SchemaAST.AST;
   isArray: boolean;
+  typename?: string;
 };
 
 export const getRefProps = (ast: SchemaAST.AST): RefProps | undefined => {
@@ -18,14 +20,16 @@ export const getRefProps = (ast: SchemaAST.AST): RefProps | undefined => {
     const elementType = getArrayElementType(ast);
     if (elementType) {
       if (Ref.isRefType(elementType)) {
-        return { ast: elementType, isArray: true };
+        const typename = findAnnotation<ReferenceAnnotationValue>(elementType, ReferenceAnnotationId)?.typename;
+        return { ast: elementType, isArray: true, typename };
       }
     }
   }
 
   // Direct reference.
   if (Ref.isRefType(ast)) {
-    return { ast, isArray: false };
+    const typename = findAnnotation<ReferenceAnnotationValue>(ast, ReferenceAnnotationId)?.typename;
+    return { ast, isArray: false, typename };
   }
 
   return undefined;