@strato-admin/cloudscape 0.1.0

package/dist/field/DateField.js

@@ -0,0 +1,17 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useFieldValue, useRecordContext, useLocale } from '@strato-admin/core';
+import RecordLink from '../RecordLink';
+const DateField = (props) => {
+    const { source, record: recordProp, emptyText, options, locales, link } = props;
+    const record = useRecordContext({ record: recordProp });
+    const value = useFieldValue({ source: source, record });
+    const currentLocale = useLocale();
+    const hasValue = value !== null && value !== undefined && value !== '';
+    if (!hasValue) {
+        return _jsx(_Fragment, { children: emptyText ?? null });
+    }
+    const dateValue = value instanceof Date ? value : new Date(value);
+    const formattedValue = new Intl.DateTimeFormat(locales || currentLocale, options).format(dateValue);
+    return _jsx(RecordLink, { link: link, children: formattedValue });
+};
+export default DateField;

package/dist/field/IdField.d.ts

@@ -0,0 +1,17 @@
+import { type RaRecord } from '@strato-admin/core';
+import { type TextFieldProps } from './TextField';
+export type IdFieldProps<RecordType extends RaRecord = RaRecord> = TextFieldProps<RecordType>;
+/**
+ * A field that displays the record's ID.
+ *
+ * Defaults to:
+ * - source="id"
+ * - input={false} (hidden in forms)
+ * - link="show" if the resource has a show page
+ *
+ * @example
+ * <IdField />
+ * <IdField source="identifier" />
+ */
+declare const IdField: <RecordType extends RaRecord = RaRecord>(props: IdFieldProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export default IdField;

package/dist/field/IdField.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useResourceDefinition } from '@strato-admin/core';
+import TextField from './TextField';
+/**
+ * A field that displays the record's ID.
+ *
+ * Defaults to:
+ * - source="id"
+ * - input={false} (hidden in forms)
+ * - link="show" if the resource has a show page
+ *
+ * @example
+ * <IdField />
+ * <IdField source="identifier" />
+ */
+const IdField = (props) => {
+    const { hasShow } = useResourceDefinition(props);
+    const { source = 'id', link = hasShow ? 'show' : undefined, input = false, ...rest } = props;
+    return (_jsx(TextField, { source: source, link: link, input: input, ...rest }));
+};
+export default IdField;

package/dist/field/NumberField.d.ts

@@ -0,0 +1,14 @@
+import { type RaRecord } from '@strato-admin/core';
+import { type FieldProps } from './types';
+export type NumberFieldProps<RecordType extends RaRecord = RaRecord> = FieldProps<RecordType> & {
+    /**
+     * Options for Intl.NumberFormat.
+     */
+    options?: Intl.NumberFormatOptions;
+    /**
+     * Locale(s) to use for formatting. Defaults to the current app locale.
+     */
+    locales?: string | string[];
+};
+declare const NumberField: <RecordType extends RaRecord = RaRecord>(props: NumberFieldProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export default NumberField;

package/dist/field/NumberField.js

@@ -0,0 +1,18 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useFieldValue, useRecordContext, useLocale } from '@strato-admin/core';
+import RecordLink from '../RecordLink';
+const NumberField = (props) => {
+    const { source, record: recordProp, emptyText, options, locales, link } = props;
+    const record = useRecordContext({ record: recordProp });
+    const value = useFieldValue({ source: source, record });
+    const currentLocale = useLocale();
+    const hasValue = value !== null && value !== undefined && value !== '';
+    if (!hasValue) {
+        return _jsx(_Fragment, { children: emptyText ?? null });
+    }
+    const numberValue = typeof value === 'string' ? parseFloat(value) : value;
+    const formattedValue = new Intl.NumberFormat(locales || currentLocale, options).format(numberValue);
+    return _jsx(RecordLink, { link: link, children: formattedValue });
+};
+NumberField.isNumberColumn = true;
+export default NumberField;

package/dist/field/ReferenceField.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import { type RaRecord } from '@strato-admin/core';
+import { type FieldProps } from './types';
+export type ReferenceFieldProps<RecordType extends RaRecord = RaRecord> = FieldProps<RecordType> & {
+    /**
+     * The resource name that this field refers to.
+     */
+    reference: string;
+    /**
+     * Optional custom representation of the related record. If not provided,
+     * the recordRepresentation of the referenced resource will be used.
+     */
+    children?: ReactNode;
+};
+declare const ReferenceField: <RecordType extends RaRecord = RaRecord>(props: ReferenceFieldProps<RecordType>) => import("react/jsx-runtime").JSX.Element | null;
+export default ReferenceField;

