typia 5.0.0-dev.20230823 → 5.0.0-dev.20230824

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -9,11 +9,13 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -42,7 +44,9 @@ export namespace JsonStringifyProgrammer {
 
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             const config: FeatureProgrammer.IConfig =
                 configure(project)(importer);
 
@@ -186,14 +190,14 @@ export namespace JsonStringifyProgrammer {
             const unions: IUnion[] = [];
 
             // toJSON() METHOD
-            if (meta.resolved !== null)
+            if (meta.escaped !== null)
                 unions.push({
                     type: "resolved",
                     is: () => IsProgrammer.decode_to_json(false)(input),
                     value: () =>
                         decode_to_json(project)(config)(importer)(
                             input,
-                            meta.resolved!.returns,
+                            meta.escaped!.returns,
                             explore,
                         ),
                 });
@@ -211,7 +215,7 @@ export namespace JsonStringifyProgrammer {
             )
                 if (AtomicPredicator.template(meta)) {
                     const partial = Metadata.initialize();
-                    partial.atomics.push("string"),
+                    partial.atomics.push({ type: "string", tags: [] }),
                         unions.push({
                             type: "template literal",
                             is: () =>
@@ -243,7 +247,10 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(constant.type);
+                                    partial.atomics.push({
+                                        type: constant.type,
+                                        tags: [],
+                                    });
                                     return partial;
                                 })(),
                                 explore,
@@ -265,7 +272,10 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push("string");
+                                    partial.atomics.push({
+                                        type: "string",
+                                        tags: [],
+                                    });
                                     return partial;
                                 })(),
                                 explore,
@@ -281,8 +291,8 @@ export namespace JsonStringifyProgrammer {
                     });
 
             /// ATOMICS
-            for (const type of meta.atomics)
-                if (AtomicPredicator.atomic(meta)(type))
+            for (const a of meta.atomics)
+                if (AtomicPredicator.atomic(meta)(a.type))
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -290,7 +300,7 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(type);
+                                    partial.atomics.push(a);
                                     return partial;
                                 })(),
                                 explore,
@@ -300,14 +310,14 @@ export namespace JsonStringifyProgrammer {
                         value: () =>
                             decode_atomic(project)(importer)(
                                 input,
-                                type,
+                                a.type,
                                 explore,
                             ),
                     });
 
             // TUPLES
             for (const tuple of meta.tuples) {
-                for (const child of tuple.elements)
+                for (const child of tuple.type.elements)
                     if (StringifyPredicator.undefindable(meta))
                         throw new Error(
                             `Error on typia.json.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
@@ -338,9 +348,9 @@ export namespace JsonStringifyProgrammer {
             // ARRAYS
             if (meta.arrays.length) {
                 for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.value))
+                    if (StringifyPredicator.undefindable(child.type.value))
                         throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.value.getName()}).`,
+                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
                         );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
@@ -353,7 +363,7 @@ export namespace JsonStringifyProgrammer {
                                       from: "array",
                                   },
                               )
-                        : meta.arrays.some((elem) => elem.value.any)
+                        : meta.arrays.some((elem) => elem.type.value.any)
                         ? () =>
                               ts.factory.createCallExpression(
                                   ts.factory.createIdentifier("JSON.stringify"),
@@ -510,10 +520,12 @@ export namespace JsonStringifyProgrammer {
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
-            array.recursive
+            array.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}a${array.index}`),
+                          importer.useLocal(
+                              `${config.prefix}a${array.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -522,14 +534,18 @@ export namespace JsonStringifyProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(
@@ -545,10 +561,12 @@ export namespace JsonStringifyProgrammer {
             tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                          importer.useLocal(
+                              `${config.prefix}t${tuple.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -558,7 +576,7 @@ export namespace JsonStringifyProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -568,7 +586,7 @@ export namespace JsonStringifyProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -747,7 +765,7 @@ export namespace JsonStringifyProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -761,7 +779,7 @@ export namespace JsonStringifyProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -777,7 +795,7 @@ export namespace JsonStringifyProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -931,15 +949,15 @@ export namespace JsonStringifyProgrammer {
         (type) => {
             const collection: MetadataCollection = new MetadataCollection();
             const meta: Metadata = MetadataFactory.analyze(checker)({
-                resolve: true,
+                escape: true,
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
-                    if (meta.atomics.find((str) => str === "bigint"))
+                    if (meta.atomics.find((a) => a.type === "bigint"))
                         throw new Error(NO_BIGINT);
                     else if (
                         meta.arrays.some(
-                            (array) => array.value.isRequired() === false,
+                            (array) => array.type.value.isRequired() === false,
                         )
                     )
                         throw new Error(NO_UNDEFINED_IN_ARRAY);

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -24,7 +24,7 @@ export namespace MiscAssertCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
+                    `typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),