refactor: optimize grouping

src/__tests__/compiler.test.tsx → src/__tests__/encoder.test.tsx

@@ -1,4 +1,4 @@
-import { buildPattern, buildRegex } from '../compiler';
+import { buildPattern, buildRegex } from '..';
 import { one, oneOrMore, optionally, zeroOrMore } from '../quantifiers/base';
 import { repeat } from '../quantifiers/repeat';
 
@@ -56,3 +56,9 @@ test('buildRegex throws error on unknown element', () => {
     buildRegex({ type: 'unknown' })
   ).toThrowErrorMatchingInlineSnapshot(`"Unknown elements type unknown"`);
 });
+
+test('buildPattern throws on empty text', () => {
+  expect(() => buildPattern('')).toThrowErrorMatchingInlineSnapshot(
+    `"\`encodeText\`: received text should not be empty"`
+  );
+});

src/character-classes/__tests__/any-of.test.ts

@@ -1,23 +1,28 @@
-import { buildPattern as p } from '../../compiler';
+import { buildPattern } from '../..';
 import { oneOrMore } from '../../quantifiers/base';
 import { anyOf } from '../any-of';
 
 test('"anyOf" base cases', () => {
-  expect(p(anyOf(''))).toBe('');
-  expect(p(anyOf('a'))).toBe('a');
-  expect(p(anyOf('abc'))).toBe('[abc]');
+  expect(buildPattern(anyOf('a'))).toBe('a');
+  expect(buildPattern(anyOf('abc'))).toBe('[abc]');
 });
 
 test('"anyOf" in context', () => {
-  expect(p('x', anyOf('a'), 'x')).toBe('xax');
-  expect(p('x', anyOf('abc'), 'x')).toBe('x[abc]x');
-  expect(p('x', oneOrMore(anyOf('abc')), 'x')).toBe('x(?:[abc])+x');
+  expect(buildPattern('x', anyOf('a'), 'x')).toBe('xax');
+  expect(buildPattern('x', anyOf('abc'), 'x')).toBe('x[abc]x');
+  expect(buildPattern('x', oneOrMore(anyOf('abc')), 'x')).toBe('x[abc]+x');
 });
 
 test('"anyOf" escapes special characters', () => {
-  expect(p(anyOf('abc-+.'))).toBe('[-abc\\+\\.]');
+  expect(buildPattern(anyOf('abc-+.'))).toBe('[-abc\\+\\.]');
 });
 
 test('"anyOf" moves hyphen to the first position', () => {
-  expect(p(anyOf('a-bc'))).toBe('[-abc]');
+  expect(buildPattern(anyOf('a-bc'))).toBe('[-abc]');
+});
+
+test('`anyOf` throws on empty text', () => {
+  expect(() => anyOf('')).toThrowErrorMatchingInlineSnapshot(
+    `"\`anyOf\` should received at least one character"`
+  );
 });

src/character-classes/__tests__/base.test.ts

@@ -1,6 +1,6 @@
-import { any, digit, whitespace, word } from '../base';
-import { buildPattern } from '../../compiler';
+import { buildPattern } from '../..';
 import { one } from '../../quantifiers/base';
