feat: choiceOf component

.gitignore

@@ -32,4 +32,4 @@ buck-out/
 lib/
 
 /.idea
-coverage/
+coverage/

package.json

@@ -118,7 +118,8 @@
   },
   "eslintIgnore": [
     "node_modules/",
-    "lib/"
+    "lib/",
+    "coverage/"
   ],
   "prettier": {
     "quoteProps": "consistent",

src/compiler.ts

@@ -1,5 +1,6 @@
 import type { RegexElement } from './types';
 import { characterClasses, isCharacterClass } from './character-classes';
+import { compileChoiceOf } from './components/choiceOf';
 import { baseQuantifiers, isBaseQuantifier } from './quantifiers/base';
 import { compileRepeat } from './quantifiers/repeat';
 import { escapeText } from './utils';
@@ -39,6 +40,10 @@ function compileSingle(element: RegexElement): string {
     return characterClasses[element.type];
   }
 
+  if (element.type === 'choiceOf') {
+    return compileChoiceOf(element, compileSingle);
+  }
+
   if (element.type === 'repeat') {
     const compiledChildren = compileList(element.children);
     return compileRepeat(element.config, compiledChildren);

src/components/__tests__/choiceOf.test.ts

@@ -0,0 +1,23 @@
+import { buildPattern } from '../../compiler';
+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('aaa', 'bbb'))).toEqual('(?:aaa|bbb)');
+});
+
+test('"choiceOf" using nested regex', () => {
+  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})');
+});

src/components/choiceOf.ts

@@ -0,0 +1,18 @@
+import type { ChoiceOf, RegexElement } from '../types';
+import type { CompileSingle } from '../types-internal';
+import { wrapGroup } from '../utils';
+
+export function choiceOf(...children: RegexElement[]): ChoiceOf {
+  return {
+    type: 'choiceOf',
+    children,
+  };
+}
+
+export function compileChoiceOf(
+  element: ChoiceOf,
+  compileSingle: CompileSingle
+): string {
+  const compiledChildren = element.children.map(compileSingle);
+  return wrapGroup(compiledChildren.join('|'));
+}

src/index.ts

@@ -0,0 +1,7 @@
+export type * from './types';
+
+export { any, digit, whitespace, word } from './character-classes';
+export { buildRegex, buildPattern } from './compiler';
+export { one, oneOrMore, optionally, zeroOrMore } from './quantifiers/base';
+export { repeat } from './quantifiers/repeat';
+export { choiceOf } from './components/choiceOf';

src/types-internal.ts

@@ -0,0 +1,3 @@
+import type { RegexElement } from './types';
+
+export type CompileSingle = (element: RegexElement) => string;

src/types.ts

@@ -1,4 +1,4 @@
-export type RegexElement = string | CharacterClass | Quantifier;
+export type RegexElement = string | ChoiceOf | CharacterClass | Quantifier;
 
 export type CharacterClass = Whitespace | Digit | Word | Any;
 
@@ -10,6 +10,12 @@ export type Digit = { type: 'digit' };
 export type Word = { type: 'word' };
 export type Any = { type: 'any' };
 
+// Components
+export type ChoiceOf = {
+  type: 'choiceOf';
+  children: RegexElement[];
+};
+
 // Quantifiers
 export type One = {
   type: 'one';