typia 6.0.0-dev.20240122 → 6.0.0

package/src/transformers/CallExpressionTransformer.ts

@@ -1,6 +1,17 @@
 import path from "path";
 import ts from "typescript";
 
+import { FunctionalAssertFunctionProgrammer } from "../programmers/functional/FunctionalAssertFunctionProgrammer";
+import { FunctionalAssertParametersProgrammer } from "../programmers/functional/FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "../programmers/functional/FunctionalAssertReturnProgrammer";
+import { FunctionalIsFunctionProgrammer } from "../programmers/functional/FunctionalIsFunctionProgrammer";
+import { FunctionalIsParametersProgrammer } from "../programmers/functional/FunctionalIsParametersProgrammer";
+import { FunctionalIsReturnProgrammer } from "../programmers/functional/FunctionalIsReturnProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "../programmers/functional/FunctionalValidateFunctionProgrammer";
+import { FunctionalValidateParametersProgrammer } from "../programmers/functional/FunctionalValidateParametersProgrammer";
+import { FunctionalValidateReturnProgrammer } from "../programmers/functional/FunctionalValidateReturnProgrammer";
+import { FunctionalGenericTransformer } from "./features/functional/FunctionalGenericTransformer";
+
 import { NamingConvention } from "../utils/NamingConvention";
 
 import { IProject } from "./IProject";
@@ -12,22 +23,30 @@ import { CreateValidateTransformer } from "./features/CreateValidateTransformer"
 import { IsTransformer } from "./features/IsTransformer";
 import { RandomTransformer } from "./features/RandomTransformer";
 import { ValidateTransformer } from "./features/ValidateTransformer";
+import { CreateHttpAssertFormDataTransformer } from "./features/http/CreateHttpAssertFormDataTransformer";
 import { CreateHttpAssertHeadersTransformer } from "./features/http/CreateHttpAssertHeadersTransformer";
 import { CreateHttpAssertQueryTransformer } from "./features/http/CreateHttpAssertQueryTransformer";
+import { CreateHttpFormDataTransformer } from "./features/http/CreateHttpFormDataTransformer";
 import { CreateHttpHeadersTransformer } from "./features/http/CreateHttpHeadersTransformer";
+import { CreateHttpIsFormDataTransformer } from "./features/http/CreateHttpIsFormDataTransformer";
 import { CreateHttpIsHeadersTransformer } from "./features/http/CreateHttpIsHeadersTransformer";
 import { CreateHttpIsQueryTransformer } from "./features/http/CreateHttpIsQueryTransformer";
 import { CreateHttpParameterTransformer } from "./features/http/CreateHttpParameterTransformer";
 import { CreateHttpQueryTransformer } from "./features/http/CreateHttpQueryTransformer";
+import { CreateHttpValidateFormDataTransformer } from "./features/http/CreateHttpValidateFormDataTransformer";
 import { CreateHttpValidateHeadersTransformer } from "./features/http/CreateHttpValidateHeadersTransformer";
 import { CreateHttpValidateQueryTransformer } from "./features/http/CreateHttpValidateQueryTransformer";
+import { HttpAssertFormDataTransformer } from "./features/http/HttpAssertFormDataTransformer";
 import { HttpAssertHeadersTransformer } from "./features/http/HttpAssertHeadersTransformer";
 import { HttpAssertQueryTransformer } from "./features/http/HttpAssertQueryTransformer";
+import { HttpFormDataTransformer } from "./features/http/HttpFormDataTransformer";
 import { HttpHeadersTransformer } from "./features/http/HttpHeadersTransformer";
+import { HttpIsFormDataTransformer } from "./features/http/HttpIsFormDataTransformer";
 import { HttpIsHeadersTransformer } from "./features/http/HttpIsHeadersTransformer";
 import { HttpIsQueryTransformer } from "./features/http/HttpIsQueryTransformer";
 import { HttpParameterTransformer } from "./features/http/HttpParameterTransformer";
 import { HttpQueryTransformer } from "./features/http/HttpQueryTransformer";
+import { HttpValidateFormDataTransformer } from "./features/http/HttpValidateFormDataTransformer";
 import { HttpValidateHeadersTransformer } from "./features/http/HttpValidateHeadersTransformer";
 import { HttpValidateQueryTransformer } from "./features/http/HttpValidateQueryTransformer";
 import { JsonApplicationTransformer } from "./features/json/JsonApplicationTransformer";
