npm - typia - Versions diffs - 3.4.5 → 3.4.6 - Mend

typia 3.4.5 → 3.4.6

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

package/README.md +5 -47
package/package.json +1 -1
package/src/executable/internal/TypiaSetupWizard.ts +148 -148
package/src/executable/typia.ts +35 -35
package/src/factories/MetadataTagFactory.ts +347 -347
package/src/factories/internal/iterate_metadata.ts +81 -81
package/src/factories/internal/iterate_metadata_native.ts +227 -227
package/src/functional/$number.ts +19 -19
package/src/index.ts +4 -4
package/src/module.ts +1535 -1535
package/src/programmers/ApplicationProgrammer.ts +55 -55
package/src/programmers/StringifyProgrammer.ts +746 -746
package/src/programmers/internal/application_array.ts +45 -45
package/src/programmers/internal/application_default.ts +17 -17
package/src/programmers/internal/application_number.ts +76 -76
package/src/programmers/internal/application_object.ts +103 -103
package/src/programmers/internal/application_string.ts +49 -49
package/src/schemas/IJsonComponents.ts +24 -24
package/src/schemas/IJsonSchema.ts +92 -92
package/src/transformers/CallExpressionTransformer.ts +124 -124
package/src/transformers/features/miscellaneous/ApplicationTransformer.ts +114 -114
package/src/transformers/features/miscellaneous/CreateInstanceTransformer.ts +41 -41
package/src/transformers/features/miscellaneous/MetadataTransformer.ts +55 -55
package/src/transformers/features/parsers/AssertParseTransformer.ts +36 -36
package/src/transformers/features/parsers/CreateAssertParseTransformer.ts +32 -32
package/src/transformers/features/parsers/CreateIsParseTransformer.ts +32 -32
package/src/transformers/features/parsers/CreateValidateParseTransformer.ts +32 -32
package/src/transformers/features/parsers/IsParseTransformer.ts +36 -36
package/src/transformers/features/parsers/ValidateParseTransformer.ts +36 -36
package/src/transformers/features/stringifiers/AssertStringifyTransformer.ts +38 -38
package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts +32 -32
package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts +32 -32
package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts +31 -31
package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts +32 -32
package/src/transformers/features/stringifiers/IsStringifyTransformer.ts +38 -38
package/src/transformers/features/stringifiers/StringifyTransformer.ts +36 -36
package/src/transformers/features/stringifiers/ValidateStringifyTransformer.ts +38 -38
package/src/transformers/features/validators/AssertTransformer.ts +43 -43
package/src/transformers/features/validators/CreateAssertTransformer.ts +35 -35
package/src/transformers/features/validators/CreateIsTransformer.ts +35 -35
package/src/transformers/features/validators/CreateValidateTransformer.ts +35 -35
package/src/transformers/features/validators/IsTransformer.ts +43 -43
package/src/transformers/features/validators/ValidateTransformer.ts +43 -43

package/src/transformers/features/validators/CreateAssertTransformer.ts CHANGED Viewed

@@ -1,35 +1,35 @@
-import ts from "typescript";
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-import { IProject } from "../../IProject";
-export namespace CreateAssertTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createAssertEquals" : "createAssert";
-        const MESSAGES = {
-            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(MESSAGES.NOT_SPECIFIED);
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-            // DO TRANSFORM
-            return AssertProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+import { IProject } from "../../IProject";
+export namespace CreateAssertTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createAssertEquals" : "createAssert";
+        const MESSAGES = {
+            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !expression.typeArguments[0])
+                throw new Error(MESSAGES.NOT_SPECIFIED);
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+            // DO TRANSFORM
+            return AssertProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}

package/src/transformers/features/validators/CreateIsTransformer.ts CHANGED Viewed