package/dist/field/ReferenceField.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { ReferenceFieldBase, useRecordContext, useGetRecordRepresentation, } from '@strato-admin/core';
+import RecordLink from '../RecordLink';
+const ReferenceField = (props) => {
+    const { source, reference, children, emptyText, record, link } = props;
+    if (!source) {
+        return null; // Or some fallback
+    }
+    return (_jsx(ReferenceFieldBase, { source: source, reference: reference, record: record, empty: _jsx(_Fragment, { children: emptyText ?? null }), children: _jsx(ReferenceFieldValue, { emptyText: emptyText, link: link, reference: reference, children: children }) }));
+};
+const ReferenceFieldValue = ({ children, emptyText, link, reference }) => {
+    const record = useRecordContext();
+    const getRecordRepresentation = useGetRecordRepresentation();
+    if (!record) {
+        return _jsx(_Fragment, { children: emptyText ?? null });
+    }
+    if (children) {
+        return (_jsx(RecordLink, { link: link, resource: reference, children: children }));
+    }
+    const representation = getRecordRepresentation(record);
+    return (_jsx(RecordLink, { link: link, resource: reference, children: representation ? String(representation) : (emptyText ?? null) }));
+};
+export default ReferenceField;

package/dist/field/ReferenceManyField.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+import { type RaRecord } from '@strato-admin/core';
+import { type FieldProps } from './types';
+export interface ReferenceManyFieldProps<RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord> extends FieldProps<RecordType> {
+    children?: ReactNode;
+    reference: string;
+    target: string;
+    filter?: any;
+    sort?: {
+        field: string;
+        order: 'ASC' | 'DESC';
+    };
+    perPage?: number;
+    page?: number;
+    fieldSchema?: ReactNode;
+    /**
+     * Element to display during loading.
+     */
+    loading?: ReactNode;
+    /**
+     * Element to display if there's no data.
+     */
+    empty?: ReactNode;
+    /**
+     * Element to display if there's an error.
+     */
+    error?: ReactNode;
+    /**
+     * Element to display if the application is offline.
+     */
+    offline?: ReactNode;
+    /**
+     * Debounce time for filtering.
+     */
+    debounce?: number;
+    /**
+     * Whether to synchronize the list with the URL.
+     * @default false
+     */
+    synchronizeWithLocation?: boolean;
+}
+/**
+ * Render related records to the current one.
+ *
+ * @example
+ * <ReferenceManyField reference="comments" target="post_id">
+ *     <Table title="Comments">
+ *         <Table.Column source="id" />
+ *         <Table.Column source="body" />
+ *         <Table.Column source="created_at" />
+ *     </Table>
+ * </ReferenceManyField>
+ */
+export declare const ReferenceManyField: <RecordType extends RaRecord = RaRecord, ReferenceRecordType extends RaRecord = RaRecord>(props: ReferenceManyFieldProps<RecordType, ReferenceRecordType>) => import("react/jsx-runtime").JSX.Element;
+export default ReferenceManyField;

package/dist/field/ReferenceManyField.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ReferenceManyFieldBase, ResourceSchemaProvider } from '@strato-admin/core';
+/**
+ * Render related records to the current one.
+ *
+ * @example
+ * <ReferenceManyField reference="comments" target="post_id">
+ *     <Table title="Comments">
+ *         <Table.Column source="id" />
+ *         <Table.Column source="body" />
+ *         <Table.Column source="created_at" />
+ *     </Table>
+ * </ReferenceManyField>
+ */
+export const ReferenceManyField = (props) => {
+    const { children, reference, fieldSchema, ...rest } = props;
+    return (_jsx(ReferenceManyFieldBase, { reference: reference, ...rest, children: _jsx(ResourceSchemaProvider, { resource: reference, fieldSchema: fieldSchema, children: children }) }));
+};
+export default ReferenceManyField;

package/dist/field/StatusIndicatorField.d.ts

