typia 6.7.0 → 6.7.1

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -1,109 +1,109 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
-
-export namespace ProtobufValidateEncodeProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      project: {
-        ...props.project,
-        options: {
-          ...props.project.options,
-          functional: false,
-          numeric: true,
-        },
-      },
-      equals: false,
-    });
-    const encode = ProtobufEncodeProgrammer.decompose(props);
-    return {
-      functions: {
-        ...validate.functions,
-        ...encode.functions,
-      },
-      statements: [
-        ...validate.statements,
-        ...encode.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__encode", encode.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          encode.arrow.type ?? ts.factory.createTypeReferenceNode("Uint8Array"),
-        ]),
-        undefined,
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant(
-              "result",
-              ts.factory.createAsExpression(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("__validate"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-                TypeFactory.keyword("any"),
-              ),
-            ),
-            ts.factory.createIfStatement(
-              ts.factory.createIdentifier("result.success"),
-              ts.factory.createExpressionStatement(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createIdentifier("result.data"),
-                  ts.SyntaxKind.EqualsToken,
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("__encode"),
-                    undefined,
-                    [ts.factory.createIdentifier("input")],
-                  ),
-                ),
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("result"),
-            ),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
+
+export namespace ProtobufValidateEncodeProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    modulo: ts.LeftHandSideExpression;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: true,
+        },
+      },
+      equals: false,
+    });
+    const encode = ProtobufEncodeProgrammer.decompose(props);
+    return {
+      functions: {
+        ...validate.functions,
+        ...encode.functions,
+      },
+      statements: [
+        ...validate.statements,
+        ...encode.statements,
+        StatementFactory.constant("__validate", validate.arrow),
+        StatementFactory.constant("__encode", encode.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        ts.factory.createTypeReferenceNode("typia.IValidation", [
+          encode.arrow.type ?? ts.factory.createTypeReferenceNode("Uint8Array"),
+        ]),
+        undefined,
+        ts.factory.createBlock(
+          [
+            StatementFactory.constant(
+              "result",
+              ts.factory.createAsExpression(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("__validate"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+                TypeFactory.keyword("any"),
+              ),
+            ),
+            ts.factory.createIfStatement(
+              ts.factory.createIdentifier("result.success"),
+              ts.factory.createExpressionStatement(
+                ts.factory.createBinaryExpression(
+                  ts.factory.createIdentifier("result.data"),
+                  ts.SyntaxKind.EqualsToken,
+                  ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("__encode"),
+                    undefined,
+                    [ts.factory.createIdentifier("input")],
+                  ),
+                ),
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createIdentifier("result"),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        modulo,
+        importer,
+        type,
+        name,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,104 +1,104 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-export namespace GenericTransformer {
-  export const scalar =
-    (method: string) =>
-    (
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (type: ts.Type, name: string) => ts.Expression | ts.ArrowFunction,
-    ) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression) => {
-      // CHECK PARAMETER
-      if (expression.arguments.length === 0)
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `no input value.`,
-        });
-
-      // GET TYPE INFO
-      const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-        expression.typeArguments && expression.typeArguments[0]
-          ? [
-              project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
-              expression.typeArguments[0],
-              true,
-            ]
-          : [
-              project.checker.getTypeAtLocation(expression.arguments[0]!),
-              expression.arguments[0]!,
-              false,
-            ];
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `non-specified generic argument.`,
-        });
-
-      // DO TRANSFORM
-      return ts.factory.createCallExpression(
-        programmer(project)(modulo)(
-          type,
-          generic
-            ? node.getFullText().trim()
-            : name(project.checker)(type)(node),
-        ),
-        undefined,
-        expression.arguments,
-      );
-    };
-
-  export const factory =
-    (method: string) =>
-    (
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (
-        type: ts.Type,
-        name: string,
-        init?: ts.Expression,
-      ) => ts.Expression | ts.ArrowFunction,
-    ) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression) => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `generic argument is not specified.`,
-        });
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `non-specified generic argument.`,
-        });
-
-      // DO TRANSFORM
-      return programmer(project)(modulo)(
-        type,
-        node.getFullText().trim(),
-        expression.arguments[0],
-      );
-    };
-
-  const name =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type) =>
-    (node: ts.Node): string =>
-      checker.typeToString(type, node, ts.TypeFormatFlags.NodeBuilderFlagsMask);
-}
+import ts from "typescript";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+export namespace GenericTransformer {
+  export const scalar =
+    (method: string) =>
+    (
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (type: ts.Type, name: string) => ts.Expression | ts.ArrowFunction,
+    ) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+        expression.typeArguments && expression.typeArguments[0]
+          ? [
+              project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
+              expression.typeArguments[0],
+              true,
+            ]
+          : [
+              project.checker.getTypeAtLocation(expression.arguments[0]!),
+              expression.arguments[0]!,
+              false,
+            ];
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `non-specified generic argument.`,
+        });
+
+      // DO TRANSFORM
+      return ts.factory.createCallExpression(
+        programmer(project)(modulo)(
+          type,
+          generic
+            ? node.getFullText().trim()
+            : name(project.checker)(type)(node),
+        ),
+        undefined,
+        expression.arguments,
+      );
+    };
+
+  export const factory =
+    (method: string) =>
+    (
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (
+        type: ts.Type,
+        name: string,
+        init?: ts.Expression,
+      ) => ts.Expression | ts.ArrowFunction,
+    ) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK GENERIC ARGUMENT EXISTENCE
+      if (!expression.typeArguments?.[0])
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `generic argument is not specified.`,
+        });
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `non-specified generic argument.`,
+        });
+
+      // DO TRANSFORM
+      return programmer(project)(modulo)(
+        type,
+        node.getFullText().trim(),
+        expression.arguments[0],
+      );
+    };
+
+  const name =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type) =>
+    (node: ts.Node): string =>
+      checker.typeToString(type, node, ts.TypeFormatFlags.NodeBuilderFlagsMask);
+}