typia 5.0.4-dev.20230911 → 5.0.5-dev.20230921

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -1,78 +1,78 @@
-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 { IsProgrammer } from "../IsProgrammer";
-import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-
-export namespace MiscIsCloneProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                ts.factory.createUnionTypeNode([
-                    ts.factory.createTypeReferenceNode(
-                        `typia.Resolved<${
-                            name ??
-                            TypeFactory.getFullName(project.checker)(type)
-                        }>`,
-                    ),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-                ]),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write(project)(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "clone",
-                        MiscCloneProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createNull(),
-                        ),
-                    ),
-                    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 { IsProgrammer } from "../IsProgrammer";
+import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+
+export namespace MiscIsCloneProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode(
+                        `typia.Resolved<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
+                    ),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "clone",
+                        MiscCloneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                    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/MiscIsPruneProgrammer.ts

@@ -1,73 +1,73 @@
-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 { IsProgrammer } from "../IsProgrammer";
-import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
-
-export namespace MiscIsPruneProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                ts.factory.createTypePredicateNode(
-                    undefined,
-                    "input",
-                    ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
-                    ),
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write(project)(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "prune",
-                        MiscPruneProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createFalse(),
-                        ),
-                    ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("prune"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(ts.factory.createTrue()),
-                ]),
-            );
-}
+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 { IsProgrammer } from "../IsProgrammer";
+import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
+
+export namespace MiscIsPruneProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypePredicateNode(
+                    undefined,
+                    "input",
+                    ts.factory.createTypeReferenceNode(
+                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    ),
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "prune",
+                        MiscPruneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createFalse(),
+                        ),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("prune"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(ts.factory.createTrue()),
+                ]),
+            );
+}

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -1,69 +1,69 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace MiscLiteralsProgrammer {
-    export const write = (project: IProject) => (type: ts.Type) => {
-        const result = MetadataFactory.analyze(project.checker)({
-            escape: true,
-            constant: true,
-            absorb: true,
-            validate: (meta) => {
-                const length: number =
-                    meta.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    meta.atomics.filter((a) => a.type === "boolean").length;
-                if (0 === length) return [ErrorMessages.NO];
-                else if (meta.size() !== length) return [ErrorMessages.ONLY];
-                return [];
-            },
-        })(new MetadataCollection())(type);
-        if (result.success === false)
-            throw TransformerError.from(`typia.misc.literals`)(result.errors);
-
-        const meta: Metadata = result.data;
-        const values: Set<Atomic.Type | null> = new Set([
-            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
-            ...(meta.atomics.filter((a) => a.type === "boolean").length
-                ? [true, false]
-                : []),
-            ...(meta.nullable ? [null] : []),
-        ]);
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                [...values].map((v) =>
-                    v === null
-                        ? ts.factory.createNull()
-                        : typeof v === "boolean"
-                        ? v
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
-                        : typeof v === "number"
-                        ? ts.factory.createNumericLiteral(v)
-                        : typeof v === "bigint"
-                        ? ExpressionFactory.bigint(Number(v))
-                        : ts.factory.createStringLiteral(v),
-                ),
-                true,
-            ),
-            ts.factory.createTypeReferenceNode("const"),
-        );
-    };
-}
-
-enum ErrorMessages {
-    NO = "no constant literal type found.",
-    ONLY = "only constant literal types are allowed.",
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace MiscLiteralsProgrammer {
+    export const write = (project: IProject) => (type: ts.Type) => {
+        const result = MetadataFactory.analyze(project.checker)({
+            escape: true,
+            constant: true,
+            absorb: true,
+            validate: (meta) => {
+                const length: number =
+                    meta.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    meta.atomics.filter((a) => a.type === "boolean").length;
+                if (0 === length) return [ErrorMessages.NO];
+                else if (meta.size() !== length) return [ErrorMessages.ONLY];
+                return [];
+            },
+        })(new MetadataCollection())(type);
+        if (result.success === false)
+            throw TransformerError.from(`typia.misc.literals`)(result.errors);
+
+        const meta: Metadata = result.data;
+        const values: Set<Atomic.Type | null> = new Set([
+            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
+            ...(meta.atomics.filter((a) => a.type === "boolean").length
+                ? [true, false]
+                : []),
+            ...(meta.nullable ? [null] : []),
+        ]);
+        return ts.factory.createAsExpression(
+            ts.factory.createArrayLiteralExpression(
+                [...values].map((v) =>
+                    v === null
+                        ? ts.factory.createNull()
+                        : typeof v === "boolean"
+                        ? v
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse()
+                        : typeof v === "number"
+                        ? ts.factory.createNumericLiteral(v)
+                        : typeof v === "bigint"
+                        ? ExpressionFactory.bigint(Number(v))
+                        : ts.factory.createStringLiteral(v),
+                ),
+                true,
+            ),
+            ts.factory.createTypeReferenceNode("const"),
+        );
+    };
+}
+
+enum ErrorMessages {
+    NO = "no constant literal type found.",
+    ONLY = "only constant literal types are allowed.",
+}