How do I pass additional parameters to normalize? - redux-form

Question

I have a field called "decimal" and with this field, I also have a property called "precision". So my field could be 0.00 or 0.000... etc.
Now I can have a normalize function that allows only numbers and one period, but I also need to pass something that tells me the precision of the field. What can I do here?
I guess I could create precisionOne(),precisionTwo(), precisionThree() etc.. but that seems like a lot of code duplication, for what would be precision(value, previousValue, precision)
EDIT: I've added some code below. It's pretty standard and made up of a few key parts:
createField.js = this is basically my component that receives the fields.json that holds the fields object, and their keys: {row_position, id, identifier, required, min_length, max_length, field_type}
field_type could be: number, text, decimal, date etc.
const row = [];
for(let j = fields.length - 1 - 1; j > 0; j--) {
const {row_position, id, identifier, required, min_length, max_length, field_type} = fields[j];
const validations = [];
//As of now normalize can only be one fuction
let normalize = null;
/// SETUP VALIDATIONS FOR FIELDS ///
if(required) {validations.push(validationFunctions.required)}; // REQUIRED
if(field_type === 3) {validations.push(validationFunctions.email)}; //EMAIL
if(field_type === 4) {validations.push(validationFunctions.number); normalize = normalizeFunctions.number;}; //NUMBER
if(field_type === 7) {validations.push(validationFunctions.number); normalize = normalizeFunctions.decimal;}; //DECIMAL
row.unshift(<Field key={id} name={identifier} component={renderField} validate={validations} normalize={normalize} props={fields[j]}/>);
}
this is my renderField component:
import React from 'react';
import {padWithZero} from '../../helpers/objectManipulationHelpers';
//Get field to display based on type
export default function constructField(field) {
const {input, type, field_type, className, cols, precision, required, id, identifier, addOn} = field;
let fieldTypeBasedCss = '';
let typeAddOn = null;
let iconAddOn = null;
let _precision = null;
let fieldType = 'text';
switch(field_type) {
case 2:
fieldType = 'password';
typeAddOn = <span class="fa fa-asterisk" aria-hidden="true"/>;
break;
case 3:
fieldTypeBasedCss = 'email-field';
typeAddOn = <span class="fa fa-at" aria-hidden="true"/>;
break;
case 4:
fieldTypeBasedCss = 'number-field';
typeAddOn = <span class="fa fa-sort-numeric-asc" aria-hidden="true"/>;
break;
case 6:
fieldTypeBasedCss = 'money-field';
typeAddOn = '$';
break;
case 7:
fieldTypeBasedCss = 'decimal-field';
typeAddOn = padWithZero('0.', precision + 2);
_precision = precision;
break;
case 8:
fieldTypeBasedCss = 'percent-field';
_precision = precision;
typeAddOn = '%';
break;
}
const css = `${className} ${fieldTypeBasedCss}`;
switch(type) {
//Type Text
case 0:
return (
<div className={typeAddOn || addOn ? 'input-group' : ''}>
{addOn ? <span class="input-group-addon" dangerouslySetInnerHTML={{__html: addOn}} /> : ''}
<input {...input} required={required} type={fieldType} size={cols} class={`form-control ${css}`} data-field-id={id} data-field-identifier={identifier} data-precision={_precision}/>
{typeAddOn ? <span class="input-group-addon">{typeAddOn}</span> : ''}
</div>
);
//....more field types below...
//.....
}
}
Now here is the important part:
My formNormalize.js holds all my normalizer functions like so:
//Intercept user input and return valid value field
//Force uppercase
export const upper = value => value && value.toUpperCase();
//Force lowercase
export const lower = value => value && value.toLowerCase();
//Force number
export const number = function(value, previousValue) {
return value.replace(/[^\d]/g, '');
};
//Here I need another variable passed that's called "precision" or
//something that let's me use the same function to return either 0.00 or
//0.000 etc depending on the precision of the decimal field. Right now the
//function will return any valid decimal number, so 0.0 or 0.00 or 0.0000000
//anything, but I need to be able to limit the number of decimal places.
export const decimal = function(value, previousValue) {
if(value && !isNaN(Number(value))){
return value;
} else {
return previousValue;
};
};

Answer 1

Your normalizer can take additional parameters like so:
export const normalizeWhatever = (paramOne,paramTwo) =>
(value, previousValue, allValues) => {
console.log(paramOne,paramTwo,value)
}