struct-fakerator 3.0.0 → 3.1.0

package/README.md

@@ -1,126 +1,131 @@
 # 假資料結構產生器
 
 - [假資料結構產生器](#假資料結構產生器)
-  - [Wrapping fakerjs Functions](#wrapping-fakerjs-functions)
-  - [用途](#用途)
-    - [Value](#value)
-    - [Selection](#selection)
-    - [Object](#object)
-    - [Array](#array)
-    - [Tuple](#tuple)
-    - [BoundedSeries](#boundedseries)
-  - [擴充](#擴充)
+    - [Wrapping fakerjs Functions](#wrapping-fakerjs-functions)
+    - [用途](#用途)
+        - [Value](#value)
+        - [Selection](#selection)
+        - [Object](#object)
+        - [Array](#array)
+        - [Tuple](#tuple)
+        - [BoundedSeries](#boundedseries)
+    - [擴充](#擴充)
 
 ## Wrapping fakerjs Functions
 
-- [X] Airline
-- [X] Animal
-- [X] Color
-- [X] Commerce
-- [X] Company
-- [X] Database
-- [X] Datatype
-- [X] Date(Datetime)
-- [X] Finance
-- [X] Food
-- [X] Git
-- [X] Hacker
-- [X] Image
-- [X] Internet
-- [X] Location
-- [X] Lorem
-- [X] Music
-- [X] Number
-- [X] Person
-- [X] Phone
-- [X] Science
-- [X] String
-- [X] System
-- [X] Vehicle
+- [x] Airline
+- [x] Animal
+- [x] Color
+- [x] Commerce
+- [x] Company
+- [x] Database
+- [x] Datatype
+- [x] Date(Datetime)
+- [x] Finance
+- [x] Food
+- [x] Git
+- [x] Hacker
+- [x] Image
+- [x] Internet
+- [x] Location
+- [x] Lorem
+- [x] Music
+- [x] Number
+- [x] Person
+- [x] Phone
+- [x] Science
+- [x] String
+- [x] System
+- [x] Vehicle
 
 ## 用途
 
 使用 faker js 時是單一純值不能產生結構，需要自己手動組合結構，此專案利用撰寫設定檔的方式來產生一個特定的假資料函數，減少手動組合結構的麻煩。
 
 ```typescript
-import { StructConfig } from 'struct-fakerator'
+import { StructConfig } from "struct-fakerator";
 
 const scheme = StructConfig.object({
-  name: StructConfig.value(() => 'hello'),
-  enum: StructConfig.select([1, 2, 3]),
-  list: StructConfig.array(StructConfig.value(() => 10), 5),
-  tuple: StructConfig.tuple([StructConfig.value(() => 'tuple1'), StructConfig.value(() => '100')])
-})
+    name: StructConfig.value(() => "hello"),
+    enum: StructConfig.select([1, 2, 3]),
+    list: StructConfig.array(
+        StructConfig.value(() => 10),
+        5,
+    ),
+    tuple: StructConfig.tuple([
+        StructConfig.value(() => "tuple1"),
+        StructConfig.value(() => "100"),
+    ]),
+});
 
 // or
 import {
-  createObjectConfig,
-  createArrayConfig,
-  createValueConfig,
-  createTupleConfig,
-  createSelectionConfig
-} from 'struct-fakerator';
-
+    createObjectConfig,
+    createArrayConfig,
+    createValueConfig,
+    createTupleConfig,
+    createSelectionConfig,
+} from "struct-fakerator";
 
 const scheme = createObjectConfig({
-  name: createValueConfig(() => 'hello'),
-  enum: createSelectionConfig([1, 2, 3]),
-  list: createArrayConfig(
-    createValueConfig(() => 10),
-    5
-  ),
-  tuple: createTupleConfig([
-    createValueConfig(() => 'tuple1'),
-    createValueConfig(() => 100),
-    createValueConfig(() => false),
-  ])
+    name: createValueConfig(() => "hello"),
+    enum: createSelectionConfig([1, 2, 3]),
+    list: createArrayConfig(
+        createValueConfig(() => 10),
+        5,
+    ),
+    tuple: createTupleConfig([
+        createValueConfig(() => "tuple1"),
+        createValueConfig(() => 100),
+        createValueConfig(() => false),
+    ]),
 });
 
 // or
 const scheme = {
-  type: 'obj',
-  content: {
-    name: {
-      type: 'value',
-      generateFn: () => 'hello',
-    },
-    enum: {
-      type: 'select',
-      items: [1, 2, 3],
-    },
-    list: {
-      type: 'arr',
-      item: {
-        type: 'value',
-        generateFn: () => 10,
-      },
-      len: 5,
-    },
-    tuple: {
-      type: 'tuple',
-      configItems: [
-        {
-          type: 'value',
-          generateFn: () => 'tuple1',
+    type: "obj",
+    content: {
+        name: {
+            type: "value",
+            generateFn: () => "hello",
         },
-        {
-          type: 'value',
-          generateFn: () => 100,
+        enum: {
+            type: "select",
+            items: [1, 2, 3],
         },
-        {
-          type: 'value',
-          generateFn: () => false,
+        list: {
+            type: "arr",
+            item: {
+                type: "value",
+                generateFn: () => 10,
+            },
+            len: 5,
+        },
+        tuple: {
+            type: "tuple",
+            configItems: [
+                {
+                    type: "value",
+                    generateFn: () => "tuple1",
+                },
+                {
+                    type: "value",
+                    generateFn: () => 100,
+                },
+                {
+                    type: "value",
+                    generateFn: () => false,
+                },
+            ],
         },
-      ],
     },
-  },
 };
 ```
 
 ```typescript
-import { StructGenerator } from 'struct-fakerator';
+import { StructGenerator } from "struct-fakerator";
 
-const result = StructGenerator.genFn(scheme)()
+const result = StructGenerator.genFn(scheme)();
 
 console.log(result);
 // {
@@ -129,10 +134,8 @@ console.log(result);
 //   list: [10, 10, 10, 10, 10],
 //   tuple: ['tuple1', 100, false]
 // }
-
 ```
 
-
 ### Value
 
 ```typescript
@@ -145,7 +148,7 @@ console.log(generateFn());
 ### Selection
 
 ```typescript
-const generateFn = StructGenerator.genFn(StructConfig.select([1, 2, 3, 4, 5]))
+const generateFn = StructGenerator.genFn(StructConfig.select([1, 2, 3, 4, 5]));
 
 console.log(generateFn());
 // 1 or 2 or 3 or 4 or 5
@@ -154,10 +157,15 @@ console.log(generateFn());
 ### Object
 
 ```typescript
-const generateFn = StructGenerator.genFn(StructConfig.object({
-  name: StructConfig.value(() => 'hello'),
-  list: StructConfig.array(StructConfig.value(() => 10), 5),
-}));
+const generateFn = StructGenerator.genFn(
+    StructConfig.object({
+        name: StructConfig.value(() => "hello"),
+        list: StructConfig.array(
+            StructConfig.value(() => 10),
+            5,
+        ),
+    }),
+);
 
 console.log(generateFn());
 // {
@@ -167,16 +175,16 @@ console.log(generateFn());
 
 // with transformer function
 const generateFn = StructGenerator.genFn(
-  StructConfig.object(
-    {
-      name: StructConfig.value(() => 'hello'),
-      list: StructConfig.array(
-        StructConfig.value(() => 10),
-        5
-      ),
-    },
-    ({ name, list }) => list.map((item) => `${name} ${item}`)
-  )
+    StructConfig.object(
+        {
+            name: StructConfig.value(() => "hello"),
+            list: StructConfig.array(
+                StructConfig.value(() => 10),
+                5,
+            ),
+        },
+        ({ name, list }) => list.map((item) => `${name} ${item}`),
+    ),
 );
 
 console.log(generateFn());
@@ -187,10 +195,10 @@ console.log(generateFn());
 
 ```typescript
 const generateFn = StructGenerator.genFn(
-  StructConfig.array(
-    StructConfig.value(() => 10),
-    5
-  )
+    StructConfig.array(
+        StructConfig.value(() => 10),
+        5,
+    ),
 );
 
 console.log(generateFn());
@@ -198,11 +206,11 @@ console.log(generateFn());
 
 // with next function
 const generateFn = StructGenerator.genFn(
-  StructConfig.array(
-    StructConfig.value(() => 10),
-    5,
-    (prev, current) => prev + 1 + current
-  )
+    StructConfig.array(
+        StructConfig.value(() => 10),
+        5,
+        (prev, current) => prev + 1 + current,
+    ),
 );
 
 console.log(generateFn());
@@ -213,11 +221,11 @@ console.log(generateFn());
 
 ```typescript
 const generateFn = StructGenerator.genFn(
-  StructConfig.tuple([
-    StructConfig.value(() => 'tuple1'),
-    StructConfig.value(() => 100),
-    StructConfig.value(() => false),
-  ])
+    StructConfig.tuple([
+        StructConfig.value(() => "tuple1"),
+        StructConfig.value(() => 100),
+        StructConfig.value(() => false),
+    ]),
 );
 
 console.log(generateFn());
@@ -228,19 +236,19 @@ console.log(generateFn());
 
 ```typescript
 const generateFn = StructGenerator.genFn(
-  StructConfig.boundedSeries({
-    upperLimit: 1.1,
-    lowerLimit: 0.9,
-    createInitValue: () => 100,
-    count: 20,
-  })
+    StructConfig.boundedSeries({
+        upperLimit: 1.1,
+        lowerLimit: 0.9,
+        createInitValue: () => 100,
+        count: 20,
+    }),
 );
 
 console.log(generateFn());
-// [100 * 0.9 <= num <= 100 * 1.1, 
+// [100 * 0.9 <= num <= 100 * 1.1,
 //  prev * 0.9 <= num <= prev * 1.1,
 //  prev * 0.9 <= num <= prev * 1.1,
-//  ...] 
+//  ...]
 ```
 
 ## 擴充
@@ -263,23 +271,23 @@ const createIntValueConfig = (option) => createValueConfig(() => faker.number.in
 const createEmailValueConfig = (option) => createValueConfig(() => faker.internet.email(option));
 
 const customTypeMatch = (config) => {
-  if (config.type === "int") {
-    return createIntValueConfig(config.option);
-  }
-  if (config.type === "email") {
-    return createEmailValueConfig(config.option);
-  }
-
-  throw Error("error");
+    if (config.type === "int") {
+        return createIntValueConfig(config.option);
+    }
+    if (config.type === "email") {
+        return createEmailValueConfig(config.option);
+    }
+
+    throw Error("error");
 };
 
 const config = {
-  type: "obj",
-  content: {
-    name: { type: "value", generateFn: () => "John" },
-    age: { type: "int" },
-    email: { type: "email" },
-  },
+    type: "obj",
+    content: {
+        name: { type: "value", generateFn: () => "John" },
+        age: { type: "int" },
+        email: { type: "email" },
+    },
 };
 
 const result = createGeneratorByType(config, customTypeMatch)();
@@ -294,4 +302,3 @@ console.log(result);
   }
 */
 ```
-

package/dist/config.cjs

@@ -13,7 +13,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -25,10 +25,10 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     select: ()=>external_create_config_cjs_namespaceObject.createSelectionConfig,
+    boundedSeries: ()=>external_create_config_cjs_namespaceObject.createBoundedSeriesConfig,
     object: ()=>external_create_config_cjs_namespaceObject.createObjectConfig,
     tuple: ()=>external_create_config_cjs_namespaceObject.createTupleConfig,
     value: ()=>external_create_config_cjs_namespaceObject.createValueConfig,
-    boundedSeries: ()=>external_create_config_cjs_namespaceObject.createBoundedSeriesConfig,
     array: ()=>external_create_config_cjs_namespaceObject.createArrayConfig
 });
 const external_create_config_cjs_namespaceObject = require("./create_config.cjs");
@@ -38,14 +38,14 @@ exports.object = __webpack_exports__.object;
 exports.select = __webpack_exports__.select;
 exports.tuple = __webpack_exports__.tuple;
 exports.value = __webpack_exports__.value;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "array",
     "boundedSeries",
     "object",
     "select",
     "tuple",
     "value"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/config_scheme.cjs

@@ -13,7 +13,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -24,72 +24,56 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    boundedSeriesScheme: ()=>boundedSeriesScheme,
+    selectionConfigScheme: ()=>selectionConfigScheme,
     tupleConfigScheme: ()=>tupleConfigScheme,
-    valueConfigScheme: ()=>valueConfigScheme,
     arrayConfigScheme: ()=>arrayConfigScheme,
-    selectionConfigScheme: ()=>selectionConfigScheme,
+    valueConfigScheme: ()=>valueConfigScheme,
+    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 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 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 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 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 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 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 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 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 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;
 exports.selectionConfigScheme = __webpack_exports__.selectionConfigScheme;
 exports.tupleConfigScheme = __webpack_exports__.tupleConfigScheme;
 exports.valueConfigScheme = __webpack_exports__.valueConfigScheme;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "arrayConfigScheme",
     "boundedSeriesScheme",
     "objConfigScheme",
     "selectionConfigScheme",
     "tupleConfigScheme",
     "valueConfigScheme"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

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 };