typia 5.3.0-dev.20231117 → 5.3.0-dev.20231119

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -1,50 +1,50 @@
-import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { application_schema } from "../internal/application_schema";
-
-export namespace JsonApplicationProgrammer {
-    export interface IOptions {
-        purpose: "ajv" | "swagger";
-    }
-
-    /**
-     * @internal
-     */
-    export namespace IOptions {
-        export const complement = (options?: Partial<IOptions>): IOptions => {
-            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
-            return {
-                purpose,
-            };
-        };
-    }
-
-    export const write =
-        (options?: Partial<IOptions>) =>
-        (metadatas: Array<Metadata>): IJsonApplication => {
-            const fullOptions: IOptions = IOptions.complement(options);
-            const components: IJsonComponents = {
-                schemas: {},
-            };
-            const generator = application_schema(fullOptions)(true)(components);
-
-            return {
-                schemas: metadatas.map((meta, i) => {
-                    const schema: IJsonSchema | null = generator(meta)({});
-                    if (schema === null)
-                        throw new TransformerError({
-                            code: "typia.json.application",
-                            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-                        });
-                    return schema;
-                }),
-                components,
-                ...fullOptions,
-            };
-        };
-}
+import { IJsonApplication } from "../../schemas/json/IJsonApplication";
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { application_schema } from "../internal/application_schema";
+
+export namespace JsonApplicationProgrammer {
+  export interface IOptions {
+    purpose: "ajv" | "swagger";
+  }
+
+  /**
+   * @internal
+   */
+  export namespace IOptions {
+    export const complement = (options?: Partial<IOptions>): IOptions => {
+      const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
+      return {
+        purpose,
+      };
+    };
+  }
+
+  export const write =
+    (options?: Partial<IOptions>) =>
+    (metadatas: Array<Metadata>): IJsonApplication => {
+      const fullOptions: IOptions = IOptions.complement(options);
+      const components: IJsonComponents = {
+        schemas: {},
+      };
+      const generator = application_schema(fullOptions)(true)(components);
+
+      return {
+        schemas: metadatas.map((meta, i) => {
+          const schema: IJsonSchema | null = generator(meta)({});
+          if (schema === null)
+            throw new TransformerError({
+              code: "typia.json.application",
+              message: `invalid type on argument - (${meta.getName()}, ${i})`,
+            });
+          return schema;
+        }),
+        components,
+        ...fullOptions,
+      };
+    };
+}

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,72 +1,67 @@
-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 { AssertProgrammer } from "../AssertProgrammer";
-
-export namespace JsonAssertParseProgrammer {
-    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.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    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.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("assert"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            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 { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace JsonAssertParseProgrammer {
+  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.Primitive<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          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.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+    };
+}

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -1,66 +1,61 @@
-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 { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonAssertStringifyProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                TypeFactory.keyword("string"),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.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),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("stringify"),
-                            undefined,
-                            [
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("assert"),
-                                    undefined,
-                                    [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 { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonAssertStringifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string) =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        TypeFactory.keyword("string"),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.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),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
+              undefined,
+              [
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("assert"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+              ],
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,78 +1,73 @@
-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 { IsProgrammer } from "../IsProgrammer";
-
-export namespace JsonIsParseProgrammer {
-    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("any"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    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(),
-                        ),
-                    ),
-                ]),
-            );
-        };
-}
+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 { IsProgrammer } from "../IsProgrammer";
+
+export namespace JsonIsParseProgrammer {
+  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("any"))],
+        ts.factory.createTypeReferenceNode(
+          `typia.Primitive<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "is",
+            IsProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          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(),
+            ),
+          ),
+        ]),
+      );
+    };
+}