typia 4.0.0-dev.20230520 → 4.0.0-dev.20230527

package/src/programmers/ApplicationProgrammer.ts

@@ -1,48 +1,48 @@
-import { Metadata } from "../metadata/Metadata";
-import { IJsonApplication } from "../schemas/IJsonApplication";
-import { IJsonComponents } from "../schemas/IJsonComponents";
-import { IJsonSchema } from "../schemas/IJsonSchema";
-
-import { application_schema } from "./internal/application_schema";
-
-export namespace ApplicationProgrammer {
-    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 Error(
-                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                        );
-                    return schema;
-                }),
-                components,
-                ...fullOptions,
-                prefix: "#/components/schemas",
-            };
-        };
-}
+import { Metadata } from "../metadata/Metadata";
+import { IJsonApplication } from "../schemas/IJsonApplication";
+import { IJsonComponents } from "../schemas/IJsonComponents";
+import { IJsonSchema } from "../schemas/IJsonSchema";
+
+import { application_schema } from "./internal/application_schema";
+
+export namespace ApplicationProgrammer {
+    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 Error(
+                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
+                        );
+                    return schema;
+                }),
+                components,
+                ...fullOptions,
+                prefix: "#/components/schemas",
+            };
+        };
+}

package/src/programmers/AssertCloneProgrammer.ts

@@ -1,68 +1,68 @@
-import type ts from "typescript/lib/tsclibrary";
-
-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 { CloneProgrammer } from "./CloneProgrammer";
-
-export namespace AssertCloneProgrammer {
-    export const write =
-        (p: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            p.tsc.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(p.tsc)(
-                        "input",
-                        TypeFactory.keyword(p.tsc)("any"),
-                    ),
-                ],
-                p.tsc.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(p)(type)
-                    }>`,
-                ),
-                undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
-                        "assert",
-                        AssertProgrammer.write(p)(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(p.tsc)(
-                        "clone",
-                        CloneProgrammer.write({
-                            ...p,
-                            options: {
-                                ...p.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    p.tsc.factory.createExpressionStatement(
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("assert"),
-                            undefined,
-                            [p.tsc.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    StatementFactory.constant(p.tsc)(
-                        "output",
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("clone"),
-                            undefined,
-                            [p.tsc.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+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 { CloneProgrammer } from "./CloneProgrammer";
+
+export namespace AssertCloneProgrammer {
+    export const write =
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            p.tsc.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(p.tsc)(
+                        "input",
+                        TypeFactory.keyword(p.tsc)("any"),
+                    ),
+                ],
+                p.tsc.factory.createTypeReferenceNode(
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(p)(type)
+                    }>`,
+                ),
+                undefined,
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
+                        "assert",
+                        AssertProgrammer.write(p)(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "clone",
+                        CloneProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("assert"),
+                            undefined,
+                            [p.tsc.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "output",
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("clone"),
+                            undefined,
+                            [p.tsc.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/AssertParseProgrammer.ts

@@ -1,66 +1,66 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { AssertProgrammer } from "./AssertProgrammer";
-
-export namespace AssertParseProgrammer {
-    export const write =
-        (p: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            p.tsc.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(p.tsc)(
-                        "input",
-                        TypeFactory.keyword(p.tsc)("string"),
-                    ),
-                ],
-                p.tsc.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(p)(type)
-                    }>`,
-                ),
-                undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...p,
-                            options: {
-                                ...p.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    p.tsc.factory.createExpressionStatement(
-                        p.tsc.factory.createBinaryExpression(
-                            p.tsc.factory.createIdentifier("input"),
-                            p.tsc.SyntaxKind.EqualsToken,
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("JSON.parse"),
-                                undefined,
-                                [p.tsc.factory.createIdentifier("input")],
-                            ),
-                        ),
-                    ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createAsExpression(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("assert"),
-                                undefined,
-                                [p.tsc.factory.createIdentifier("input")],
-                            ),
-                            p.tsc.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { AssertProgrammer } from "./AssertProgrammer";
+
+export namespace AssertParseProgrammer {
+    export const write =
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            p.tsc.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(p.tsc)(
+                        "input",
+                        TypeFactory.keyword(p.tsc)("string"),
+                    ),
+                ],
+                p.tsc.factory.createTypeReferenceNode(
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(p)(type)
+                    }>`,
+                ),
+                undefined,
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createBinaryExpression(
+                            p.tsc.factory.createIdentifier("input"),
+                            p.tsc.SyntaxKind.EqualsToken,
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("JSON.parse"),
+                                undefined,
+                                [p.tsc.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createAsExpression(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("assert"),
+                                undefined,
+                                [p.tsc.factory.createIdentifier("input")],
+                            ),
+                            p.tsc.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}