@@ -0,0 +1,56 @@
+import { type StatusIndicatorProps } from '@cloudscape-design/components/status-indicator';
+import React from 'react';
+import { type RaRecord } from '@strato-admin/core';
+import { type FieldProps } from './types';
+export interface StatusIndicatorLabelProps {
+    /**
+     * The value to match against the field's value.
+     */
+    value: any;
+    /**
+     * The type of the status indicator for this value.
+     */
+    type: StatusIndicatorProps.Type;
+    /**
+     * Color override for the status indicator for this value.
+     */
+    color?: StatusIndicatorProps.Color;
+    /**
+     * The label to display. If not provided, the value will be used.
+     */
+    label?: React.ReactNode;
+}
+/**
+ * A declarative way to define status indicator mapping.
+ */
+export declare const StatusIndicatorLabel: (_: StatusIndicatorLabelProps) => null;
+export interface StatusIndicatorFieldProps<RecordType extends RaRecord = RaRecord> extends FieldProps<RecordType> {
+    /**
+     * The type of the status indicator.
+     * If provided as a string, it will be used for all values.
+     * If provided as a function, it will be called with the field value and the record.
+     * @default "info"
+     */
+    type?: StatusIndicatorProps.Type | ((value: any, record: RecordType) => StatusIndicatorProps.Type);
+    /**
+     * A mapping from field values to status indicator types.
+     */
+    mapping?: Record<string | number, StatusIndicatorProps.Type>;
+    /**
+     * Icon aria label for screen readers.
+     */
+    iconAriaLabel?: string;
+    /**
+     * Color override for the status indicator.
+     */
+    colorOverride?: StatusIndicatorProps.Color;
+    /**
+     * Declarative mapping using StatusIndicatorLabel children.
+     */
+    children?: React.ReactNode;
+}
+declare const StatusIndicatorField: {
+    <RecordType extends RaRecord = RaRecord<import("@strato-admin/ra-core").Identifier>>(props: StatusIndicatorFieldProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+    Label: (_: StatusIndicatorLabelProps) => null;
+};
+export default StatusIndicatorField;

package/dist/field/StatusIndicatorField.js

@@ -0,0 +1,48 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import StatusIndicator from '@cloudscape-design/components/status-indicator';
+import React from 'react';
+import { useFieldValue, useRecordContext, useTranslate } from '@strato-admin/core';
+import RecordLink from '../RecordLink';
+/**
+ * A declarative way to define status indicator mapping.
+ */
+export const StatusIndicatorLabel = (_) => null;
+const StatusIndicatorField = (props) => {
+    const { source, record: recordProp, emptyText, link, type, mapping, iconAriaLabel, colorOverride, children, } = props;
+    const record = useRecordContext({ record: recordProp });
+    const value = useFieldValue({ source: source, record });
+    const translate = useTranslate();
+    const hasValue = value !== null && value !== undefined && value !== '';
+    if (!hasValue) {
+        return _jsx(_Fragment, { children: emptyText ?? null });
+    }
+    // 1. Try to find mapping from children
+    const childrenArray = React.Children.toArray(children);
+    const matchingLabel = childrenArray.find((child) => child.props?.value === value);
+    let statusType = 'info';
+    let finalColorOverride = colorOverride;
+    let label = String(value);
+    if (matchingLabel) {
+        statusType = matchingLabel.props.type;
+        if (matchingLabel.props.color) {
+            finalColorOverride = matchingLabel.props.color;
+        }
+        if (matchingLabel.props.label) {
+            label = typeof matchingLabel.props.label === 'string'
+                ? translate(matchingLabel.props.label)
+                : matchingLabel.props.label;
+        }
+    }
+    else if (typeof type === 'function') {
+        statusType = type(value, record);
+    }
+    else if (type) {
+        statusType = type;
+    }
+    else if (mapping && value in mapping) {
+        statusType = mapping[value];
+    }
+    return (_jsx(RecordLink, { link: link, children: _jsx(StatusIndicator, { type: statusType, iconAriaLabel: iconAriaLabel, colorOverride: finalColorOverride, children: label }) }));
+};
+StatusIndicatorField.Label = StatusIndicatorLabel;
+export default StatusIndicatorField;

package/dist/field/TextField.d.ts

@@ -0,0 +1,5 @@
+import { type RaRecord } from '@strato-admin/core';
+import { type FieldProps } from './types';
+export type TextFieldProps<RecordType extends RaRecord = RaRecord> = FieldProps<RecordType>;
+declare const TextField: <RecordType extends RaRecord = RaRecord>(props: TextFieldProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export default TextField;

package/dist/field/TextField.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFieldValue, useRecordContext } from '@strato-admin/core';
+import RecordLink from '../RecordLink';
+const TextField = (props) => {
+    const { source, record: recordProp, emptyText, link } = props;
+    const record = useRecordContext({ record: recordProp });
+    const value = useFieldValue({ source: source, record });
+    const hasValue = value !== null && value !== undefined && value !== '';
+    return _jsx(RecordLink, { link: link, children: hasValue ? String(value) : (emptyText ?? null) });
+};
+export default TextField;

package/dist/field/index.d.ts

@@ -0,0 +1,23 @@
+export * from './types';
+export { default as StatusIndicatorField } from './StatusIndicatorField';
+export * from './StatusIndicatorField';
+export { default as TextField } from './TextField';
+export { default as IdField } from './IdField';
+export { default as NumberField } from './NumberField';
+export { default as CurrencyField } from './CurrencyField';
+export { default as DateField } from './DateField';
+export { default as BooleanField } from './BooleanField';
+export { default as BadgeField } from './BadgeField';
+export { default as ReferenceField } from './ReferenceField';
+export { default as ReferenceManyField } from './ReferenceManyField';
+export { default as ArrayField } from './ArrayField';
+export * from './TextField';
+export * from './IdField';
+export * from './NumberField';
+export * from './DateField';
+export * from './BooleanField';
+export * from './BadgeField';
+export * from './ReferenceField';
+export * from './ReferenceManyField';
+export * from './ArrayField';
+export * from './CurrencyField';

package/dist/field/index.js

@@ -0,0 +1,23 @@
+export * from './types';
+export { default as StatusIndicatorField } from './StatusIndicatorField';
+export * from './StatusIndicatorField';
+export { default as TextField } from './TextField';
+export { default as IdField } from './IdField';
+export { default as NumberField } from './NumberField';
+export { default as CurrencyField } from './CurrencyField';
+export { default as DateField } from './DateField';
+export { default as BooleanField } from './BooleanField';
+export { default as BadgeField } from './BadgeField';
+export { default as ReferenceField } from './ReferenceField';
+export { default as ReferenceManyField } from './ReferenceManyField';
+export { default as ArrayField } from './ArrayField';
+export * from './TextField';
+export * from './IdField';
+export * from './NumberField';
+export * from './DateField';
+export * from './BooleanField';
+export * from './BadgeField';
+export * from './ReferenceField';
+export * from './ReferenceManyField';
+export * from './ArrayField';
+export * from './CurrencyField';

package/dist/field/types.d.ts

@@ -0,0 +1,56 @@
+import { type ReactNode } from 'react';
+import { type BaseFieldProps, type RaRecord } from '@strato-admin/core';
+import { type RecordLinkType } from '../RecordLink';
+/**
+ * Common props for all field components in strato-cloudscape.
+ */
+export interface FieldProps<RecordType extends RaRecord = RaRecord> extends Omit<BaseFieldProps<RecordType>, 'source'> {
+    /**
+     * The property name in the record that should be displayed.
+     */
+    source?: string;
+    /**
+     * The label to display for this field. Usually inferred from the source.
+     */
+    label?: ReactNode;
+    /**
+     * Whether the field is sortable in a table.
+     * @default true
+     */
+    sortable?: boolean;
+    /**
+     * Whether to link the field to another page.
+     * - true: links to the 'edit' page of the current resource
+     * - 'edit' | 'show': links to the specified page type
+     * - string: a custom URL
+     * - function: (record, resource) => string
+     */
+    link?: RecordLinkType;
+    /**
+     * The text to display if the value is empty or null.
+     */
+    emptyText?: ReactNode;
+    /**
+     * Configuration for the inferred form input.
+     * - object: Props passed to the inferred Input component.
+     * - ReactElement: A specific Input component to use (escape hatch).
+     * - false: Excludes this field from forms.
+     */
+    input?: Record<string, any> | React.ReactElement | false;
+    /**
+     * Whether the field is required.
+     * This is used to automatically add validation to the inferred input
+     * and potentially show warnings in display views.
+     */
+    isRequired?: boolean;
+    /**
+     * Additional text to help the user fill in the field.
+     * Passed to the inferred Input component's FormField.
+     */
+    description?: ReactNode;
+    /**
+     * Text describing constraints (e.g., "Must be between 1 and 100").
+     * Passed to the inferred Input component's FormField.
+     */
+    constraintText?: ReactNode;
+}

package/dist/field/types.js

@@ -0,0 +1 @@
+export {};

package/dist/form/Form.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { type FormProps as RaFormProps } from '@strato-admin/core';
+export interface FormProps extends Omit<RaFormProps, 'children'> {
+    children?: React.ReactNode;
+    include?: string[];
+    exclude?: string[];
+    toolbar?: React.ReactNode;
+}
+export declare const Form: {
+    ({ children, include, exclude, toolbar, ...props }: FormProps): import("react/jsx-runtime").JSX.Element;
+    Field: (props: import("..").FormFieldProps) => import("react/jsx-runtime").JSX.Element;
+};
+export default Form;

package/dist/form/Form.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Form as RaForm, useSaveContext, useInputSchema } from '@strato-admin/core';
+import CloudscapeForm from '@cloudscape-design/components/form';
+import SpaceBetween from '@cloudscape-design/components/space-between';
+import { SaveButton } from '../button/SaveButton';
+import { FormField } from '../input/FormField';
+export const Form = ({ children, include, exclude, toolbar, ...props }) => {
+    const saveContext = useSaveContext();
+    const schemaChildren = useInputSchema();
+    const finalChildren = React.useMemo(() => {
+        const baseChildren = children || schemaChildren;
+        let result = React.Children.toArray(baseChildren);
+        if (include) {
+            result = result.filter((child) => React.isValidElement(child) && include.includes(child.props.source));
+        }
+        else if (exclude) {
+            result = result.filter((child) => React.isValidElement(child) && !exclude.includes(child.props.source));
+        }
+        return result;
+    }, [children, schemaChildren, include, exclude]);
+    const handleSubmit = async (values, event) => {
+        if (props.onSubmit) {
+            return props.onSubmit(values, event);
+        }
+        if (saveContext?.save) {
+            return saveContext.save(values, event);
+        }
+    };
+    return (_jsx(RaForm, { ...props, onSubmit: handleSubmit, children: _jsx(CloudscapeForm, { actions: toolbar || (_jsx(SpaceBetween, { direction: "horizontal", size: "xs", children: _jsx(SaveButton, {}) })), children: _jsx(SpaceBetween, { direction: "vertical", size: "l", children: finalChildren }) }) }));
+};
+Form.Field = FormField;
+export default Form;

