typia 5.3.12-dev.20240121 → 5.3.12

package/src/transformers/internal/GenericTransformer.ts

@@ -1,96 +1,96 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-export namespace GenericTransformer {
-  export const scalar =
-    (method: string) =>
-    (
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-    ) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression) => {
-      // CHECK PARAMETER
-      if (expression.arguments.length !== 1)
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `no input value.`,
-        });
-
-      // GET TYPE INFO
-      const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-        expression.typeArguments && expression.typeArguments[0]
-          ? [
-              project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
-              expression.typeArguments[0],
-              true,
-            ]
-          : [
-              project.checker.getTypeAtLocation(expression.arguments[0]!),
-              expression.arguments[0]!,
-              false,
-            ];
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `non-specified generic argument.`,
-        });
-
-      // DO TRANSFORM
-      return ts.factory.createCallExpression(
-        programmer(project)(modulo)(
-          type,
-          generic
-            ? node.getFullText().trim()
-            : name(project.checker)(type)(node),
-        ),
-        undefined,
-        [expression.arguments[0]!],
-      );
-    };
-
-  export const factory =
-    (method: string) =>
-    (
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-    ) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression) => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `generic argument is not specified.`,
-        });
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${method}`,
-          message: `non-specified generic argument.`,
-        });
-
-      // DO TRANSFORM
-      return programmer(project)(modulo)(type, node.getFullText().trim());
-    };
-
-  const name =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type) =>
-    (node: ts.Node): string =>
-      checker.typeToString(type, node, ts.TypeFormatFlags.NodeBuilderFlagsMask);
-}
+import ts from "typescript";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+export namespace GenericTransformer {
+  export const scalar =
+    (method: string) =>
+    (
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+    ) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length !== 1)
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+        expression.typeArguments && expression.typeArguments[0]
+          ? [
+              project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
+              expression.typeArguments[0],
+              true,
+            ]
+          : [
+              project.checker.getTypeAtLocation(expression.arguments[0]!),
+              expression.arguments[0]!,
+              false,
+            ];
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `non-specified generic argument.`,
+        });
+
+      // DO TRANSFORM
+      return ts.factory.createCallExpression(
+        programmer(project)(modulo)(
+          type,
+          generic
+            ? node.getFullText().trim()
+            : name(project.checker)(type)(node),
+        ),
+        undefined,
+        [expression.arguments[0]!],
+      );
+    };
+
+  export const factory =
+    (method: string) =>
+    (
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+    ) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK GENERIC ARGUMENT EXISTENCE
+      if (!expression.typeArguments?.[0])
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `generic argument is not specified.`,
+        });
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: `typia.${method}`,
+          message: `non-specified generic argument.`,
+        });
+
+      // DO TRANSFORM
+      return programmer(project)(modulo)(type, node.getFullText().trim());
+    };
+
+  const name =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type) =>
+    (node: ts.Node): string =>
+      checker.typeToString(type, node, ts.TypeFormatFlags.NodeBuilderFlagsMask);
+}

package/src/typings/Atomic.ts

@@ -1,13 +1,13 @@
-export namespace Atomic {
-  export type Type = boolean | number | string | bigint;
-
-  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
-
-  export type Mapper = {
-    boolean: boolean;
-    integer: number;
-    number: number;
-    string: string;
-    bigint: bigint;
-  };
-}
+export namespace Atomic {
+  export type Type = boolean | number | string | bigint;
+
+  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
+
+  export type Mapper = {
+    boolean: boolean;
+    integer: number;
+    number: number;
+    string: string;
+    bigint: bigint;
+  };
+}

package/src/typings/ClassProperties.ts

@@ -1,5 +1,5 @@
-import { OmitNever } from "./OmitNever";
-
-export type ClassProperties<T extends object> = OmitNever<{
-  [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+export type ClassProperties<T extends object> = OmitNever<{
+  [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/Customizable.ts

@@ -1,5 +1,5 @@
-export type Customizable = {
-  number: number;
-  string: string;
-  bigint: bigint;
-};
+export type Customizable = {
+  number: number;
+  string: string;
+  bigint: bigint;
+};

package/src/typings/OmitNever.ts

@@ -1,3 +1,3 @@
-import { SpecialFields } from "./SpecialFields";
-
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;

package/src/typings/ProtobufAtomic.ts

@@ -1,19 +1,19 @@
-export type ProtobufAtomic =
-  | "bool"
-  | "int32"
-  | "uint32"
-  | "int64"
-  | "uint64"
-  | "float"
-  | "double"
-  | "string";
-export namespace ProtobufAtomic {
-  export type Numeric =
-    | "int32"
-    | "uint32"
-    | "int64"
-    | "uint64"
-    | "float"
-    | "double";
-  export type BigNumeric = "int64" | "uint64";
-}
+export type ProtobufAtomic =
+  | "bool"
+  | "int32"
+  | "uint32"
+  | "int64"
+  | "uint64"
+  | "float"
+  | "double"
+  | "string";
+export namespace ProtobufAtomic {
+  export type Numeric =
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double";
+  export type BigNumeric = "int64" | "uint64";
+}

package/src/typings/SpecialFields.ts

@@ -1,3 +1,3 @@
-export type SpecialFields<Instance extends object, Target> = {
-  [P in keyof Instance]: Instance[P] extends Target ? P : never;
-}[keyof Instance & string];
+export type SpecialFields<Instance extends object, Target> = {
+  [P in keyof Instance]: Instance[P] extends Target ? P : never;
+}[keyof Instance & string];

package/src/typings/ValidationPipe.ts

@@ -1,9 +1,9 @@
-export type ValidationPipe<T, E> =
-  | {
-      success: true;
-      data: T;
-    }
-  | {
-      success: false;
-      errors: E[];
-    };
+export type ValidationPipe<T, E> =
+  | {
+      success: true;
+      data: T;
+    }
+  | {
+      success: false;
+      errors: E[];
+    };

package/src/typings/Writable.ts

@@ -1,11 +1,11 @@
-import { ClassProperties } from "./ClassProperties";
-
-export type Writable<T extends object> = {
-  -readonly [P in keyof T]: T[P];
-};
-
-export function Writable<T extends object>(
-  elem: T,
-): Writable<ClassProperties<T>> {
-  return elem as any;
-}
+import { ClassProperties } from "./ClassProperties";
+
+export type Writable<T extends object> = {
+  -readonly [P in keyof T]: T[P];
+};
+
+export function Writable<T extends object>(
+  elem: T,
+): Writable<ClassProperties<T>> {
+  return elem as any;
+}

package/src/utils/ArrayUtil.ts

@@ -1,43 +1,43 @@
-export namespace ArrayUtil {
-  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
-    array.some(pred);
-
-  export const add = <T>(
-    array: T[],
-    value: T,
-    pred: (x: T, y: T) => boolean = (x, y) => x === y,
-  ): boolean => {
-    if (array.some((elem) => pred(elem, value))) return false;
-    array.push(value);
-    return true;
-  };
-
-  export const set = <Key, T>(
-    array: T[],
-    value: T,
-    key: (elem: T) => Key,
-  ): void => {
-    if (array.some((elem) => key(elem) === key(value))) return;
-    array.push(value);
-  };
-
-  export const take = <T>(
-    array: T[],
-    pred: (elem: T) => boolean,
-    init: () => T,
-  ): T => {
-    const index: number = array.findIndex(pred);
-    if (index !== -1) return array[index]!;
-
-    const elem: T = init();
-    array.push(elem);
-    return elem;
-  };
-
-  export const repeat = <T>(
-    count: number,
-    closure: (index: number, count: number) => T,
-  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
-
-  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
-}
+export namespace ArrayUtil {
+  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
+    array.some(pred);
+
+  export const add = <T>(
+    array: T[],
+    value: T,
+    pred: (x: T, y: T) => boolean = (x, y) => x === y,
+  ): boolean => {
+    if (array.some((elem) => pred(elem, value))) return false;
+    array.push(value);
+    return true;
+  };
+
+  export const set = <Key, T>(
+    array: T[],
+    value: T,
+    key: (elem: T) => Key,
+  ): void => {
+    if (array.some((elem) => key(elem) === key(value))) return;
+    array.push(value);
+  };
+
+  export const take = <T>(
+    array: T[],
+    pred: (elem: T) => boolean,
+    init: () => T,
+  ): T => {
+    const index: number = array.findIndex(pred);
+    if (index !== -1) return array[index]!;
+
+    const elem: T = init();
+    array.push(elem);
+    return elem;
+  };
+
+  export const repeat = <T>(
+    count: number,
+    closure: (index: number, count: number) => T,
+  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
+
+  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
+}

package/src/utils/Escaper.ts

@@ -1,46 +1,46 @@
-export namespace Escaper {
-  export const variable = (str: string): boolean =>
-    reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-
-  export const reserved = (str: string): boolean => RESERVED.has(str);
-}
-
-const RESERVED: Set<string> = new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "package",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-]);
+export namespace Escaper {
+  export const variable = (str: string): boolean =>
+    reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+
+  export const reserved = (str: string): boolean => RESERVED.has(str);
+}
+
+const RESERVED: Set<string> = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "package",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,12 +1,12 @@
-export namespace MapUtil {
-  export const take =
-    <Key, T>(dict: Map<Key, T>) =>
-    (key: Key, generator: () => T): T => {
-      const oldbie: T | undefined = dict.get(key);
-      if (oldbie) return oldbie;
-
-      const value: T = generator();
-      dict.set(key, value);
-      return value;
-    };
-}
+export namespace MapUtil {
+  export const take =
+    <Key, T>(dict: Map<Key, T>) =>
+    (key: Key, generator: () => T): T => {
+      const oldbie: T | undefined = dict.get(key);
+      if (oldbie) return oldbie;
+
+      const value: T = generator();
+      dict.set(key, value);
+      return value;
+    };
+}

package/src/utils/NameEncoder.ts

@@ -1,32 +1,32 @@
-export namespace NameEncoder {
-  export function encode(str: string): string {
-    for (const [before, after] of REPLACERS)
-      str = str.split(before).join(after);
-    return str;
-  }
-
-  export function decode(str: string): string {
-    for (const [before, after] of REPLACERS)
-      if (after !== "") str = str.split(after).join(before);
-    return str;
-  }
-}
-
-const REPLACERS: [string, string][] = [
-  ["$", "_dollar_"],
-  ["&", "_and_"],
-  ["|", "_or_"],
-  ["{", "_blt_"],
-  ["}", "_bgt_"],
-  ["<", "_lt_"],
-  [">", "_gt_"],
-  ["(", "_lp_"],
-  [")", "_rp_"],
-  ["[", "_alt_"],
-  ["]", "_agt_"],
-  [",", "_comma_"],
-  ["`", "_backquote_"],
-  ["'", "_singlequote_"],
-  ['"', "_doublequote_"],
-  [" ", "_space_"],
-];
+export namespace NameEncoder {
+  export function encode(str: string): string {
+    for (const [before, after] of REPLACERS)
+      str = str.split(before).join(after);
+    return str;
+  }
+
+  export function decode(str: string): string {
+    for (const [before, after] of REPLACERS)
+      if (after !== "") str = str.split(after).join(before);
+    return str;
+  }
+}
+
+const REPLACERS: [string, string][] = [
+  ["$", "_dollar_"],
+  ["&", "_and_"],
+  ["|", "_or_"],
+  ["{", "_blt_"],
+  ["}", "_bgt_"],
+  ["<", "_lt_"],
+  [">", "_gt_"],
+  ["(", "_lp_"],
+  [")", "_rp_"],
+  ["[", "_alt_"],
+  ["]", "_agt_"],
+  [",", "_comma_"],
+  ["`", "_backquote_"],
+  ["'", "_singlequote_"],
+  ['"', "_doublequote_"],
+  [" ", "_space_"],
+];