typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/programmers/internal/check_union_array_like.ts

@@ -4,7 +4,6 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
@@ -26,8 +25,6 @@ export const check_union_array_like =
         input: ts.Expression,
         origins: Origin[],
         explore: FeatureProgrammer.IExplore,
-        tags: IMetadataCommentTag[],
-        jsDocTags: ts.JSDocTagInfo[],
     ): ts.ArrowFunction => {
         // ONLY ONE TYPE
         const targets: Array<Category> = origins.map(accessor.transform);
@@ -38,13 +35,7 @@ export const check_union_array_like =
                 parameters,
                 undefined,
                 undefined,
-                props.decoder(
-                    accessor.array(input),
-                    targets[0]!,
-                    explore,
-                    tags,
-                    jsDocTags,
-                ),
+                props.decoder(accessor.array(input), targets[0]!, explore),
             );
 
         const array = ts.factory.createIdentifier("array");
@@ -87,8 +78,6 @@ export const check_union_array_like =
                                         ? `"[0]"`
                                         : "",
                             },
-                            tags,
-                            jsDocTags,
                             array,
                         ),
                     ),
@@ -110,8 +99,6 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: true,
                             },
-                            tags,
-                            jsDocTags,
                         ),
                     ),
                 ],
@@ -301,8 +288,6 @@ export namespace check_union_array_like {
             front: ts.Expression,
             target: Element,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
             container: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<Category>;

package/src/programmers/internal/feature_object_entries.ts

@@ -41,23 +41,17 @@ export const feature_object_entries =
                 input: propInput,
                 key: prop.key,
                 meta: prop.value,
-                expression: config.decoder()(
-                    propInput,
-                    prop.value,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from,
-                        postfix:
-                            sole !== null
-                                ? IdentifierFactory.postfix(sole)
-                                : (() => {
-                                      importer.use("join");
-                                      return `$join(key)`;
-                                  })(),
-                    },
-                    prop.tags,
-                    prop.jsDocTags,
-                ),
+                expression: config.decoder()(propInput, prop.value, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from,
+                    postfix:
+                        sole !== null
+                            ? IdentifierFactory.postfix(sole)
+                            : (() => {
+                                  importer.use("join");
+                                  return `$join(key)`;
+                              })(),
+                }),
             };
         });

package/src/programmers/internal/random_custom.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { LiteralFactory } from "../../factories/LiteralFactory";
 
-import { ICommentTag } from "../../schemas/metadata/ICommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 import { Customizable } from "../../typings/Customizable";
 
