@headless-adminapp/app 1.4.15 → 1.4.17

package/app/AuthWrapper.js

@@ -17,9 +17,9 @@ const AuthWrapper = ({ children, Placeholder = DefaultPlaceHolder, }) => {
     }
     if (!state.authenticated) {
         if (state.sessionExpired) {
-            return (0, jsx_runtime_1.jsx)(Placeholder, { sessionExpired: true, retry: state.loadSession });
+            return ((0, jsx_runtime_1.jsx)(Placeholder, { sessionExpired: true, retry: state.loadSession, reason: state.reason }));
         }
-        return (0, jsx_runtime_1.jsx)(Placeholder, { unauthorized: true, retry: state.loadSession });
+        return ((0, jsx_runtime_1.jsx)(Placeholder, { unauthorized: true, retry: state.loadSession, reason: state.reason }));
     }
     return children;
 };

package/auth/AuthProvider.js

@@ -48,6 +48,7 @@ const AuthProvider = ({ sessionResolver, onUnauthenticated, children, }) => {
                     authenticated: false,
                     sessionExpired: false,
                     session: null,
+                    reason: 'load',
                 });
                 onUnauthenticatedRef.current?.('load');
             }
@@ -85,6 +86,7 @@ const AuthProvider = ({ sessionResolver, onUnauthenticated, children, }) => {
                 authenticated: false,
                 sessionExpired: true,
                 session: null,
+                reason: 'sessionExpired',
             });
             onUnauthenticatedRef.current?.('sessionExpired');
             return;
@@ -99,6 +101,7 @@ const AuthProvider = ({ sessionResolver, onUnauthenticated, children, }) => {
                 authenticated: false,
                 sessionExpired: true,
                 session: null,
+                reason: 'sessionExpired',
             });
             onUnauthenticatedRef.current?.('sessionExpired');
         }, timeout);

package/auth/context.d.ts

@@ -8,6 +8,7 @@ interface AuthStoreUnauthorizedState {
     authenticated: false;
     sessionExpired: boolean;
     session: null;
+    reason?: UnauthorizeReason;
 }
 interface AuthStoreAuthorizedState<T extends AuthSession = AuthSession> {
     initialized: true;

package/auth/hooks/useLogout.js

@@ -12,6 +12,7 @@ function useLogout() {
             initialized: true,
             authenticated: false,
             session: null,
+            reason: 'logout',
         });
         onUnauthenticated?.('logout');
     }, [setValue, onUnauthenticated]);

package/auth/types.d.ts

@@ -5,6 +5,7 @@ export interface AuthProviderPlaceholderProps {
     loadingError?: boolean;
     unauthorized?: boolean;
     sessionExpired?: boolean;
+    reason?: UnauthorizeReason;
     retry: () => void;
 }
 export type SessionResolver = () => Promise<AuthSession | null>;

package/dataform/DataFormProvider/CalculatedField.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const CalculatedField: FC;

