typia 7.0.0-dev.20241001 → 7.0.0-dev.20241002-2

package/src/programmers/internal/check_dynamic_properties.ts

@@ -29,7 +29,8 @@ export const check_dynamic_properties = (props: {
       undefined,
       [props.input],
     ),
-  )("length");
+    "length",
+  );
   const left: ts.Expression | null =
     props.config.equals === true && props.dynamic.length === 0
       ? props.config.undefined === true ||
@@ -75,7 +76,8 @@ export const check_dynamic_properties = (props: {
             undefined,
             [props.input],
           ),
-        )(props.config.assert ? "every" : "map"),
+          props.config.assert ? "every" : "map",
+        ),
         undefined,
         [check_dynamic_property(props)],
       );
@@ -121,10 +123,10 @@ const check_dynamic_property = (props: {
   if (props.regular.length)
     add(is_regular_property(props.regular), props.config.positive);
   statements.push(
-    StatementFactory.constant(
-      "value",
-      ts.factory.createElementAccessExpression(props.input, key),
-    ),
+    StatementFactory.constant({
+      name: "value",
+      value: ts.factory.createElementAccessExpression(props.input, key),
+    }),
   );
   if (props.config.undefined === true)
     add(
@@ -191,7 +193,8 @@ const is_regular_property = (regular: IExpressionEntry[]) =>
           ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
         ),
       ),
-    )("some"),
+      "some",
+    ),
     undefined,
     [
       ts.factory.createArrowFunction(

package/src/programmers/internal/check_everything.ts

@@ -8,7 +8,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
  */
 export const check_everything = (array: ts.Expression) =>
   ts.factory.createCallExpression(
-    IdentifierFactory.access(array)("every"),
+    IdentifierFactory.access(array, "every"),
     undefined,
     [
       ts.factory.createArrowFunction(

package/src/programmers/internal/check_native.ts

@@ -9,7 +9,7 @@ export const check_native = (props: {
   type: string;
   input: ts.Expression;
 }): ts.Expression => {
-  const instanceOf = ExpressionFactory.isInstanceOf(props.type)(props.input);
+  const instanceOf = ExpressionFactory.isInstanceOf(props.type, props.input);
   return ATOMIC_LIKE.has(props.type)
     ? ts.factory.createLogicalOr(
         ts.factory.createStrictEquality(

package/src/programmers/internal/check_number.ts

@@ -105,7 +105,7 @@ const check_numeric_type_tags = (props: {
         expected: `number & ${tag.name}`,
         expression: (
           tag.predicate ??
-          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
         )(props.input),
       })),
     ]);

package/src/programmers/internal/check_string.ts

@@ -43,7 +43,7 @@ const check_string_type_tags = (props: {
         expected: `string & ${tag.name}`,
         expression: (
           tag.predicate ??
-          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
         )(props.input),
       })),
     );

package/src/programmers/internal/check_union_array_like.ts

@@ -128,14 +128,17 @@ export const check_union_array_like = <
 
   if (tupleList.length)
     statements.push(
-      StatementFactory.constant("array", props.accessor.array(props.input)),
-      StatementFactory.constant(
-        "tuplePredicators",
-        ts.factory.createArrayLiteralExpression(
+      StatementFactory.constant({
+        name: "array",
+        value: props.accessor.array(props.input),
+      }),
+      StatementFactory.constant({
+        name: "tuplePredicators",
+        value: ts.factory.createArrayLiteralExpression(
           tupleList.map((x) => predicate(x as Category)),
           true,
         ),
-      ),
+      }),
       iterate({
         init: "pred",
         from: ts.factory.createIdentifier("tuplePredicators"),
@@ -158,10 +161,16 @@ export const check_union_array_like = <
   if (arrayList.length) {
     if (tupleList.length === 0)
       statements.push(
-        StatementFactory.constant("array", props.accessor.array(props.input)),
+        StatementFactory.constant({
+          name: "array",
+          value: props.accessor.array(props.input),
+        }),
       );
     statements.push(
-      StatementFactory.constant("top", props.accessor.front(props.input)),
+      StatementFactory.constant({
+        name: "top",
+        value: props.accessor.front(props.input),
+      }),
       ts.factory.createIfStatement(
         ts.factory.createStrictEquality(
           ExpressionFactory.number(0),
@@ -171,19 +180,20 @@ export const check_union_array_like = <
           ? props.config.empty
           : ts.factory.createReturnStatement(props.config.empty),
       ),
-      StatementFactory.constant(
-        "arrayPredicators",
-        ts.factory.createArrayLiteralExpression(
+      StatementFactory.constant({
+        name: "arrayPredicators",
+        value: ts.factory.createArrayLiteralExpression(
           arrayList.map((x) => predicate(x as Category)),
           true,
         ),
-      ),
-      StatementFactory.constant(
-        "passed",
-        ts.factory.createCallExpression(
+      }),
+      StatementFactory.constant({
+        name: "passed",
+        value: ts.factory.createCallExpression(
           IdentifierFactory.access(
             ts.factory.createIdentifier("arrayPredicators"),
-          )("filter"),
+            "filter",
+          ),
           undefined,
           [
             ts.factory.createArrowFunction(
@@ -200,7 +210,7 @@ export const check_union_array_like = <
             ),
           ],
         ),
-      ),
+      }),
       ts.factory.createIfStatement(
         ts.factory.createStrictEquality(
           ExpressionFactory.number(1),
@@ -228,7 +238,7 @@ export const check_union_array_like = <
             from: ts.factory.createIdentifier("passed"),
             if: ts.factory.createIfStatement(
               ts.factory.createCallExpression(
-                IdentifierFactory.access(array)("every"),
+                IdentifierFactory.access(array, "every"),
                 undefined,
                 [
                   ts.factory.createArrowFunction(

package/src/programmers/internal/prune_object_properties.ts

@@ -50,7 +50,7 @@ export const prune_object_properties = (object: MetadataObject) => {
 
   return ts.factory.createForOfStatement(
     undefined,
-    StatementFactory.constant("key").declarationList,
+    StatementFactory.constant({ name: "key" }).declarationList,
     ts.factory.createCallExpression(
       ts.factory.createIdentifier("Object.keys"),
       undefined,

package/src/programmers/internal/random_custom.ts

@@ -35,4 +35,5 @@ export const random_custom = (props: {
         ),
       ],
     ),
-  )(props.expression);
+    props.expression,
+  );

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,160 +1,162 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TemplateFactory } from "../../factories/TemplateFactory";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const stringify_dynamic_properties = (
-  dynamic: IExpressionEntry<ts.Expression>[],
-  regular: string[],
-): ts.Expression => {
-  // BASIC STATMEMENT, CHECK UNDEFINED
-  const statements: ts.Statement[] = [
-    ts.factory.createIfStatement(
-      ts.factory.createStrictEquality(
-        ts.factory.createIdentifier("undefined"),
-        ts.factory.createIdentifier("value"),
-      ),
-      ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-    ),
-  ];
-
-  // PREPARE RETURN FUNCTION
-  const output = () => {
-    const mapped = ts.factory.createCallExpression(
-      IdentifierFactory.access(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [ts.factory.createIdentifier("input")],
-        ),
-      )("map"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            IdentifierFactory.parameter(
-              ts.factory.createArrayBindingPattern([
-                ts.factory.createBindingElement(undefined, undefined, "key"),
-                ts.factory.createBindingElement(undefined, undefined, "value"),
-              ]),
-              ts.factory.createTypeReferenceNode("[string, any]"),
-            ),
-          ],
-          undefined,
-          undefined,
-          ts.factory.createBlock(statements),
-        ),
-      ],
-    );
-    const filtered = ts.factory.createCallExpression(
-      IdentifierFactory.access(mapped)("filter"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [IdentifierFactory.parameter("str")],
-          undefined,
-          undefined,
-          ts.factory.createStrictInequality(
-            ts.factory.createStringLiteral(""),
-            ts.factory.createIdentifier("str"),
-          ),
-        ),
-      ],
-    );
-    return ts.factory.createCallExpression(
-      IdentifierFactory.access(filtered)("join"),
-      undefined,
-      [ts.factory.createStringLiteral(",")],
-    );
-  };
-
-  // WHEN REGULAR PROPERTY EXISTS
-  if (regular.length)
-    statements.push(
-      ts.factory.createIfStatement(
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(
-            ts.factory.createArrayLiteralExpression(
-              regular.map((key) => ts.factory.createStringLiteral(key)),
-            ),
-          )("some"),
-          undefined,
-          [
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              [IdentifierFactory.parameter("regular")],
-              undefined,
-              undefined,
-              ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("regular"),
-                ts.factory.createIdentifier("key"),
-              ),
-            ),
-          ],
-        ),
-        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-      ),
-    );
-
-  // ONLY STRING TYPED KEY EXISTS
-  const simple: boolean =
-    dynamic.length === 1 &&
-    dynamic[0]!.key.size() === 1 &&
-    dynamic[0]!.key.atomics[0]?.type === "string";
-  if (simple === true) {
-    statements.push(stringify(dynamic[0]!));
-    return output();
-  }
-
-  // COMPOSITE TEMPLATE LITERAL TYPES
-  for (const entry of dynamic) {
-    const condition: ts.IfStatement = ts.factory.createIfStatement(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          `RegExp(/${metadata_to_pattern({
-            top: true,
-            metadata: entry.key,
-          })}/).test`,
-        ),
-        undefined,
-        [ts.factory.createIdentifier("key")],
-      ),
-      stringify(entry),
-    );
-    statements.push(condition);
-  }
-  statements.push(
-    ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-  );
-
-  return output();
-};
-
-/**
- * @internal
- */
-const stringify = (
-  entry: IExpressionEntry<ts.Expression>,
-): ts.ReturnStatement =>
-  ts.factory.createReturnStatement(
-    TemplateFactory.generate([
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("JSON.stringify"),
-        [],
-        [ts.factory.createIdentifier("key")],
-      ),
-      ts.factory.createStringLiteral(":"),
-      entry.expression,
-    ]),
-  );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const stringify_dynamic_properties = (
+  dynamic: IExpressionEntry<ts.Expression>[],
+  regular: string[],
+): ts.Expression => {
+  // BASIC STATMEMENT, CHECK UNDEFINED
+  const statements: ts.Statement[] = [
+    ts.factory.createIfStatement(
+      ts.factory.createStrictEquality(
+        ts.factory.createIdentifier("undefined"),
+        ts.factory.createIdentifier("value"),
+      ),
+      ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+    ),
+  ];
+
+  // PREPARE RETURN FUNCTION
+  const output = () => {
+    const mapped = ts.factory.createCallExpression(
+      IdentifierFactory.access(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [ts.factory.createIdentifier("input")],
+        ),
+        "map",
+      ),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [
+            IdentifierFactory.parameter(
+              ts.factory.createArrayBindingPattern([
+                ts.factory.createBindingElement(undefined, undefined, "key"),
+                ts.factory.createBindingElement(undefined, undefined, "value"),
+              ]),
+              ts.factory.createTypeReferenceNode("[string, any]"),
+            ),
+          ],
+          undefined,
+          undefined,
+          ts.factory.createBlock(statements),
+        ),
+      ],
+    );
+    const filtered = ts.factory.createCallExpression(
+      IdentifierFactory.access(mapped, "filter"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("str")],
+          undefined,
+          undefined,
+          ts.factory.createStrictInequality(
+            ts.factory.createStringLiteral(""),
+            ts.factory.createIdentifier("str"),
+          ),
+        ),
+      ],
+    );
+    return ts.factory.createCallExpression(
+      IdentifierFactory.access(filtered, "join"),
+      undefined,
+      [ts.factory.createStringLiteral(",")],
+    );
+  };
+
+  // WHEN REGULAR PROPERTY EXISTS
+  if (regular.length)
+    statements.push(
+      ts.factory.createIfStatement(
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createArrayLiteralExpression(
+              regular.map((key) => ts.factory.createStringLiteral(key)),
+            ),
+            "some",
+          ),
+          undefined,
+          [
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              [IdentifierFactory.parameter("regular")],
+              undefined,
+              undefined,
+              ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("regular"),
+                ts.factory.createIdentifier("key"),
+              ),
+            ),
+          ],
+        ),
+        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+      ),
+    );
+
+  // ONLY STRING TYPED KEY EXISTS
+  const simple: boolean =
+    dynamic.length === 1 &&
+    dynamic[0]!.key.size() === 1 &&
+    dynamic[0]!.key.atomics[0]?.type === "string";
+  if (simple === true) {
+    statements.push(stringify(dynamic[0]!));
+    return output();
+  }
+
+  // COMPOSITE TEMPLATE LITERAL TYPES
+  for (const entry of dynamic) {
+    const condition: ts.IfStatement = ts.factory.createIfStatement(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          `RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: entry.key,
+          })}/).test`,
+        ),
+        undefined,
+        [ts.factory.createIdentifier("key")],
+      ),
+      stringify(entry),
+    );
+    statements.push(condition);
+  }
+  statements.push(
+    ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+  );
+
+  return output();
+};
+
+/**
+ * @internal
+ */
+const stringify = (
+  entry: IExpressionEntry<ts.Expression>,
+): ts.ReturnStatement =>
+  ts.factory.createReturnStatement(
+    TemplateFactory.generate([
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("JSON.stringify"),
+        [],
+        [ts.factory.createIdentifier("key")],
+      ),
+      ts.factory.createStringLiteral(":"),
+      entry.expression,
+    ]),
+  );

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -38,7 +38,10 @@ export namespace JsonAssertParseProgrammer {
       functions: assert.functions,
       statements: [
         ...assert.statements,
-        StatementFactory.constant("__assert", assert.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,7 +59,10 @@ export namespace JsonAssertParseProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ],
           false,

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -48,8 +48,14 @@ export namespace JsonAssertStringifyProgrammer {
       statements: [
         ...assert.statements,
         ...stringify.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__stringify", stringify.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__stringify",
+          value: stringify.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -36,7 +36,10 @@ export namespace JsonIsParseProgrammer {
       functions: is.functions,
       statements: [
         ...is.statements,
-        StatementFactory.constant("__is", is.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -52,7 +55,10 @@ export namespace JsonIsParseProgrammer {
             [
               ts.factory.createTypeReferenceNode(
                 props.name ??
-                  TypeFactory.getFullName(props.context.checker)(props.type),
+                  TypeFactory.getFullName({
+                    checker: props.context.checker,
+                    type: props.type,
+                  }),
               ),
             ],
             false,

package/src/programmers/json/JsonIsStringifyProgrammer.ts

@@ -54,8 +54,14 @@ export namespace JsonIsStringifyProgrammer {
       statements: [
         ...is.statements,
         ...stringify.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__stringify", stringify.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__stringify",
+          value: stringify.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,