Parse input opts logic moved from MaskInput

src/mask-input.ts

@@ -1,5 +1,5 @@
 import { Mask, MaskOptions } from './mask'
-import { parseMask, parseOpts, parseTokens } from './parser'
+import { parseInput } from './parser'
 
 type OnMaskaType = (detail: MaskaDetail) => void
 
@@ -41,24 +41,7 @@ export class MaskInput {
 
   private init (inputs: HTMLInputElement[], defaults: MaskOptions): void {
     for (const input of inputs) {
-      const opts = { ...defaults }
+      const mask = new Mask(parseInput(input, defaults))
-      if (input.dataset.maska != null && input.dataset.maska !== '') {
-        opts.mask = parseMask(input.dataset.maska)
-      }
-      if (input.dataset.maskaEager != null) {
-        opts.eager = parseOpts(input.dataset.maskaEager)
-      }
-      if (input.dataset.maskaReversed != null) {
-        opts.reversed = parseOpts(input.dataset.maskaReversed)
-      }
-      if (input.dataset.maskaTokensReplace != null) {
-        opts.tokensReplace = parseOpts(input.dataset.maskaTokensReplace)
-      }
-      if (input.dataset.maskaTokens != null) {
-        opts.tokens = parseTokens(input.dataset.maskaTokens)
-      }
-
-      const mask = new Mask(opts)
       this.items.set(input, mask)
 
       if (input.value !== '') {

src/parser.ts

@@ -1,15 +1,40 @@
-import { MaskType } from './mask'
+import { MaskOptions, MaskType } from './mask'
 import { MaskTokens } from './tokens'
 
 const parseJson = (value: string): any => JSON.parse(value.replaceAll("'", '"'))
 
-export const parseOpts = (value: string): boolean =>
+export const parseInput = (
+  input: HTMLInputElement,
+  defaults: MaskOptions = {}
+): MaskOptions => {
+  const opts = { ...defaults }
+
+  if (input.dataset.maska != null && input.dataset.maska !== '') {
+    opts.mask = parseMask(input.dataset.maska)
+  }
+  if (input.dataset.maskaEager != null) {
+    opts.eager = parseOpts(input.dataset.maskaEager)
+  }
+  if (input.dataset.maskaReversed != null) {
+    opts.reversed = parseOpts(input.dataset.maskaReversed)
+  }
+  if (input.dataset.maskaTokensReplace != null) {
+    opts.tokensReplace = parseOpts(input.dataset.maskaTokensReplace)
+  }
+  if (input.dataset.maskaTokens != null) {
+    opts.tokens = parseTokens(input.dataset.maskaTokens)
+  }
+
+  return opts
+}
+
+const parseOpts = (value: string): boolean =>
   value !== '' ? Boolean(JSON.parse(value)) : true
 
-export const parseMask = (value: string): MaskType =>
+const parseMask = (value: string): MaskType =>
   value.startsWith('[') && value.endsWith(']') ? parseJson(value) : value
 
-export const parseTokens = (value: string): MaskTokens => {
+const parseTokens = (value: string): MaskTokens => {
   if (value.startsWith('{') && value.endsWith('}')) {
     return parseJson(value)
   }

test/parser.test.ts

@@ -1,67 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { parseMask, parseOpts, parseTokens } from '../src/parser'
-
-test('mask: empty', () => {
-  expect(parseMask('')).toBe('')
-})
-
-test('mask: string', () => {
-  expect(parseMask('#-#')).toBe('#-#')
-})
-
-test('mask: array', () => {
-  expect(parseMask('["#", "##"]')).toEqual(expect.arrayContaining(['#', '##']))
-})
-
-test('opts: empty', () => {
-  expect(parseOpts('')).toBe(true)
-})
-
-test('opts: true', () => {
-  expect(parseOpts('true')).toBe(true)
-})
-
-test('opts: truthy', () => {
-  expect(parseOpts('1')).toBe(true)
-})
-
-test('opts: false', () => {
-  expect(parseOpts('false')).toBe(false)
-})
-
-test('opts: falsy', () => {
-  expect(parseOpts('0')).toBe(false)
-})
-
-test('tokens: json', () => {
-  expect(parseTokens('{ "Z": { "pattern": "[0-9]" } }')).toEqual(
-    expect.objectContaining({ Z: { pattern: '[0-9]' } })
-  )
-})
-
-test('tokens: code', () => {
-  expect(parseTokens('Z:[0-9]')).toEqual(
-    expect.objectContaining({
-      Z: { pattern: /[0-9]/, multiple: false, optional: false, repeated: false }
-    })
-  )
-
-  expect(parseTokens('Z:[0-9]:multiple')).toEqual(
-    expect.objectContaining({
-      Z: { pattern: /[0-9]/, multiple: true, optional: false, repeated: false }
-    })
-  )
-
-  expect(parseTokens('Z:[0-9]:optional')).toEqual(
-    expect.objectContaining({
-      Z: { pattern: /[0-9]/, multiple: false, optional: true, repeated: false }
-    })
-  )
-
-  expect(parseTokens('Z:[0-9]:repeated')).toEqual(
-    expect.objectContaining({
-      Z: { pattern: /[0-9]/, multiple: false, optional: false, repeated: true }
-    })
-  )
-})