@@ -128,7 +147,7 @@ export namespace CallExpressionTransformer {
   const isTarget = (location: string): boolean => {
     const files: string[] = Object.keys(FUNCTORS);
     return files.some((f) =>
-      location.includes(path.join("node_modules", "typia", "lib", `${f}.d.ts`)),
+      location.includes(path.join("typia", "lib", `${f}.d.ts`)),
     );
   };
 }
@@ -179,7 +198,128 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     createValidateEquals: () => CreateValidateTransformer.transform(true),
     createRandom: () => CreateRandomTransformer.transform,
   },
+  functional: {
+    // ASSERTIONS
+    assertFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertFunction",
+        equals: false,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertParameters",
+        equals: false,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertReturn",
+        equals: false,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+    assertEqualsFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsFunction",
+        equals: true,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertEqualsParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsParameters",
+        equals: true,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertEqualsReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsReturn",
+        equals: true,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+
+    // IS
+    isFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "isFunction",
+        equals: false,
+        programmer: FunctionalIsFunctionProgrammer.write,
+      }),
+    isParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "isParameters",
+        equals: false,
+        programmer: FunctionalIsParametersProgrammer.write,
+      }),
+    isReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "isReturn",
+        equals: false,
+        programmer: FunctionalIsReturnProgrammer.write,
+      }),
+    equalsFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "equalsFunction",
+        equals: true,
+        programmer: FunctionalIsFunctionProgrammer.write,
+      }),
+    equalsParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "equalsParameters",
+        equals: true,
+        programmer: FunctionalIsParametersProgrammer.write,
+      }),
+    equalsReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "equalsReturn",
+        equals: true,
+        programmer: FunctionalIsReturnProgrammer.write,
+      }),
+
+    // VALIDATIONS
+    validateFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateFunction",
+        equals: false,
+        programmer: FunctionalValidateFunctionProgrammer.write,
+      }),
+    validateParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateParameters",
+        equals: false,
+        programmer: FunctionalValidateParametersProgrammer.write,
+      }),
+    validateReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateReturn",
+        equals: false,
+        programmer: FunctionalValidateReturnProgrammer.write,
+      }),
+    validateEqualsFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateEqualsFunction",
+        equals: true,
+        programmer: FunctionalValidateFunctionProgrammer.write,
+      }),
+    validateEqualsParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateEqualsParameters",
+        equals: true,
+        programmer: FunctionalValidateParametersProgrammer.write,
+      }),
+    validateEqualsReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "validateEqualsReturn",
+        equals: true,
+        programmer: FunctionalValidateReturnProgrammer.write,
+      }),
+  },
   http: {
+    // FORM-DATA
+    formData: () => HttpFormDataTransformer.transform,
+    isFormData: () => HttpIsFormDataTransformer.transform,
+    assertFormData: () => HttpAssertFormDataTransformer.transform,
+    validateFormData: () => HttpValidateFormDataTransformer.transform,
+
     // HEADERS
     headers: () => HttpHeadersTransformer.transform,
     isHeaders: () => HttpIsHeadersTransformer.transform,
@@ -196,6 +336,11 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     validateQuery: () => HttpValidateQueryTransformer.transform,
 
     // FACTORIES
+    createFormData: () => CreateHttpFormDataTransformer.transform,
+    createIsFormData: () => CreateHttpIsFormDataTransformer.transform,
+    createAssertFormData: () => CreateHttpAssertFormDataTransformer.transform,
+    createValidateFormData: () =>
+      CreateHttpValidateFormDataTransformer.transform,
     createHeaders: () => CreateHttpHeadersTransformer.transform,
     createIsHeaders: () => CreateHttpIsHeadersTransformer.transform,
     createAssertHeaders: () => CreateHttpAssertHeadersTransformer.transform,

package/src/transformers/features/AssertTransformer.ts

@@ -10,7 +10,7 @@ export namespace AssertTransformer {
           ? "assertGuardEquals"
           : "assertEquals"
         : props.guard
-        ? "assertGuard"
-        : "assert",
+          ? "assertGuard"
+          : "assert",
     )((project) => (modulo) => AssertProgrammer.write(project)(modulo)(props));
 }

