typia 5.5.0-dev.20240304 → 5.5.0-dev.20240306

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -24,10 +24,18 @@ export namespace ProtobufAssertDecodeProgrammer {
           ),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -58,10 +58,18 @@ export namespace ProtobufDecodeProgrammer {
             ts.factory.createTypeReferenceNode("Uint8Array"),
           ),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock(

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -24,10 +24,18 @@ export namespace ProtobufIsDecodeProgrammer {
           ),
         ],
         ts.factory.createUnionTypeNode([
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           ts.factory.createLiteralTypeNode(ts.factory.createNull()),
         ]),

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -157,4 +157,4 @@ interface IPointer<T> {
   value: T;
 }
 
-const TAB = " ".repeat(4);
+const TAB = " ".repeat(2);

package/src/protobuf.ts

@@ -164,6 +164,7 @@ export { decodePure as decode };
  *
  * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Decoded value
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -196,6 +197,7 @@ function assertDecode(
  *
  * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Decoded value
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -446,6 +448,7 @@ export { encodePure as encode };
  *
  * @template T Type of the value input
  * @param input A value to encode
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Encoded binary data
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -482,6 +485,7 @@ function assertEncode<T>(
  *
  * @template T Type of the value input
  * @param input A value to encode
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Encoded binary data
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -750,6 +754,7 @@ export { createIsDecodePure as createIsDecode };
  * Creates a reusable {@link assertDecode} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
@@ -763,6 +768,7 @@ function createAssertDecode(
  * Creates a reusable {@link assertDecode} function.
  *
  * @template T Target type
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertDecode` function
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -905,6 +911,7 @@ export { createIsEncodePure as createIsEncode };
  * Creates a reusable {@link assertEncode} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
@@ -918,6 +925,7 @@ function createAssertEncode(
  * Creates a reusable {@link assertEncode} function.
  *
  * @template T Target type
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertEncode` function
  *
  * @author Jeongho Nam - https://github.com/samchon

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";
@@ -88,18 +107,6 @@ import { ProtobufMessageTransformer } from "./features/protobuf/ProtobufMessageT
 import { ProtobufValidateDecodeTransformer } from "./features/protobuf/ProtobufValidateDecodeTransformer";
 import { ProtobufValidateEncodeTransformer } from "./features/protobuf/ProtobufValidateEncodeTransformer";
 import { ReflectMetadataTransformer } from "./features/reflect/ReflectMetadataTransformer";
-import { HttpAssertFormDataTransformer } from "./features/http/HttpAssertFormDataTransformer";
-import { HttpFormDataTransformer } from "./features/http/HttpFormDataTransformer";
-import { HttpIsFormDataTransformer } from "./features/http/HttpIsFormDataTransformer";
-import { HttpValidateFormDataTransformer } from "./features/http/HttpValidateFormDataTransformer";
-import { CreateHttpAssertFormDataTransformer } from "./features/http/CreateHttpAssertFormDataTransformer";
-import { CreateHttpFormDataTransformer } from "./features/http/CreateHttpFormDataTransformer";
-import { CreateHttpIsFormDataTransformer } from "./features/http/CreateHttpIsFormDataTransformer";
-import { CreateHttpValidateFormDataTransformer } from "./features/http/CreateHttpValidateFormDataTransformer";
-import { FunctionalGenericTransformer } from "./features/functional/FunctionalGenericTransformer";
-import { FunctionalAssertFunctionProgrammer } from "../programmers/functional/FunctionalAssertFunctionProgrammer";
-import { FunctionalAssertParametersProgrammer } from "../programmers/functional/FunctionalAssertParametersProgrammer";
-import { FunctionAssertReturnProgrammer } from "../programmers/functional/FunctionalAssertReturnProgrammer";
 
 export namespace CallExpressionTransformer {
   export const transform =
@@ -229,6 +236,82 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         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

package/src/utils/StringUtil/StringUtil.ts

@@ -1,2 +1,7 @@
 export const capitalize = (str: string) =>
   str.length ? str[0]!.toUpperCase() + str.slice(1) : str;
+
+export const escapeDuplicate =
+  (keep: string[]) =>
+  (change: string): string =>
+    keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;