feat : findOne method added / incomplete

Author: kakasoo

Diff for: README.md

@@ -38,16 +38,16 @@ const regExp = new RegExpBuilder().from('initialValue').getOne(); // RegExp, sam
 If you want to create a more complex pattern, you can also write the `sub-expression` below.  
 All methods to be implemented in the future will be made all sub-expression possible.
 
-## getOne
+## getOne method
 
 Returns regexp instances based on methods written so far.
 
-## getRawOne
+## getRawOne method
 
 Returns string based on methods written so far.  
 You can use this as the first parameter of the regular expression constructor.
 
-## include & andInclude
+## include & andInclude method
 
 ```typescript
 /**
@@ -83,11 +83,11 @@ The options means where the string of this inclusion relationship should be loca
 
 The include method should only be used once per builder. If you want to use a second inclusion, sconsider and include.
 
-## isOptinonal (to be created)
+## isOptinonal method (incomplete)
 
-## whatever (to be created)
+## whatever method (incomplete)
 
-## and
+## and method
 
 ```typescript
 const leftHand = new RegExpBuilder('Hand').and('left', { isForehead: true }).getRawOne();
@@ -192,6 +192,23 @@ it('1. string "cat" but lessThanEqual 3', () => {
 });
 ```
 
+# findOne method (incomplete)
+
+```typescript
+it('from method set initial value & include other', () => {
+    const test = new RegExpBuilder().findOne({
+        from: 'test',
+        include: { partial: 'left', options: {} },
+    });
+
+    expect(test).toBe('(test)(?=(left))');
+});
+```
+
+The test variable is deduced from type to `'(test)(?=(left))'`, without having to check whether it is `'(test)(?=(left))'`.  
+Therefore, the findOne method is useful when you immediately deduce and write a value, even if it may be less free than other RegExpBuilder methods.  
+now from and include method options available.
+
 # order by execution
 
 1. from ( or constructor )

Diff for: package.json

@@ -1,6 +1,6 @@
 {
     "name": "regexp-manager",
-    "version": "0.8.2",
+    "version": "0.9.0",
     "description": "regexp builder for node.js developer",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",

Diff for: src/regexp-builder.ts

@@ -26,11 +26,62 @@ export class RegExpBuilder {
         moreThanEqual,
     }: {
         from: T;
-        include?: IncludeOptions; // TODO : approve array of include's options
+        include?: null;
+        lessThanEqual?: number;
+        moreThanEqual?: number;
+    }): T;
+    findOne<T extends string, P extends string>({
+        from,
+        include,
+        lessThanEqual,
+        moreThanEqual,
+    }: {
+        from: T;
+        include: { partial: P; options?: IncludeOptions<true> };
+        lessThanEqual?: number;
+        moreThanEqual?: number;
+    }): `(${T})(?=(${P}))`;
+    findOne<T extends string, P extends string>({
+        from,
+        include,
+        lessThanEqual,
+        moreThanEqual,
+    }: {
+        from: T;
+        include: { partial: P; options?: IncludeOptions<false> };
+        lessThanEqual?: number;
+        moreThanEqual?: number;
+    }): `(?<=(${P}))(${T})`;
+    findOne<T extends string, P extends string>({
+        from,
+        include,
+        lessThanEqual,
+        moreThanEqual,
+    }: {
+        from: T;
+        include: { partial: P; options?: IncludeOptions<boolean> };
+        lessThanEqual?: number;
+        moreThanEqual?: number;
+    }): `(?<=(${P}))(${T})` | `(${T})(?=(${P}))`;
+    findOne<T extends string, P extends string>({
+        from,
+        include,
+        lessThanEqual,
+        moreThanEqual,
+    }: {
+        from: T;
+        include?: { partial: P; options?: IncludeOptions<boolean> };
         lessThanEqual?: number;
         moreThanEqual?: number;
     }) {
         let expression = from;
+        if (include) {
+            if (include.options.isForehead) {
+                return this.excuteIncludeStatement(expression, include.partial, { isForehead: true });
+            } else {
+                return this.excuteIncludeStatement(expression, include.partial, { isForehead: false });
+            }
+        }
 
         return expression;
     }
@@ -187,31 +238,37 @@ export class RegExpBuilder {
             includeStatement.value = `${value}${includeStatement.value}`;
             return this;
         }
-        return this.include(value, options);
+
+        if (options.isForehead) {
+            return this.include(value, { isForehead: true });
+        }
+        return this.include(value, { isForehead: false });
     }
 
     /**
      * @param partial A function returns RegExpBuilder instance to prevent making human error
      * @param options
      */
-    include(partial: (subBuilder: RegExpBuilder) => RegExpBuilder, options?: IncludeOptions): this;
-
+    include(partial: (subBuilder: RegExpBuilder) => RegExpBuilder, options?: IncludeOptions<true>): this;
+    include(partial: (subBuilder: RegExpBuilder) => RegExpBuilder, options?: IncludeOptions<false>): this;
     /**
      * @param partial sub-regular expression builder that returns a string
      * @param options isForehead's default is true. If it's false, first parameter(partial) will set after present expression
      */
-    include(partial: (subBuilder: RegExpBuilder) => string, options?: IncludeOptions): this;
+    include(partial: (subBuilder: RegExpBuilder) => string, options?: IncludeOptions<true>): this;
+    include(partial: (subBuilder: RegExpBuilder) => string, options?: IncludeOptions<false>): this;
 
     /**
      * Specifies the string that must be included before and after the current expression.
      * @param partial  string (=pattern) or sub-expression / string to be included but not captured.
      * @param options isForehead's default is true. If it's false, first parameter(partial) will set after present expression
      * @returns
      */
-    include(partial: string, options?: IncludeOptions): this;
+    include(partial: string, options?: IncludeOptions<true>): this;
+    include(partial: string, options?: IncludeOptions<false>): this;
     include<T extends string>(
         partial: string | SubExpressionBilder<T>,
-        options: IncludeOptions = { isForehead: true },
+        options: IncludeOptions<boolean> = { isForehead: true },
     ) {
         const beforeStatus = this.getRawOne();
         const value: string = slove(partial);
@@ -416,7 +473,11 @@ export class RegExpBuilder {
                         );
                     }
 
-                    return this.excuteIncludeStatement(acc, value, options);
+                    if (options.isForehead) {
+                        return this.excuteIncludeStatement(acc, value, { isForehead: true });
+                    } else {
+                        return this.excuteIncludeStatement(acc, value, { isForehead: false });
+                    }
                 } else if (name === 'lessThanEqual') {
                     return this.executeMoreOrLessThanEqual(acc);
                 } else if (name === 'moreThanEqual') {
@@ -443,8 +504,18 @@ export class RegExpBuilder {
     private excuteIncludeStatement<T extends string, P extends string>(
         lastExpression: T,
         value: P,
-        options: IncludeOptions,
-    ) {
+        options: IncludeOptions<true>,
+    ): `(?<=(${P}))(${T})`;
+    private excuteIncludeStatement<T extends string, P extends string>(
+        lastExpression: T,
+        value: P,
+        options: IncludeOptions<false>,
+    ): `(${T})(?=(${P}))`;
+    private excuteIncludeStatement<T extends string, P extends string>(
+        lastExpression: T,
+        value: P,
+        options: IncludeOptions<boolean>,
+    ): `(?<=(${P}))(${T})` | `(${T})(?=(${P}))` {
         if (options.isForehead) {
             return this.lookbehind(value, lastExpression);
         } else {

Diff for: src/test/regexp-repository.spec.ts

@@ -10,4 +10,15 @@ describe('Check regexp-builder is type-safe', () => {
             expect(test).toBe('test');
         });
     });
+
+    describe('from & include infer response type', () => {
+        it('from method set initial value & include other', () => {
+            const test = new RegExpBuilder().findOne({
+                from: 'test',
+                include: { partial: 'left', options: {} },
+            });
+
+            expect(test).toBe('(test)(?=(left))');
+        });
+    });
 });

Diff for: types/index.d.ts

@@ -1,6 +1,9 @@
 import { RegExpBuilder } from '../src/regexp-builder';
 
-type IncludeOptions = { isForehead?: boolean };
+// type IncludeOptionIsBehind = { isForehead?: true };
+// type IncludeOptionIsForehead = { isForehead?: true };
+
+type IncludeOptions<T extends boolean> = { isForehead?: T };
 type AndOptions = { isForehead?: boolean };
 type SubExpressionBilder<T extends string> = (subBuilder: RegExpBuilder) => T | string | RegExpBuilder;
 type Push<T extends any[], val> = [...T, val];
@@ -21,7 +24,7 @@ type Status<T extends RegExpMethodNames> = {
         : T extends 'lessThanEqual'
         ? number
         : string;
-    options: T extends 'include' ? IncludeOptions : T extends 'and' ? AndOptions : null;
+    options: T extends 'include' ? IncludeOptions<boolean> : T extends 'and' ? AndOptions : null;
     beforeStatus: string;
     order: number;
 };