typia 5.4.14 → 5.5.0-dev.20240301

package/src/programmers/AssertProgrammer.ts

@@ -17,15 +17,14 @@ export namespace AssertProgrammer {
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
     (props: boolean | { equals: boolean; guard: boolean }) =>
-    (type: ts.Type, name?: string) => {
+    (type: ts.Type, name?: string, init?: ts.Expression) => {
       // TO SUPPORT LEGACY FEATURE
       if (typeof props === "boolean") props = { equals: props, guard: false };
 
       const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const is = IsProgrammer.write(project)(modulo, true)(props.equals)(
-        type,
-        name ?? TypeFactory.getFullName(project.checker)(type),
-      );
+      const is: ts.ArrowFunction = IsProgrammer.write(project)(modulo, true)(
+        props.equals,
+      )(type, name ?? TypeFactory.getFullName(project.checker)(type));
       const assert: ts.ArrowFunction = CheckerProgrammer.write(project)({
         prefix: "$a",
         path: true,
@@ -41,7 +40,7 @@ export namespace AssertProgrammer {
               ? entry.conditions[0]!.map((cond) =>
                   ts.factory.createLogicalOr(
                     cond.expression,
-                    create_guard_call(importer)(
+                    create_guard_call(
                       explore.from === "top"
                         ? ts.factory.createTrue()
                         : ts.factory.createIdentifier("_exceptionable"),
@@ -65,7 +64,7 @@ export namespace AssertProgrammer {
                           .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
                       )
                       .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_guard_call(importer)(
+                    create_guard_call(
                       explore.from === "top"
                         ? ts.factory.createTrue()
                         : ts.factory.createIdentifier("_exceptionable"),
@@ -90,7 +89,10 @@ export namespace AssertProgrammer {
       return ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          Guardian.parameter(init),
+        ],
         props.guard
           ? ts.factory.createTypePredicateNode(
               ts.factory.createToken(ts.SyntaxKind.AssertsKeyword),
@@ -105,6 +107,21 @@ export namespace AssertProgrammer {
         undefined,
         ts.factory.createBlock(
           [
+            StatementFactory.constant(
+              "$guard",
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(
+                  ts.factory.createParenthesizedExpression(
+                    ts.factory.createAsExpression(
+                      modulo,
+                      TypeFactory.keyword("any"),
+                    ),
+                  ),
+                )("guard"),
+                undefined,
+                [Guardian.identifier()],
+              ),
+            ),
             StatementFactory.constant("__is", is),
             ts.factory.createIfStatement(
               ts.factory.createStrictEquality(
@@ -159,7 +176,7 @@ export namespace AssertProgrammer {
                   ? binary.expression
                   : ts.factory.createLogicalOr(
                       binary.expression,
-                      create_guard_call(importer)(
+                      create_guard_call(
                         explore.source === "top"
                           ? ts.factory.createTrue()
                           : ts.factory.createIdentifier("_exceptionable"),
@@ -171,7 +188,7 @@ export namespace AssertProgrammer {
               binaries
                 .map((binary) => binary.expression)
                 .reduce(ts.factory.createLogicalOr),
-              create_guard_call(importer)(
+              create_guard_call(
                 explore.source === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
@@ -184,7 +201,7 @@ export namespace AssertProgrammer {
       //       ) {
       //           addicted.push({
       //               combined: true,
-      //               expression: create_guard_call(importer)(
+      //               expression: create_guard_call(
       //                   explore.source === "top"
       //                       ? ts.factory.createTrue()
       //                       : ts.factory.createIdentifier(
@@ -212,7 +229,7 @@ export namespace AssertProgrammer {
         reduce: ts.factory.createLogicalAnd,
         positive: ts.factory.createTrue(),
         superfluous: (value) =>
-          create_guard_call(importer)()(
+          create_guard_call()(
             ts.factory.createAdd(
               ts.factory.createIdentifier("_path"),
               ts.factory.createCallExpression(importer.use("join"), undefined, [
@@ -244,7 +261,7 @@ export namespace AssertProgrammer {
           [arrow],
         ),
       failure: (value, expected, explore) =>
-        create_guard_call(importer)(
+        create_guard_call(
           explore?.from === "top"
             ? ts.factory.createTrue()
             : ts.factory.createIdentifier("_exceptionable"),
@@ -260,7 +277,7 @@ export namespace AssertProgrammer {
         : (condition) => (input, expected, explore) =>
             ts.factory.createLogicalOr(
               condition,
-              create_guard_call(importer)(
+              create_guard_call(
                 explore.from === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
@@ -269,25 +286,49 @@ export namespace AssertProgrammer {
     });
 
   const create_guard_call =
-    (importer: FunctionImporter) =>
     (exceptionable?: ts.Expression) =>
     (
       path: ts.Expression,
       expected: string,
       value: ts.Expression,
     ): ts.Expression =>
-      ts.factory.createCallExpression(importer.use("guard"), undefined, [
-        exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
-        ts.factory.createObjectLiteralExpression(
-          [
-            ts.factory.createPropertyAssignment("path", path),
-            ts.factory.createPropertyAssignment(
-              "expected",
-              ts.factory.createStringLiteral(expected),
-            ),
-            ts.factory.createPropertyAssignment("value", value),
-          ],
-          true,
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("$guard"),
+        undefined,
+        [
+          exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createPropertyAssignment("path", path),
+              ts.factory.createPropertyAssignment(
+                "expected",
+                ts.factory.createStringLiteral(expected),
+              ),
+              ts.factory.createPropertyAssignment("value", value),
+            ],
+            true,
+          ),
+        ],
+      );
+
+  export namespace Guardian {
+    export const identifier = () => ts.factory.createIdentifier("errorFactory");
+    export const parameter = (init: ts.Expression | undefined) =>
+      IdentifierFactory.parameter(
+        "errorFactory",
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createQualifiedName(
+            ts.factory.createIdentifier("TypeGuardError"),
+            ts.factory.createIdentifier("IProps"),
+          ),
+          undefined,
+          false,
         ),
-      ]);
+        init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+      );
+  }
 }

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertFormDataProgrammer {
   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,
@@ -22,6 +22,7 @@ export namespace HttpAssertFormDataProgrammer {
             "input",
             ts.factory.createTypeReferenceNode("FormData"),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -65,7 +66,10 @@ export namespace HttpAssertFormDataProgrammer {
               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/http/HttpAssertHeadersProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertHeadersProgrammer {
   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,
@@ -24,6 +24,7 @@ export namespace HttpAssertHeadersProgrammer {
               HttpHeadersProgrammer.INPUT_TYPE,
             ),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -67,7 +68,10 @@ export namespace HttpAssertHeadersProgrammer {
               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/http/HttpAssertQueryProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertQueryProgrammer {
   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,
@@ -22,6 +22,7 @@ export namespace HttpAssertQueryProgrammer {
             "input",
             ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -65,7 +66,10 @@ export namespace HttpAssertQueryProgrammer {
               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/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 =