package/dataform/DataFormProvider/CalculatedField.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculatedField = void 0;
+const useCalculatedAttributeStore_1 = require("@headless-adminapp/app/metadata/hooks/useCalculatedAttributeStore");
+const react_1 = require("react");
+const constants_1 = require("../constants");
+const hooks_1 = require("../hooks");
+const utils_1 = require("./utils");
+const CalculatedField = () => {
+    const formInstance = (0, hooks_1.useFormInstance)();
+    const schema = (0, hooks_1.useDataFormSchema)();
+    const form = (0, hooks_1.useSelectedForm)();
+    const formInstanceRef = (0, react_1.useRef)(formInstance);
+    formInstanceRef.current = formInstance;
+    const calculatedAttributeStore = (0, useCalculatedAttributeStore_1.useCalculatedAttributeStore)();
+    const eventManager = (0, hooks_1.useEventManager)();
+    (0, react_1.useEffect)(() => {
+        const editableGridControls = (0, utils_1.getControls)(form).filter((x) => x.type === 'editablegrid');
+        const formAttributeNames = (0, utils_1.getColumns)(form, schema);
+        const listener = (key) => {
+            if (!calculatedAttributeStore)
+                return;
+            const values = formInstanceRef.current.getValues();
+            function recalculateRecordField(item) {
+                if (!formAttributeNames.find((x) => x === item.attributeName)) {
+                    // If the standard control is not found, we can't recalculate
+                    return;
+                }
+                const record = {};
+                for (const dep of item.deps) {
+                    record[dep] = values[dep];
+                }
+                const relatedRecords = {};
+                for (const relatedDep of Object.entries(item.relatedDeps || {})) {
+                    const [logicalName, { associatedColumn, columns }] = relatedDep;
+                    relatedRecords[logicalName] = [];
+                    const gridControl = editableGridControls.find((x) => x.alias !== false &&
+                        x.logicalName === logicalName &&
+                        x.associatedAttribute === associatedColumn);
+                    if (!gridControl) {
+                        continue;
+                    }
+                    const gridItemValues = values[gridControl.alias];
+                    if (!gridItemValues || !Array.isArray(gridItemValues)) {
+                        continue;
+                    }
+                    relatedRecords[logicalName] = gridItemValues.map((item) => {
+                        const childRecord = {};
+                        for (const column of columns) {
+                            childRecord[column] = item[column];
+                        }
+                        return childRecord;
+                    });
+                }
+                const currentValue = formInstanceRef.current.getValues(item.attributeName);
+                const newValue = item.handler(record, relatedRecords);
+                console.log('Recalculated main record field:', item.attributeName, item, record, relatedRecords, {
+                    currentValue,
+                    newValue,
+                });
+                if (currentValue !== newValue) {
+                    formInstanceRef.current.setValue(item.attributeName, newValue);
+                    eventManager.emit(constants_1.EVENT_KEY_ON_FIELD_CHANGE, item.attributeName, newValue, currentValue);
+                }
+            }
+            function recalculateSubGridField(item, alias, indexStr) {
+                const record = {};
+                for (const dep of item.deps) {
+                    record[dep] = values[alias][indexStr][dep];
+                }
+                const currentValue = formInstanceRef.current.getValues(`${alias}.${indexStr}.${item.attributeName}`);
+                const newValue = item.handler(record, {});
+                console.log('Subgrid row level calculation:', item.attributeName, item, record, {
+                    currentValue,
+                    newValue,
+                });
+                if (currentValue !== newValue) {
+                    formInstanceRef.current.setValue(`${alias}.${indexStr}.${item.attributeName}`, newValue);
+                    eventManager.emit(constants_1.EVENT_KEY_ON_FIELD_CHANGE, `${alias}.${indexStr}.${item.attributeName}`, newValue, currentValue);
+                }
+            }
+            if (key.includes('.')) {
+                // Handle subgrid changes
+                const [alias, indexStr, field] = key.split('.');
+                const gridControl = editableGridControls.find((x) => x.alias === alias);
+                if (!gridControl) {
+                    // Invalid state
+                    // Grid control not found
+                    return;
+                }
+                if (!field) {
+                    // row removed or inserted
+                    // Find depended controls for all attributes included in subgrid
+                    let items = calculatedAttributeStore.getCalculatedAttributeInfosByDeps(gridControl.logicalName, ...gridControl.controls.map((x) => typeof x === 'string' ? x : x.attributeName));
+                    // Filter out row level calculated fields
+                    items = items.filter((x) => x.logicalName !== gridControl.logicalName);
+                    for (const item of items) {
+                        recalculateRecordField(item);
+                    }
+                }
+                else {
+                    const items = calculatedAttributeStore.getCalculatedAttributeInfosByDeps(gridControl.logicalName, field);
+                    for (const item of items) {
+                        if (item.logicalName === gridControl.logicalName) {
+                            // This is a row level calculated field
+                            if (Object.keys(item.relatedDeps || {}).length > 0) {
+                                // Grid row level calculated fields have nested related deps
+                                // We don't have nested subgrid so no need to handle this case
+                                continue;
+                            }
+                            recalculateSubGridField(item, alias, indexStr);
+                        }
+                        else {
+                            recalculateRecordField(item);
+                        }
+                    }
+                }
+            }
+            else {
+                // Handle standard field changes
+                const items = calculatedAttributeStore.getCalculatedAttributeInfosByDeps(schema.logicalName, key);
+                for (const item of items) {
+                    if (item.logicalName !== schema.logicalName) {
+                        // This item is not related to the current schema
+                        // In main record field we can only calculated top-level fields
+                        continue;
+                    }
+                    recalculateRecordField(item);
+                }
+            }
+        };
+        eventManager.on(constants_1.EVENT_KEY_ON_FIELD_CHANGE, listener);
+        return () => {
+            eventManager.off(constants_1.EVENT_KEY_ON_FIELD_CHANGE, listener);
+        };
+    }, [eventManager, calculatedAttributeStore, form, schema]);
+    return null;
+};
+exports.CalculatedField = CalculatedField;

