@bolttech/form-engine-core 1.0.10 → 1.1.0

package/date.d.ts

@@ -0,0 +1,582 @@
+import { TCurrencyLocalCode } from '@gaignoux/currency';
+
+/**
+ * @type TFormValues<T>
+ * Represents the values and state of a form. It has a generic type that allows the importer to determine which type values key will return.
+ *
+ * @property {Generic Type} values - The current values of the form fields.
+ * @property {string[]} erroredFields - A list of field names that have errors.
+ * @property {boolean} isValid - Indicates whether the form is valid.
+ *
+ * @example
+ * ```typescript
+ * const formValues: TFormValues = {
+ *   values: { name: 'John', age: 30 },
+ *   erroredFields: ['email'],
+ *   isValid: false
+ * };
+ * ```
+ */
+type TFormValues<T> = {
+    values: T;
+    metadata: unknown;
+    erroredFields: string[];
+    isValid: boolean;
+};
+
+/** @virtual */
+
+/**
+ * @type TLengthValidation
+ * Represents the validation rules based on the length of the input.
+ *
+ * @property {'equal' | 'notEqual' | 'less' | 'lessOrEqual' | 'greater' | 'greaterOrEqual'} rule - The rule to apply.
+ * @property {number} target - The target value to compare against.
+ *
+ * @example
+ * ```typescript
+ * const lengthValidation: TLengthValidation = { rule: 'greaterOrEqual', target: 8 };
+ * ```
+ */
+type TLengthValidation = {
+    rule: 'equal' | 'notEqual' | 'less' | 'lessOrEqual' | 'greater' | 'greaterOrEqual';
+    target: number;
+};
+/**
+ * @type TCallbackValidation
+ * A custom validation function.
+ *
+ * @param {unknown} value - The value to validate.
+ * @returns {boolean} - The result of the validation.
+ *
+ * @example
+ * ```typescript
+ * const callbackValidation: TCallbackValidation = (value) => typeof value === 'string';
+ * ```
+ */
+type TCallbackValidation = (value: unknown, formValues: Pick<TFormValues<unknown>, 'values' | 'metadata'>) => boolean;
+/**
+ * @type TBetweenValidation
+ * Represents validation rules that check if a value is between a range.
+ *
+ * @property {number} start - The start of the range.
+ * @property {number} end - The end of the range.
+ *
+ * @example
+ * ```typescript
+ * const betweenValidation: TBetweenValidation = { start: 1, end: 10 };
+ * ```
+ */
+type TBetweenValidation = {
+    start: number;
+    end: number;
+};
+/**
+ * @type TCreditCardMatch
+ * Represents the options for credit card matching.
+ *
+ * @property {string} numberCard - The credit card number.
+ * @property {string[]} availableOptions - The available options for matching.
+ *
+ * @example
+ * ```typescript
+ * const creditCardMatch: TCreditCardMatch = { numberCard: '1234', availableOptions: ['Visa', 'MasterCard'] };
+ * ```
+ */
+type TCreditCardMatch = {
+    numberCard: string;
+    availableOptions: string[];
+};
+/**
+ * @type TDocumentValidation
+ * Represents validation for specific document types.
+ *
+ * @property {'NIF' | 'NIE' | 'CIF' | 'IBAN'} type - The type of document.
+ * @property {TCurrencyLocalCode} [locale] - The locale code for validation.
+ *
+ * @example
+ * ```typescript
+ * const documentValidation: TDocumentValidation = { type: 'NIF', locale: 'ES' };
+ * ```
+ */
+type TDocumentValidation = {
+    type: 'NIF' | 'NIE' | 'CIF' | 'IBAN';
+    locale?: TCurrencyLocalCode;
+};
+/**
+ * @type TDateOperatorsValidation
+ * Represents the operators used for date validation conditions.
+ *
+ * @property {'<' | '>' | '===' | '>=' | '<=' | '!==' | '!!origin'}
+ *
+ * @example
+ * ```typescript
+ * const operator: TDateOperatorsValidation = '<';
+ * ```
+ */
+type TDateOperatorsValidation = '<' | '>' | '===' | '>=' | '<=' | '!==' | '!!origin';
+/**
+ * @type TConditionsValidationSet
+ * Represents a single validation condition set.
+ *
+ * @property {boolean} [forceDefinedOrigin] - Flag to force the origin value to be defined.
+ * @property {boolean} [forceDefinedTarget] - Flag to force the target value to be defined.
+ * @property {string | number | boolean} [origin] - The origin value for the condition.
+ * @property {TDateOperatorsValidation} condition - The validation condition operator.
+ * @property {string | number | boolean} [target] - The target value for the condition.
+ *
+ * @example
+ * ```typescript
+ * const conditionSet: TConditionsValidationSet = {
+ *   forceDefinedOrigin: true,
+ *   forceDefinedTarget: true,
+ *   origin: '2023-01-01',
+ *   condition: '>',
+ *   target: '2022-01-01'
+ * };
+ * ```
+ */
+type TConditionsValidationSet = {
+    forceDefinedOrigin?: boolean;
+    forceDefinedTarget?: boolean;
+    origin?: string | number | boolean | null;
+    condition: TDateOperatorsValidation;
+    target?: string | number | boolean;
+};
+/**
+ * @type TConditionsValidation
+ * Represents a set of validation conditions.
+ *
+ * @property {'and' | 'or'} rule - The logical rule to combine the conditions (AND/OR).
+ * @property {TConditionsValidationSet[]} set - The array of validation condition sets.
+ * @property {TConditionsValidation} [conditions] - Nested conditions for more complex validation logic.
+ *
+ * @example
+ * ```typescript
+ * const conditionsValidation: TConditionsValidation = {
+ *   rule: 'and',
+ *   set: [
+ *     {
+ *       forceDefinedOrigin: true,
+ *       forceDefinedTarget: true,
+ *       origin: '2023-01-01',
+ *       condition: '>',
+ *       target: '2022-01-01'
+ *     }
+ *   ],
+ *   conditions: {
+ *     rule: 'or',
+ *     set: [
+ *       {
+ *         origin: true,
+ *         condition: '!!origin',
+ *         target: false
+ *       }
+ *     ]
+ *   }
+ * };
+ * ```
+ */
+type TConditionsValidation = {
+    rule: 'and' | 'or';
+    set: TConditionsValidationSet[];
+    conditions?: TConditionsValidation;
+};
+type TAvailableValidations = Omit<TValidationMethods, 'multipleValidations'> | TGenericValidationRule;
+/**
+ * @type TMultipleValidation
+ * Represents a set of multiple validation methods combined with a logical rule.
+ *
+ * @property {'AND' | 'OR' | 'NOT'} rule - The logical rule to combine the validation methods (AND, OR, NOT).
+ * @property {TAvailableValidations} validations - The validation methods to be combined.
+ *
+ * @example
+ * ```typescript
+ * const multipleValidation: TMultipleValidation = {
+ *   rule: 'AND',
+ *   validations: {
+ *     required: true,
+ *     min: 5,
+ *     max: 10
+ *   }
+ * };
+ * ```
+ */
+type TMultipleValidation = {
+    rule: 'AND' | 'OR' | 'NOT';
+    validations: TAvailableValidations;
+};
+/**
+ * @type TBetweenDatesValidation
+ * Represents a validation method to check if a value falls between specified dates.
+ *
+ * @property {TDateValidation[]} [TBetweenDatesValidation] - An array of date validation methods.
+ *
+ * @example
+ * ```typescript
+ * const betweenDatesValidation: TBetweenDatesValidation = [
+ *    {
+ *      onlyValidDate: true,
+ *      operator: '>=',
+ *      origin: {
+ *        format: 'MMDDYYYY',
+ *        intervals: {
+ *          years: 1
+ *        }
+ *      },
+ *      target: {
+ *        value: Date.now(),
+ *        format: 'timestamp',
+ *        value: '01/01/2023',
+ *      }
+ *    },
+ *    {
+ *      onlyValidDate: true,
+ *      operator: '<=',
+ *      origin: {
+ *        format: 'MMDDYYYY',
+ *        intervals: {
+ *          years: 1
+ *        }
+ *      },
+ *      target: {
+ *        format: 'timestamp',
+ *        value: '31/12/2023',
+ *      }
+ *    }
+ * ];
+ * ```
+ */
+type TBetweenDatesValidation = TDateValidation[];
+/**
+ * @type TDateFormatsValidation
+ * Represents the supported date formats for validation.
+ *
+ * @type {'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD' | 'YYYYDDMM' | 'timestamp'}
+ *
+ * @example
+ * ```typescript
+ * const dateFormat: TDateFormatsValidation = 'MMDDYYYY';
+ * ```
+ */
+type TDateFormatsValidation = 'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD' | 'YYYYDDMM' | 'timestamp';
+type TDateInterval = {
+    years?: number;
+    months?: number;
+    days?: number;
+};
+/**
+ * @type TDateValidation
+ * Represents a validation method for date values.
+ *
+ * @property {boolean} [onlyValidDate] - Flag to validate only if the date is valid.
+ * @property {TDateOperatorsValidation} operator - The validation operator to be used.
+ * @property {Object} origin - The origin date configuration.
+ * @property {string | number} [origin.value] - The origin date value.
+ * @property {TDateFormatsValidation} origin.format - The format of the origin date.
+ * @property {Object} [origin.intervals] - The intervals to add to the origin date for comparison.
+ * @property {number} [origin.intervals.years] - The number of years to add.
+ * @property {number} [origin.intervals.months] - The number of months to add.
+ * @property {number} [origin.intervals.days] - The number of days to add.
+ * @property {Object} [target] - The target date configuration.
+ * @property {string | number} target.value - The target date value.
+ * @property {TDateFormatsValidation} target.format - The format of the target date.
+ *
+ * @example
+ * ```typescript
+ * const dateValidation: TDateValidation = {
+ *   onlyValidDate: true,
+ *   operator: '===',
+ *   origin: {
+ *     value: '10/10/2022',
+ *     format: 'MMDDYYYY',
+ *     intervals: {
+ *       years: 1
+ *     }
+ *   },
+ *   target: {
+ *     value: Date.now(),
+ *     format: 'timestamp'
+ *   }
+ * };
+ * ```
+ */
+type TDateValidation = {
+    onlyValidDate?: boolean;
+    operator: TDateOperatorsValidation;
+    origin: {
+        value?: string | number;
+        format: TDateFormatsValidation;
+        /**
+         * Intervals to compare with the original date.
+         *
+         * It will use today's date for comparison.
+         *
+         * @example
+         * ```typescript
+         * origin date = 10/10/2022
+         * interval.year = 1
+         * operator = '==='
+         * ```
+         *
+         * It will compare (10/10/2022 + 1) with the current date and check if they are the same
+         */
+        intervals?: TDateInterval;
+    };
+    target?: {
+        value: string | number;
+        format: TDateFormatsValidation;
+    };
+};
+/**
+ * @type TValidationMethods
+ * Represents the various validation methods that can be applied to form fields.
+ *
+ * @property {number} [max] - Maximum value or length.
+ * @property {number} [min] - Minimum value or length.
+ * @property {number} [lessThan] - Minimum value or length.
+ * @property {number} [greaterThan] - Minimum value or length.
+ * @property {TLengthValidation} [length] - Length validation rule.
+ * @property {boolean} [required] - Indicates if the field is required.
+ * @property {unknown} [value] - Specific value to match.
+ * @property {string} [regex] - Regular expression for validation.
+ * @property {boolean} [email] - Indicates if the value should be a valid email.
+ * @property {boolean} [url] - Indicates if the value should be a valid URL.
+ * @property {boolean} [onlyLetters] - Indicates if the value should contain only letters.
+ * @property {boolean} [notAllowSpaces] - Indicates if spaces are not allowed.
+ * @property {TCallbackValidation} [callback] - Custom validation callback function.
+ * @property {boolean} [isNumber] - Indicates if the value should be a number.
+ * @property {boolean} [bool] - Indicates if the value should be a boolean or a string that can be converted to a boolean.
+ * @property {boolean | string} [exists] - Indicates if the value should exist or match a specific existence condition.
+ * @property {boolean} [hasNoExtraSpaces] - Indicates if there should be no extra spaces.
+ * @property {boolean} [notEmpty] - Indicates if the field should not be empty.
+ * @property {TBetweenValidation} [between] - Validation rule for range between two values.
+ * @property {boolean} [sequential] - Indicates if the value should be sequential.
+ * @property {boolean} [repeated] - Indicates if the value should not be repeated.
+ * @property {string[] | number[]} [includes] - Array of values that should be included.
+ * @property {string[]} [isCreditCard] - Array of valid credit card numbers.
+ * @property {TCreditCardMatch} [isCreditCodeMatch] - Validation rule for credit card matching.
+ * @property {string[]} [isCreditCardAndLength] - Array of valid credit card numbers with length check.
+ * @property {TDocumentValidation} [document] - Document validation rule.
+ * @property {TConditionsValidation} [conditions] - Conditional validation rules.
+ * @property {TMultipleValidation} [multipleValidations] - Multiple validation rules combined with a logical rule.
+ * @property {TBetweenDatesValidation} [betweenDates] - Validation rule for checking if a date falls between two dates.
+ * @property {TDateValidation} [date] - Validation rule for date values.
+ * @property {TDateFormatsValidation} [validDate] - Validation rule for valid date formats.
+ *
+ * @example
+ * ```typescript
+ * const validationMethods: TValidationMethods = {
+ *   max: 100,
+ *   min: 1,
+ *   lessThan: 1995,
+ *   greaterThan: 82000,
+ *   length: { rule: 'greaterOrEqual', target: 8 },
+ *   required: true,
+ *   regex: '^[a-zA-Z0-9]+$',
+ *   email: true,
+ *   conditions: {
+ *     rule: 'and',
+ *     set: [
+ *       {
+ *         forceDefinedOrigin: true,
+ *         forceDefinedTarget: true,
+ *         origin: '2023-01-01',
+ *         condition: '>',
+ *         target: '2022-01-01'
+ *       }
+ *     ]
+ *   },
+ *   multipleValidations: {
+ *     rule: 'AND',
+ *     validations: {
+ *       required: true,
+ *       min: 5,
+ *       max: 10
+ *     }
+ *   },
+ *   betweenDates: {
+ *     start: Date.parse('2023-01-01'),
+ *     end: Date.parse('2023-12-31'),
+ *     isIncludedBoundaries: true
+ *   },
+ *   date: {
+ *     operator: '===',
+ *     origin: {
+ *       value: '10/10/2022',
+ *       format: 'MMDDYYYY',
+ *       intervals: {
+ *         years: 1
+ *       }
+ *     },
+ *     target: {
+ *       value: Date.now(),
+ *       format: 'timestamp'
+ *     }
+ *   },
+ *   validDate: 'MMDDYYYY'
+ * };
+ * ```
+ */
+type TValidationMethods = {
+    /** Maximum value or length. */
+    max?: number;
+    /** Minimum value or length. */
+    min?: number;
+    /** Minimum value or length. */
+    lessThan?: number;
+    /** Minimum value or length. */
+    greaterThan?: number;
+    /** Length validation rule. */
+    length?: TLengthValidation;
+    /** Indicates if the field is required. */
+    required?: boolean;
+    /** Specific value to match. */
+    value?: unknown;
+    /** Regular expression for validation. */
+    regex?: string;
+    /** Indicates if the value should be a valid email. */
+    email?: boolean;
+    /** Indicates if the value should be a valid URL. */
+    url?: boolean;
+    /** Indicates if the value should contain only letters. */
+    onlyLetters?: boolean;
+    /** Indicates if spaces are not allowed. */
+    notAllowSpaces?: boolean;
+    /** Custom validation callback function. */
+    callback?: TCallbackValidation;
+    /** Indicates if the value should be a number. */
+    isNumber?: boolean;
+    /** Indicates if the value should be a boolean or a string that can be converted to a boolean. */
+    bool?: boolean | string;
+    /** Indicates if the value should exist or match a specific existence condition. */
+    exists?: boolean | string;
+    /** Indicates if there should be no extra spaces. */
+    hasNoExtraSpaces?: boolean;
+    /** Indicates if the field should not be empty. */
+    notEmpty?: boolean;
+    /** Validation rule for range between two values. */
+    between?: TBetweenValidation;
+    /** Indicates if the value should be sequential. */
+    sequential?: boolean;
+    /** Indicates if the value should not be repeated. */
+    repeated?: boolean;
+    /** Array of values that should be included. */
+    includes?: (string | number)[];
+    /** Array of valid credit card numbers. */
+    isCreditCard?: string[];
+    /** Validation rule for credit card matching. */
+    isCreditCodeMatch?: TCreditCardMatch;
+    /** Array of valid credit card numbers with length check. */
+    isCreditCardAndLength?: string[];
+    /** Document validation rule. */
+    document?: TDocumentValidation;
+    /** Conditional validation rules. */
+    conditions?: TConditionsValidation;
+    /** Multiple validation rules combined with a logical rule. */
+    multipleValidations?: TMultipleValidation;
+    /** Validation rule for checking if a date falls between two dates. */
+    betweenDates?: TBetweenDatesValidation;
+    /** Validation rule for date values. */
+    date?: TDateValidation;
+    /** Validation rule for valid date formats. */
+    validDate?: TDateFormatsValidation;
+};
+/**
+ * @type {Object.<string, TValidationMethods>} TGenericValidationRule
+ * Represents a generic validation rule where each key is associated with a set of validation methods.
+ *
+ * @example
+ * const genericValidationRule = {
+ *   email: {
+ *     required: true,
+ *     email: true,
+ *   },
+ *   password: {
+ *     required: true,
+ *     minLength: 8,
+ *   },
+ * };
+ */
+type TGenericValidationRule = Record<string, TValidationMethods>;
+
+/**
+ * @function betweenDates
+ * Validates if a date value falls between two specified dates.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the betweenDates validation rules.
+ * @returns {boolean} - Returns `true` if the date value fails the betweenDates validation, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = {
+ *   betweenDates: [
+ *     { origin: { value: '2023-01-01', format: 'yyyy-MM-dd' }, operator: '>=' },
+ *     { origin: { value: '2023-12-31', format: 'yyyy-MM-dd' }, operator: '<=' }
+ *   ]
+ * };
+ *
+ * const result1 = betweenDates('2023-06-01', validations);
+ * console.log(result1); // false (date is within the range)
+ *
+ * const result2 = betweenDates('2024-01-01', validations);
+ * console.log(result2); // true (date is outside the range)
+ * ```
+ */
+declare const betweenDates: (value: string, validations: TValidationMethods) => boolean;
+/**
+ * @function date
+ * Validates a date value based on various date conditions and intervals.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the date validation rules.
+ * @returns {boolean} - Returns `true` if the date validation fails, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = {
+ *   date: {
+ *     origin: {
+ *       value: '2023-01-01',
+ *       format: 'YYYY-MM-DD'
+ *     },
+ *     target: {
+ *       value: '2023-12-31',
+ *       format: 'YYYY-MM-DD'
+ *     },
+ *     operator: '<=',
+ *     onlyValidDate: true
+ *   }
+ * };
+ *
+ * const result1 = date('2023-06-01', validations);
+ * console.log(result1); // false (date is within the range)
+ *
+ * const result2 = date('2024-01-01', validations);
+ * console.log(result2); // true (date is outside the range)
+ * ```
+ */
+declare const date: (value: string | null, validations: TValidationMethods) => boolean;
+/**
+ * @function validDate
+ * Validates that a date string is a valid date according to the given format.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the validDate rule.
+ * @returns {boolean} - Returns `true` if the date is not valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = { validDate: 'MM-dd-yyyy' };
+ *
+ * const result1 = validDate('12-31-2023', validations);
+ * console.log(result1); // false (date is valid)
+ *
+ * const result2 = validDate('02-30-2023', validations);
+ * console.log(result2); // true (date is invalid)
+ * ```
+ */
+declare const validDate: (value: string, validations: TValidationMethods) => boolean;
+
+export { betweenDates, date, validDate };

