typia 6.7.0 → 6.7.1

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,96 +1,96 @@
-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 { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-
-export namespace JsonAssertParseProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name: string | undefined;
-    init: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      project: {
-        ...props.project,
-        options: {
-          ...props.project.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      equals: false,
-      guard: false,
-    });
-    return {
-      functions: assert.functions,
-      statements: [
-        ...assert.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Primitive"),
-          [
-            ts.factory.createTypeReferenceNode(
-              props.name ??
-                TypeFactory.getFullName(props.project.checker)(props.type),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("JSON.parse"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            AssertProgrammer.Guardian.identifier(),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      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 { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+
+export namespace JsonAssertParseProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      equals: false,
+      guard: false,
+    });
+    return {
+      functions: assert.functions,
+      statements: [
+        ...assert.statements,
+        StatementFactory.constant("__assert", assert.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
+          AssertProgrammer.Guardian.parameter(props.init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Primitive"),
+          [
+            ts.factory.createTypeReferenceNode(
+              props.name ??
+                TypeFactory.getFullName(props.project.checker)(props.type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("JSON.parse"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            AssertProgrammer.Guardian.identifier(),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        importer,
+        type,
+        name,
+        init,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -1,104 +1,104 @@
-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 { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonAssertStringifyProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name: string | undefined;
-    init: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      project: {
-        ...props.project,
-        options: {
-          ...props.project.options,
-          functional: false,
-          numeric: true,
-        },
-      },
-      equals: false,
-      guard: false,
-    });
-    const stringify: FeatureProgrammer.IDecomposed =
-      JsonStringifyProgrammer.decompose({
-        ...props,
-        validated: true,
-      });
-    return {
-      functions: {
-        ...assert.functions,
-        ...stringify.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...stringify.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__stringify", stringify.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        stringify.arrow.type,
-        undefined,
-        ts.factory.createBlock(
-          [
-            ts.factory.createExpressionStatement(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__assert"),
-                undefined,
-                [
-                  ts.factory.createIdentifier("input"),
-                  AssertProgrammer.Guardian.identifier(),
-                ],
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__stringify"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      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 { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonAssertStringifyProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: true,
+        },
+      },
+      equals: false,
+      guard: false,
+    });
+    const stringify: FeatureProgrammer.IDecomposed =
+      JsonStringifyProgrammer.decompose({
+        ...props,
+        validated: true,
+      });
+    return {
+      functions: {
+        ...assert.functions,
+        ...stringify.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...stringify.statements,
+        StatementFactory.constant("__assert", assert.arrow),
+        StatementFactory.constant("__stringify", stringify.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(props.init),
+        ],
+        stringify.arrow.type,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createExpressionStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__assert"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("input"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__stringify"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        importer,
+        type,
+        name,
+        init,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,110 +1,110 @@
-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 { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-
-export namespace JsonIsParseProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name?: string;
-  }): FeatureProgrammer.IDecomposed => {
-    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
-      ...props,
-      project: {
-        ...props.project,
-        options: {
-          ...props.project.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      equals: false,
-    });
-    return {
-      functions: is.functions,
-      statements: [
-        ...is.statements,
-        StatementFactory.constant("__is", is.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
-        ts.factory.createUnionTypeNode([
-          ts.factory.createImportTypeNode(
-            ts.factory.createLiteralTypeNode(
-              ts.factory.createStringLiteral("typia"),
-            ),
-            undefined,
-            ts.factory.createIdentifier("Primitive"),
-            [
-              ts.factory.createTypeReferenceNode(
-                props.name ??
-                  TypeFactory.getFullName(props.project.checker)(props.type),
-              ),
-            ],
-            false,
-          ),
-          ts.factory.createTypeReferenceNode("null"),
-        ]),
-        undefined,
-        ts.factory.createBlock([
-          ts.factory.createExpressionStatement(
-            ts.factory.createBinaryExpression(
-              ts.factory.createIdentifier("input"),
-              ts.SyntaxKind.EqualsToken,
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("JSON.parse"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createConditionalExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__is"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-              undefined,
-              ts.factory.createAsExpression(
-                ts.factory.createIdentifier("input"),
-                TypeFactory.keyword("any"),
-              ),
-              undefined,
-              ts.factory.createNull(),
-            ),
-          ),
-        ]),
-      ),
-    };
-  };
-
-  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,
-        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 { IsProgrammer } from "../IsProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+
+export namespace JsonIsParseProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      equals: false,
+    });
+    return {
+      functions: is.functions,
+      statements: [
+        ...is.statements,
+        StatementFactory.constant("__is", is.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
+        ts.factory.createUnionTypeNode([
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Primitive"),
+            [
+              ts.factory.createTypeReferenceNode(
+                props.name ??
+                  TypeFactory.getFullName(props.project.checker)(props.type),
+              ),
+            ],
+            false,
+          ),
+          ts.factory.createTypeReferenceNode("null"),
+        ]),
+        undefined,
+        ts.factory.createBlock([
+          ts.factory.createExpressionStatement(
+            ts.factory.createBinaryExpression(
+              ts.factory.createIdentifier("input"),
+              ts.SyntaxKind.EqualsToken,
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("JSON.parse"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createConditionalExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__is"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+              undefined,
+              ts.factory.createAsExpression(
+                ts.factory.createIdentifier("input"),
+                TypeFactory.keyword("any"),
+              ),
+              undefined,
+              ts.factory.createNull(),
+            ),
+          ),
+        ]),
+      ),
+    };
+  };
+
+  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,
+        importer,
+        type,
+        name,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}