refactor: cleanup and optimizing types

Author: mdjastrzebski

src/__tests__/characterClasses.test.tsx

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

src/__tests__/compiler.test.tsx

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

src/__tests__/quantifiers.test.tsx

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

src/__tests__/repeat.test.tsx

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

src/character-classes.ts

@@ -0,0 +1,26 @@
+import type {
+  Any,
+  CharacterClass,
+  Digit,
+  RegexElement,
+  Whitespace,
+  Word,
+} from './types';
+
+export const whitespace: Whitespace = { type: 'whitespace' };
+export const digit: Digit = { type: 'digit' };
+export const word: Word = { type: 'word' };
+export const any: Any = { type: 'any' };
+
+export const characterClasses = {
+  whitespace: '\\s',
+  digit: '\\d',
+  word: '\\w',
+  any: '.',
+} as const satisfies Record<string, string>;
+
+export function isCharacterClass(
+  element: Exclude<RegexElement, string>
+): element is CharacterClass {
+  return element.type in characterClasses;
+}

src/characterClasses.ts

@@ -1,7 +1,7 @@
 import type { RegexElement } from './types';
-import { compilers as quantifiers } from './quantifiers';
+import { characterClasses, isCharacterClass } from './character-classes';
+import { baseQuantifiers, isBaseQuantifier } from './quantifiers/base';
 import { compileRepeat } from './quantifiers/repeat';
-import { compilers as characterClasses } from './characterClasses';
 
 /**
  * Generate RegExp object for elements.
@@ -29,31 +29,26 @@ function compileList(elements: RegexElement[]): string {
   return elements.map((c) => compileSingle(c)).join('');
 }
 
-function compileSingle(elements: RegexElement): string {
-  if (typeof elements === 'string') {
-    return elements;
+function compileSingle(element: RegexElement): string {
+  if (typeof element === 'string') {
+    return element;
   }
 
-  if (!('children' in elements)) {
-    const characterCompiler = characterClasses[elements.type];
-
-    if (!characterCompiler) {
-      throw new Error(`Unknown character type ${elements.type}`);
-    }
-
-    return characterCompiler;
+  if (isCharacterClass(element)) {
+    return characterClasses[element.type];
   }
 
-  const compiledChildren = compileList(elements.children);
+  const compiledChildren = compileList(element.children);
 
-  if (elements.type === 'repeat') {
-    return compileRepeat(elements.config, compiledChildren);
+  if (element.type === 'repeat') {
+    return compileRepeat(element.config, compiledChildren);
   }
 
-  const elementCompiler = quantifiers[elements.type];
-  if (!elementCompiler) {
-    throw new Error(`Unknown elements type ${elements.type}`);
+  if (isBaseQuantifier(element)) {
+    const compiler = baseQuantifiers[element.type];
+    return compiler(compiledChildren);
   }
 
-  return elementCompiler(compiledChildren);
+  // @ts-expect-error User passed incorrect type
+  throw new Error(`Unknown elements type ${element.type}`);
 }

src/compiler.ts

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

src/index.tsx

@@ -2,12 +2,10 @@ import type {
   One,
   OneOrMore,
   Optionally,
+  Quantifier,
   RegexElement,
-  Repeat,
-  RepeatConfig,
   ZeroOrMore,
 } from '../types';
-import type { CompilerMap } from '../types-internal';
 import { wrapGroup } from '../utils';
 
 export function oneOrMore(...children: RegexElement[]): OneOrMore {
@@ -38,20 +36,15 @@ export function zeroOrMore(...children: RegexElement[]): ZeroOrMore {
   };
 }
 
-export function repeat(
-  config: RepeatConfig,
-  ...children: RegexElement[]
-): Repeat {
-  return {
-    type: 'repeat',
-    children,
-    config,
-  };
-}
-
-export const compilers = {
+export const baseQuantifiers = {
   one: (compiledChildren) => compiledChildren,
   oneOrMore: (compiledChildren) => `${wrapGroup(compiledChildren)}+`,
   optionally: (compiledChildren) => `${wrapGroup(compiledChildren)}?`,
   zeroOrMore: (compiledChildren) => `${wrapGroup(compiledChildren)}*`,
-} satisfies CompilerMap;
+} as const satisfies Record<string, (compiledChildren: string) => string>;
+
+export function isBaseQuantifier(
+  element: Exclude<RegexElement, string>
+): element is Quantifier {
+  return element.type in baseQuantifiers;
+}

src/quantifiers/index.ts renamed to src/quantifiers/base.ts

@@ -1,6 +1,17 @@
-import type { RepeatConfig } from '../types';
+import type { RegexElement, Repeat, RepeatConfig } from '../types';
 import { wrapGroup } from '../utils';
 
+export function repeat(
+  config: RepeatConfig,
+  ...children: RegexElement[]
+): Repeat {
+  return {
+    type: 'repeat',
+    children,
+    config,
+  };
+}
+
 export function compileRepeat(
   config: RepeatConfig,
   compiledChildren: string

src/quantifiers/repeat.ts

@@ -1,21 +1,13 @@
-export type RegexElement = string | RegexCharacterClass | RegexQuantifier;
+export type RegexElement = string | CharacterClass | Quantifier;
 
-export type RegexCharacterClass = Whitespace | Digit | Word | Any;
+export type CharacterClass = Whitespace | Digit | Word | Any;
 
-export type RegexQuantifier =
-  | One
-  | OneOrMore
-  | Optionally
-  | ZeroOrMore
-  | Repeat;
+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' };
 
 // Quantifiers