package/date.esm.js

@@ -0,0 +1 @@
+const e={DDMMYYYY:e=>{if(!e)return"";const t=e.split(e.includes("/")?"/":"-");return`${t[1]}/${t[0]}/${t[2]}`},YYYYMMDD:e=>{if(!e)return"";const t=e.split(e.includes("/")?"/":"-");return`${t[1]}/${t[2]}/${t[0]}`},YYYYDDMM:e=>{if(!e)return"";const t=e.split(e.includes("/")?"/":"-");return`${t[2]}/${t[1]}/${t[0]}`},MMDDYYYY:e=>e,timestamp:e=>new Date(e).toString()},t=(e,t)=>{var a;let i=!1;if(2!=(null===(a=t.betweenDates)||void 0===a?void 0:a.length))return!1;for(const a of t.betweenDates)if(n(e,{date:a})){i=!0;break}return i},n=(t,n)=>{var a,i,r,d,l,o,Y,s,u,D,v,g;if(!(null===(i=null===(a=n.date)||void 0===a?void 0:a.target)||void 0===i?void 0:i.value)&&!(null===(d=null===(r=n.date)||void 0===r?void 0:r.origin)||void 0===d?void 0:d.intervals))return!1;const M=n.date.origin.value||t,c=e[null===(l=n.date)||void 0===l?void 0:l.origin.format](M).toString();let f=new Date(c),$=new Date,w=new Date;if((null===(Y=null===(o=n.date)||void 0===o?void 0:o.target)||void 0===Y?void 0:Y.format)&&(w=new Date(e[null===(u=null===(s=n.date)||void 0===s?void 0:s.target)||void 0===u?void 0:u.format](n.date.target.value).toString()),$=w),n.date.origin.intervals){$=((e,t)=>{const n={years:(e,t)=>new Date(e.setUTCFullYear(e.getUTCFullYear()+t)),months:(e,t)=>new Date(e.setUTCMonth(e.getUTCMonth()+t)),days:(e,t)=>new Date(e.setDate(e.getUTCDate()+t))};return Object.keys(t).reduce((e,a)=>n[a](e,t[a]),new Date(e))})(f,n.date.origin.intervals);const e=new Date;(null===(D=n.date.target)||void 0===D?void 0:D.value)&&w&&(e.setDate(w.getDate()),e.setMonth(w.getMonth())),f=new Date(`${e.getUTCMonth()+1}/${e.getUTCDate()}/${e.getUTCFullYear()}`)}if(n.date.onlyValidDate&&(!($ instanceof Date&&isFinite($))||!($ instanceof Date&&isFinite(f))||M.length<8))return!0;if(((e,t)=>{if(!e.includes("/")&&!e.includes("-")||!t)return!0;const n=e.replace(/[-/]/g,"");return!{DDMMYYYY:/^(\d{2})(\d{2})(\d{4})$/,YYYYMMDD:/^(\d{4})(\d{2})(\d{2})$/,YYYYDDMM:/^(\d{4})(\d{2})(\d{2})$/,MMDDYYYY:/^(\d{2})(\d{2})(\d{4})$/,DMYYYY:/^(\d{1,2})(\d{1,2})(\d{4})$/,YYYYMD:/^(\d{4})(\d{1,2})(\d{1,2})$/,YYYYDM:/^(\d{4})(\d{1,2})(\d{1,2})$/,MDYYYY:/^(\d{1,2})(\d{1,2})(\d{4})$/}[t].test(n)})(c,null===(v=n.date)||void 0===v?void 0:v.origin.format))return!1;const p=f.getTime(),F=$.getTime();return{">":p>F,">=":p>=F,"<":p<F,"<=":p<=F,"===":p===F,"!==":p!==F}[null===(g=n.date)||void 0===g?void 0:g.operator]},a=(t,n)=>{if(!n.validDate||!t)return!1;if(/[^a-zA-Z0-9\s-]/.test(t))return!0;const a=e[n.validDate](t).toString().split(/[/-]/),i=parseInt(a[2],10),r=parseInt(a[0],10)-1,d=parseInt(a[1],10),l=new Date(i,r,d),o=new Date;return o.setFullYear(o.getFullYear()-150),l.getFullYear()<o.getFullYear()||!(l.getFullYear()===i&&l.getMonth()===r&&l.getDate()===d)};Object.assign({},{date:n,betweenDates:t,validDate:a});export{t as betweenDates,n as date,a as validDate};