package/dataform/DataFormProvider/index.js

@@ -14,6 +14,7 @@ const mutable_1 = require("../../mutable");
 const context_1 = require("../context");
 const utils_1 = require("../utils");
 const saveRecord_1 = require("../utils/saveRecord");
+const CalculatedField_1 = require("./CalculatedField");
 const CustomHookExecuter_1 = require("./CustomHookExecuter");
 const DataResolver_1 = require("./DataResolver");
 const getRecord_1 = require("./getRecord");
@@ -116,5 +117,5 @@ function DataFormProvider(props) {
         schemaStore,
         props.commands,
     ]);
-    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, { ...formInstance, children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, { retriveRecordFn: props.retriveRecordFn ?? getRecord_1.getRecord }), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), (0, jsx_runtime_1.jsx)(CustomHookExecuter_1.CustomHookExecuter, { useHookFn: props.form.experience.useHookFn }), props.children] }) }));
+    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, { ...formInstance, children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, { retriveRecordFn: props.retriveRecordFn ?? getRecord_1.getRecord }), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), (0, jsx_runtime_1.jsx)(CustomHookExecuter_1.CustomHookExecuter, { useHookFn: props.form.experience.useHookFn }), (0, jsx_runtime_1.jsx)(CalculatedField_1.CalculatedField, {}), props.children] }) }));
 }

package/dataform/DataFormProvider/utils.d.ts

@@ -2,15 +2,17 @@ import { AttributeBase } from '@headless-adminapp/core/attributes/AttributeBase'
 import { Form, Section } from '@headless-adminapp/core/experience/form';
 import { SectionControl, SectionStatndardControl } from '@headless-adminapp/core/experience/form/SectionControl';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { CalculatedAttributeInfo } from '@headless-adminapp/core/schema/CalculatedAttributeInfo';
 import { DataFormContextState } from '../context';
 export declare function getControls<SA extends SchemaAttributes>(form: Form<SA>): SectionControl<SA>[];
 export declare function getColumns<SA extends SchemaAttributes>(form: Form<SA>, schema: Schema<SA>): (keyof SA)[];
 export declare function transformFormInternal<SA extends SchemaAttributes>(form: Form<SA>): DataFormContextState<SA>['formInternal'];
