typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/internal/application_schema.ts

@@ -1,165 +0,0 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_alias } from "./application_alias";
-import { application_array } from "./application_array";
-import { application_boolean } from "./application_boolean";
-import { application_constant } from "./application_constant";
-import { application_escaped } from "./application_escaped";
-import { application_native } from "./application_native";
-import { application_number } from "./application_number";
-import { application_object } from "./application_object";
-import { application_string } from "./application_string";
-import { application_templates } from "./application_templates";
-import { application_tuple } from "./application_tuple";
-
-/**
- * @internal
- */
-export const application_schema =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: IJsonComponents) =>
-  (meta: Metadata) =>
-  (
-    attribute: IJsonSchema.IAttribute,
-  ): BlockNever extends true ? IJsonSchema | null : IJsonSchema => {
-    // VULNERABLE CASE
-    if (meta.any === true)
-      return {
-        ...attribute,
-        type: undefined,
-      };
-    else if (meta.nullable && meta.empty())
-      return { type: "null", ...attribute };
-
-    //----
-    // GATHER UNION SCHEMAS
-    //----
-    const union: IJsonSchema[] = [];
-    if (meta.nullable && options.purpose !== "swagger")
-      union.push({
-        ...attribute,
-        type: "null",
-      });
-
-    const insert =
-      meta.nullable && options.purpose === "swagger"
-        ? (schema: IJsonSchema) =>
-            union.push({
-              ...schema,
-              nullable: (schema as IJsonSchema.ISignificant<any>).type
-                ? true
-                : undefined,
-            } as IJsonSchema)
-        : (schema: IJsonSchema) => union.push(schema);
-
-    // toJSON() METHOD
-    if (meta.escaped !== null)
-      union.push(
-        ...application_escaped(options)(blockNever)(components)(meta.escaped),
-      );
-
-    // ATOMIC TYPES
-    if (meta.templates.length && AtomicPredicator.template(meta))
-      insert(application_templates(meta)(attribute));
-    for (const constant of meta.constants)
-      if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
-      else if (
-        (constant.type === "string" && meta.templates.length) ||
-        AtomicPredicator.constant(meta)(constant.type) === false
-      )
-        continue;
-      else insert(application_constant(constant)(attribute));
-    for (const a of meta.atomics)
-      if (a.type === "bigint") throw new TypeError(NO_BIGINT);
-      else if (a.type === "boolean")
-        application_boolean(options)(a)(attribute).forEach(insert);
-      else if (a.type === "number")
-        application_number(options)(a)(attribute).forEach(insert);
-      else if (a.type === "string")
-        application_string(options)(meta)(a)(attribute).forEach(insert);
-
-    // ARRAY
-    for (const array of meta.arrays)
-      application_array(options)(components)(array).forEach(insert);
-
-    // TUPLE
-    for (const tuple of meta.tuples)
-      insert(application_tuple(options)(components)(tuple)(attribute));
-
-    // NATIVES
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native)) {
-        const type: string = native.toLowerCase();
-        if (meta.atomics.some((a) => a.type === type)) continue;
-        else if (type === "bigint") throw new TypeError(NO_BIGINT);
-        else if (type === "boolean")
-          insert(
-            application_boolean(options)(
-              MetadataAtomic.create({
-                type: "boolean",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-        else if (type === "number")
-          insert(
-            application_number(options)(
-              MetadataAtomic.create({
-                type: "number",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-        else if (type === "string")
-          insert(
-            application_string(options)(meta)(
-              MetadataAtomic.create({
-                type: "string",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-      } else
-        insert(application_native(options)(components)(native)(meta.nullable));
-    if (meta.sets.length)
-      insert(application_native(options)(components)(`Set`)(meta.nullable));
-    if (meta.maps.length)
-      insert(application_native(options)(components)(`Map`)(meta.nullable));
-
-    // OBJECT
-    for (const obj of meta.objects)
-      insert(application_object(options)(components)(obj)(meta.nullable));
-
-    // ALIASES
-    for (const alias of meta.aliases)
-      insert(
-        application_alias(options)(blockNever)(components)(alias)(
-          meta.nullable,
-        ),
-      );
-
-    //----
-    // RETURNS
-    //----
-    if (union.length === 0)
-      return blockNever === true
-        ? null!
-        : {
-            ...attribute,
-            type: undefined,
-          };
-    else if (union.length === 1)
-      return {
-        ...union[0]!,
-        ...attribute,
-      };
-    return { oneOf: union, ...attribute };
-  };
-
-const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_tuple.ts

@@ -1,54 +0,0 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
-
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_tuple =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (components: IJsonComponents) =>
-  (tuple: MetadataTuple) =>
-  (
-    attribute: IJsonSchema.IAttribute,
-  ): IJsonSchema.ITuple | IJsonSchema.IArray => {
-    const schema: IJsonSchema.ITuple = {
-      type: "array",
-      items: tuple.type.elements.map((meta, i) =>
-        application_schema(options)(false)(components)(meta.rest ?? meta)({
-          "x-typia-rest":
-            i === tuple.type.elements.length - 1 && meta.rest !== null,
-          "x-typia-required": meta.required,
-          "x-typia-optional": meta.optional,
-        }),
-      ),
-      ...attribute,
-      minItems: !!tuple.type.elements.at(-1)?.rest
-        ? tuple.type.elements.length - 1
-        : tuple.type.elements.filter((x) => !x.optional).length,
-      maxItems: !!tuple.type.elements.at(-1)?.rest
-        ? undefined
-        : tuple.type.elements.length,
-    };
-    if (options.purpose === "ajv")
-      if (tuple.type.elements.length === 0) return schema;
-      else if (!tuple.type.elements.at(-1)?.rest) return schema;
-
-    const wrapper: IJsonSchema.IArray = {
-      ...schema,
-      items: application_schema(options)(false)(components)(
-        tuple.type.elements.reduce(
-          (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
-          Metadata.initialize(),
-        ),
-      )(tuple.type.recursive ? {} : attribute),
-      "x-typia-tuple": schema,
-      minItems: schema.minItems,
-      maxItems: schema.maxItems,
-    };
-    return wrapper;
-  };

package/src/schemas/json/IJsonComponents.ts

@@ -1,19 +0,0 @@
-import { IJsonSchema } from "./IJsonSchema";
-
-export interface IJsonComponents {
-  schemas?: undefined | Record<string, IJsonComponents.IAlias>;
-}
-export namespace IJsonComponents {
-  /**
-   * @deprecated
-   */
-  export interface IObject extends IJsonSchema.IObject {
-    $id?: undefined | string;
-  }
-
-  export type IAlias = IJsonSchema & IIdentified;
-  interface IIdentified {
-    $id?: undefined | string;
-    $recursiveAnchor?: undefined | boolean;
-  }
-}

package/src/schemas/json/IJsonSchema.ts

@@ -1,122 +0,0 @@
-import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTypeTag } from "../metadata/IMetadataTypeTag";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { Type } from "../../tags/Type";
-
-export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
-export namespace IJsonSchema {
-  export type Known =
-    | IEnumeration<"boolean">
-    | IEnumeration<"number">
-    | IEnumeration<"string">
-    | IBoolean
-    | IInteger
-    | INumber
-    | IString
-    | IArray
-    | ITuple
-    | IObject
-    | IReference
-    | INullOnly
-    | IOneOf;
-
-  export interface IUnknown extends IAttribute {
-    type?: undefined | undefined;
-  }
-
-  /* -----------------------------------------------------------
-        ATOMICS
-    ----------------------------------------------------------- */
-  export interface IEnumeration<
-    Literal extends Exclude<Atomic.Literal, "bigint">,
-  > extends Omit<IAtomic<Literal>, "x-typia-typeTags"> {
-    enum: Array<Atomic.Mapper[Literal]>;
-  }
-  export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
-    extends ISignificant<Literal> {
-    default?: undefined | Atomic.Mapper[Literal];
-  }
-  export interface IString extends IAtomic<"string"> {
-    minLength?: undefined | (number & Type<"uint32">);
-    maxLength?: undefined | (number & Type<"uint32">);
-    pattern?: undefined | string;
-    format?: undefined | string;
-    "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
-  }
-  export interface INumber extends IAtomic<"number"> {
-    minimum?: undefined | number;
-    maximum?: undefined | number;
-    exclusiveMinimum?: undefined | boolean;
-    exclusiveMaximum?: undefined | boolean;
-    multipleOf?: undefined | number;
-    "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
-  }
-  export interface IInteger extends IAtomic<"integer"> {
-    minimum?: undefined | (number & Type<"int32">);
-    maximum?: undefined | (number & Type<"int32">);
-    exclusiveMinimum?: undefined | boolean;
-    exclusiveMaximum?: undefined | boolean;
-    multipleOf?: undefined | (number & Type<"int32">);
-    "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
-  }
-  export interface IBoolean extends IAtomic<"boolean"> {
-    "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
-  }
-
-  /* -----------------------------------------------------------
-        OBJECTS
-    ----------------------------------------------------------- */
-  export interface IArray extends ISignificant<"array"> {
-    items: IJsonSchema;
-    minItems?: undefined | (number & Type<"uint32">);
-    maxItems?: undefined | (number & Type<"uint32">);
-    "x-typia-tuple"?: undefined | ITuple;
-    "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
-  }
-  export interface ITuple extends ISignificant<"array"> {
-    items: IJsonSchema[];
-    minItems: number & Type<"uint32">;
-    maxItems?: undefined | (number & Type<"uint32">);
-  }
-  export interface IObject extends ISignificant<"object"> {
-    properties: Record<string, IJsonSchema>;
-    required?: undefined | string[];
-    patternProperties?: undefined | Record<string, IJsonSchema>;
-    additionalProperties?: undefined | IJsonSchema;
-    "x-typia-patternProperties"?: undefined | Record<string, IJsonSchema>;
-    "x-typia-additionalProperties"?: undefined | IJsonSchema;
-  }
-  export interface IReference extends IAttribute {
-    $ref: string;
-  }
-  export interface INullOnly extends IAttribute {
-    type: "null";
-  }
-
-  /* -----------------------------------------------------------
-        MISCELLANEOUS
-    ----------------------------------------------------------- */
-  export interface IOneOf extends IAttribute {
-    oneOf: IJsonSchema[];
-  }
-
-  export interface ISignificant<Literal extends string> extends IAttribute {
-    type: Literal;
-
-    /**
-     * Only when swagger mode.
-     */
-    nullable?: undefined | boolean;
-  }
-  export interface IAttribute {
-    deprecated?: undefined | boolean;
-    title?: undefined | string;
-    description?: undefined | string;
-    "x-typia-jsDocTags"?: undefined | IJsDocTagInfo[];
-    "x-typia-required"?: undefined | boolean;
-    "x-typia-optional"?: undefined | boolean;
-    "x-typia-rest"?: undefined | boolean;
-  }
-}

package/src/utils/NamingConvention.ts

@@ -1,87 +0,0 @@
-import { StringUtil } from "./StringUtil";
-
-export namespace NamingConvention {
-  export function snake(str: string): string {
-    const indexes: number[] = [];
-    for (let i: number = 0; i < str.length; i++) {
-      const code: number = str.charCodeAt(i);
-      if (65 <= code && code <= 90) indexes.push(i);
-    }
-    for (let i: number = indexes.length - 1; i > 0; --i) {
-      const now: number = indexes[i]!;
-      const prev: number = indexes[i - 1]!;
-      if (now - prev === 1) indexes.splice(i, 1);
-    }
-    if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-    if (indexes.length === 0) return str.toLowerCase();
-
-    let ret: string = "";
-    for (let i: number = 0; i < indexes.length; i++) {
-      const first: number = i === 0 ? 0 : indexes[i - 1]!;
-      const last: number = indexes[i]!;
-
-      ret += str.substring(first, last).toLowerCase();
-      ret += "_";
-    }
-    ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
-    return ret;
-  }
-
-  export function camel(str: string): string {
-    str = removeSnake(str);
-    if (str.length === 0) return str;
-    else if (str[0] === str[0]!.toUpperCase())
-      return str[0]!.toLowerCase() + str.substring(1);
-    else if (
-      str[0] === "_" &&
-      str.length > 1 &&
-      str[1] === str[1]!.toLowerCase()
-    )
-      return "_" + str[1]!.toUpperCase() + str.substring(2);
-    else return str;
-  }
-
-  export function pascal(str: string): string {
-    str = removeSnake(str);
-    if (str.length === 0) return str;
-    else if (str[0] === str[0]!.toLowerCase())
-      return str[0]!.toUpperCase() + str.substring(1);
-    else if (
-      str[0] === "_" &&
-      str.length > 1 &&
-      str[1] === str[1]!.toLowerCase()
-    )
-      return "_" + str[1]!.toUpperCase() + str.substring(2);
-    else return str;
-  }
-
-  const removeSnake = (str: string): string => {
-    const indexes: [number, number][] = [];
-    for (let i: number = 0; i < str.length; i++) {
-      const ch: string = str[i]!;
-      if (ch !== "_") continue;
-
-      const last = indexes[indexes.length - 1];
-      if (last === undefined || last[0] + last[1] !== i) indexes.push([i, 1]);
-      else ++last[1];
-    }
-    if (indexes.length === 0) return str;
-
-    let ret: string = "";
-    for (let i: number = 0; i < indexes.length; i++) {
-      const [first] = indexes[i]!;
-      if (i === 0)
-        if (first === 0) ret += "_";
-        else ret += str.substring(0, first);
-      else {
-        const [prevFirst, prevLength] = indexes[i - 1]!;
-        const piece: string = str.substring(prevFirst + prevLength, first);
-        if (piece.length) ret += StringUtil.capitalize(piece);
-      }
-    }
-    const last = indexes[indexes.length - 1]!;
-    const piece: string = str.substring(last[0] + last[1]);
-    if (last.length) ret += StringUtil.capitalize(piece);
-    return ret;
-  };
-}

package/src/utils/RandomGenerator.ts

@@ -1,83 +0,0 @@
-import RandExp from "randexp";
-
-/**
- * @internal
- */
-export namespace RandomGenerator {
-  const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
-
-  /* -----------------------------------------------------------
-        REGULAR
-    ----------------------------------------------------------- */
-  export const boolean = () => Math.random() < 0.5;
-
-  export const integer = (min?: number, max?: number) => {
-    min ??= 0;
-    max ??= 100;
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-  };
-
-  export const bigint = (min?: bigint, max?: bigint) => {
-    min ??= BigInt(0);
-    max ??= BigInt(100);
-    return BigInt(integer(Number(min), Number(max)));
-  };
-
-  export const number = (min?: number, max?: number) => {
-    min ??= 0;
-    max ??= 100;
-    return Math.random() * (max - min) + min;
-  };
-
-  export const string = (length?: number): string =>
-    new Array(length ?? integer(5, 10))
-      .fill(0)
-      .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
-      .join("");
-
-  export const array = <T>(
-    closure: (index: number) => T,
-    count?: number,
-  ): T[] =>
-    new Array(count ?? length()).fill(0).map((_e, index) => closure(index));
-
-  export const pick = <T>(array: T[]): T =>
-    array[integer(0, array.length - 1)]!;
-
-  export const length = () => integer(0, 3);
-
-  /* -----------------------------------------------------------
-        SECIAL FORMATS
-    ----------------------------------------------------------- */
-  export const uuid = () =>
-    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-      const r = (Math.random() * 16) | 0;
-      const v = c === "x" ? r : (r & 0x3) | 0x8;
-      return v.toString(16);
-    });
-
-  export const email = () => `${string(10)}@${string(10)}.${string(3)}`;
-
-  export const url = () => `https://${string(10)}.${string(3)}`;
-
-  export const ipv4 = () => array(() => integer(0, 255), 4).join(".");
-
-  export const ipv6 = (): string =>
-    array(() => integer(0, 65535).toString(16), 8).join(":");
-
-  export const pattern = (regex: RegExp): string => new RandExp(regex).gen();
-
-  export const date = (min?: number, max?: number) => {
-    min ??= 0;
-    max ??= Date.now() * 2;
-    return new Date(number(min, max)).toISOString().substring(0, 10);
-  };
-
-  export const datetime = (min?: number, max?: number) => {
-    min ??= Date.now() - 30 * DAY;
-    max ??= Date.now() + 7 * DAY;
-    return new Date(number(min, max)).toISOString();
-  };
-}
-
-const DAY = 1000 * 60 * 60 * 24;

package/src/utils/StringUtil.ts

@@ -1,4 +0,0 @@
-export namespace StringUtil {
-  export const capitalize = (str: string) =>
-    str.length ? str[0]!.toUpperCase() + str.slice(1) : str;
-}