ngx-t-forms-types 0.0.1

package/dist/interfaces/FormBuilder/inputConfig/ElementEditConfig.js

@@ -0,0 +1,644 @@
+import { CurrenciesList } from "../../../Configs/currencies";
+import { DatePipeOptions } from "../../../Configs/datePipes";
+import { ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from "../../formInput";
+import { DataSources } from "../../formInput/APIDataFetchingConfigurationInterface";
+import { InputFileType } from "../../formInput/FileUploadInputInterface";
+import { RichTextEditorType } from "../../formInput/RichTextEditorInput";
+import { LabelPosition } from "../../formInput/ToggleInputInterface";
+import { AllFormInputPrimaryKeys, SpecialElementKeys } from "../FormInputKeys";
+import { BlurHandleTypes, ElementEditorTypes } from "../elementEditor";
+export var ElementConfig = {
+    editorSections: [
+        {
+            label: 'Basic Configuration',
+            id: "4bc757c5-5830-4135-9bdc-df4d1aace7f1",
+            showItemValue: 'label',
+            elements: [
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [AllFormInputPrimaryKeys.ColSize],
+                    id: "bcc00a6b-4323-4cc8-9cb6-b3efc0aedfd2",
+                    editType: ElementEditorTypes.Range,
+                    min: 1,
+                    max: 12,
+                    step: 1,
+                    format: (value) => `${(value / 12) * 100} %`,
+                    hint: `The size determines the width of the input column in the form.
+                        A column size of 12 will take up the full width of the form, while a column size of 4 will take up a third of the form.
+                    `,
+                    label: 'Input column size',
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [AllFormInputPrimaryKeys.Label],
+                    editType: ElementEditorTypes.Input,
+                    id: "cbe76f17-7a33-481e-b945-38ba146ea194",
+                    label: 'Input label',
+                    blurHandle: BlurHandleTypes.PrePopulateFormControl,
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [AllFormInputPrimaryKeys.FormControlName],
+                    id: "8db68cde-52ca-4be6-9db9-e0d53217f00a",
+                    hint: 'The form control is an inputs unique identifier in the form group, and should be in CamelCase',
+                    editType: ElementEditorTypes.Input,
+                    label: 'Control name ',
+                    blurHandle: BlurHandleTypes.CleanFormControl,
+                },
+                {
+                    name: AllFormInputPrimaryKeys.Appearance,
+                    deepBind: [AllFormInputPrimaryKeys.Appearance],
+                    hint: 'Choose between filled or outlined input styling',
+                    id: 'a768dbcd-97e3-42c6-9299-b6b49842d813',
+                    editType: ElementEditorTypes.OptionSelect,
+                    options: ['fill', 'outline'].map((type) => ({ label: type, value: type })),
+                    label: 'Appearance',
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [AllFormInputPrimaryKeys.Required],
+                    id: '99cd6f5a-2bca-4cfb-832a-6ec2a9da40ae',
+                    editType: ElementEditorTypes.Toggle,
+                    label: 'Input is required',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.StartDateControl,
+                    id: "73b3f981-9f7d-4361-9aee-4507e20bf255",
+                    editType: ElementEditorTypes.Input,
+                    deepBind: [AllFormInputPrimaryKeys.StartDateControl],
+                    blurHandle: BlurHandleTypes.CleanFormControl,
+                    disabled: [
+                        //Don't allow editing if the form control name is already set
+                        {
+                            deepBind: [AllFormInputPrimaryKeys.Id],
+                            testType: 'exists'
+                        },
+                    ],
+                    hint: "Because a date range has two values representing the start end end value, you need to assign a form control name to the start date input.",
+                    label: 'Start Date Control name',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.EndDateControl,
+                    deepBind: [AllFormInputPrimaryKeys.EndDateControl],
+                    id: "a50917da-9129-434a-b2db-316dea2ff0a7",
+                    disabled: [
+                        //Don't allow editing if the form control name is already set
+                        {
+                            deepBind: [AllFormInputPrimaryKeys.Id],
+                            testType: 'exists'
+                        },
+                    ],
+                    editType: ElementEditorTypes.Input,
+                    blurHandle: BlurHandleTypes.CleanFormControl,
+                    label: 'End Date Control name',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.Type,
+                    editType: ElementEditorTypes.ChipSelect,
+                    deepBind: [AllFormInputPrimaryKeys.Type],
+                    id: "37e210dd-5e25-4bab-8a40-779770cf1f61",
+                    label: 'Input type',
+                    hint: 'The type of input determines the type of data that can be entered into the input',
+                    options: Object.values(InputTypes).map((type) => ({ label: type, value: type })),
+                },
+                {
+                    name: AllFormInputPrimaryKeys.FileType,
+                    editType: ElementEditorTypes.OptionSelect,
+                    deepBind: [AllFormInputPrimaryKeys.FileType],
+                    id: "fdde0f7a-5d18-497f-998b-74957cb1dc22",
+                    label: 'File Type',
+                    options: Object.values(InputFileType).map((type) => ({ label: type, value: type })),
+                },
+                {
+                    name: AllFormInputPrimaryKeys.SingleSelect,
+                    editType: ElementEditorTypes.Toggle,
+                    deepBind: [AllFormInputPrimaryKeys.SingleSelect],
+                    id: "b475bbc9-6316-427b-ab03-830e03b83d81",
+                    label: 'Restrict to a single upload',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.LabelPosition,
+                    editType: ElementEditorTypes.OptionSelect,
+                    id: "b70c056d-32d4-4fa0-918a-a0d4b5f84c94",
+                    deepBind: [AllFormInputPrimaryKeys.LabelPosition],
+                    label: 'Label position',
+                    options: Object.values(LabelPosition).map((type) => ({ label: type, value: type })),
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    id: "e7be625c-f771-4c09-b121-32e1b1ce72b1",
+                    deepBind: [AllFormInputPrimaryKeys.Min],
+                    additionalTest: [
+                        {
+                            expression: `type === ${InputTypes.Number} || type === ${InputTypes.Date}`,
+                        },
+                    ],
+                    editType: ElementEditorTypes.Input,
+                    label: 'Minimum value',
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [AllFormInputPrimaryKeys.Max],
+                    id: "04709d9d-53e8-4078-8833-425921cdc27c",
+                    additionalTest: [
+                        {
+                            expression: `type === ${InputTypes.Number} || type === ${InputTypes.Date}`,
+                        },
+                    ],
+                    editType: ElementEditorTypes.Input,
+                    label: 'Maximum value',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.MinLength,
+                    deepBind: [AllFormInputPrimaryKeys.MinLength],
+                    editType: ElementEditorTypes.Input,
+                    id: "a894e16f-2d7e-4dca-825f-452eef3aebcc",
+                    label: 'Min length of characters',
+                },
+                {
+                    name: AllFormInputPrimaryKeys.MaxLength,
+                    deepBind: [AllFormInputPrimaryKeys.MaxLength],
+                    editType: ElementEditorTypes.Input,
+                    label: 'Max length of characters',
+                    id: "9bc50894-5230-46f2-91de-b45673b3a80a"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.HandleLabel,
+                    deepBind: [AllFormInputPrimaryKeys.HandleLabel],
+                    editType: ElementEditorTypes.Input,
+                    label: 'Handle label',
+                    id: "3f056cc9-e639-4db7-aa41-3f96593356b2"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.MscoaConfig,
+                    editType: ElementEditorTypes.Toggle,
+                    label: 'Allow selection of all mscoa segments',
+                    deepBind: ['mscoaConfig', 'showAllSegments'],
+                    clearOnChange: [
+                        [AllFormInputPrimaryKeys.MscoaConfig, 'segments'],
+                    ],
+                    hint: 'If enabled, the user can select any segment from the MScoa configuration',
+                    id: "0f78efcc-5477-4202-916a-8a7cf459c017"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.MscoaConfig,
+                    deepBind: ['mscoaConfig', 'segments'],
+                    editType: ElementEditorTypes.ConfigMscoaSegments,
+                    label: 'Configure MScoa segments',
+                    fetchOptions: ['mscoaConfig', 'showAllSegments'],
+                    id: "ba1a5b79-b071-44a6-b39a-bf1c2fafcda5"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.RichTextEditorLibrary,
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Rich text editor library',
+                    deepBind: [AllFormInputPrimaryKeys.RichTextEditorLibrary],
+                    additionalTest: [
+                        {
+                            expression: `element === ${ElementTypes.Editor}`,
+                            deepBind: ['element'],
+                        },
+                    ],
+                    options: Object.values(RichTextEditorType).map((type) => ({ label: type, value: type })),
+                    id: "9e98d072-cea9-4ee0-a085-0a8998ec0d7a"
+                }
+            ],
+        },
+        {
+            label: 'Input value configurations',
+            id: "ce6e8786-45c3-4167-a84c-e871da0c13aa",
+            elements: [
+                {
+                    name: AllFormInputPrimaryKeys.Value,
+                    editType: ElementEditorTypes.Input,
+                    label: 'Default value',
+                    hint: 'Set a default value for the input',
+                    deepBind: [AllFormInputPrimaryKeys.Value],
+                    id: "791d7452-765c-47db-bb15-cd9b3c58a259"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.DataType,
+                    deepBind: [AllFormInputPrimaryKeys.DataType],
+                    editType: ElementEditorTypes.ChipSelect,
+                    hint: 'The data type is the type of data that the input will hold.Data types are used to validate the input data',
+                    label: 'Data value type',
+                    id: "07e33ac0-ba36-48b9-989f-a33293f93051",
+                    options: Object.values(InputDataTypes).map((type) => ({ label: type, value: type })),
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.Toggle,
+                    deepBind: [AllFormInputPrimaryKeys.Readonly],
+                    label: 'Set as readonly field',
+                    id: "cdc5173b-8464-4e03-b0fb-6258437fa50b"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.IServeInputWithRequisitionItems,
+                    deepBind: ['iServeInputWithRequisitionItems'],
+                    editType: ElementEditorTypes.FormInputSelector,
+                    label: 'Select Input with requisitions',
+                    id: "4a976294-451e-4501-a02a-b5df76254beb"
+                },
+                /// NOTE: Caluculated field rules
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.Toggle,
+                    deepBind: [AllFormInputPrimaryKeys.IsCalculatedField],
+                    additionalTest: [
+                        {
+                            expression: `type === number`,
+                            deepBind: ['type'],
+                        },
+                    ],
+                    label: 'Is calculated field',
+                    clearOnChange: [
+                        ['calculatedFieldRules'],
+                    ],
+                    id: "6443ed57-665a-4d0e-8487-33a6e2278f27"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.CalculatedFieldRules,
+                    label: 'Is calculated form field',
+                    deepBind: ['calculatedFieldRules'],
+                    fetchOptions: [],
+                    additionalTest: [
+                        {
+                            expression: `isCalculatedField === true`,
+                            deepBind: ['isCalculatedField'],
+                        },
+                    ],
+                    id: "70aa312f-ee21-4970-a8a7-6fd6c9d572f1"
+                },
+            ],
+        },
+        {
+            label: 'Data mapping for value',
+            id: "d4d792af-c983-4587-a94f-781d7b963b4d",
+            elements: [
+                {
+                    name: AllFormInputPrimaryKeys.MatOptions,
+                    deepBind: ['matOptions', 'fetch', 'value', 'source'],
+                    hint: `Choose data source for input values - affects how values are populated and which configuration options become available`,
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Select value source',
+                    clearOnChange: [
+                        ['matOptions', 'fetch', 'value'],
+                    ],
+                    options: [
+                        { label: 'Form Input', value: DataSources.Local },
+                        { label: 'Postman API', value: DataSources.Api },
+                        { label: 'Data Pipeline', value: DataSources.MongoDb },
+                    ],
+                    id: "18361155-034d-40dd-a445-a493437ed5fc"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'value', 'inputSourceId'],
+                    editType: ElementEditorTypes.FormInputSelector,
+                    hint: `Links this field to a source input: when the source input's value changes, this field will automatically update to match.This creates a dynamic connection between fields.`,
+                    additionalTest: [
+                        {
+                            expression: `source === ${DataSources.Local}`,
+                            deepBind: ['matOptions', 'fetch', 'value', 'source'],
+                        },
+                    ],
+                    label: 'Select Input To fetch Data from',
+                    id: "865658d5-6ba4-4402-952f-731cfaeefb76"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'value'],
+                    editType: ElementEditorTypes.ApiCall,
+                    additionalTest: [
+                        {
+                            expression: `source === ${DataSources.Api}`,
+                            deepBind: ['matOptions', 'fetch', 'value', 'source'],
+                        },
+                    ],
+                    clearOnChange: [
+                        ['matOptions', 'fetch', 'value'],
+                    ],
+                    hint: `APIs are loaded from Postman collection. Configure required headers, payload format, and response mapping before use. Ensure API is documented in Postman.`,
+                    label: 'Select API to fetch data from',
+                    id: "95724e64-9d5b-4260-866c-4ada95670b46"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'value'],
+                    editType: ElementEditorTypes.MongoPipelineBuilder,
+                    hint: `MongoDb pipelines are used to fetch data from a MongoDb database. 
+                    Configure the pipeline to fetch the required data before use.`,
+                    additionalTest: [
+                        {
+                            expression: `source === ${DataSources.MongoDb}`,
+                            deepBind: ['matOptions', 'fetch', 'value', 'source'],
+                        },
+                    ],
+                    label: 'Configure a MongoDb data pipeline',
+                    id: "7b2989ae-2f54-4849-93d0-aff56ac12ef2"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [
+                        'matOptions',
+                        'fetch',
+                        'value',
+                        'backEndConfig',
+                        'minimumInputRequired',
+                    ],
+                    additionalTest: [
+                        {
+                            testType: 'exists',
+                            deepBind: [
+                                'matOptions',
+                                'fetch',
+                                'value',
+                                'backEndConfig',
+                                'minimumInputRequired',
+                            ],
+                        }
+                    ],
+                    hint: `These are payload fields that are required to be filled in order to fetch data from the selected source`,
+                    editType: ElementEditorTypes.RequiredInputs,
+                    label: 'Set up required inputs',
+                    id: "2d0f1e18-897b-4c28-97bc-3078be09f8ee"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'value', 'valueAccessRules'],
+                    hint: `Map the fetched data to the input value. This is useful when the fetched data is an object and you want to map a specific field to the input value.It also allow data transformation before setting the value`,
+                    fetchOptions: ['matOptions', 'fetch', 'value', '_id'],
+                    additionalTest: [
+                        {
+                            testType: 'exists',
+                            // Because only Api calls have value access rules
+                            deepBind: ['matOptions', 'fetch', 'value'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.ApiValueAccessRules,
+                    label: 'Map value to fetched data',
+                    id: "26939f46-e8ed-404c-886e-2838495d56e6"
+                },
+            ]
+        },
+        {
+            label: 'Data Configuration for options',
+            id: "a283ec41-0397-494c-b78d-51c18414a343",
+            elements: [
+                {
+                    name: AllFormInputPrimaryKeys.MatOptions,
+                    deepBind: ['matOptions', 'fetch', 'options', 'source'],
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Select options source',
+                    clearOnChange: [
+                        ['matOptions', 'fetch', 'options'],
+                    ],
+                    options: [
+                        { label: 'Custom options', value: DataSources.CustomOptions },
+                        { label: 'Form Input', value: DataSources.Local },
+                        { label: 'Postman API', value: DataSources.Api },
+                        { label: 'Data Pipeline', value: DataSources.MongoDb },
+                    ],
+                    id: "114b794c-0288-4253-915c-ac8456191698"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'options'],
+                    additionalTest: [
+                        {
+                            expression: `source === ${DataSources.CustomOptions}`,
+                            deepBind: ['matOptions', 'fetch', 'options', 'source'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.SelectionOptions,
+                    label: 'Configure options',
+                    id: "622142bb-9794-48a5-8cb7-4b503220259a"
+                },
+                {
+                    name: SpecialElementKeys.MatOptionsItemType,
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Option item type',
+                    deepBind: ['matOptions', 'optionType'],
+                    additionalTest: [
+                        {
+                            expression: `element === select`,
+                            deepBind: ['element'],
+                        },
+                    ],
+                    options: [
+                        { label: 'Text', value: 'text' },
+                        { label: 'User', value: 'user' },
+                    ],
+                    id: "d46d9261-f777-4ff5-9436-c9f7b119f5e0"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'options', 'inputSourceId'],
+                    editType: ElementEditorTypes.FormInputSelector,
+                    additionalTest: [
+                        {
+                            expression: `source === ${DataSources.Local}`,
+                            deepBind: ['matOptions', 'fetch', 'options', 'source'],
+                        },
+                    ],
+                    label: 'Select Input To fetch Options Data from',
+                    id: "8c8e62ee-a4f0-4129-8e3b-8270669ff716"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'options'],
+                    additionalTest: [
+                        {
+                            expression: "source === mongoPipeline",
+                            deepBind: ['matOptions', 'fetch', 'options', 'source'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.MongoPipelineBuilder,
+                    label: 'Configure a MongoDb data pipeline',
+                    id: "4e31a786-ec96-4b42-8156-31357958c032"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'options'],
+                    additionalTest: [
+                        {
+                            expression: "source === api",
+                            deepBind: ['matOptions', 'fetch', 'options', 'source'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.ApiCall,
+                    label: 'Select API to fetch data from',
+                    id: "df9e2a34-7bf5-411e-a265-14ca4f85166d"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [
+                        'matOptions',
+                        'fetch',
+                        'options',
+                        'backEndConfig',
+                        'minimumInputRequired',
+                    ],
+                    additionalTest: [
+                        {
+                            testType: 'exists',
+                            deepBind: [
+                                'matOptions',
+                                'fetch',
+                                'options',
+                                'backEndConfig',
+                                'minimumInputRequired',
+                            ],
+                        }
+                    ],
+                    editType: ElementEditorTypes.RequiredInputs,
+                    label: 'Set up required inputs',
+                    id: "ce8f3b42-340d-4f3e-8d6a-13c93251173f"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'options', 'valueAccessRules'],
+                    fetchOptions: ['matOptions', 'fetch', 'options', '_id'],
+                    additionalTest: [
+                        {
+                            testType: 'exists',
+                            deepBind: ['matOptions', 'fetch', 'options'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.ApiValueAccessRules,
+                    label: 'Map option value to fetched data',
+                    id: "e24ce283-4cea-497e-b692-feeb4f3afbed"
+                },
+            ]
+        },
+        {
+            label: 'Validation & Formatting',
+            id: "1d3149de-d1e9-4b51-93c4-5cb82e51107c",
+            elements: [
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.Toggle,
+                    deepBind: [AllFormInputPrimaryKeys.OnlySetTempErrorOnTouch],
+                    label: 'Set temporary errors only on touch',
+                    hint: 'If enabled, the input will only show errors when the user interacts with the input',
+                    id: "264bf529-c0f1-4393-b6fd-1d5eb48fce91"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.Input,
+                    deepBind: [AllFormInputPrimaryKeys.HintLabel],
+                    label: 'Input hint',
+                    id: "6a047c2f-ff33-4154-8c07-90d5272346a4"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.TourContent,
+                    editType: ElementEditorTypes.Input,
+                    deepBind: [AllFormInputPrimaryKeys.TourContent,],
+                    label: 'App tour message',
+                    id: "a72704ba-d2a9-4884-bc90-14dac84b7d23"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.Spellcheck,
+                    editType: ElementEditorTypes.Toggle,
+                    deepBind: [AllFormInputPrimaryKeys.Spellcheck],
+                    label: 'Enable spellcheck',
+                    id: "ca2cf43b-8614-4a5e-b664-3cf96b9d239f"
+                },
+                {
+                    name: SpecialElementKeys.DefaultValuePipe,
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Add a value pipe',
+                    deepBind: ['pipe', 'pipeType'],
+                    additionalTest: [
+                        {
+                            expression: `type === ${InputTypes.Number}`,
+                            deepBind: ['type'],
+                        },
+                    ],
+                    id: "328e8d2b-86a9-4ccd-8adc-635393c1c3a9",
+                    options: Object.values(InputPipeTypes).map((type) => ({ label: type, value: type })),
+                },
+                {
+                    name: SpecialElementKeys.DefaultCurrencySelect,
+                    editType: ElementEditorTypes.OptionSelect,
+                    deepBind: ['pipe', 'param'],
+                    label: 'Select currency to apply',
+                    options: CurrenciesList,
+                    id: "209d2295-cbaa-4f99-98d2-15c4515581b8",
+                    additionalTest: [
+                        {
+                            expression: `type === ${InputTypes.Number}`,
+                            deepBind: ['type'],
+                        },
+                        {
+                            expression: `pipeType === ${InputPipeTypes.Currency}`,
+                            deepBind: ['pipe', 'pipeType'],
+                        },
+                    ],
+                },
+                {
+                    name: SpecialElementKeys.DefaultValuePipe,
+                    editType: ElementEditorTypes.OptionSelect,
+                    deepBind: ['pipe', 'param'],
+                    label: 'Select date format',
+                    options: DatePipeOptions,
+                    additionalTest: [
+                        {
+                            expression: `pipeType === ${InputPipeTypes.Date}`,
+                            deepBind: ['pipe', 'pipeType'],
+                        },
+                    ],
+                    id: "36b8e1e1-625b-422a-8aa8-b594f3524bcc"
+                },
+                {
+                    name: SpecialElementKeys.DefaultDecimalNumberInput,
+                    editType: ElementEditorTypes.Input,
+                    label: 'Decimal numbers',
+                    deepBind: ['pipe', 'param'],
+                    additionalTest: [
+                        {
+                            expression: `type === ${InputTypes.Number}`,
+                            deepBind: ['type'],
+                        },
+                        {
+                            expression: `pipeType === ${InputPipeTypes.Decimal}`,
+                            deepBind: ['pipe', 'pipeType'],
+                        },
+                    ],
+                    id: "d0771f0e-eaec-457c-a2f4-e454fd9092c7"
+                },
+                {
+                    name: SpecialElementKeys.Default,
+                    editType: ElementEditorTypes.Input,
+                    label: "On change event",
+                    deepBind: ['script', 'onChange'],
+                    id: "cece038b-66b2-4e23-b3a3-01902ff342c3"
+                },
+                {
+                    name: AllFormInputPrimaryKeys.Validators,
+                    editType: ElementEditorTypes.Validators,
+                    label: 'Add Validators',
+                    deepBind: ['validators'],
+                    id: "babd1b19-aa49-41b6-bd06-1c34ea2b9fe0"
+                },
+            ],
+        },
+    ],
+};
+export const getElementEditorConfig = deepCopy(ElementConfig);
+function deepCopy(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => deepCopy(item));
+    }
+    const copy = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            copy[key] = deepCopy(obj[key]);
+        }
+    }
+    return copy;
+}

