feat: anyOf component

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

@@ -0,0 +1,23 @@
+import { buildPattern as p } from '../../compiler';
+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]');
+});
+
+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');
+});
+
+test('"anyOf" escapes special characters', () => {
+  expect(p(anyOf('abc-+.'))).toBe('[-abc\\+\\.]');
+});
+
+test('"anyOf" moves hyphen to the first position', () => {
+  expect(p(anyOf('a-bc'))).toBe('[-abc]');
+});

src/__tests__/characterClasses.test.tsx → src/character-classes/__tests__/base.test.ts

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

src/character-classes/any-of.ts

@@ -0,0 +1,9 @@
+import type { CharacterClass } from '../types';
+import { escapeText } from '../utils';
+
+export function anyOf(characters: string): CharacterClass {
+  return {
+    type: 'characterClass',
+    characters: characters.split('').map(escapeText),
+  };
+}

src/character-classes/base.ts

@@ -0,0 +1,21 @@
+import type { CharacterClass } from '../types';
+
+export const whitespace: CharacterClass = {
+  type: 'characterClass',
+  characters: ['\\s'],
+};
+
+export const digit: CharacterClass = {
+  type: 'characterClass',
+  characters: ['\\d'],
+};
+
+export const word: CharacterClass = {
+  type: 'characterClass',
+  characters: ['\\w'],
+};
+
+export const any: CharacterClass = {
+  type: 'characterClass',
+  characters: ['.'],
+};

src/character-classes/compiler.ts

@@ -0,0 +1,24 @@
+import type { CharacterClass } from '../types';
+
+export function compileCharacterClass({ characters }: CharacterClass): string {
+  if (characters.length === 0) {
+    return '';
+  }
+
+  if (characters.length === 1) {
+    return characters[0]!;
+  }
+
+  return `[${escapeHyphen(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[]) {
+  if (characters.includes('-')) {
+    return ['-', ...characters.filter((c) => c !== '-')];
+  }
+
+  return characters;
+}

src/compiler.ts

@@ -1,6 +1,6 @@
 import type { RegexElement } from './types';
-import { characterClasses, isCharacterClass } from './character-classes';
 import { compileChoiceOf } from './components/choiceOf';
+import { compileCharacterClass } from './character-classes/compiler';
 import { baseQuantifiers, isBaseQuantifier } from './quantifiers/base';
 import { compileRepeat } from './quantifiers/repeat';
 import { escapeText } from './utils';
@@ -36,8 +36,8 @@ function compileSingle(element: RegexElement): string {
     return escapeText(element);
   }
 
-  if (isCharacterClass(element)) {
-    return characterClasses[element.type];
+  if (element.type === 'characterClass') {
+    return compileCharacterClass(element);
   }
 
   if (element.type === 'choiceOf') {

src/index.ts

@@ -1,7 +1,9 @@
 export type * from './types';
 
-export { any, digit, whitespace, word } from './character-classes';
 export { buildRegex, buildPattern } from './compiler';
+
+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';

src/index.tsx

@@ -0,0 +1,5 @@
+export type * from './types';
+
+export { whitespace } from './character-classes/base';
+export { buildRegex, buildPattern } from './compiler';
+export { oneOrMore, optionally } from './quantifiers/base';

src/__tests__/quantifiers.test.tsx → src/quantifiers/__tests__/base.test.tsx

@@ -1,5 +1,5 @@
-import { one, oneOrMore, optionally, zeroOrMore } from '../quantifiers/base';
-import { buildPattern, buildRegex } from '../compiler';
+import { one, oneOrMore, optionally, zeroOrMore } from '../base';
+import { buildPattern, buildRegex } from '../../compiler';
 
 test('"oneOrMore" quantifier', () => {
   expect(buildPattern(oneOrMore('a'))).toEqual('a+');

src/__tests__/repeat.test.tsx → src/quantifiers/__tests__/repeat.test.tsx

@@ -1,6 +1,6 @@
-import { buildPattern } from '../compiler';
-import { zeroOrMore, oneOrMore } from '../quantifiers/base';
-import { repeat } from '../quantifiers/repeat';
+import { buildPattern } from '../../compiler';
+import { zeroOrMore, oneOrMore } from '../base';
+import { repeat } from '../repeat';
 
 test('"repeat" quantifier', () => {
   expect(buildPattern('a', repeat({ min: 1, max: 5 }, 'b'))).toEqual('ab{1,5}');

src/quantifiers/base.ts

@@ -8,23 +8,23 @@ import type {
 } from '../types';
 import { wrapGroup } from '../utils';
 
-export function oneOrMore(...children: RegexElement[]): OneOrMore {
+export function one(...children: RegexElement[]): One {
   return {
-    type: 'oneOrMore',
+    type: 'one',
     children,
   };
 }
 
-export function optionally(...children: RegexElement[]): Optionally {
+export function oneOrMore(...children: RegexElement[]): OneOrMore {
   return {
-    type: 'optionally',
+    type: 'oneOrMore',
     children,
   };
 }
 
-export function one(...children: RegexElement[]): One {
+export function optionally(...children: RegexElement[]): Optionally {
   return {
-    type: 'one',
+    type: 'optionally',
     children,
   };
 }

src/types.ts

@@ -1,14 +1,11 @@
 export type RegexElement = string | ChoiceOf | CharacterClass | Quantifier;
 
-export type CharacterClass = Whitespace | Digit | Word | Any;
-
 export type Quantifier = One | OneOrMore | Optionally | ZeroOrMore | Repeat;
 
-// Character classes
-export type Whitespace = { type: 'whitespace' };
-export type Digit = { type: 'digit' };
-export type Word = { type: 'word' };
-export type Any = { type: 'any' };
+export type CharacterClass = {
+  type: 'characterClass';
+  characters: string[];
+};
 
 // Components
 export type ChoiceOf = {