typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/FeatureProgrammer.ts

@@ -1,5 +1,4 @@
-import { JSDocTagInfo } from "typescript";
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
@@ -10,6 +9,7 @@ import { ValueFactory } from "../factories/ValueFactory";
 import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataArray } from "../metadata/MetadataArray";
 import { MetadataObject } from "../metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
@@ -28,14 +28,9 @@ export namespace FeatureProgrammer {
         types: IConfig.ITypes;
 
         /**
-         * Prefix name of functions for specific object types.
+         * Prefix name of internal functions for specific types.
          */
-        functors: string;
-
-        /**
-         * Prefix name of functions for union object types.
-         */
-        unioners: string;
+        prefix: string;
 
         /**
          * Whether to archive access path or not.
@@ -59,7 +54,7 @@ export namespace FeatureProgrammer {
         /**
          * Decoder, station of every types.
          */
-        decoder: Decoder<Metadata, Output>;
+        decoder: () => Decoder<Metadata, Output>;
 
         /**
          * Object configurator.
@@ -69,7 +64,7 @@ export namespace FeatureProgrammer {
         /**
          * Generator of functions for object types.
          */
-        generator?: Partial<IConfig.IGenerator>;
+        generator: IConfig.IGenerator;
     }
     export namespace IConfig {
         export interface ITypes {
@@ -81,12 +76,12 @@ export namespace FeatureProgrammer {
             /**
              * Type checker when union object type comes.
              */
-            checker: Decoder<Metadata, ts.Expression>;
+            checker: () => Decoder<Metadata, ts.Expression>;
 
             /**
              * Decoder, function call expression generator of specific typed objects.
              */
-            decoder: Decoder<MetadataObject, ts.Expression>;
+            decoder: () => Decoder<MetadataObject, ts.Expression>;
 
             /**
              * Joiner of expressions from properties.
@@ -175,23 +170,16 @@ export namespace FeatureProgrammer {
             type?: ts.TypeNode;
         }
         export interface IGenerator {
-            /**
-             *
-             * @param col
-             */
-            functors(col: MetadataCollection): ts.VariableStatement[];
-
-            /**
-             *
-             * @param col
-             */
-            unioners(col: MetadataCollection): ts.VariableStatement[];
+            objects?(): (col: MetadataCollection) => ts.VariableStatement[];
+            unions?(): (col: MetadataCollection) => ts.VariableStatement[];
+            arrays(): (col: MetadataCollection) => ts.VariableStatement[];
+            tuples(): (col: MetadataCollection) => ts.VariableStatement[];
         }
     }
 
     export interface IExplore {
         tracable: boolean;
-        source: "top" | "object";
+        source: "top" | "function";
         from: "top" | "array" | "object";
         postfix: string;
         start?: number;
@@ -206,23 +194,23 @@ export namespace FeatureProgrammer {
             target: T,
             explore: IExplore,
             metaTags: IMetadataTag[],
-            jsDocTags: JSDocTagInfo[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): Output;
     }
 
     /* -----------------------------------------------------------
         GENERATORS
     ----------------------------------------------------------- */
-    export const analyze =
-        (p: IProject) =>
+    export const write =
+        (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
         (type: ts.Type, name?: string) => {
-            const [collection, meta] = config.initializer(p)(type);
+            const [collection, meta] = config.initializer(project)(type);
 
             // ITERATE OVER ALL METADATA
-            const output: ts.ConciseBody = config.decoder(
-                ValueFactory.INPUT(p.tsc)(),
+            const output: ts.ConciseBody = config.decoder()(
+                ValueFactory.INPUT(),
                 meta,
                 {
                     tracable: config.path || config.trace,
@@ -235,113 +223,111 @@ export namespace FeatureProgrammer {
             );
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
-            const functors: ts.VariableStatement[] = (
-                config.generator?.functors ??
-                write_functors(p.tsc)(config)(importer)
-            )(collection);
-            const unioners: ts.VariableStatement[] = (
-                config.generator?.unioners ??
-                write_unioners(p.tsc)(config)(importer)
-            )(collection);
+            const functions = {
+                objects: (
+                    config.generator.objects?.() ??
+                    write_object_functions(config)(importer)
+                )(collection),
+                unions: (
+                    config.generator.unions?.() ?? write_union_functions(config)
+                )(collection),
+                arrays: config.generator.arrays()(collection),
+                tuples: config.generator.tuples()(collection),
+            };
             const added: ts.Statement[] = (config.addition ?? (() => []))(
                 collection,
             );
 
-            return p.tsc.factory.createArrowFunction(
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(p.tsc)(config)(config.types.input(type, name))(
-                    ValueFactory.INPUT(p.tsc)(),
+                parameterDeclarations(config)(config.types.input(type, name))(
+                    ValueFactory.INPUT(),
                 ),
                 config.types.output(type, name),
                 undefined,
-                p.tsc.factory.createBlock(
+                ts.factory.createBlock(
                     [
                         ...added,
-                        ...functors.filter((_, i) =>
-                            importer.hasLocal(`${config.functors}${i}`),
+                        ...functions.objects.filter((_, i) =>
+                            importer.hasLocal(`${config.prefix}o${i}`),
+                        ),
+                        ...functions.unions.filter((_, i) =>
+                            importer.hasLocal(`${config.prefix}u${i}`),
                         ),
-                        ...unioners.filter((_, i) =>
-                            importer.hasLocal(`${config.unioners}${i}`),
+                        ...functions.arrays.filter((_, i) =>
+                            importer.hasLocal(`${config.prefix}a${i}`),
                         ),
-                        ...(p.tsc.isBlock(output)
+                        ...functions.tuples.filter((_, i) =>
+                            importer.hasLocal(`${config.prefix}t${i}`),
+                        ),
+                        ...(ts.isBlock(output)
                             ? output.statements
-                            : [p.tsc.factory.createReturnStatement(output)]),
+                            : [ts.factory.createReturnStatement(output)]),
                     ],
                     true,
                 ),
             );
         };
 
-    export const write_functors =
-        (tsc: typeof ts) =>
+    export const write_object_functions =
         (config: IConfig) =>
         (importer: FunctionImporter) =>
         (collection: MetadataCollection) =>
             collection
                 .objects()
                 .map((obj, i) =>
-                    StatementFactory.constant(tsc)(
-                        `${config.functors}${i}`,
-                        write_object(tsc)(config)(importer)(obj),
+                    StatementFactory.constant(
+                        `${config.prefix}o${i}`,
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ValueFactory.INPUT()),
+                            config.objector.type ?? TypeFactory.keyword("any"),
+                            undefined,
+                            config.objector.joiner(
+                                ts.factory.createIdentifier("input"),
+                                feature_object_entries(config)(importer)(obj)(
+                                    ts.factory.createIdentifier("input"),
+                                ),
+                                obj,
+                            ),
+                        ),
                     ),
                 );
 
-    export const write_unioners =
-        (tsc: typeof ts) =>
-        (config: IConfig) =>
-        (importer: FunctionImporter) =>
-        (collection: MetadataCollection) =>
+    export const write_union_functions =
+        (config: IConfig) => (collection: MetadataCollection) =>
             collection
                 .unions()
                 .map((union, i) =>
-                    StatementFactory.constant(tsc)(
-                        importer.useLocal(`${config.unioners}${i}`),
-                        write_union(tsc)(config)(union),
+                    StatementFactory.constant(
+                        `${config.prefix}u${i}`,
+                        write_union(config)(union),
                     ),
                 );
 
-    const write_object =
-        (tsc: typeof ts) =>
-        (config: IConfig) =>
-        (importer: FunctionImporter) =>
-        (obj: MetadataObject) =>
-            tsc.factory.createArrowFunction(
-                undefined,
-                undefined,
-                PARAMETERS(tsc)(config)(TypeFactory.keyword(tsc)("any"))(
-                    ValueFactory.INPUT(tsc)(),
-                ),
-                config.objector.type ?? TypeFactory.keyword(tsc)("any"),
-                undefined,
-                config.objector.joiner(
-                    tsc.factory.createIdentifier("input"),
-                    feature_object_entries(tsc)(config)(importer)(obj)(
-                        tsc.factory.createIdentifier("input"),
-                    ),
-                    obj,
-                ),
-            );
-
-    const write_union = (tsc: typeof ts) => (config: IConfig) => {
-        const explorer = UnionExplorer.object(tsc)(config);
-        const input = ValueFactory.INPUT(tsc)();
+    const write_union = (config: IConfig) => {
+        const explorer = UnionExplorer.object(config);
+        const input = ValueFactory.INPUT();
 
         return (meta: MetadataObject[]) =>
-            tsc.factory.createArrowFunction(
+            ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(tsc)(config)(TypeFactory.keyword(tsc)("any"))(
-                    ValueFactory.INPUT(tsc)(),
+                parameterDeclarations(config)(TypeFactory.keyword("any"))(
+                    ValueFactory.INPUT(),
                 ),
-                TypeFactory.keyword(tsc)("any"),
+                TypeFactory.keyword("any"),
                 undefined,
                 explorer(
                     input,
                     meta,
                     {
                         tracable: config.path || config.trace,
-                        source: "object",
+                        source: "function",
                         from: "object",
                         postfix: "",
                     },
@@ -355,55 +341,54 @@ export namespace FeatureProgrammer {
         DECODERS
     ----------------------------------------------------------- */
     export const decode_array =
-        (tsc: typeof ts) =>
-        (config: Pick<IConfig, "trace" | "path" | "decoder">) =>
+        (config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">) =>
         (importer: FunctionImporter) =>
         (
             combiner: (
                 input: ts.Expression,
                 arrow: ts.ArrowFunction,
                 metaTags: IMetadataTag[],
-                jsDocTags: JSDocTagInfo[],
+                jsDocTags: ts.JSDocTagInfo[],
             ) => ts.Expression,
         ) => {
             const rand: string = importer.increment().toString();
             const tail =
                 config.path || config.trace
                     ? [
-                          IdentifierFactory.parameter(tsc)(
+                          IdentifierFactory.parameter(
                               "_index" + rand,
-                              TypeFactory.keyword(tsc)("number"),
+                              TypeFactory.keyword("number"),
                           ),
                       ]
                     : [];
 
             return (
                 input: ts.Expression,
-                meta: Metadata,
+                array: MetadataArray,
                 explore: IExplore,
                 metaTags: IMetadataTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => {
-                const arrow: ts.ArrowFunction = tsc.factory.createArrowFunction(
+                const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [
-                        IdentifierFactory.parameter(tsc)(
+                        IdentifierFactory.parameter(
                             "elem",
-                            TypeFactory.keyword(tsc)("any"),
+                            TypeFactory.keyword("any"),
                         ),
                         ...tail,
                     ],
                     undefined,
                     undefined,
-                    config.decoder(
-                        ValueFactory.INPUT(tsc)("elem"),
-                        meta,
+                    config.decoder()(
+                        ValueFactory.INPUT("elem"),
+                        array.value,
                         {
                             tracable: explore.tracable,
                             source: explore.source,
                             from: "array",
-                            postfix: INDEX_SYMBOL(explore.start ?? null)(
+                            postfix: index(explore.start ?? null)(
                                 explore.postfix,
                             )(rand),
                         },
@@ -416,20 +401,33 @@ export namespace FeatureProgrammer {
         };
 
     export const decode_object =
-        (tsc: typeof ts) =>
-        (config: Pick<IConfig, "trace" | "path" | "functors">) =>
+        (config: Pick<IConfig, "trace" | "path" | "prefix">) =>
         (importer: FunctionImporter) =>
         (input: ts.Expression, obj: MetadataObject, explore: IExplore) =>
-            tsc.factory.createCallExpression(
-                tsc.factory.createIdentifier(
-                    importer.useLocal(`${config.functors}${obj.index}`),
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    importer.useLocal(`${config.prefix}o${obj.index}`),
                 ),
                 undefined,
-                get_object_arguments(tsc)(config)(explore)(input),
+                argumentsArray(config)(explore)(input),
             );
 
-    export const get_object_arguments =
-        (tsc: typeof ts) =>
+    /* -----------------------------------------------------------
+        UTILITIES FOR INTERNAL FUNCTIONS
+    ----------------------------------------------------------- */
+    export const index =
+        (start: number | null) => (prev: string) => (rand: string) => {
+            const tail: string =
+                start !== null
+                    ? `"[" + (${start} + _index${rand}) + "]"`
+                    : `"[" + _index${rand} + "]"`;
+            if (prev === "") return tail;
+            else if (prev[prev.length - 1] === `"`)
+                return prev.substring(0, prev.length - 1) + tail.substring(1);
+            return prev + ` + ${tail}`;
+        };
+
+    export const argumentsArray =
         (config: Pick<IConfig, "path" | "trace">) =>
         (explore: FeatureProgrammer.IExplore) => {
             const tail: ts.Expression[] =
@@ -437,74 +435,61 @@ export namespace FeatureProgrammer {
                     ? []
                     : config.path === true && config.trace === true
                     ? [
-                          tsc.factory.createIdentifier(
+                          ts.factory.createIdentifier(
                               explore.postfix
                                   ? `_path + ${explore.postfix}`
                                   : "_path",
                           ),
-                          explore.source === "object"
-                              ? tsc.factory.createIdentifier(
+                          explore.source === "function"
+                              ? ts.factory.createIdentifier(
                                     `${explore.tracable} && _exceptionable`,
                                 )
                               : explore.tracable
-                              ? tsc.factory.createTrue()
-                              : tsc.factory.createFalse(),
+                              ? ts.factory.createTrue()
+                              : ts.factory.createFalse(),
                       ]
                     : config.path === true
                     ? [
-                          tsc.factory.createIdentifier(
+                          ts.factory.createIdentifier(
                               explore.postfix
                                   ? `_path + ${explore.postfix}`
                                   : "_path",
                           ),
                       ]
                     : [
-                          explore.source === "object"
-                              ? tsc.factory.createIdentifier(
+                          explore.source === "function"
+                              ? ts.factory.createIdentifier(
                                     `${explore.tracable} && _exceptionable`,
                                 )
                               : explore.tracable
-                              ? tsc.factory.createTrue()
-                              : tsc.factory.createFalse(),
+                              ? ts.factory.createTrue()
+                              : ts.factory.createFalse(),
                       ];
             return (input: ts.Expression) => [input, ...tail];
         };
-}
-
-const INDEX_SYMBOL =
-    (start: number | null) => (prev: string) => (rand: string) => {
-        const tail: string =
-            start !== null
-                ? `"[" + (${start} + _index${rand}) + "]"`
-                : `"[" + _index${rand} + "]"`;
-        if (prev === "") return tail;
-        else if (prev[prev.length - 1] === `"`)
-            return prev.substring(0, prev.length - 1) + tail.substring(1);
-        return prev + ` + ${tail}`;
-    };
 
-const PARAMETERS =
-    (tsc: typeof ts) =>
-    (props: Pick<CheckerProgrammer.IConfig, "path" | "trace">) =>
-    (type: ts.TypeNode) => {
-        const tail: ts.ParameterDeclaration[] = [];
-        if (props.path)
-            tail.push(
-                IdentifierFactory.parameter(tsc)(
-                    "_path",
-                    TypeFactory.keyword(tsc)("string"),
-                ),
-            );
-        if (props.trace)
-            tail.push(
-                IdentifierFactory.parameter(tsc)(
-                    "_exceptionable",
-                    TypeFactory.keyword(tsc)("boolean"),
-                    tsc.factory.createTrue(),
-                ),
-            );
-        return (input: ts.Identifier) => [
-            IdentifierFactory.parameter(tsc)(input, type),
-            ...tail,
-        ];
-    };
+    export const parameterDeclarations =
+        (props: Pick<CheckerProgrammer.IConfig, "path" | "trace">) =>
+        (type: ts.TypeNode) => {
+            const tail: ts.ParameterDeclaration[] = [];
+            if (props.path)
+                tail.push(
+                    IdentifierFactory.parameter(
+                        "_path",
+                        TypeFactory.keyword("string"),
+                    ),
+                );
+            if (props.trace)
+                tail.push(
+                    IdentifierFactory.parameter(
+                        "_exceptionable",
+                        TypeFactory.keyword("boolean"),
+                        ts.factory.createTrue(),
+                    ),
+                );
+            return (input: ts.Identifier): ts.ParameterDeclaration[] => [
+                IdentifierFactory.parameter(input, type),
+                ...tail,
+            ];
+        };
+}

package/src/programmers/IsCloneProgrammer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -10,69 +10,76 @@ import { CloneProgrammer } from "./CloneProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 
 export namespace IsCloneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
     export const write =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            p.tsc.factory.createArrowFunction(
+            ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(p.tsc)(
+                    IdentifierFactory.parameter(
                         "input",
-                        TypeFactory.keyword(p.tsc)("any"),
+                        TypeFactory.keyword("any"),
                     ),
                 ],
-                p.tsc.factory.createUnionTypeNode([
-                    p.tsc.factory.createTypeReferenceNode(
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode(
                         `typia.Primitive<${
-                            name ?? TypeFactory.getFullName(p)(type)
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
                         }>`,
                     ),
-                    p.tsc.factory.createLiteralTypeNode(
-                        p.tsc.factory.createNull(),
-                    ),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "is",
-                        IsProgrammer.write(p)(modulo)(false)(type, name),
+                        IsProgrammer.write(project)(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "clone",
                         CloneProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    p.tsc.factory.createIfStatement(
-                        p.tsc.factory.createPrefixUnaryExpression(
-                            p.tsc.SyntaxKind.ExclamationToken,
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("is"),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                         ),
-                        p.tsc.factory.createReturnStatement(
-                            p.tsc.factory.createNull(),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createNull(),
                         ),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "output",
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("clone"),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("clone"),
                             undefined,
-                            [p.tsc.factory.createIdentifier("input")],
+                            [ts.factory.createIdentifier("input")],
                         ),
                     ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createIdentifier("output"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
                     ),
                 ]),
             );