typia 5.3.12-dev.20240121 → 5.3.12

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -1,70 +1,70 @@
-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,66 +1,66 @@
-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,72 +1,72 @@
-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,
-      project.context,
-    )({
-      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"
-            ? ExpressionFactory.number(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,
+      project.context,
+    )({
+      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"
+            ? ExpressionFactory.number(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.",
+}