struct-fakerator 2.8.9 → 3.0.0

package/src/create_config.ts

@@ -1,170 +0,0 @@
-import {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  valueConfigScheme,
-} from "./config_scheme";
-import type {
-  ArrayConfig,
-  BoundedSeriesConfig,
-  ObjectConfig,
-  ObjectConfigWithFn,
-  Result,
-  SelectionConfig,
-  TupleConfig,
-  TupleItems,
-  ValueConfig,
-} 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
- * @param {function} transformer
- * @return {ObjectConfig}
- */
-export function createObjectConfig<T extends object>(
-  content: T,
-): ObjectConfig<T>;
-export function createObjectConfig<T extends object, R>(
-  content: T,
-  transformer: (v: { [K in keyof T]: Result<T[K]> }) => R,
-): ObjectConfigWithFn<T, R>;
-export function createObjectConfig<T extends object, R>(
-  content: T,
-  transformer?: (v: { [K in keyof T]: Result<T[K]> }) => R,
-) {
-  if (transformer) {
-    const config: ObjectConfigWithFn<T, R> = {
-      type: "obj",
-      content,
-      transformer,
-    };
-    objConfigScheme.parse(config);
-    return config;
-  }
-
-  const config: ObjectConfig<T> = { type: "obj", content };
-
-  objConfigScheme.parse(config);
-
-  return config;
-}
-
-/**
- * array
- * @param {object} item
- * @param {number} len
- * @param {function} next
- * @return {ArrayConfig}
- */
-export const createArrayConfig = <T>(
-  item: T,
-  len: number,
-  next?: (prev: Result<T>, current: Result<T>) => Result<T>,
-): ArrayConfig<T> => {
-  const config: ArrayConfig<T> = { type: "arr", item, len, next };
-
-  arrayConfigScheme.parse(config);
-
-  return config;
-};
-
-/**
- * tuple
- * @param {Array} configItems
- * @return {TupleConfig}
- */
-interface CreateTupleConfig {
-  <A, B, C, D, E, F, G, H, I, J>(
-    configItems: [A, B, C, D, E, F, G, H, I, J],
-  ): TupleConfig<A, B, C, D, E, F, G, H, I, J>;
-  <A, B, C, D, E, F, G, H, I>(
-    configItems: [A, B, C, D, E, F, G, H, I],
-  ): TupleConfig<A, B, C, D, E, F, G, H, I>;
-  <A, B, C, D, E, F, G, H>(
-    configItems: [A, B, C, D, E, F, G, H],
-  ): TupleConfig<A, B, C, D, E, F, G, H>;
-  <A, B, C, D, E, F, G>(
-    configItems: [A, B, C, D, E, F, G],
-  ): TupleConfig<A, B, C, D, E, F, G>;
-  <A, B, C, D, E, F>(
-    configItems: [A, B, C, D, E, F],
-  ): TupleConfig<A, B, C, D, E, F>;
-  <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,
-  C,
-  D,
-  E,
-  F,
-  G,
-  H,
-  I,
-  J,
->(
-  configItems: TupleItems<A, B, C, D, E, F, G, H, I, J>,
-) => {
-  const config: TupleConfig<A, B, C, D, E, F, G, H, I, J> = {
-    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.ts

@@ -1,229 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-  createArrayConfig,
-  createObjectConfig,
-  createTupleConfig,
-  createValueConfig,
-} from "./create_config";
-import {
-  createArrayGenerator,
-  createBoundedSeriesGenerator,
-  createGeneratorByType,
-  createObjectGenerator,
-  createSelectionGenerator,
-  createTupleGenerator,
-  createValueGenerator,
-} from "./create_generator_fn";
-import type { ObjectConfig } from "./type";
-
-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 },
-    ]);
-  });
-  test("with next function", () => {
-    const list = createArrayGenerator(
-      createArrayConfig(
-        createValueConfig(() => 100),
-        5,
-        (prev) => prev + 1,
-      ),
-    )();
-
-    expect(list).toEqual([101, 102, 103, 104, 105]);
-  });
-});
-
-describe("createTupleGenerator", () => {
-  test("normal", () => {
-    const tuple = createTupleGenerator(
-      createTupleConfig([
-        createValueConfig(() => 225),
-        createValueConfig(() => "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" });
-  });
-
-  test("transformer function", () => {
-    const obj = createObjectGenerator(
-      createObjectConfig(
-        {
-          name: createValueConfig(() => "John"),
-          age: createValueConfig(() => 50),
-          location: createValueConfig(() => "Taiwan"),
-        },
-        ({ age }) => age + 50,
-      ),
-    )();
-
-    expect(obj).toEqual(100);
-  });
-});
-
-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 = createObjectConfig({
-      name: createValueConfig(() => "John"),
-      age: createValueConfig(() => 50),
-      locations: createArrayConfig(
-        createValueConfig(() => "Taiwan"),
-        5,
-      ),
-    });
-    const result = createGeneratorByType(config)();
-
-    expect(result).toEqual({
-      name: "John",
-      age: 50,
-      locations: ["Taiwan", "Taiwan", "Taiwan", "Taiwan", "Taiwan"],
-    });
-  });
-
-  test("test error config", () => {
-    const config = {
-      type: "obj",
-      content: {
-        name: {
-          type: "123",
-          generateFn: "John",
-        },
-      },
-    } as ObjectConfig<unknown>;
-
-    expect(() => createGeneratorByType(config)).toThrowError();
-  });
-
-  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 = createObjectConfig({
-      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",
-    });
-  });
-});