struct-fakerator 1.2.2 → 1.2.3

package/cjs/create_config.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createValueConfig = exports.createTupleConfig = exports.createSelectionConfig = exports.createObjectConfig = exports.createBoundedSeriesConfig = exports.createArrayConfig = void 0;
 var _faker = require("@faker-js/faker");
-var _config_scheme = require("./config_scheme.js");
+var _config_scheme = require("./config_scheme.mjs");
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }

package/cjs/create_config.test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _create_config = require("./create_config.mjs");
+var _create_generator_fn = require("./create_generator_fn.mjs");
+(0, _vitest.test)("createValueConfig", function () {
+  var valueConfig = (0, _create_config.createValueConfig)(function () {
+    return 44;
+  });
+  (0, _vitest.expect)(valueConfig.type).toBe("value");
+  (0, _vitest.expect)(valueConfig.generateFn).toBeTypeOf("function");
+});
+(0, _vitest.test)("createSelectionConfig", function () {
+  var options = [1, 2, 3, 4];
+  var selectionConfig = (0, _create_config.createSelectionConfig)([1, 2, 3, 4]);
+  (0, _vitest.expect)(selectionConfig.type).toBe("select");
+  (0, _vitest.expect)(selectionConfig.items).toEqual(options);
+});
+(0, _vitest.test)("createArrayConfig", function () {
+  var valueConfig = (0, _create_config.createValueConfig)(function () {
+    return 44;
+  });
+  var arrConfig = (0, _create_config.createArrayConfig)(valueConfig, 20);
+  (0, _vitest.expect)(arrConfig.type).toBe("arr");
+  (0, _vitest.expect)(arrConfig.len).toBe(20);
+  (0, _vitest.expect)(arrConfig.item).toEqual(valueConfig);
+});
+(0, _vitest.test)("createTupleConfig", function () {
+  var value1Config = (0, _create_config.createValueConfig)(function () {
+    return 123;
+  });
+  var value2Config = (0, _create_config.createValueConfig)(function () {
+    return "hello";
+  });
+  var tupleConfig = (0, _create_config.createTupleConfig)([value1Config, value2Config]);
+  (0, _vitest.expect)(tupleConfig.type).toBe("tuple");
+  (0, _vitest.expect)(tupleConfig.configItems).toEqual([value1Config, value2Config]);
+});
+(0, _vitest.test)("createObjConfig", function () {
+  var value1Config = (0, _create_config.createValueConfig)(function () {
+    return 32;
+  });
+  var value2Config = (0, _create_config.createValueConfig)(function () {
+    return "frank";
+  });
+  var objConfig = (0, _create_config.createObjectConfig)({
+    name: value2Config,
+    age: value1Config
+  });
+  (0, _vitest.expect)(objConfig.type).toBe("obj");
+  (0, _vitest.expect)(objConfig.content).toEqual({
+    name: value2Config,
+    age: value1Config
+  });
+});
+(0, _vitest.test)("createBoundedSeriesConfig", function () {
+  var boundedSeriesConfig = (0, _create_config.createBoundedSeriesConfig)({
+    count: 1,
+    upperLimit: 1.2,
+    lowerLimit: 1.0,
+    createInitValue: function createInitValue() {
+      return 40;
+    }
+  });
+  (0, _vitest.expect)(boundedSeriesConfig.type).toBe("bounded_series");
+  (0, _vitest.expect)(boundedSeriesConfig.upperLimit).toBe(1.2);
+  (0, _vitest.expect)(boundedSeriesConfig.lowerLimit).toBe(1.0);
+  (0, _vitest.expect)(boundedSeriesConfig.createInitValue).toBeTypeOf("function");
+});

package/cjs/create_generator_fn.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createValueGenerator = exports.createTupleGenerator = exports.createSelectionGenerator = exports.createObjectGenerator = exports.createGeneratorByType = exports.createBoundedSeriesGenerator = exports.createArrayGenerator = void 0;
 var _faker = require("@faker-js/faker");
-var _config_scheme = require("./config_scheme.js");
+var _config_scheme = require("./config_scheme.mjs");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

package/cjs/create_generator_fn.test.js

