struct-fakerator 3.0.1 → 3.1.0

package/README.md

@@ -267,10 +267,8 @@ flowchart TB
 但並不是所有人情況都能自己手動建立函數，有可能是開放給別人使用的服務，沒辦法在使用方建立函數，這時 `createGeneratorByType` 第二個可以讓製作服務的人帶入自己的擴充，這樣這個函數就能接受更多種型態。
 
 ```typescript
-const createIntValueConfig = (option) =>
-    createValueConfig(() => faker.number.int(option));
-const createEmailValueConfig = (option) =>
-    createValueConfig(() => faker.internet.email(option));
+const createIntValueConfig = (option) => createValueConfig(() => faker.number.int(option));
+const createEmailValueConfig = (option) => createValueConfig(() => faker.internet.email(option));
 
 const customTypeMatch = (config) => {
     if (config.type === "int") {

package/dist/config_scheme.cjs

@@ -31,51 +31,35 @@ __webpack_require__.d(__webpack_exports__, {
     boundedSeriesScheme: ()=>boundedSeriesScheme,
     objConfigScheme: ()=>objConfigScheme
 });
-const external_zod_namespaceObject = require("zod");
-const valueConfigScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^value$/, {
-        message: "invalid type string"
-    }),
-    generateFn: external_zod_namespaceObject.z.any()
+const external_valibot_namespaceObject = require("valibot");
+const valueConfigScheme = external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^value$/, "invalid type string")),
+    generateFn: external_valibot_namespaceObject.any()
 });
-const selectionConfigScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^select$/, {
-        message: "invalid type string"
-    }),
-    items: external_zod_namespaceObject.z.any().array().nonempty({
-        message: "items can not be empty"
-    })
+const selectionConfigScheme = external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^select$/, "invalid type string")),
+    items: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.array(external_valibot_namespaceObject.any()), external_valibot_namespaceObject.nonEmpty("items can not be empty"))
 });
-const arrayConfigScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^arr$/, {
-        message: "invalid type string"
-    }),
-    item: external_zod_namespaceObject.z.object({}),
-    len: external_zod_namespaceObject.z.number().nonnegative()
+const arrayConfigScheme = external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^arr$/, "invalid type string")),
+    item: external_valibot_namespaceObject.object({}),
+    len: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.number(), external_valibot_namespaceObject.integer(), external_valibot_namespaceObject.minValue(0))
 });
-const tupleConfigScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^tuple$/, {
-        message: "invalid type string"
-    }),
-    configItems: external_zod_namespaceObject.z.any().array()
+const tupleConfigScheme = external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^tuple$/, "invalid type string")),
+    configItems: external_valibot_namespaceObject.array(external_valibot_namespaceObject.any())
 });
-const objConfigScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^obj$/, {
-        message: "invalid type string"
-    }),
-    content: external_zod_namespaceObject.z.object({})
-});
-const boundedSeriesScheme = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.string().regex(/^bounded_series$/, {
-        message: "invalid type string"
-    }),
-    upperLimit: external_zod_namespaceObject.z.number().nonnegative(),
-    lowerLimit: external_zod_namespaceObject.z.number().nonnegative(),
-    createInitValue: external_zod_namespaceObject.z.any(),
-    count: external_zod_namespaceObject.z.number().nonnegative()
-}).refine(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, {
-    message: "lowerLimit can not greater then upperLimit"
+const objConfigScheme = external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^obj$/, "invalid type string")),
+    content: external_valibot_namespaceObject.object({})
 });
+const boundedSeriesScheme = external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.object({
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^bounded_series$/, "invalid type string")),
+    upperLimit: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.number(), external_valibot_namespaceObject.minValue(0)),
+    lowerLimit: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.number(), external_valibot_namespaceObject.minValue(0)),
+    createInitValue: external_valibot_namespaceObject.any(),
+    count: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.number(), external_valibot_namespaceObject.integer(), external_valibot_namespaceObject.minValue(0))
+}), external_valibot_namespaceObject.check(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, "lowerLimit can not greater then upperLimit"));
 exports.arrayConfigScheme = __webpack_exports__.arrayConfigScheme;
 exports.boundedSeriesScheme = __webpack_exports__.boundedSeriesScheme;
 exports.objConfigScheme = __webpack_exports__.objConfigScheme;

package/dist/config_scheme.js

@@ -1,46 +1,30 @@
-import { z } from "zod";
-const valueConfigScheme = z.object({
-    type: z.string().regex(/^value$/, {
-        message: "invalid type string"
-    }),
-    generateFn: z.any()
+import { any, array, check, integer, minValue, nonEmpty, number, object, pipe, regex, string } from "valibot";
+const valueConfigScheme = object({
+    type: pipe(string(), regex(/^value$/, "invalid type string")),
+    generateFn: any()
 });
-const selectionConfigScheme = z.object({
-    type: z.string().regex(/^select$/, {
-        message: "invalid type string"
-    }),
-    items: z.any().array().nonempty({
-        message: "items can not be empty"
-    })
+const selectionConfigScheme = object({
+    type: pipe(string(), regex(/^select$/, "invalid type string")),
+    items: pipe(array(any()), nonEmpty("items can not be empty"))
 });
-const arrayConfigScheme = z.object({
-    type: z.string().regex(/^arr$/, {
-        message: "invalid type string"
-    }),
-    item: z.object({}),
-    len: z.number().nonnegative()
+const arrayConfigScheme = object({
+    type: pipe(string(), regex(/^arr$/, "invalid type string")),
+    item: object({}),
+    len: pipe(number(), integer(), minValue(0))
 });
-const tupleConfigScheme = z.object({
-    type: z.string().regex(/^tuple$/, {
-        message: "invalid type string"
-    }),
-    configItems: z.any().array()
+const tupleConfigScheme = object({
+    type: pipe(string(), regex(/^tuple$/, "invalid type string")),
+    configItems: array(any())
 });
-const objConfigScheme = z.object({
-    type: z.string().regex(/^obj$/, {
-        message: "invalid type string"
-    }),
-    content: z.object({})
-});
-const boundedSeriesScheme = z.object({
-    type: z.string().regex(/^bounded_series$/, {
-        message: "invalid type string"
-    }),
-    upperLimit: z.number().nonnegative(),
-    lowerLimit: z.number().nonnegative(),
-    createInitValue: z.any(),
-    count: z.number().nonnegative()
-}).refine(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, {
-    message: "lowerLimit can not greater then upperLimit"
+const objConfigScheme = object({
+    type: pipe(string(), regex(/^obj$/, "invalid type string")),
+    content: object({})
 });
+const boundedSeriesScheme = pipe(object({
+    type: pipe(string(), regex(/^bounded_series$/, "invalid type string")),
+    upperLimit: pipe(number(), minValue(0)),
+    lowerLimit: pipe(number(), minValue(0)),
+    createInitValue: any(),
+    count: pipe(number(), integer(), minValue(0))
+}), check(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, "lowerLimit can not greater then upperLimit"));
 export { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme };

package/dist/create_config.cjs

@@ -31,13 +31,14 @@ __webpack_require__.d(__webpack_exports__, {
     createBoundedSeriesConfig: ()=>createBoundedSeriesConfig,
     createTupleConfig: ()=>createTupleConfig
 });
+const external_valibot_namespaceObject = require("valibot");
 const external_config_scheme_cjs_namespaceObject = require("./config_scheme.cjs");
 const createValueConfig = (generateFn)=>{
     const config = {
         type: "value",
         generateFn
     };
-    external_config_scheme_cjs_namespaceObject.valueConfigScheme.parse(config);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.valueConfigScheme, config);
     return config;
 };
 const createSelectionConfig = (items)=>{
@@ -45,7 +46,7 @@ const createSelectionConfig = (items)=>{
         type: "select",
         items
     };
-    external_config_scheme_cjs_namespaceObject.selectionConfigScheme.parse(config);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.selectionConfigScheme, config);
     return config;
 };
 function createObjectConfig(content, transformer) {
@@ -55,14 +56,14 @@ function createObjectConfig(content, transformer) {
             content,
             transformer
         };
-        external_config_scheme_cjs_namespaceObject.objConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.objConfigScheme, config);
         return config;
     }
     const config = {
         type: "obj",
         content
     };
-    external_config_scheme_cjs_namespaceObject.objConfigScheme.parse(config);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.objConfigScheme, config);
     return config;
 }
 const createArrayConfig = (item, len, next)=>{
@@ -72,7 +73,7 @@ const createArrayConfig = (item, len, next)=>{
         len,
         next
     };
-    external_config_scheme_cjs_namespaceObject.arrayConfigScheme.parse(config);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.arrayConfigScheme, config);
     return config;
 };
 const createTupleConfig = (configItems)=>{
@@ -80,7 +81,7 @@ const createTupleConfig = (configItems)=>{
         type: "tuple",
         configItems
     };
-    external_config_scheme_cjs_namespaceObject.tupleConfigScheme.parse(config);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.tupleConfigScheme, config);
     return config;
 };
 const createBoundedSeriesConfig = (config)=>{
@@ -88,7 +89,7 @@ const createBoundedSeriesConfig = (config)=>{
         type: "bounded_series",
         ...config
     };
-    external_config_scheme_cjs_namespaceObject.boundedSeriesScheme.parse(newConfig);
+    external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.boundedSeriesScheme, newConfig);
     return newConfig;
 };
 exports.createArrayConfig = __webpack_exports__.createArrayConfig;

package/dist/create_config.js

@@ -1,10 +1,11 @@
+import { assert } from "valibot";
 import { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme } from "./config_scheme.js";
 const createValueConfig = (generateFn)=>{
     const config = {
         type: "value",
         generateFn
     };
-    valueConfigScheme.parse(config);
+    assert(valueConfigScheme, config);
     return config;
 };
 const createSelectionConfig = (items)=>{
@@ -12,7 +13,7 @@ const createSelectionConfig = (items)=>{
         type: "select",
         items
     };
-    selectionConfigScheme.parse(config);
+    assert(selectionConfigScheme, config);
     return config;
 };
 function createObjectConfig(content, transformer) {
@@ -22,14 +23,14 @@ function createObjectConfig(content, transformer) {
             content,
             transformer
         };
-        objConfigScheme.parse(config);
+        assert(objConfigScheme, config);
         return config;
     }
     const config = {
         type: "obj",
         content
     };
-    objConfigScheme.parse(config);
+    assert(objConfigScheme, config);
     return config;
 }
 const createArrayConfig = (item, len, next)=>{
@@ -39,7 +40,7 @@ const createArrayConfig = (item, len, next)=>{
         len,
         next
     };
-    arrayConfigScheme.parse(config);
+    assert(arrayConfigScheme, config);
     return config;
 };
 const createTupleConfig = (configItems)=>{
@@ -47,7 +48,7 @@ const createTupleConfig = (configItems)=>{
         type: "tuple",
         configItems
     };
-    tupleConfigScheme.parse(config);
+    assert(tupleConfigScheme, config);
     return config;
 };
 const createBoundedSeriesConfig = (config)=>{
@@ -55,7 +56,7 @@ const createBoundedSeriesConfig = (config)=>{
         type: "bounded_series",
         ...config
     };
-    boundedSeriesScheme.parse(newConfig);
+    assert(boundedSeriesScheme, newConfig);
     return newConfig;
 };
 export { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig };

package/dist/create_generator_fn.cjs

@@ -33,10 +33,11 @@ __webpack_require__.d(__webpack_exports__, {
     createTupleGenerator: ()=>createTupleGenerator
 });
 const faker_namespaceObject = require("@faker-js/faker");
+const external_valibot_namespaceObject = require("valibot");
 const external_config_scheme_cjs_namespaceObject = require("./config_scheme.cjs");
 const _createValueGenerator = (config, path)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.valueConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.valueConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.value\n${err}`);
     }
