typia 4.3.2 → 4.3.3

package/src/transformers/features/stringifiers/IsStringifyTransformer.ts

@@ -1,9 +1,9 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsStringifyTransformer {
-    export const transform = GenericTransformer.scalar("isStringify")(
-        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsStringifyTransformer {
+    export const transform = GenericTransformer.scalar("isStringify")(
+        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/StringifyTransformer.ts

@@ -1,9 +1,9 @@
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace StringifyTransformer {
-    export const transform = GenericTransformer.scalar("stringify")(
-        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
-    );
-}
+import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace StringifyTransformer {
+    export const transform = GenericTransformer.scalar("stringify")(
+        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/ValidateStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateStringifyTransformer {
-    export const transform = GenericTransformer.scalar("validatStringify")(
-        (project) => (modulo) =>
-            ValidateStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateStringifyTransformer {
+    export const transform = GenericTransformer.scalar("validatStringify")(
+        (project) => (modulo) =>
+            ValidateStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/validators/AssertTransformer.ts

@@ -1,11 +1,11 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/validators/CreateAssertTransformer.ts

@@ -1,13 +1,13 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createAssertEquals" : "createAssert",
-        )(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createAssertEquals" : "createAssert",
+        )(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/validators/CreateIsTransformer.ts

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/validators/CreateValidateTransformer.ts

@@ -1,13 +1,13 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createValidateEquals" : "createValidate",
-        )(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createValidateEquals" : "createValidate",
+        )(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/validators/IsTransformer.ts

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "equals" : "is")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "equals" : "is")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/validators/ValidateTransformer.ts

@@ -1,11 +1,11 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,97 +1,97 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-
-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 Error(`Error on typia.${method}(): 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 Error(
-                    `Error on typia.${method}(): 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 Error(
-                    `Error on typia.${method}(): 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 Error(
-                    `Error on typia.${method}(): 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";
+
+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 Error(`Error on typia.${method}(): 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 Error(
+                    `Error on typia.${method}(): 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 Error(
+                    `Error on typia.${method}(): 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 Error(
+                    `Error on typia.${method}(): 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,17 +1,17 @@
-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/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/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,45 +1,45 @@
-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);
+}