feat: 🎸 rewrite the path search in template

BREAKING CHANGE: 🧨 Y

✅ Closes: Y

Author: fefit

__tests__/types.test.ts

@@ -362,14 +362,14 @@ describe('test built-in types', () => {
       // in a template
       return Such.as({
         a: 1,
-        b: ':::`:string``:ref:&/${2}`',
+        b: ':::`:string``:ref:&//${2}`',
       });
     }).toThrow();
     expect(() => {
       // in a template
       const instance = Such.instance({
         a: 1,
-        b: ':::`:string``:ref:&/${2}``:number`',
+        b: ':::`:string``:ref:&//${2}``:number`',
       });
       for (let i = 0; i < 10; i++) {
         instance.a();
@@ -379,7 +379,7 @@ describe('test built-in types', () => {
       // in a template with named
       const instance = Such.instance({
         a: 1,
-        b: ':::`:string``:ref:&/${mystr}``:number`',
+        b: ':::`:string``:ref:&//${mystr}``:number`',
       });
       for (let i = 0; i < 10; i++) {
         instance.a();
@@ -415,15 +415,15 @@ describe('test built-in types', () => {
     const tmplRef = {
       a: 'hello',
       b: 'world',
-      c: ':::`:ref:&./a`:`:regexp:/abc/`;`:ref:&./b`:`:ref:&/${1}`;',
+      c: ':::`:ref:&./a`:`:regexp:/abc/`;`:ref:&./b`:`:ref:&//${1}`;',
     };
     const tmplRefData = Such.as(tmplRef) as typeof tmplRef;
     expect(tmplRefData.c === `${tmplRef.a}:abc;${tmplRef.b}:abc;`).toBeTruthy();
     // make a template ref with named
     const namedTmplRef = {
       a: 'hello',
       b: 'world',
-      c: ':::`<say>:ref:&./a`,`<say>:ref:&./b`!`<helloworld>:ref:&/${say}:@join(",")`!`:ref:&/${helloworld}`!',
+      c: ':::`<say>:ref:&./a`,`<say>:ref:&./b`!`<helloworld>:ref:&//${say}:@join(",")`!`:ref:&//${helloworld}`!',
     };
     const namedTmplRefData = Such.as(namedTmplRef) as typeof namedTmplRef;
     expect(
@@ -624,7 +624,7 @@ describe('test built-in types', () => {
     const refTmplData = Such.as<typeof refTmpl>(refTmpl);
     expect(refTmplData.tmpl === [refTmpl.a, refTmpl.b].join(" ")).toBeTruthy();
     // reference
-    expect(['truetrue', 'falsefalse'].includes(Such.template('`:bool``:ref:&/${0}`').a())).toBeTruthy();
+    expect(['truetrue', 'falsefalse'].includes(Such.template('`:bool``:ref:&//${0}`').a())).toBeTruthy();
     // wrong reference
     expect(() => {
       Such.as(':::`:ref:&./a,&./b`');

examples/index.ts

@@ -3,13 +3,24 @@ import Such, { createNsSuch } from '../src/index';
 import PathMap from '../src/helpers/pathmap';
 (async () => {
   await Such.loadData();
-  console.log(Such.as(':dict:&<dataDir>/dict.txt'));
-  const txt = await Such.asc('mock.txt');
-  console.log(txt);
-  const map = new PathMap(false);
-  map.set([0], 1);
-  map.set([1], 2);
-  console.log(map.get([]));
+  // console.log(Such.as(':dict:&<dataDir>/dict.txt'));
+  // const txt = await Such.asc('mock.txt');
+  // console.log(txt);
+  const instance = Such.instance({
+    a: ":::`:province`,`:cascader:&//${0}`,`<number>:number`,`:ref:&//${number}`",
+    b: ":ref:&./a/${0}"
+  });
+  for(let i = 0; i < 10; i++){
+    console.log(instance.a());
+  }
+  // console.log(Such.template('`:bool``:ref:&//${0}`').a());
+  // const tmplRef = {
+  //   a: 'hello',
+  //   b: 'world',
+  //   c: ':::`:ref:&./a`:`:regexp:/abc/`;`:ref:&./b`:`:ref:&//${1}`;',
+  // };
+  // const tmplRefData = Such.as(tmplRef);
+  // console.log(tmplRefData);
   // const globalConfig = {
   //   suffix: 'ok'
   // };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "suchjs",
-  "version": "2.2.3",
+  "version": "3.0.0",
   "description": "Generating fake data, define your own types easily, expandable and powerful.",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",

src/core/mockit.ts

@@ -225,6 +225,8 @@ type TPartStaticMockit = Partial<TStaticMockit>;
 export default abstract class Mockit<T = unknown> {
   // chain names
   public static chainNames: string[] = [];
+  // inherit base mockit type
+  public static baseType: typeof BaseExtendMockit;
   // constructor name, for cache
   public static readonly constrName: string;
   // namespace
@@ -308,28 +310,25 @@ export default abstract class Mockit<T = unknown> {
    *
    * @param {string} name
    * @param {TMModifierFn<T>} fn
-   * @param {string} [pos]
    * @returns
    * @memberof Mockit
    */
   public addModifier(
     name: string,
-    fn: TMModifierFn<T>,
-    pos?: string,
+    fn: TMModifierFn<T>
   ): void | never {
-    return this.add('modifier', name, fn, pos);
+    return this.add('modifier', name, fn);
   }
   /**
    *
    *
    * @param {string} name
    * @param {TMRuleFn} fn
-   * @param {string} [pos]
    * @returns
    * @memberof Mockit
    */
-  public addRule(name: string, fn: TMRuleFn, pos?: string): void | never {
-    return this.add('rule', name, fn, pos);
+  public addRule(name: string, fn: TMRuleFn): void | never {
+    return this.add('rule', name, fn);
   }
   /**
    *
@@ -457,8 +456,7 @@ export default abstract class Mockit<T = unknown> {
   private add(
     type: 'rule' | 'modifier',
     name: string,
-    fn: TMRuleFn | TMModifierFn<T>,
-    pos?: string,
+    fn: TMRuleFn | TMModifierFn<T>
   ): never | void {
     const { namespace, constrName } = this.getStaticProps();
     const curName = constrName;
@@ -489,26 +487,7 @@ export default abstract class Mockit<T = unknown> {
     if (isRuleType) {
       this.setAllowAttrs(name);
     }
-    // add by position
-    if (pos === undefined || pos.trim() === '') {
-      target.push(name);
-    } else {
-      let prepend = false;
-      if (pos.charAt(0) === '^') {
-        prepend = true;
-        pos = pos.slice(1);
-      }
-      if (pos === '') {
-        target.unshift(name);
-      } else {
-        const findIndex = target.indexOf(pos);
-        if (findIndex < 0) {
-          throw new Error(`no exists ${type} name of ${pos}`);
-        } else {
-          target.splice(findIndex + (prepend ? 0 : 1), 0, name);
-        }
-      }
-    }
+    target.push(name);
     fns[name] = fn;
   }
   /**
@@ -525,6 +504,7 @@ export default abstract class Mockit<T = unknown> {
       configOptions,
       selfConfigOptions,
       specialType,
+      baseType
     } = staticMockit;
     return {
       constrName,
@@ -534,6 +514,7 @@ export default abstract class Mockit<T = unknown> {
       configOptions,
       selfConfigOptions,
       specialType,
+      baseType
     };
   }
   /**
@@ -700,3 +681,19 @@ export default abstract class Mockit<T = unknown> {
     return this.runFuncs(result, options);
   }
 }
+
+/**
+ * BaseExtendMockit
+ * Just for types
+ */
+export class BaseExtendMockit extends Mockit {
+  init(): void {
+    // nothing to do
+  }
+  test(): boolean {
+    return false;
+  }
+  generate(): void {
+    // nothing to do
+  }
+}

src/core/parser.ts

@@ -1,6 +1,6 @@
 import { IParserConfig } from '../types/parser';
-import { encodeSplitor, splitor as confSplitor } from '../data/config';
-import { encodeRegexpChars, hasOwn, isArray } from '../helpers/utils';
+import { encodeSplitor, encodeRegexpChars, splitor as confSplitor } from '../data/config';
+import { hasOwn, isArray } from '../helpers/utils';
 import { TMatchResult, TObj, TStrList } from '../types/common';
 import Mockit from './mockit';
 export interface Tags {
@@ -341,8 +341,9 @@ export class Dispatcher {
         );
       } else {
         if (mockit) {
-          const { constrName, allowAttrs } = mockit.getStaticProps();
-          if (!allowAttrs.includes(type)) {
+          const { constrName, allowAttrs, baseType } = mockit.getStaticProps();
+          // when no base type, check the allow attrs
+          if (!baseType && !allowAttrs.includes(type)) {
             switch (type) {
               case '$config':
                 throw new Error(