typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/programmers/CloneProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
@@ -18,28 +18,16 @@ import { UnionExplorer } from "./helpers/UnionExplorer";
 import { decode_union_object } from "./internal/decode_union_object";
 
 export namespace CloneProgrammer {
-    /**
-     * @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 =
-        (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
-            return FeatureProgrammer.analyze(project)({
-                ...CONFIG(project, importer),
+        (p: IProject) => (modulo: ts.LeftHandSideExpression) => {
+            const importer: FunctionImporter = new FunctionImporter(p.tsc);
+            return FeatureProgrammer.analyze(p)({
+                ...CONFIG(p)(importer),
                 addition: (collection) => {
                     const isFunctors =
-                        IsProgrammer.write_functors(project)(importer)(
-                            collection,
-                        );
+                        IsProgrammer.write_functors(p)(importer)(collection);
                     const isUnioners =
-                        IsProgrammer.write_unioners(project)(importer)(
-                            collection,
-                        );
+                        IsProgrammer.write_unioners(p)(importer)(collection);
 
                     return [
                         ...importer.declare(modulo),
@@ -58,7 +46,8 @@ export namespace CloneProgrammer {
         DECODERS
     ----------------------------------------------------------- */
     const decode =
-        (project: IProject, importer: FunctionImporter) =>
+        (p: IProject) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             meta: Metadata,
@@ -70,7 +59,7 @@ export namespace CloneProgrammer {
                 meta.arrays.some((a) => a.any) ||
                 meta.tuples.some((t) => t.every((e) => e.any))
             )
-                return ts.factory.createCallExpression(
+                return p.tsc.factory.createCallExpression(
                     importer.use("any"),
                     undefined,
                     [input],
@@ -90,9 +79,9 @@ export namespace CloneProgrammer {
             if (meta.resolved !== null)
                 unions.push({
                     type: "resolved",
-                    is: () => IsProgrammer.decode_to_json(true)(input),
+                    is: () => IsProgrammer.decode_to_json(p.tsc)(true)(input),
                     value: () =>
-                        decode_to_json(project, importer)(
+                        decode_to_json(p)(importer)(
                             input,
                             meta.resolved!,
                             explore,
@@ -104,7 +93,7 @@ export namespace CloneProgrammer {
                 unions.push({
                     type: "tuple",
                     is: () =>
-                        IsProgrammer.decode(project, importer)(
+                        IsProgrammer.decode(p)(importer)(
                             input,
                             (() => {
                                 const partial = Metadata.initialize();
@@ -116,16 +105,16 @@ export namespace CloneProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(project, importer)(input, tuple, explore),
+                        decode_tuple(p)(importer)(input, tuple, explore),
                 });
 
             // ARRAYS
             if (meta.arrays.length)
                 unions.push({
                     type: "array",
-                    is: () => ExpressionFactory.isArray(input),
+                    is: () => ExpressionFactory.isArray(p.tsc)(input),
                     value: () =>
-                        explore_arrays(project, importer)(
+                        explore_arrays(p)(importer)(
                             input,
                             meta.arrays,
                             {
@@ -141,29 +130,34 @@ export namespace CloneProgrammer {
             if (meta.sets.length)
                 unions.push({
                     type: "set",
-                    is: () => ExpressionFactory.isInstanceOf("Set")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    is: () =>
+                        ExpressionFactory.isInstanceOf(p.tsc)("Set")(input),
+                    value: () => p.tsc.factory.createIdentifier("{}"),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
-                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    is: () =>
+                        ExpressionFactory.isInstanceOf(p.tsc)("Map")(input),
+                    value: () => p.tsc.factory.createIdentifier("{}"),
                 });
             for (const native of meta.natives)
                 unions.push({
                     type: "native",
-                    is: () => ExpressionFactory.isInstanceOf(native)(input),
+                    is: () =>
+                        ExpressionFactory.isInstanceOf(p.tsc)(native)(input),
                     value: () =>
                         native === "Boolean" ||
                         native === "Number" ||
                         native === "String"
-                            ? ts.factory.createCallExpression(
-                                  IdentifierFactory.access(input)("valueOf"),
+                            ? p.tsc.factory.createCallExpression(
+                                  IdentifierFactory.access(p.tsc)(input)(
+                                      "valueOf",
+                                  ),
                                   undefined,
                                   undefined,
                               )
-                            : ts.factory.createIdentifier("{}"),
+                            : p.tsc.factory.createIdentifier("{}"),
                 });
 
             // OBJECTS
@@ -171,12 +165,12 @@ export namespace CloneProgrammer {
                 unions.push({
                     type: "object",
                     is: () =>
-                        ExpressionFactory.isObject({
+                        ExpressionFactory.isObject(p.tsc)({
                             checkNull: true,
                             checkArray: false,
                         })(input),
                     value: () =>
-                        explore_objects(importer)(input, meta, {
+                        explore_objects(p.tsc)(importer)(input, meta, {
                             ...explore,
                             from: "object",
                         }),
@@ -185,29 +179,30 @@ export namespace CloneProgrammer {
             // COMPOSITION
             let last: ts.Expression = input;
             for (const u of unions.reverse())
-                last = ts.factory.createConditionalExpression(
+                last = p.tsc.factory.createConditionalExpression(
                     u.is(),
                     undefined,
                     u.value(),
                     undefined,
                     last,
                 );
-            return ts.factory.createAsExpression(
+            return p.tsc.factory.createAsExpression(
                 last,
-                TypeFactory.keyword("any"),
+                TypeFactory.keyword(p.tsc)("any"),
             );
         };
 
     const decode_to_json =
-        (project: IProject, importer: FunctionImporter) =>
+        (p: IProject) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             resolved: Metadata,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
-            return decode(project, importer)(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(input)("toJSON"),
+            return decode(p)(importer)(
+                p.tsc.factory.createCallExpression(
+                    IdentifierFactory.access(p.tsc)(input)("toJSON"),
                     undefined,
                     [],
                 ),
@@ -217,7 +212,8 @@ export namespace CloneProgrammer {
         };
 
     const decode_tuple =
-        (project: IProject, importer: FunctionImporter) =>
+        (p: IProject) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             tuple: Metadata[],
@@ -226,8 +222,11 @@ export namespace CloneProgrammer {
             const children: ts.Expression[] = tuple
                 .filter((m) => m.rest === null)
                 .map((elem, index) =>
-                    decode(project, importer)(
-                        ts.factory.createElementAccessExpression(input, index),
+                    decode(p)(importer)(
+                        p.tsc.factory.createElementAccessExpression(
+                            input,
+                            index,
+                        ),
                         elem,
                         {
                             ...explore,
@@ -242,11 +241,11 @@ export namespace CloneProgrammer {
                 const rest: Metadata | null = last.rest;
                 if (rest === null) return null;
 
-                return decode(project, importer)(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(input)("slice"),
+                return decode(p)(importer)(
+                    p.tsc.factory.createCallExpression(
+                        IdentifierFactory.access(p.tsc)(input)("slice"),
                         undefined,
-                        [ts.factory.createNumericLiteral(tuple.length - 1)],
+                        [p.tsc.factory.createNumericLiteral(tuple.length - 1)],
                     ),
                     (() => {
                         const wrapper: Metadata = Metadata.initialize();
@@ -259,32 +258,33 @@ export namespace CloneProgrammer {
                     },
                 );
             })();
-            return CloneJoiner.tuple(children, rest);
+            return CloneJoiner.tuple(p.tsc)(children, rest);
         };
 
-    const decode_array = (project: IProject, importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(CONFIG(project, importer))(importer)(
-            CloneJoiner.array,
+    const decode_array = (p: IProject, importer: FunctionImporter) =>
+        FeatureProgrammer.decode_array(p.tsc)(CONFIG(p)(importer))(importer)(
+            CloneJoiner.array(p.tsc),
         );
 
-    const decode_object = (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_object({
+    const decode_object = (tsc: typeof ts) => (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_object(tsc)({
             trace: false,
             path: false,
             functors: FUNCTORS,
         })(importer);
 
-    const explore_arrays = (project: IProject, importer: FunctionImporter) =>
-        UnionExplorer.array({
-            checker: IsProgrammer.decode(project, importer),
-            decoder: decode_array(project, importer),
-            empty: ts.factory.createReturnStatement(),
-            success: ts.factory.createTrue(),
+    const explore_arrays = (p: IProject) => (importer: FunctionImporter) =>
+        UnionExplorer.array(p.tsc)({
+            checker: IsProgrammer.decode(p)(importer),
+            decoder: decode_array(p, importer),
+            empty: p.tsc.factory.createReturnStatement(),
+            success: p.tsc.factory.createTrue(),
             failure: (input, expected) =>
-                create_throw_error(importer, input, expected),
+                create_throw_error(p.tsc)(importer, input, expected),
         });
 
     const explore_objects =
+        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -292,14 +292,14 @@ export namespace CloneProgrammer {
             explore: FeatureProgrammer.IExplore,
         ) => {
             if (meta.objects.length === 1)
-                return decode_object(importer)(
+                return decode_object(tsc)(importer)(
                     input,
                     meta.objects[0]!,
                     explore,
                 );
 
-            return ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+            return tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
                 undefined,
                 [input],
             );
@@ -311,79 +311,77 @@ export namespace CloneProgrammer {
     const FUNCTORS = "$co";
     const UNIONERS = "$cu";
 
-    const CONFIG = (
-        project: IProject,
-        importer: FunctionImporter,
-    ): FeatureProgrammer.IConfig => ({
-        types: {
-            input: (type, name) =>
-                ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
-                ),
-            output: (type, name) =>
-                ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-        },
-        functors: FUNCTORS,
-        unioners: UNIONERS,
-        trace: false,
-        path: false,
-        initializer,
-        decoder: decode(project, importer),
-        objector: OBJECTOR(project, importer),
-    });
+    const CONFIG =
+        (p: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
+            types: {
+                input: (type, name) =>
+                    p.tsc.factory.createTypeReferenceNode(
+                        name ?? TypeFactory.getFullName(p)(type),
+                    ),
+                output: (type, name) =>
+                    p.tsc.factory.createTypeReferenceNode(
+                        `typia.Primitive<${
+                            name ?? TypeFactory.getFullName(p)(type)
+                        }>`,
+                    ),
+            },
+            functors: FUNCTORS,
+            unioners: UNIONERS,
+            trace: false,
+            path: false,
+            initializer,
+            decoder: decode(p)(importer),
+            objector: OBJECTOR(p)(importer),
+        });
 
-    const OBJECTOR = (
-        project: IProject,
-        importer: FunctionImporter,
-    ): FeatureProgrammer.IConfig.IObjector => ({
-        checker: IsProgrammer.decode(project, importer),
-        decoder: decode_object(importer),
-        joiner: CloneJoiner.object,
-        unionizer: decode_union_object(IsProgrammer.decode_object(importer))(
-            decode_object(importer),
-        )((exp) => exp)((value, expected) =>
-            create_throw_error(importer, value, expected),
-        ),
-        failure: (input, expected) =>
-            create_throw_error(importer, input, expected),
-    });
+    const OBJECTOR =
+        (p: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
+            checker: IsProgrammer.decode(p)(importer),
+            decoder: decode_object(p.tsc)(importer),
+            joiner: CloneJoiner.object(p.tsc),
+            unionizer: decode_union_object(p.tsc)(
+                IsProgrammer.decode_object(p.tsc)(importer),
+            )(decode_object(p.tsc)(importer))((exp) => exp)((value, expected) =>
+                create_throw_error(p.tsc)(importer, value, expected),
+            ),
+            failure: (input, expected) =>
+                create_throw_error(p.tsc)(importer, input, expected),
+        });
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
-        ({ checker }) =>
-        (type) => {
+        (p) => (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const meta = MetadataFactory.analyze(p)({
                 resolve: true,
                 constant: true,
             })(collection)(type);
             return [collection, meta];
         };
 
-    const create_throw_error = (
-        importer: FunctionImporter,
-        value: ts.Expression,
-        expected: string,
-    ) =>
-        ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-                importer.use("throws"),
-                [],
-                [
-                    ts.factory.createObjectLiteralExpression(
-                        [
-                            ts.factory.createPropertyAssignment(
-                                "expected",
-                                ts.factory.createStringLiteral(expected),
-                            ),
-                            ts.factory.createPropertyAssignment("value", value),
-                        ],
-                        true,
-                    ),
-                ],
-            ),
-        );
+    const create_throw_error =
+        (tsc: typeof ts) =>
+        (importer: FunctionImporter, value: ts.Expression, expected: string) =>
+            tsc.factory.createExpressionStatement(
+                tsc.factory.createCallExpression(
+                    importer.use("throws"),
+                    [],
+                    [
+                        tsc.factory.createObjectLiteralExpression(
+                            [
+                                tsc.factory.createPropertyAssignment(
+                                    "expected",
+                                    tsc.factory.createStringLiteral(expected),
+                                ),
+                                tsc.factory.createPropertyAssignment(
+                                    "value",
+                                    value,
+                                ),
+                            ],
+                            true,
+                        ),
+                    ],
+                ),
+            );
 }