struct-fakerator 3.1.0 → 3.3.0

package/dist/config_scheme.cjs

@@ -33,28 +33,28 @@ __webpack_require__.d(__webpack_exports__, {
 });
 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")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("value", "invalid type string")),
     generateFn: external_valibot_namespaceObject.any()
 });
 const selectionConfigScheme = external_valibot_namespaceObject.object({
-    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^select$/, "invalid type string")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("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_valibot_namespaceObject.object({
-    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^arr$/, "invalid type string")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("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_valibot_namespaceObject.object({
-    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^tuple$/, "invalid type string")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("tuple", "invalid type string")),
     configItems: external_valibot_namespaceObject.array(external_valibot_namespaceObject.any())
 });
 const objConfigScheme = external_valibot_namespaceObject.object({
-    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.regex(/^obj$/, "invalid type string")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("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")),
+    type: external_valibot_namespaceObject.pipe(external_valibot_namespaceObject.string(), external_valibot_namespaceObject.value("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(),

package/dist/config_scheme.js

@@ -1,27 +1,27 @@
-import { any, array, check, integer, minValue, nonEmpty, number, object, pipe, regex, string } from "valibot";
+import { any, array, check, integer, minValue, nonEmpty, number, object, pipe, string, value } from "valibot";
 const valueConfigScheme = object({
-    type: pipe(string(), regex(/^value$/, "invalid type string")),
+    type: pipe(string(), value("value", "invalid type string")),
     generateFn: any()
 });
 const selectionConfigScheme = object({
-    type: pipe(string(), regex(/^select$/, "invalid type string")),
+    type: pipe(string(), value("select", "invalid type string")),
     items: pipe(array(any()), nonEmpty("items can not be empty"))
 });
 const arrayConfigScheme = object({
-    type: pipe(string(), regex(/^arr$/, "invalid type string")),
+    type: pipe(string(), value("arr", "invalid type string")),
     item: object({}),
     len: pipe(number(), integer(), minValue(0))
 });
 const tupleConfigScheme = object({
-    type: pipe(string(), regex(/^tuple$/, "invalid type string")),
+    type: pipe(string(), value("tuple", "invalid type string")),
     configItems: array(any())
 });
 const objConfigScheme = object({
-    type: pipe(string(), regex(/^obj$/, "invalid type string")),
+    type: pipe(string(), value("obj", "invalid type string")),
     content: object({})
 });
 const boundedSeriesScheme = pipe(object({
-    type: pipe(string(), regex(/^bounded_series$/, "invalid type string")),
+    type: pipe(string(), value("bounded_series", "invalid type string")),
     upperLimit: pipe(number(), minValue(0)),
     lowerLimit: pipe(number(), minValue(0)),
     createInitValue: any(),

package/dist/create_generator_fn_async.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createGeneratorByTypeAsync: ()=>createGeneratorByTypeAsync,
+    createSelectionGeneratorAsync: ()=>createSelectionGeneratorAsync,
+    createTupleGeneratorAsync: ()=>createTupleGeneratorAsync,
+    createValueGeneratorAsync: ()=>createValueGeneratorAsync,
+    createArrayGeneratorAsync: ()=>createArrayGeneratorAsync,
+    createBoundedSeriesGeneratorAsync: ()=>createBoundedSeriesGeneratorAsync,
+    createObjectGeneratorAsync: ()=>createObjectGeneratorAsync
+});
+const faker_namespaceObject = require("@faker-js/faker");
+const external_valibot_namespaceObject = require("valibot");
+const external_config_scheme_cjs_namespaceObject = require("./config_scheme.cjs");
+const _createValueGeneratorAsync = (config, path)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.valueConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.value\n${err}`);
+    }
+    return ()=>Promise.resolve().then(()=>config.generateFn());
+};
+const createValueGeneratorAsync = (config)=>_createValueGeneratorAsync(config, "*");
+const _createSelectionGeneratorAsync = (config, path)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.selectionConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.select\n${err}`);
+    }
+    const { items } = config;
+    return ()=>Promise.resolve(items[faker_namespaceObject.faker.number.int(items.length - 1)]);
+};
+const createSelectionGeneratorAsync = (config)=>_createSelectionGeneratorAsync(config, "*");
+const _createObjectGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.objConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.obj\n ${err}`);
+    }
+    const keyWithFns = Object.entries(config.content).map(([key, subConfig])=>[
+            key,
+            _createGeneratorByTypeAsync(subConfig, `${path}.obj[${key}]`, customTypeMatch)
+        ]);
+    return async ()=>{
+        const result = {};
+        const results = await Promise.all(keyWithFns.map(([key, generateFn])=>generateFn().then((v)=>[
+                    key,
+                    v
+                ])));
+        for (const [key, value] of results)result[key] = value;
+        if ("transformer" in config && "function" == typeof config.transformer) return config.transformer(result);
+        return result;
+    };
+};
+const createObjectGeneratorAsync = (config, customTypeMatch)=>_createObjectGeneratorAsync(config, "*", customTypeMatch);
+const _createArrayGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.arrayConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.arr\n ${err}`);
+    }
+    const itemGeneratorFn = _createGeneratorByTypeAsync(config.item, `${path}.arr`, customTypeMatch);
+    if (config.next) {
+        const next = config.next;
+        return async ()=>{
+            let prev = await itemGeneratorFn();
+            const result = [];
+            for(let i = 0; i < config.len; i += 1){
+                const nextValue = next(prev, await itemGeneratorFn());
+                result.push(nextValue);
+                prev = nextValue;
+            }
+            return result;
+        };
+    }
+    return ()=>Promise.all(Array.from({
+            length: config.len ?? 0
+        }, itemGeneratorFn));
+};
+const createArrayGeneratorAsync = (config, customTypeMatch)=>_createArrayGeneratorAsync(config, "*", customTypeMatch);
+const _createTupleGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.tupleConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.tuple\n ${err}`);
+    }
+    const itemsFns = config.configItems.map((configItem, index)=>_createGeneratorByTypeAsync(configItem, `${path}.tuple[${index}]`, customTypeMatch));
+    return ()=>Promise.all(itemsFns.map((generateFn)=>generateFn()));
+};
+const createTupleGeneratorAsync = (config, customTypeMatch)=>_createTupleGeneratorAsync(config, "*", customTypeMatch);
+const _createBoundedSeriesGeneratorAsync = (config, path)=>{
+    try {
+        external_valibot_namespaceObject.assert(external_config_scheme_cjs_namespaceObject.boundedSeriesScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
+    }
+    const { upperLimit, lowerLimit, createInitValue, count } = config;
+    return ()=>{
+        let value = createInitValue();
+        const boundedSeries = [];
+        for(let i = 0; i < count; i += 1){
+            value = faker_namespaceObject.faker.number.float({
+                max: upperLimit,
+                min: lowerLimit
+            }) * value;
+            boundedSeries.push(value);
+        }
+        return Promise.resolve(boundedSeries);
+    };
+};
+const createBoundedSeriesGeneratorAsync = (config)=>_createBoundedSeriesGeneratorAsync(config, "*");
+const _createGeneratorByTypeAsync = (config, path, customTypeMatch)=>{
+    switch(config.type){
+        case "obj":
+            return _createObjectGeneratorAsync(config, path, customTypeMatch);
+        case "arr":
+            return _createArrayGeneratorAsync(config, path, customTypeMatch);
+        case "tuple":
+            return _createTupleGeneratorAsync(config, path, customTypeMatch);
+        case "select":
+            return _createSelectionGeneratorAsync(config, path);
+        case "value":
+            return _createValueGeneratorAsync(config, path);
+        case "bounded_series":
+            return _createBoundedSeriesGeneratorAsync(config, path);
+        default:
+            if (customTypeMatch) return createValueGeneratorAsync(customTypeMatch(config, path));
+            throw new Error(`path: ${path}\nconfig type is not supported`);
+    }
+};
+const createGeneratorByTypeAsync = (config, customTypeMatch)=>_createGeneratorByTypeAsync(config, "*", customTypeMatch);
+exports.createArrayGeneratorAsync = __webpack_exports__.createArrayGeneratorAsync;
+exports.createBoundedSeriesGeneratorAsync = __webpack_exports__.createBoundedSeriesGeneratorAsync;
+exports.createGeneratorByTypeAsync = __webpack_exports__.createGeneratorByTypeAsync;
+exports.createObjectGeneratorAsync = __webpack_exports__.createObjectGeneratorAsync;
+exports.createSelectionGeneratorAsync = __webpack_exports__.createSelectionGeneratorAsync;
+exports.createTupleGeneratorAsync = __webpack_exports__.createTupleGeneratorAsync;
+exports.createValueGeneratorAsync = __webpack_exports__.createValueGeneratorAsync;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createArrayGeneratorAsync",
+    "createBoundedSeriesGeneratorAsync",
+    "createGeneratorByTypeAsync",
+    "createObjectGeneratorAsync",
+    "createSelectionGeneratorAsync",
+    "createTupleGeneratorAsync",
+    "createValueGeneratorAsync"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/create_generator_fn_async.js

@@ -0,0 +1,121 @@
+import { faker } from "@faker-js/faker";
+import { assert } from "valibot";
+import { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme } from "./config_scheme.js";
+const _createValueGeneratorAsync = (config, path)=>{
+    try {
+        assert(valueConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.value\n${err}`);
+    }
+    return ()=>Promise.resolve().then(()=>config.generateFn());
+};
+const createValueGeneratorAsync = (config)=>_createValueGeneratorAsync(config, "*");
+const _createSelectionGeneratorAsync = (config, path)=>{
+    try {
+        assert(selectionConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.select\n${err}`);
+    }
+    const { items } = config;
+    return ()=>Promise.resolve(items[faker.number.int(items.length - 1)]);
+};
+const createSelectionGeneratorAsync = (config)=>_createSelectionGeneratorAsync(config, "*");
+const _createObjectGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        assert(objConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.obj\n ${err}`);
+    }
+    const keyWithFns = Object.entries(config.content).map(([key, subConfig])=>[
+            key,
+            _createGeneratorByTypeAsync(subConfig, `${path}.obj[${key}]`, customTypeMatch)
+        ]);
+    return async ()=>{
+        const result = {};
+        const results = await Promise.all(keyWithFns.map(([key, generateFn])=>generateFn().then((v)=>[
+                    key,
+                    v
+                ])));
+        for (const [key, value] of results)result[key] = value;
+        if ("transformer" in config && "function" == typeof config.transformer) return config.transformer(result);
+        return result;
+    };
+};
+const createObjectGeneratorAsync = (config, customTypeMatch)=>_createObjectGeneratorAsync(config, "*", customTypeMatch);
+const _createArrayGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        assert(arrayConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.arr\n ${err}`);
+    }
+    const itemGeneratorFn = _createGeneratorByTypeAsync(config.item, `${path}.arr`, customTypeMatch);
+    if (config.next) {
+        const next = config.next;
+        return async ()=>{
+            let prev = await itemGeneratorFn();
+            const result = [];
+            for(let i = 0; i < config.len; i += 1){
+                const nextValue = next(prev, await itemGeneratorFn());
+                result.push(nextValue);
+                prev = nextValue;
+            }
+            return result;
+        };
+    }
+    return ()=>Promise.all(Array.from({
+            length: config.len ?? 0
+        }, itemGeneratorFn));
+};
+const createArrayGeneratorAsync = (config, customTypeMatch)=>_createArrayGeneratorAsync(config, "*", customTypeMatch);
+const _createTupleGeneratorAsync = (config, path, customTypeMatch)=>{
+    try {
+        assert(tupleConfigScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.tuple\n ${err}`);
+    }
+    const itemsFns = config.configItems.map((configItem, index)=>_createGeneratorByTypeAsync(configItem, `${path}.tuple[${index}]`, customTypeMatch));
+    return ()=>Promise.all(itemsFns.map((generateFn)=>generateFn()));
+};
+const createTupleGeneratorAsync = (config, customTypeMatch)=>_createTupleGeneratorAsync(config, "*", customTypeMatch);
+const _createBoundedSeriesGeneratorAsync = (config, path)=>{
+    try {
+        assert(boundedSeriesScheme, config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
+    }
+    const { upperLimit, lowerLimit, createInitValue, count } = config;
+    return ()=>{
+        let value = createInitValue();
+        const boundedSeries = [];
+        for(let i = 0; i < count; i += 1){
+            value = faker.number.float({
+                max: upperLimit,
+                min: lowerLimit
+            }) * value;
+            boundedSeries.push(value);
+        }
+        return Promise.resolve(boundedSeries);
+    };
+};
+const createBoundedSeriesGeneratorAsync = (config)=>_createBoundedSeriesGeneratorAsync(config, "*");
+const _createGeneratorByTypeAsync = (config, path, customTypeMatch)=>{
+    switch(config.type){
+        case "obj":
+            return _createObjectGeneratorAsync(config, path, customTypeMatch);
+        case "arr":
+            return _createArrayGeneratorAsync(config, path, customTypeMatch);
+        case "tuple":
+            return _createTupleGeneratorAsync(config, path, customTypeMatch);
+        case "select":
+            return _createSelectionGeneratorAsync(config, path);
+        case "value":
+            return _createValueGeneratorAsync(config, path);
+        case "bounded_series":
+            return _createBoundedSeriesGeneratorAsync(config, path);
+        default:
+            if (customTypeMatch) return createValueGeneratorAsync(customTypeMatch(config, path));
+            throw new Error(`path: ${path}\nconfig type is not supported`);
+    }
+};
+const createGeneratorByTypeAsync = (config, customTypeMatch)=>_createGeneratorByTypeAsync(config, "*", customTypeMatch);
+export { createArrayGeneratorAsync, createBoundedSeriesGeneratorAsync, createGeneratorByTypeAsync, createObjectGeneratorAsync, createSelectionGeneratorAsync, createTupleGeneratorAsync, createValueGeneratorAsync };

package/dist/index.cjs

@@ -9,6 +9,9 @@ var __webpack_modules__ = {
     "./create_generator_fn" (module) {
         module.exports = require("./create_generator_fn.cjs");
     },
+    "./create_generator_fn_async" (module) {
+        module.exports = require("./create_generator_fn_async.cjs");
+    },
     "./generator_fn" (module) {
         module.exports = require("./generator_fn.cjs");
     },
@@ -61,7 +64,7 @@ var __webpack_exports__ = {};
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
         StructConfig: ()=>_config__rspack_import_0,
-        StructGenerator: ()=>_generator_fn__rspack_import_3
+        StructGenerator: ()=>_generator_fn__rspack_import_4
     });
     var _config__rspack_import_0 = __webpack_require__("./config");
     var _create_config__rspack_import_1 = __webpack_require__("./create_config");
