typia 3.8.0-dev.20230417 → 3.8.0-dev.20230420

package/src/factories/StatementFactory.ts

@@ -1,8 +1,8 @@
 import ts from "typescript";
 
 export namespace StatementFactory {
-    export function constant(name: string, initializer?: ts.Expression) {
-        return ts.factory.createVariableStatement(
+    export const constant = (name: string, initializer?: ts.Expression) =>
+        ts.factory.createVariableStatement(
             undefined,
             ts.factory.createVariableDeclarationList(
                 [
@@ -16,45 +16,9 @@ export namespace StatementFactory {
                 ts.NodeFlags.Const,
             ),
         );
-    }
 
-    export function transpile(script: string) {
-        return ts.factory.createExpressionStatement(
+    export const transpile = (script: string) =>
+        ts.factory.createExpressionStatement(
             ts.factory.createIdentifier(ts.transpile(script)),
         );
-    }
-
-    // export function require(variable: string, location: string) {
-    //     return ts.factory.createImportDeclaration(
-    //         undefined,
-    //         undefined,
-    //         ts.factory.createImportClause(
-    //             false,
-    //             undefined,
-    //             ts.factory.createNamespaceImport(
-    //                 ts.factory.createIdentifier(variable),
-    //             ),
-    //         ),
-    //         ts.factory.createStringLiteral(location),
-    //     );
-    // }
-
-    // export function importModulo(variable: string, location: string) {
-    //     return ts.factory.createImportDeclaration(
-    //         undefined,
-    //         undefined,
-    //         ts.factory.createImportClause(
-    //             false,
-    //             undefined,
-    //             ts.factory.createNamedImports([
-    //                 ts.factory.createImportSpecifier(
-    //                     false,
-    //                     undefined,
-    //                     ts.factory.createIdentifier(variable),
-    //                 ),
-    //             ]),
-    //         ),
-    //         ts.factory.createStringLiteral(location),
-    //     );
-    // }
 }

package/src/factories/TemplateFactory.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 export namespace TemplateFactory {
-    export function generate(expressions: ts.Expression[]): ts.Expression {
+    export const generate = (expressions: ts.Expression[]): ts.Expression => {
         if (expressions.every((exp) => ts.isStringLiteral(exp)))
             return ts.factory.createStringLiteral(
                 (expressions as ts.StringLiteral[])
@@ -9,18 +9,18 @@ export namespace TemplateFactory {
                     .join(""),
             );
 
-        const it: IIerator = {
+        const it: IIterator = {
             value: "",
             index: 0,
         };
-        gather(expressions, it);
+        gather(expressions)(it);
 
         const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
         const spans: ts.TemplateSpan[] = [];
 
         while (true) {
             const elem: ts.Expression = expressions[it.index++]!;
-            gather(expressions, it);
+            gather(expressions)(it);
 
             const broken: boolean = it.index === expressions.length;
             spans.push(
@@ -34,22 +34,24 @@ export namespace TemplateFactory {
             if (broken === true) break;
         }
         return ts.factory.createTemplateExpression(head, spans);
-    }
+    };
 
-    function gather(expressions: ts.Expression[], it: IIerator): void {
-        const found: number = expressions.findIndex(
-            (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-        );
-
-        const last: number = found !== -1 ? found : expressions.length;
-        it.value = expressions
-            .slice(it.index, last)
-            .map((elem) => (elem as ts.StringLiteral).text)
-            .reduce((x, y) => x + y, "");
-        it.index = last;
-    }
+    const gather =
+        (expressions: ts.Expression[]) =>
+        (it: IIterator): void => {
+            const found: number = expressions.findIndex(
+                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+            );
+
+            const last: number = found !== -1 ? found : expressions.length;
+            it.value = expressions
+                .slice(it.index, last)
+                .map((elem) => (elem as ts.StringLiteral).text)
+                .reduce((x, y) => x + y, "");
+            it.index = last;
+        };
 
-    interface IIerator {
+    interface IIterator {
         value: string;
         index: number;
     }

package/src/factories/TypeFactory.ts

@@ -1,18 +1,15 @@
 import ts from "typescript";
 
 export namespace TypeFactory {
-    export function resolve(
-        checker: ts.TypeChecker,
-        type: ts.Type,
-    ): ts.Type | null {
-        return getReturnType(checker, type, "toJSON");
-    }
+    export const resolve =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): ts.Type | null =>
+            getReturnType(checker)(type)("toJSON");
 
-    export function isFunction(type: ts.Type): boolean {
-        return getFunction(type) !== null;
-    }
+    export const isFunction = (type: ts.Type): boolean =>
+        getFunction(type) !== null;
 
-    function getFunction(type: ts.Type) {
+    const getFunction = (type: ts.Type) => {
         const node = type.symbol?.declarations?.[0];
         if (node === undefined) return null;
 
@@ -23,82 +20,80 @@ export namespace TypeFactory {
                 ? node.initializer
                 : null
             : null;
-    }
+    };
 
-    export function getReturnType(
-        checker: ts.TypeChecker,
-        type: ts.Type,
-        name: string,
-    ): ts.Type | null {
-        // FIND TO-JSON METHOD
-        const symbol: ts.Symbol | undefined = type.getProperty(name);
-        if (!symbol) return null;
-        else if (!symbol.valueDeclaration) return null;
+    export const getReturnType =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (name: string): ts.Type | null => {
+            // FIND TO-JSON METHOD
+            const symbol: ts.Symbol | undefined = type.getProperty(name);
+            if (!symbol) return null;
+            else if (!symbol.valueDeclaration) return null;
 
-        // GET FUNCTION DECLARATION
-        const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-            symbol,
-            symbol.valueDeclaration,
-        );
+            // GET FUNCTION DECLARATION
+            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
+                symbol,
+                symbol.valueDeclaration,
+            );
 
-        // RETURNS THE RETURN-TYPE
-        const signature: ts.Signature | undefined = checker.getSignaturesOfType(
-            functor,
-            ts.SignatureKind.Call,
-        )[0];
-        return signature ? signature.getReturnType() : null;
-    }
+            // RETURNS THE RETURN-TYPE
+            const signature: ts.Signature | undefined =
+                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+            return signature ? signature.getReturnType() : null;
+        };
 
-    export function getFullName(
-        checker: ts.TypeChecker,
-        type: ts.Type,
-        symbol?: ts.Symbol,
-    ): string {
-        // PRIMITIVE
-        symbol ??= type.aliasSymbol ?? type.getSymbol();
-        if (symbol === undefined) return checker.typeToString(type);
+    export const getFullName =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type, symbol?: ts.Symbol): string => {
+            // PRIMITIVE
+            symbol ??= type.aliasSymbol ?? type.getSymbol();
+            if (symbol === undefined) return checker.typeToString(type);
 
-        // UNION OR INTERSECT
-        if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-            const joiner: string = type.isIntersection() ? " & " : " | ";
-            return type.types
-                .map((child) => getFullName(checker, child))
-                .join(joiner);
-        }
+            // UNION OR INTERSECT
+            if (
+                type.aliasSymbol === undefined &&
+                type.isUnionOrIntersection()
+            ) {
+                const joiner: string = type.isIntersection() ? " & " : " | ";
+                return type.types
+                    .map((child) => getFullName(checker)(child))
+                    .join(joiner);
+            }
 
-        //----
-        // SPECIALIZATION
-        //----
-        const name: string = get_name(symbol);
+            //----
+            // SPECIALIZATION
+            //----
+            const name: string = get_name(symbol);
 
-        // CHECK GENERIC
-        const generic: readonly ts.Type[] = type.aliasSymbol
-            ? type.aliasTypeArguments || []
-            : checker.getTypeArguments(type as ts.TypeReference);
-        return generic.length
-            ? name === "Promise"
-                ? getFullName(checker, generic[0]!)
-                : `${name}<${generic
-                      .map((child) => getFullName(checker, child))
-                      .join(", ")}>`
-            : name;
-    }
+            // CHECK GENERIC
+            const generic: readonly ts.Type[] = type.aliasSymbol
+                ? type.aliasTypeArguments || []
+                : checker.getTypeArguments(type as ts.TypeReference);
+            return generic.length
+                ? name === "Promise"
+                    ? getFullName(checker)(generic[0]!)
+                    : `${name}<${generic
+                          .map((child) => getFullName(checker)(child))
+                          .join(", ")}>`
+                : name;
+        };
 
-    function explore_name(name: string, decl: ts.Node): string {
-        return ts.isModuleBlock(decl)
-            ? explore_name(
-                  `${decl.parent.name.getFullText().trim()}.${name}`,
-                  decl.parent.parent,
-              )
-            : name;
-    }
+    const explore_name =
+        (decl: ts.Node) =>
+        (name: string): string =>
+            ts.isModuleBlock(decl)
+                ? explore_name(decl.parent.parent)(
+                      `${decl.parent.name.getFullText().trim()}.${name}`,
+                  )
+                : name;
 
-    function get_name(symbol: ts.Symbol): string {
+    const get_name = (symbol: ts.Symbol): string => {
         const parent = symbol.getDeclarations()?.[0]?.parent;
         return parent
-            ? explore_name(symbol.escapedName.toString(), parent)
+            ? explore_name(parent)(symbol.escapedName.toString())
             : "__type";
-    }
+    };
 
     export const keyword = (
         type:

package/src/factories/internal/metadata/MetadataHelper.ts

@@ -1,12 +1,12 @@
 import { Metadata } from "../../../metadata/Metadata";
 
 export namespace MetadataHelper {
-    export function literal_to_metadata(key: string): Metadata {
+    export const literal_to_metadata = (key: string): Metadata => {
         const metadata: Metadata = Metadata.initialize();
         metadata.constants.push({
             type: "string",
             values: [key],
         });
         return metadata;
-    }
+    };
 }

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -50,7 +50,7 @@ export const emplace_metadata_object =
             ): MetadataProperty => {
                 // COMMENTS AND TAGS
                 const description: string | undefined =
-                    CommentFactory.generate(
+                    CommentFactory.string(
                         symbol?.getDocumentationComment(checker) || [],
                     ) || undefined;
                 const jsDocTags: ts.JSDocTagInfo[] = (
@@ -63,10 +63,8 @@ export const emplace_metadata_object =
                     value,
                     description,
                     jsDocTags,
-                    tags: MetadataTagFactory.generate(
-                        () => identifier(),
-                        value,
-                        jsDocTags,
+                    tags: MetadataTagFactory.generate(value)(jsDocTags)(() =>
+                        identifier(),
                     ),
                 });
                 obj.properties.push(property);

package/src/factories/internal/metadata/iterate_metadata_map.ts

@@ -16,7 +16,7 @@ export const iterate_metadata_map =
     (meta: Metadata, type: ts.Type): boolean => {
         type = checker.getApparentType(type);
 
-        const name = TypeFactory.getFullName(checker, type, type.getSymbol());
+        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
         const generic = type.aliasSymbol
             ? type.aliasTypeArguments
             : checker.getTypeArguments(type as ts.TypeReference);

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -10,8 +10,7 @@ export const iterate_metadata_native =
     (checker: ts.TypeChecker) =>
     (meta: Metadata, type: ts.Type): boolean => {
         const validator = validate(checker)(type);
-        const name: string = TypeFactory.getFullName(
-            checker,
+        const name: string = TypeFactory.getFullName(checker)(
             type,
             type.getSymbol(),
         );
@@ -42,9 +41,7 @@ export const iterate_metadata_native =
 const validate =
     (checker: ts.TypeChecker) => (type: ts.Type) => (info: IClassInfo) =>
         (info.methods ?? []).every((method) => {
-            const returnType = TypeFactory.getReturnType(
-                checker,
-                type,
+            const returnType = TypeFactory.getReturnType(checker)(type)(
                 method.name,
             );
             return (

package/src/factories/internal/metadata/iterate_metadata_resolve.ts

@@ -15,7 +15,7 @@ export const iterate_metadata_resolve =
     (collection: MetadataCollection) =>
     (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
         if (options.resolve === true && parentResolved === false) {
-            const resolved: ts.Type | null = TypeFactory.resolve(checker, type);
+            const resolved: ts.Type | null = TypeFactory.resolve(checker)(type);
             if (resolved !== null) {
                 Writable(meta).resolved = explore_metadata(checker)(options)(
                     collection,

package/src/factories/internal/metadata/iterate_metadata_set.ts

@@ -16,7 +16,7 @@ export const iterate_metadata_set =
     (meta: Metadata, type: ts.Type): boolean => {
         type = checker.getApparentType(type);
 
-        const name = TypeFactory.getFullName(checker, type, type.getSymbol());
+        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
         const generic = type.aliasSymbol
             ? type.aliasTypeArguments
             : checker.getTypeArguments(type as ts.TypeReference);

package/src/factories/internal/metadata/iterate_metadata_tuple.ts

@@ -40,6 +40,5 @@ export const iterate_metadata_tuple =
         return true;
     };
 
-function join_tuple_names(metas: Metadata[]): string {
-    return `[${metas.map((m) => m.getName).join(", ")}]`;
-}
+const join_tuple_names = (metas: Metadata[]): string =>
+    `[${metas.map((m) => m.getName).join(", ")}]`;

package/src/factories/internal/metadata/iterate_metadata_union.ts

@@ -29,10 +29,8 @@ export const iterate_metadata_union =
 
         for (const individual of type.types) {
             if (filter(ts.TypeFlags.Object, individual)) {
-                const resolved: ts.Type | null = TypeFactory.resolve(
-                    checker,
-                    individual,
-                );
+                const resolved: ts.Type | null =
+                    TypeFactory.resolve(checker)(individual);
                 if (resolved !== null) toJsons.push(resolved);
                 else normals.push(individual);
             } else normals.push(individual);

package/src/functional/$any.ts

@@ -1,3 +1,2 @@
-export function $any(val: any): any {
-    return val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;
-}
+export const $any = (val: any): any =>
+    val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;

package/src/functional/$is_between.ts

@@ -1,7 +1,2 @@
-export function $is_between(
-    value: number,
-    minimum: number,
-    maximum: number,
-): boolean {
-    return minimum <= value && value <= maximum;
-}
+export const $is_between = (value: number, minimum: number, maximum: number) =>
+    minimum <= value && value <= maximum;

package/src/functional/$is_custom.ts

@@ -2,13 +2,13 @@ import { Customizable } from "../typings/Customizable";
 
 import { $dictionary } from "./$dictionary";
 
-export function $is_custom<Type extends keyof Customizable>(
+export const $is_custom = <Type extends keyof Customizable>(
     name: string,
     type: Type,
     text: string,
     value: Customizable[Type],
-): boolean {
+): boolean => {
     const validator = $dictionary.get(name)?.get(type);
     if (validator === undefined) return true;
     return validator(text)(value);
-}
+};

package/src/functional/$is_date.ts

@@ -1,4 +1,3 @@
-export function $is_date(value: string): boolean {
-    return REGEX.test(value);
-}
+export const $is_date = (value: string): boolean => REGEX.test(value);
+
 const REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;

package/src/functional/$is_datetime.ts

@@ -1,3 +1,2 @@
-export function $is_datetime(value: string): boolean {
-    return !isNaN(new Date(value).getTime());
-}
+export const $is_datetime = (value: string): boolean =>
+    !isNaN(new Date(value).getTime());

package/src/functional/$is_email.ts

@@ -1,5 +1,4 @@
-export function $is_email(str: string): boolean {
-    return REGEX.test(str);
-}
+export const $is_email = (str: string): boolean => REGEX.test(str);
+
 const REGEX =
     /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

package/src/functional/$is_ipv4.ts

@@ -1,5 +1,4 @@
-export function $is_ipv4(str: string): boolean {
-    return REGEX.test(str);
-}
+export const $is_ipv4 = (str: string): boolean => REGEX.test(str);
+
 const REGEX =
     /^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;

package/src/functional/$is_ipv6.ts

@@ -1,5 +1,4 @@
-export function $is_ipv6(str: string): boolean {
-    return REGEX.test(str);
-}
+export const $is_ipv6 = (str: string): boolean => REGEX.test(str);
+
 const REGEX =
     /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;

package/src/functional/$is_url.ts

@@ -1,5 +1,4 @@
-export function $is_url(str: string): boolean {
-    return REGEX.test(str);
-}
+export const $is_url = (str: string): boolean => REGEX.test(str);
+
 const REGEX =
     /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;

package/src/functional/$is_uuid.ts

@@ -1,5 +1,4 @@
-export function $is_uuid(str: string): boolean {
-    return REGEX.test(str);
-}
+export const $is_uuid = (str: string): boolean => REGEX.test(str);
+
 const REGEX =
     /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;

package/src/functional/$join.ts

@@ -1,14 +1,10 @@
-export function $join(str: string): string {
-    return variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
-}
+export const $join = (str: string): string =>
+    variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
 
-function variable(str: string): boolean {
-    return reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-}
+const variable = (str: string): boolean =>
+    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 = (str: string): boolean => RESERVED.has(str);
 
 const RESERVED: Set<string> = new Set([
     "break",

package/src/functional/$number.ts

@@ -1,6 +1,6 @@
 import { TypeGuardError } from "../TypeGuardError";
 
-export function $number(value: number): number {
+export const $number = (value: number): number => {
     if (isFinite(value) === false)
         throw new TypeGuardError({
             method: "typia.stringify",
@@ -9,4 +9,4 @@ export function $number(value: number): number {
             message: "Error on typia.stringify(): infinite or not a number.",
         });
     return value;
-}
+};

package/src/functional/$rest.ts

@@ -1,3 +1,3 @@
-export function $rest(str: string): string {
+export const $rest = (str: string): string => {
     return str.length === 2 ? "" : "," + str.substring(1, str.length - 1);
-}
+};

package/src/functional/$string.ts

@@ -1,7 +1,7 @@
 /**
  * @internal
  */
-export function $string(str: string): string {
+export const $string = (str: string): string => {
     if (str.length > 41) return JSON.stringify(str);
 
     const length = str.length;
@@ -34,4 +34,4 @@ export function $string(str: string): string {
     return point < 32 || surrogateFound === true
         ? JSON.stringify(str)
         : `"${result}"`;
-}
+};

package/src/functional/$tail.ts

@@ -1,6 +1,5 @@
 /**
  * @internal
  */
-export function $tail(str: string): string {
-    return str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
-}
+export const $tail = (str: string): string =>
+    str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;

package/src/metadata/ICommentTag.ts

@@ -1,4 +1,4 @@
-export interface ICommentTag {
-    name: string;
-    value?: string;
-}
+export interface ICommentTag {
+    name: string;
+    value?: string;
+}