typia 5.4.14 → 5.5.0-dev.20240302

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -13,7 +13,7 @@ export namespace JsonAssertParseProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction => {
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction => {
       JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
         project.checker,
         project.context,
@@ -21,7 +21,10 @@ export namespace JsonAssertParseProgrammer {
       return ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           `typia.Primitive<${
             name ?? TypeFactory.getFullName(project.checker)(type)
@@ -56,7 +59,10 @@ export namespace JsonAssertParseProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("input")],
+                [
+                  ts.factory.createIdentifier("input"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               ts.factory.createTypeReferenceNode("any"),
             ),

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -13,11 +13,14 @@ export namespace JsonAssertStringifyProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         TypeFactory.keyword("string"),
         undefined,
         ts.factory.createBlock([
@@ -51,7 +54,10 @@ export namespace JsonAssertStringifyProgrammer {
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("assert"),
                   undefined,
-                  [ts.factory.createIdentifier("input")],
+                  [
+                    ts.factory.createIdentifier("input"),
+                    AssertProgrammer.Guardian.identifier(),
+                  ],
                 ),
               ],
             ),

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -13,11 +13,14 @@ export namespace MiscAssertCloneProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
             name ?? TypeFactory.getFullName(project.checker)(type)
@@ -44,7 +47,10 @@ export namespace MiscAssertCloneProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           StatementFactory.constant(

package/src/programmers/misc/MiscAssertPruneProgrammer.ts

@@ -13,11 +13,14 @@ export namespace MiscAssertPruneProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           name ?? TypeFactory.getFullName(project.checker)(type),
         ),
@@ -42,7 +45,10 @@ export namespace MiscAssertPruneProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           ts.factory.createExpressionStatement(

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -14,11 +14,14 @@ export namespace NotationAssertGeneralProgrammer {
     (rename: (str: string) => string) =>
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           NotationGeneralProgrammer.returnType(rename)(
             name ?? TypeFactory.getFullName(project.checker)(type),
@@ -45,7 +48,10 @@ export namespace NotationAssertGeneralProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           StatementFactory.constant(

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -13,7 +13,7 @@ export namespace ProtobufAssertDecodeProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -22,6 +22,7 @@ export namespace ProtobufAssertDecodeProgrammer {
             "input",
             ts.factory.createTypeReferenceNode("Uint8Array"),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -65,7 +66,10 @@ export namespace ProtobufAssertDecodeProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -13,11 +13,14 @@ export namespace ProtobufAssertEncodeProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode("Uint8Array"),
         undefined,
         ts.factory.createBlock([
@@ -51,7 +54,10 @@ export namespace ProtobufAssertEncodeProgrammer {
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("assert"),
                   undefined,
-                  [ts.factory.createIdentifier("input")],
+                  [
+                    ts.factory.createIdentifier("input"),
+                    AssertProgrammer.Guardian.identifier(),
+                  ],
                 ),
               ],
             ),

package/src/protobuf.ts

@@ -2,6 +2,7 @@ import * as Namespace from "./functional/Namespace";
 
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
+import { TypeGuardError } from "./TypeGuardError";
 
 /* ===========================================================
     PROTOCOL BUFFER
@@ -167,7 +168,10 @@ export { decodePure as decode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertDecode(input: Uint8Array): never;
+function assertDecode(
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Protocol Buffer Decoder wity type assertion, but not safe.
@@ -196,7 +200,10 @@ function assertDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertDecode<T>(input: Uint8Array): Resolved<T>;
+function assertDecode<T>(
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Resolved<T>;
 
 /**
  * @internal
@@ -443,7 +450,10 @@ export { encodePure as encode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEncode<T>(input: T): Uint8Array;
+function assertEncode<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Uint8Array;
 
 /**
  * Protocol Buffer Encoder with type assertion.
@@ -476,7 +486,10 @@ function assertEncode<T>(input: T): Uint8Array;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEncode<T>(input: unknown): Uint8Array;
+function assertEncode<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Uint8Array;
 
 /**
  * @internal
@@ -742,7 +755,9 @@ export { createIsDecodePure as createIsDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertDecode(): never;
+function createAssertDecode(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertDecode} function.
@@ -752,7 +767,9 @@ function createAssertDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T>;
+function createAssertDecode<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: Uint8Array) => Resolved<T>;
 
 /**
  * @internal
@@ -893,7 +910,9 @@ export { createIsEncodePure as createIsEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEncode(): never;
+function createAssertEncode(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertEncode} function.
@@ -903,7 +922,9 @@ function createAssertEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEncode<T>(): (input: T) => Uint8Array;
+function createAssertEncode<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => Uint8Array;
 
 /**
  * @internal

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 =