typia 7.0.0-dev.20240918 → 7.0.0-dev.20240919

package/src/programmers/helpers/NotationJoiner.ts

@@ -12,14 +12,14 @@ import { IExpressionEntry } from "./IExpressionEntry";
 export namespace NotationJoiner {
   export const object =
     (rename: (str: string) => string) =>
-    (
-      input: ts.Expression,
-      entries: IExpressionEntry<ts.Expression>[],
-    ): ts.ConciseBody => {
-      if (entries.length === 0) return ts.factory.createIdentifier("{}");
+    (props: {
+      input: ts.Expression;
+      entries: IExpressionEntry<ts.Expression>[];
+    }): ts.ConciseBody => {
+      if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
 
-      const regular = entries.filter((e) => e.key.isSoleLiteral());
-      const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+      const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+      const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
       const literal = ts.factory.createObjectLiteralExpression(
         regular.map((entry) => {
           const str: string = rename(entry.key.getSoleLiteral()!);
@@ -100,7 +100,7 @@ export namespace NotationJoiner {
           ts.factory.createCallExpression(
             ts.factory.createIdentifier("Object.entries"),
             undefined,
-            [input],
+            [props.input],
           ),
           ts.factory.createBlock(statements),
         ),
@@ -108,25 +108,28 @@ export namespace NotationJoiner {
       ]);
     };
 
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
     return ts.factory.createAsExpression(
       ts.factory.createArrayLiteralExpression(
-        rest === null
-          ? children
-          : [...children, ts.factory.createSpreadElement(rest)],
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
         true,
       ),
       TypeFactory.keyword("any"),
     );
   };
 
-  export const array = (input: ts.Expression, arrow: ts.Expression) =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
     ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(input, "map"),
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
       undefined,
-      [arrow],
+      [props.arrow],
     );
 }

package/src/programmers/helpers/PruneJoiner.ts

@@ -9,14 +9,14 @@ import { prune_object_properties } from "../internal/prune_object_properties";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace PruneJoiner {
-  export const object = (
-    input: ts.Expression,
-    entries: IExpressionEntry[],
-    obj: MetadataObject,
-  ): ts.ConciseBody => {
+  export const object = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry[];
+    object: MetadataObject;
+  }): ts.ConciseBody => {
     // PREPARE ASSETS
-    const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
 
     const statements: ts.Statement[] = regular
       .map((entry) =>
@@ -28,27 +28,34 @@ export namespace PruneJoiner {
     if (dynamic.length)
       statements.push(
         ts.factory.createExpressionStatement(
-          iterate_dynamic_properties({ regular, dynamic })(input),
+          iterate_dynamic_properties({
+            regular,
+            dynamic,
+            input: props.input,
+          }),
         ),
       );
 
-    statements.push(prune_object_properties(obj));
+    statements.push(prune_object_properties(props.object));
     return ts.factory.createBlock(statements, true);
   };
 
-  export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }) =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(input)("forEach"),
+      IdentifierFactory.access(props.input)("forEach"),
       undefined,
-      [arrow],
+      [props.arrow],
     );
 
