typia 7.0.0-dev.20241007 → 7.0.0-dev.20241008

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -1,99 +1,99 @@
-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 { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-
-export namespace MiscIsCloneProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
-      ...props,
-      config: {
-        equals: false,
-      },
-    });
-    const clone: FeatureProgrammer.IDecomposed = MiscCloneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...is.functions,
-        ...clone.functions,
-      },
-      statements: [
-        ...is.statements,
-        ...clone.statements,
-        StatementFactory.constant({
-          name: "__is",
-          value: is.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__clone",
-          value: clone.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createUnionTypeNode([
-          clone.arrow.type ?? TypeFactory.keyword("any"),
-          ts.factory.createTypeReferenceNode("null"),
-        ]),
-        undefined,
-        ts.factory.createBlock(
-          [
-            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()),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__clone"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  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 { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+
+export namespace MiscIsCloneProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
+      ...props,
+      config: {
+        equals: false,
+      },
+    });
+    const clone: FeatureProgrammer.IDecomposed = MiscCloneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...is.functions,
+        ...clone.functions,
+      },
+      statements: [
+        ...is.statements,
+        ...clone.statements,
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        ts.factory.createUnionTypeNode([
+          clone.arrow.type ?? TypeFactory.keyword("any"),
+          ts.factory.createTypeReferenceNode("null"),
+        ]),
+        undefined,
+        ts.factory.createBlock(
+          [
+            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()),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__clone"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  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/misc/MiscIsPruneProgrammer.ts

@@ -1,97 +1,97 @@
-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 { MiscPruneProgrammer } from "./MiscPruneProgrammer";
-
-export namespace MiscIsPruneProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
-      ...props,
-      config: {
-        equals: false,
-      },
-    });
-    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...is.functions,
-        ...prune.functions,
-      },
-      statements: [
-        ...is.statements,
-        ...prune.statements,
-        StatementFactory.constant({
-          name: "__is",
-          value: is.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__prune",
-          value: prune.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        is.arrow.type,
-        undefined,
-        ts.factory.createBlock(
-          [
-            ts.factory.createIfStatement(
-              ts.factory.createEquality(
-                ts.factory.createFalse(),
-                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()),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  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 { MiscPruneProgrammer } from "./MiscPruneProgrammer";
+
+export namespace MiscIsPruneProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
+      ...props,
+      config: {
+        equals: false,
+      },
+    });
+    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...is.functions,
+        ...prune.functions,
+      },
+      statements: [
+        ...is.statements,
+        ...prune.statements,
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__prune",
+          value: prune.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        is.arrow.type,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createIfStatement(
+              ts.factory.createEquality(
+                ts.factory.createFalse(),
+                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()),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  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/misc/MiscLiteralsProgrammer.ts

@@ -1,80 +1,80 @@
-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 { ITypiaContext } from "../../transformers/ITypiaContext";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { Atomic } from "../../typings/Atomic";
-
-export namespace MiscLiteralsProgrammer {
-  export interface IProps {
-    context: ITypiaContext;
-    type: ts.Type;
-  }
-  export const write = (props: IProps) => {
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        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 [];
-        },
-      },
-      collection: new MetadataCollection(),
-      type: props.type,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: `typia.misc.literals`,
-        errors: result.errors,
-      });
-
-    const metadata: Metadata = result.data;
-    const values: Set<Atomic.Type | null> = new Set([
-      ...metadata.constants.map((c) => c.values.map((v) => v.value)).flat(),
-      ...(metadata.atomics.filter((a) => a.type === "boolean").length
-        ? [true, false]
-        : []),
-      ...(metadata.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 { ITypiaContext } from "../../transformers/ITypiaContext";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { Atomic } from "../../typings/Atomic";
+
+export namespace MiscLiteralsProgrammer {
+  export interface IProps {
+    context: ITypiaContext;
+    type: ts.Type;
+  }
+  export const write = (props: IProps) => {
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        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 [];
+        },
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: `typia.misc.literals`,
+        errors: result.errors,
+      });
+
+    const metadata: Metadata = result.data;
+    const values: Set<Atomic.Type | null> = new Set([
+      ...metadata.constants.map((c) => c.values.map((v) => v.value)).flat(),
+      ...(metadata.atomics.filter((a) => a.type === "boolean").length
+        ? [true, false]
+        : []),
+      ...(metadata.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.",
+}