@@ -0,0 +1,244 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _zod = require("zod");
+var _create_generator_fn = require("./create_generator_fn.mjs");
+var _create_config = require("./create_config.mjs");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+(0, _vitest.describe)("createValueGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var value = (0, _create_generator_fn.createValueGenerator)({
+      type: "value",
+      generateFn: function generateFn() {
+        return 50;
+      }
+    })();
+    (0, _vitest.expect)(value).toBe(50);
+    var value2 = (0, _create_generator_fn.createValueGenerator)({
+      type: "value",
+      generateFn: function generateFn() {
+        return {
+          age: 100,
+          name: "hello"
+        };
+      }
+    })();
+    (0, _vitest.expect)(value2).toEqual({
+      age: 100,
+      name: "hello"
+    });
+  });
+});
+(0, _vitest.describe)("createSelectionGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var value = (0, _create_generator_fn.createSelectionGenerator)({
+      type: "select",
+      items: [1]
+    })();
+    (0, _vitest.expect)(value).toBe(1);
+    var value2 = (0, _create_generator_fn.createSelectionGenerator)({
+      type: "select",
+      items: [30, 30, 30, 30]
+    })();
+    (0, _vitest.expect)(value2).toBe(30);
+  });
+});
+(0, _vitest.describe)("createArrayGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var list = (0, _create_generator_fn.createArrayGenerator)({
+      type: "arr",
+      len: 5,
+      item: {
+        type: "value",
+        generateFn: function generateFn() {
+          return {
+            age: 42
+          };
+        }
+      }
+    })();
+    (0, _vitest.expect)(list).toEqual([{
+      age: 42
+    }, {
+      age: 42
+    }, {
+      age: 42
+    }, {
+      age: 42
+    }, {
+      age: 42
+    }]);
+  });
+});
+(0, _vitest.describe)("createTupleGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var tuple = (0, _create_generator_fn.createTupleGenerator)({
+      type: "tuple",
+      configItems: [{
+        type: "value",
+        generateFn: function generateFn() {
+          return 225;
+        }
+      }, {
+        type: "value",
+        generateFn: function generateFn() {
+          return "hello world";
+        }
+      }]
+    })();
+    (0, _vitest.expect)(tuple.length).toBe(2);
+    var _tuple = _slicedToArray(tuple, 2),
+      num = _tuple[0],
+      str = _tuple[1];
+    (0, _vitest.expect)(num).toBe(225);
+    (0, _vitest.expect)(str).toBe("hello world");
+  });
+});
+(0, _vitest.describe)("createObjectGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var obj = (0, _create_generator_fn.createObjectGenerator)({
+      type: "obj",
+      content: {
+        name: {
+          type: "value",
+          generateFn: function generateFn() {
+            return "John";
+          }
+        },
+        age: {
+          type: "value",
+          generateFn: function generateFn() {
+            return 50;
+          }
+        },
+        location: {
+          type: "value",
+          generateFn: function generateFn() {
+            return "Taiwan";
+          }
+        }
+      }
+    })();
+    (0, _vitest.expect)(obj).toEqual({
+      name: "John",
+      age: 50,
+      location: "Taiwan"
+    });
+  });
+});
+(0, _vitest.describe)("createBoundedSeriesGenerator", function () {
+  (0, _vitest.test)("normal", function () {
+    var upperLimit = 1.1;
+    var lowerLimit = 0.9;
+    var initValue = 100;
+    var count = 100;
+    var list = (0, _create_generator_fn.createBoundedSeriesGenerator)({
+      type: "bounded_series",
+      upperLimit: upperLimit,
+      lowerLimit: lowerLimit,
+      createInitValue: function createInitValue() {
+        return initValue;
+      },
+      count: count
+    })();
+    for (var i = 0; i < count; i++) {
+      var value = list[i];
+      if (i === 0) {
+        var _ratio = value / initValue;
+        (0, _vitest.expect)(_ratio).toBeLessThanOrEqual(upperLimit);
+        (0, _vitest.expect)(_ratio).toBeGreaterThanOrEqual(lowerLimit);
+        continue;
+      }
+      var prevValue = list[i - 1];
+      var ratio = value / prevValue;
+      (0, _vitest.expect)(ratio).toBeLessThanOrEqual(upperLimit);
+      (0, _vitest.expect)(ratio).toBeGreaterThanOrEqual(lowerLimit);
+    }
+  });
+});
+(0, _vitest.describe)("createGeneratorByType", function () {
+  (0, _vitest.test)("normal", function () {
+    var config = {
+      type: "obj",
+      content: {
+        name: {
+          type: "value",
+          generateFn: function generateFn() {
+            return "John";
+          }
+        },
+        age: {
+          type: "value",
+          generateFn: function generateFn() {
+            return 50;
+          }
+        },
+        locations: {
+          type: "arr",
+          item: {
+            type: "value",
+            generateFn: function generateFn() {
+              return "Taiwan";
+            }
+          },
+          len: 5
+        }
+      }
+    };
+    var result = (0, _create_generator_fn.createGeneratorByType)(config)();
+    (0, _vitest.expect)(result).toEqual({
+      name: "John",
+      age: 50,
+      locations: ["Taiwan", "Taiwan", "Taiwan", "Taiwan", "Taiwan"]
+    });
+  });
+  (0, _vitest.test)("with custom type match", function () {
+    var createIntValueConfig = function createIntValueConfig(option) {
+      return (0, _create_config.createValueConfig)(function () {
+        return 50;
+      });
+    };
+    var createEmailValueConfig = function createEmailValueConfig(option) {
+      return (0, _create_config.createValueConfig)(function () {
+        return "xxx@example.com";
+      });
+    };
+    var customTypeMatch = function customTypeMatch(config) {
+      if (config.type === "int") {
+        return createIntValueConfig(config.option);
+      }
+      if (config.type === "email") {
+        return createEmailValueConfig(config.option);
+      }
+      throw Error("error");
+    };
+    var config = {
+      type: "obj",
+      content: {
+        name: {
+          type: "value",
+          generateFn: function generateFn() {
+            return "John";
+          }
+        },
+        age: {
+          type: "int"
+        },
+        email: {
+          type: "email"
+        }
+      }
+    };
+    var result = (0, _create_generator_fn.createGeneratorByType)(config, customTypeMatch)();
+    (0, _vitest.expect)(result).toEqual({
+      name: "John",
+      age: 50,
+      email: "xxx@example.com"
+    });
+  });
+});

