struct-fakerator 1.2.6 → 2.0.1

package/package.json

@@ -1,34 +1,29 @@
 {
   "name": "struct-fakerator",
-  "version": "1.2.6",
+  "version": "2.0.1",
   "description": "",
-  "main": "cjs/index.js",
-  "module": "esm/index.mjs",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.mjs"
-    }
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.js"
   },
-  "type": "module",
   "scripts": {
-    "start": "node src/index.js",
-    "dev": "node",
-    "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",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
     "test": "vitest src"
   },
   "keywords": [],
   "author": "FizzyElt",
-  "homepage": "https://github.com/FizzyElt/struct-fakerator",
+  "homepage": "https://github.com/FizzyElt/fakerator",
   "license": "ISC",
   "devDependencies": {
-    "@babel/cli": "^7.24.7",
-    "@babel/core": "^7.24.7",
-    "@babel/preset-env": "^7.24.7",
     "@biomejs/biome": "^1.8.3",
     "@faker-js/faker": "^8.4.1",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3",
     "vitest": "^1.6.0"
   },
   "dependencies": {

package/src/{create_config.test.mjs → create_config.test.ts}

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

package/src/create_config.ts

@@ -0,0 +1,131 @@
+import {
+  valueConfigScheme,
+  arrayConfigScheme,
+  selectionConfigScheme,
+  tupleConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+} from "./config_scheme";
+import type {
+  ValueConfig,
+  SelectionConfig,
+  ObjectConfig,
+  ArrayConfig,
+  TupleConfig,
+  BoundedSeriesConfig,
+} from "./type";
+
+/**
+ * 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 = <T>(generateFn: () => T): ValueConfig<T> => {
+  const config: ValueConfig<T> = {
+    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 = <T>(items: T[]): SelectionConfig<T> => {
+  const config: SelectionConfig<T> = { type: "select", items };
+
+  selectionConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * object
+ * @param {object} content
+ * @return {ObjectConfig}
+ */
+export const createObjectConfig = <T extends object>(
+  content: T,
+): ObjectConfig<T> => {
+  const config: ObjectConfig<T> = { type: "obj", content };
+
+  objConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * array
+ * @param {object} item
+ * @param {number} len
+ * @return {ArrayConfig}
+ */
+export const createArrayConfig = <T>(item: T, len: number): ArrayConfig<T> => {
+  const config: ArrayConfig<T> = { type: "arr", item, len };
+
+  arrayConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * tuple
+ * @param {Array} configItems
+ * @return {TupleConfig}
+ */
+interface CreateTupleConfig {
+  <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 const createTupleConfig: CreateTupleConfig = <
+  A,
+  B = undefined,
+  C = undefined,
+  D = undefined,
+  E = undefined,
+>(
+  configItems: E extends undefined
+    ? D extends undefined
+      ? C extends undefined
+        ? B extends undefined
+          ? [A]
+          : [A, B]
+        : [A, B, C]
+      : [A, B, C, D]
+    : [A, B, C, D, E],
+) => {
+  const config: TupleConfig<A, B, C, D, E> = {
+    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: Omit<BoundedSeriesConfig, "type">,
+): BoundedSeriesConfig => {
+  const newConfig: BoundedSeriesConfig = {
+    type: "bounded_series",
+    ...config,
+  };
+
+  boundedSeriesScheme.parse(newConfig);
+
+  return newConfig;
+};

package/src/{create_generator_fn.test.mjs → create_generator_fn.test.ts}

@@ -1,5 +1,4 @@
 import { describe, test, expect } from "vitest";
-import { ZodError } from "zod";
 import {
   createValueGenerator,
   createSelectionGenerator,
@@ -8,8 +7,13 @@ import {
   createObjectGenerator,
   createBoundedSeriesGenerator,
   createGeneratorByType,
-} from "./create_generator_fn.mjs";
-import { createValueConfig } from "./create_config.mjs";
+} from "./create_generator_fn";
+import {
+  createValueConfig,
+  createTupleConfig,
+  createObjectConfig,
+  createArrayConfig,
+} from "./create_config";
 
 describe("createValueGenerator", () => {
   test("normal", () => {
@@ -67,13 +71,12 @@ describe("createArrayGenerator", () => {
 
 describe("createTupleGenerator", () => {
   test("normal", () => {
-    const tuple = createTupleGenerator({
-      type: "tuple",
-      configItems: [
-        { type: "value", generateFn: () => 225 },
-        { type: "value", generateFn: () => "hello world" },
-      ],
-    })();
+    const tuple = createTupleGenerator(
+      createTupleConfig([
+        createValueConfig(() => 225),
+        createValueConfig(() => "hello world"),
+      ]),
+    )();
 
     expect(tuple.length).toBe(2);
     const [num, str] = tuple;
@@ -135,18 +138,14 @@ describe("createBoundedSeriesGenerator", () => {
 
 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 config = createObjectConfig({
+      name: createValueConfig(() => "John"),
+      age: createValueConfig(() => 50),
+      locations: createArrayConfig(
+        createValueConfig(() => "Taiwan"),
+        5,
+      ),
+    });
     const result = createGeneratorByType(config)();
 
     expect(result).toEqual({
@@ -172,14 +171,11 @@ describe("createGeneratorByType", () => {
       throw Error("error");
     };
 
-    const config = {
-      type: "obj",
-      content: {
-        name: { type: "value", generateFn: () => "John" },
-        age: { type: "int" },
-        email: { type: "email" },
-      },
-    };
+    const config = createObjectConfig({
+      name: { type: "value", generateFn: () => "John" },
+      age: { type: "int" },
+      email: { type: "email" },
+    });
 
     const result = createGeneratorByType(config, customTypeMatch)();
 

package/src/create_generator_fn.ts

@@ -0,0 +1,160 @@
+import { faker } from "@faker-js/faker";
+
+import {
+  valueConfigScheme,
+  selectionConfigScheme,
+  arrayConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+  tupleConfigScheme,
+} from "./config_scheme";
+import type {
+  ValueConfig,
+  SelectionConfig,
+  ObjectConfig,
+  TupleConfig,
+  ArrayConfig,
+  Result,
+  BoundedSeriesConfig,
+} from "./type";
+import { createObjectConfig, createValueConfig } from "./create_config";
+
+type AllConfig<T> =
+  | ValueConfig<T>
+  | SelectionConfig<T>
+  | ArrayConfig<T>
+  | ObjectConfig<T>
+  | TupleConfig<T>
+  | TupleConfig<T, T>
+  | TupleConfig<T, T, T>
+  | TupleConfig<T, T, T, T>
+  | TupleConfig<T, T, T, T, T>
+  | BoundedSeriesConfig;
+
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+export const createValueGenerator = <R = unknown>(config: any): (() => R) => {
+  valueConfigScheme.parse(config);
+
+  return config.generateFn as () => R;
+};
+
+export const createSelectionGenerator = <T extends SelectionConfig<unknown>>(
+  config: T,
+): (() => Result<T>) => {
+  selectionConfigScheme.parse(config);
+
+  const { items } = config;
+
+  return (() => items[faker.number.int(items.length - 1)]) as () => Result<T>;
+};
+
+export const createObjectGenerator = <T extends ObjectConfig<unknown>>(
+  config: T,
+  customTypeMatch?: (config: unknown) => ValueConfig<unknown>,
+): (() => Result<T>) => {
+  objConfigScheme.parse(config);
+
+  const keyWithFns: [string, () => Result<AllConfig<unknown>>][] =
+    Object.entries(config.content as object).map(([key, subConfig]) => [
+      key,
+      createGeneratorByType(subConfig, customTypeMatch),
+    ]);
+
+  return () => {
+    const result: Record<string, unknown> = {};
+    for (const [key, generateFn] of keyWithFns) {
+      result[key] = generateFn();
+    }
+    return result as Result<T>;
+  };
+};
+
+export const createArrayGenerator = <T extends ArrayConfig<unknown>>(
+  config: T,
+  customTypeMatch?: (config: unknown) => ValueConfig<unknown>,
+): (() => Result<T>) => {
+  arrayConfigScheme.parse(config);
+
+  const itemGeneratorFn = createGeneratorByType(
+    config.item as AllConfig<unknown>,
+    customTypeMatch,
+  );
+
+  return () =>
+    Array.from({ length: config.len ?? 0 }, itemGeneratorFn) as Result<T>;
+};
+
+export const createTupleGenerator = <
+  T extends
+    | TupleConfig<unknown, unknown, unknown, unknown, unknown>
+    | TupleConfig<unknown, unknown, unknown, unknown>
+    | TupleConfig<unknown, unknown, unknown>
+    | TupleConfig<unknown, unknown>
+    | TupleConfig<unknown>,
+>(
+  config: T,
+  customTypeMatch?: (config: unknown) => ValueConfig<unknown>,
+): (() => Result<T>) => {
+  tupleConfigScheme.parse(config);
+
+  const itemsFns = config.configItems.map((configItem) =>
+    createGeneratorByType(configItem as AllConfig<unknown>, customTypeMatch),
+  );
+
+  return () => itemsFns.map((generateFn) => generateFn()) as Result<T>;
+};
+
+export const createBoundedSeriesGenerator = <T extends BoundedSeriesConfig>(
+  config: T,
+): (() => Result<T>) => {
+  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 as Result<T>;
+  };
+};
+
+export const createGeneratorByType = <T extends AllConfig<unknown>>(
+  config: T,
+  customTypeMatch?: (config: unknown) => ValueConfig<unknown>,
+): (() => Result<T>) => {
+  switch (config.type) {
+    case "obj":
+      return createObjectGenerator(config, customTypeMatch) as () => Result<T>;
+    case "arr":
+      return createArrayGenerator(config, customTypeMatch) as () => Result<T>;
+    case "tuple":
+      return createTupleGenerator(config, customTypeMatch) as () => Result<T>;
+    case "select":
+      return createSelectionGenerator(config) as () => Result<T>;
+    case "value":
+      return createValueGenerator(config);
+    case "bounded_series":
+      return createBoundedSeriesGenerator(config) as () => Result<T>;
+    default: {
+      if (customTypeMatch) {
+        return createValueGenerator(customTypeMatch(config));
+      }
+      throw Error(`config type "${config}" is not supported`);
+    }
+  }
+};
+
+const config = createObjectConfig({
+  a: createObjectConfig({
+    b: createValueConfig(() => 1),
+  }),
+});
+
+const fn = createGeneratorByType(config);

package/src/index.ts

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

package/src/type.ts

@@ -0,0 +1,69 @@
+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;
+};
+
+export type ObjectConfig<T> = {
+  type: "obj";
+  content: T;
+};
+
+export type TupleConfig<
+  A,
+  B = undefined,
+  C = undefined,
+  D = undefined,
+  E = undefined,
+> = {
+  type: "tuple";
+  configItems: E extends undefined
+    ? D extends undefined
+      ? C extends undefined
+        ? B extends undefined
+          ? [A]
+          : [A, B]
+        : [A, B, C]
+      : [A, B, C, D]
+    : [A, B, C, D, E];
+};
+
+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 ObjectConfig<infer O>
+          ? { [K in keyof O]: Result<O[K]> }
+          : T extends TupleConfig<infer A, infer B, infer C, infer D, infer E>
+            ? E extends undefined
+              ? D extends undefined
+                ? C extends undefined
+                  ? B extends undefined
+                    ? [Result<A>]
+                    : [Result<A>, Result<B>]
+                  : [Result<A>, Result<B>, Result<C>]
+                : [Result<A>, Result<B>, Result<C>, Result<D>]
+              : [Result<A>, Result<B>, Result<C>, Result<D>, Result<E>]
+            : never;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "ESNext",
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
+    "declaration": true,
+    "outDir": "./dist/lib/es6",
+    "moduleResolution": "node"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}

package/cjs/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/cjs/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.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; }
-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;
-};