struct-fakerator 1.2.6 → 2.0.1

package/esm/create_config.mjs

@@ -1,97 +0,0 @@
-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/esm/create_config.test.mjs

@@ -1,72 +0,0 @@
-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/esm/create_generator_fn.d.ts

@@ -1,35 +0,0 @@
-declare function createValueGenerator<T>(config: ValueConfig<T>): () => T;
-
-declare function createSelectionGenerator<T>(
-  config: SelectionConfig<T>,
-): () => T;
-
-declare function createObjectGenerator(
-  config: ObjectConfig,
-  customTypeMatch?: (config: object) => ValueConfig<unknown>,
-): () => Record<string, unknown>;
-
-declare function createArrayGenerator(
-  config: ArrayConfig,
-  customTypeMatch?: (config: object) => ValueConfig<unknown>,
-): () => unknown[];
-
-declare function createTupleGenerator(
-  config: TupleConfig,
-  customTypeMatch?: (config: object) => ValueConfig<unknown>,
-): () => unknown[];
-
-declare function createBoundedSeriesGenerator(
-  config: BoundedSeriesConfig,
-): () => number[];
-
-declare function createGeneratorByType(
-  config:
-    | ValueConfig<unknown>
-    | SelectionConfig<unknown>
-    | ArrayConfig
-    | ObjectConfig
-    | TupleConfig
-    | BoundedSeriesConfig,
-  customTypeMatch?: (config: object) => ValueConfig<unknown>,
-): () => unknown;

package/esm/create_generator_fn.mjs

@@ -1,140 +0,0 @@
-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/esm/create_generator_fn.test.mjs

@@ -1,192 +0,0 @@
-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/esm/index.mjs

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

package/esm/type.mjs

@@ -1,23 +0,0 @@
-/**
- * @typedef {{ type: 'value', generateFn: Function}} ValueConfig
- */
-
-/**
- * @typedef {{ type: 'select', items: Array }} SelectionConfig
- */
-
-/**
- * @typedef {{ type: 'arr', item: Object, len: number }} ArrayConfig
- */
-
-/**
- * @typedef {{ type: 'tuple', configItems: Array }} TupleConfig
- */
-
-/**
- * @typedef {{ type: 'obj', content: Object }} ObjectConfig
- */
-
-/**
- * @typedef {{ type: 'bounded_series', upperLimit: number, lowerLimit: number, createInitValue: function, count: number }} BoundedSeriesConfig
- */

package/jsconfig.json

@@ -1,20 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es6",
-        "module": "CommonJS",
-        "baseUrl": ".",
-        "paths": {
-            "*": [
-                "node_modules/*"
-            ]
-        },
-        "checkJs": true,
-    },
-    "include": [
-        "./**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "**/node_modules/*"
-    ]
-}

package/src/config_scheme.mjs

@@ -1,45 +0,0 @@
-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"],
-  });