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

package/src/factories/LiteralFactory.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { IdentifierFactory } from "./IdentifierFactory";
 
 export namespace LiteralFactory {
-    export function generate(input: any): ts.Expression {
+    export const generate = (input: any): ts.Expression => {
         if (input === null) return ts.factory.createNull();
         else if (ts.isIdentifier(input)) return input;
         else if (input instanceof Array) return generate_array(input);
@@ -13,32 +13,27 @@ export namespace LiteralFactory {
         else if (typeof input === "number") return generate_value(input);
         else if (typeof input === "bigint") return generate_value(input);
         else throw new Error("Unknown type.");
-    }
+    };
 
-    function generate_object(obj: object): ts.ObjectLiteralExpression {
-        const properties = Object.entries(obj)
-            .filter((tuple) => tuple[1] !== undefined)
-            .map(([key, value]) =>
-                ts.factory.createPropertyAssignment(
-                    IdentifierFactory.generate(key),
-                    generate(value),
+    const generate_object = (obj: object): ts.ObjectLiteralExpression =>
+        ts.factory.createObjectLiteralExpression(
+            Object.entries(obj)
+                .filter((tuple) => tuple[1] !== undefined)
+                .map(([key, value]) =>
+                    ts.factory.createPropertyAssignment(
+                        IdentifierFactory.accessor(key),
+                        generate(value),
+                    ),
                 ),
-            );
-        return ts.factory.createObjectLiteralExpression(properties, true);
-    }
-
-    function generate_array(array: any[]): ts.ArrayLiteralExpression {
-        return ts.factory.createArrayLiteralExpression(
-            array.map(generate),
             true,
         );
-    }
 
-    function generate_value(value: number | boolean | bigint): ts.Identifier {
-        return ts.factory.createIdentifier(value.toString());
-    }
+    const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
+        ts.factory.createArrayLiteralExpression(array.map(generate), true);
+
+    const generate_value = (value: number | boolean | bigint): ts.Identifier =>
+        ts.factory.createIdentifier(value.toString());
 
-    function generate_string(value: string): ts.StringLiteral {
-        return ts.factory.createStringLiteral(value);
-    }
+    const generate_string = (value: string): ts.StringLiteral =>
+        ts.factory.createStringLiteral(value);
 }

package/src/factories/MetadataCollection.ts

@@ -43,7 +43,7 @@ export class MetadataCollection {
             properties: [],
             description:
                 (type.symbol &&
-                    CommentFactory.generate(
+                    CommentFactory.string(
                         type.symbol.getDocumentationComment(checker),
                     )) ||
                 undefined,
@@ -62,18 +62,17 @@ export class MetadataCollection {
      */
     public getUnionIndex(meta: Metadata): number {
         const key: string = meta.objects.map((obj) => obj.name).join(" | ");
-        MapUtil.take(this.unions_, key, () => meta.objects);
+        MapUtil.take(this.unions_)(key, () => meta.objects);
         return [...this.unions_.keys()].indexOf(key);
     }
 
     private get_name(checker: ts.TypeChecker, type: ts.Type): string {
         const name: string = (() => {
-            const str: string = TypeFactory.getFullName(checker, type);
+            const str: string = TypeFactory.getFullName(checker)(type);
             return this.options?.replace ? this.options.replace(str) : str;
         })();
 
-        const duplicates: Map<ts.Type, string> = MapUtil.take(
-            this.names_,
+        const duplicates: Map<ts.Type, string> = MapUtil.take(this.names_)(
             name,
             () => new Map(),
         );
@@ -92,17 +91,17 @@ export namespace MetadataCollection {
         replace?(str: string): string;
     }
 
-    export function replace(str: string): string {
+    export const replace = (str: string): string => {
         for (const [before, after] of REPLACERS)
             str = str.split(before).join(after);
         return str;
-    }
+    };
 
-    export function escape(str: string): string {
+    export const escape = (str: string): string => {
         for (const [before, after] of REPLACERS)
             if (after !== "") str = str.split(after).join(before);
         return str;
-    }
+    };
 }
 const REPLACERS: [string, string][] = [
     ["$", "_dollar_"],

package/src/factories/MetadataFactory.ts

@@ -12,40 +12,51 @@ export namespace MetadataFactory {
         validate?: (meta: Metadata) => void;
     }
 
-    export function generate(
+    /**
+     * @deprecated Use `analyze` function instead
+     */
+    export const generate = (
         checker: ts.TypeChecker,
         collection: MetadataCollection,
-        type: ts.Type | null,
+        type: ts.Type,
         options: IOptions,
-    ): Metadata {
-        // CONSTRUCT SCHEMA WITH OBJECTS
-        const metadata: Metadata = explore_metadata(checker)(options)(
-            collection,
-        )(type, false);
-
-        // FIND RECURSIVE OBJECTS
-        for (const object of collection.objects())
-            object.recursive = object.properties.some((prop) =>
-                isRecursive(object.name, prop.value),
-            );
+    ) => analyze(checker)(options)(collection)(type);
 
-        // RETURNS
-        return metadata;
-    }
+    export const analyze =
+        (checker: ts.TypeChecker) =>
+        (options: IOptions) =>
+        (collection: MetadataCollection) =>
+        (type: ts.Type | null): Metadata => {
+            // CONSTRUCT SCHEMA WITH OBJECTS
+            const metadata: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(type, false);
 
-    function isRecursive(name: string, meta: Metadata): boolean {
-        const similar = (str: string) =>
-            name === str ||
-            name.indexOf(`<${str},`) !== -1 ||
-            name.indexOf(`, ${str}>`) !== -1 ||
-            name.indexOf(`, ${str},`) !== -1;
-        return (
-            meta.objects.some((obj) => similar(obj.name)) ||
-            meta.arrays.some((arr) => isRecursive(name, arr)) ||
-            meta.tuples.some((tuple) =>
-                tuple.some((m) => isRecursive(name, m.rest ?? m)),
-            ) ||
-            meta.maps.some((map) => isRecursive(name, map.value))
-        );
-    }
+            // FIND RECURSIVE OBJECTS
+            for (const object of collection.objects())
+                object.recursive = object.properties.some((prop) =>
+                    isRecursive(object.name)(prop.value),
+                );
+
+            // RETURNS
+            return metadata;
+        };
+
+    const isRecursive =
+        (name: string) =>
+        (meta: Metadata): boolean => {
+            const similar = (str: string) =>
+                name === str ||
+                name.indexOf(`<${str},`) !== -1 ||
+                name.indexOf(`, ${str}>`) !== -1 ||
+                name.indexOf(`, ${str},`) !== -1;
+            return (
+                meta.objects.some((obj) => similar(obj.name)) ||
+                meta.arrays.some((arr) => isRecursive(name)(arr)) ||
+                meta.tuples.some((tuple) =>
+                    tuple.some((m) => isRecursive(name)(m.rest ?? m)),
+                ) ||
+                meta.maps.some((map) => isRecursive(name)(map.value))
+            );
+        };
 }