package/dist/form/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Form';
+export { ValidationError } from '@strato-admin/core';

package/dist/form/index.js

@@ -0,0 +1,2 @@
+export * from './Form';
+export { ValidationError } from '@strato-admin/core';

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from '@strato-admin/core';
+export * from './collection-hooks';
+export * from './list';
+export * from './detail';
+export * from './edit';
+export * from './create';
+export * from './field';
+export * from './input';
+export * from './form';
+export * from './layout';
+export * from './theme';
+export * from './button';
+export * from './Admin';
+export { default as RecordLink } from './RecordLink';
+export * from './RecordLink';
+export { Admin, type AdminProps } from './Admin';
+export { Form, type FormProps } from './form';
+export { List, type ListProps } from './list';
+export { Create, type CreateProps } from './create';
+export { Edit, type EditProps } from './edit';
+export { Show, type ShowProps } from './detail';
+export { type InputProps } from './input';

package/dist/index.js

@@ -0,0 +1,22 @@
+export * from '@strato-admin/core';
+export * from './collection-hooks';
+export * from './list';
+export * from './detail';
+export * from './edit';
+export * from './create';
+export * from './field';
+export * from './input';
+export * from './form';
+export * from './layout';
+export * from './theme';
+export * from './button';
+export * from './Admin';
+export { default as RecordLink } from './RecordLink';
+export * from './RecordLink';
+// Explicitly export themed components to resolve ambiguity with strato-core (ra-core) re-exports
+export { Admin } from './Admin';
+export { Form } from './form';
+export { List } from './list';
+export { Create } from './create';
+export { Edit } from './edit';
+export { Show } from './detail';

