feat: chnage value and input type base in ts

javadbat · javadbat · commit 9c9a55da02e2 · 2024-02-07T11:36:11.000+03:30
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,7 @@
 #changelog
+## [3.12.0] - 2024-2-7
+### new features
+- change `inputType` and `valuetype` from enum to pure string so it easily be used in other ts files without extra dep
 ## [3.11.1] - 2023-12-13
 ### new features
 - fix `:dir(ltr)` bug of calendar
diff --git a/lib/DateFactory.ts b/lib/DateFactory.ts
@@ -1,5 +1,5 @@
 
-import { DateInObject, DateRestrictions, DateRestrictionsValidResult, DateValidResult, InputTypes, JBDateInputValueObject, ValueTypes } from './Types';
+import { DateInObject, DateRestrictions, DateRestrictionsValidResult, DateValidResult, InputTypes, JBDateInputValueObject, ValueTypes, ValueType, InputType } from './Types';
 import { getEmptyValueObject } from './Helpers';
 import { getYear, getMonth, getTime as getTimeStamp, getUnixTime as getTimeStampInSecond, isEqual, isLeapYear, getDate } from 'date-fns';
 import { newDate, isLeapYear as isJalaliLeapYear, isAfter, isBefore, getYear as getJalaliYear, getMonth as getJalaliMonth, getDate as getJalaliDate } from 'date-fns-jalali';