+import { any, digit, whitespace, word } from '../base';
 
 test('"whitespace" character class', () => {
   expect(buildPattern(whitespace)).toEqual(`\\s`);

src/character-classes/__tests__/encoder.test.ts

@@ -0,0 +1,12 @@
+import { encodeCharacterClass } from '../encoder';
+
+test('buildPattern throws on empty text', () => {
+  expect(() =>
+    encodeCharacterClass({
+      type: 'characterClass',
+      characters: [],
+    })
+  ).toThrowErrorMatchingInlineSnapshot(
+    `"Character class should contain at least one character"`
+  );
+});

src/character-classes/any-of.ts

@@ -2,8 +2,13 @@ import type { CharacterClass } from '../types';
 import { escapeText } from '../utils';
 
 export function anyOf(characters: string): CharacterClass {
+  const charactersArray = characters.split('').map(escapeText);
+  if (charactersArray.length === 0) {
+    throw new Error('`anyOf` should received at least one character');
+  }
+
   return {
     type: 'characterClass',
-    characters: characters.split('').map(escapeText),
+    characters: charactersArray,
   };
 }

src/character-classes/base.ts

@@ -1,5 +1,10 @@
 import type { CharacterClass } from '../types';
 
+export const any: CharacterClass = {
+  type: 'characterClass',
+  characters: ['.'],
+};
+
 export const whitespace: CharacterClass = {
   type: 'characterClass',
   characters: ['\\s'],
@@ -14,8 +19,3 @@ export const word: CharacterClass = {
   type: 'characterClass',
   characters: ['\\w'],
 };
-
-export const any: CharacterClass = {
-  type: 'characterClass',
-  characters: ['.'],
-};

src/character-classes/compiler.ts → src/character-classes/encoder.ts

@@ -1,21 +1,30 @@
 import type { CharacterClass } from '../types';
+import { EncoderPriority, type EncoderNode } from '../types-internal';
 
-export function compileCharacterClass({ characters }: CharacterClass): string {
+export function encodeCharacterClass({
+  characters,
+}: CharacterClass): EncoderNode {
   if (characters.length === 0) {
-    return '';
+    throw new Error('Character class should contain at least one character');
   }
 
   if (characters.length === 1) {
-    return characters[0]!;
+    return {
+      priority: EncoderPriority.Atom,
+      pattern: characters[0]!,
+    };
   }
 
-  return `[${escapeHyphen(characters).join('')}]`;
+  return {
+    priority: EncoderPriority.Atom,
+    pattern: `[${reorderHyphen(characters).join('')}]`,
+  };
 }
 
 // If passed characters includes hyphen (`-`) it need to be moved to
 // first (or last) place in order to treat it as hyphen character and not a range.
 // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes#types
-function escapeHyphen(characters: string[]) {
+function reorderHyphen(characters: string[]) {
   if (characters.includes('-')) {
     return ['-', ...characters.filter((c) => c !== '-')];
   }

src/components/__tests__/choiceOf.test.ts

@@ -1,23 +1,38 @@
-import { buildPattern } from '../../compiler';
+import { buildPattern } from '../..';
 import { oneOrMore, zeroOrMore } from '../../quantifiers/base';
 import { repeat } from '../../quantifiers/repeat';
 import { choiceOf } from '../choiceOf';
 
 test('"choiceOf" using basic strings', () => {
   expect(buildPattern(choiceOf('a'))).toEqual('a');
-  expect(buildPattern(choiceOf('a', 'b'))).toEqual('(?:a|b)');
-  expect(buildPattern(choiceOf('a', 'b', 'c'))).toEqual('(?:a|b|c)');
+  expect(buildPattern(choiceOf('a', 'b'))).toEqual('a|b');
+  expect(buildPattern(choiceOf('a', 'b', 'c'))).toEqual('a|b|c');
+  expect(buildPattern(choiceOf('aaa', 'bbb'))).toEqual('aaa|bbb');
+});
+
+test('"choiceOf" used in sequence', () => {
+  expect(buildPattern('x', choiceOf('a'), 'x')).toEqual('xax');
+  expect(buildPattern(choiceOf('a', 'b'), 'x')).toEqual('(?:a|b)x');
+  expect(buildPattern('x', choiceOf('a', 'b'))).toEqual('x(?:a|b)');
 
-  expect(buildPattern(choiceOf('aaa', 'bbb'))).toEqual('(?:aaa|bbb)');
+  expect(buildPattern(choiceOf('a', 'b', 'c'))).toEqual('a|b|c');
+  expect(buildPattern('x', choiceOf('a', 'b', 'c'))).toEqual('x(?:a|b|c)');
+  expect(buildPattern(choiceOf('a', 'b', 'c'), 'x')).toEqual('(?:a|b|c)x');
+
+  expect(buildPattern(choiceOf('aaa', 'bbb'))).toEqual('aaa|bbb');
 });
 
 test('"choiceOf" using nested regex', () => {
-  expect(buildPattern(choiceOf(oneOrMore('a'), zeroOrMore('b')))).toBe(
-    '(?:a+|b*)'
-  );
+  expect(buildPattern(choiceOf(oneOrMore('a'), zeroOrMore('b')))).toBe('a+|b*');
   expect(
     buildPattern(
       choiceOf(repeat({ min: 1, max: 3 }, 'a'), repeat({ count: 5 }, 'bx'))
     )
-  ).toBe('(?:a{1,3}|(?:bx){5})');
+  ).toBe('a{1,3}|(?:bx){5}');
+});
+
+test('`anyOf` throws on empty options', () => {
+  expect(() => choiceOf()).toThrowErrorMatchingInlineSnapshot(
+    `"\`choiceOf\` should receive at least one option"`
+  );
 });

src/components/choiceOf.ts

@@ -1,18 +1,32 @@
 import type { ChoiceOf, RegexElement } from '../types';
-import type { CompileSingle } from '../types-internal';
-import { wrapGroup } from '../utils';
+import {
+  EncoderPriority,
+  type EncodeElement,
+  type EncoderNode,
+} from '../types-internal';
 
 export function choiceOf(...children: RegexElement[]): ChoiceOf {
+  if (children.length === 0) {
+    throw new Error('`choiceOf` should receive at least one option');
+  }
+
   return {
     type: 'choiceOf',
     children,
   };
 }
 
-export function compileChoiceOf(
+export function encodeChoiceOf(
   element: ChoiceOf,
-  compileSingle: CompileSingle
-): string {
-  const compiledChildren = element.children.map(compileSingle);
-  return wrapGroup(compiledChildren.join('|'));
+  encodeElement: EncodeElement
+): EncoderNode {
+  const encodedNodes = element.children.map(encodeElement);
+  if (encodedNodes.length === 1) {
+    return encodedNodes[0]!;
+  }
+
+  return {
+    priority: EncoderPriority.Alternation,
+    pattern: encodedNodes.map((n) => n.pattern).join('|'),
+  };
 }

src/encoder.ts

@@ -0,0 +1,71 @@
+import type { RegexElement } from './types';
+import { EncoderPriority, type EncoderNode } from './types-internal';
+import { encodeChoiceOf } from './components/choiceOf';
+import { encodeCharacterClass } from './character-classes/encoder';
+import {
+  encodeOne,
+  encodeOneOrMore,
+  encodeOptionally,
+  encodeZeroOrMore,
+} from './quantifiers/base';
+import { encodeRepeat } from './quantifiers/repeat';
+import { concatNodes, escapeText } from './utils';
+
+export function encodeSequence(elements: RegexElement[]): EncoderNode {
+  return concatNodes(elements.map((c) => encodeElement(c)));
+}
+
+export function encodeElement(element: RegexElement): EncoderNode {
+  if (typeof element === 'string') {
+    return encodeText(element);
+  }
+
+  if (element.type === 'characterClass') {
+    return encodeCharacterClass(element);
+  }
+
+  if (element.type === 'choiceOf') {
+    return encodeChoiceOf(element, encodeElement);
+  }
+
+  if (element.type === 'repeat') {
+    return encodeRepeat(element.config, encodeSequence(element.children));
+  }
+
+  if (element.type === 'one') {
+    return encodeOne(encodeSequence(element.children));
+  }
+
+  if (element.type === 'oneOrMore') {
+    return encodeOneOrMore(encodeSequence(element.children));
+  }
+
+  if (element.type === 'optionally') {
+    return encodeOptionally(encodeSequence(element.children));
+  }
+
+  if (element.type === 'zeroOrMore') {
+    return encodeZeroOrMore(encodeSequence(element.children));
+  }
+
+  // @ts-expect-error User passed incorrect type
+  throw new Error(`Unknown elements type ${element.type}`);
+}
+
+function encodeText(text: string): EncoderNode {
+  if (text.length === 0) {
+    throw new Error('`encodeText`: received text should not be empty');
+  }
+
+  if (text.length === 1) {
+    return {
+      priority: EncoderPriority.Atom,
+      pattern: escapeText(text),
+    };
+  }
+
+  return {
+    priority: EncoderPriority.Sequence,
+    pattern: escapeText(text),
+  };
+}

src/index.ts

@@ -1,9 +1,30 @@
-export type * from './types';
+import type { RegexElement } from './types';
+import { encodeSequence } from './encoder';
 
-export { buildRegex, buildPattern } from './compiler';
+export type * from './types';
 
 export { any, digit, whitespace, word } from './character-classes/base';
 export { anyOf } from './character-classes/any-of';
 export { one, oneOrMore, optionally, zeroOrMore } from './quantifiers/base';
 export { repeat } from './quantifiers/repeat';
 export { choiceOf } from './components/choiceOf';
+
+/**
+ * Generate RegExp object for elements.
+ *
+ * @param elements
+ * @returns
+ */
+export function buildRegex(...elements: RegexElement[]): RegExp {
+  const pattern = encodeSequence(elements).pattern;
+  return new RegExp(pattern);
+}
+
+/**
+ * Generate regex pattern for elements.
+ * @param elements
+ * @returns
+ */
+export function buildPattern(...elements: RegexElement[]): string {
+  return encodeSequence(elements).pattern;
+}