@zeedhi/common 3.0.5 → 3.0.7

package/environments.json

@@ -0,0 +1,6 @@
+{
+  "development": {
+  },
+  "production": {
+  }
+}

package/jest.config.cjs

@@ -7,4 +7,5 @@ module.exports = {
   coveragePathIgnorePatterns: [
     "/tests/unit/__helpers__/"
   ],
+	setupFilesAfterEnv: ['<rootDir>/tests/unit/utils/mock-console.ts'],
 };

package/package.json

@@ -1,37 +1,35 @@
 {
   "name": "@zeedhi/common",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "Zeedhi Common",
   "author": "Zeedhi <zeedhi@teknisa.com>",
   "license": "ISC",
   "main": "src/index.ts",
-  "types": "dist/types/index.d.ts",
+  "types": "dist/zd-common.d.mts",
   "type": "module",
-  "module": "dist/zd-common.js",
-  "packageManager": "npm@8.19.2",
+  "module": "dist/zd-common.mjs",
+  "packageManager": "npm@10.0.0",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "rollup -c && npm run build:scss",
+    "build": "npm run types && tsdown",
+    "types": "tsc --noEmit",
     "clean": "rm -rf ./dist",
-    "build:scss": "rollup -c rollup.scss.config.js",
     "test": "jest --verbose=false",
-    "watch": "rollup -cw"
+    "watch": "tsdown --watch"
   },
   "dependencies": {
     "@zeedhi/autonumeric": "^4.6.3",
-    "@zeedhi/core": "^3.0.5",
     "lodash.clonedeep": "^4.5.0",
     "lodash.debounce": "^4.0.8",
     "lodash.get": "^4.4.2",
     "lodash.isundefined": "^3.0.1",
     "lodash.merge": "^4.6.2",
     "lodash.set": "^4.3.2",
-    "typescript": "^4.9.3"
+    "node-fetch": "^2.7.0"
   },
   "devDependencies": {
-    "@rollup/plugin-json": "^6.0.0",
     "@types/lodash.clonedeep": "^4.5.9",
     "@types/lodash.debounce": "^4.0.7",
     "@types/lodash.get": "^4.4.7",
@@ -39,8 +37,17 @@
     "@types/lodash.merge": "^4.6.7",
     "@types/lodash.set": "^4.3.7",
     "@types/lodash.times": "^4.3.7",
+    "@zeedhi/core": "^3.0.7",
     "lodash.times": "^4.3.2",
-    "mockdate": "^3.0.5"
+    "mockdate": "^3.0.5",
+    "postcss": "^8.5.6",
+    "rollup-plugin-postcss": "^4.0.2"
   },
-  "gitHead": "2c7e039fc90ab9b705354a51f0de77496f2556dd"
+  "peerDependencies": {
+    "@zeedhi/core": "^3.0.6"
+  },
+  "env": {
+    "NODE_ENV": "production"
+  },
+  "gitHead": "637e1cdfa2ea8144502a5425b898156fa3f6059b"
 }

package/src/components/zd-date-input/date-input.ts

@@ -1,8 +1,9 @@
 import { Config, DateHelper, FormatterParserProvider, I18n, Mask, Utils, dayjs } from '@zeedhi/core';
-import isUndefined from 'lodash.isundefined';
 import { InputFactory } from '../zd-input/input-factory';
 import { TextInput } from '../zd-text-input/text-input';
 import { IDateInput } from './interfaces';
+import { isDateAllowed } from '../../utils/date-utils/date-utils';
+import { getDateMask, validateThenFormat } from './utils';
 
 /**
  * Base class for Date component.
@@ -90,10 +91,6 @@ export class DateInput extends TextInput implements IDateInput {
 
 	protected parserFn = FormatterParserProvider.getParser('ZdDateInput');
 
-	protected initialMask?: string;
-
-	protected isSimpleDisplay!: boolean;
-
 	public inputMode?: string = 'none';
 
 	/* istanbul ignore next */
