refactor: split code into multiple files (#2)

Author: mdjastrzebski

Diff for: README.md

@@ -11,11 +11,10 @@ npm install ts-regex
 ## Usage
 
 ```js
-import { multiply } from 'ts-regex';
+import { buildRegex, oneOrMore } from 'ts-regex';
 
-// ...
-
-const result = await multiply(3, 7);
+// /(Hello)+ World/
+const regex = buildRegex(oneOrMore('Hello '), 'World');
 ```
 
 ## Contributing

Diff for: src/__tests__/compiler.test.tsx

@@ -0,0 +1,20 @@
+import { buildPattern, buildRegex, oneOrMore, optionally } from '..';
+
+test('basic quantifies', () => {
+  expect(buildPattern('a')).toEqual('a');
+  expect(buildPattern('a', 'b')).toEqual('ab');
+
+  expect(buildPattern(oneOrMore('a'))).toEqual('a+');
+  expect(buildPattern(optionally('a'))).toEqual('a?');
+
+  expect(buildPattern('a', oneOrMore('b'))).toEqual('ab+');
+  expect(buildPattern('a', oneOrMore('bc'))).toEqual('a(bc)+');
+  expect(buildPattern('a', oneOrMore('bc'))).toEqual('a(bc)+');
+
+  expect(buildPattern(optionally('a'), 'b')).toEqual('a?b');
+});
+
+test('regex constructor', () => {
+  expect(buildRegex('a').test('a')).toBeTruthy();
+  expect(buildRegex('a').test('b')).toBeFalsy();
+});

Diff for: src/__tests__/index.test.tsx

@@ -0,0 +1,12 @@
+import { oneOrMore, optionally } from '../quantifiers';
+import { buildPattern } from '../compiler';
+
+test('"oneOrMore" quantifier', () => {
+  expect(buildPattern(oneOrMore('a'))).toEqual('a+');
+  expect(buildPattern(oneOrMore('ab'))).toEqual('(ab)+');
+});
+
+test('"optionally" quantifier', () => {
+  expect(buildPattern(optionally('a'))).toEqual('a?');
+  expect(buildPattern(optionally('ab'))).toEqual('(ab)?');
+});

Diff for: src/__tests__/quantifier.test.tsx

@@ -0,0 +1,42 @@
+import type { RegexComponent } from './types';
+import { compilers as quantifiers } from './quantifiers';
+
+/**
+ * Generate RegExp object from components.
+ *
+ * @param components
+ * @returns
+ */
+export function buildRegex(...components: RegexComponent[]): RegExp {
+  const pattern = compileList(components);
+  return new RegExp(pattern);
+}
+
+/**
+ * Generate regex pattern from components.
+ * @param components
+ * @returns
+ */
+export function buildPattern(...components: RegexComponent[]): string {
+  return compileList(components);
+}
+
+// Recursive compilation
+
+function compileList(components: RegexComponent[]): string {
+  return components.map((c) => compileSingle(c)).join('');
+}
+
+function compileSingle(component: RegexComponent): string {
+  if (typeof component === 'string') {
+    return component;
+  }
+
+  const componentCompiler = quantifiers[component.type];
+  if (!componentCompiler) {
+    throw new Error(`Unknown component type ${component.type}`);
+  }
+
+  const children = compileList(component.children);
+  return componentCompiler(children);
+}

Diff for: src/compiler.ts

@@ -1,3 +1,4 @@
-export function multiply(a: number, b: number): Promise<number> {
-  return Promise.resolve(a * b);
-}
+export type * from './types';
+
+export { buildRegex, buildPattern } from './compiler';
+export { oneOrMore, optionally } from './quantifiers';

Diff for: src/index.tsx

@@ -0,0 +1,22 @@
+import type { OneOrMore, Optionally, RegexComponent } from './types';
+import type { CompilerMap } from './types-internal';
+import { wrapGroup } from './utils';
+
+export function oneOrMore(...children: RegexComponent[]): OneOrMore {
+  return {
+    type: 'oneOrMore',
+    children,
+  };
+}
+
+export function optionally(...children: RegexComponent[]): Optionally {
+  return {
+    type: 'optionally',
+    children,
+  };
+}
+
+export const compilers = {
+  oneOrMore: (compiledChildren) => `${wrapGroup(compiledChildren)}+`,
+  optionally: (compiledChildren: string) => `${wrapGroup(compiledChildren)}?`,
+} satisfies CompilerMap;

Diff for: src/quantifiers.ts

@@ -0,0 +1,3 @@
+// Compilation
+export type ComponentCompiler = (compiledChildren: string) => string;
+export type CompilerMap = Record<string, ComponentCompiler>;

Diff for: src/types-internal.ts

@@ -0,0 +1,14 @@
+export type RegexComponent = string | RegexQuantifier;
+
+export type RegexQuantifier = OneOrMore | Optionally;
+
+// Quantifiers
+export type OneOrMore = {
+  type: 'oneOrMore';
+  children: RegexComponent[];
+};
+
+export type Optionally = {
+  type: 'optionally';
+  children: RegexComponent[];
+};

Diff for: src/types.ts

@@ -0,0 +1,3 @@
+export function wrapGroup(input: string): string {
+  return input.length === 1 ? input : `(${input})`;
+}