package/src/transformers/features/CreateAssertTransformer.ts

@@ -10,7 +10,7 @@ export namespace CreateAssertTransformer {
           ? "createAssertGuardEquals"
           : "createAssertEquals"
         : props.guard
-        ? "createAssertGuard"
-        : "createAssert",
+          ? "createAssertGuard"
+          : "createAssert",
     )((project) => (modulo) => AssertProgrammer.write(project)(modulo)(props));
 }

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -0,0 +1,57 @@
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace FunctionalGenericTransformer {
+  export const transform =
+    (props: {
+      method: string;
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (
+        equals: boolean,
+      ) => (
+        expression: ts.Expression,
+        declaration: ts.FunctionDeclaration,
+        init?: ts.Expression,
+      ) => ts.Expression;
+      equals: boolean;
+    }) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const type: ts.Type =
+        expression.typeArguments && expression.typeArguments[0]
+          ? project.checker.getTypeFromTypeNode(expression.typeArguments[0])
+          : project.checker.getTypeAtLocation(expression.arguments[0]!);
+      // if (type. === true)
+      //   throw new TransformerError({
+      //     code: `typia.functional.${props.method}`,
+      //     message: `non-specified generic argument.`,
+      //   });
+      // else
+      if (TypeFactory.isFunction(type) === false)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `input value is not a function.`,
+        });
+      return props.programmer(project)(modulo)(props.equals)(
+        expression.arguments[0]!,
+        type.symbol!.declarations![0] as ts.FunctionDeclaration,
+        expression.arguments[1],
+      );
+    };
+}

package/src/transformers/features/http/CreateHttpAssertFormDataTransformer.ts

