@headless-adminapp/app 0.0.17-alpha.59 → 0.0.17-alpha.62

package/dataform/hooks/useRequiredFieldManager.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRequiredFieldManager = useRequiredFieldManager;
+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 useRequiredFieldManager() {
+    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
+    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
+    const _getIsFieldRequired = (0, react_1.useCallback)((attributeName) => {
+        const attribute = dataFormContextValue.current.schema.attributes[attributeName];
+        const control = dataFormContextValue.current.formInternal.controls.dict[attributeName];
+        if (control.type !== 'standard') {
+            return false;
+        }
+        return (0, utils_1.getIsFieldRequired)({
+            attribute,
+            control,
+            requiredFields: dataFormContextValue.current.requiredFields,
+        });
+    }, [dataFormContextValue]);
+    const _setFieldRequired = (0, react_1.useCallback)((attributeName, state) => {
+        setValue((prev) => {
+            return {
+                requiredFields: {
+                    ...prev.requiredFields,
+                    [attributeName]: state,
+                },
+            };
+        });
+    }, [setValue]);
+    const _resetFieldRequired = (0, react_1.useCallback)((key) => {
+        setValue((prev) => {
+            const _requiredFields = { ...prev.requiredFields };
+            delete _requiredFields[key];
+            return {
+                requiredFields: _requiredFields,
+            };
+        });
+    }, [setValue]);
+    return {
+        getIsFieldRequired: _getIsFieldRequired,
+        setFieldRequired: _setFieldRequired,
+        resetFieldRequired: _resetFieldRequired,
+    };
+}

package/dataform/test.d.ts

@@ -0,0 +1,57 @@
+import { Attribute } from '@headless-adminapp/core';
+import { SectionControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ContextValue } from '../mutable';
+import { DataFormContextState } from './context';
+import { Section } from '@headless-adminapp/core/experience/form';
+import { Tab } from '@headless-adminapp/core/experience/form/Tab';
+export declare class FormUiManager<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>);
+    private get context();
+    getAttribute(attributeName: keyof SA): FormAttribute<SA> | null;
+    getControl<C extends Control<SA>>(name: string): C | null;
+    getSection(name: string): FormSection<SA> | null;
+    getTab(name: string): FormTab<SA> | null;
+}
+declare class FormAttribute<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly attributeName;
+    private readonly attribute;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, attributeName: keyof SA, attribute: Attribute);
+    getInnerAttribute(): Attribute;
+    setRequired(state: boolean): void;
+    getRequired(): boolean;
+    resetRequired(): void;
+    getControls(): Control<SA>[];
+}
+declare class Control<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly control;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, control: SectionControl<SA>);
+    private get context();
+    getKey(): string | undefined;
+    getDisabled(): boolean;
+    setDisabled(state: boolean): void;
+    resetDisabled(): void;
+    getHidden(): boolean;
+    setHidden(state: boolean): void;
+    resetHidden(): void;
+}
+declare class FormSection<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly section;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, section: Section<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+declare class FormTab<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly tab;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, tab: Tab<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+export {};