-export declare function getIsFieldDisabled<S extends SchemaAttributes = SchemaAttributes>({ attribute, isFormReadonly, disabledFields, control, }: {
+export declare function getIsFieldDisabled<S extends SchemaAttributes = SchemaAttributes>({ attribute, isFormReadonly, disabledFields, control, calculatedAttribute, }: {
     attribute: AttributeBase | null;
     isFormReadonly: boolean | undefined;
     disabledFields: Record<string, boolean>;
     control: Section<S>['controls'][0];
+    calculatedAttribute: CalculatedAttributeInfo | undefined;
 }): boolean;
 export declare function getIsControlHidden<S extends SchemaAttributes = SchemaAttributes>({ control, hiddenControls, }: {
     hiddenControls: Record<string, boolean>;

package/dataform/DataFormProvider/utils.js

@@ -65,7 +65,7 @@ function transformFormInternal(form) {
         },
     };
 }
-function getIsFieldDisabled({ attribute, isFormReadonly, disabledFields, control, }) {
+function getIsFieldDisabled({ attribute, isFormReadonly, disabledFields, control, calculatedAttribute, }) {
     let disabled = isFormReadonly ?? false;
     if (!disabled) {
         if (control.type === 'standard' &&
@@ -80,6 +80,11 @@ function getIsFieldDisabled({ attribute, isFormReadonly, disabledFields, control
             disabled = attribute.readonly;
         }
     }
+    if (!disabled &&
+        calculatedAttribute &&
+        !calculatedAttribute.allowUserToEdit) {
+        disabled = true;
+    }
     return disabled;
 }
 function getIsControlHidden({ control, hiddenControls, }) {

package/dataform/FormManager.js

@@ -120,6 +120,7 @@ class Control {
             attribute: this.context.schema.attributes[attributeName],
             disabledFields: this.context.disabledControls,
             isFormReadonly: this.context.isReadonly,
+            calculatedAttribute: undefined,
         });
     }
     setDisabled(state) {

package/dataform/hooks/index.d.ts

@@ -14,8 +14,6 @@ export * from './useProcessFlowSteps';
 export * from './useEventManager';
 export * from './useIsControlHiddenByAttributeName';
 export * from './useIsControlHiddenByKey';
-export * from './useHiddenControlsManager';
-export * from './useDisabledControlsManager';
 export * from './useContextKey';
 export * from './useIsControlDisabled';
 export * from './useIsFieldRequired';

package/dataform/hooks/index.js

@@ -30,8 +30,6 @@ __exportStar(require("./useProcessFlowSteps"), exports);
 __exportStar(require("./useEventManager"), exports);
 __exportStar(require("./useIsControlHiddenByAttributeName"), exports);
 __exportStar(require("./useIsControlHiddenByKey"), exports);
-__exportStar(require("./useHiddenControlsManager"), exports);
-__exportStar(require("./useDisabledControlsManager"), exports);
 __exportStar(require("./useContextKey"), exports);
 __exportStar(require("./useIsControlDisabled"), exports);
 __exportStar(require("./useIsFieldRequired"), exports);

package/dataform/hooks/useIsControlDisabled.js

@@ -23,5 +23,6 @@ function useIsControlDisabled(attributeName) {
         control: controls[attributeName],
         disabledFields: disabledFields,
         isFormReadonly: isFormReadonly,
+        calculatedAttribute: undefined,
     });
 }

package/metadata/MetadataProvider.d.ts

@@ -1,5 +1,6 @@
 import { AppExperience } from '@headless-adminapp/core/experience/app';
 import { ISchemaExperienceStore, ISchemaStore, SchemaStore } from '@headless-adminapp/core/store';
+import { ICalculatedAttributeStore } from '@headless-adminapp/core/store/ICalculatedAttributeStore';
 import { FC, PropsWithChildren } from 'react';
 import { IRecentItemStore, SchemaExperienceStore } from '../store';
 export interface MetadataProviderProps {
@@ -7,6 +8,7 @@ export interface MetadataProviderProps {
     experienceStore?: ISchemaExperienceStore;
     appExperience?: AppExperience;
     recentItemStore?: IRecentItemStore;
+    calculatedAttributeStore?: ICalculatedAttributeStore;
 }
 export declare const defaultSchemaStore: SchemaStore<import("@headless-adminapp/core/schema").SchemaAttributes>;
 export declare const defaultExperienceStore: SchemaExperienceStore;

package/metadata/MetadataProvider.js

@@ -26,12 +26,13 @@ const defaultApp = {
     logo: {},
 };
 const defaultRecentItemStore = new store_2.RecentItemStore();
-const MetadataProvider = ({ children, experienceStore = exports.defaultExperienceStore, schemaStore = exports.defaultSchemaStore, appExperience = defaultApp, recentItemStore = defaultRecentItemStore, }) => {
+const MetadataProvider = ({ children, experienceStore = exports.defaultExperienceStore, schemaStore = exports.defaultSchemaStore, appExperience = defaultApp, recentItemStore = defaultRecentItemStore, calculatedAttributeStore, }) => {
     const contextValue = (0, context_1.useCreateContextStore)({
         experienceStore,
         schemaStore,
         appExperience,
         recentItemStore,
+        calculatedAttributeStore,
     });
     (0, react_1.useEffect)(() => {
         contextValue.setValue({

package/metadata/context.d.ts

@@ -1,10 +1,12 @@
 import type { AppExperience } from '@headless-adminapp/core/experience/app';
 import type { ISchemaExperienceStore, ISchemaStore } from '@headless-adminapp/core/store';
+import { ICalculatedAttributeStore } from '@headless-adminapp/core/store/ICalculatedAttributeStore';
 import { IRecentItemStore } from '../store';
 export interface MetadataContextState {
     schemaStore: ISchemaStore;
     experienceStore: ISchemaExperienceStore;
     appExperience: AppExperience;
     recentItemStore: IRecentItemStore;
+    calculatedAttributeStore?: ICalculatedAttributeStore;
 }
 export declare const MetadataContext: import("react").Context<import("../mutable/context").ContextValue<MetadataContextState>>;

package/metadata/hooks/useCalculatedAttributeStore.d.ts

@@ -0,0 +1 @@
+export declare function useCalculatedAttributeStore(): import("@headless-adminapp/core/store/ICalculatedAttributeStore").ICalculatedAttributeStore | undefined;

package/metadata/hooks/useCalculatedAttributeStore.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCalculatedAttributeStore = useCalculatedAttributeStore;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useCalculatedAttributeStore() {
+    return (0, context_1.useContextSelector)(context_2.MetadataContext, (state) => state.calculatedAttributeStore);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "1.4.15",
+  "version": "1.4.17",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -38,5 +38,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "a95b4f3c11bcb78f672fb7299bb461368d70bd48"
+  "gitHead": "a5a471cce4df9e87552b23e3de8c90d53e4adf43"
 }

package/transport/RestDataService/index.d.ts

@@ -8,9 +8,12 @@ export declare class RestDataService implements IDataService {
     protected readonly options: RestDataServiceOptions;
     constructor(options: RestDataServiceOptions);
     protected readonly headers: Record<string, string>;
-    private getHeaders;
+    protected getHeaders(): {
+        'content-type': string;
+    };
     setHeader(name: string, value: string): void;
     removeHeader(name: string): void;
+    protected handleResponseError(response: Response): Promise<void>;
     protected execute<T = unknown, D = unknown>(data: D): Promise<T>;
     retriveRecord<T = unknown>(logicalName: string, id: string, columns: (keyof T)[], expand?: {
         [key in keyof T]?: string[];

package/transport/RestDataService/index.js

@@ -33,13 +33,16 @@ class RestDataService {
     removeHeader(name) {
         delete this.headers[name];
     }
+    handleResponseError(response) {
+        return handleResponseError(response);
+    }
     async execute(data) {
         const response = await fetch(this.options.endpoint, {
             headers: this.getHeaders(),
             method: 'POST',
             body: JSON.stringify(data),
         });
-        await handleResponseError(response);
+        await this.handleResponseError(response);
         return response.json();
     }
     async retriveRecord(logicalName, id, columns, expand) {

package/transport/hooks/useDataService.d.ts

@@ -1 +1,2 @@
-export declare function useDataService(): import("@headless-adminapp/core/transport").IDataService;
+import { IDataService } from '@headless-adminapp/core/transport';
+export declare function useDataService<T extends IDataService = IDataService>(): T;

package/utils/color.js

@@ -2,13 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isColorDark = isColorDark;
 function isColorDark(color) {
-    if (color.startsWith('#')) {
-        color = color.substring(1);
+    let hexColor = getColorHexCode(color);
+    if (!hexColor) {
+        return false;
     }
-    const rgb = parseInt(color, 16);
+    hexColor = hexColor.substring(1);
+    const rgb = parseInt(hexColor, 16);
     const r = (rgb >> 16) & 0xff;
     const g = (rgb >> 8) & 0xff;
     const b = (rgb >> 0) & 0xff;
     const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
     return luma < 128;
 }
+function getColorHexCode(color) {
+    if (color.startsWith('#')) {
+        return color;
+    }
+    const tempDiv = document.createElement('div');
+    tempDiv.style.color = color; // Accepts color name, rgb(), hsl(), etc.
+    document.body.appendChild(tempDiv);
+    const computedColor = getComputedStyle(tempDiv).color;
+    document.body.removeChild(tempDiv);
+    // Convert rgb(a) string to hex
+    const rgb = computedColor.match(/\d+/g); // Extract numbers
+    if (!rgb)
+        return null;
+    // rgb might have 3 or 4 values (ignore alpha)
+    const hex = rgb
+        .slice(0, 3)
+        .map((x) => {
+        const hexPart = Number(x).toString(16);
+        return hexPart.length === 1 ? '0' + hexPart : hexPart;
+    })
+        .join('');
+    return '#' + hex;
+}

package/dataform/hooks/useDisabledControlsManager.d.ts

@@ -1,6 +0,0 @@
-/*** @deprecated */
-export declare function useDisabledControlsManager(): {
-    getIsControlDisabled: (attributeName: string) => boolean;
-    setControlDisabled: (attributeName: string, state: boolean) => void;
-    resetControlDisabled: (key: string) => void;
-};

package/dataform/hooks/useDisabledControlsManager.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useDisabledControlsManager = useDisabledControlsManager;
-const mutable_1 = require("@headless-adminapp/app/mutable");
-const context_1 = require("@headless-adminapp/app/mutable/context");
-const react_1 = require("react");
-const context_2 = require("../context");
-const utils_1 = require("../DataFormProvider/utils");
-/*** @deprecated */
-function useDisabledControlsManager() {
-    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
-    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
-    const _getIsControlDisabled = (0, react_1.useCallback)((attributeName) => {
-        const attribute = dataFormContextValue.current.schema.attributes[attributeName];
-        return (0, utils_1.getIsFieldDisabled)({
-            attribute,
-            control: dataFormContextValue.current.formInternal.controls.dict[attributeName],
-            disabledFields: dataFormContextValue.current.disabledControls,
-            isFormReadonly: dataFormContextValue.current.isReadonly,
-        });
-    }, [dataFormContextValue]);
-    const _setControlDisabled = (0, react_1.useCallback)((attributeName, state) => {
-        setValue((prev) => {
-            return {
-                disabledControls: {
-                    ...prev.disabledControls,
-                    [attributeName]: state,
-                },
-            };
-        });
-    }, [setValue]);
-    const _resetControlDisabled = (0, react_1.useCallback)((key) => {
-        setValue((prev) => {
-            const _disabledControls = { ...prev.disabledControls };
-            delete _disabledControls[key];
-            return {
-                hiddenControls: _disabledControls,
-            };
-        });
-    }, [setValue]);
-    return {
-        getIsControlDisabled: _getIsControlDisabled,
-        setControlDisabled: _setControlDisabled,
-        resetControlDisabled: _resetControlDisabled,
-    };
-}

package/dataform/hooks/useHiddenControlsManager.d.ts

@@ -1,7 +0,0 @@
-/** @deprecated */
-export declare function useHiddenControlsManager(): {
-    getIsControlHiddenByAttributeName: (attributeName: string) => boolean;
-    getIsControlHiddenByKey: (key: string) => boolean;
-    setControlHiddenByKey: (key: string, state: boolean) => void;
-    resetControlHiddenByKey: (key: string) => void;
-};

package/dataform/hooks/useHiddenControlsManager.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHiddenControlsManager = useHiddenControlsManager;
-const mutable_1 = require("@headless-adminapp/app/mutable");
-const context_1 = require("@headless-adminapp/app/mutable/context");
-const react_1 = require("react");
-const context_2 = require("../context");
-const utils_1 = require("../DataFormProvider/utils");
-/** @deprecated */
-function useHiddenControlsManager() {
-    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
-    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
-    const _getIsControlHiddenByAttributeName = (0, react_1.useCallback)((attributeName) => {
-        return (0, utils_1.getIsControlHidden)({
-            control: dataFormContextValue.current.formInternal.controls.dict[attributeName],
-            hiddenControls: dataFormContextValue.current.hiddenControls,
-        });
-    }, [dataFormContextValue]);
-    const _getIsControlHiddenByKey = (0, react_1.useCallback)((key) => {
-        return (0, utils_1.getIsControlHidden)({
-            control: dataFormContextValue.current.formInternal.controls.dict[key],
-            hiddenControls: dataFormContextValue.current.hiddenControls,
-        });
-    }, [dataFormContextValue]);
-    const _setControlHiddenByKey = (0, react_1.useCallback)((key, state) => {
-        setValue((prev) => {
-            return {
-                hiddenControls: {
-                    ...prev.hiddenControls,
-                    [key]: state,
-                },
-            };
-        });
-    }, [setValue]);
-    const _resetControlHiddenByKey = (0, react_1.useCallback)((key) => {
-        setValue((prev) => {
-            const _hiddenControls = { ...prev.hiddenControls };
-            delete _hiddenControls[key];
-            return {
-                hiddenControls: _hiddenControls,
-            };
-        });
-    }, [setValue]);
-    return {
-        getIsControlHiddenByAttributeName: _getIsControlHiddenByAttributeName,
-        getIsControlHiddenByKey: _getIsControlHiddenByKey,
-        setControlHiddenByKey: _setControlHiddenByKey,
-        resetControlHiddenByKey: _resetControlHiddenByKey,
-    };
-}