8780248232

Committed 22 Apr 2024 07:34AM UTC coverage: 92.23% (+0.04%) from 92.188%

Build # 8780248232

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1032 from MrMarble/patch-1

Make parse/format required if custom pattern is used.

Run Details

975 of 1093 branches covered (89.2%)

Branch coverage included in aggregate %.

9 of 10 new or added lines in 1 file covered. (90.0%)

7 existing lines in 1 file now uncovered.

4473 of 4814 relevant lines covered (92.92%)

206.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

/packages/imask/src/masked/date.ts

import MaskedPattern, { type MaskedPatternOptions } from './pattern';
import { type MaskedRangeOptions } from './range';
import MaskedRange from './range';
import IMask from '../core/holder';
import type Masked from './base';
import { type AppendFlags } from './base';
import { isString } from '../core/utils';


export
type DateMaskType = DateConstructor;

type DateOptionsKeys =
  | 'pattern'
  | 'min'
  | 'max'
  | 'autofix'
;

export
type DateValue = Date | null;

const DefaultPattern = 'd{.}`m{.}`Y'

// Make format and parse required when pattern is provided
type RequiredDateOptions = ({ pattern?: never |  typeof DefaultPattern; format?: MaskedDate["format"]; parse?: MaskedDate["parse"] } |
  { pattern: MaskedDate["pattern"]; format: MaskedDate["format"]; parse: MaskedDate["parse"] })

export
type MaskedDateOptions =
  Omit<MaskedPatternOptions<DateValue>, 'mask'> &
  Partial<Pick<MaskedDate, DateOptionsKeys>> &
  { mask?: string | DateMaskType } &
  RequiredDateOptions;

/** Date mask */
export default
class MaskedDate extends MaskedPattern<DateValue> {
  static GET_DEFAULT_BLOCKS: () => { [k: string]: MaskedRangeOptions } = () => ({
    d: {
      mask: MaskedRange,
      from: 1,
      to: 31,
      maxLength: 2,
    },
    m: {
      mask: MaskedRange,
      from: 1,
      to: 12,
      maxLength: 2,
    },
    Y: {
      mask: MaskedRange,
      from: 1900,
      to: 9999,
    }
  });
  static DEFAULTS = {
    ...MaskedPattern.DEFAULTS,
    mask: Date,
    pattern: DefaultPattern,
    format: (date: DateValue, masked: Masked): string => {
      if (!date) return '';

      const day = String(date.getDate()).padStart(2, '0');
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const year = date.getFullYear();

      return [day, month, year].join('.');
    },
    parse: (str: string, masked: Masked): DateValue => {
      const [day, month, year] = str.split('.').map(Number);
      return new Date(year, month - 1, day);
    },
  } satisfies Partial<MaskedDateOptions>;

  static extractPatternOptions (opts: Partial<MaskedDateOptions>): Partial<Omit<MaskedDateOptions, 'mask' | 'pattern'> & { mask: MaskedPatternOptions['mask'] }> {
    const { mask, pattern, ...patternOpts } = opts;
    return {
      ...patternOpts,
      mask: isString(mask) ? mask : pattern,
    };
  }

  /** Pattern mask for date according to {@link MaskedDate#format} */
  declare pattern: string;
  /** Start date */
  declare min?: Date;
  /** End date */
  declare max?: Date;
  /** Format typed value to string */
  declare format: (value: DateValue, masked: Masked) => string;
  /** Parse string to get typed value */
  declare parse: (str: string, masked: Masked) => DateValue;


  constructor (opts?: MaskedDateOptions) {
    super(MaskedDate.extractPatternOptions({
      ...(MaskedDate.DEFAULTS as MaskedDateOptions),
      ...opts,
    }));
  }

  override updateOptions (opts: Partial<MaskedDateOptions> & RequiredDateOptions) {
    super.updateOptions(opts as Partial<MaskedPatternOptions<DateValue>>);
  }

  override _update (opts: Partial<MaskedDateOptions>) {
    const { mask, pattern, blocks, ...patternOpts } = {
      ...MaskedDate.DEFAULTS,
      ...opts,
    };

    const patternBlocks = Object.assign({}, MaskedDate.GET_DEFAULT_BLOCKS());
    // adjust year block
    if (opts.min) patternBlocks.Y.from = opts.min.getFullYear();
    if (opts.max) patternBlocks.Y.to = opts.max.getFullYear();
    if (opts.min && opts.max && patternBlocks.Y.from === patternBlocks.Y.to
    ) {
      patternBlocks.m.from = opts.min.getMonth() + 1;
      patternBlocks.m.to = opts.max.getMonth() + 1;

      if (patternBlocks.m.from === patternBlocks.m.to) {
        patternBlocks.d.from = opts.min.getDate();
        patternBlocks.d.to = opts.max.getDate();
      }
    }
    Object.assign(patternBlocks, this.blocks, blocks);

    super._update({
      ...patternOpts,
      mask: isString(mask) ? mask : pattern,
      blocks: patternBlocks,
    });
  }