@@ -0,0 +1,12 @@
+import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertFormDataTransformer {
+  export const transform = GenericTransformer.factory(
+    "http.createAssertFormData",
+  )(
+    (project) => (modulo) =>
+      HttpAssertFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/CreateHttpFormDataTransformer.ts

@@ -0,0 +1,9 @@
+import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpFormDataTransformer {
+  export const transform = GenericTransformer.factory("http.createFormData")(
+    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/CreateHttpIsFormDataTransformer.ts

@@ -0,0 +1,9 @@
+import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsFormDataTransformer {
+  export const transform = GenericTransformer.factory("http.createIsFormData")(
+    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/CreateHttpValidateFormDataTransformer.ts

@@ -0,0 +1,12 @@
+import { HttpValidateFormDataProgrammer } from "../../../programmers/http/HttpValidateFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateFormDataTransformer {
+  export const transform = GenericTransformer.factory(
+    "http.createValidateFormData",
+  )(
+    (project) => (modulo) =>
+      HttpValidateFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/HttpAssertFormDataTransformer.ts

@@ -0,0 +1,10 @@
+import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertFormDataTransformer {
+  export const transform = GenericTransformer.scalar("http.assertFormData")(
+    (project) => (modulo) =>
+      HttpAssertFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/HttpFormDataTransformer.ts

@@ -0,0 +1,9 @@
+import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpFormDataTransformer {
+  export const transform = GenericTransformer.scalar("http.formdata")(
+    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/HttpIsFormDataTransformer.ts

@@ -0,0 +1,9 @@
+import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsFormDataTransformer {
+  export const transform = GenericTransformer.scalar("http.isFormData")(
+    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/http/HttpValidateFormDataTransformer.ts

@@ -0,0 +1,10 @@
+import { HttpValidateFormDataProgrammer } from "../../../programmers/http/HttpValidateFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpValidateFormDataTransformer {
+  export const transform = GenericTransformer.scalar("http.validateFormData")(
+    (project) => (modulo) =>
+      HttpValidateFormDataProgrammer.write(project)(modulo),
+  );
+}

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,6 +1,5 @@
 import ts from "typescript";
 
-import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
 import { MetadataFactory } from "../../../factories/MetadataFactory";
@@ -45,20 +44,13 @@ export namespace JsonApplicationTransformer {
         });
 
       // ADDITIONAL PARAMETERS
-      const purpose: "swagger" | "ajv" = get_parameter<"swagger" | "ajv">({
+      const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
         checker: project.checker,
-        name: "Purpose",
-        is: (str) => str === "swagger" || str === "ajv",
-        cast: (str) => str as "swagger" | "ajv",
-        default: () => "swagger",
+        name: "Version",
+        is: (str) => str === "3.0" || str === "3.1",
+        cast: (str) => str as "3.0" | "3.1",
+        default: () => "3.1",
       })(expression.typeArguments[1]);
-      const surplus: boolean = get_parameter<boolean>({
-        checker: project.checker,
-        name: "Surplus",
-        is: (str) => str === "true" || str === "false",
-        cast: (str) => str === "true",
-        default: () => false,
-      })(expression.typeArguments[2]);
 
       //----
       // GENERATORS
@@ -76,7 +68,7 @@ export namespace JsonApplicationTransformer {
             escape: true,
             constant: true,
             absorb: false,
-            validate: JsonMetadataFactory.validate,
+            validate: JsonApplicationProgrammer.validate,
           })(collection)(type),
         );
 
@@ -91,10 +83,8 @@ export namespace JsonApplicationTransformer {
         throw TransformerError.from("typia.json.application")(errors);
 
       // APPLICATION
-      const app: IJsonApplication = JsonApplicationProgrammer.write({
-        purpose,
-        surplus,
-      })(metadatas);
+      const app: IJsonApplication<any> =
+        JsonApplicationProgrammer.write(version)(metadatas);
       return LiteralFactory.generate(app);
     };
 

package/src/transformers/internal/GenericTransformer.ts

@@ -17,7 +17,7 @@ export namespace GenericTransformer {
     (modulo: ts.LeftHandSideExpression) =>
     (expression: ts.CallExpression) => {
       // CHECK PARAMETER
-      if (expression.arguments.length !== 1)
+      if (expression.arguments.length === 0)
         throw new TransformerError({
           code: `typia.${method}`,
           message: `no input value.`,
@@ -51,7 +51,7 @@ export namespace GenericTransformer {
             : name(project.checker)(type)(node),
         ),
         undefined,
-        [expression.arguments[0]!],
+        expression.arguments,
       );
     };
 
@@ -62,7 +62,11 @@ export namespace GenericTransformer {
         project: IProject,
       ) => (
         modulo: ts.LeftHandSideExpression,
-      ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+      ) => (
+        type: ts.Type,
+        name: string,
+        init?: ts.Expression,
+      ) => ts.ArrowFunction,
     ) =>
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
@@ -85,7 +89,11 @@ export namespace GenericTransformer {
         });
 
       // DO TRANSFORM
-      return programmer(project)(modulo)(type, node.getFullText().trim());
+      return programmer(project)(modulo)(
+        type,
+        node.getFullText().trim(),
+        expression.arguments[0],
+      );
     };
 
   const name =

package/src/utils/ArrayUtil.ts

@@ -38,6 +38,4 @@ export namespace ArrayUtil {
     count: number,
     closure: (index: number, count: number) => T,
   ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
-
-  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
 }

package/src/utils/NamingConvention/NamingConvention.ts

@@ -0,0 +1,86 @@
+import { StringUtil } from "../StringUtil";
+
+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 {
+  return unsnake((str: string) => {
+    if (str.length === 0) return str;
+    else if (str[0] === str[0]!.toUpperCase())
+      return str[0]!.toLowerCase() + str.substring(1);
+    else return str;
+  })(str);
+}
+
+export function pascal(str: string): string {
+  return unsnake((str: string) => {
+    if (str.length === 0) return str;
+    else if (str[0] === str[0]!.toLowerCase())
+      return str[0]!.toUpperCase() + str.substring(1);
+    else return str;
+  })(str);
+}
+
+const unsnake =
+  (escaper: (str: string) => string) =>
+  (str: string): string => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let prefix: string = "";
+    for (let i: number = 0; i < str.length; i++) {
+      if (str[i] === "_") prefix += "_";
+      else break;
+    }
+    if (prefix.length !== 0) str = str.substring(prefix.length);
+
+    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 prefix + escaper(str);
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    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 prefix + escaper(ret);
+  };

package/src/utils/NamingConvention/index.ts

@@ -0,0 +1 @@
+export * as NamingConvention from "./NamingConvention";