package/dist/input/AttributeEditor.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { InputProps } from './types';
+export interface AttributeEditorItemProps {
+    source: string;
+    label?: string | false;
+    field?: React.ComponentType<any>;
+    validate?: any;
+    defaultValue?: any;
+    children?: React.ReactNode;
+}
+export declare const Item: (_props: AttributeEditorItemProps) => null;
+export interface AttributeEditorProps extends Omit<InputProps, 'source'> {
+    source?: string;
+    children: React.ReactNode;
+    addButtonText?: string;
+    removeButtonText?: string;
+    empty?: React.ReactNode;
+    disableAddButton?: boolean;
+    hideAddButton?: boolean;
+}
+export declare const AttributeEditor: {
+    (props: AttributeEditorProps): import("react/jsx-runtime").JSX.Element;
+    Item: (_props: AttributeEditorItemProps) => null;
+};
+export default AttributeEditor;

package/dist/input/AttributeEditor.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useMemo } from 'react';
+import { useInput, RecordContextProvider, useResourceContext } from '@strato-admin/core';
+import { useFieldArray, useFormContext } from 'react-hook-form';
+import CloudscapeAttributeEditor from '@cloudscape-design/components/attribute-editor';
+import Box from '@cloudscape-design/components/box';
+import { FieldTitle } from './FieldTitle';
+import TextInput from './TextInput';
+import FormField from './FormField';
+import { FormFieldContext, useFormFieldContext } from './FormFieldContext';
+export const Item = (_props) => {
+    // This is a placeholder component used to collect props.
+    // The actual rendering is handled by the AttributeEditor.
+    return null;
+};
+export const AttributeEditor = (props) => {
+    const { children, label, source: sourceProp, validate, defaultValue, addButtonText = 'Add item', removeButtonText = 'Remove item', empty, disableAddButton, hideAddButton, ...rest } = props;
+    const { control } = useFormContext();
+    const contextValue = useFormFieldContext();
+    const resource = useResourceContext();
+    // Attempt to get source from context if not provided
+    const source = sourceProp || contextValue?.source || '';
+    const inputState = contextValue ??
+        useInput({
+            source,
+            validate,
+            defaultValue,
+            ...rest,
+        });
+    const { fields, append, remove } = useFieldArray({
+        control,
+        name: source,
+    });
+    const handleAdd = () => {
+        append({});
+    };
+    const handleRemove = (index) => {
+        remove(index);
+    };
+    const definition = useMemo(() => {
+        return React.Children.map(children, (child) => {
+            if (!React.isValidElement(child))
+                return null;
+            const childProps = child.props;
+            const childSource = childProps.source;
+            const childLabel = childProps.label;
+            const childValidate = childProps.validate;
+            // Determine if the field is required by checking validators
+            const isRequired = Array.isArray(childValidate)
+                ? childValidate.some((v) => v.isRequired)
+                : childValidate?.isRequired || childProps.isRequired;
+            return {
+                label: _jsx(FieldTitle, { label: childLabel, source: childSource, resource: resource, isRequired: isRequired }),
+                control: (item, index) => {
+                    const prefixedSource = `${source}.${index}.${childSource}`;
+                    let content;
+                    if (child.type === Item) {
+                        const { field: FieldComponent, children: itemChildren, validate: itemValidate, defaultValue: itemDefaultValue, } = childProps;
+                        content = itemChildren ? (_jsx(FormField, { source: prefixedSource, label: false, validate: itemValidate, defaultValue: itemDefaultValue, children: itemChildren })) : FieldComponent ? (_jsx(FieldComponent, { source: prefixedSource, label: false, validate: itemValidate, defaultValue: itemDefaultValue })) : (_jsx(TextInput, { source: prefixedSource, label: false, validate: itemValidate, defaultValue: itemDefaultValue }));
+                    }
+                    else {
+                        // Standard child (e.g. TextInput)
+                        content = React.cloneElement(child, {
+                            source: prefixedSource,
+                            label: false,
+                        });
+                    }
+                    return (_jsx(RecordContextProvider, { value: item, children: _jsx(Box, { padding: { top: 's' }, children: content }) }));
+                },
+            };
+        })?.filter(Boolean);
+    }, [children, source, resource]);
+    const inner = (_jsx(FormFieldContext.Provider, { value: undefined, children: _jsx(CloudscapeAttributeEditor, { items: fields, definition: definition, onAddButtonClick: handleAdd, onRemoveButtonClick: ({ detail: { itemIndex } }) => handleRemove(itemIndex), empty: empty || (_jsx(Box, { textAlign: "center", color: "inherit", children: "No items added yet." })), addButtonText: addButtonText, removeButtonText: removeButtonText, disableAddButton: disableAddButton, hideAddButton: hideAddButton }) }));
+    if (contextValue) {
+        return inner;
+    }
+    return (_jsx(FormFieldContext.Provider, { value: { ...inputState, source }, children: _jsx(FormField, { ...props, source: source, children: inner }) }));
+};
+AttributeEditor.Item = Item;
+export default AttributeEditor;