@@ -1,35 +1,35 @@
-import ts from "typescript";
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-import { IProject } from "../../IProject";
-export namespace CreateIsTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createEquals" : "createIs";
-        const MESSAGES = {
-            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(MESSAGES.NOT_SPECIFIED);
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-            // DO TRANSFORM
-            return IsProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+import { IProject } from "../../IProject";
+export namespace CreateIsTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createEquals" : "createIs";
+        const MESSAGES = {
+            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !expression.typeArguments[0])
+                throw new Error(MESSAGES.NOT_SPECIFIED);
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+            // DO TRANSFORM
+            return IsProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}

package/src/transformers/features/validators/CreateValidateTransformer.ts CHANGED Viewed

@@ -1,35 +1,35 @@
-import ts from "typescript";
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-import { IProject } from "../../IProject";
-export namespace CreateValidateTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createValidateEquals" : "createValidate";
-        const MESSAGES = {
-            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(MESSAGES.NOT_SPECIFIED);
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-            // DO TRANSFORM
-            return ValidateProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+import { IProject } from "../../IProject";
+export namespace CreateValidateTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createValidateEquals" : "createValidate";
+        const MESSAGES = {
+            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !expression.typeArguments[0])
+                throw new Error(MESSAGES.NOT_SPECIFIED);
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+            // DO TRANSFORM
+            return ValidateProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}

package/src/transformers/features/validators/IsTransformer.ts CHANGED Viewed

@@ -1,43 +1,43 @@
-import ts from "typescript";
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-import { IProject } from "../../IProject";
-export namespace IsTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "equals" : "is";
-        const MESSAGES = {
-            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            if (expression.arguments.length !== 1)
-                throw new Error(MESSAGES.NO_INPUT_VALUE);
-            // GET TYPE INFO
-            const type: ts.Type =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? project.checker.getTypeFromTypeNode(
-                          expression.typeArguments[0],
-                      )
-                    : project.checker.getTypeAtLocation(
-                          expression.arguments[0]!,
-                      );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                IsProgrammer.generate(project, modulo, equals)(type),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-    }
-}
+import ts from "typescript";
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+import { IProject } from "../../IProject";
+export namespace IsTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "equals" : "is";
+        const MESSAGES = {
+            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            if (expression.arguments.length !== 1)
+                throw new Error(MESSAGES.NO_INPUT_VALUE);
+            // GET TYPE INFO
+            const type: ts.Type =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? project.checker.getTypeFromTypeNode(
+                          expression.typeArguments[0],
+                      )
+                    : project.checker.getTypeAtLocation(
+                          expression.arguments[0]!,
+                      );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                IsProgrammer.generate(project, modulo, equals)(type),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+    }
+}

package/src/transformers/features/validators/ValidateTransformer.ts CHANGED Viewed

@@ -1,43 +1,43 @@
-import ts from "typescript";
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-import { IProject } from "../../IProject";
-export namespace ValidateTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "validateEquals" : "validate";
-        const MESSAGES = {
-            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            if (expression.arguments.length !== 1)
-                throw new Error(MESSAGES.NO_INPUT_VALUE);
-            // GET TYPE INFO
-            const type: ts.Type =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? project.checker.getTypeFromTypeNode(
-                          expression.typeArguments[0],
-                      )
-                    : project.checker.getTypeAtLocation(
-                          expression.arguments[0]!,
-                      );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                ValidateProgrammer.generate(project, modulo, equals)(type),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-    }
-}
+import ts from "typescript";
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+import { IProject } from "../../IProject";
+export namespace ValidateTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "validateEquals" : "validate";
+        const MESSAGES = {
+            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            if (expression.arguments.length !== 1)
+                throw new Error(MESSAGES.NO_INPUT_VALUE);
+            // GET TYPE INFO
+            const type: ts.Type =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? project.checker.getTypeFromTypeNode(
+                          expression.typeArguments[0],
+                      )
+                    : project.checker.getTypeAtLocation(
+                          expression.arguments[0]!,
+                      );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                ValidateProgrammer.generate(project, modulo, equals)(type),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+    }
+}