typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,114 +1,114 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-
-export namespace JsonIsParseProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-      },
-    });
-    return {
-      functions: is.functions,
-      statements: [
-        ...is.statements,
-        StatementFactory.constant({
-          name: "__is",
-          value: is.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
-        ts.factory.createUnionTypeNode([
-          props.context.importer.type({
-            file: "typia",
-            name: "Primitive",
-            arguments: [
-              ts.factory.createTypeReferenceNode(
-                props.name ??
-                  TypeFactory.getFullName({
-                    checker: props.context.checker,
-                    type: props.type,
-                  }),
-              ),
-            ],
-          }),
-          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 = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      context: props.context,
-      functor,
-      type: props.type,
-      name: props.name,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+
+export namespace JsonIsParseProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+      },
+    });
+    return {
+      functions: is.functions,
+      statements: [
+        ...is.statements,
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
+        ts.factory.createUnionTypeNode([
+          props.context.importer.type({
+            file: "typia",
+            name: "Primitive",
+            arguments: [
+              ts.factory.createTypeReferenceNode(
+                props.name ??
+                  TypeFactory.getFullName({
+                    checker: props.context.checker,
+                    type: props.type,
+                  }),
+              ),
+            ],
+          }),
+          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 = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      context: props.context,
+      functor,
+      type: props.type,
+      name: props.name,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/json/JsonIsStringifyProgrammer.ts

@@ -1,108 +1,108 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonIsStringifyProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: true,
-        },
-      },
-      config: {
-        equals: false,
-      },
-    });
-    const stringify: FeatureProgrammer.IDecomposed =
-      JsonStringifyProgrammer.decompose({
-        ...props,
-        context: {
-          ...props.context,
-          options: {
-            ...props.context.options,
-            functional: false,
-            numeric: true,
-          },
-        },
-        validated: true,
-      });
-    return {
-      functions: {
-        ...is.functions,
-        ...stringify.functions,
-      },
-      statements: [
-        ...is.statements,
-        ...stringify.statements,
-        StatementFactory.constant({
-          name: "__is",
-          value: is.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__stringify",
-          value: stringify.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createUnionTypeNode([
-          stringify.arrow.type ?? TypeFactory.keyword("string"),
-          ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-        ]),
-        undefined,
-        ts.factory.createConditionalExpression(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("__is"),
-            undefined,
-            [ts.factory.createIdentifier("input")],
-          ),
-          undefined,
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("__stringify"),
-            undefined,
-            [ts.factory.createIdentifier("input")],
-          ),
-          undefined,
-          ts.factory.createNull(),
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonIsStringifyProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: true,
+        },
+      },
+      config: {
+        equals: false,
+      },
+    });
+    const stringify: FeatureProgrammer.IDecomposed =
+      JsonStringifyProgrammer.decompose({
+        ...props,
+        context: {
+          ...props.context,
+          options: {
+            ...props.context.options,
+            functional: false,
+            numeric: true,
+          },
+        },
+        validated: true,
+      });
+    return {
+      functions: {
+        ...is.functions,
+        ...stringify.functions,
+      },
+      statements: [
+        ...is.statements,
+        ...stringify.statements,
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__stringify",
+          value: stringify.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        ts.factory.createUnionTypeNode([
+          stringify.arrow.type ?? TypeFactory.keyword("string"),
+          ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+        ]),
+        undefined,
+        ts.factory.createConditionalExpression(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("__is"),
+            undefined,
+            [ts.factory.createIdentifier("input")],
+          ),
+          undefined,
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("__stringify"),
+            undefined,
+            [ts.factory.createIdentifier("input")],
+          ),
+          undefined,
+          ts.factory.createNull(),
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/json/JsonSchemasProgrammer.ts

@@ -1,91 +1,91 @@
-import { OpenApi } from "@samchon/openapi";
-import { OpenApiV3Downgrader } from "@samchon/openapi/lib/converters/OpenApiV3Downgrader";
-
-import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { json_schema_station } from "../internal/json_schema_station";
-
-export namespace JsonSchemasProgrammer {
-  export const validate = (metadata: Metadata): string[] => {
-    const output: string[] = [];
-    if (
-      metadata.atomics.some((a) => a.type === "bigint") ||
-      metadata.constants.some((c) => c.type === "bigint")
-    )
-      output.push("JSON schema does not support bigint type.");
-    if (
-      metadata.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      metadata.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("JSON schema does not support undefined type in array.");
-    if (metadata.maps.length)
-      output.push("JSON schema does not support Map type.");
-    if (metadata.sets.length)
-      output.push("JSON schema does not support Set type.");
-    for (const native of metadata.natives)
-      if (
-        AtomicPredicator.native(native.name) === false &&
-        native.name !== "Date" &&
-        native.name !== "Blob" &&
-        native.name !== "File"
-      )
-        output.push(`JSON schema does not support ${native.name} type.`);
-    return output;
-  };
-
-  export const write = <Version extends "3.0" | "3.1">(props: {
-    version: Version;
-    metadatas: Array<Metadata>;
-  }): IJsonSchemaCollection<Version> =>
-    props.version === "3.0"
-      ? (writeV3_0(props.metadatas) as IJsonSchemaCollection<Version>)
-      : (writeV3_1(props.metadatas) as IJsonSchemaCollection<Version>);
-
-  const writeV3_0 = (
-    medadataList: Array<Metadata>,
-  ): IJsonSchemaCollection<"3.0"> => {
-    const collection: IJsonSchemaCollection<"3.1"> = writeV3_1(medadataList);
-    const asset: OpenApiV3Downgrader.IComponentsCollection =
-      OpenApiV3Downgrader.downgradeComponents(collection.components);
-    const caster = OpenApiV3Downgrader.downgradeSchema(asset);
-    return {
-      version: "3.0",
-      components: asset.downgraded,
-      schemas: collection.schemas.map(caster),
-    };
-  };
-
-  const writeV3_1 = (
-    metadataList: Array<Metadata>,
-  ): IJsonSchemaCollection<"3.1"> => {
-    const components: OpenApi.IComponents = {
-      schemas: {},
-    };
-    const generator = (metadata: Metadata): OpenApi.IJsonSchema | null =>
-      json_schema_station({
-        blockNever: true,
-        components,
-        attribute: {},
-        metadata,
-      });
-    return {
-      version: "3.1",
-      components,
-      schemas: metadataList.map((meta, i) => {
-        const schema: OpenApi.IJsonSchema | null = generator(meta);
-        if (schema === null)
-          throw new TransformerError({
-            code: "typia.json.application",
-            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-          });
-        return schema;
-      }),
-    };
-  };
-}
+import { OpenApi } from "@samchon/openapi";
+import { OpenApiV3Downgrader } from "@samchon/openapi/lib/converters/OpenApiV3Downgrader";
+
+import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { json_schema_station } from "../internal/json_schema_station";
+
+export namespace JsonSchemasProgrammer {
+  export const validate = (metadata: Metadata): string[] => {
+    const output: string[] = [];
+    if (
+      metadata.atomics.some((a) => a.type === "bigint") ||
+      metadata.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON schema does not support bigint type.");
+    if (
+      metadata.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      metadata.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON schema does not support undefined type in array.");
+    if (metadata.maps.length)
+      output.push("JSON schema does not support Map type.");
+    if (metadata.sets.length)
+      output.push("JSON schema does not support Set type.");
+    for (const native of metadata.natives)
+      if (
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
+      )
+        output.push(`JSON schema does not support ${native.name} type.`);
+    return output;
+  };
+
+  export const write = <Version extends "3.0" | "3.1">(props: {
+    version: Version;
+    metadatas: Array<Metadata>;
+  }): IJsonSchemaCollection<Version> =>
+    props.version === "3.0"
+      ? (writeV3_0(props.metadatas) as IJsonSchemaCollection<Version>)
+      : (writeV3_1(props.metadatas) as IJsonSchemaCollection<Version>);
+
+  const writeV3_0 = (
+    medadataList: Array<Metadata>,
+  ): IJsonSchemaCollection<"3.0"> => {
+    const collection: IJsonSchemaCollection<"3.1"> = writeV3_1(medadataList);
+    const asset: OpenApiV3Downgrader.IComponentsCollection =
+      OpenApiV3Downgrader.downgradeComponents(collection.components);
+    const caster = OpenApiV3Downgrader.downgradeSchema(asset);
+    return {
+      version: "3.0",
+      components: asset.downgraded,
+      schemas: collection.schemas.map(caster),
+    };
+  };
+
+  const writeV3_1 = (
+    metadataList: Array<Metadata>,
+  ): IJsonSchemaCollection<"3.1"> => {
+    const components: OpenApi.IComponents = {
+      schemas: {},
+    };
+    const generator = (metadata: Metadata): OpenApi.IJsonSchema | null =>
+      json_schema_station({
+        blockNever: true,
+        components,
+        attribute: {},
+        metadata,
+      });
+    return {
+      version: "3.1",
+      components,
+      schemas: metadataList.map((meta, i) => {
+        const schema: OpenApi.IJsonSchema | null = generator(meta);
+        if (schema === null)
+          throw new TransformerError({
+            code: "typia.json.application",
+            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+          });
+        return schema;
+      }),
+    };
+  };
+}