package/cjs/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _create_config = require("./create_config");
+var _create_config = require("./create_config.mjs");
 Object.keys(_create_config).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _create_config[key]) return;
@@ -14,7 +14,7 @@ Object.keys(_create_config).forEach(function (key) {
     }
   });
 });
-var _create_generator_fn = require("./create_generator_fn");
+var _create_generator_fn = require("./create_generator_fn.mjs");
 Object.keys(_create_generator_fn).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _create_generator_fn[key]) return;

package/{src/create_config.js → esm/src/create_config.mjs}

@@ -6,7 +6,7 @@ import {
   tupleConfigScheme,
   objConfigScheme,
   boundedSeriesScheme,
-} from "./config_scheme.js";
+} from "./config_scheme.mjs";
 
 /**
  * value

package/{src/create_config.test.js → esm/src/create_config.test.mjs}

@@ -7,8 +7,8 @@ import {
   createTupleConfig,
   createObjectConfig,
   createBoundedSeriesConfig,
-} from "./create_config";
-import { createGeneratorByType } from "./create_generator_fn";
+} from "./create_config.mjs";
+import { createGeneratorByType } from "./create_generator_fn.mjs";
 
 test("createValueConfig", () => {
   const valueConfig = createValueConfig(() => 44);

package/{src/create_generator_fn.js → esm/src/create_generator_fn.mjs}

@@ -7,7 +7,7 @@ import {
   objConfigScheme,
   boundedSeriesScheme,
   tupleConfigScheme,
-} from "./config_scheme.js";
+} from "./config_scheme.mjs";
 
 /**
  * value

package/{src/create_generator_fn.test.js → esm/src/create_generator_fn.test.mjs}

@@ -8,8 +8,8 @@ import {
   createObjectGenerator,
   createBoundedSeriesGenerator,
   createGeneratorByType,
-} from "./create_generator_fn";
-import { createValueConfig } from "./create_config";
+} from "./create_generator_fn.mjs";
+import { createValueConfig } from "./create_config.mjs";
 
 describe("createValueGenerator", () => {
   test("normal", () => {

package/esm/src/index.mjs

@@ -0,0 +1,2 @@
+export * from "./create_config.mjs";
+export * from "./create_generator_fn.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "struct-fakerator",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "",
   "main": "cjs/index.js",
   "module": "esm/index.mjs",
@@ -8,10 +8,10 @@
   "scripts": {
     "start": "node src/index.js",
     "dev": "node",
-    "build:cjs": "babel src --out-dir cjs --presets=@babel/preset-env",
-    "build:esm": "babel src --out-dir esm --presets=@babel/preset-env --plugins=@babel/plugin-transform-modules-commonjs",
+    "build:cjs": "babel src --out-dir cjs --presets=@babel/preset-env --plugins=@babel/plugin-transform-modules-commonjs",
+    "build:esm": "cp -r src esm",
     "build": "pnpm build:cjs && pnpm build:esm",
-    "test": "vitest"
+    "test": "vitest src"
   },
   "keywords": [],
   "author": "FizzyElt",

package/src/config_scheme.mjs

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+export const valueConfigScheme = z.object({
+  type: z.string().regex(/^value$/, { message: "invalid type string" }),
+  generateFn: z.function(),
+});
+
+export const selectionConfigScheme = z.object({
+  type: z.string().regex(/^select$/, { message: "invalid type string" }),
+  items: z.any().array().nonempty({ message: "items can not be empty" }),
+});
+
+export const arrayConfigScheme = z.object({
+  type: z.string().regex(/^arr$/, { message: "invalid type string" }),
+  item: z.object({}),
+  len: z.number().nonnegative(),
+});
+
+export const tupleConfigScheme = z.object({
+  type: z.string().regex(/^tuple$/, { message: "invalid type string" }),
+  configItems: z.any().array(),
+});
+
+export const objConfigScheme = z.object({
+  type: z.string().regex(/^obj$/, { message: "invalid type string" }),
+  content: z.object({}),
+});
+
+export const boundedSeriesScheme = z
+  .object({
+    type: z
+      .string()
+      .regex(/^bounded_series$/, { message: "invalid type string" }),
+    upperLimit: z.number().nonnegative(),
+    lowerLimit: z.number().nonnegative(),
+    createInitValue: z.function().args().returns(z.number()),
+    count: z.number().nonnegative(),
+  })
+  .refine(({ upperLimit, lowerLimit }) => upperLimit >= lowerLimit, {
+    message: "lowerLimit can not greater then upperLimit",
+  })
+  .refine(({ createInitValue }) => typeof createInitValue() === "number", {
+    message: "createInitValue is not return number",
+    path: ["createInitValue"],
+  });

package/src/create_config.mjs

@@ -0,0 +1,97 @@
+import { faker } from "@faker-js/faker";
+import {
+  valueConfigScheme,
+  arrayConfigScheme,
+  selectionConfigScheme,
+  tupleConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+} from "./config_scheme.mjs";
+
+/**
+ * value
+ * @param {function} generateFn - The function used to generate the value.
+ * @return {ValueConfig} The configuration object with the type "value" and the provided generate function.
+ */
+export const createValueConfig = (generateFn) => {
+  const config = {
+    type: "value",
+    generateFn,
+  };
+
+  valueConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * selection
+ * @param {Array} items - The array of items to choose from.
+ * @return {SelectionConfig} The configuration object with the type "select" and the provided items.
+ */
+export const createSelectionConfig = (items) => {
+  const config = { type: "select", items };
+
+  selectionConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * object
+ * @param {object} content
+ * @return {ObjectConfig}
+ */
+export const createObjectConfig = (content) => {
+  const config = { type: "obj", content };
+
+  objConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * array
+ * @param {object} item
+ * @param {number} len
+ * @return {ArrayConfig}
+ */
+export const createArrayConfig = (item, len) => {
+  const config = { type: "arr", item, len };
+
+  arrayConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * tuple
+ * @param {Array} configItems
+ * @return {TupleConfig}
+ */
+export const createTupleConfig = (configItems) => {
+  const config = {
+    type: "tuple",
+    configItems,
+  };
+
+  tupleConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * bounded series
+ * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
+ * @return {BoundedSeriesConfig}
+ */
+export const createBoundedSeriesConfig = (config) => {
+  const newConfig = {
+    type: "bounded_series",
+    ...config,
+  };
+
+  boundedSeriesScheme.parse(newConfig);
+
+  return newConfig;
+};

package/src/create_config.test.mjs

@@ -0,0 +1,72 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import {
+  createValueConfig,
+  createSelectionConfig,
+  createArrayConfig,
+  createTupleConfig,
+  createObjectConfig,
+  createBoundedSeriesConfig,
+} from "./create_config.mjs";
+import { createGeneratorByType } from "./create_generator_fn.mjs";
+
+test("createValueConfig", () => {
+  const valueConfig = createValueConfig(() => 44);
+
+  expect(valueConfig.type).toBe("value");
+  expect(valueConfig.generateFn).toBeTypeOf("function");
+});
+
+test("createSelectionConfig", () => {
+  const options = [1, 2, 3, 4];
+  const selectionConfig = createSelectionConfig([1, 2, 3, 4]);
+
+  expect(selectionConfig.type).toBe("select");
+  expect(selectionConfig.items).toEqual(options);
+});
+
+test("createArrayConfig", () => {
+  const valueConfig = createValueConfig(() => 44);
+  const arrConfig = createArrayConfig(valueConfig, 20);
+
+  expect(arrConfig.type).toBe("arr");
+  expect(arrConfig.len).toBe(20);
+  expect(arrConfig.item).toEqual(valueConfig);
+});
+
+test("createTupleConfig", () => {
+  const value1Config = createValueConfig(() => 123);
+  const value2Config = createValueConfig(() => "hello");
+
+  const tupleConfig = createTupleConfig([value1Config, value2Config]);
+
+  expect(tupleConfig.type).toBe("tuple");
+  expect(tupleConfig.configItems).toEqual([value1Config, value2Config]);
+});
+
+test("createObjConfig", () => {
+  const value1Config = createValueConfig(() => 32);
+  const value2Config = createValueConfig(() => "frank");
+
+  const objConfig = createObjectConfig({
+    name: value2Config,
+    age: value1Config,
+  });
+
+  expect(objConfig.type).toBe("obj");
+  expect(objConfig.content).toEqual({ name: value2Config, age: value1Config });
+});
+
+test("createBoundedSeriesConfig", () => {
+  const boundedSeriesConfig = createBoundedSeriesConfig({
+    count: 1,
+    upperLimit: 1.2,
+    lowerLimit: 1.0,
+    createInitValue: () => 40,
+  });
+
+  expect(boundedSeriesConfig.type).toBe("bounded_series");
+  expect(boundedSeriesConfig.upperLimit).toBe(1.2);
+  expect(boundedSeriesConfig.lowerLimit).toBe(1.0);
+  expect(boundedSeriesConfig.createInitValue).toBeTypeOf("function");
+});

package/src/create_generator_fn.mjs

@@ -0,0 +1,140 @@
+import { faker } from "@faker-js/faker";
+
+import {
+  valueConfigScheme,
+  selectionConfigScheme,
+  arrayConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+  tupleConfigScheme,
+} from "./config_scheme.mjs";
+
+/**
+ * value
+ * @param {ValueConfig} config
+ * @return {function}
+ */
+export const createValueGenerator = (config) => {
+  valueConfigScheme.parse(config);
+
+  return config.generateFn;
+};
+
+/**
+ * selection
+ * @param {SelectionConfig} config
+ * @return {function} The configuration object with the type "select" and the provided items.
+ */
+export const createSelectionGenerator = (config) => {
+  selectionConfigScheme.parse(config);
+
+  const { items } = config;
+
+  return () => items[faker.number.int(items.length - 1)];
+};
+
+/**
+ * object
+ * @param {ObjectConfig} config
+ * @param {(() => ValueConfig)=} customTypeMatch
+ * @return {() => object}
+ */
+export const createObjectGenerator = (config, customTypeMatch) => {
+  objConfigScheme.parse(config);
+
+  const keyWithFns = Object.entries(config.content).map(([key, subConfig]) => [
+    key,
+    createGeneratorByType(subConfig, customTypeMatch),
+  ]);
+
+  return () => {
+    const result = {};
+    for (const [key, generateFn] of keyWithFns) {
+      result[key] = generateFn();
+    }
+    return result;
+  };
+};
+
+/**
+ * array
+ * @param {ArrayConfig} config
+ * @param {(() => ValueConfig)=} customTypeMatch
+ * @return {() => Array}
+ */
+export const createArrayGenerator = (config, customTypeMatch) => {
+  arrayConfigScheme.parse(config);
+
+  const itemGeneratorFn = createGeneratorByType(config.item, customTypeMatch);
+
+  return () => Array.from({ length: config.len ?? 0 }, itemGeneratorFn);
+};
+
+/**
+ * tuple
+ * @param {TupleConfig} config
+ * @param {(() => ValueConfig)=} customTypeMatch
+ * @return {() => Array}
+ */
+export const createTupleGenerator = (config, customTypeMatch) => {
+  tupleConfigScheme.parse(config);
+
+  const itemsFns = config.configItems.map((configItem) =>
+    createGeneratorByType(configItem, customTypeMatch),
+  );
+
+  return () => itemsFns.map((generateFn) => generateFn());
+};
+
+/**
+ * bounded series
+ * @param {BoundedSeriesConfig} config
+ * @return {() => Array<number>}
+ */
+export const createBoundedSeriesGenerator = (config) => {
+  boundedSeriesScheme.parse(config);
+
+  const { upperLimit, lowerLimit, createInitValue, count } = config;
+
+  return () => {
+    let value = createInitValue();
+
+    const boundedSeries = [];
+
+    for (let i = 0; i < count; i++) {
+      value = faker.number.float({ max: upperLimit, min: lowerLimit }) * value;
+      boundedSeries.push(value);
+    }
+
+    return boundedSeries;
+  };
+};
+
+/**
+ *
+ * @param {ValueConfig | SelectionConfig | ArrayConfig | ObjectConfig | TupleConfig | BoundedSeriesConfig} config
+ * @param {(() => ValueConfig)=} customTypeMatch
+ * @return {function}
+ */
+export const createGeneratorByType = (config, customTypeMatch) => {
+  switch (config.type) {
+    case "obj":
+      return createObjectGenerator(config, customTypeMatch);
+    case "arr":
+      return createArrayGenerator(config, customTypeMatch);
+    case "select":
+      return createSelectionGenerator(config);
+    case "tuple":
+      return createTupleGenerator(config, customTypeMatch);
+    case "value":
+      return createValueGenerator(config);
+    case "bounded_series":
+      return createBoundedSeriesGenerator(config);
+    default: {
+      if (customTypeMatch) {
+        return createValueGenerator(customTypeMatch(config));
+      }
+      throw Error(`config type "${config.type}" is not supported`);
+    }
+  }
+};

package/src/create_generator_fn.test.mjs

@@ -0,0 +1,192 @@
+import { describe, test, expect } from "vitest";
+import { ZodError } from "zod";
+import {
+  createValueGenerator,
+  createSelectionGenerator,
+  createArrayGenerator,
+  createTupleGenerator,
+  createObjectGenerator,
+  createBoundedSeriesGenerator,
+  createGeneratorByType,
+} from "./create_generator_fn.mjs";
+import { createValueConfig } from "./create_config.mjs";
+
+describe("createValueGenerator", () => {
+  test("normal", () => {
+    const value = createValueGenerator({
+      type: "value",
+      generateFn: () => 50,
+    })();
+
+    expect(value).toBe(50);
+
+    const value2 = createValueGenerator({
+      type: "value",
+      generateFn: () => ({ age: 100, name: "hello" }),
+    })();
+
+    expect(value2).toEqual({ age: 100, name: "hello" });
+  });
+});
+
+describe("createSelectionGenerator", () => {
+  test("normal", () => {
+    const value = createSelectionGenerator({
+      type: "select",
+      items: [1],
+    })();
+
+    expect(value).toBe(1);
+
+    const value2 = createSelectionGenerator({
+      type: "select",
+      items: [30, 30, 30, 30],
+    })();
+
+    expect(value2).toBe(30);
+  });
+});
+
+describe("createArrayGenerator", () => {
+  test("normal", () => {
+    const list = createArrayGenerator({
+      type: "arr",
+      len: 5,
+      item: { type: "value", generateFn: () => ({ age: 42 }) },
+    })();
+
+    expect(list).toEqual([
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+    ]);
+  });
+});
+
+describe("createTupleGenerator", () => {
+  test("normal", () => {
+    const tuple = createTupleGenerator({
+      type: "tuple",
+      configItems: [
+        { type: "value", generateFn: () => 225 },
+        { type: "value", generateFn: () => "hello world" },
+      ],
+    })();
+
+    expect(tuple.length).toBe(2);
+    const [num, str] = tuple;
+    expect(num).toBe(225);
+    expect(str).toBe("hello world");
+  });
+});
+
+describe("createObjectGenerator", () => {
+  test("normal", () => {
+    const obj = createObjectGenerator({
+      type: "obj",
+      content: {
+        name: { type: "value", generateFn: () => "John" },
+        age: { type: "value", generateFn: () => 50 },
+        location: { type: "value", generateFn: () => "Taiwan" },
+      },
+    })();
+
+    expect(obj).toEqual({ name: "John", age: 50, location: "Taiwan" });
+  });
+});
+
+describe("createBoundedSeriesGenerator", () => {
+  test("normal", () => {
+    const upperLimit = 1.1;
+    const lowerLimit = 0.9;
+    const initValue = 100;
+    const count = 100;
+
+    const list = createBoundedSeriesGenerator({
+      type: "bounded_series",
+      upperLimit,
+      lowerLimit,
+      createInitValue: () => initValue,
+      count,
+    })();
+
+    for (let i = 0; i < count; i++) {
+      const value = list[i];
+      if (i === 0) {
+        const ratio = value / initValue;
+
+        expect(ratio).toBeLessThanOrEqual(upperLimit);
+        expect(ratio).toBeGreaterThanOrEqual(lowerLimit);
+
+        continue;
+      }
+
+      const prevValue = list[i - 1];
+
+      const ratio = value / prevValue;
+
+      expect(ratio).toBeLessThanOrEqual(upperLimit);
+      expect(ratio).toBeGreaterThanOrEqual(lowerLimit);
+    }
+  });
+});
+
+describe("createGeneratorByType", () => {
+  test("normal", () => {
+    const config = {
+      type: "obj",
+      content: {
+        name: { type: "value", generateFn: () => "John" },
+        age: { type: "value", generateFn: () => 50 },
+        locations: {
+          type: "arr",
+          item: { type: "value", generateFn: () => "Taiwan" },
+          len: 5,
+        },
+      },
+    };
+    const result = createGeneratorByType(config)();
+
+    expect(result).toEqual({
+      name: "John",
+      age: 50,
+      locations: ["Taiwan", "Taiwan", "Taiwan", "Taiwan", "Taiwan"],
+    });
+  });
+
+  test("with custom type match", () => {
+    const createIntValueConfig = (option) => createValueConfig(() => 50);
+    const createEmailValueConfig = (option) =>
+      createValueConfig(() => "xxx@example.com");
+
+    const customTypeMatch = (config) => {
+      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" },
+      },
+    };
+
+    const result = createGeneratorByType(config, customTypeMatch)();
+
+    expect(result).toEqual({
+      name: "John",
+      age: 50,
+      email: "xxx@example.com",
+    });
+  });
+});

package/src/index.mjs

@@ -0,0 +1,2 @@
+export * from "./create_config.mjs";
+export * from "./create_generator_fn.mjs";

package/{esm/type.js → src/type.mjs}

@@ -21,4 +21,3 @@
 /**
  * @typedef {{ type: 'bounded_series', upperLimit: number, lowerLimit: number, createInitValue: function, count: number }} BoundedSeriesConfig
  */
-"use strict";

package/esm/config_scheme.js

@@ -1,61 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.valueConfigScheme = exports.tupleConfigScheme = exports.selectionConfigScheme = exports.objConfigScheme = exports.boundedSeriesScheme = exports.arrayConfigScheme = void 0;
-var _zod = require("zod");
-var valueConfigScheme = exports.valueConfigScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^value$/, {
-    message: "invalid type string"
-  }),
-  generateFn: _zod.z["function"]()
-});
-var selectionConfigScheme = exports.selectionConfigScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^select$/, {
-    message: "invalid type string"
-  }),
-  items: _zod.z.any().array().nonempty({
-    message: "items can not be empty"
-  })
-});
-var arrayConfigScheme = exports.arrayConfigScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^arr$/, {
-    message: "invalid type string"
-  }),
-  item: _zod.z.object({}),
-  len: _zod.z.number().nonnegative()
-});
-var tupleConfigScheme = exports.tupleConfigScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^tuple$/, {
-    message: "invalid type string"
-  }),
-  configItems: _zod.z.any().array()
-});
-var objConfigScheme = exports.objConfigScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^obj$/, {
-    message: "invalid type string"
-  }),
-  content: _zod.z.object({})
-});
-var boundedSeriesScheme = exports.boundedSeriesScheme = _zod.z.object({
-  type: _zod.z.string().regex(/^bounded_series$/, {
-    message: "invalid type string"
-  }),
-  upperLimit: _zod.z.number().nonnegative(),
-  lowerLimit: _zod.z.number().nonnegative(),
-  createInitValue: _zod.z["function"]().args().returns(_zod.z.number()),
-  count: _zod.z.number().nonnegative()
-}).refine(function (_ref) {
-  var upperLimit = _ref.upperLimit,
-    lowerLimit = _ref.lowerLimit;
-  return upperLimit >= lowerLimit;
-}, {
-  message: "lowerLimit can not greater then upperLimit"
-}).refine(function (_ref2) {
-  var createInitValue = _ref2.createInitValue;
-  return typeof createInitValue() === "number";
-}, {
-  message: "createInitValue is not return number",
-  path: ["createInitValue"]
-});

