typia 3.8.0-dev.20230418 → 3.8.0-dev.20230420

package/src/factories/IdentifierFactory.ts

@@ -1,59 +1,57 @@
-import ts from "typescript";
-
-import { Escaper } from "../utils/Escaper";
-
-export namespace IdentifierFactory {
-    export function generate(name: string) {
-        return Escaper.variable(name)
-            ? ts.factory.createIdentifier(name)
-            : ts.factory.createStringLiteral(name);
-    }
-
-    export function join(prefix: ts.Expression, name: string) {
-        const postfix = generate(name);
-        return ts.isStringLiteral(postfix)
-            ? ts.factory.createElementAccessExpression(prefix, postfix)
-            : ts.factory.createPropertyAccessExpression(prefix, postfix);
-    }
-
-    export function postfix(str: string): string {
-        return Escaper.variable(str)
-            ? `".${str}"`
-            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-    }
-
-    export function parameter(
-        name: string | ts.BindingName,
-        type?: ts.TypeNode,
-        init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
-    ) {
-        // instead of ts.version >= "4.8"
-        if (ts.getDecorators !== undefined)
-            return ts.factory.createParameterDeclaration(
-                undefined,
-                undefined,
-                name,
-                init?.kind === ts.SyntaxKind.QuestionToken
-                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                    : undefined,
-                type,
-                init && init.kind !== ts.SyntaxKind.QuestionToken
-                    ? init
-                    : undefined,
-            );
-        // eslint-disable-next-line
-        return (ts.factory.createParameterDeclaration as any)(
-            undefined,
-            undefined,
-            undefined,
-            name,
-            init?.kind === ts.SyntaxKind.QuestionToken
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined,
-            type,
-            init && init.kind !== ts.SyntaxKind.QuestionToken
-                ? init
-                : undefined,
-        );
-    }
-}
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export const accessor = (name: string) =>
+        Escaper.variable(name)
+            ? ts.factory.createIdentifier(name)
+            : ts.factory.createStringLiteral(name);
+
+    export const join = (prefix: ts.Expression) => (name: string) => {
+        const postfix = accessor(name);
+        return ts.isStringLiteral(postfix)
+            ? ts.factory.createElementAccessExpression(prefix, postfix)
+            : ts.factory.createPropertyAccessExpression(prefix, postfix);
+    };
+
+    export const postfix = (str: string): string =>
+        Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+
+    export const parameter = (
+        name: string | ts.BindingName,
+        type?: ts.TypeNode,
+        init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
+    ) => {
+        // instead of ts.version >= "4.8"
+        if (ts.getDecorators !== undefined)
+            return ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                name,
+                init?.kind === ts.SyntaxKind.QuestionToken
+                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                    : undefined,
+                type,
+                init && init.kind !== ts.SyntaxKind.QuestionToken
+                    ? init
+                    : undefined,
+            );
+        // eslint-disable-next-line
+        return (ts.factory.createParameterDeclaration as any)(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            init?.kind === ts.SyntaxKind.QuestionToken
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined,
+            type,
+            init && init.kind !== ts.SyntaxKind.QuestionToken
+                ? init
+                : undefined,
+        );
+    };
+}

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))
+            );
+        };
 }

package/src/factories/MetadataTagFactory.ts