@@ -80,14 +83,22 @@ var __webpack_exports__ = {};
         "StructGenerator"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_create_generator_fn__rspack_import_2[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _generator_fn__rspack_import_3 = __webpack_require__("./generator_fn");
-    var _type__rspack_import_4 = __webpack_require__("./type");
+    var _create_generator_fn_async__rspack_import_3 = __webpack_require__("./create_generator_fn_async");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _create_generator_fn_async__rspack_import_3)if ([
+        "default",
+        "StructConfig",
+        "StructGenerator"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_create_generator_fn_async__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _generator_fn__rspack_import_4 = __webpack_require__("./generator_fn");
+    var _type__rspack_import_5 = __webpack_require__("./type");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _type__rspack_import_4)if ([
+    for(const __rspack_import_key in _type__rspack_import_5)if ([
         "default",
         "StructConfig",
         "StructGenerator"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_type__rspack_import_4[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_type__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 exports.StructConfig = __webpack_exports__.StructConfig;

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./create_config.js";
 export * from "./create_generator_fn.js";
+export * from "./create_generator_fn_async.js";
 export * from "./type.js";
 import * as __rspack_external__config_js_0f05d986 from "./config.js";
 import * as __rspack_external__generator_fn_js_1567d0d7 from "./generator_fn.js";

package/dist/types/{config_scheme.d.ts → src/config_scheme.d.ts}

@@ -1,27 +1,27 @@
 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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "value", "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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "select", "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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "arr", "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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "tuple", "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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "obj", "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 type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ValueAction<string, "bounded_series", "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;

package/dist/types/{create_config.d.ts → src/create_config.d.ts}

@@ -34,23 +34,10 @@ export declare const createArrayConfig: <T>(item: T, len: number, next?: (prev:
  * @param {Array} configItems
  * @return {TupleConfig}
  */
-interface CreateTupleConfig {
-    <A, B, C, D, E, F, G, H, I, J>(configItems: [A, B, C, D, E, F, G, H, I, J]): TupleConfig<A, B, C, D, E, F, G, H, I, J>;
-    <A, B, C, D, E, F, G, H, I>(configItems: [A, B, C, D, E, F, G, H, I]): TupleConfig<A, B, C, D, E, F, G, H, I>;
-    <A, B, C, D, E, F, G, H>(configItems: [A, B, C, D, E, F, G, H]): TupleConfig<A, B, C, D, E, F, G, H>;
-    <A, B, C, D, E, F, G>(configItems: [A, B, C, D, E, F, G]): TupleConfig<A, B, C, D, E, F, G>;
-    <A, B, C, D, E, F>(configItems: [A, B, C, D, E, F]): TupleConfig<A, B, C, D, E, F>;
-    <A, B, C, D, E>(configItems: [A, B, C, D, E]): TupleConfig<A, B, C, D, E>;
-    <A, B, C, D>(configItems: [A, B, C, D]): TupleConfig<A, B, C, D>;
-    <A, B, C>(configItems: [A, B, C]): TupleConfig<A, B, C>;
-    <A, B>(configItems: [A, B]): TupleConfig<A, B>;
-    <A>(configItems: [A]): TupleConfig<A>;
-}
-export declare const createTupleConfig: CreateTupleConfig;
+export declare const createTupleConfig: <const TItems extends readonly [unknown, ...unknown[]]>(configItems: TItems) => TupleConfig<TItems>;
 /**
  * bounded series
  * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
  * @return {BoundedSeriesConfig}
  */
 export declare const createBoundedSeriesConfig: (config: Omit<BoundedSeriesConfig, "type">) => BoundedSeriesConfig;
-export {};

package/dist/types/src/create_generator_fn.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayConfig, BoundedSeriesConfig, ObjectConfig, ObjectConfigWithFn, Result, SelectionConfig, TupleConfig, ValueConfig } from "./type";
+type AllConfig = ValueConfig<unknown> | SelectionConfig<unknown> | ArrayConfig<unknown> | ObjectConfig<unknown> | ObjectConfigWithFn<unknown, unknown> | TupleConfig<readonly unknown[]> | BoundedSeriesConfig;
+export declare const createValueGenerator: <R = unknown>(config: ValueConfig<unknown>) => (() => R);
+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<readonly 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>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
+export {};

package/dist/types/src/create_generator_fn_async.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayConfig, BoundedSeriesConfig, ObjectConfig, ObjectConfigWithFn, Result, SelectionConfig, TupleConfig, ValueConfig } from "./type";
+type AllConfig = ValueConfig<unknown> | SelectionConfig<unknown> | ArrayConfig<unknown> | ObjectConfig<unknown> | ObjectConfigWithFn<unknown, unknown> | TupleConfig<readonly unknown[]> | BoundedSeriesConfig;
+export declare const createValueGeneratorAsync: <R = unknown>(config: ValueConfig<unknown>) => (() => Promise<R>);
+export declare const createSelectionGeneratorAsync: <T extends SelectionConfig<unknown>>(config: T) => (() => Promise<Result<T>>);
+export declare const createObjectGeneratorAsync: <T extends ObjectConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Promise<Result<T>>);
+export declare const createArrayGeneratorAsync: <T extends ArrayConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Promise<Result<T>>);
+export declare const createTupleGeneratorAsync: <T extends TupleConfig<readonly unknown[]>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Promise<Result<T>>);
+export declare const createBoundedSeriesGeneratorAsync: <T extends BoundedSeriesConfig>(config: T) => (() => Promise<Result<T>>);
+export declare const createGeneratorByTypeAsync: <T extends AllConfig>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Promise<Result<T>>);
+export {};

package/dist/types/src/create_generator_fn_async.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/{index.d.ts → src/index.d.ts}

@@ -1,5 +1,6 @@
 export * as StructConfig from "./config";
 export * from "./create_config";
 export * from "./create_generator_fn";
+export * from "./create_generator_fn_async";
 export * as StructGenerator from "./generator_fn";
 export * from "./type";

package/dist/types/src/type.d.ts

@@ -0,0 +1,43 @@
+export type ValueConfig<T> = {
+    type: "value";
+    generateFn: () => T;
+};
+export type SelectionConfig<T> = {
+    type: "select";
+    items: T[];
+};
+export type BoundedSeriesConfig = {
+    type: "bounded_series";
+    upperLimit: number;
+    lowerLimit: number;
+    createInitValue: () => number;
+    count: number;
+};
+export type ArrayConfig<T> = {
+    type: "arr";
+    item: T;
+    len: number;
+    next?: (prev: Result<T>, current: Result<T>) => Result<T>;
+};
+export type ObjectConfig<T> = {
+    type: "obj";
+    content: T;
+};
+export type ObjectConfigWithFn<T, R> = {
+    type: "obj";
+    content: T;
+    transformer: (v: {
+        [K in keyof T]: Result<T[K]>;
+    }) => R;
+};
+export type TupleConfig<TItems extends readonly unknown[]> = {
+    type: "tuple";
+    configItems: TItems;
+};
+type ResolveTuple<TItems extends readonly unknown[]> = {
+    [K in keyof TItems]: Result<TItems[K]>;
+};
+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 TItems> ? ResolveTuple<TItems> : never;
+export {};

package/dist/types/{utils → src/utils}/airline.d.ts

@@ -1,5 +1,5 @@
 import { faker } from "@faker-js/faker";
-import type { ValueConfig } from "..";
+import type { ValueConfig } from "../type";
 /** Airline [aircraftType](https://fakerjs.dev/api/airline.html#aircraftType) */
 export declare const aircraftType: () => ValueConfig<"narrowbody" | "regional" | "widebody">;
 type Airline = ReturnType<typeof faker.airline.airline>;

package/dist/types/{utils → src/utils}/commerce.d.ts

@@ -22,3 +22,7 @@ export declare const productDescription: () => import("..").ValueConfig<string>;
 export declare const productMaterial: () => import("..").ValueConfig<string>;
 /** Commerce [productName](https://fakerjs.dev/api/commerce.html#productName) */
 export declare const productName: () => import("..").ValueConfig<string>;
+/** Commerce [upc](https://fakerjs.dev/api/commerce.html#upc) */
+export declare const upc: (options?: {
+    prefix?: string;
+} | undefined) => import("..").ValueConfig<string>;

package/dist/types/{utils → src/utils}/common.d.ts

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

package/dist/types/{utils → src/utils}/image.d.ts

@@ -9,6 +9,11 @@ export declare const dataUri: (options?: {
     color?: string;
     type?: "svg-uri" | "svg-base64";
 } | undefined) => import("..").ValueConfig<string>;
+/** Image [personPortrait](https://fakerjs.dev/api/image.html#personPortrait) */
+export declare const personPortrait: (options?: {
+    sex?: import("@faker-js/faker").SexType;
+    size?: 512 | 256 | 128 | 64 | 32;
+} | undefined) => import("..").ValueConfig<string>;
 /** Image [url](https://fakerjs.dev/api/image.html#url) */
 export declare const url: (options?: {
     width?: number;

package/dist/types/{utils → src/utils}/index.d.ts

@@ -23,6 +23,7 @@ export * as Phone from "./phone";
 export * as Science from "./science";
 export * as String from "./string";
 export * as System from "./system";
+export * as Word from "./word";
+export * as Vehicle from "./vehicle";
 export * as utils from "./utils";
 export { makeValueConfigFn } from "./utils";
-export * as Vehicle from "./vehicle";

package/dist/types/{utils → src/utils}/location.d.ts

@@ -1,5 +1,5 @@
 import { faker } from "@faker-js/faker";
-import type { ValueConfig } from "..";
+import type { ValueConfig } from "../type";
 /** Location [buildingNumber](https://fakerjs.dev/api/location.html#buildingNumber) */
 export declare const buildingNumber: () => ValueConfig<string>;
 /** Location [cardinalDirection](https://fakerjs.dev/api/location.html#cardinalDirection) */

package/dist/types/{utils → src/utils}/string.d.ts

@@ -47,6 +47,17 @@ export declare const nanoid: (length?: number | {
     min: number;
     max: number;
 } | undefined) => import("..").ValueConfig<string>;
+/** String [numeric](https://fakerjs.dev/api/string.html#numeric) */
+export declare const numeric: (options?: number | {
+    length?: number | {
+        min: number;
+        max: number;
+    };
+    allowLeadingZeros?: boolean;
+    exclude?: ReadonlyArray<(string & {
+        zz_IGNORE_ME?: never;
+    }) | ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9")> | string;
+} | undefined) => import("..").ValueConfig<string>;
 /** String [octal](https://fakerjs.dev/api/string.html#octal) */
 export declare const octal: (options?: {
     length?: number | {

package/dist/types/{utils → src/utils}/utils.d.ts

@@ -1,2 +1,2 @@
-import type { ValueConfig } from "..";
+import type { ValueConfig } from "../type";
 export declare function makeValueConfigFn<Args extends Array<unknown>, R>(fn: (...options: Args) => R): (...options: Args) => ValueConfig<R>;