typia 5.5.8 → 5.5.9

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -1,64 +1,64 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-
-export namespace JsonValidateParseProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction => {
-      JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
-        project.checker,
-        project.context,
-      )(type);
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<typia.Primitive<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>>`,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("JSON.parse"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("output")],
-              ),
-              ts.factory.createTypeReferenceNode("any"),
-            ),
-          ),
-        ]),
-      );
-    };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+
+export namespace JsonValidateParseProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction => {
+      JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+        project.checker,
+        project.context,
+      )(type);
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
+        ts.factory.createTypeReferenceNode(
+          `typia.IValidation<typia.Primitive<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "validate",
+            ValidateProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("JSON.parse"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+    };
+}

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -1,83 +1,83 @@
-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 { ValidateProgrammer } from "../ValidateProgrammer";
-import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonValidateStringifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode("typia.IValidation<string>"),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: true,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            JsonStringifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-              TypeFactory.keyword("any"),
-            ),
-          ),
-          ts.factory.createIfStatement(
-            ts.factory.createIdentifier("output.success"),
-            ts.factory.createExpressionStatement(
-              ts.factory.createBinaryExpression(
-                ts.factory.createIdentifier("output.data"),
-                ts.SyntaxKind.EqualsToken,
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("stringify"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-              ),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ]),
-      );
-}
+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 { ValidateProgrammer } from "../ValidateProgrammer";
+import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonValidateStringifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode("typia.IValidation<string>"),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "validate",
+            ValidateProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: true,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "stringify",
+            JsonStringifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+          ts.factory.createIfStatement(
+            ts.factory.createIdentifier("output.success"),
+            ts.factory.createExpressionStatement(
+              ts.factory.createBinaryExpression(
+                ts.factory.createIdentifier("output.data"),
+                ts.SyntaxKind.EqualsToken,
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("stringify"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+              ),
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ]),
+      );
+}

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -1,77 +1,77 @@
-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 { AssertProgrammer } from "../AssertProgrammer";
-import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-
-export namespace MiscAssertCloneProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression) =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Resolved"),
-          [
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write(project)(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "clone",
-            MiscCloneProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("assert"),
-              undefined,
-              [
-                ts.factory.createIdentifier("input"),
-                AssertProgrammer.Guardian.identifier(),
-              ],
-            ),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("clone"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("output"),
-          ),
-        ]),
-      );
-}
+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 { AssertProgrammer } from "../AssertProgrammer";
+import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+
+export namespace MiscAssertCloneProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write(project)(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "clone",
+            MiscCloneProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("assert"),
+              undefined,
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
+            ),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("clone"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ]),
+      );
+}

package/src/programmers/misc/MiscAssertPruneProgrammer.ts

@@ -1,66 +1,66 @@
-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 { AssertProgrammer } from "../AssertProgrammer";
-import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
-
-export namespace MiscAssertPruneProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression) =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        ts.factory.createTypeReferenceNode(
-          name ?? TypeFactory.getFullName(project.checker)(type),
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write(project)(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "prune",
-            MiscPruneProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("assert"),
-              undefined,
-              [
-                ts.factory.createIdentifier("input"),
-                AssertProgrammer.Guardian.identifier(),
-              ],
-            ),
-          ),
-          ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("prune"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("input"),
-          ),
-        ]),
-      );
-}
+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 { AssertProgrammer } from "../AssertProgrammer";
+import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
+
+export namespace MiscAssertPruneProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
+        ts.factory.createTypeReferenceNode(
+          name ?? TypeFactory.getFullName(project.checker)(type),
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write(project)(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "prune",
+            MiscPruneProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("assert"),
+              undefined,
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
+            ),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("prune"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("input"),
+          ),
+        ]),
+      );
+}