typia 3.6.2 → 3.6.3

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

@@ -1,12 +1,12 @@
-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.generate(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.generate(project, modulo, equals),
+        );
+}

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

@@ -1,10 +1,10 @@
-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.generate(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.generate(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.generate(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.generate(project, modulo, equals),
+        );
+}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,99 +1,99 @@
-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.getText()
-                        : 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.getText());
-        };
-
-    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.getText()
+                        : 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.getText());
+        };
+
+    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/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,49 +1,49 @@
-export namespace ArrayUtil {
-    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
-        return array.some(pred);
-    }
-
-    export function add<T>(
-        array: T[],
-        value: T,
-        pred: (x: T, y: T) => boolean = (x, y) => x === y,
-    ): void {
-        if (array.some((elem) => pred(elem, value))) return;
-        array.push(value);
-    }
-
-    export function 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 function 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 function repeat<T>(
-        count: number,
-        closure: (index: number, count: number) => T,
-    ): T[] {
-        return new Array(count)
-            .fill("")
-            .map((_, index) => closure(index, count));
-    }
-
-    export function flat<T>(matrix: T[][]): T[] {
-        return ([] as T[]).concat(...matrix);
-    }
-}
+export namespace ArrayUtil {
+    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
+        return array.some(pred);
+    }
+
+    export function add<T>(
+        array: T[],
+        value: T,
+        pred: (x: T, y: T) => boolean = (x, y) => x === y,
+    ): void {
+        if (array.some((elem) => pred(elem, value))) return;
+        array.push(value);
+    }
+
+    export function 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 function 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 function repeat<T>(
+        count: number,
+        closure: (index: number, count: number) => T,
+    ): T[] {
+        return new Array(count)
+            .fill("")
+            .map((_, index) => closure(index, count));
+    }
+
+    export function flat<T>(matrix: T[][]): T[] {
+        return ([] as T[]).concat(...matrix);
+    }
+}

package/src/utils/Escaper.ts

@@ -1,50 +1,50 @@
-export namespace Escaper {
-    export function variable(str: string): boolean {
-        return (
-            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
-        );
-    }
-
-    function reserved(str: string): boolean {
-        return 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",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-]);
+export namespace Escaper {
+    export function variable(str: string): boolean {
+        return (
+            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
+        );
+    }
+
+    function reserved(str: string): boolean {
+        return 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",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-    export function 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 function 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/PatternUtil.ts

@@ -1,30 +1,30 @@
-export namespace PatternUtil {
-    export function fix(str: string): string {
-        const first: number = str.indexOf(STRING);
-        const last: number = str.lastIndexOf(STRING);
-        return [
-            first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
-            str,
-            last === -1 || none(")")(str.slice(last + STRING.length))
-                ? "$"
-                : "",
-        ].join("");
-    }
-
-    export function escape(str: string): string {
-        return str
-            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
-            .replace(/-/g, "\\x2d");
-    }
-
-    export const NUMBER = "-?\\d+\\.?\\d*";
-    export const BOOLEAN = "true|false";
-    export const STRING = "(.*)";
-}
-
-const none =
-    (parenthesis: string) =>
-    (str: string): boolean => {
-        for (const ch of str) if (ch !== parenthesis) return true;
-        return false;
-    };
+export namespace PatternUtil {
+    export function fix(str: string): string {
+        const first: number = str.indexOf(STRING);
+        const last: number = str.lastIndexOf(STRING);
+        return [
+            first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
+            str,
+            last === -1 || none(")")(str.slice(last + STRING.length))
+                ? "$"
+                : "",
+        ].join("");
+    }
+
+    export function escape(str: string): string {
+        return str
+            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
+            .replace(/-/g, "\\x2d");
+    }
+
+    export const NUMBER = "-?\\d+\\.?\\d*";
+    export const BOOLEAN = "true|false";
+    export const STRING = "(.*)";
+}
+
+const none =
+    (parenthesis: string) =>
+    (str: string): boolean => {
+        for (const ch of str) if (ch !== parenthesis) return true;
+        return false;
+    };