package/dataform/test.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormUiManager = void 0;
+const utils_1 = require("./DataFormProvider/utils");
+class FormUiManager {
+    contextState;
+    constructor(contextState) {
+        this.contextState = contextState;
+    }
+    get context() {
+        return this.contextState.value.current;
+    }
+    getAttribute(attributeName) {
+        return new FormAttribute(this.contextState, attributeName, this.context.schema.attributes[attributeName]);
+    }
+    getControl(name) {
+        const control = this.context.formInternal.controls.dict[name] ?? null;
+        if (!control) {
+            return null;
+        }
+        return new Control(this.contextState, control);
+    }
+    getSection(name) {
+        const section = this.context.formInternal.sections.dict[name];
+        if (!section) {
+            return null;
+        }
+        return new FormSection(this.contextState, section);
+    }
+    getTab(name) {
+        const tab = this.context.formInternal.tabs.dict[name];
+        if (!tab) {
+            return null;
+        }
+        return new FormTab(this.contextState, tab);
+    }
+}
+exports.FormUiManager = FormUiManager;
+class FormAttribute {
+    contextState;
+    attributeName;
+    attribute;
+    constructor(contextState, attributeName, attribute) {
+        this.contextState = contextState;
+        this.attributeName = attributeName;
+        this.attribute = attribute;
+    }
+    getInnerAttribute() {
+        return this.attribute;
+    }
+    setRequired(state) {
+        const control = this.contextState.value.current.formInternal.controls.dict[this.attributeName];
+        if (!control) {
+            return;
+        }
+        if (control.type !== 'standard') {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            return {
+                requiredFields: {
+                    ...prev.requiredFields,
+                    [this.attributeName]: state,
+                },
+            };
+        });
+    }
+    getRequired() {
+        const attribute = this.attribute;
+        const control = this.contextState.value.current.formInternal.controls.dict[this.attributeName];
+        if (control.type !== 'standard') {
+            return false;
+        }
+        return (0, utils_1.getIsFieldRequired)({
+            attribute,
+            control,
+            requiredFields: this.contextState.value.current.requiredFields,
+        });
+    }
+    resetRequired() {
+        this.contextState.setValue((prev) => {
+            const requiredFields = { ...prev.requiredFields };
+            delete requiredFields[this.attributeName];
+            return {
+                requiredFields,
+            };
+        });
+    }
+    getControls() {
+        return this.contextState.value.current.formInternal.controls.list
+            .filter((control) => control.type === 'standard' &&
+            control.attributeName === this.attributeName)
+            .map((control) => new Control(this.contextState, control));
+    }
+}
+class Control {
+    contextState;
+    control;
+    constructor(contextState, control) {
+        this.contextState = contextState;
+        this.control = control;
+    }
+    get context() {
+        return this.contextState.value.current;
+    }
+    getKey() {
+        let key = this.control.key;
+        if (!key && this.control.type === 'standard') {
+            key = this.control.attributeName;
+        }
+        return key;
+    }
+    getDisabled() {
+        if (this.control.type !== 'standard') {
+            return false;
+        }
+        const attributeName = this.control.attributeName;
+        return (0, utils_1.getIsFieldDisabled)({
+            control: this.control,
+            attribute: this.context.schema.attributes[attributeName],
+            disabledFields: this.context.disabledControls,
+            isFormReadonly: this.context.isReadonly,
+        });
+    }
+    setDisabled(state) {
+        if (this.control.type !== 'standard') {
+            return;
+        }
+        const key = this.control.attributeName;
+        this.contextState.setValue((prev) => {
+            return {
+                disabledControls: {
+                    ...prev.disabledControls,
+                    [key]: state,
+                },
+            };
+        });
+    }
+    resetDisabled() {
+        if (this.control.type !== 'standard') {
+            return;
+        }
+        const key = this.control.attributeName;
+        this.contextState.setValue((prev) => {
+            const disabledFields = { ...prev.disabledControls };
+            delete disabledFields[key];
+            return {
+                disabledControls: disabledFields,
+            };
+        });
+    }
+    getHidden() {
+        return (0, utils_1.getIsControlHidden)({
+            control: this.control,
+            hiddenControls: this.context.hiddenControls,
+        });
+    }
+    setHidden(state) {
+        const key = this.getKey();
+        if (!key) {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenControls: {
+                    ...prev.hiddenControls,
+                    [key]: state,
+                },
+            };
+        });
+    }
+    resetHidden() {
+        const key = this.getKey();
+        if (!key) {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            const hiddenControls = { ...prev.hiddenControls };
+            delete hiddenControls[key];
+            return {
+                hiddenControls,
+            };
+        });
+    }
+}
+class FormSection {
+    contextState;
+    section;
+    constructor(contextState, section) {
+        this.contextState = contextState;
+        this.section = section;
+    }
+    setHidden(state) {
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenSections: {
+                    ...prev.hiddenSections,
+                    [this.section.name]: state,
+                },
+            };
+        });
+    }
+    getHidden() {
+        return (this.contextState.value.current.hiddenSections[this.section.name] ??
+            this.section.hidden ??
+            false);
+    }
+    resetHidden() {
+        this.contextState.setValue((prev) => {
+            const hiddenSections = { ...prev.hiddenSections };
+            delete hiddenSections[this.section.name];
+            return {
+                hiddenSections,
+            };
+        });
+    }
+}
+class FormTab {
+    contextState;
+    tab;
+    constructor(contextState, tab) {
+        this.contextState = contextState;
+        this.tab = tab;
+    }
+    setHidden(state) {
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenTabs: {
+                    ...prev.hiddenTabs,
+                    [this.tab.name]: state,
+                },
+            };
+        });
+    }
+    getHidden() {
+        return this.contextState.value.current.hiddenTabs[this.tab.name] ?? false;
+    }
+    resetHidden() {
+        this.contextState.setValue((prev) => {
+            const hiddenTabs = { ...prev.hiddenTabs };
+            delete hiddenTabs[this.tab.name];
+            return {
+                hiddenTabs,
+            };
+        });
+    }
+}