@@ -45,7 +46,7 @@ const _createValueGenerator = (config, path)=>{
 const createValueGenerator = (config)=>_createValueGenerator(config, "*");
 const _createSelectionGenerator = (config, path)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.selectionConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.selectionConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.select\n${err}`);
     }
@@ -55,7 +56,7 @@ const _createSelectionGenerator = (config, path)=>{
 const createSelectionGenerator = (config)=>_createSelectionGenerator(config, "*");
 const _createObjectGenerator = (config, path, customTypeMatch)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.objConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.objConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.obj\n ${err}`);
     }
@@ -73,7 +74,7 @@ const _createObjectGenerator = (config, path, customTypeMatch)=>{
 const createObjectGenerator = (config, customTypeMatch)=>_createObjectGenerator(config, "*", customTypeMatch);
 const _createArrayGenerator = (config, path, customTypeMatch)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.arrayConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.arrayConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.arr\n ${err}`);
     }
@@ -83,7 +84,7 @@ const _createArrayGenerator = (config, path, customTypeMatch)=>{
         return ()=>{
             let prev = itemGeneratorFn();
             const result = [];
-            for(let i = 0; i < config.len; i++){
+            for(let i = 0; i < config.len; i += 1){
                 const nextValue = next(prev, itemGeneratorFn());
                 result.push(nextValue);
                 prev = nextValue;
@@ -98,7 +99,7 @@ const _createArrayGenerator = (config, path, customTypeMatch)=>{
 const createArrayGenerator = (config, customTypeMatch)=>_createArrayGenerator(config, "*", customTypeMatch);
 const _createTupleGenerator = (config, path, customTypeMatch)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.tupleConfigScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.tupleConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.tuple\n ${err}`);
     }