package/esm/create_config.js

@@ -1,98 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createValueConfig = exports.createTupleConfig = exports.createSelectionConfig = exports.createObjectConfig = exports.createBoundedSeriesConfig = exports.createArrayConfig = void 0;
-var _faker = require("@faker-js/faker");
-var _config_scheme = require("./config_scheme.js");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * value
- * @param {function} generateFn - The function used to generate the value.
- * @return {ValueConfig} The configuration object with the type "value" and the provided generate function.
- */
-var createValueConfig = exports.createValueConfig = function createValueConfig(generateFn) {
-  var config = {
-    type: "value",
-    generateFn: generateFn
-  };
-  _config_scheme.valueConfigScheme.parse(config);
-  return config;
-};
-
-/**
- * selection
- * @param {Array} items - The array of items to choose from.
- * @return {SelectionConfig} The configuration object with the type "select" and the provided items.
- */
-var createSelectionConfig = exports.createSelectionConfig = function createSelectionConfig(items) {
-  var config = {
-    type: "select",
-    items: items
-  };
-  _config_scheme.selectionConfigScheme.parse(config);
-  return config;
-};
-
-/**
- * object
- * @param {object} content
- * @return {ObjectConfig}
- */
-var createObjectConfig = exports.createObjectConfig = function createObjectConfig(content) {
-  var config = {
-    type: "obj",
-    content: content
-  };
-  _config_scheme.objConfigScheme.parse(config);
-  return config;
-};
-
-/**
- * array
- * @param {object} item
- * @param {number} len
- * @return {ArrayConfig}
- */
-var createArrayConfig = exports.createArrayConfig = function createArrayConfig(item, len) {
-  var config = {
-    type: "arr",
-    item: item,
-    len: len
-  };
-  _config_scheme.arrayConfigScheme.parse(config);
-  return config;
-};
-
-/**
- * tuple
- * @param {Array} configItems
- * @return {TupleConfig}
- */
-var createTupleConfig = exports.createTupleConfig = function createTupleConfig(configItems) {
-  var config = {
-    type: "tuple",
-    configItems: configItems
-  };
-  _config_scheme.tupleConfigScheme.parse(config);
-  return config;
-};
-
-/**
- * bounded series
- * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
- * @return {BoundedSeriesConfig}
- */
-var createBoundedSeriesConfig = exports.createBoundedSeriesConfig = function createBoundedSeriesConfig(config) {
-  var newConfig = _objectSpread({
-    type: "bounded_series"
-  }, config);
-  _config_scheme.boundedSeriesScheme.parse(newConfig);
-  return newConfig;
-};

