struct-fakerator 2.7.9 → 2.9.9

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",
-    });
-  });
-});

package/src/create_generator_fn.ts

@@ -1,343 +0,0 @@
-import { faker } from "@faker-js/faker";
-
-import {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  valueConfigScheme,
-} from "./config_scheme";
-import type {
-  ArrayConfig,
-  BoundedSeriesConfig,
-  ObjectConfig,
-  ObjectConfigWithFn,
-  Result,
-  SelectionConfig,
-  TupleConfig,
-  ValueConfig,
-} from "./type";
-
-type AllConfig<T> =
-  | ValueConfig<T>
-  | SelectionConfig<T>
-  | ArrayConfig<T>
-  | ObjectConfig<T>
-  | ObjectConfigWithFn<T, unknown>
-  | TupleConfig<T>
-  | TupleConfig<T, T>
-  | TupleConfig<T, T, T>
-  | TupleConfig<T, T, T, T>
-  | TupleConfig<T, T, T, T, T>
-  | TupleConfig<T, T, T, T, T, T>
-  | TupleConfig<T, T, T, T, T, T, T>
-  | TupleConfig<T, T, T, T, T, T, T, T>
-  | TupleConfig<T, T, T, T, T, T, T, T, T>
-  | TupleConfig<T, T, T, T, T, T, T, T, T, T>
-  | BoundedSeriesConfig;
-
-const _createValueGenerator = <R = unknown>(
-  config: ValueConfig<unknown>,
-  path: string,
-): (() => R) => {
-  try {
-    valueConfigScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.value\n${err}`);
-  }
-
-  return config.generateFn as () => R;
-};
-export const createValueGenerator = <R = unknown>(
-  config: ValueConfig<unknown>,
-): (() => R) => _createValueGenerator(config, "*");
-
-// =================== generator fn ====================
-
-const _createSelectionGenerator = <T extends SelectionConfig<unknown>>(
-  config: T,
-  path: string,
-): (() => Result<T>) => {
-  try {
-    selectionConfigScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.select\n${err}`);
-  }
-
-  const { items } = config;
-
-  return (() => items[faker.number.int(items.length - 1)]) as () => Result<T>;
-};
-
-export const createSelectionGenerator = <T extends SelectionConfig<unknown>>(
-  config: T,
-): (() => Result<T>) => _createSelectionGenerator(config, "*");
-
-// =================== generator fn ====================
-
-const _createObjectGenerator = <
-  T extends ObjectConfig<unknown> | ObjectConfigWithFn<unknown, unknown>,
->(
-  config: T,
-  path: string,
-  customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>,
-): (() => Result<T>) => {
-  try {
-    objConfigScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.obj\n ${err}`);
-  }
-
-  const keyWithFns: [string, () => Result<AllConfig<unknown>>][] =
-    Object.entries(config.content as object).map(([key, subConfig]) => [
-      key,
-      _createGeneratorByType(subConfig, `${path}.obj[${key}]`, customTypeMatch),
-    ]);
-
-  return () => {
-    const result: Record<string, unknown> = {};
-    for (const [key, generateFn] of keyWithFns) {
-      result[key] = generateFn();
-    }
-
-    if ("transformer" in config && typeof config.transformer === "function") {
-      return config.transformer(result) as Result<T>;
-    }
-    return result as Result<T>;
-  };
-};
-export const createObjectGenerator = <T extends ObjectConfig<unknown>>(
-  config: T,
-  customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>,
-): (() => Result<T>) => _createObjectGenerator(config, "*", customTypeMatch);
-
-// =================== generator fn ====================
-
-const _createArrayGenerator = <T extends ArrayConfig<unknown>>(
-  config: T,
-  path: string,
-  customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>,
-): (() => Result<T>) => {
-  try {
-    arrayConfigScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.arr\n ${err}`);
-  }
-
-  const itemGeneratorFn = _createGeneratorByType(
-    config.item as AllConfig<unknown>,
-    `${path}.arr`,
-    customTypeMatch,
-  ) as () => Result<T>;
-
-  if (config.next) {
-    const next: (prev: Result<T>, current: Result<T>) => Result<T> =
-      config.next;
-    return () => {
-      let prev = itemGeneratorFn();
-      const result = [];
-      for (let i = 0; i < config.len; i++) {
-        const nextValue = next(prev, itemGeneratorFn());
-        result.push(nextValue);
-        prev = nextValue;
-      }
-
-      return result as Result<T>;
-    };
-  }
-
-  return () =>
-    Array.from({ length: config.len ?? 0 }, itemGeneratorFn) as Result<T>;
-};
-export const createArrayGenerator = <T extends ArrayConfig<unknown>>(
-  config: T,
-  customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>,
-): (() => Result<T>) => _createArrayGenerator(config, "*", customTypeMatch);
-
-// =================== generator fn ====================
-
-const _createTupleGenerator = <
-  T extends
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown>
-    | TupleConfig<unknown, unknown, unknown, unknown, unknown>
-    | TupleConfig<unknown, unknown, unknown, unknown>
-    | TupleConfig<unknown, unknown, unknown>
-    | TupleConfig<unknown, unknown>
-    | TupleConfig<unknown>,
->(
-  config: T,
-  path: string,
-  customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>,
-): (() => Result<T>) => {
-  try {
-    tupleConfigScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.tuple\n ${err}`);
-  }
-
-  const itemsFns = config.configItems.map((configItem, index) =>
-    _createGeneratorByType(
-      configItem as AllConfig<unknown>,
-      `${path}.tuple[${index}]`,
-      customTypeMatch,
-    ),
-  );
-
-  return () => itemsFns.map((generateFn) => generateFn()) as Result<T>;
-};
-export const createTupleGenerator = <
-  T extends
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown
-      >
-    | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown>
-    | 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, path: string) => ValueConfig<unknown>,
-): (() => Result<T>) => _createTupleGenerator(config, "*", customTypeMatch);
-
-// =================== generator fn ====================
-
-const _createBoundedSeriesGenerator = <T extends BoundedSeriesConfig>(
-  config: T,
-  path: string,
-): (() => Result<T>) => {
-  try {
-    boundedSeriesScheme.parse(config);
-  } catch (err) {
-    throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
-  }
-
-  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 createBoundedSeriesGenerator = <T extends BoundedSeriesConfig>(
-  config: T,
-): (() => Result<T>) => _createBoundedSeriesGenerator(config, "*");
-
-// =================== generator fn ====================
-
-const _createGeneratorByType = <T extends AllConfig<unknown>>(
-  config: T,
-  path: string,
-  customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>,
-): (() => Result<T>) => {
-  switch (config.type) {
-    case "obj":
-      return _createObjectGenerator(
-        config,
-        path,
-        customTypeMatch,
-      ) as () => Result<T>;
-    case "arr":
-      return _createArrayGenerator(
-        config,
-        path,
-        customTypeMatch,
-      ) as () => Result<T>;
-    case "tuple":
-      return _createTupleGenerator(
-        config,
-        path,
-        customTypeMatch,
-      ) as () => Result<T>;
-    case "select":
-      return _createSelectionGenerator(config, path) as () => Result<T>;
-    case "value":
-      return _createValueGenerator(config, path);
-    case "bounded_series":
-      return _createBoundedSeriesGenerator(config, path) as () => Result<T>;
-    default: {
-      if (customTypeMatch) {
-        return createValueGenerator(customTypeMatch(config, path));
-      }
-      throw new Error(`path: ${path}\nconfig type is not supported`);
-    }
-  }
-};
-
-export const createGeneratorByType = <T extends AllConfig<unknown>>(
-  config: T,
-  customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>,
-): (() => Result<T>) => _createGeneratorByType(config, "*", customTypeMatch);

package/src/generator_fn.ts

@@ -1,9 +0,0 @@
-export {
-  createGeneratorByType as genFn,
-  createArrayGenerator as genArrayFn,
-  createBoundedSeriesGenerator as genBoundedSeriesFn,
-  createObjectGenerator as genObjectFn,
-  createSelectionGenerator as genSelectFn,
-  createTupleGenerator as genTupleFn,
-  createValueGenerator as genValueFn,
-} from "./create_generator_fn";

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./create_config";
-export * from "./create_generator_fn";
-export * from "./type";
-export * as StructConfig from "./config";
-export * as StructGenerator from "./generator_fn";