package/dist/interfaces/FormBuilder/inputConfig/getInputValueFromElement.d.ts

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

package/dist/interfaces/FormBuilder/inputConfig/getInputValueFromElement.js

@@ -0,0 +1,37 @@
+import { ElementTypes, InputDataTypes, MinInputTypes } from "../../formInput";
+import { DataSources } from "../../formInput/APIDataFetchingConfigurationInterface";
+import { ElementEditorTypes } from "../elementEditor";
+function elementValue(element) {
+    const editType = element.editType;
+    switch (editType) {
+        case ElementEditorTypes.ApiCall:
+            return {
+                valueAccessRules: [],
+                source: DataSources.Api,
+                _id: '89445d2e-ea0a-4207-a393-e7b0a83e9f690',
+                name: 'Api Call',
+                httpEndPoint: 'localhost:3000/api',
+                httpMethod: 'POST',
+                postFormData: true,
+                backEndConfig: {
+                    minimumInputRequired: [
+                        {
+                            name: 'value',
+                            type: MinInputTypes.MapTo,
+                            mapTo: [
+                                {
+                                    formControlName: 'value',
+                                    dataType: InputDataTypes.String,
+                                    element: ElementTypes.Input
+                                }
+                            ],
+                        }
+                    ]
+                }
+            };
+        case ElementEditorTypes.
+            default:
+            return 'text';
+            break;
+    }
+}