@@ -4,30 +4,29 @@ import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
 
 export namespace MetadataTagFactory {
-    export function generate(
-        identifier: () => string,
-        metadata: Metadata,
-        tagList: ts.JSDocTagInfo[],
-    ): IMetadataTag[] {
-        const output: IMetadataTag[] = [];
-        for (const tag of tagList) {
-            const elem: IMetadataTag | null = parse(
-                identifier,
-                metadata,
-                tag,
-                output,
-            );
-            if (elem !== null) output.push(elem);
-        }
-        return output;
-    }
+    export const generate =
+        (metadata: Metadata) =>
+        (tagList: ts.JSDocTagInfo[]) =>
+        (identifier: () => string): IMetadataTag[] => {
+            const output: IMetadataTag[] = [];
+            for (const tag of tagList) {
+                const elem: IMetadataTag | null = parse(
+                    identifier,
+                    metadata,
+                    tag,
+                    output,
+                );
+                if (elem !== null) output.push(elem);
+            }
+            return output;
+        };
 
-    function parse(
+    const parse = (
         identifier: () => string,
         metadata: Metadata,
         tag: ts.JSDocTagInfo,
         output: IMetadataTag[],
-    ): IMetadataTag | null {
+    ): IMetadataTag | null => {
         const closure = _PARSER[tag.name];
         if (closure === undefined) return null;
 
@@ -36,7 +35,7 @@ export namespace MetadataTagFactory {
             throw new Error(`${LABEL}: no tag value on ${identifier()}`);
 
         return closure(identifier, metadata, text, output);
-    }
+    };
 
     /**
      * @internal
@@ -225,12 +224,12 @@ export namespace MetadataTagFactory {
     };
 }
 
-function parse_number(identifier: () => string, str: string): number {
+const parse_number = (identifier: () => string, str: string): number => {
     const value: number = Number(str);
     if (isNaN(value) === true)
         throw new Error(`${LABEL}: invalid number on "${identifier()}".`);
     return value;
-}
+};
 
 const LABEL = "Error on typia.MetadataTagFactory.generate()";
 const FORMATS: Map<string, IMetadataTag.IFormat["value"]> = new Map([
@@ -251,19 +250,19 @@ const WRONG_TYPE = (
     identifier: () => string,
 ) => `${LABEL}: ${tag} requires ${type} type, but no "${identifier()}".`;
 
-function validate(
+const validate = (
     identifier: () => string,
     metadata: Metadata,
     output: IMetadataTag[],
     kind: IMetadataTag["kind"],
     type: "array" | "string" | "number",
     neighbors: IMetadataTag["kind"][],
-): void {
+): void => {
     // TYPE CHECKING
     if (type === "array") {
         if (has_array(metadata) === false)
             throw new Error(WRONG_TYPE(kind, "array", identifier));
-    } else if (has_atomic(metadata, type) === false)
+    } else if (has_atomic(metadata)(type) === false)
         throw new Error(WRONG_TYPE(kind, type, identifier));
 
     // DUPLICATED TAG
@@ -278,25 +277,21 @@ function validate(
             throw new Error(
                 `${LABEL}: ${kind} and ${name} tags on "${identifier()}".`,
             );
-}
+};
 
-function has_atomic(metadata: Metadata, type: "string" | "number"): boolean {
-    const valid =
-        type === "number"
-            ? (atom: string) => atom === type || atom === "bigint"
-            : (atom: string) => atom === type;
-    return (
-        metadata.atomics.find((atom) => valid(atom)) !== undefined ||
-        metadata.arrays.some((child) => has_atomic(child, type)) ||
+const has_atomic =
+    (metadata: Metadata) =>
+    (type: "string" | "number"): boolean =>
+        metadata.atomics.find(
+            type === "number"
+                ? (atom: string) => atom === type || atom === "bigint"
+                : (atom: string) => atom === type,
+        ) !== undefined ||
+        metadata.arrays.some((child) => has_atomic(child)(type)) ||
         metadata.tuples.some((tuple) =>
-            tuple.some((child) => has_atomic(child, type)),
-        )
-    );
-}
+            tuple.some((child) => has_atomic(child)(type)),
+        );
 
-function has_array(metadata: Metadata): boolean {
-    return (
-        metadata.arrays.length !== 0 ||
-        metadata.tuples.some((tuple) => tuple.some((child) => has_array(child)))
-    );
-}
+const has_array = (metadata: Metadata): boolean =>
+    metadata.arrays.length !== 0 ||
+    metadata.tuples.some((tuple) => tuple.some((child) => has_array(child)));

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;
     }