-  export const tuple = (
-    children: ts.ConciseBody[],
-    rest: ts.ConciseBody | null,
-  ): ts.Block => {
-    const entire: ts.ConciseBody[] = [...children];
-    if (rest !== null) entire.push(rest);
+  export const tuple = (props: {
+    elements: ts.ConciseBody[];
+    rest: ts.ConciseBody | null;
+  }): ts.Block => {
+    const entire: ts.ConciseBody[] = [...props.elements];
+    if (props.rest !== null) entire.push(props.rest);
 
     const statements: ts.Statement[] = entire
       .map((elem) =>
@@ -61,79 +68,77 @@ export namespace PruneJoiner {
   };
 }
 
-const iterate_dynamic_properties =
-  (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
-  (input: ts.Expression) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [input],
-        ),
-      )("forEach"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            IdentifierFactory.parameter(
-              ts.factory.createArrayBindingPattern(
-                ["key", "value"].map((l) =>
-                  ts.factory.createBindingElement(
-                    undefined,
-                    undefined,
-                    ts.factory.createIdentifier(l),
-                    undefined,
-                  ),
+const iterate_dynamic_properties = (props: {
+  regular: IExpressionEntry[];
+  dynamic: IExpressionEntry[];
+  input: ts.Expression;
+}) =>
+  ts.factory.createCallExpression(
+    IdentifierFactory.access(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("Object.entries"),
+        undefined,
+        [props.input],
+      ),
+    )("forEach"),
+    undefined,
+    [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            ts.factory.createArrayBindingPattern(
+              ["key", "value"].map((l) =>
+                ts.factory.createBindingElement(
+                  undefined,
+                  undefined,
+                  ts.factory.createIdentifier(l),
+                  undefined,
                 ),
               ),
             ),
-          ],
-          undefined,
-          undefined,
-          ts.factory.createBlock(
-            [
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createIfStatement(
+              ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+              ),
+              ts.factory.createReturnStatement(),
+            ),
+            ...props.regular.map(({ key }) =>
               ts.factory.createIfStatement(
                 ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  ts.factory.createIdentifier("value"),
+                  ts.factory.createStringLiteral(key.getSoleLiteral()!),
+                  ts.factory.createIdentifier("key"),
                 ),
                 ts.factory.createReturnStatement(),
               ),
-              ...props.regular.map(({ key }) =>
-                ts.factory.createIfStatement(
-                  ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral(key.getSoleLiteral()!),
-                    ts.factory.createIdentifier("key"),
-                  ),
-                  ts.factory.createReturnStatement(),
-                ),
-              ),
-              ...props.dynamic.map((dynamic) =>
-                ts.factory.createIfStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                      `RegExp(/${metadata_to_pattern(true)(
-                        dynamic.key,
-                      )}/).test`,
-                    ),
-                    undefined,
-                    [ts.factory.createIdentifier("key")],
+            ),
+            ...props.dynamic.map((dynamic) =>
+              ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(dynamic.key)}/).test`,
                   ),
-                  ts.isBlock(dynamic.expression)
-                    ? dynamic.expression
-                    : ts.factory.createBlock([
-                        ts.factory.createExpressionStatement(
-                          dynamic.expression,
-                        ),
-                      ]),
+                  undefined,
+                  [ts.factory.createIdentifier("key")],
                 ),
+                ts.isBlock(dynamic.expression)
+                  ? dynamic.expression
+                  : ts.factory.createBlock([
+                      ts.factory.createExpressionStatement(dynamic.expression),
+                    ]),
               ),
-            ],
-            true,
-          ),
+            ),
+          ],
+          true,
         ),
-      ],
-    );
+      ),
+    ],
+  );

package/src/programmers/helpers/StringifyJoinder.ts

@@ -11,18 +11,16 @@ import { IExpressionEntry } from "./IExpressionEntry";
 export namespace StringifyJoiner {
   export const object =
     (importer: FunctionImporter) =>
-    (
-      _input: ts.Expression,
-      entries: IExpressionEntry<ts.Expression>[],
-    ): ts.Expression => {
+    (props: { entries: IExpressionEntry<ts.Expression>[] }): ts.Expression => {
       // CHECK AND SORT ENTRIES
-      if (entries.length === 0) return ts.factory.createStringLiteral("{}");
+      if (props.entries.length === 0)
+        return ts.factory.createStringLiteral("{}");
 
       // PROPERTIES
-      const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
+      const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
         (entry) => entry.key.isSoleLiteral(),
       );
-      const dynamic: IExpressionEntry<ts.Expression>[] = entries.filter(
+      const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
         (entry) => !entry.key.isSoleLiteral(),
       );
       const expressions: ts.Expression[] = [
@@ -58,18 +56,18 @@ export namespace StringifyJoiner {
       ]);
     };
 
-  export const array = (
-    input: ts.Expression,
-    arrow: ts.ArrowFunction,
-  ): ts.Expression =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }): ts.Expression =>
     TemplateFactory.generate([
       ts.factory.createStringLiteral(`[`),
       ts.factory.createCallExpression(
         ts.factory.createPropertyAccessExpression(
           ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("map"),
+            IdentifierFactory.access(props.input)("map"),
             undefined,
-            [arrow],
+            [props.arrow],
           ),
           ts.factory.createIdentifier("join"),
         ),
@@ -79,27 +77,33 @@ export namespace StringifyJoiner {
       ts.factory.createStringLiteral(`]`),
     ]);
 
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
-    if (children.length === 0) return ts.factory.createStringLiteral("[]");
-    if (rest === null && children.every((child) => ts.isStringLiteral(child)))
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
+    if (props.elements.length === 0)
+      return ts.factory.createStringLiteral("[]");
+    if (
+      props.rest === null &&
+      props.elements.every((child) => ts.isStringLiteral(child))
+    )
       return ts.factory.createStringLiteral(
         "[" +
-          children.map((child) => (child as ts.StringLiteral).text).join(",") +
+          props.elements
+            .map((child) => (child as ts.StringLiteral).text)
+            .join(",") +
           "]",
       );
 
-    const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
-    children.forEach((child, i) => {
-      elements.push(child);
-      if (i !== children.length - 1)
-        elements.push(ts.factory.createStringLiteral(`,`));
+    const expressions: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
+    props.elements.forEach((child, i) => {
+      expressions.push(child);
+      if (i !== props.elements.length - 1)
+        expressions.push(ts.factory.createStringLiteral(`,`));
     });
-    if (rest !== null) elements.push(rest);
+    if (props.rest !== null) expressions.push(props.rest);
 
-    elements.push(ts.factory.createStringLiteral(`]`));
-    return TemplateFactory.generate(elements);
+    expressions.push(ts.factory.createStringLiteral(`]`));
+    return TemplateFactory.generate(expressions);
   };
 }

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -1,110 +1,110 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-
-export namespace HttpParameterProgrammer {
-  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      },
-      collection: new MetadataCollection(),
-      type: props.type,
-    });
-    if (result.success === false)
-      throw TransformerError.from(props.modulo.getText())(result.errors);
-
-    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-    const importer: FunctionImporter = new FunctionImporter(
-      props.modulo.getText(),
-    );
-    const block: ts.Statement[] = [
-      StatementFactory.constant(
-        "assert",
-        AssertProgrammer.write({
-          ...props,
-          context: {
-            ...props.context,
-            options: {
-              numeric: true,
-            },
-          },
-          config: {
-            equals: false,
-            guard: false,
-          },
-        }),
-      ),
-      StatementFactory.constant(
-        "value",
-        ts.factory.createCallExpression(importer.use(atomic), undefined, [
-          ts.factory.createIdentifier("input"),
-        ]),
-      ),
-      ts.factory.createReturnStatement(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("assert"),
-          undefined,
-          [ts.factory.createIdentifier("value")],
-        ),
-      ),
-    ];
-
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [
-        IdentifierFactory.parameter(
-          "input",
-          ts.factory.createTypeReferenceNode("string"),
-        ),
-      ],
-      ts.factory.createTypeReferenceNode(
-        props.name ??
-          TypeFactory.getFullName(props.context.checker)(props.type),
-      ),
-      undefined,
-      ts.factory.createBlock(
-        [...importer.declare(props.modulo), ...block],
-        true,
-      ),
-    );
-  };
-
-  export const validate = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = HttpMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpParameterProgrammer {
+  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from(props.modulo.getText())(result.errors);
+
+    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const block: ts.Statement[] = [
+      StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write({
+          ...props,
+          context: {
+            ...props.context,
+            options: {
+              numeric: true,
+            },
+          },
+          config: {
+            equals: false,
+            guard: false,
+          },
+        }),
+      ),
+      StatementFactory.constant(
+        "value",
+        ts.factory.createCallExpression(importer.use(atomic), undefined, [
+          ts.factory.createIdentifier("input"),
+        ]),
+      ),
+      ts.factory.createReturnStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [ts.factory.createIdentifier("value")],
+        ),
+      ),
+    ];
+
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [
+        IdentifierFactory.parameter(
+          "input",
+          ts.factory.createTypeReferenceNode("string"),
+        ),
+      ],
+      ts.factory.createTypeReferenceNode(
+        props.name ??
+          TypeFactory.getFullName(props.context.checker)(props.type),
+      ),
+      undefined,
+      ts.factory.createBlock(
+        [...importer.declare(props.modulo), ...block],
+        true,
+      ),
+    );
+  };
+
+  export const validate = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = HttpMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+}