refactor: reorganize files

package.json

@@ -49,6 +49,7 @@
     "del-cli": "^5.0.0",
     "eslint": "^8.4.1",
     "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^4.0.0",
     "jest": "^28.1.1",
     "prettier": "^2.0.5",
@@ -103,6 +104,9 @@
       "@react-native",
       "prettier"
     ],
+    "plugins": [
+      "import"
+    ],
     "rules": {
       "prettier/prettier": [
         "error",
@@ -113,7 +117,15 @@
           "trailingComma": "es5",
           "useTabs": false
         }
-      ]
+      ],
+      "sort-imports": [
+        "error",
+        {
+          "ignoreCase": true,
+          "ignoreDeclarationSort": true
+        }
+      ],
+      "import/order": "error"
     }
   },
   "eslintIgnore": [

src/builders.ts

@@ -0,0 +1,24 @@
+import type { RegexElement } from './components/types';
+import { encodeSequence } from './encoder/encoder';
+
+/**
+ * Generate RegExp object for elements.
+ *
+ * @param elements
+ * @returns
+ */
+export function buildRegex(...elements: Array<RegexElement | string>): RegExp {
+  const pattern = encodeSequence(elements).pattern;
+  return new RegExp(pattern);
+}
+
+/**
+ * Generate regex pattern for elements.
+ * @param elements
+ * @returns
+ */
+export function buildPattern(
+  ...elements: Array<RegexElement | string>
+): string {
+  return encodeSequence(elements).pattern;
+}

src/__tests__/capture.test.tsx → src/components/__tests__/capture.test.tsx

@@ -1,7 +1,7 @@
-import { buildPattern } from '..';
+import { buildPattern } from '../../builders';
 import { capture } from '../capture';
-import { oneOrMore } from '../quantifiers/base';
-import { execRegex } from '../test-utils';
+import { oneOrMore } from '../quantifiers';
+import { execRegex } from '../../test-utils';
 
 test('"capture" base cases', () => {
   expect(buildPattern(capture('a'))).toBe('(a)');

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

@@ -0,0 +1,78 @@
+import { buildPattern } from '../../builders';
+import { one, oneOrMore } from '../quantifiers';
+import {
+  any,
+  anyOf,
+  digit,
+  encodeCharacterClass,
+  whitespace,
+  word,
+} from '../character-class';
+
+test('"whitespace" character class', () => {
+  expect(buildPattern(whitespace)).toEqual(`\\s`);
+
+  expect(buildPattern(one('ab'), whitespace)).toEqual(`ab\\s`);
+
+  expect(buildPattern(one('ab'), whitespace, one('c'))).toEqual(`ab\\sc`);
+});
+
+test('"digit" character class', () => {
+  expect(buildPattern(digit)).toEqual(`\\d`);
+
+  expect(buildPattern(one('ab'), digit)).toEqual(`ab\\d`);
+
+  expect(buildPattern(one('ab'), digit, one('c'))).toEqual(`ab\\dc`);
+});
+
+test('"word" character class', () => {
+  expect(buildPattern(word)).toEqual(`\\w`);
+
+  expect(buildPattern(one('ab'), word)).toEqual(`ab\\w`);
+
+  expect(buildPattern(one('ab'), word, one('c'))).toEqual(`ab\\wc`);
+});
+
+test('"any" character class', () => {
+  expect(buildPattern(any)).toEqual(`.`);
+
+  expect(buildPattern(one('ab'), any)).toEqual(`ab.`);
+
+  expect(buildPattern(one('ab'), any, one('c'))).toEqual(`ab.c`);
+});
+
+test('"anyOf" base cases', () => {
+  expect(buildPattern(anyOf('a'))).toBe('a');
+  expect(buildPattern(anyOf('abc'))).toBe('[abc]');
+});
+
+test('"anyOf" in context', () => {
+  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(buildPattern(anyOf('abc-+.'))).toBe('[-abc\\+\\.]');
+});
+
+test('"anyOf" moves hyphen to the first position', () => {
+  expect(buildPattern(anyOf('a-bc'))).toBe('[-abc]');
+});
+
+test('`anyOf` throws on empty text', () => {
+  expect(() => anyOf('')).toThrowErrorMatchingInlineSnapshot(
+    `"\`anyOf\` should received at least one character"`
+  );
+});
+
+test('buildPattern throws on empty text', () => {
+  expect(() =>
+    encodeCharacterClass({
+      type: 'characterClass',
+      characters: [],
+    })
+  ).toThrowErrorMatchingInlineSnapshot(
+    `"Character class should contain at least one character"`
+  );
+});

src/components/__tests__/choiceOf.test.ts → src/components/__tests__/choice-of.test.ts

@@ -1,7 +1,7 @@
-import { buildPattern } from '../..';
-import { oneOrMore, zeroOrMore } from '../../quantifiers/base';
-import { repeat } from '../../quantifiers/repeat';
-import { choiceOf } from '../choiceOf';
+import { buildPattern } from '../../builders';
+import { oneOrMore, zeroOrMore } from '../quantifiers';
+import { repeat } from '../repeat';
+import { choiceOf } from '../choice-of';
 
 test('"choiceOf" using basic strings', () => {
   expect(buildPattern(choiceOf('a'))).toEqual('a');

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

@@ -1,6 +1,6 @@
-import { buildPattern, buildRegex } from '../..';
-import { digit } from '../../character-classes/base';
-import { one, oneOrMore, optionally, zeroOrMore } from '../base';
+import { buildPattern, buildRegex } from '../../builders';
+import { digit } from '../character-class';
+import { one, oneOrMore, optionally, zeroOrMore } from '../quantifiers';
 
 test('"oneOrMore" quantifier', () => {
   expect(buildPattern(oneOrMore('a'))).toEqual('a+');

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

@@ -1,6 +1,6 @@
-import { buildPattern } from '../..';
-import { digit } from '../../character-classes/base';
-import { zeroOrMore, oneOrMore } from '../base';
+import { buildPattern } from '../../builders';
+import { digit } from '../character-class';
+import { oneOrMore, zeroOrMore } from '../quantifiers';
 import { repeat } from '../repeat';
 
 test('"repeat" quantifier', () => {

src/capture.ts → src/components/capture.ts

@@ -1,7 +1,7 @@
+import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
 import type { Capture, RegexElement } from './types';
-import { EncoderPriority, type EncoderNode } from './types-internal';
 
-export function capture(...children: RegexElement[]): Capture {
+export function capture(...children: Array<RegexElement | string>): Capture {
   return {
     type: 'capture',
     children,
@@ -10,7 +10,7 @@ export function capture(...children: RegexElement[]): Capture {
 
 export function encodeCapture(node: EncoderNode): EncoderNode {
   return {
+    precedence: EncoderPrecedence.Atom,
     pattern: `(${node.pattern})`,
-    priority: EncoderPriority.Atom,
   };
 }