struct-fakerator 2.6.9 → 2.8.9

package/README.md

@@ -3,12 +3,12 @@
 - [假資料結構產生器](#假資料結構產生器)
   - [Wrapping fakerjs Functions](#wrapping-fakerjs-functions)
   - [用途](#用途)
-    - [createValueGenerator](#createvaluegenerator)
-    - [createSelectionGenerator](#createselectiongenerator)
-    - [createObjectGenerator](#createobjectgenerator)
-    - [createArrayGenerator](#createarraygenerator)
-    - [createTupleGenerator](#createtuplegenerator)
-    - [createBoundedSeriesGenerator](#createboundedseriesgenerator)
+    - [Value](#value)
+    - [Selection](#selection)
+    - [Object](#object)
+    - [Array](#array)
+    - [Tuple](#tuple)
+    - [BoundedSeries](#boundedseries)
   - [擴充](#擴充)
 
 ## Wrapping fakerjs Functions
@@ -42,146 +42,201 @@
 
 使用 faker js 時是單一純值不能產生結構，需要自己手動組合結構，此專案利用撰寫設定檔的方式來產生一個特定的假資料函數，減少手動組合結構的麻煩。
 
-```javascript
-const test = {
+```typescript
+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')])
+})
+
+// or
+import {
+  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),
+  ])
+});
+
+// or
+const scheme = {
   type: 'obj',
   content: {
     name: {
       type: 'value',
       generateFn: () => 'hello',
     },
+    enum: {
+      type: 'select',
+      items: [1, 2, 3],
+    },
     list: {
       type: 'arr',
-      len: 5,
       item: {
         type: 'value',
         generateFn: () => 10,
       },
+      len: 5,
+    },
+    tuple: {
+      type: 'tuple',
+      configItems: [
+        {
+          type: 'value',
+          generateFn: () => 'tuple1',
+        },
+        {
+          type: 'value',
+          generateFn: () => 100,
+        },
+        {
+          type: 'value',
+          generateFn: () => false,
+        },
+      ],
     },
   },
 };
+```
 
-const generateFn = createGeneratorByType(test);
+```typescript
+import { StructGenerator } from 'struct-fakerator';
 
-console.log(generateFn());
+const result = StructGenerator.genFn(scheme)()
 
-/*
-{
-  name: "hello"
-  list: [10, 10, 10, 10, 10,]
-}
-*/
-```
+console.log(result);
+// {
+//   name: 'hello',
+//   enum: 1, // or 2 or 3
+//   list: [10, 10, 10, 10, 10],
+//   tuple: ['tuple1', 100, false]
+// }
 
+```
 
 
-### createValueGenerator
+### Value
 
-```javascript
-const generateFn = createValueGenerator({
-  type: 'value',
-  generateFn: () => 10,
-})
+```typescript
+const generateFn = StructGenerator.genFn(StructConfig.value(() => 10));
 
 console.log(generateFn());
-
 // 10
 ```
 
-### createSelectionGenerator
+### Selection
 
-```javascript
-const generateFn = createSelectionGenerator({
- type: 'select',
- items: [1, 2, 3, 4, 5],
-})
+```typescript
+const generateFn = StructGenerator.genFn(StructConfig.select([1, 2, 3, 4, 5]))
 
 console.log(generateFn());
-
 // 1 or 2 or 3 or 4 or 5
 ```
 
-### createObjectGenerator
-
-```javascript
-const generateFn = createObjectGenerator({
- type: 'obj',
- content: {
-   name: {
-     type: 'value',
-     generateFn: () => 'hello',
-   },
-   list: {
-     type: 'arr',
-     len: 5,
-     item: {
-       type: 'value',
-       generateFn: () => 10,
-     }
-   }
- }
-})
+### Object
 
-console.log(generateFn());
+```typescript
+const generateFn = StructGenerator.genFn(StructConfig.object({
+  name: StructConfig.value(() => 'hello'),
+  list: StructConfig.array(StructConfig.value(() => 10), 5),
+}));
 
+console.log(generateFn());
 // {
 //   name: 'hello',
 //   list: [10, 10, 10, 10, 10]
 // }
+
+// 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}`)
+  )
+);
+
+console.log(generateFn());
+// ["hello 10", "hello 10", "hello 10", "hello 10", "hello 10"]
 ```
-### createArrayGenerator
 
+### Array
 
-```javascript
-const generateFn = createArrayGenerator({
- type: 'arr',
- len: 5,
- item: {
-   type: 'value',
-   generateFn: () => 10,
- }
-})
+```typescript
+const generateFn = StructGenerator.genFn(
+  StructConfig.array(
+    StructConfig.value(() => 10),
+    5
+  )
+);
 
 console.log(generateFn());
-
 // [10, 10, 10, 10, 10]
-```
 
-### createTupleGenerator
-
-```javascript
-const generateFn = createTupleGenerator({
- type: 'tuple',
- configItems: [
-   {
-     type: 'value',
-     generateFn: () => 10,
-   },
-   {
-     type: 'value',
-     generateFn: () => 'hello',
-   },
- ]
-})
+// with next function
+const generateFn = StructGenerator.genFn(
+  StructConfig.array(
+    StructConfig.value(() => 10),
+    5,
+    (prev, current) => prev + 1 + current
+  )
+);
 
 console.log(generateFn());
-
-// [10, 'hello']
+// [21, 32, 43, 54, 65]
 ```
 
-### createBoundedSeriesGenerator
+### Tuple
 
-```javascript
-const generateFn = createBoundedSeriesGenerator({
- type: 'bounded_series',
- upperLimit: 1.1,
- lowerLimit: 0.9,
- createInitValue: () => 100,
- count: 20
-})
+```typescript
+const generateFn = StructGenerator.genFn(
+  StructConfig.tuple([
+    StructConfig.value(() => 'tuple1'),
+    StructConfig.value(() => 100),
+    StructConfig.value(() => false),
+  ])
+);
 
 console.log(generateFn());
+// ['tuple1', 100, false]
+```
+
+### BoundedSeries
 
+```typescript
+const generateFn = StructGenerator.genFn(
+  StructConfig.boundedSeries({
+    upperLimit: 1.1,
+    lowerLimit: 0.9,
+    createInitValue: () => 100,
+    count: 20,
+  })
+);
+
+console.log(generateFn());
 // [100 * 0.9 <= num <= 100 * 1.1, 
 //  prev * 0.9 <= num <= prev * 1.1,
 //  prev * 0.9 <= num <= prev * 1.1,
@@ -203,7 +258,7 @@ flowchart TB
 
 但並不是所有人情況都能自己手動建立函數，有可能是開放給別人使用的服務，沒辦法在使用方建立函數，這時 `createGeneratorByType` 第二個可以讓製作服務的人帶入自己的擴充，這樣這個函數就能接受更多種型態。
 
-```javascript
+```typescript
 const createIntValueConfig = (option) => createValueConfig(() => faker.number.int(option));
 const createEmailValueConfig = (option) => createValueConfig(() => faker.internet.email(option));
 

package/biome.json

@@ -1,27 +1,31 @@
 {
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-	"organizeImports": {
-		"enabled": true
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true
-		},
-		"include": [
-			"src/**/*"
-		]
-	},
-	"formatter": {
-		"indentStyle": "space",
-		"include": [
-			"src/**/*",
-			"tsup.config.ts"
-		]
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "double"
-		}
-	}
-}
+  "$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    },
+    "includes": ["src/**/*"]
+  },
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf",
+    "includes": ["src/**/*", "tsup.config.ts", "rslib.config.ts"]
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "files": {
+    "includes": ["src/**/*", "tsup.config.ts", "rslib.config.ts"]
+  }
+}

package/dist/config.d.ts

@@ -1,2 +1 @@
-export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value } from './create_config.js';
-import './type.js';
+export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value, } from "./create_config";

package/dist/config.js

@@ -1,19 +1,51 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-V2AWKRQI.js');
-
-
-
-
-
-
-
-var _chunkC3RGM3CBjs = require('./chunk-C3RGM3CB.js');
-require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.array = _chunkC3RGM3CBjs.createArrayConfig; exports.boundedSeries = _chunkC3RGM3CBjs.createBoundedSeriesConfig; exports.object = _chunkC3RGM3CBjs.createObjectConfig; exports.select = _chunkC3RGM3CBjs.createSelectionConfig; exports.tuple = _chunkC3RGM3CBjs.createTupleConfig; exports.value = _chunkC3RGM3CBjs.createValueConfig;
+"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 ('undefined' != 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__, {
+    select: ()=>external_create_config_js_namespaceObject.createSelectionConfig,
+    object: ()=>external_create_config_js_namespaceObject.createObjectConfig,
+    tuple: ()=>external_create_config_js_namespaceObject.createTupleConfig,
+    value: ()=>external_create_config_js_namespaceObject.createValueConfig,
+    boundedSeries: ()=>external_create_config_js_namespaceObject.createBoundedSeriesConfig,
+    array: ()=>external_create_config_js_namespaceObject.createArrayConfig
+});
+const external_create_config_js_namespaceObject = require("./create_config.js");
+exports.array = __webpack_exports__.array;
+exports.boundedSeries = __webpack_exports__.boundedSeries;
+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 === [
+    "array",
+    "boundedSeries",
+    "object",
+    "select",
+    "tuple",
+    "value"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/config.mjs

@@ -1,19 +1,2 @@
-import "./chunk-VE3Q5LC3.mjs";
-import {
-  createArrayConfig,
-  createBoundedSeriesConfig,
-  createObjectConfig,
-  createSelectionConfig,
-  createTupleConfig,
-  createValueConfig
-} from "./chunk-ZQA42PYM.mjs";
-import "./chunk-USLYTOPD.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  createArrayConfig as array,
-  createBoundedSeriesConfig as boundedSeries,
-  createObjectConfig as object,
-  createSelectionConfig as select,
-  createTupleConfig as tuple,
-  createValueConfig as value
-};
+import { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig } from "./create_config.mjs";
+export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value };

