npm - typia - Versions diffs - 4.0.0-dev.20230520 → 4.0.0-dev.20230603 - Mend

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

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 (653) hide show

package/src/programmers/TypiaProgrammer.ts CHANGED Viewed

@@ -2,11 +2,10 @@ 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";
-/// @todo
+import transform from "../transform";
 export namespace TypiaProgrammer {
     export interface IProps {
         input: string;
@@ -56,22 +55,7 @@ export namespace TypiaProgrammer {
             compilerOptions,
         );
-        // 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",
-                ) ?? {},
-        };
+        // DO TRANSFORM
         const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
             program
                 .getSourceFiles()
@@ -81,11 +65,15 @@ export namespace TypiaProgrammer {
                         path.resolve(file.fileName).indexOf(props.input) !== -1,
                 ),
             [
-                ImportTransformer.transform(p.tsc)(props.input)(
-                    props.output,
-                ) as any,
-                (context) => (file) =>
-                    FileTransformer.transform(p)(context as any)(file),
+                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",
+                    ) ?? {},
+                ),
             ],
             program.getCompilerOptions(),
         );

package/src/programmers/ValidateCloneProgrammer.ts CHANGED Viewed

@@ -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";
@@ -19,74 +19,74 @@ export namespace ValidateCloneProgrammer {
             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.createTypeReferenceNode(
+                ts.factory.createTypeReferenceNode(
                     `typia.IValidation<typia.Primitive<${
-                        name ?? TypeFactory.getFullName(p)(type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>>`,
                 ),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "validate",
                         ValidateProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: true,
                             },
                         })(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),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "output",
-                        p.tsc.factory.createAsExpression(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("validate"),
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
-                            TypeFactory.keyword(p.tsc)("any"),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
-                    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"),
+                    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"),
                                     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"),
                     ),
                 ]),
             );

package/src/programmers/ValidateParseProgrammer.ts CHANGED Viewed

@@ -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";
@@ -18,59 +18,59 @@ export namespace ValidateParseProgrammer {
             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)("string"),
+                        TypeFactory.keyword("string"),
                     ),
                 ],
-                p.tsc.factory.createTypeReferenceNode(
+                ts.factory.createTypeReferenceNode(
                     `typia.IValidation<typia.Primitive<${
-                        name ?? TypeFactory.getFullName(p)(type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>>`,
                 ),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "validate",
                         ValidateProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    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"),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createIdentifier("input"),
+                            ts.SyntaxKind.EqualsToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("JSON.parse"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                         ),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "output",
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("validate"),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
                             undefined,
-                            [p.tsc.factory.createIdentifier("input")],
+                            [ts.factory.createIdentifier("input")],
                         ),
                     ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createAsExpression(
-                            p.tsc.factory.createIdentifier("output"),
-                            p.tsc.factory.createTypeReferenceNode("any"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createIdentifier("output"),
+                            ts.factory.createTypeReferenceNode("any"),
                         ),
                     ),
                 ]),