@@ -124,9 +121,6 @@ export class DateInput extends TextInput implements IDateInput {
 
 		this.dateValidation = this.dateValidation.bind(this);
 		this.rules.push(this.dateValidation);
-
-		this.initialMask = this.getInitialMask();
-		this.isSimpleDisplay = this.isSimpleFormat(this.displayFormat);
 	}
 
 	public appendIconClick(event: Event, element: any) {
@@ -134,14 +128,6 @@ export class DateInput extends TextInput implements IDateInput {
 		super.appendIconClick(event, element);
 	}
 
-	private getInitialMask() {
-		if (isUndefined(this.mask)) {
-			this.mask = this.inputFormat && this.maskFormat(this.inputFormat);
-		}
-
-		return this.mask;
-	}
-
 	public formatter(value: string): string {
 		return this.formatterFn(value, this);
 	}
@@ -175,6 +161,8 @@ export class DateInput extends TextInput implements IDateInput {
 		}
 		if (this.isValidFormatDate(value, this.dateFormat)) {
 			this.dateObject = dayjs(value, this.dateFormat);
+		} else {
+			this.dateObject = null;
 		}
 	}
 
@@ -189,30 +177,6 @@ export class DateInput extends TextInput implements IDateInput {
 		this.value = parsedValue; // forces value accessor to be called if necessary
 	}
 
