npm - typia - Versions diffs - 4.0.0-dev.20230502 → 4.0.0-dev.20230519 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (695) hide show

package/src/programmers/TypiaProgrammer.ts CHANGED Viewed

@@ -2,10 +2,11 @@ import fs from "fs";
 import path from "path";
 import ts from "typescript";
+import { FileTransformer } from "../transformers/FileTransformer";
+import { IProject } from "../transformers/IProject";
 import { ImportTransformer } from "../transformers/ImportTransformer";
-import transform from "../transform";
+/// @todo
 export namespace TypiaProgrammer {
     export interface IProps {
         input: string;
@@ -55,7 +56,22 @@ export namespace TypiaProgrammer {
             compilerOptions,
         );
-        // DO TRANSFORM
+        // DO TRANSFORM - @todo: BUG OF TYPESCRIPT
+        const p: IProject = {
+            tsc: ts as any,
+            program: program as any,
+            compilerOptions,
+            checker: program.getTypeChecker() as any,
+            printer: ts.createPrinter() as any,
+            options:
+                ((compilerOptions.plugins as any[]) ?? []).find(
+                    (p: any) =>
+                        p.transform === "typia/lib/transform" ||
+                        p.transform === "./lib/transform" ||
+                        p.path === "typia/lib/transform" ||
+                        p.path === "./lib/transform",
+                ) ?? {},
+        };
         const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
             program
                 .getSourceFiles()
@@ -65,15 +81,11 @@ export namespace TypiaProgrammer {
                         path.resolve(file.fileName).indexOf(props.input) !== -1,
                 ),
             [
-                ImportTransformer.transform(props.input)(props.output),
-                transform(
-                    program,
-                    ((compilerOptions.plugins as any[]) ?? []).find(
-                        (p: any) =>
-                            p.transform === "typia/lib/transform" ||
-                            p.transform === "../src/transform.ts",
-                    ) ?? {},
-                ),
+                ImportTransformer.transform(p.tsc)(props.input)(
+                    props.output,
+                ) as any,
+                (context) => (file) =>
+                    FileTransformer.transform(p)(context as any)(file),
             ],
             program.getCompilerOptions(),
         );

package/src/programmers/ValidateCloneProgrammer.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -19,74 +19,74 @@ export namespace ValidateCloneProgrammer {
             write(project)(modulo)(type, name);
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        TypeFactory.keyword("any"),
+                        TypeFactory.keyword(p.tsc)("any"),
                     ),
                 ],
-                ts.factory.createTypeReferenceNode(
+                p.tsc.factory.createTypeReferenceNode(
                     `typia.IValidation<typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
+                        name ?? TypeFactory.getFullName(p)(type)
                     }>>`,
                 ),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "validate",
                         ValidateProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: true,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "clone",
                         CloneProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "output",
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
+                        p.tsc.factory.createAsExpression(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("validate"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
-                            TypeFactory.keyword("any"),
+                            TypeFactory.keyword(p.tsc)("any"),
                         ),
                     ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createIdentifier("output.success"),
-                        ts.factory.createExpressionStatement(
-                            ts.factory.createBinaryExpression(
-                                ts.factory.createIdentifier("output.data"),
-                                ts.SyntaxKind.EqualsToken,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("clone"),
+                    p.tsc.factory.createIfStatement(
+                        p.tsc.factory.createIdentifier("output.success"),
+                        p.tsc.factory.createExpressionStatement(
+                            p.tsc.factory.createBinaryExpression(
+                                p.tsc.factory.createIdentifier("output.data"),
+                                p.tsc.SyntaxKind.EqualsToken,
+                                p.tsc.factory.createCallExpression(
+                                    p.tsc.factory.createIdentifier("clone"),
                                     undefined,
-                                    [ts.factory.createIdentifier("input")],
+                                    [p.tsc.factory.createIdentifier("input")],
                                 ),
                             ),
                         ),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createIdentifier("output"),
                     ),
                 ]),
             );

package/src/programmers/ValidateParseProgrammer.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -18,59 +18,59 @@ export namespace ValidateParseProgrammer {
             write(project)(modulo)(type, name);
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        TypeFactory.keyword("string"),
+                        TypeFactory.keyword(p.tsc)("string"),
                     ),
                 ],
-                ts.factory.createTypeReferenceNode(
+                p.tsc.factory.createTypeReferenceNode(
                     `typia.IValidation<typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
+                        name ?? TypeFactory.getFullName(p)(type)
                     }>>`,
                 ),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "validate",
                         ValidateProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createIdentifier("input"),
-                            ts.SyntaxKind.EqualsToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("JSON.parse"),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createBinaryExpression(
+                            p.tsc.factory.createIdentifier("input"),
+                            p.tsc.SyntaxKind.EqualsToken,
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("JSON.parse"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
                         ),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("validate"),
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("validate"),
                             undefined,
-                            [ts.factory.createIdentifier("input")],
+                            [p.tsc.factory.createIdentifier("input")],
                         ),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createIdentifier("output"),
-                            ts.factory.createTypeReferenceNode("any"),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createAsExpression(
+                            p.tsc.factory.createIdentifier("output"),
+                            p.tsc.factory.createTypeReferenceNode("any"),
                         ),
                     ),
                 ]),