fix #878

packages/imask/src/controls/input.ts

@@ -1,6 +1,6 @@
 import { objectIncludes, DIRECTION, type Selection } from '../core/utils';
 import ActionDetails from '../core/action-details';
-import createMask, { maskedClass, type FactoryArg, type FactoryReturnMasked } from '../masked/factory';
+import createMask, { FactoryOpts, maskedClass, type FactoryArg, type FactoryReturnMasked } from '../masked/factory';
 import Masked from '../masked/base';
 import MaskElement from './mask-element';
 import HTMLInputMaskElement, { type InputElement } from './html-input-mask-element';
@@ -204,7 +204,7 @@ class InputMask<Opts extends FactoryArg> {
   }
 
   /** Updates options with deep equal check, recreates @{link Masked} model if mask type changes */
-  updateOptions (opts: Partial<Opts>) {
+  updateOptions<UpdateOpts extends Partial<Opts>> (opts: UpdateOpts extends FactoryOpts ? UpdateOpts : never) {
     const { mask, ...restOpts } = opts;
 
     const updateMask = !this.maskEquals(mask);

packages/imask/src/masked/factory.ts

@@ -49,15 +49,24 @@ export
 type FactoryStaticReturnMasked<Opts extends FactoryStaticOpts> =
   Opts extends MaskedDateFactoryOptions ? MaskedDate :
   Opts extends MaskedNumberOptions ? MaskedNumber :
-  Opts extends MaskedEnumOptions ? MaskedEnum :
-  Opts extends MaskedRangeOptions ? MaskedRange :
   Opts extends MaskedPatternOptions ? MaskedPattern :
   Opts extends MaskedDynamicOptions ? MaskedDynamic :
   Opts extends MaskedRegExpOptions ? MaskedRegExp :
   Opts extends MaskedFunctionOptions ? MaskedFunction :
   never
 ;
 
+export
+type FactoryStaticMaskReturnMasked<Mask extends FactoryStaticOpts['mask']> =
+  Mask extends MaskedDateFactoryOptions['mask'] ? MaskedDate :
+  Mask extends MaskedNumberOptions['mask'] ? MaskedNumber :
+  Mask extends MaskedPatternOptions['mask'] ? MaskedPattern :
+  Mask extends MaskedDynamicOptions['mask'] ? MaskedDynamic :
+  Mask extends MaskedRegExpOptions['mask'] ? MaskedRegExp :
+  Mask extends MaskedFunctionOptions['mask'] ? MaskedFunction :
+  never
+;
+
 
 export
 type FactoryInstanceOpts = MaskedOptions & { mask: Masked };
@@ -96,11 +105,12 @@ export
 type FactoryOpts = FactoryConstructorOpts | FactoryInstanceOpts | FactoryStaticOpts;
 
 export
-type FactoryArg = Masked | FactoryOpts;
+type FactoryArg = Masked | FactoryOpts | FactoryStaticOpts['mask'];
 
 export
 type FactoryReturnMasked<Opts extends FactoryArg> =
   Opts extends Masked ? Opts :
+  Opts extends FactoryStaticOpts['mask'] ? FactoryStaticMaskReturnMasked<Opts> :
   Opts extends FactoryConstructorOpts ? FactoryConstructorReturnMasked<Opts> :
   Opts extends FactoryInstanceOpts ? FactoryInstanceReturnMasked<Opts> :
   Opts extends FactoryStaticOpts ? FactoryStaticReturnMasked<Opts> :
@@ -178,6 +188,7 @@ type NormalizedInstanceOpts<Opts extends FactoryInstanceOpts> =
 
 export
 type NormalizedOpts<Opts extends FactoryArg> =
+  Opts extends FactoryStaticOpts['mask'] ? { mask: Opts } :
   Opts extends Masked ? NormalizedMaskedOpts<Opts> :
   Opts extends FactoryInstanceOpts ? NormalizedInstanceOpts<Opts> :
   Opts extends FactoryStaticOpts | FactoryConstructorOpts ? Opts :
@@ -198,7 +209,7 @@ function normalizeOpts<Opts extends FactoryArg> (opts: Opts): NormalizedOpts<Opt
     */
     const { mask=undefined, ...instanceOpts } =
       opts instanceof IMask.Masked ? { mask: opts } :
-      opts.mask instanceof IMask.Masked ? opts : {};
+      isObject(opts) && (opts as FactoryInstanceOpts).mask instanceof IMask.Masked ? (opts as FactoryInstanceOpts) : {};
 
     if (mask) {
       const _mask = (mask as Masked).mask;

packages/imask/src/masked/pattern.ts

@@ -3,7 +3,7 @@ import IMask from '../core/holder';
 import { type TailDetails } from '../core/tail-details';
 import { DIRECTION, type Direction } from '../core/utils';
 import Masked, { type AppendFlags, type ExtractFlags, type MaskedOptions, type MaskedState } from './base';
-import createMask, { type FactoryOpts, normalizeOpts } from './factory';
+import createMask, { type FactoryArg, normalizeOpts } from './factory';
 import type PatternBlock from './pattern/block';
 import ChunksTailDetails from './pattern/chunk-tail-details';
 import PatternCursor from './pattern/cursor';
@@ -24,7 +24,7 @@ type MaskedPatternOptions<Value=string, M extends MaskedPattern<Value>=MaskedPat
 
 export
 type Definitions = {
-  [k: string]: FactoryOpts,
+  [k: string]: FactoryArg,
 };
 
 export
@@ -55,7 +55,7 @@ class MaskedPattern<Value=string> extends Masked<Value> {
 
   declare mask: string;
   /** */
-  declare blocks: { [key: string]: FactoryOpts };
+  declare blocks: { [key: string]: FactoryArg };
   /** */
   declare definitions: Definitions;
   /** Single char for empty input */

packages/imask/test/masked/factory.types.ts

@@ -12,11 +12,9 @@ import type MaskedRange from '../../src/masked/range';
 import type MaskedRegExp from '../../src/masked/regexp';
 
 import { type MaskedDynamicOptions } from '../../src/masked/dynamic';
-import { type MaskedEnumOptions } from '../../src/masked/enum';
 import { type MaskedFunctionOptions } from '../../src/masked/function';
 import { type MaskedNumberOptions } from '../../src/masked/number';
 import { type MaskedPatternOptions } from '../../src/masked/pattern';
-import { type MaskedRangeOptions } from '../../src/masked/range';
 import { type MaskedRegExpOptions } from '../../src/masked/regexp';
 
 class MyMasked extends Masked {}
@@ -57,13 +55,12 @@ type cases = [
   Check<Equal<FactoryReturnMasked<{ mask: DateConstructor }>, MaskedDate>>,
   Check<Equal<FactoryReturnMasked<MaskedNumberOptions>, MaskedNumber>>,
   Check<Equal<FactoryReturnMasked<MaskedDynamicOptions>, MaskedDynamic>>,
-  Check<Equal<FactoryReturnMasked<MaskedRangeOptions>, MaskedRange>>,
-  Check<Equal<FactoryReturnMasked<MaskedEnumOptions>, MaskedEnum>>,
 
   Check<Equal<FactoryReturnMasked<MaskedNumberOptions>['typedValue'], number>>,
 
   Check<Equal<NormalizedOpts<MaskedNumberOptions>, MaskedNumberOptions>>,
   Check<NormalizedOpts<{ mask: MaskedNumber }> extends { _mask: MaskedNumber, mask: typeof MaskedNumber } ? true : false>,
   Check<NormalizedOpts<MaskedNumber> extends { _mask: MaskedNumber, mask: typeof MaskedNumber } ? true : false>,
   Check<Equal<NormalizedOpts<{ mask: typeof MaskedNumber }>, { mask: typeof MaskedNumber }>>,
+  Check<Equal<NormalizedOpts<NumberConstructor>, { mask: NumberConstructor }>>,
 ];

packages/imask/test/masked/pattern/insert.ts

@@ -185,4 +185,19 @@ describe('Insert', function () {
       assert.equal(masked.displayValue, 'XXX-XX-6789');
     });
   });
+
+  describe('definitions', function () {
+    it('should work', function () {
+      masked.updateOptions({
+        mask: '#00000',
+        definitions: {
+          '#': /[1-6]/,
+        },
+      });
+      masked.unmaskedValue = '123456';
+
+      assert.equal(masked.unmaskedValue, '123456');
+      assert.equal(masked.value, '123456');
+    });
+  });
 });