@@ -108,7 +109,7 @@ const _createTupleGenerator = (config, path, customTypeMatch)=>{
 const createTupleGenerator = (config, customTypeMatch)=>_createTupleGenerator(config, "*", customTypeMatch);
 const _createBoundedSeriesGenerator = (config, path)=>{
     try {
-        external_config_scheme_cjs_namespaceObject.boundedSeriesScheme.parse(config);
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.boundedSeriesScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
     }
@@ -116,7 +117,7 @@ const _createBoundedSeriesGenerator = (config, path)=>{
     return ()=>{
         let value = createInitValue();
         const boundedSeries = [];
-        for(let i = 0; i < count; i++){
+        for(let i = 0; i < count; i += 1){
             value = faker_namespaceObject.faker.number.float({
                 max: upperLimit,
                 min: lowerLimit

package/dist/create_generator_fn.js

@@ -1,8 +1,9 @@
 import { faker } from "@faker-js/faker";
+import { assert } from "valibot";
 import { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme } from "./config_scheme.js";
 const _createValueGenerator = (config, path)=>{
     try {
-        valueConfigScheme.parse(config);
+        assert(valueConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.value\n${err}`);
     }
@@ -11,7 +12,7 @@ const _createValueGenerator = (config, path)=>{
 const createValueGenerator = (config)=>_createValueGenerator(config, "*");
 const _createSelectionGenerator = (config, path)=>{
     try {
-        selectionConfigScheme.parse(config);
+        assert(selectionConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.select\n${err}`);
     }
@@ -21,7 +22,7 @@ const _createSelectionGenerator = (config, path)=>{
 const createSelectionGenerator = (config)=>_createSelectionGenerator(config, "*");
 const _createObjectGenerator = (config, path, customTypeMatch)=>{
     try {
-        objConfigScheme.parse(config);
+        assert(objConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.obj\n ${err}`);
     }
@@ -39,7 +40,7 @@ const _createObjectGenerator = (config, path, customTypeMatch)=>{
 const createObjectGenerator = (config, customTypeMatch)=>_createObjectGenerator(config, "*", customTypeMatch);
 const _createArrayGenerator = (config, path, customTypeMatch)=>{
     try {
-        arrayConfigScheme.parse(config);
+        assert(arrayConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.arr\n ${err}`);
     }
@@ -49,7 +50,7 @@ const _createArrayGenerator = (config, path, customTypeMatch)=>{
         return ()=>{
             let prev = itemGeneratorFn();
             const result = [];
-            for(let i = 0; i < config.len; i++){
+            for(let i = 0; i < config.len; i += 1){
                 const nextValue = next(prev, itemGeneratorFn());
                 result.push(nextValue);
                 prev = nextValue;
@@ -64,7 +65,7 @@ const _createArrayGenerator = (config, path, customTypeMatch)=>{
 const createArrayGenerator = (config, customTypeMatch)=>_createArrayGenerator(config, "*", customTypeMatch);
 const _createTupleGenerator = (config, path, customTypeMatch)=>{
     try {
-        tupleConfigScheme.parse(config);
+        assert(tupleConfigScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.tuple\n ${err}`);
     }
@@ -74,7 +75,7 @@ const _createTupleGenerator = (config, path, customTypeMatch)=>{
 const createTupleGenerator = (config, customTypeMatch)=>_createTupleGenerator(config, "*", customTypeMatch);
 const _createBoundedSeriesGenerator = (config, path)=>{
     try {
-        boundedSeriesScheme.parse(config);
+        assert(boundedSeriesScheme, config);
     } catch (err) {
         throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
     }
@@ -82,7 +83,7 @@ const _createBoundedSeriesGenerator = (config, path)=>{
     return ()=>{
         let value = createInitValue();
         const boundedSeries = [];
-        for(let i = 0; i < count; i++){
+        for(let i = 0; i < count; i += 1){
             value = faker.number.float({
                 max: upperLimit,
                 min: lowerLimit

package/dist/types/config_scheme.d.ts

@@ -1,29 +1,35 @@
-import { z } from "zod";
-export declare const valueConfigScheme: z.ZodObject<{
-    type: z.ZodString;
-    generateFn: z.ZodAny;
-}, z.core.$strip>;
-export declare const selectionConfigScheme: z.ZodObject<{
-    type: z.ZodString;
-    items: z.ZodArray<z.ZodAny>;
-}, z.core.$strip>;
-export declare const arrayConfigScheme: z.ZodObject<{
-    type: z.ZodString;
-    item: z.ZodObject<{}, z.core.$strip>;
-    len: z.ZodNumber;
-}, z.core.$strip>;
-export declare const tupleConfigScheme: z.ZodObject<{
-    type: z.ZodString;
-    configItems: z.ZodArray<z.ZodAny>;
-}, z.core.$strip>;
-export declare const objConfigScheme: z.ZodObject<{
-    type: z.ZodString;
-    content: z.ZodObject<{}, z.core.$strip>;
-}, z.core.$strip>;
-export declare const boundedSeriesScheme: z.ZodObject<{
-    type: z.ZodString;
-    upperLimit: z.ZodNumber;
-    lowerLimit: z.ZodNumber;
-    createInitValue: z.ZodAny;
-    count: z.ZodNumber;
-}, z.core.$strip>;
+import * as v from "valibot";
+export declare const valueConfigScheme: v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly generateFn: v.AnySchema;
+}, undefined>;
+export declare const selectionConfigScheme: v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly items: v.SchemaWithPipe<readonly [v.ArraySchema<v.AnySchema, undefined>, v.NonEmptyAction<any[], "items can not be empty">]>;
+}, undefined>;
+export declare const arrayConfigScheme: v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly item: v.ObjectSchema<{}, undefined>;
+    readonly len: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const tupleConfigScheme: v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly configItems: v.ArraySchema<v.AnySchema, undefined>;
+}, undefined>;
+export declare const objConfigScheme: v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly content: v.ObjectSchema<{}, undefined>;
+}, undefined>;
+export declare const boundedSeriesScheme: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "invalid type string">]>;
+    readonly upperLimit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lowerLimit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly createInitValue: v.AnySchema;
+    readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>, v.CheckAction<{
+    type: string;
+    upperLimit: number;
+    lowerLimit: number;
+    createInitValue: any;
+    count: number;
+}, "lowerLimit can not greater then upperLimit">]>;

package/dist/types/create_generator_fn.d.ts

@@ -4,7 +4,7 @@ export declare const createValueGenerator: <R = unknown>(config: ValueConfig<unk
 export declare const createSelectionGenerator: <T extends SelectionConfig<unknown>>(config: T) => (() => Result<T>);
 export declare const createObjectGenerator: <T extends ObjectConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
 export declare const createArrayGenerator: <T extends ArrayConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
-export declare const createTupleGenerator: <T extends TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown> | TupleConfig<unknown, unknown> | TupleConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
+export declare const createTupleGenerator: <T extends TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown> | TupleConfig<unknown, unknown> | TupleConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
 export declare const createBoundedSeriesGenerator: <T extends BoundedSeriesConfig>(config: T) => (() => Result<T>);
-export declare const createGeneratorByType: <T extends AllConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
+export declare const createGeneratorByType: <T extends AllConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
 export {};

package/dist/types/type.d.ts

@@ -37,16 +37,7 @@ export type TupleConfig<A, B = undefined, C = undefined, D = undefined, E = unde
 };
 export type Result<T> = T extends ValueConfig<infer U> ? U : T extends SelectionConfig<infer S> ? S : T extends BoundedSeriesConfig ? number[] : T extends ArrayConfig<infer W> ? Array<Result<W>> : T extends ObjectConfigWithFn<infer _, infer R> ? R : T extends ObjectConfig<infer O> ? {
     [K in keyof O]: Result<O[K]>;
-} : T extends TupleConfig<infer A, infer B, infer C, infer D, infer E, infer F, infer G, infer H, infer I, infer J> ? J extends undefined ? I extends undefined ? H extends undefined ? G extends undefined ? F extends undefined ? E extends undefined ? D extends undefined ? C extends undefined ? B extends undefined ? [Result<A>] : [Result<A>, Result<B>] : [
-    Result<A>,
-    Result<B>,
-    Result<C>
-] : [
-    Result<A>,
-    Result<B>,
-    Result<C>,
-    Result<D>
-] : [
+} : T extends TupleConfig<infer A, infer B, infer C, infer D, infer E, infer F, infer G, infer H, infer I, infer J> ? J extends undefined ? I extends undefined ? H extends undefined ? G extends undefined ? F extends undefined ? E extends undefined ? D extends undefined ? C extends undefined ? B extends undefined ? [Result<A>] : [Result<A>, Result<B>] : [Result<A>, Result<B>, Result<C>] : [Result<A>, Result<B>, Result<C>, Result<D>] : [
     Result<A>,
     Result<B>,
     Result<C>,

package/dist/types/utils/airline.d.ts

@@ -1,5 +1,5 @@
 import { faker } from "@faker-js/faker";
-import type { ValueConfig } from "../type";
+import type { ValueConfig } from "..";
 /** Airline [aircraftType](https://fakerjs.dev/api/airline.html#aircraftType) */
 export declare const aircraftType: () => ValueConfig<"narrowbody" | "regional" | "widebody">;
 type Airline = ReturnType<typeof faker.airline.airline>;
@@ -18,14 +18,14 @@ export declare const flightNumber: (options?: {
         max: number;
     };
     addLeadingZeros?: boolean;
-}) => ValueConfig<string>;
+} | undefined) => ValueConfig<string>;
 /** Airline [recordLocator](https://fakerjs.dev/api/airline.html#recordLocator) */
 export declare const recordLocator: (options?: {
     allowNumerics?: boolean;
     allowVisuallySimilarCharacters?: boolean;
-}) => ValueConfig<string>;
+} | undefined) => ValueConfig<string>;
 /** Airline [seat](https://fakerjs.dev/api/airline.html#seat) */
 export declare const seat: (options?: {
     aircraftType?: import("@faker-js/faker").AircraftType;
-}) => ValueConfig<string>;
+} | undefined) => ValueConfig<string>;
 export {};

package/dist/types/utils/color.d.ts

@@ -1,12 +1,12 @@
 /** Color [cmyk](https://fakerjs.dev/api/color.html#cmyk) */
 export declare const cmyk: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [colorByCSSColorSpace](https://fakerjs.dev/api/color.html#colorByCSSColorSpace) */
 export declare const colorByCSSColorSpace: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
     space?: import("@faker-js/faker").CssSpaceType;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [cssSupportedFunction](https://fakerjs.dev/api/color.html#cssSupportedFunction) */
 export declare const cssSupportedFunction: () => import("..").ValueConfig<"rgb" | "rgba" | "hsl" | "hsla" | "hwb" | "cmyk" | "lab" | "lch" | "color">;
 /** Color [cssSupportedSpace](https://fakerjs.dev/api/color.html#cssSupportedSpace) */
@@ -15,27 +15,27 @@ export declare const cssSupportedSpace: () => import("..").ValueConfig<"sRGB" |
 export declare const hsl: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
     includeAlpha?: boolean;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [human](https://fakerjs.dev/api/color.html#human) */
 export declare const human: () => import("..").ValueConfig<string>;
 /** Color [hwb](https://fakerjs.dev/api/color.html#hwb) */
 export declare const hwb: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [lab](https://fakerjs.dev/api/color.html#lab) */
 export declare const lab: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [lch](https://fakerjs.dev/api/color.html#lch) */
 export declare const lch: (options?: {
     format?: import("@faker-js/faker").ColorFormat;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [rgb](https://fakerjs.dev/api/color.html#rgb) */
 export declare const rgb: (options?: {
     prefix?: string;
     casing?: import("@faker-js/faker").Casing;
     format?: "hex" | import("@faker-js/faker").ColorFormat;
     includeAlpha?: boolean;
-}) => import("..").ValueConfig<string | number[]>;
+} | undefined) => import("..").ValueConfig<string | number[]>;
 /** Color [space](https://fakerjs.dev/api/color.html#space) */
 export declare const space: () => import("..").ValueConfig<string>;

package/dist/types/utils/commerce.d.ts

@@ -4,14 +4,14 @@ export declare const department: () => import("..").ValueConfig<string>;
 export declare const isbn: (options?: 10 | 13 | {
     variant?: 10 | 13;
     separator?: string;
-}) => import("..").ValueConfig<string>;
+} | undefined) => import("..").ValueConfig<string>;
 /** Commerce [price](https://fakerjs.dev/api/commerce.html#price) */
 export declare const price: (options?: {
     min?: number;
     max?: number;
     dec?: number;
     symbol?: string;
-}) => import("..").ValueConfig<string>;
+} | undefined) => import("..").ValueConfig<string>;
 /** Commerce [product](https://fakerjs.dev/api/commerce.html#product) */
 export declare const product: () => import("..").ValueConfig<string>;
 /** Commerce [productAdjective](https://fakerjs.dev/api/commerce.html#productAdjective) */

package/dist/types/utils/common.d.ts

@@ -1,2 +1,3 @@
+import { ValueConfig } from "..";
 /** Common constant */
-export declare const constant: <T>(value: T) => import("..").ValueConfig<T>;
+export declare const constant: <T>(value: T) => ValueConfig<T>;