package/esm/create_generator_fn.js

@@ -1,161 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createValueGenerator = exports.createTupleGenerator = exports.createSelectionGenerator = exports.createObjectGenerator = exports.createGeneratorByType = exports.createBoundedSeriesGenerator = exports.createArrayGenerator = void 0;
-var _faker = require("@faker-js/faker");
-var _config_scheme = require("./config_scheme.js");
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-/**
- * value
- * @param {ValueConfig} config
- * @return {function}
- */
-var createValueGenerator = exports.createValueGenerator = function createValueGenerator(config) {
-  _config_scheme.valueConfigScheme.parse(config);
-  return config.generateFn;
-};
-
-/**
- * selection
- * @param {SelectionConfig} config
- * @return {function} The configuration object with the type "select" and the provided items.
- */
-var createSelectionGenerator = exports.createSelectionGenerator = function createSelectionGenerator(config) {
-  _config_scheme.selectionConfigScheme.parse(config);
-  var items = config.items;
-  return function () {
-    return items[_faker.faker.number["int"](items.length - 1)];
-  };
-};
-
-/**
- * object
- * @param {ObjectConfig} config
- * @param {(() => ValueConfig)=} customTypeMatch
- * @return {() => object}
- */
-var createObjectGenerator = exports.createObjectGenerator = function createObjectGenerator(config, customTypeMatch) {
-  _config_scheme.objConfigScheme.parse(config);
-  var keyWithFns = Object.entries(config.content).map(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      key = _ref2[0],
-      subConfig = _ref2[1];
-    return [key, createGeneratorByType(subConfig, customTypeMatch)];
-  });
-  return function () {
-    var result = {};
-    var _iterator = _createForOfIteratorHelper(keyWithFns),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _slicedToArray(_step.value, 2),
-          key = _step$value[0],
-          generateFn = _step$value[1];
-        result[key] = generateFn();
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    return result;
-  };
-};
-
-/**
- * array
- * @param {ArrayConfig} config
- * @param {(() => ValueConfig)=} customTypeMatch
- * @return {() => Array}
- */
-var createArrayGenerator = exports.createArrayGenerator = function createArrayGenerator(config, customTypeMatch) {
-  _config_scheme.arrayConfigScheme.parse(config);
-  var itemGeneratorFn = createGeneratorByType(config.item, customTypeMatch);
-  return function () {
-    var _config$len;
-    return Array.from({
-      length: (_config$len = config.len) !== null && _config$len !== void 0 ? _config$len : 0
-    }, itemGeneratorFn);
-  };
-};
-
-/**
- * tuple
- * @param {TupleConfig} config
- * @param {(() => ValueConfig)=} customTypeMatch
- * @return {() => Array}
- */
-var createTupleGenerator = exports.createTupleGenerator = function createTupleGenerator(config, customTypeMatch) {
-  _config_scheme.tupleConfigScheme.parse(config);
-  var itemsFns = config.configItems.map(function (configItem) {
-    return createGeneratorByType(configItem, customTypeMatch);
-  });
-  return function () {
-    return itemsFns.map(function (generateFn) {
-      return generateFn();
-    });
-  };
-};
-
-/**
- * bounded series
- * @param {BoundedSeriesConfig} config
- * @return {() => Array<number>}
- */
-var createBoundedSeriesGenerator = exports.createBoundedSeriesGenerator = function createBoundedSeriesGenerator(config) {
-  _config_scheme.boundedSeriesScheme.parse(config);
-  var upperLimit = config.upperLimit,
-    lowerLimit = config.lowerLimit,
-    createInitValue = config.createInitValue,
-    count = config.count;
-  return function () {
-    var value = createInitValue();
-    var boundedSeries = [];
-    for (var i = 0; i < count; i++) {
-      value = _faker.faker.number["float"]({
-        max: upperLimit,
-        min: lowerLimit
-      }) * value;
-      boundedSeries.push(value);
-    }
-    return boundedSeries;
-  };
-};
-
-/**
- *
- * @param {ValueConfig | SelectionConfig | ArrayConfig | ObjectConfig | TupleConfig | BoundedSeriesConfig} config
- * @param {(() => ValueConfig)=} customTypeMatch
- * @return {function}
- */
-var createGeneratorByType = exports.createGeneratorByType = function createGeneratorByType(config, customTypeMatch) {
-  switch (config.type) {
-    case "obj":
-      return createObjectGenerator(config, customTypeMatch);
-    case "arr":
-      return createArrayGenerator(config, customTypeMatch);
-    case "select":
-      return createSelectionGenerator(config);
-    case "tuple":
-      return createTupleGenerator(config, customTypeMatch);
-    case "value":
-      return createValueGenerator(config);
-    case "bounded_series":
-      return createBoundedSeriesGenerator(config);
-    default:
-      {
-        if (customTypeMatch) {
-          return createValueGenerator(customTypeMatch(config));
-        }
-        throw Error("config type \"".concat(config.type, "\" is not supported"));
-      }
-  }
-};

package/esm/index.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _create_config = require("./create_config");
-Object.keys(_create_config).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _create_config[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _create_config[key];
-    }
-  });
-});
-var _create_generator_fn = require("./create_generator_fn");
-Object.keys(_create_generator_fn).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _create_generator_fn[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _create_generator_fn[key];
-    }
-  });
-});

package/src/index.js

@@ -1,2 +0,0 @@
-export * from "./create_config";
-export * from "./create_generator_fn";