package/dataform/utils/defaultParameters.d.ts

@@ -1,3 +1,6 @@
+import { FormExperience } from '@headless-adminapp/core/experience/form';
 import { Schema } from '@headless-adminapp/core/schema';
-export declare function getFormDefaultParameters(schema: Schema): Record<string, any>;
+export declare function getFormDefaultParameters(schema: Schema, formExperience: FormExperience): {
+    [x: string]: any;
+};
 export declare function setFormDefaultParameters(logicalName: string, values: Record<string, any>): void;

package/dataform/utils/defaultParameters.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFormDefaultParameters = getFormDefaultParameters;
 exports.setFormDefaultParameters = setFormDefaultParameters;
 let formDefaultParameters = null;
-function getFormDefaultParameters(schema) {
+function getFormDefaultParameters(schema, formExperience) {
     const _values = formDefaultParameters?.values;
     const _logicalName = formDefaultParameters?.logicalName;
     const schemaDefaultValues = Object.keys(schema.attributes).reduce((acc, key) => {
@@ -20,13 +20,24 @@ function getFormDefaultParameters(schema) {
             [key]: defaultValue,
         };
     }, {});
+    let formDefaultValues = {};
+    if (typeof formExperience.defaultValues === 'function') {
+        formDefaultValues = formExperience.defaultValues();
+    }
+    else if (typeof formExperience.defaultValues === 'object') {
+        formDefaultValues = formExperience.defaultValues;
+    }
+    let defaultValues = {
+        ...schemaDefaultValues,
+        ...formDefaultValues,
+    };
     if (_logicalName === schema.logicalName) {
-        return {
-            ...schemaDefaultValues,
+        defaultValues = {
+            ...defaultValues,
             ..._values,
         };
     }
-    return schemaDefaultValues;
+    return defaultValues;
 }
 let defaultParamsTimeout = null;
 function setFormDefaultParameters(logicalName, values) {

package/dataform/utils/index.js

@@ -29,13 +29,13 @@ const phone_1 = require("@headless-adminapp/app/utils/phone");
 const yup_1 = require("@hookform/resolvers/yup");
 const lodash_1 = require("lodash");
 const yup = __importStar(require("yup"));
-const DataResolver_1 = require("../../dataform/DataFormProvider/DataResolver");
-const utils_1 = require("../../locale/utils");
+const utils_1 = require("../../dataform/DataFormProvider/utils");
+const utils_2 = require("../../locale/utils");
 var saveRecord_1 = require("./saveRecord");
 Object.defineProperty(exports, "saveRecord", { enumerable: true, get: function () { return saveRecord_1.saveRecord; } });
 function getInitialValues({ cloneRecord, form, record, recordId, schema, defaultParameters, }) {
-    const formColumns = (0, DataResolver_1.getColumns)(form, schema);
-    const editableGridControls = (0, DataResolver_1.getControls)(form).filter((control) => control.type === 'editablegrid');
+    const formColumns = (0, utils_1.getColumns)(form, schema);
+    const editableGridControls = (0, utils_1.getControls)(form).filter((control) => control.type === 'editablegrid');
     const allColumns = [
         ...formColumns,
         ...editableGridControls.map((x) => x.attributeName),
@@ -301,7 +301,7 @@ function extendAttributeAttachmentsValidationSchema({ attribute, validationSchem
 }
 exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings, region) {
     let validationSchema = createAttributeValidationSchema(attribute);
-    const label = (0, utils_1.localizedLabel)(language, attribute);
+    const label = (0, utils_2.localizedLabel)(language, attribute);
     validationSchema = extendAttributeRequiredValidationSchema({
         attribute,
         validationSchema,

package/dataform/utils/saveRecord.d.ts

@@ -13,7 +13,7 @@ type SaveRecordResult = {
     message: string;
     isError: boolean;
 };
-export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: {
+export interface SaveRecordFnOptions {
     values: any;
     form: Form<SchemaAttributes>;
     record: InferredSchemaType<SchemaAttributes> | undefined;
@@ -21,5 +21,7 @@ export declare function saveRecord({ values, form, schema, dataService, initialV
     schema: Schema<SchemaAttributes>;
     dataService: IDataService;
     schemaStore: ISchemaStore;
-}): Promise<SaveRecordResult>;
+}
+export type SaveRecordFn = (options: SaveRecordFnOptions) => Promise<SaveRecordResult>;
+export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: SaveRecordFnOptions): Promise<SaveRecordResult>;
 export {};

package/dataform/utils/saveRecord.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModifiedValues = getModifiedValues;
 exports.saveRecord = saveRecord;
-const DataResolver_1 = require("../../dataform/DataFormProvider/DataResolver");
+const utils_1 = require("../../dataform/DataFormProvider/utils");
 function getModifiedValues(initialValues, values, exclude) {
     const keys = Object.keys(values);
     return keys.reduce((p, c) => {
@@ -78,7 +78,7 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
     return operations;
 }
 async function createRecord({ values, form, schema, dataService, }) {
-    const controls = (0, DataResolver_1.getControls)(form);
+    const controls = (0, utils_1.getControls)(form);
     const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
     const result = await dataService.createRecord(schema.logicalName, values);
     const recordId = result[schema.idAttribute];
@@ -96,7 +96,7 @@ async function createRecord({ values, form, schema, dataService, }) {
     return recordId;
 }
 async function updateRecord({ recordId, values, form, schema, dataService, initialValues, schemaStore, }) {
-    const controls = (0, DataResolver_1.getControls)(form);
+    const controls = (0, utils_1.getControls)(form);
     const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
     const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.attributeName));
     const operations = [];
@@ -128,12 +128,16 @@ async function updateRecord({ recordId, values, form, schema, dataService, initi
     for (const operation of operations) {
         await executeOperation(operation, dataService);
     }
+    return {
+        success: true,
+        recordId,
+    };
 }
 async function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
     let recordId;
     if (record) {
         recordId = record[schema.idAttribute];
-        await updateRecord({
+        const updateResult = await updateRecord({
             recordId,
             values,
             form,
@@ -142,6 +146,7 @@ async function saveRecord({ values, form, schema, dataService, initialValues, re
             initialValues,
             schemaStore,
         });
+        return updateResult;
     }
     else {
         recordId = await createRecord({

package/mutable/context.d.ts

@@ -4,6 +4,9 @@ export type ContextValue<T> = MutableValue<T>;
 export declare const useContextSelectorInternal: typeof useMutableValueSelector;
 export declare function createContext<T>(): import("react").Context<ContextValue<T>>;
 export declare function useCreateContextStore<T>(initialValue: T): MutableValue<T>;
+export declare function useContextValue<T>(context: React.Context<ContextValue<T>>): {
+    current: T;
+};
 export declare function useContextSelector<T, R>(context: React.Context<ContextValue<T>>, selector: (state: T) => R): R;
 export declare function useContextSetValue<T>(context: React.Context<ContextValue<T>>): (value: Partial<T> | ((state: T) => Partial<T>)) => void;
 type Setter<T, U extends unknown[]> = (setValue: ContextValue<T>['setValue']) => (...args: U) => void;

package/mutable/context.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useContextSelectorInternal = void 0;
 exports.createContext = createContext;
 exports.useCreateContextStore = useCreateContextStore;
+exports.useContextValue = useContextValue;
 exports.useContextSelector = useContextSelector;
 exports.useContextSetValue = useContextSetValue;
 exports.useContextValueSetter = useContextValueSetter;
@@ -18,6 +19,13 @@ function useCreateContextStore(initialValue) {
     const [state] = (0, react_1.useState)(() => createContextValue(initialValue));
     return state;
 }
+function useContextValue(context) {
+    const contextValue = (0, react_1.useContext)(context);
+    if (!contextValue) {
+        throw new Error('useContextValue must be used within a Provider');
+    }
+    return contextValue.value;
+}
 function useContextSelector(context, selector) {
     const contextValue = (0, react_1.useContext)(context);
     if (!contextValue) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "0.0.17-alpha.59",
+  "version": "0.0.17-alpha.62",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -34,5 +34,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "813d07729a10a5613b46f012ba4b24bcaab384dc"
+  "gitHead": "7b4ba8b46dc270e88055b7352d74fae7a2363cd0"
 }

package/providers/PageEntityFormProvider/index.d.ts

@@ -1,11 +1,15 @@
 import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { PropsWithChildren } from 'react';
+import { RetriveRecordFn } from '../../dataform/DataFormProvider/types';
+import { SaveRecordFn } from '../../dataform/utils/saveRecord';
 interface PageEntityFormProviderProps<S extends SchemaAttributes> {
     schema: Schema<S>;
     form: Form<S>;
     recordId?: string;
     commands: EntityMainFormCommandItemExperience[][];
+    retriveRecordFn?: RetriveRecordFn<S>;
+    saveRecordFn?: SaveRecordFn;
 }
-export declare function PageEntityFormProvider<S extends SchemaAttributes>({ schema, form, recordId, children, commands, }: PropsWithChildren<PageEntityFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;
+export declare function PageEntityFormProvider<S extends SchemaAttributes>({ schema, form, recordId, children, commands, retriveRecordFn, saveRecordFn, }: PropsWithChildren<PageEntityFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;
 export {};

package/providers/PageEntityFormProvider/index.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageEntityFormProvider = PageEntityFormProvider;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const DataFormProvider_1 = require("../../dataform/DataFormProvider");
-function PageEntityFormProvider({ schema, form, recordId, children, commands, }) {
-    return ((0, jsx_runtime_1.jsx)(DataFormProvider_1.DataFormProvider, { schema: schema, form: form, recordId: recordId, commands: commands, children: children }));
+function PageEntityFormProvider({ schema, form, recordId, children, commands, retriveRecordFn, saveRecordFn, }) {
+    return ((0, jsx_runtime_1.jsx)(DataFormProvider_1.DataFormProvider, { schema: schema, form: form, recordId: recordId, commands: commands, retriveRecordFn: retriveRecordFn, saveRecordFn: saveRecordFn, children: children }));
 }

package/store/EventManager.d.ts

@@ -1,7 +1,7 @@
 import { IEventManager } from '@headless-adminapp/core/store';
 export declare class EventManager implements IEventManager {
     private handlers;
-    on<T>(key: string, handler: T): Promise<void>;
-    off<T>(key: string, handler: T): Promise<void>;
+    on<T>(key: string, handler: T): void;
+    off<T>(key: string, handler: T): void;
     emit(key: string, ...args: any[]): any[];
 }

package/store/EventManager.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventManager = void 0;
 class EventManager {
     handlers = {};
-    async on(key, handler) {
+    on(key, handler) {
         if (!this.handlers[key]) {
             this.handlers[key] = [];
         }
         this.handlers[key].push(handler);
     }
-    async off(key, handler) {
+    off(key, handler) {
         if (!this.handlers[key]) {
             return;
         }

package/transport/RestDataService/index.d.ts

@@ -16,8 +16,8 @@ export declare class RestDataService implements IDataService {
         [key in keyof T]?: string[];
     }): Promise<Data<T>>;
     retriveRecords<T = unknown>(params: RetriveRecordsFnOptions<T>): Promise<RetriveRecordsResult<T>>;
-    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
-    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
+    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core").Id>>;
+    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core").Id>>;
     deleteRecord(logicalName: string, id: string): Promise<void>;
     retriveAggregate<Q extends Record<string, AggregateAttribute> = Record<string, AggregateAttribute>>(query: AggregateQuery<Q>): Promise<InferredAggregateQueryResult<Q>[]>;
     customAction<T = unknown>(_actionName: string, _payload: unknown): Promise<T>;

package/transport/context.d.ts

@@ -1,4 +1,3 @@
 import { IDataService, IFileService } from '@headless-adminapp/core/transport';
 export declare const DataServiceContext: import("react").Context<IDataService | undefined>;
-export declare const noopFileService: IFileService;
-export declare const FileServiceContext: import("react").Context<IFileService>;
+export declare const FileServiceContext: import("react").Context<IFileService | null>;

package/transport/context.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileServiceContext = exports.noopFileService = exports.DataServiceContext = void 0;
+exports.FileServiceContext = exports.DataServiceContext = void 0;
 const react_1 = require("react");
 exports.DataServiceContext = (0, react_1.createContext)(undefined);
-exports.noopFileService = {
-    uploadFile: async () => {
-        throw new Error('File service not implemented');
-    },
-};
-exports.FileServiceContext = (0, react_1.createContext)(exports.noopFileService);
+// export const noopFileService = {
+//   uploadFile: async () => {
+//     throw new Error('File service not implemented');
+//   },
+// } as IFileService;
+exports.FileServiceContext = (0, react_1.createContext)(null);

package/transport/hooks/useFileService.d.ts

@@ -1 +1 @@
-export declare function useFileService(): import("@headless-adminapp/core/transport").IFileService;
+export declare function useFileService(): import("@headless-adminapp/core/transport").IFileService | null;

package/transport/hooks/useFileService.js

@@ -5,8 +5,5 @@ const react_1 = require("react");
 const context_1 = require("../context");
 function useFileService() {
     const context = (0, react_1.useContext)(context_1.FileServiceContext);
-    if (!context) {
-        throw new Error('FileServiceContext must be used within a FileServiceProvider');
-    }
     return context;
 }