-	/**
-	 * Assign the updated mask to mask property
-	 */
-	public updateMask() {
-		this.isSimpleDisplay = this.isSimpleFormat(this.displayFormat);
-		this.mask = this.getUpdatedMask();
-		return this.mask;
-	}
-
-	/**
-	 * Gets the updated masked, based on displayFormat if the initial mask is undefined
-	 */
-	protected getUpdatedMask(): string | undefined {
-		if (isUndefined(this.initialMask)) {
-			return this.maskFormat(this.displayFormat);
-		}
-
-		return this.mask;
-	}
-
-	protected maskFormat(format: string) {
-		return format.replace(/[A-Za-z]/gi, '#');
-	}
-
 	public setDateValue(displayValue: string) {
 		if (this.isValidDate(displayValue, this.displayFormat)) {
 			this.setValidDateValue(displayValue);
@@ -252,15 +216,9 @@ export class DateInput extends TextInput implements IDateInput {
 		const isValidMax = !maxDate || date.isBefore(maxDate) || date.isSame(maxDate);
 		if (!isValidMax) return false;
 
-		const isAllowedDate =
-			this.allowedDates === undefined ||
-			(this.allowedDates instanceof Function && this.allowedDates(dayjs(value, format).format(this.dateFormat))) ||
-			(Array.isArray(this.allowedDates) &&
-				this.allowedDates.indexOf(dayjs(value, format).format(this.dateFormat)) !== -1);
+		const isAllowedDate = this.getAllowedDates(dayjs(value, format).toDate());
 
-		if (!isAllowedDate) return false;
-
-		return true;
+		return isAllowedDate;
 	}
 
 	public isValidFormatDate(value: string, format: string, strict = true): boolean {
@@ -280,18 +238,7 @@ export class DateInput extends TextInput implements IDateInput {
 	}
 
 	public getAllowedDates(date: Date) {
-		if (!this.allowedDates) return true;
-
-		if (this.allowedDates.length === 0) return false;
-
-		const dayjsDate = dayjs(date);
-		const dateString = dayjsDate.format(this.dateFormat);
-
-		if (this.allowedDates instanceof Function) {
-			return this.allowedDates(dateString);
-		}
-
-		return this.allowedDates.indexOf(dateString) !== -1;
+		return isDateAllowed(date, this.dateFormat, this.allowedDates);
 	}
 
 	public formatISODateValue(value: string): string {
@@ -321,49 +268,29 @@ export class DateInput extends TextInput implements IDateInput {
 	}
 
 	public blur(event: Event, element: any) {
-		this.removeDateMask();
-		this.setDateValue(this.formatter(this.value));
 		super.blur(event, element);
+		this.setDateValue(this.formatter(this.value));
 		if (!Utils.isMobile()) {
 			this.showDatePicker = false;
 		}
 	}
 
-	public onMounted() {
+	public onMounted(element: any) {
+		super.onMounted(element);
+
 		if (!this.value) return;
 
 		this.setDateValue(this.formatter(this.value));
 	}
 
 	public focus(event: Event, element: any) {
-		this.addDateMask();
 		super.focus(event, element);
-	}
+		if (!this.inputFormat || !this.value) return;
 
-	/**
-	 * Add date mask
-	 */
-	protected addDateMask() {
-		if (isUndefined(this.initialMask) || !this.value) return;
-
-		this.internalDisplayValue = dayjs(this.value, this.dateFormat).format(this.inputFormat || this.displayFormat);
-		this.mask = this.initialMask;
-	}
-
-	/**
-	 * Removes the component mask if value is valid
-	 */
-	protected removeDateMask() {
-		if (
-			isUndefined(this.initialMask) ||
-			!this.value ||
-			this.dateError ||
-			!this.isValidDate(this.value, this.dateFormat)
-		) {
-			return;
-		}
-
-		this.mask = '';
+		const dayObj = dayjs(this.value, this.dateFormat, true);
+		if (!dayObj.isValid()) return;
+		// on focus, should use the inputFormat
+		this.internalDisplayValue = dayObj.format(this.inputFormat);
 	}
 
 	/**
@@ -385,23 +312,6 @@ export class DateInput extends TextInput implements IDateInput {
 		}
 	}
 
-	/**
-	 * Checks if a date format is simple.
-	 * Simple date formats are the ones that consists only of 'DD', 'MM' or 'YYYY', and mask delimiters
-	 * @param format The format to be checked
-	 * @returns true if it is simple, false otherwise
-	 */
-	protected isSimpleFormat(format: string): boolean {
-		const simpleTokens = ['DD', 'MM', 'YYYY'];
-
-		// remove the simple tokens from the string
-		const replaced = simpleTokens.reduce((result, token) => result.replace(token, ''), format);
-
-		const chars = replaced.split('');
-
-		return chars.length ? chars.every((char) => Mask.isMaskDelimiter(char)) : true;
-	}
-
 	private previousHint = '';
 
 	private previousPersistentHint = false;
@@ -423,18 +333,8 @@ export class DateInput extends TextInput implements IDateInput {
 		this.persistentHint = this.previousPersistentHint;
 	}
 
-	/**
-	 * Converts a date format to a mask
-	 */
-	private toMask(format: string) {
-		return format.replace(/[A-Za-z]/gi, '#'); // .split('').map((char: string) => (char === '#' ? /\d/ : char));
-	}
-
 	public getMask() {
-		if (this.isFocused) {
-			return this.toMask(this.inputFormat || this.displayFormat || '');
-		}
-		return '';
+		return getDateMask(this.inputFormat || this.displayFormat || '', this.isFocused);
 	}
 }
 
@@ -446,10 +346,13 @@ FormatterParserProvider.registerFormatter(
 			dateFormat = Config.dateFormat,
 			displayFormat = Config.displayFormat,
 			inputFormat = Config.dateInputFormat,
-			mask = '',
-			initialMask,
-			isSimpleDisplay = false,
-		}: any = {},
+			isFocused = false,
+		}: {
+			dateFormat?: string;
+			displayFormat?: string;
+			inputFormat?: string;
+			isFocused?: boolean;
+		} = {},
 	) => {
 		if (!value) {
 			return '';
@@ -461,22 +364,13 @@ FormatterParserProvider.registerFormatter(
 			return value;
 		}
 
-		if (mask && initialMask) {
-			if (inputFormat) {
-				return dayjs(value, dateFormat).format(inputFormat);
-			}
-
-			let valueToUnmask = value;
-			if (isSimpleDisplay) {
-				valueToUnmask = dayjs(value, dateFormat).format(displayFormat);
-			}
+		const mask = getDateMask(inputFormat || displayFormat, isFocused);
 
-			const unmasked = Mask.getValueWithoutMask(valueToUnmask);
-			const masked = Mask.getValueWithMask(unmasked, mask);
-			return masked;
+		if (!mask || !isFocused || !inputFormat) {
+			return dayjs(value, dateFormat).format(displayFormat);
 		}
 
-		return dayjs(value, dateFormat).format(displayFormat);
+		return dayjs(value, dateFormat).format(inputFormat);
 	},
 );
 
@@ -488,51 +382,38 @@ FormatterParserProvider.registerParser(
 			dateFormat = Config.dateFormat,
 			displayFormat = Config.displayFormat,
 			inputFormat = Config.dateInputFormat,
-			mask = '',
-			initialMask,
-			isSimpleDisplay = false,
-		}: any = {},
+			isFocused = false,
+		}: {
+			dateFormat?: string;
+			displayFormat?: string;
+			inputFormat?: string;
+			isFocused?: boolean;
+		} = {},
 	) => {
 		if (!value) {
 			return null;
 		}
 
-		if (dayjs(value, displayFormat, true).isValid()) {
-			return dayjs(value, displayFormat).format(dateFormat);
-		}
+		const mask = getDateMask(inputFormat || displayFormat, isFocused);
+		if (!Mask.checkMask(value, mask)) return value;
 
-		if (mask && Mask.checkMask(value, mask)) {
-			if (inputFormat) {
-				if (dayjs(value, inputFormat, true).isValid()) {
-					return dayjs(value, inputFormat).format(dateFormat);
-				}
-
-				return value;
+		// when using inputFormat and focused, should parse according to inputFormat
+		if (inputFormat && isFocused) {
+			const { valid, newValue } = validateThenFormat(value, inputFormat, dateFormat);
+			if (valid) {
+				return newValue;
 			}
 
-			const unmasked = Mask.getValueWithoutMask(value);
-			let masked;
-
-			if (!initialMask || isSimpleDisplay) {
-				const displayFmtMask = displayFormat.replace(/[A-Za-z]/gi, '#');
-
-				masked = Mask.getValueWithMask(unmasked, displayFmtMask);
-
-				if (dayjs(masked, displayFormat, true).format(displayFormat) === masked) {
-					return dayjs(masked, displayFormat).format(dateFormat);
-				}
-			}
-
-			const dateFmtMask = dateFormat.replace(/[A-Za-z]/gi, '#');
-
-			masked = Mask.getValueWithMask(unmasked, dateFmtMask);
+			return value;
+		}
 
-			if (dayjs(masked, dateFormat, true).format(dateFormat) === masked) {
-				return masked;
-			}
+		// should parse according to displayFormat
+		const { valid, newValue } = validateThenFormat(value, displayFormat, dateFormat);
+		if (!valid) {
+			return value;
 		}
 
-		return value;
+		return newValue;
 	},
 );
 

package/src/components/zd-date-input/utils.ts

@@ -0,0 +1,17 @@
+import { dayjs } from '@zeedhi/core';
+import { toMask } from '../../utils/date-utils/date-utils';
+
+export function getDateMask(format: string, focused: boolean) {
+    if (focused) {
+        return toMask(format);
+    }
+    return '';
+}
+
+export function validateThenFormat(value: string, fromFormat: string, toFormat: string) {
+    if (dayjs(value, fromFormat, true).isValid()) {
+        return { valid: true, newValue: dayjs(value, fromFormat).format(toFormat) };
+    }
+
+    return { valid: false, newValue: null };
+}