@dxos/react-ui-form 0.8.4-main.ead640a → 0.8.4-main.effb148878

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/field.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { FormatEnum, GeoLocation, TypeEnum } from '@dxos/echo/internal';
+import { Format, GeoLocation, TypeEnum } from '@dxos/echo/internal';
 import { type ValidationError } from '@dxos/schema';
 
 /**
@@ -13,7 +13,7 @@ import { type ValidationError } from '@dxos/schema';
  */
 export type ParseProps = {
   type?: TypeEnum;
-  format?: FormatEnum;
+  format?: Format.TypeFormat;
   value: any;
 };
 
@@ -57,31 +57,31 @@ export const parseValue = ({ type, format, value }: ParseProps) => {
   }
 
   switch (format) {
-    case FormatEnum.Boolean:
+    case Format.TypeFormat.Boolean:
       return parseScalar(TypeEnum.Boolean);
 
-    case FormatEnum.Number:
-    case FormatEnum.Percent:
-    case FormatEnum.Currency:
+    case Format.TypeFormat.Number:
+    case Format.TypeFormat.Percent:
+    case Format.TypeFormat.Currency:
       return parseScalar(TypeEnum.Number);
 
-    case FormatEnum.String:
-    case FormatEnum.Markdown: {
+    case Format.TypeFormat.String:
+    case Format.TypeFormat.Markdown: {
       return parseScalar(TypeEnum.String);
     }
 
-    case FormatEnum.Ref:
-      throw new Error(`unexpected format: ${FormatEnum.Ref}`);
+    case Format.TypeFormat.Ref:
+      throw new Error(`unexpected format: ${Format.TypeFormat.Ref}`);
 
-    case FormatEnum.DateTime:
-    case FormatEnum.Date:
-    case FormatEnum.Time:
-    case FormatEnum.Timestamp: {
+    case Format.TypeFormat.DateTime:
+    case Format.TypeFormat.Date:
+    case Format.TypeFormat.Time:
+    case Format.TypeFormat.Timestamp: {
       const date = new Date(value as string | number);
       return isNaN(date.getTime()) ? null : date;
     }
 
-    case FormatEnum.GeoPoint: {
+    case Format.TypeFormat.GeoPoint: {
       // Parse string in format "lat,long" to GeoPoint [longitude, latitude].
       if (typeof value === 'string') {
         // Only keep digits, decimal points, minus signs, and commas.
@@ -108,23 +108,23 @@ export const parseValue = ({ type, format, value }: ParseProps) => {
 // TODO(burdon): Type and format.
 export type CellClassesForFieldTypeProps = {
   type?: TypeEnum;
-  format?: FormatEnum;
+  format?: Format.TypeFormat;
 };
 
 export const cellClassesForFieldType = ({ type, format }: CellClassesForFieldTypeProps): string[] | undefined => {
   switch (format || type) {
-    case FormatEnum.Markdown:
+    case Format.TypeFormat.Markdown:
       return undefined;
-    case FormatEnum.Time:
-    case FormatEnum.Timestamp:
-    case FormatEnum.DateTime:
-    case FormatEnum.Date:
-    case FormatEnum.Duration:
+    case Format.TypeFormat.Time:
+    case Format.TypeFormat.Timestamp:
+    case Format.TypeFormat.DateTime:
+    case Format.TypeFormat.Date:
+    case Format.TypeFormat.Duration:
       return ['font-mono', 'text-right'];
-    case FormatEnum.Currency:
+    case Format.TypeFormat.Currency:
       return ['text-right'];
-    case FormatEnum.JSON:
-    case FormatEnum.DID:
+    case Format.TypeFormat.JSON:
+    case Format.TypeFormat.DID:
       return ['font-mono'];
     case TypeEnum.Number:
     case TypeEnum.Boolean:

package/src/util/formatting.ts

@@ -4,11 +4,11 @@
 
 import { format as formatDate } from 'date-fns/format';
 
-import { FormatEnum, GeoLocation, TypeEnum } from '@dxos/echo/internal';
+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

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

package/src/util/properties.test.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { DXN, 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.makeObject(DXN.make('org.dxos.test.keywordHidden', '0.1.0')));
+
+    const names = getFormProperties(Type.getSchema(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.makeObject(DXN.make('org.dxos.test.structHidden', '0.1.0')));
+
+    const names = getFormProperties(Type.getSchema(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.makeObject(DXN.make('org.dxos.test.arrayHidden', '0.1.0')));
+
+    const names = getFormProperties(Type.getSchema(TestSchema).ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('context');
+  });
+
+  test('filters out optional fields annotated FormInputAnnotation.set(false)', ({ expect }) => {
+    // Regression: optional fields' `prop.type` is the union `T | undefined`; the
+    // annotation lives on the inner `T`. Without unwrapping, the filter would
+    // miss the annotation and the hidden field would render. Covers the
+    // conventional pattern `Schema.X.pipe(FormInputAnnotation.set(false), Schema.optional)`.
+    const TestSchema = Schema.Struct({
+      name: Schema.optional(Schema.String),
+      userId: Schema.String.pipe(Annotation.FormInputAnnotation.set(false), Schema.optional),
+    }).pipe(Type.makeObject(DXN.make('org.dxos.test.optionalHidden', '0.1.0')));
+
+    const names = getFormProperties(Type.getSchema(TestSchema).ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('userId');
+  });
+
+  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.makeObject(DXN.make('org.dxos.test.chainedHidden', '0.1.0')));
+
+    const names = getFormProperties(Type.getSchema(TestSchema).ast).map((prop) => prop.name);
+    expect(names).toContain('name');
+    expect(names).not.toContain('hidden');
+  });
+});

package/src/util/properties.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+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.
+ *
+ * For optional fields, `prop.type` is the union `T | undefined` — the annotation
+ * lives on the inner `T`. Unwrap before reading so that the conventional pattern
+ * `Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional)` works.
+ */
+export const getFormProperties = (ast: SchemaAST.AST): SchemaProperty[] => {
+  const hidden = new Set(
+    SchemaAST.getPropertySignatures(ast)
+      .filter((prop) => {
+        // Unwrap `T | undefined` for optional fields so the inner annotation is visible.
+        const type =
+          prop.isOptional && SchemaAST.isUnion(prop.type)
+            ? (prop.type.types.find((t) => t._tag !== 'UndefinedKeyword') ?? prop.type)
+            : prop.type;
+        return Annotation.FormInputAnnotation.getFromAst(type).pipe(Option.getOrElse(() => true)) === false;
+      })
+      .map((prop) => prop.name),
+  );
+  return getProperties(ast).filter((prop) => !hidden.has(prop.name));
+};

package/src/util/refs.ts

@@ -4,35 +4,33 @@
 
 import type * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatEnum, ReferenceAnnotationId } from '@dxos/echo/internal';
-import { findAnnotation } from '@dxos/effect';
-import { type SchemaProperty } from '@dxos/schema';
-
-import { findArrayElementType } from './schema';
+import { Ref } from '@dxos/echo';
+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 = (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) {
-        return { ast: elementType, isArray: true };
+      if (Ref.isRefType(elementType)) {
+        const typename = findAnnotation<ReferenceAnnotationValue>(elementType, ReferenceAnnotationId)?.typename;
+        return { ast: elementType, isArray: true, typename };
       }
     }
   }
 
+  // Direct reference.
+  if (Ref.isRefType(ast)) {
+    const typename = findAnnotation<ReferenceAnnotationValue>(ast, ReferenceAnnotationId)?.typename;
+    return { ast, isArray: false, typename };
+  }
+
   return undefined;
 };

package/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+//
+// Copyright 2026 DXOS.org
+//
+
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}

package/dist/types/src/components/ControlSection/ControlSection.d.ts

@@ -1,23 +0,0 @@
-import React, { type ComponentPropsWithoutRef, type PropsWithChildren } from 'react';
-import { type ButtonProps, type Label, type ThemedClassName } from '@dxos/react-ui';
-export type ControlPageProps = ThemedClassName<ComponentPropsWithoutRef<'div'>>;
-export declare const ControlPage: ({ children, classNames, ...props }: ControlPageProps) => React.JSX.Element;
-export type ControlSectionProps = PropsWithChildren<{
-    title: Label;
-    description?: Label;
-}>;
-export declare const ControlSection: ({ title, description, children }: ControlSectionProps) => React.JSX.Element;
-export declare const ControlSectionHeading: ({ title, description }: Omit<ControlSectionProps, "children">) => React.JSX.Element;
-export declare const ControlGroupButton: ({ classNames, ...props }: ButtonProps) => React.JSX.Element;
-export type ControlGroupProps = ThemedClassName<PropsWithChildren>;
-export declare const ControlGroup: ({ children, classNames }: ControlGroupProps) => React.JSX.Element;
-export declare const ControlFrame: ({ children }: ControlGroupProps) => React.JSX.Element;
-export declare const controlItemClasses: string;
-export type ControlItemProps = PropsWithChildren<{
-    title: Label;
-    description?: Label;
-}>;
-export declare const ControlItem: ({ title, description, children }: ControlItemProps) => React.JSX.Element;
-export declare const ControlItemInput: ({ title, description, children }: ControlItemProps) => React.JSX.Element;
-export declare const ControlFrameItem: ({ title, description, children }: ControlItemProps) => React.JSX.Element;
-//# sourceMappingURL=ControlSection.d.ts.map

package/dist/types/src/components/ControlSection/ControlSection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ControlSection.d.ts","sourceRoot":"","sources":["../../../../../src/components/ControlSection/ControlSection.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,KAAK,wBAAwB,EAAE,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAErF,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,KAAK,EACV,KAAK,eAAe,EAGrB,MAAM,gBAAgB,CAAC;AAMxB,MAAM,MAAM,gBAAgB,GAAG,eAAe,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC,CAAC;AAEhF,eAAO,MAAM,WAAW,GAAI,oCAAoC,gBAAgB,sBAQ/E,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;IAClD,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB,CAAC,CAAC;AAEH,eAAO,MAAM,cAAc,GAAI,kCAAkC,mBAAmB,sBAOnF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,wBAAwB,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,sBAYlG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,0BAA0B,WAAW,sBAEvE,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAAC;AAEnE,eAAO,MAAM,YAAY,GAAI,0BAA0B,iBAAiB,sBAWvE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,cAAc,iBAAiB,sBAU3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAK7B,CAAC;AAKH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;IAC/C,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB,CAAC,CAAC;AAEH,eAAO,MAAM,WAAW,GAAI,kCAAkC,gBAAgB,sBAY7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,kCAAkC,gBAAgB,sBAoBlF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,kCAAkC,gBAAgB,sBAUlF,CAAC"}

package/dist/types/src/components/ControlSection/ControlSection.stories.d.ts

@@ -1,84 +0,0 @@
-import { type StoryObj } from '@storybook/react-vite';
-import React from 'react';
-declare const meta: {
-    title: string;
-    component: ({ title, description, children }: import("./ControlSection").ControlSectionProps) => React.JSX.Element;
-    render: (args: {
-        title: import("@dxos/react-ui").Label;
-        description?: import("@dxos/react-ui").Label;
-    } & {
-        children?: React.ReactNode | undefined;
-    }) => React.JSX.Element;
-    decorators: import("@storybook/react").Decorator[];
-    parameters: {
-        layout: string;
-        translations: [{
-            readonly 'en-US': {
-                readonly "react-ui-form": {
-                    readonly 'fields label': "Fields";
-                    readonly 'hidden fields label': "Hidden Fields";
-                    readonly 'empty readonly ref field label': "(none)";
-                    readonly 'button add property': "Add property";
-                    readonly 'field property label': "Property";
-                    readonly 'field property placeholder': "Property name";
-                    readonly 'field format label': "Type";
-                    readonly 'field path label': "Field path";
-                    readonly 'add field': "Add field";
-                    readonly 'delete field': "Delete field";
-                    readonly 'field limit reached': "Maximum number of fields reached";
-                    readonly 'boolean input true value': "Yes";
-                    readonly 'boolean input false value': "No";
-                    readonly 'show field label': "Show field";
-                    readonly 'hide field label': "Hide field";
-                    readonly 'delete field label': "Delete field";
-                    readonly 'ref field combobox input placeholder': "Search…";
-                    readonly 'ref field placeholder_one': "Select…";
-                    readonly 'ref field placeholder_other': "Select items…";
-                    readonly 'button cancel': "Cancel";
-                    readonly 'button save': "Save";
-                    readonly 'format boolean': "Boolean";
-                    readonly 'format currency': "Currency";
-                    readonly 'format date': "Date";
-                    readonly 'format date-time': "DateTime";
-                    readonly 'format did': "DID";
-                    readonly 'format duration': "Duration";
-                    readonly 'format dxn': "DXN";
-                    readonly 'format email': "Email";
-                    readonly 'format formula': "Formula";
-                    readonly 'format hostname': "Hostname";
-                    readonly 'format integer': "Integer";
-                    readonly 'format json': "JSON";
-                    readonly 'format lnglat': "Geopoint";
-                    readonly 'format markdown': "Markdown";
-                    readonly 'format percent': "Percent";
-                    readonly 'format ref': "Reference";
-                    readonly 'format regex': "RegExp";
-                    readonly 'format string': "String";
-                    readonly 'format single-select': "Select";
-                    readonly 'format multi-select': "Multi-select";
-                    readonly 'format text': "Long text";
-                    readonly 'format time': "Time";
-                    readonly 'format timestamp': "Timestamp";
-                    readonly 'format user': "User";
-                    readonly 'format number': "Number";
-                    readonly 'format uri': "URI";
-                    readonly 'format url': "URL";
-                    readonly 'format uuid': "UUID";
-                    readonly 'latitude label': "Latitude";
-                    readonly 'longitude label': "Longitude";
-                    readonly 'select option label': "Label";
-                    readonly 'select option label placeholder': "Option label";
-                    readonly 'select option color': "Color";
-                    readonly 'select option delete': "Delete";
-                    readonly 'select option add': "Add option";
-                    readonly 'system schema title': "System record type";
-                    readonly 'system schema description': "This is a system record type and cannot be modified, though the view can still be configured.";
-                };
-            };
-        }];
-    };
-};
-export default meta;
-type Story = StoryObj<typeof meta>;
-export declare const Default: Story;
-//# sourceMappingURL=ControlSection.stories.d.ts.map

package/dist/types/src/components/ControlSection/ControlSection.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ControlSection.stories.d.ts","sourceRoot":"","sources":["../../../../../src/components/ControlSection/ControlSection.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,MAAM,OAAO,CAAC;AAQ1B,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa6B,CAAC;AAExC,eAAe,IAAI,CAAC;AAEpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnC,eAAO,MAAM,OAAO,EAAE,KAKrB,CAAC"}

package/dist/types/src/components/ControlSection/index.d.ts

@@ -1,2 +0,0 @@
-export * from './ControlSection';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/components/ControlSection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ControlSection/index.ts"],"names":[],"mappings":"AAIA,cAAc,kBAAkB,CAAC"}

package/dist/types/src/components/Form/ArrayField.d.ts

@@ -1,16 +0,0 @@
-import React from 'react';
-import { type SchemaProperty } from '@dxos/schema';
-import { type ComponentLookup } from './Form';
-import { type FormFieldProps } from './FormContent';
-import { type FormInputStateProps } from './FormContext';
-import { type InputComponent } from './Input';
-type ArrayFieldProps = {
-    property: SchemaProperty<any>;
-    inputProps: FormInputStateProps;
-    path?: (string | number)[];
-    Custom?: Partial<Record<string, InputComponent>>;
-    lookupComponent?: ComponentLookup;
-} & Pick<FormFieldProps, 'readonly'>;
-export declare const ArrayField: ({ property, readonly, path, inputProps, Custom, lookupComponent }: ArrayFieldProps) => React.JSX.Element | null;
-export {};
-//# sourceMappingURL=ArrayField.d.ts.map

package/dist/types/src/components/Form/ArrayField.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ArrayField.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/ArrayField.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAKrD,OAAO,EAAE,KAAK,cAAc,EAAuB,MAAM,cAAc,CAAC;AAKxE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,KAAK,mBAAmB,EAAiB,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,KAAK,cAAc,EAAe,MAAM,SAAS,CAAC;AAE3D,KAAK,eAAe,GAAG;IACrB,QAAQ,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IAC9B,UAAU,EAAE,mBAAmB,CAAC;IAChC,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;IACjD,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,GAAG,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;AAErC,eAAO,MAAM,UAAU,GAAI,mEAAmE,eAAe,6BA8F5G,CAAC"}

package/dist/types/src/components/Form/Defaults.d.ts

@@ -1,14 +0,0 @@
-import React from 'react';
-import { type InputProps } from './Input';
-export declare const TextInput: ({ type, label, inputOnly, readonly, placeholder, getStatus, getValue, onValueChange, onBlur, }: InputProps) => React.JSX.Element | null;
-export declare const NumberInput: ({ type, label, inputOnly, readonly, placeholder, getStatus, getValue, onValueChange, onBlur, }: InputProps) => React.JSX.Element | null;
-export declare const BooleanInput: ({ type, label, inputOnly, getStatus, getValue, onValueChange, readonly }: InputProps) => React.JSX.Element;
-export type SelectInputOptions = InputProps & {
-    options?: Array<{
-        value: string | number;
-        label?: string;
-    }>;
-};
-export declare const SelectInput: ({ type, label, inputOnly, readonly, placeholder, options, getStatus, getValue, onValueChange, }: SelectInputOptions) => React.JSX.Element | null;
-export declare const MarkdownInput: ({ type, label, inputOnly, readonly, placeholder, getStatus, getValue, onValueChange, onBlur, }: InputProps) => React.JSX.Element;
-//# sourceMappingURL=Defaults.d.ts.map

package/dist/types/src/components/Form/Defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Defaults.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/Defaults.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAyC,MAAM,OAAO,CAAC;AAM9D,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,SAAS,GAAI,gGAUvB,UAAU,6BAsBZ,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,gGAUzB,UAAU,6BAuBZ,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,0EAA0E,UAAU,sBAgBhH,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG;IAC5C,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,iGAUzB,kBAAkB,6BAiCpB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,gGAU3B,UAAU,sBA8CZ,CAAC"}

package/dist/types/src/components/Form/FormActions.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-export type FormOuterSpacing = boolean | 'blockStart-0' | 'scroll-fields';
-export type FormActionsProps = {
-    readonly?: boolean;
-    onCancel?: () => void;
-    outerSpacing?: FormOuterSpacing;
-};
-export declare const FormActions: ({ readonly, onCancel, outerSpacing }: FormActionsProps) => React.JSX.Element;
-//# sourceMappingURL=FormActions.d.ts.map

package/dist/types/src/components/Form/FormActions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormActions.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/FormActions.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAU1B,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,cAAc,GAAG,eAAe,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,sCAA6C,gBAAgB,sBA+BxF,CAAC"}