@@ -10,8 +10,8 @@ export type DateFactoryConstructorArg = {
     valueType: ValueTypes | null | undefined;
 }
 export class DateFactory {
-    #valueType = ValueTypes.gregorian;
-    #inputType = InputTypes.jalali;
+    #valueType:ValueType = "GREGORIAN";
+    #inputType:InputType = InputTypes.jalali;
     //here we keep numbers that replace the year,month,day in niche situations
     #nicheNumbers = {
         //when year is invalid or empty and we want to show the calendar we need to show the current year or any other base on user config
@@ -35,21 +35,21 @@ export class DateFactory {
         return this.#nicheNumbers;
     }
     get yearOnEmptyBaseOnValueType() {
-        if (this.#valueType == ValueTypes.jalali) {
+        if (this.#valueType == "JALALI") {
             return this.#nicheNumbers.calendarYearOnEmpty.jalali;
         }
         return this.#nicheNumbers.calendarYearOnEmpty.gregorian;
     }
     get monthOnEmptyBaseOnValueType(): number {
-        if (this.valueType == ValueTypes.jalali) {
+        if (this.valueType == "JALALI") {
             return this.#nicheNumbers.calendarMonthOnEmpty.jalali;
         }
         return this.#nicheNumbers.calendarMonthOnEmpty.gregorian;
     }
     get inputType() {
         return this.#inputType;
     }
-    get valueType() {
+    get valueType():ValueType{
         return this.#valueType;
     }
     constructor(args: DateFactoryConstructorArg) {
@@ -61,10 +61,10 @@ export class DateFactory {
         }
     }
 
-    setInputType(inputType: InputTypes) {
+    setInputType(inputType: InputType) {
         this.#inputType = inputType;
     }
-    setValueType(valueType: ValueTypes) {
+    setValueType(valueType: ValueType) {
         this.#valueType = valueType;
     }
     getYearValueBaseOnInputType(valueObject: JBDateInputValueObject): number | null {
@@ -88,16 +88,16 @@ export class DateFactory {
     getDateFromValueDateString(valueDateString: string): Date | null {
         let resultDate: Date | null = null;
         //create min date base on input value type
-        if (this.valueType == ValueTypes.timestamp) {
+        if (this.valueType == "TIME_STAMP") {
             resultDate = DateFactory.getDateFromTimestamp(parseInt(valueDateString));
         } else {
             const dateValueObj = this.getDateObjectValueBaseOnFormat(valueDateString);
             //sometimes format set after min value restriction set by user so this object returned null in these scenario we set min after format set again
             if (dateValueObj !== null && dateValueObj !== undefined && dateValueObj.year !== null && dateValueObj.month !== null && dateValueObj.day !== null) {
-                if (this.valueType == ValueTypes.gregorian) {
+                if (this.valueType == "GREGORIAN") {
                     resultDate = DateFactory.getDateFromGregorian(dateValueObj.year, dateValueObj.month, dateValueObj.day);
                 }
-                if (this.valueType == ValueTypes.jalali) {
+                if (this.valueType == "JALALI") {
                     resultDate = DateFactory.getDateFromJalali(dateValueObj.year, dateValueObj.month, dateValueObj.day);
                 }
             }
@@ -166,7 +166,7 @@ export class DateFactory {
     getCalendarDay(valueObject: JBDateInputValueObject): number | null {
         return this.getDayValueBaseOnInputType(valueObject);
     }
-    setCalendarDefaultDateView(year: number, month: number, inputType: InputTypes = this.#inputType) {
+    setCalendarDefaultDateView(year: number, month: number, inputType: InputType = this.#inputType) {
         if (inputType == InputTypes.gregorian) {
             this.#nicheNumbers.calendarYearOnEmpty.gregorian = year;
             this.#nicheNumbers.calendarMonthOnEmpty.gregorian = month;
@@ -325,13 +325,13 @@ export class DateFactory {
         return getEmptyValueObject();
     }
     getDateValueObjectBaseOnValueType(year: number, month: number, day: number, oldYear: number | null, oldMonth: number | null): JBDateInputValueObject {
-        if (this.#valueType == ValueTypes.gregorian) {
+        if (this.#valueType == "GREGORIAN") {
             return this.#getDateValueFromGregorian(year, month, day, oldYear, oldMonth);
         }
-        if (this.#valueType == ValueTypes.jalali) {
+        if (this.#valueType == "JALALI") {
             return this.#getDateValueFromJalali(year, month, day, oldYear, oldMonth);
         }
-        if (this.#valueType == ValueTypes.timestamp) {
+        if (this.#valueType == "TIME_STAMP") {
             return this.#getDateValueFromGregorian(year, month, day, oldYear, oldMonth);
         }
         console.error("INVALID_INPUT_TYPE");
@@ -436,7 +436,7 @@ export class DateFactory {
             }
             if (dateValidationResult.error == "INVALID_DAY_IN_MONTH") {
                 if (oldJalaliMonth != jalaliMonth && jalaliDay == 31) {
-                    //if we update to 30days month when day set to 31 we substrc day to 30 instead of prevent user from updating month
+                    //if we update to 30days month when day set to 31 we substr day to 30 instead of prevent user from updating month
                     return this.#getDateValueFromJalali(jalaliYear, jalaliMonth, jalaliDay - 1, oldJalaliYear, oldJalaliMonth);
                 }
             }
@@ -487,7 +487,7 @@ export class DateFactory {
         const res = regex.exec(value);
         return res;
     }
-    static getDate(year: number, month: number, day: number, inputType: InputTypes): Date {
+    static getDate(year: number, month: number, day: number, inputType: InputType): Date {
         if (inputType == InputTypes.jalali) {
             return DateFactory.getDateFromJalali(year, month, day);
         }
@@ -503,8 +503,8 @@ export class DateFactory {
     static getDateFromTimestamp(timestamp: number): Date {
         return new Date(timestamp);
     }
-    static checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputTypes, dateRestrictions: DateRestrictions): DateRestrictionsValidResult {
-        //this function check if inputed date is valid date in min and max range
+    static checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputType, dateRestrictions: DateRestrictions): DateRestrictionsValidResult {
+        //this function check if inputted date is valid date in min and max range
         const result: DateRestrictionsValidResult = {
             get isAllValid() { return (this.min.isValid && this.max.isValid); },
             min: {
diff --git a/lib/JBDateInput.ts b/lib/JBDateInput.ts
@@ -9,7 +9,7 @@ import './inbox-element/inbox-element';
 import {JBDDateInputInboxElementWebComponent} from './inbox-element/inbox-element';
 //import cloneDeep from 'lodash.clonedeep';
 
-import { InputTypes, ValueTypes, ElementsObject, ValidationResultSummary, DateRestrictions, JBDateInputValueObject, ValidationResultItem, JBDateInputValidationItem, DateValidResult, DateRestrictionsValidResult, ValidationResult } from './Types';
+import { InputTypes, ValueTypes, ElementsObject, ValidationResultSummary, DateRestrictions, JBDateInputValueObject, ValidationResultItem, JBDateInputValidationItem, DateRestrictionsValidResult, ValidationResult, ValueType, InputType } from './Types';
 import { DateFactory } from './DateFactory';
 import { getEmptyValueObject, handleDayBeforeInput, handleMonthBeforeInput } from './Helpers';
 // import { JBCalendarValue } from 'jb-calendar/lib/Types';
@@ -54,7 +54,7 @@ export class JBDateInputWebComponent extends HTMLElement {
     }
     set value(value: string | Date) {
         this.#setDateValue(value);
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     #updateFormAssossicatedValue():void{
         //in html form we need to get date input value in native way this function update and set value of the input so form can get it when needed
@@ -82,9 +82,9 @@ export class JBDateInputWebComponent extends HTMLElement {
         }else{
             this.elements.input.placeholder= "";
         }
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
-    //standarded input value
+    //standardized input value
     get #sInputValue():string{
         let value = this.#inputValue;
         if(this.#usePersianDigits){
@@ -114,10 +114,10 @@ export class JBDateInputWebComponent extends HTMLElement {
         }
     }
    
-    get inputType() {
+    get inputType():InputType{
         return this.#dateFactory.inputType;
     }
-    set inputType(value) {
+    set inputType(value:InputType) {
 
         if (Object.values(InputTypes).includes(value as InputTypes)) {
             this.#dateFactory.setInputType(value);
@@ -130,7 +130,7 @@ export class JBDateInputWebComponent extends HTMLElement {
     get valueType() {
         return this.#dateFactory.valueType;
     }
-    set valueType(value: ValueTypes) {
+    set valueType(value: ValueType) {
         if (Object.values(ValueTypes).includes(value as ValueTypes)) {
             this.#dateFactory.setValueType(value);
         } else {
@@ -147,35 +147,35 @@ export class JBDateInputWebComponent extends HTMLElement {
     }
     get yearValue(): number | null {
         switch (this.valueType) {
-            case ValueTypes.jalali:
+            case "JALALI":
                 return this.#valueObject.jalali.year;
-            case ValueTypes.gregorian:
+            case "GREGORIAN":
                 return this.#valueObject.gregorian.year;
-            case ValueTypes.timestamp:
+            case "TIME_STAMP":
                 return this.#valueObject.gregorian.year;
             default:
                 return null;
         }
     }
     get monthValue(): number | null {
         switch (this.valueType) {
-            case ValueTypes.jalali:
+            case "JALALI":
                 return this.#valueObject.jalali.month;
-            case ValueTypes.gregorian:
+            case "GREGORIAN":
                 return this.#valueObject.gregorian.month;
-            case ValueTypes.timestamp:
+            case "TIME_STAMP":
                 return this.#valueObject.gregorian.month;
             default:
                 return null;
         }
     }
     get dayValue(): number | null {
         switch (this.valueType) {
-            case ValueTypes.jalali:
+            case "JALALI":
                 return this.#valueObject.jalali.day;
-            case ValueTypes.gregorian:
+            case "GREGORIAN":
                 return this.#valueObject.gregorian.day;
-            case ValueTypes.timestamp:
+            case "TIME_STAMP":
                 return this.#valueObject.gregorian.day;
             default:
                 return null;
@@ -244,7 +244,7 @@ export class JBDateInputWebComponent extends HTMLElement {
     }
     set usePersianDigits(value) {
         this.#usePersianDigits = value;
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     constructor() {
         super();
@@ -624,41 +624,41 @@ export class JBDateInputWebComponent extends HTMLElement {
         const currentMonth = this.monthValue || 1;
         const currentDay = this.dayValue || 1;
         this.#setDateValueFromNumbers(currentYear + interval, currentMonth, currentDay);
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     addMonth(interval: number) {
         const currentYear = this.yearValue ? this.yearValue : this.#dateFactory.yearOnEmptyBaseOnValueType;
         const currentMonth = this.monthValue || 1;
         const currentDay = this.dayValue || 1;
         this.#setDateValueFromNumbers(currentYear, currentMonth + interval, currentDay);
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     addDay(interval: number) {
         const currentYear = this.yearValue ? this.yearValue : this.#dateFactory.yearOnEmptyBaseOnValueType;
         const currentMonth = this.monthValue || 1;
         const currentDay = this.dayValue || 1;
         this.#setDateValueFromNumbers(currentYear, currentMonth, currentDay + interval);
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     /**
      * will convert current valueObject to expected value string
      * @param {ValueTypes} type 
      * @return {String} value base on format and date type
      */
-    getDateValue(type: ValueTypes = this.valueType): string {
+    getDateValue(type: ValueType = this.valueType): string {
         return this.#dateFactory.getDateValueStringFromValueObject(this.#valueObject, type);
     }
     /**
      * when user change value this function called and update inner value object base on user value
      */
     #setDateValue(value: string | Date) {
         if(typeof value == "string"){
-            switch (this.#dateFactory.valueType) {
-                case ValueTypes.gregorian:
-                case ValueTypes.jalali:
+            switch(this.#dateFactory.valueType) {
+                case "GREGORIAN":
+                case "JALALI":
                     this.#setDateValueFromString(value);
                     break;
-                case ValueTypes.timestamp:
+                case "TIME_STAMP":
                     this.#setDateValueFromTimeStamp(value);
                     break;
             }
@@ -672,7 +672,7 @@ export class JBDateInputWebComponent extends HTMLElement {
         this.#valueObject = getEmptyValueObject();
     }
     private updateCalendarView() {
-        //update jb-calendr view base on current data
+        //update jb-calendar view base on current data
         const value: JBCalendarValue = {
             year: this.#dateFactory.getCalendarYear(this.#valueObject),
             month: this.#dateFactory.getCalendarMonth(this.#valueObject),
@@ -713,7 +713,7 @@ export class JBDateInputWebComponent extends HTMLElement {
             this.#setDateValueFromNumbers(dateInObject.year, dateInObject.month, dateInObject.day);
         } else {
             if (value !== null && value !== undefined && value !== '') {
-                console.error('your inputed Date doest match defualt or your specified Format');
+                console.error('your inputed Date doest match default or your specified Format');
             } else {
                 this.setValueObjNull();
             }
@@ -746,7 +746,7 @@ export class JBDateInputWebComponent extends HTMLElement {
         this.updateCalendarView();
         this.#updateFormAssossicatedValue();
     }
-    #updateinputTextFromValue() {
+    #updateInputTextFromValue() {
         const { year, month, day } = this.inputType == InputTypes.jalali ? this.#valueObject.jalali : this.#valueObject.gregorian;
         if(this.placeholder && !(year && month && day)){
             //if we have placeholder and inputed value were all null we show placeholder until user input some value
@@ -921,7 +921,7 @@ export class JBDateInputWebComponent extends HTMLElement {
      * @param  {String} dateInputType what is the date type of this number jalali or gregorian
      * @return {Object}
      */
-    checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputTypes): DateRestrictionsValidResult {
+    checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputType): DateRestrictionsValidResult {
         return DateFactory.checkDateRestrictions(year, month, day, dateInputType, this.dateRestrictions);
 
     }
@@ -1060,7 +1060,7 @@ export class JBDateInputWebComponent extends HTMLElement {
         const { year, month, day } = target.value;
         if (year && month && day) {
             this.#setDateValueFromNumberBaseOnInputType(year, month, day);
-            this.#updateinputTextFromValue();
+            this.#updateInputTextFromValue();
             this.showCalendar = false;
             this.callOnDateSelect();
             this.callOnChange();
@@ -1074,7 +1074,7 @@ export class JBDateInputWebComponent extends HTMLElement {
     }
     onInputTypeChange() {
         this.elements.calendar.inputType = this.inputType;
-        this.#updateinputTextFromValue();
+        this.#updateInputTextFromValue();
     }
     /**
      * set opend calendar date when date input value is empty
diff --git a/lib/Types.ts b/lib/Types.ts
@@ -64,12 +64,14 @@ export enum InputTypes {
     jalali = 'JALALI',
     gregorian = 'GREGORIAN'
 }
+export type InputType = 'JALALI' | 'GREGORIAN';
+export type ValueType = 'JALALI' | 'GREGORIAN' | 'TIME_STAMP';
 export enum ValueTypes {
-    jalali = 'JALALI',
-    gregorian = 'GREGORIAN',
-    timestamp = 'TIME_STAMP',
+    jalali='JALALI' ,
+    gregorian='GREGORIAN' ,
+    timeStamp= 'TIME_STAMP'
 }
-//becuase this._internal is not a standard we have to extend HTMLELEMENT to use it
+//because this._internal is not a standard we have to extend HTML ELEMENT to use it
 declare global {
     interface ElementInternals{
         setFormValue(value:string):void;
diff --git a/package.json b/package.json
@@ -28,7 +28,7 @@
     "jalali web-component",
     "jalali web component"
   ],
-  "version": "3.11.1",
+  "version": "3.12.0",
   "bugs": "https://github.com/javadbat/jb-date-input/issues",
   "license": "MIT",
   "files": [

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`
`2`		`-import { DateInObject, DateRestrictions, DateRestrictionsValidResult, DateValidResult, InputTypes, JBDateInputValueObject, ValueTypes } from './Types';`
	`2`	`+import { DateInObject, DateRestrictions, DateRestrictionsValidResult, DateValidResult, InputTypes, JBDateInputValueObject, ValueTypes, ValueType, InputType } from './Types';`
`3`	`3`	`import { getEmptyValueObject } from './Helpers';`
`4`	`4`	`import { getYear, getMonth, getTime as getTimeStamp, getUnixTime as getTimeStampInSecond, isEqual, isLeapYear, getDate } from 'date-fns';`
`5`	`5`	`import { newDate, isLeapYear as isJalaliLeapYear, isAfter, isBefore, getYear as getJalaliYear, getMonth as getJalaliMonth, getDate as getJalaliDate } from 'date-fns-jalali';`
`@@ -10,8 +10,8 @@ export type DateFactoryConstructorArg = {`
`10`	`10`	`valueType: ValueTypes \| null \| undefined;`
`11`	`11`	`}`
`12`	`12`	`export class DateFactory {`
`13`		`- #valueType = ValueTypes.gregorian;`
`14`		`- #inputType = InputTypes.jalali;`
	`13`	`+ #valueType:ValueType = "GREGORIAN";`
	`14`	`+ #inputType:InputType = InputTypes.jalali;`
`15`	`15`	`//here we keep numbers that replace the year,month,day in niche situations`
`16`	`16`	`#nicheNumbers = {`
`17`	`17`	`//when year is invalid or empty and we want to show the calendar we need to show the current year or any other base on user config`
`@@ -35,21 +35,21 @@ export class DateFactory {`
`35`	`35`	`return this.#nicheNumbers;`
`36`	`36`	`}`
`37`	`37`	`get yearOnEmptyBaseOnValueType() {`
`38`		`- if (this.#valueType == ValueTypes.jalali) {`
	`38`	`+ if (this.#valueType == "JALALI") {`
`39`	`39`	`return this.#nicheNumbers.calendarYearOnEmpty.jalali;`
`40`	`40`	`}`
`41`	`41`	`return this.#nicheNumbers.calendarYearOnEmpty.gregorian;`
`42`	`42`	`}`
`43`	`43`	`get monthOnEmptyBaseOnValueType(): number {`
`44`		`- if (this.valueType == ValueTypes.jalali) {`
	`44`	`+ if (this.valueType == "JALALI") {`
`45`	`45`	`return this.#nicheNumbers.calendarMonthOnEmpty.jalali;`
`46`	`46`	`}`
`47`	`47`	`return this.#nicheNumbers.calendarMonthOnEmpty.gregorian;`
`48`	`48`	`}`
`49`	`49`	`get inputType() {`
`50`	`50`	`return this.#inputType;`
`51`	`51`	`}`
`52`		`- get valueType() {`
	`52`	`+ get valueType():ValueType{`
`53`	`53`	`return this.#valueType;`
`54`	`54`	`}`
`55`	`55`	`constructor(args: DateFactoryConstructorArg) {`
`@@ -61,10 +61,10 @@ export class DateFactory {`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`- setInputType(inputType: InputTypes) {`
	`64`	`+ setInputType(inputType: InputType) {`
`65`	`65`	`this.#inputType = inputType;`
`66`	`66`	`}`
`67`		`- setValueType(valueType: ValueTypes) {`
	`67`	`+ setValueType(valueType: ValueType) {`
`68`	`68`	`this.#valueType = valueType;`
`69`	`69`	`}`
`70`	`70`	`getYearValueBaseOnInputType(valueObject: JBDateInputValueObject): number \| null {`
`@@ -88,16 +88,16 @@ export class DateFactory {`
`88`	`88`	`getDateFromValueDateString(valueDateString: string): Date \| null {`
`89`	`89`	`let resultDate: Date \| null = null;`
`90`	`90`	`//create min date base on input value type`
`91`		`- if (this.valueType == ValueTypes.timestamp) {`
	`91`	`+ if (this.valueType == "TIME_STAMP") {`
`92`	`92`	`resultDate = DateFactory.getDateFromTimestamp(parseInt(valueDateString));`
`93`	`93`	`} else {`
`94`	`94`	`const dateValueObj = this.getDateObjectValueBaseOnFormat(valueDateString);`
`95`	`95`	`//sometimes format set after min value restriction set by user so this object returned null in these scenario we set min after format set again`
`96`	`96`	`if (dateValueObj !== null && dateValueObj !== undefined && dateValueObj.year !== null && dateValueObj.month !== null && dateValueObj.day !== null) {`
`97`		`- if (this.valueType == ValueTypes.gregorian) {`
	`97`	`+ if (this.valueType == "GREGORIAN") {`
`98`	`98`	`resultDate = DateFactory.getDateFromGregorian(dateValueObj.year, dateValueObj.month, dateValueObj.day);`
`99`	`99`	`}`
`100`		`- if (this.valueType == ValueTypes.jalali) {`
	`100`	`+ if (this.valueType == "JALALI") {`
`101`	`101`	`resultDate = DateFactory.getDateFromJalali(dateValueObj.year, dateValueObj.month, dateValueObj.day);`
`102`	`102`	`}`
`103`	`103`	`}`
`@@ -166,7 +166,7 @@ export class DateFactory {`
`166`	`166`	`getCalendarDay(valueObject: JBDateInputValueObject): number \| null {`
`167`	`167`	`return this.getDayValueBaseOnInputType(valueObject);`
`168`	`168`	`}`
`169`		`- setCalendarDefaultDateView(year: number, month: number, inputType: InputTypes = this.#inputType) {`
	`169`	`+ setCalendarDefaultDateView(year: number, month: number, inputType: InputType = this.#inputType) {`
`170`	`170`	`if (inputType == InputTypes.gregorian) {`
`171`	`171`	`this.#nicheNumbers.calendarYearOnEmpty.gregorian = year;`
`172`	`172`	`this.#nicheNumbers.calendarMonthOnEmpty.gregorian = month;`
`@@ -325,13 +325,13 @@ export class DateFactory {`
`325`	`325`	`return getEmptyValueObject();`
`326`	`326`	`}`
`327`	`327`	`getDateValueObjectBaseOnValueType(year: number, month: number, day: number, oldYear: number \| null, oldMonth: number \| null): JBDateInputValueObject {`
`328`		`- if (this.#valueType == ValueTypes.gregorian) {`
	`328`	`+ if (this.#valueType == "GREGORIAN") {`
`329`	`329`	`return this.#getDateValueFromGregorian(year, month, day, oldYear, oldMonth);`
`330`	`330`	`}`
`331`		`- if (this.#valueType == ValueTypes.jalali) {`
	`331`	`+ if (this.#valueType == "JALALI") {`
`332`	`332`	`return this.#getDateValueFromJalali(year, month, day, oldYear, oldMonth);`
`333`	`333`	`}`
`334`		`- if (this.#valueType == ValueTypes.timestamp) {`
	`334`	`+ if (this.#valueType == "TIME_STAMP") {`
`335`	`335`	`return this.#getDateValueFromGregorian(year, month, day, oldYear, oldMonth);`
`336`	`336`	`}`
`337`	`337`	`console.error("INVALID_INPUT_TYPE");`
`@@ -436,7 +436,7 @@ export class DateFactory {`
`436`	`436`	`}`
`437`	`437`	`if (dateValidationResult.error == "INVALID_DAY_IN_MONTH") {`
`438`	`438`	`if (oldJalaliMonth != jalaliMonth && jalaliDay == 31) {`
`439`		`- //if we update to 30days month when day set to 31 we substrc day to 30 instead of prevent user from updating month`
	`439`	`+ //if we update to 30days month when day set to 31 we substr day to 30 instead of prevent user from updating month`
`440`	`440`	`return this.#getDateValueFromJalali(jalaliYear, jalaliMonth, jalaliDay - 1, oldJalaliYear, oldJalaliMonth);`
`441`	`441`	`}`
`442`	`442`	`}`
`@@ -487,7 +487,7 @@ export class DateFactory {`
`487`	`487`	`const res = regex.exec(value);`
`488`	`488`	`return res;`
`489`	`489`	`}`
`490`		`- static getDate(year: number, month: number, day: number, inputType: InputTypes): Date {`
	`490`	`+ static getDate(year: number, month: number, day: number, inputType: InputType): Date {`
`491`	`491`	`if (inputType == InputTypes.jalali) {`
`492`	`492`	`return DateFactory.getDateFromJalali(year, month, day);`
`493`	`493`	`}`
`@@ -503,8 +503,8 @@ export class DateFactory {`
`503`	`503`	`static getDateFromTimestamp(timestamp: number): Date {`
`504`	`504`	`return new Date(timestamp);`
`505`	`505`	`}`
`506`		`- static checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputTypes, dateRestrictions: DateRestrictions): DateRestrictionsValidResult {`
`507`		`- //this function check if inputed date is valid date in min and max range`
	`506`	`+ static checkDateRestrictions(year: number, month: number, day: number, dateInputType: InputType, dateRestrictions: DateRestrictions): DateRestrictionsValidResult {`
	`507`	`+ //this function check if inputted date is valid date in min and max range`
`508`	`508`	`const result: DateRestrictionsValidResult = {`
`509`	`509`	`get isAllValid() { return (this.min.isValid && this.max.isValid); },`
`510`	`510`	`min: {`