feat: characterClass

Author: mdjastrzebski

src/components/__tests__/character-class.test.ts

@@ -3,6 +3,7 @@ import { one, oneOrMore } from '../quantifiers';
 import {
   any,
   anyOf,
+  characterClass,
   digit,
   encodeCharacterClass,
   whitespace,
@@ -33,6 +34,15 @@ test('"word" character class', () => {
   expect(buildPattern(one('ab'), word, one('c'))).toEqual(`ab\\wc`);
 });
 
+test('"characterClass" base cases', () => {
+  expect(buildPattern(characterClass(['a', 'z']))).toBe('[a-z]');
+  expect(buildPattern(characterClass(['a', 'z'], ['A', 'Z']))).toBe('[a-zA-Z]');
+  expect(buildPattern(characterClass(['a', 'z'], '0', '5'))).toBe('[a-z05]');
+
+  expect(buildPattern('x', characterClass(['a', 'z']))).toBe('x[a-z]');
+  expect(buildPattern(characterClass(['a', 'z']), 'x')).toBe('[a-z]x');
+});
+
 test('"any" character class', () => {
   expect(buildPattern(any)).toEqual(`.`);
 
@@ -73,6 +83,6 @@ test('buildPattern throws on empty text', () => {
       characters: [],
     })
   ).toThrowErrorMatchingInlineSnapshot(
-    `"Character class should contain at least one character"`
+    `"Character class should contain at least one range or character"`
   );
 });

src/components/character-class.ts

@@ -1,6 +1,6 @@
 import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
 import { escapeText } from '../utils';
-import type { CharacterClass } from './types';
+import type { CharacterClass, CharacterRange } from './types';
 
 export const any: CharacterClass = {
   type: 'characterClass',
@@ -22,6 +22,24 @@ export const word: CharacterClass = {
   characters: ['\\w'],
 };
 
+export function characterClass(
+  ...charactersOrRanges: Array<string | CharacterRange>
+): CharacterClass {
+  const characters = charactersOrRanges.filter(
+    (c) => !Array.isArray(c)
+  ) as string[];
+
+  const ranges = charactersOrRanges.filter((c) =>
+    Array.isArray(c)
+  ) as CharacterRange[];
+
+  return {
+    type: 'characterClass',
+    characters: characters.map((c) => escapeText(c)),
+    ranges: ranges.map((r) => [escapeText(r[0]), escapeText(r[1])]),
+  };
+}
+
 export function anyOf(characters: string): CharacterClass {
   const charactersArray = characters.split('').map(escapeText);
   if (charactersArray.length === 0) {
@@ -36,12 +54,15 @@ export function anyOf(characters: string): CharacterClass {
 
 export function encodeCharacterClass({
   characters,
+  ranges = [],
 }: CharacterClass): EncoderNode {
-  if (characters.length === 0) {
-    throw new Error('Character class should contain at least one character');
+  if (characters.length === 0 && ranges.length === 0) {
+    throw new Error(
+      'Character class should contain at least one range or character'
+    );
   }
 
-  if (characters.length === 1) {
+  if (characters.length === 1 && ranges.length === 0) {
     return {
       precedence: EncoderPrecedence.Atom,
       pattern: characters[0]!,
@@ -50,17 +71,22 @@ export function encodeCharacterClass({
 
   return {
     precedence: EncoderPrecedence.Atom,
-    pattern: `[${reorderHyphen(characters).join('')}]`,
+    pattern: `[${formatClass(characters, ranges)}]`,
   };
 }
 
 // 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 reorderHyphen(characters: string[]) {
+function formatClass(characters: string[], ranges: CharacterRange[] = []) {
+  const formattedCharacters = characters.filter((c) => c !== '-').join('');
+  const formattedRanges = ranges
+    .map(([start, end]) => `${start}-${end}`)
+    .join('');
+
   if (characters.includes('-')) {
-    return ['-', ...characters.filter((c) => c !== '-')];
+    return `-${formattedRanges}${formattedCharacters}`;
   }
 
-  return characters;
+  return `${formattedRanges}${formattedCharacters}`;
 }

src/components/types.ts

@@ -5,8 +5,14 @@ export type Quantifier = One | OneOrMore | Optionally | ZeroOrMore | Repeat;
 export type CharacterClass = {
   type: 'characterClass';
   characters: string[];
+  ranges?: CharacterRange[];
 };
 
+/**
+ * Character range from start to end (inclusive).
+ */
+export type CharacterRange = [start: string, end: string];
+
 // Components
 export type ChoiceOf = {
   type: 'choiceOf';