@@ -13,7 +13,7 @@ import { Customizable } from "../../typings/Customizable";
 export const random_custom =
     (accessor: (name: string) => ts.Expression) =>
     (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
+    (tags: IMetadataTypeTag[]) =>
     (expression: ts.Expression) =>
         ExpressionFactory.coalesce(
             ts.factory.createCallChain(
@@ -24,6 +24,6 @@ export const random_custom =
                 ),
                 ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
                 undefined,
-                [LiteralFactory.generate(comments)],
+                [LiteralFactory.generate(tags)],
             ),
         )(expression);

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -3,6 +3,8 @@ import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
+import { TransformerError } from "../../transformers/TransformerError";
+
 import { application_schema } from "../internal/application_schema";
 
 export namespace JsonApplicationProgrammer {
@@ -35,9 +37,10 @@ export namespace JsonApplicationProgrammer {
                 schemas: metadatas.map((meta, i) => {
                     const schema: IJsonSchema | null = generator(meta)({});
                     if (schema === null)
-                        throw new Error(
-                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                        );
+                        throw new TransformerError({
+                            code: "typia.json.application",
+                            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+                        });
                     return schema;
                 }),
                 components,

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonAssertParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -63,4 +67,5 @@ export namespace JsonAssertParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonIsParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -69,4 +73,5 @@ export namespace JsonIsParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -2,17 +2,15 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-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 { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
@@ -68,7 +66,7 @@ export namespace JsonStringifyProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -81,7 +79,10 @@ export namespace JsonStringifyProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -215,7 +216,9 @@ export namespace JsonStringifyProgrammer {
             )
                 if (AtomicPredicator.template(meta)) {
                     const partial = Metadata.initialize();
-                    partial.atomics.push({ type: "string", tags: [] }),
+                    partial.atomics.push(
+                        MetadataAtomic.create({ type: "string", tags: [] }),
+                    ),
                         unions.push({
                             type: "template literal",
                             is: () =>
@@ -223,8 +226,6 @@ export namespace JsonStringifyProgrammer {
                                     input,
                                     partial,
                                     explore,
-                                    [],
-                                    [],
                                 ),
                             value: () =>
                                 decode_atomic(project)(importer)(
@@ -247,15 +248,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push({
-                                        type: constant.type,
-                                        tags: [],
-                                    });
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: constant.type,
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
@@ -272,15 +273,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push({
-                                        type: "string",
-                                        tags: [],
-                                    });
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: "string",
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_constant_string(project)(importer)(
@@ -304,8 +305,6 @@ export namespace JsonStringifyProgrammer {
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
@@ -316,12 +315,7 @@ export namespace JsonStringifyProgrammer {
                     });
 
             // TUPLES
-            for (const tuple of meta.tuples) {
-                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()}).`,
-                        );
+            for (const tuple of meta.tuples)
                 unions.push({
                     type: "tuple",
                     is: () =>
@@ -333,8 +327,6 @@ export namespace JsonStringifyProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -343,15 +335,9 @@ export namespace JsonStringifyProgrammer {
                             explore,
                         ),
                 });
-            }
 
             // ARRAYS
             if (meta.arrays.length) {
-                for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.type.value))
-                        throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
-                        );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
                         ? () =>
@@ -534,23 +520,19 @@ export namespace JsonStringifyProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(
-                      input,
-                      array.type,
-                      explore,
-                  );
+                : decode_array_inline(config)(importer)(input, array, explore);
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(
                 StringifyJoiner.array,
-            )(input, array, explore, [], []);
+            )(input, array, explore);
 
     const decode_tuple =
         (project: IProject) =>
@@ -765,8 +747,6 @@ export namespace JsonStringifyProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -778,7 +758,7 @@ export namespace JsonStringifyProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
@@ -921,8 +901,6 @@ export namespace JsonStringifyProgrammer {
                             input,
                             meta,
                             explore,
-                            [],
-                            [],
                         ),
                     decoder: () => decode_object(importer),
                     joiner: StringifyJoiner.object(importer),
@@ -946,25 +924,11 @@ export namespace JsonStringifyProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
-        (type) => {
-            const collection: MetadataCollection = new MetadataCollection();
-            const meta: Metadata = MetadataFactory.analyze(checker)({
-                escape: true,
-                constant: true,
-                absorb: true,
-                validate: (meta) => {
-                    if (meta.atomics.find((a) => a.type === "bigint"))
-                        throw new Error(NO_BIGINT);
-                    else if (
-                        meta.arrays.some(
-                            (array) => array.type.value.isRequired() === false,
-                        )
-                    )
-                        throw new Error(NO_UNDEFINED_IN_ARRAY);
-                },
-            })(collection)(type);
-            return [collection, meta];
-        };
+        (importer) =>
+        (type) =>
+            JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
+                checker,
+            )(type);
 
     const create_throw_error =
         (importer: FunctionImporter) =>
@@ -998,8 +962,3 @@ interface IUnion {
     is: () => ts.Expression;
     value: () => ts.Expression;
 }
-
-const NO_BIGINT =
-    "Error on typia.json.stringify(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.stringify(): does not allow undefined type in array.";

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonValidateParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -60,4 +64,5 @@ export namespace JsonValidateParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -13,7 +13,7 @@ export namespace JsonValidateStringifyProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -7,15 +7,13 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-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 { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -49,7 +47,7 @@ export namespace MiscCloneProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -62,7 +60,10 @@ export namespace MiscCloneProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -154,8 +155,6 @@ export namespace MiscCloneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -284,26 +283,20 @@ export namespace MiscCloneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(
-                      input,
-                      array.type,
-                      explore,
-                  );
+                : decode_array_inline(config)(importer)(input, array, explore);
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
                 input,
                 array,
                 explore,
-                [],
-                [],
             );
 
     const decode_tuple =
@@ -505,7 +498,7 @@ export namespace MiscCloneProgrammer {
                     success: ts.factory.createTrue(),
                     failure: (input, expected) =>
                         create_throw_error(importer)(expected)(input),
-                })([])(input, sets, explore, [], []),
+                })([])(input, sets, explore),
                 undefined,
                 undefined,
             );
@@ -534,8 +527,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -547,8 +538,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -578,7 +567,7 @@ export namespace MiscCloneProgrammer {
                     success: ts.factory.createTrue(),
                     failure: (input, expected) =>
                         create_throw_error(importer)(expected)(input),
-                })([])(input, maps, explore, [], []),
+                })([])(input, maps, explore),
                 undefined,
                 undefined,
             );
@@ -637,8 +626,6 @@ export namespace MiscCloneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -650,7 +637,7 @@ export namespace MiscCloneProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
@@ -710,7 +697,7 @@ export namespace MiscCloneProgrammer {
                 prefix: PREFIX,
                 trace: false,
                 path: false,
-                initializer: initializer(importer.method),
+                initializer,
                 decoder: () => decode(project)(config)(importer),
                 objector: {
                     checker: () => IsProgrammer.decode(project)(importer),
@@ -734,27 +721,29 @@ export namespace MiscCloneProgrammer {
             return config;
         };
 
-    const initializer =
-        (method: string): FeatureProgrammer.IConfig["initializer"] =>
+    const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
+                    const output: string[] = [];
                     if (meta.natives.some((n) => n === "WeakSet"))
-                        throw new Error(
-                            `Error on ${method}(): WeakSet is not supported.`,
-                        );
+                        output.push("unable to clone WeakSet");
                     else if (meta.natives.some((n) => n === "WeakMap"))
-                        throw new Error(
-                            `Error on ${method}(): WeakMap is not supported.`,
-                        );
+                        output.push("unable to clone WeakMap");
+                    return output;
                 },
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =