@rebasepro/admin 0.2.1 → 0.2.4

package/src/form/EntityForm.tsx

@@ -36,15 +36,15 @@ import { getValueInPath, isObject, mergeDeep } from "@rebasepro/utils";
 import { useCollectionRegistryController, useSideEntityController, useCMSContext } from "../index";
 
 // extract touched values for nested touched trees and map to current values
-export function extractTouchedValues(values: any, touched: Record<string, boolean>): Record<string, any> {
-    let acc: Record<string, any> = {};
+export function extractTouchedValues(values: unknown, touched: Record<string, boolean>): Record<string, unknown> {
+    let acc: Record<string, unknown> = {};
     if (!touched || typeof touched !== "object") {
         return acc;
     }
 
     Object.entries(touched).forEach(([key, value]) => {
         if (value) {
-            acc = setIn(acc, key, getIn(values, key));
+            acc = setIn(acc, key, getIn(values, key)) as Record<string, unknown>;
         }
     })
 
@@ -60,20 +60,20 @@ export function extractTouchedValues(values: any, touched: Record<string, boolea
 /**
  * CheckIcon if a value is semantically empty (null, undefined, or empty string).
  */
-function isSemanticEmpty(v: any): boolean {
+function isSemanticEmpty(v: unknown): boolean {
     return v === null || v === undefined || v === "";
 }
 
-function removeEmptyContainers(obj: any): any {
+function removeEmptyContainers(obj: unknown): unknown {
     if (Array.isArray(obj)) {
         const cleaned = obj.map(removeEmptyContainers);
         // Keep arrays even if they contain only nulls/undefined — that's intentional data
         return cleaned;
     }
     if (obj && typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype) {
-        const result: Record<string, any> = {};
+        const result: Record<string, unknown> = {};
         for (const key of Object.keys(obj)) {
-            const cleaned = removeEmptyContainers(obj[key]);
+            const cleaned = removeEmptyContainers((obj as Record<string, unknown>)[key]);
             // Skip empty plain objects
             if (cleaned && typeof cleaned === "object" && !Array.isArray(cleaned)
                 && Object.getPrototypeOf(cleaned) === Object.prototype
@@ -281,7 +281,7 @@ export function EntityForm<M extends Record<string, unknown>>({
         return cleaned;
     }, [localChangesDataRaw, initialValues]);
 
-    const hasLocalChanges = !localChangesCleared && localChangesData && Object.keys(localChangesData).length > 0;
+    const hasLocalChanges = !localChangesCleared && !!localChangesData && Object.keys(localChangesData as object).length > 0;
 
     const internalFormex = useCreateFormex<M>({
         initialValues: initialValues as M,
@@ -729,7 +729,7 @@ export function EntityForm<M extends Record<string, unknown>>({
         throw Error("INTERNAL: Collection and path must be defined in form context");
     }
 
-    const EntityFormActionsRender = EntityFormActionsComponent as React.FC<any>;
+    const EntityFormActionsRender = EntityFormActionsComponent as React.FC<EntityFormActionsProps>;
 
     const dialogActions = <EntityFormActionsRender
         collection={collection}
@@ -737,14 +737,14 @@ export function EntityForm<M extends Record<string, unknown>>({
         entity={entity}
         layout={forceActionsAtTheBottom ? "bottom" : "responsive"}
         savingError={savingError}
-        formex={formex}
+        formex={formex as any}
         disabled={actionsDisabled}
         status={status}
         pluginActions={pluginFormActions ?? []}
         openEntityMode={openEntityMode}
         showDefaultActions={showDefaultActions}
         navigateBack={navigateBack}
-        formContext={formContext}
+        formContext={formContext as any}
     />;
 
     return (
@@ -844,18 +844,18 @@ export function getInitialEntityValues<M extends Record<string, unknown>>(
     }
 }
 
-export function zodToFormErrors(zodError: z.ZodError): Record<string, any> {
-    let errors: Record<string, any> = {};
+export function zodToFormErrors(zodError: z.ZodError): Record<string, string> {
+    let errors: Record<string, string> = {};
     for (const issue of zodError.issues) {
         const path = issue.path.join(".");
         if (path && !getIn(errors, path)) {
-            errors = setIn(errors, path, issue.message);
+            errors = setIn(errors, path, issue.message) as Record<string, string>;
         }
     }
     return errors;
 }
 
-function useOnAutoSave(autoSave: undefined | boolean, formex: FormexController<any>, lastSavedValues: any, save: (values: EntityValues<any>) => Promise<Entity<any> | void>) {
+function useOnAutoSave(autoSave: undefined | boolean, formex: FormexController<any>, lastSavedValues: React.MutableRefObject<any>, save: (values: EntityValues<any>) => Promise<Entity<any> | void>) {
     useEffect(() => {
         if (!autoSave) return;
         if (formex.values && !equal(formex.values, lastSavedValues.current)) {

package/src/form/EntityFormActions.tsx

@@ -97,11 +97,11 @@ type ActionsViewProps<M extends Record<string, unknown>> = {
     sideEntityController: SideEntityController,
     disabled: boolean,
     status: "new" | "existing" | "copy",
-    pluginActions?: any[],
+    pluginActions?: React.ReactNode[],
     openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
     navigateBack: () => void;
     formContext: FormContext,
-    formex: FormexController<any>;
+    formex: FormexController<Record<string, unknown>>;
     t: (key: string) => string;
     className?: string;
 };

package/src/form/PropertyFieldBinding.tsx

@@ -6,7 +6,7 @@ import { deepEqual as equal } from "fast-equals"
 
 import { resolveComponentRef } from "@rebasepro/core";
 
-import { Field, FieldProps as FormexFieldProps, getIn } from "@rebasepro/formex";
+import { Field, FormexFieldProps, getIn } from "@rebasepro/formex";
 
 ;
 import { ReadOnlyFieldBinding } from "./field_bindings/ReadOnlyFieldBinding";
@@ -42,7 +42,7 @@ import { ErrorBoundary } from "@rebasepro/ui";
  * @param autoFocus
  * @group Form custom fields
  */
-export const PropertyFieldBinding = React.memo(PropertyFieldBindingInternal, (a: PropertyFieldBindingProps<any>, b: PropertyFieldBindingProps<any>) => {
+export const PropertyFieldBinding = React.memo(PropertyFieldBindingInternal, (a: PropertyFieldBindingProps<Record<string, unknown>>, b: PropertyFieldBindingProps<Record<string, unknown>>) => {
     if (a.propertyKey !== b.propertyKey) {
         return false;
     }
@@ -70,21 +70,21 @@ export const PropertyFieldBinding = React.memo(PropertyFieldBindingInternal, (a:
 }) as typeof PropertyFieldBindingInternal;
 
 function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record<string, unknown>>
-    ({
-        propertyKey,
-        property,
-        context,
-        includeDescription,
-        underlyingValueHasChanged,
-        disabled: disabledProp,
-        partOfArray,
-        partOfBlock,
-        minimalistView,
-        autoFocus,
-        index,
-        size,
-        onPropertyChange
-    }: PropertyFieldBindingProps<M>): ReactElement<PropertyFieldBindingProps<M>> {
+({
+     propertyKey,
+     property,
+     context,
+     includeDescription,
+     underlyingValueHasChanged,
+     disabled: disabledProp,
+     partOfArray,
+     partOfBlock,
+     minimalistView,
+     autoFocus,
+     index,
+     size,
+     onPropertyChange
+ }: PropertyFieldBindingProps<M>): ReactElement<PropertyFieldBindingProps<M>> {
 
     const authController = useAuthController();
     const customizationController = useCustomizationController();
@@ -96,7 +96,7 @@ function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record
         >
             {(fieldProps) => {
 
-                let Component: ComponentType<FieldProps> | undefined;
+                let Component: ComponentType<FieldProps<Property, any, any>> | undefined;
                 const resolvedProperty = resolveProperty({
                     propertyKey,
                     property: property,
@@ -118,7 +118,7 @@ function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record
                 } else if (resolvedProperty.ui?.Field) {
                     const resolved = resolveComponentRef(resolvedProperty.ui.Field);
                     if (resolved) {
-                        Component = resolved as ComponentType<FieldProps<Property, unknown, M>>;
+                        Component = resolved as ComponentType<FieldProps<Property, any, any>>;
                     }
                 } else {
                     const propertyConfig = getFieldConfig(resolvedProperty, customizationController.propertyConfigs);
@@ -135,7 +135,7 @@ function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record
                         index,
                         authController
                     }) as Property | null;
-                    Component = resolveComponentRef(configProperty?.ui?.Field) as ComponentType<FieldProps> | undefined;
+                    Component = resolveComponentRef(configProperty?.ui?.Field) as ComponentType<FieldProps<Property, any, any>> | undefined;
                 }
                 if (!Component) {
                     console.warn(`No field component found for property ${propertyKey}`);
@@ -163,9 +163,9 @@ function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record
                 };
 
                 return <FieldInternal
-                    Component={Component as ComponentType<FieldProps>}
+                    Component={Component as ComponentType<FieldProps<Property, any, any>>}
                     componentProps={componentProps}
-                    formexFieldProps={fieldProps}/>;
+                    formexFieldProps={fieldProps as FormexFieldProps<unknown, Record<string, unknown>>}/>;
             }}
         </Field>
     );
@@ -175,68 +175,68 @@ function PropertyFieldBindingInternal<M extends Record<string, unknown> = Record
 type ResolvedPropertyFieldBindingProps<M extends Record<string, unknown> = Record<string, unknown>> =
     Omit<PropertyFieldBindingProps<M>, "property">
     & {
-        property: Property
-    };
-
-function FieldInternal<CustomProps, M extends Record<string, any>>
-    ({
-        Component,
-        componentProps: {
-            propertyKey,
-            property,
-            includeDescription,
-            underlyingValueHasChanged,
-            partOfArray,
-            partOfBlock,
-            minimalistView,
-            autoFocus,
-            context,
-            disabled,
-            size,
-            onPropertyChange
-        },
-        formexFieldProps
-    }:
-        {
-            Component: ComponentType<FieldProps>,
-            componentProps: ResolvedPropertyFieldBindingProps<M>,
-            formexFieldProps: FormexFieldProps<any, any>
-        }) {
+    property: Property
+};
+
+function FieldInternal<CustomProps, M extends Record<string, unknown>>
+({
+     Component,
+     componentProps: {
+         propertyKey,
+         property,
+         includeDescription,
+         underlyingValueHasChanged,
+         partOfArray,
+         partOfBlock,
+         minimalistView,
+         autoFocus,
+         context,
+         disabled,
+         size,
+         onPropertyChange
+     },
+     formexFieldProps
+ }:
+ {
+     Component: ComponentType<FieldProps<Property, any, any>>,
+     componentProps: ResolvedPropertyFieldBindingProps<M>,
+     formexFieldProps: FormexFieldProps<unknown, Record<string, unknown>>
+ }) {
 
     const { plugins } = useCustomizationController();
 
-    const customFieldProps: any = property.ui?.customProps;
+    const customFieldProps: unknown = property.ui?.customProps;
     const value = formexFieldProps.field.value;
     const error = getIn(formexFieldProps.form.errors, propertyKey) as string | string[] | undefined;
     const touched = getIn(formexFieldProps.form.touched, propertyKey) as boolean | undefined;
 
     const showError = Boolean(error &&
         (formexFieldProps.form.submitCount > 0 || property.validation?.unique) &&
-        (!Array.isArray(error) || !!error.filter((e: any) => !!e).length));
+        (!Array.isArray(error) || !!error.filter((e: unknown) => !!e).length));
 
-    const WrappedComponent: ComponentType<FieldProps<any, any, M>> | null = useWrappedComponent({
+    const WrappedComponent: ComponentType<FieldProps<Property, any, any>> | null = useWrappedComponent<unknown, any>({
         path: context.path,
         collection: context.collection,
         propertyKey: propertyKey,
         property: property,
-        Component: Component,
+        Component: Component as any, // Cast component here since it is a generic component type
         plugins: plugins
     });
-    const UsedComponent: ComponentType<FieldProps> = WrappedComponent ?? Component;
+    const UsedComponent: ComponentType<FieldProps<Property, any, any>> = WrappedComponent ?? Component;
 
     const isSubmitting = formexFieldProps.form.isSubmitting;
 
-    const setValue = useCallback((value: any | null, shouldValidate?: boolean) => {
+    const setValue = useCallback((value: unknown | null, shouldValidate?: boolean) => {
         formexFieldProps.form.setFieldTouched(propertyKey, true, false);
         formexFieldProps.form.setFieldValue(propertyKey, value, shouldValidate);
     }, []);
 
-    const setFieldValue = useCallback((otherPropertyKey: string, value: any | null, shouldValidate?: boolean) => {
+    const setFieldValue = useCallback((otherPropertyKey: string, value: unknown | null, shouldValidate?: boolean) => {
         formexFieldProps.form.setFieldTouched(propertyKey, true, false);
         formexFieldProps.form.setFieldValue(otherPropertyKey, value, shouldValidate);
     }, []);
 
-    const cmsFieldProps: FieldProps<any, CustomProps, M> = {
+    const cmsFieldProps: FieldProps<Property, CustomProps, M> = {
         propertyKey,
         value,
         setValue,
@@ -253,7 +253,7 @@ function FieldInternal<CustomProps, M extends Record<string, any>>
         partOfBlock: partOfBlock ?? false,
         minimalistView: minimalistView ?? false,
         autoFocus: autoFocus ?? false,
-        customProps: customFieldProps,
+        customProps: customFieldProps as CustomProps,
         context,
         size,
         onPropertyChange
@@ -295,11 +295,11 @@ interface UseWrappedComponentParams<M extends Record<string, unknown> = Record<s
     collection?: EntityCollection<M>,
     propertyKey: string,
     property: Property,
-    Component: ComponentType<FieldProps<any, any, M>>,
+    Component: ComponentType<FieldProps<Property, unknown, M>>,
     plugins?: RebasePlugin[]
 }
 
-function useWrappedComponent<T, M extends Record<string, any> = any>(
+function useWrappedComponent<T, M extends Record<string, unknown> = Record<string, unknown>>(
     {
         path,
         collection,
@@ -308,10 +308,10 @@ function useWrappedComponent<T, M extends Record<string, any> = any>(
         Component,
         plugins
     }: UseWrappedComponentParams<M>
-): ComponentType<FieldProps<any, any, M>> | null {
+): ComponentType<FieldProps<Property, unknown, M>> | null {
 
-    const wrapperRef = useRef<ComponentType<FieldProps<any, any, M>> | null>((() => {
-        let Wrapper: ComponentType<FieldProps<any, any, M>> | null = null;
+    const wrapperRef = useRef<ComponentType<FieldProps<Property, unknown, M>> | null>((() => {
+        let Wrapper: ComponentType<FieldProps<Property, unknown, M>> | null = null;
         if (plugins) {
             plugins.forEach((plugin) => {
                 const fieldId = getFieldId(property);
@@ -327,7 +327,7 @@ function useWrappedComponent<T, M extends Record<string, any> = any>(
                     };
                     const enabled = plugin.fieldBuilder.enabled?.(params);
                     if (enabled === undefined || enabled)
-                        Wrapper = (plugin.fieldBuilder.wrap(params) as unknown as ComponentType<FieldProps<any, any, M>> | null) ?? Wrapper;
+                        Wrapper = (plugin.fieldBuilder.wrap(params) as unknown as ComponentType<FieldProps<Property, unknown, M>> | null) ?? Wrapper;
                 }
                 if (!fieldId) {
                     console.warn("INTERNAL: Field id not found for property", property);

package/src/form/components/FieldHelperText.tsx

@@ -22,16 +22,16 @@ function normalizeError(error: unknown): string | undefined {
 
         // Extract all string values from the object (e.g., nested validation errors)
         const messages: string[] = [];
-        const extractMessages = (obj: any) => {
+        const extractMessages = (obj: Record<string, unknown>) => {
             for (const key in obj) {
                 if (typeof obj[key] === "string") {
-                    messages.push(obj[key]);
+                    messages.push(obj[key] as string);
                 } else if (typeof obj[key] === "object" && obj[key] !== null) {
-                    extractMessages(obj[key]);
+                    extractMessages(obj[key] as Record<string, unknown>);
                 }
             }
         };
-        extractMessages(error);
+        extractMessages(error as Record<string, unknown>);
         if (messages.length > 0) {
             return Array.from(new Set(messages)).join(", ");
         }

package/src/form/components/StorageUploadProgress.tsx

@@ -7,11 +7,11 @@ import { cls, paperMixin, Skeleton } from "@rebasepro/ui";
 
 export interface StorageUploadItemProps {
     storagePath: string;
-    metadata?: any,
+    metadata?: Record<string, unknown>,
     entry: StorageFieldItem,
     onFileUploadComplete: (value: string,
         entry: StorageFieldItem,
-        metadata?: any,
+        metadata?: Record<string, unknown>,
         uploadedUrl?: string) => Promise<void>;
     imageSize: number;
     simple: boolean;

package/src/form/field_bindings/ArrayCustomShapedFieldBinding.tsx

@@ -77,7 +77,7 @@ export function ArrayCustomShapedFieldBinding({
             setValue,
             setFieldValue,
             customProps
-        } as FieldProps<any>;
+        } as FieldProps;
         return <div key={`custom_shaped_array_${index}`} className="pb-4">
             <PropertyFieldBinding {...fieldProps}/>
         </div>;

package/src/form/field_bindings/ArrayOfReferencesFieldBinding.tsx

@@ -64,7 +64,7 @@ export function ArrayOfReferencesFieldBinding({
         throw Error(`Couldn't find the corresponding collection for the path: ${ofProperty.path}`);
     }
 
-    const onMultipleEntitiesSelected = useCallback((entities: Entity<any>[]) => {
+    const onMultipleEntitiesSelected = useCallback((entities: Entity<Record<string, unknown>>[]) => {
         const refs = entities.map(e => getReferenceFrom(e));
         setValue(refs);
     }, [setValue]);

package/src/form/field_bindings/BlockFieldBinding.tsx

@@ -7,6 +7,7 @@ import { Field, useFormex } from "@rebasepro/formex";
 import { FieldHelperText, LabelWithIconAndTooltip } from "../components";
 import { PropertyFieldBinding } from "../PropertyFieldBinding";
 import { EnumValuesChip } from "../../preview";
+
 ;
 import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, getDefaultValueFor } from "@rebasepro/common";
 import { getIconForProperty } from "../../util/property_utils";
@@ -25,20 +26,20 @@ import { mergeDeep } from "@rebasepro/utils";
  * @group Form fields
  */
 export function BlockFieldBinding({
-    propertyKey,
-    value,
-    error,
-    showError,
-    isSubmitting,
-    setValue,
-    setFieldValue,
-    minimalistView: minimalistViewProp,
-    property,
-    includeDescription,
-    underlyingValueHasChanged,
-    context,
-    disabled
-}: FieldProps<ArrayProperty>) {
+                                      propertyKey,
+                                      value,
+                                      error,
+                                      showError,
+                                      isSubmitting,
+                                      setValue,
+                                      setFieldValue,
+                                      minimalistView: minimalistViewProp,
+                                      property,
+                                      includeDescription,
+                                      underlyingValueHasChanged,
+                                      context,
+                                      disabled
+                                  }: FieldProps<ArrayProperty>) {
 
     const minimalistView = minimalistViewProp || property.ui?.minimalistView;
     const { t } = useTranslation();
@@ -56,11 +57,11 @@ export function BlockFieldBinding({
     const [lastAddedId, setLastAddedId] = useState<number | undefined>();
 
     const buildEntry = ({
-        index,
-        internalId,
-        storedProps,
-        storeProps
-    }: ArrayEntryParams) => {
+                            index,
+                            internalId,
+                            storedProps,
+                            storeProps
+                        }: ArrayEntryParams) => {
 
         return <BlockEntry
             key={`array_one_of_${internalId}`}
@@ -87,18 +88,18 @@ export function BlockFieldBinding({
 
     const firstOneOfKey = Object.keys(property.oneOf.properties)[0];
     const body = <ArrayContainer value={value}
-        className={"flex flex-col gap-3"}
-        droppableId={propertyKey}
-        addLabel={property.name ? t("add_to_field", { fieldName: property.name }) : t("add_entry")}
-        buildEntry={buildEntry}
-        onInternalIdAdded={setLastAddedId}
-        disabled={isSubmitting || Boolean(property.ui?.disabled)}
-        canAddElements={!property.ui?.disabled}
-        onValueChange={(value) => setFieldValue(propertyKey, value)}
-        newDefaultEntry={{
-            [property.oneOf!.typeField ?? DEFAULT_ONE_OF_TYPE]: firstOneOfKey,
-            [property.oneOf!.valueField ?? DEFAULT_ONE_OF_VALUE]: getDefaultValueFor(property.oneOf.properties[firstOneOfKey])
-        }}/>;
+                                 className={"flex flex-col gap-3"}
+                                 droppableId={propertyKey}
+                                 addLabel={property.name ? t("add_to_field", { fieldName: property.name }) : t("add_entry")}
+                                 buildEntry={buildEntry}
+                                 onInternalIdAdded={setLastAddedId}
+                                 disabled={isSubmitting || Boolean(property.ui?.disabled)}
+                                 canAddElements={!property.ui?.disabled}
+                                 onValueChange={(value) => setFieldValue(propertyKey, value)}
+                                 newDefaultEntry={{
+                                     [property.oneOf!.typeField ?? DEFAULT_ONE_OF_TYPE]: firstOneOfKey,
+                                     [property.oneOf!.valueField ?? DEFAULT_ONE_OF_VALUE]: getDefaultValueFor(property.oneOf.properties[firstOneOfKey])
+                                 }}/>;
     return (
 
         <>
@@ -114,10 +115,10 @@ export function BlockFieldBinding({
             {minimalistView && body}
 
             <FieldHelperText includeDescription={includeDescription}
-                showError={showError}
-                error={error}
-                disabled={disabled}
-                property={property}/>
+                             showError={showError}
+                             error={error}
+                             disabled={disabled}
+                             property={property}/>
 
         </>
     );
@@ -126,7 +127,7 @@ export function BlockFieldBinding({
 interface BlockEntryProps {
     name: string;
     index: number;
-    value: any;
+    value: Record<string, unknown>;
     /**
      * Name of the field to use as the discriminator for type
      * Defaults to `type`
@@ -148,7 +149,7 @@ interface BlockEntryProps {
     /**
      * Additional values related to the state of the form or the entity
      */
-    context: FormContext<any>;
+    context: FormContext;
 
     storedProps?: object,
     storeProps: (props: object) => void
@@ -156,19 +157,19 @@ interface BlockEntryProps {
 }
 
 function BlockEntry({
-    name,
-    index,
-    value,
-    typeField,
-    valueField,
-    properties,
-    autoFocus,
-    context,
-    storedProps,
-    storeProps
-}: BlockEntryProps) {
-
-    const type = value && value[typeField];
+                        name,
+                        index,
+                        value,
+                        typeField,
+                        valueField,
+                        properties,
+                        autoFocus,
+                        context,
+                        storedProps,
+                        storeProps
+                    }: BlockEntryProps) {
+
+    const type = value && (value[typeField] as string | undefined);
     const [typeInternal, setTypeInternal] = useState<string | undefined>(type ?? undefined);
 
     const formex = useFormex();
@@ -218,7 +219,7 @@ function BlockEntry({
         }
         : undefined;
 
-    const updateType = (newType: any) => {
+    const updateType = (newType: string | undefined) => {
         const newSelectedProperty = newType ? properties[newType] : undefined;
         setTypeInternal(newType);
         formex.setFieldTouched(typeFieldName, true);
@@ -239,12 +240,12 @@ function BlockEntry({
                             <Select
                                 className="mb-2"
                                 placeholder={<Typography variant={"caption"}
-                                    className={"px-4 py-2 font-medium"}>{t("type")}</Typography>}
+                                                         className={"px-4 py-2 font-medium"}>{t("type")}</Typography>}
                                 size={"medium"}
                                 fullWidth={true}
                                 position={"item-aligned"}
                                 value={value1}
-                                renderValue={(enumKey: any) =>
+                                renderValue={(enumKey: string) =>
                                     <EnumValuesChip
                                         enumKey={enumKey}
                                         enumValues={enumValuesConfigs}