refactor: qualifiers

Author: mdjastrzebski

src/constructs/quantifiers.ts

@@ -1,73 +1,28 @@
 import { encodeAtom } from '../encoder/encoder';
 import type { EncodeResult } from '../encoder/types';
-import { ensureArray } from '../utils/elements';
-import type { RegexConstruct, RegexElement, RegexSequence } from '../types';
+import type { RegexSequence } from '../types';
 
 export interface QuantifierOptions {
   greedy?: boolean;
 }
-export interface ZeroOrMore extends RegexConstruct {
-  type: 'zeroOrMore';
-  children: RegexElement[];
-  options?: QuantifierOptions;
-}
-
-export interface OneOrMore extends RegexConstruct {
-  type: 'oneOrMore';
-  children: RegexElement[];
-  options?: QuantifierOptions;
-}
-
-export interface Optional extends RegexConstruct {
-  type: 'optional';
-  children: RegexElement[];
-  options?: QuantifierOptions;
-}
-
-export function zeroOrMore(sequence: RegexSequence, options?: QuantifierOptions): ZeroOrMore {
-  return {
-    type: 'zeroOrMore',
-    children: ensureArray(sequence),
-    options,
-    encode: encodeZeroOrMore,
-  };
-}
-
-export function oneOrMore(sequence: RegexSequence, options?: QuantifierOptions): OneOrMore {
-  return {
-    type: 'oneOrMore',
-    children: ensureArray(sequence),
-    options,
-    encode: encodeOneOrMore,
-  };
-}
-
-export function optional(sequence: RegexSequence, options?: QuantifierOptions): Optional {
-  return {
-    type: 'optional',
-    children: ensureArray(sequence),
-    options,
-    encode: encodeOptional,
-  };
-}
 
-function encodeZeroOrMore(this: ZeroOrMore): EncodeResult {
+export function zeroOrMore(sequence: RegexSequence, options?: QuantifierOptions): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}*${this.options?.greedy === false ? '?' : ''}`,
+    pattern: `${encodeAtom(sequence).pattern}*${options?.greedy === false ? '?' : ''}`,
   };
 }
 
-function encodeOneOrMore(this: OneOrMore): EncodeResult {
+export function oneOrMore(sequence: RegexSequence, options?: QuantifierOptions): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}+${this.options?.greedy === false ? '?' : ''}`,
+    pattern: `${encodeAtom(sequence).pattern}+${options?.greedy === false ? '?' : ''}`,
   };
 }
 
-function encodeOptional(this: Optional): EncodeResult {
+export function optional(sequence: RegexSequence, options?: QuantifierOptions): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}?${this.options?.greedy === false ? '?' : ''}`,
+    pattern: `${encodeAtom(sequence).pattern}?${options?.greedy === false ? '?' : ''}`,
   };
 }

src/encoder/encoder.ts

@@ -1,14 +1,16 @@
-import type { RegexElement } from '../types';
+import type { RegexElement, RegexSequence } from '../types';
+import { ensureArray } from '../utils/elements';
 import { escapeText } from '../utils/text';
 import type { EncodeResult } from './types';
 
-export function encodeSequence(elements: RegexElement[]): EncodeResult {
+export function encodeSequence(sequence: RegexSequence): EncodeResult {
+  const elements = ensureArray(sequence);
   const encodedNodes = elements.map((n) => encodeNode(n));
   return concatSequence(encodedNodes);
 }
 
-export function encodeAtom(elements: RegexElement[]): EncodeResult {
-  return wrapAtom(encodeSequence(elements));
+export function encodeAtom(sequence: RegexSequence): EncodeResult {
+  return wrapAtom(encodeSequence(sequence));
 }
 
 function encodeNode(element: RegexElement): EncodeResult {