@headless-adminapp/app 0.0.17-alpha.8 → 1.0.0

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

@@ -0,0 +1,6 @@
+import { FormExperience } from '@headless-adminapp/core/experience/form';
+import { Schema } from '@headless-adminapp/core/schema';
+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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormDefaultParameters = getFormDefaultParameters;
+exports.setFormDefaultParameters = setFormDefaultParameters;
+let formDefaultParameters = null;
+function getFormDefaultParameters(schema, formExperience) {
+    const _values = formDefaultParameters?.values;
+    const _logicalName = formDefaultParameters?.logicalName;
+    const schemaDefaultValues = Object.keys(schema.attributes).reduce((acc, key) => {
+        const attribute = schema.attributes[key];
+        let defaultValue = attribute.default;
+        if (typeof defaultValue === 'function') {
+            defaultValue = defaultValue();
+        }
+        if (defaultValue instanceof Date) {
+            defaultValue = defaultValue.toISOString();
+        }
+        return {
+            ...acc,
+            [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) {
+        defaultValues = {
+            ...defaultValues,
+            ..._values,
+        };
+    }
+    return defaultValues;
+}
+let defaultParamsTimeout = null;
+function setFormDefaultParameters(logicalName, values) {
+    formDefaultParameters = {
+        logicalName,
+        values,
+    };
+    if (defaultParamsTimeout) {
+        clearTimeout(defaultParamsTimeout);
+    }
+    defaultParamsTimeout = setTimeout(() => {
+        formDefaultParameters = null;
+    }, 5000);
+}

package/dataform/utils/index.d.ts

@@ -2,32 +2,13 @@ import type { Attribute } from '@headless-adminapp/core/attributes';
 import { Form } from '@headless-adminapp/core/experience/form';
 import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { ISchemaStore } from '@headless-adminapp/core/store';
-import { IDataService } from '@headless-adminapp/core/transport';
 import { Nullable } from '@headless-adminapp/core/types';
 import { MemoizedFunction } from 'lodash';
 import { ResolverResult } from 'react-hook-form';
 import * as yup from 'yup';
 import { FormValidationStringSet } from '../../form/FormValidationStringContext';
-export declare function getModifiedValues(initialValues: any, values: any, exclude?: string[]): Record<string, any>;
-type SaveRecordResult = {
-    success: true;
-    recordId: string;
-} | {
-    success: false;
-    title?: string;
-    message: string;
-    isError: boolean;
-};
-export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: {
-    values: any;
-    form: Form<SchemaAttributes>;
-    record: InferredSchemaType<SchemaAttributes> | undefined;
-    initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
-    schema: Schema<SchemaAttributes>;
-    dataService: IDataService;
-    schemaStore: ISchemaStore;
-}): Promise<SaveRecordResult>;
-export declare function getInitialValues({ cloneRecord, form, record, recordId, defaultParameters, }: {
+export { saveRecord } from './saveRecord';
+export declare function getInitialValues({ cloneRecord, form, record, recordId, schema, defaultParameters, }: {
     cloneRecord: InferredSchemaType<SchemaAttributes> | undefined;
     form: Form<SchemaAttributes>;
     record: InferredSchemaType<SchemaAttributes> | undefined;
@@ -43,10 +24,11 @@ interface FormValidatorOptions<A extends SchemaAttributes = SchemaAttributes> {
     readonlyAttributes?: string[];
     strings: FormValidationStringSet;
     schemaStore: ISchemaStore;
+    region: string;
 }
 type FormValidator = (<A extends SchemaAttributes = SchemaAttributes>(options: FormValidatorOptions<A>) => (values: Record<string, any>, context: any, options: any) => Promise<ResolverResult<{}>>) & MemoizedFunction;
 export declare const formValidator: FormValidator;
-export declare const generateValidationSchema: (<A extends SchemaAttributes = SchemaAttributes>({ columns, editableGrids, language, schema, strings, readonlyAttributes, }: {
+export declare const generateValidationSchema: (<A extends SchemaAttributes = SchemaAttributes>({ columns, editableGrids, language, schema, strings, readonlyAttributes, region, }: {
     schema: Schema<A>;
     columns: string[];
     readonlyAttributes?: string[];
@@ -58,10 +40,10 @@ export declare const generateValidationSchema: (<A extends SchemaAttributes = Sc
     }> | undefined;
     language: string;
     strings: FormValidationStringSet;
+    region: string;
 }) => yup.ObjectSchema<{
     [x: string]: any;
 }, yup.AnyObject, {
     [x: string]: any;
 }, "">) & MemoizedFunction;
-export declare const generateAttributeValidationSchema: ((attribute: Attribute, language: string, strings: FormValidationStringSet) => yup.Schema<any, any, any, "">) & MemoizedFunction;
-export {};
+export declare const generateAttributeValidationSchema: ((attribute: Attribute, language: string, strings: FormValidationStringSet, region: string) => yup.Schema<any, any, any, "">) & MemoizedFunction;