typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/AssertProgrammer.ts

@@ -117,12 +117,18 @@ export namespace AssertProgrammer {
             ts.factory.createIdentifier("input"),
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           )
         : ts.factory.createTypeReferenceNode(
             props.name ??
-              TypeFactory.getFullName(props.context.checker)(props.type),
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type: props.type,
+              }),
           ),
       undefined,
       ts.factory.createBlock(
@@ -187,8 +193,13 @@ export namespace AssertProgrammer {
       statements: [
         ...is.statements,
         ...composed.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.mut("_errorFactory"),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.mut({
+          name: "_errorFactory",
+        }),
       ],
       arrow,
     };
@@ -305,36 +316,39 @@ export namespace AssertProgrammer {
     input: ts.Expression;
   }) =>
     check_object({
-      equals: props.config.equals,
-      assert: true,
-      undefined: true,
-      reduce: ts.factory.createLogicalAnd,
-      positive: ts.factory.createTrue(),
-      superfluous: (input) =>
-        create_guard_call({
-          importer: props.importer,
-          path: ts.factory.createAdd(
-            ts.factory.createIdentifier("_path"),
-            ts.factory.createCallExpression(
-              props.importer.use("join"),
-              undefined,
-              [ts.factory.createIdentifier("key")],
+      config: {
+        equals: props.config.equals,
+        assert: true,
+        undefined: true,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (input) =>
+          create_guard_call({
+            importer: props.importer,
+            path: ts.factory.createAdd(
+              ts.factory.createIdentifier("_path"),
+              ts.factory.createCallExpression(
+                props.importer.use("join"),
+                undefined,
+                [ts.factory.createIdentifier("key")],
+              ),
             ),
+            expected: "undefined",
+            input,
+          }),
+        halt: (expr) =>
+          ts.factory.createLogicalOr(
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createIdentifier("_exceptionable"),
+            ),
+            expr,
           ),
-          expected: "undefined",
-          input,
-        }),
-      halt: (expr) =>
-        ts.factory.createLogicalOr(
-          ts.factory.createStrictEquality(
-            ts.factory.createFalse(),
-            ts.factory.createIdentifier("_exceptionable"),
-          ),
-          expr,
-        ),
-    })(props.context)(props.importer)({
-      input: props.input,
+      },
+      context: props.context,
+      importer: props.importer,
       entries: props.entries,
+      input: props.input,
     });
 
   const joiner = (props: {
@@ -352,7 +366,7 @@ export namespace AssertProgrammer {
       }),
     array: (props) =>
       ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("every"),
+        IdentifierFactory.access(props.input, "every"),
         undefined,
         [props.arrow],
       ),