package/dist/config_scheme.d.ts

@@ -1,32 +1,29 @@
-import { z } from 'zod/v4';
-
-declare const valueConfigScheme: z.ZodObject<{
+import { z } from "zod";
+export declare const valueConfigScheme: z.ZodObject<{
     type: z.ZodString;
     generateFn: z.ZodAny;
 }, z.core.$strip>;
-declare const selectionConfigScheme: z.ZodObject<{
+export declare const selectionConfigScheme: z.ZodObject<{
     type: z.ZodString;
     items: z.ZodArray<z.ZodAny>;
 }, z.core.$strip>;
-declare const arrayConfigScheme: z.ZodObject<{
+export declare const arrayConfigScheme: z.ZodObject<{
     type: z.ZodString;
     item: z.ZodObject<{}, z.core.$strip>;
     len: z.ZodNumber;
 }, z.core.$strip>;
-declare const tupleConfigScheme: z.ZodObject<{
+export declare const tupleConfigScheme: z.ZodObject<{
     type: z.ZodString;
     configItems: z.ZodArray<z.ZodAny>;
 }, z.core.$strip>;
-declare const objConfigScheme: z.ZodObject<{
+export declare const objConfigScheme: z.ZodObject<{
     type: z.ZodString;
     content: z.ZodObject<{}, z.core.$strip>;
 }, z.core.$strip>;
-declare const boundedSeriesScheme: z.ZodObject<{
+export declare const boundedSeriesScheme: z.ZodObject<{
     type: z.ZodString;
     upperLimit: z.ZodNumber;
     lowerLimit: z.ZodNumber;
     createInitValue: z.ZodAny;
     count: z.ZodNumber;
 }, z.core.$strip>;
-
-export { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme };

package/dist/config_scheme.js

@@ -1,17 +1,95 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-var _chunkZWLHVT5Ojs = require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.arrayConfigScheme = _chunkZWLHVT5Ojs.arrayConfigScheme; exports.boundedSeriesScheme = _chunkZWLHVT5Ojs.boundedSeriesScheme; exports.objConfigScheme = _chunkZWLHVT5Ojs.objConfigScheme; exports.selectionConfigScheme = _chunkZWLHVT5Ojs.selectionConfigScheme; exports.tupleConfigScheme = _chunkZWLHVT5Ojs.tupleConfigScheme; exports.valueConfigScheme = _chunkZWLHVT5Ojs.valueConfigScheme;
+"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 ('undefined' != 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__, {
+    boundedSeriesScheme: ()=>boundedSeriesScheme,
+    tupleConfigScheme: ()=>tupleConfigScheme,
+    valueConfigScheme: ()=>valueConfigScheme,
+    arrayConfigScheme: ()=>arrayConfigScheme,
+    selectionConfigScheme: ()=>selectionConfigScheme,
+    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 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 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 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"
+});
+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 === [
+    "arrayConfigScheme",
+    "boundedSeriesScheme",
+    "objConfigScheme",
+    "selectionConfigScheme",
+    "tupleConfigScheme",
+    "valueConfigScheme"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});