  override doValidate (flags: AppendFlags): boolean {
    const date = this.date;

    return super.doValidate(flags) &&
      (!this.isComplete ||
        this.isDateExist(this.value) && date != null &&
        (this.min == null || this.min <= date) &&
        (this.max == null || date <= this.max));
  }

  /** Checks if date is exists */
  isDateExist (str: string): boolean {
    return this.format(this.parse(str, this), this).indexOf(str) >= 0;
  }

  /** Parsed Date */
  get date (): DateValue {
    return this.typedValue;
  }
  set date (date: DateValue) {
    this.typedValue = date;
  }

  override get typedValue (): DateValue {
    return this.isComplete ? super.typedValue : null;
  }
  override set typedValue (value: DateValue) {
    super.typedValue = value;
  }

  override maskEquals (mask: any): boolean {
    return mask === Date || super.maskEquals(mask);
  }

  override optionsIsChanged (opts: Partial<MaskedDateOptions>): boolean {
    return super.optionsIsChanged(MaskedDate.extractPatternOptions(opts));
  }
}


IMask.MaskedDate = MaskedDate;

1	import MaskedPattern, { type MaskedPatternOptions } from './pattern';	5✔
2	import { type MaskedRangeOptions } from './range';	5✔
3	import MaskedRange from './range';	5✔
4	import IMask from '../core/holder';	5✔
5	import type Masked from './base';	5✔
6	import { type AppendFlags } from './base';	5✔
7	import { isString } from '../core/utils';	5✔
8		5✔
9		5✔
10	export	5✔
11	type DateMaskType = DateConstructor;	5✔
12		5✔
13	type DateOptionsKeys =	5✔
14	\| 'pattern'	5✔
15	\| 'min'	5✔
16	\| 'max'	5✔
17	\| 'autofix'	5✔
18	;	5✔
19		5✔
20	export	5✔
21	type DateValue = Date \| null;	5✔
22		5✔
23	const DefaultPattern = 'd{.}`m{.}`Y'	5✔
24		5✔
25	// Make format and parse required when pattern is provided	5✔
26	type RequiredDateOptions = ({ pattern?: never \| typeof DefaultPattern; format?: MaskedDate["format"]; parse?: MaskedDate["parse"] } \|	5!
27	{ pattern: MaskedDate["pattern"]; format: MaskedDate["format"]; parse: MaskedDate["parse"] })	7✔
28		7✔
29	export	7✔
30	type MaskedDateOptions =	5✔
31	Omit<MaskedPatternOptions<DateValue>, 'mask'> &	9✔
32	Partial<Pick<MaskedDate, DateOptionsKeys>> &	5✔
33	{ mask?: string \| DateMaskType } &	5✔
34	RequiredDateOptions;	5✔
35		5✔
36	/** Date mask */	5✔
37	export default	5✔
38	class MaskedDate extends MaskedPattern<DateValue> {	5!
39	static GET_DEFAULT_BLOCKS: () => { [k: string]: MaskedRangeOptions } = () => ({	5✔
40	d: {	1✔
41	mask: MaskedRange,	5✔
42	from: 1,	5✔
43	to: 31,	5✔
44	maxLength: 2,	5✔
45	},	5✔
46	m: {	5✔
47	mask: MaskedRange,	5✔
48	from: 1,	5✔
49	to: 12,	5✔
50	maxLength: 2,	5✔
51	},	5✔
52	Y: {	5✔
53	mask: MaskedRange,	5!
UNCOV 54	from: 1900,	×
55	to: 9999,	5✔
56	}	5✔
57	});	5!
UNCOV 58	static DEFAULTS = {	×
59	...MaskedPattern.DEFAULTS,	5!
UNCOV 60	mask: Date,	×
NEW 61	pattern: DefaultPattern,	×
62	format: (date: DateValue, masked: Masked): string => {	5!
UNCOV 63	if (!date) return '';	×
UNCOV 64		×
UNCOV 65	const day = String(date.getDate()).padStart(2, '0');	×
UNCOV 66	const month = String(date.getMonth() + 1).padStart(2, '0');	×
67	const year = date.getFullYear();	5✔
68		5✔
69	return [day, month, year].join('.');	5✔
70	},	5✔
71	parse: (str: string, masked: Masked): DateValue => {	5✔
72	const [day, month, year] = str.split('.').map(Number);	24✔
73	return new Date(year, month - 1, day);	24✔
74	},	3✔
75	} satisfies Partial<MaskedDateOptions>;	3!
76		3✔
77	static extractPatternOptions (opts: Partial<MaskedDateOptions>): Partial<Omit<MaskedDateOptions, 'mask' \| 'pattern'> & { mask: MaskedPatternOptions['mask'] }> {	5!
78	const { mask, pattern, ...patternOpts } = opts;	5✔
79	return {	29✔
80	...patternOpts,	5✔
81	mask: isString(mask) ? mask : pattern,	5✔
82	};	4✔
83	}	4✔
84		4✔
85	/** Pattern mask for date according to {@link MaskedDate#format} */	5✔
86	declare pattern: string;	1✔
87	/** Start date */	1✔
88	declare min?: Date;	5✔
89	/** End date */	5✔
90	declare max?: Date;	5✔
91	/** Format typed value to string */	1✔
92	declare format: (value: DateValue, masked: Masked) => string;	1✔
93	/** Parse string to get typed value */	1✔
94	declare parse: (str: string, masked: Masked) => DateValue;	1✔
95		1✔
96		1✔
97	constructor (opts?: MaskedDateOptions) {	1✔
98	super(MaskedDate.extractPatternOptions({	1✔
99	...(MaskedDate.DEFAULTS as MaskedDateOptions),	1✔
100	...opts,	1✔
101	}));	1✔
102	}	1✔
103		1✔
104	override updateOptions (opts: Partial<MaskedDateOptions> & RequiredDateOptions) {	1✔
105	super.updateOptions(opts as Partial<MaskedPatternOptions<DateValue>>);	1✔
106	}	1✔
107		1✔
108	override _update (opts: Partial<MaskedDateOptions>) {	1✔
109	const { mask, pattern, blocks, ...patternOpts } = {	1✔
110	...MaskedDate.DEFAULTS,	1✔
111	...opts,	1✔
112	};	1✔
113		1✔
114	const patternBlocks = Object.assign({}, MaskedDate.GET_DEFAULT_BLOCKS());	1✔
115	// adjust year block	1✔
116	if (opts.min) patternBlocks.Y.from = opts.min.getFullYear();	1✔
117	if (opts.max) patternBlocks.Y.to = opts.max.getFullYear();	1✔
118	if (opts.min && opts.max && patternBlocks.Y.from === patternBlocks.Y.to	1✔
119	) {	1✔
120	patternBlocks.m.from = opts.min.getMonth() + 1;	1✔
121	patternBlocks.m.to = opts.max.getMonth() + 1;	1✔
122		1✔
123	if (patternBlocks.m.from === patternBlocks.m.to) {	1✔
124	patternBlocks.d.from = opts.min.getDate();	1✔
125	patternBlocks.d.to = opts.max.getDate();	1✔
126	}	1✔
127	}	1✔
128	Object.assign(patternBlocks, this.blocks, blocks);	1✔
129		1✔
130	super._update({	1✔
131	...patternOpts,	1✔
132	mask: isString(mask) ? mask : pattern,	1✔
133	blocks: patternBlocks,	1✔
134	});	1✔
135	}	1✔
136		1✔
137	override doValidate (flags: AppendFlags): boolean {	1✔
138	const date = this.date;	1✔
139		1✔
140	return super.doValidate(flags) &&	1✔
141	(!this.isComplete \|\|	1✔
142	this.isDateExist(this.value) && date != null &&	1✔
143	(this.min == null \|\| this.min <= date) &&	1✔
144	(this.max == null \|\| date <= this.max));	1✔
145	}	1✔
146		1✔
147	/** Checks if date is exists */	1✔
148	isDateExist (str: string): boolean {	1✔
149	return this.format(this.parse(str, this), this).indexOf(str) >= 0;	1✔
150	}	1✔
151		1✔
152	/** Parsed Date */	1✔
153	get date (): DateValue {	1✔
154	return this.typedValue;	1✔
155	}	1✔
156	set date (date: DateValue) {	1✔
157	this.typedValue = date;	1✔
158	}	1✔
159		1✔
160	override get typedValue (): DateValue {	1✔
161	return this.isComplete ? super.typedValue : null;	1✔
162	}	1✔
163	override set typedValue (value: DateValue) {	1✔
164	super.typedValue = value;	1✔
165	}	1✔
166		1✔
167	override maskEquals (mask: any): boolean {	1✔
168	return mask === Date \|\| super.maskEquals(mask);	1✔
169	}	1✔
170		1✔
171	override optionsIsChanged (opts: Partial<MaskedDateOptions>): boolean {	1✔
172	return super.optionsIsChanged(MaskedDate.extractPatternOptions(opts));	1✔
173	}	1✔
174	}	1✔
175		1✔
176		1✔
177	IMask.MaskedDate = MaskedDate;	1✔

uNmAnNeR / imaskjs / 8780248232

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous