typia 5.0.0-dev.20230827 → 5.0.0-dev.20230828

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -4,38 +4,39 @@ import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
 
-export const iterate_metadata_collection = (
-    collection: MetadataCollection,
-): void => {
-    for (const array of collection.arrays())
-        if (array.recursive === null)
-            collection.setArrayRecursive(
-                array,
-                isArrayRecursive(new Set())(array)(array.value),
-            );
-    for (const tuple of collection.tuples())
-        if (tuple.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setTupleRecursive(
-                tuple,
-                tuple.elements.some(isTupleRecursive(visited)(tuple)),
-            );
-        }
-    for (const obj of collection.objects()) {
-        iterate_metadata_comment_tags(obj);
-        if (obj.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setObjectRecursive(
-                obj,
-                obj.properties.some((p) =>
-                    isObjectRecursive(visited)(obj)(p.value),
-                ),
-            );
+export const iterate_metadata_collection =
+    (errors: MetadataFactory.IError[]) =>
+    (collection: MetadataCollection): void => {
+        for (const array of collection.arrays())
+            if (array.recursive === null)
+                collection.setArrayRecursive(
+                    array,
+                    isArrayRecursive(new Set())(array)(array.value),
+                );
+        for (const tuple of collection.tuples())
+            if (tuple.recursive === null) {
+                const visited: Set<Metadata> = new Set();
+                collection.setTupleRecursive(
+                    tuple,
+                    tuple.elements.some(isTupleRecursive(visited)(tuple)),
+                );
+            }
+        for (const obj of collection.objects()) {
+            iterate_metadata_comment_tags(errors)(obj);
+            if (obj.recursive === null) {
+                const visited: Set<Metadata> = new Set();
+                collection.setObjectRecursive(
+                    obj,
+                    obj.properties.some((p) =>
+                        isObjectRecursive(visited)(obj)(p.value),
+                    ),
+                );
+            }
         }
-    }
-};
+    };
 
 const isArrayRecursive =
     (visited: Set<Metadata>) =>

package/src/factories/internal/metadata/iterate_metadata_comment_tags.ts

@@ -1,27 +1,26 @@
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
-import { Escaper } from "../../../utils/Escaper";
-
 import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
+import { MetadataFactory } from "../../MetadataFactory";
 
-export const iterate_metadata_comment_tags = (obj: MetadataObject) => {
-    if (obj.tagged_ === true) return;
-    obj.tagged_ = true;
-
-    for (const prop of obj.properties) {
-        const key: string = prop.key.getName();
-        const variable: string | null =
-            key.length >= 3 &&
-            key[0] === '"' &&
-            key[key.length - 1] === '"' &&
-            Escaper.variable(key.slice(1, -1))
-                ? key.slice(1, -1)
-                : null;
+export const iterate_metadata_comment_tags =
+    (errors: MetadataFactory.IError[]) => (object: MetadataObject) => {
+        if (object.tagged_ === true) return;
+        object.tagged_ = true;
 
-        MetadataCommentTagFactory.analyze(
-            variable !== null
-                ? () => `${obj.name}.${variable}`
-                : () => `${obj.name}[${key}]`,
-        )(prop.value)(prop.jsDocTags);
-    }
-};
+        for (const property of object.properties) {
+            MetadataCommentTagFactory.analyze(errors)(property.value)(
+                property.jsDocTags,
+                {
+                    top: false,
+                    object,
+                    property: property.key.isSoleLiteral()
+                        ? property.key.getSoleLiteral()!
+                        : {},
+                    nested: null,
+                    escaped: false,
+                    aliased: false,
+                },
+            );
+        }
+    };

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -17,11 +17,11 @@ export const iterate_metadata_intersection =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (
         meta: Metadata,
         type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
+        explore: MetadataFactory.IExplore,
     ): boolean => {
         if (!type.isIntersection()) return false;
         else if (
@@ -36,25 +36,32 @@ export const iterate_metadata_intersection =
 
         // COSTRUCT FAKE METADATA LIST
         const fakeCollection: MetadataCollection = new MetadataCollection();
+        const fakeErrors: MetadataFactory.IError[] = [];
         const children: Metadata[] = [
             ...new Map(
                 type.types.map((t) => {
                     const m: Metadata = explore_metadata(checker)({
                         ...options,
                         absorb: true,
-                    })(fakeCollection)(t, resolved);
+                    })(fakeCollection)(fakeErrors)(t, {
+                        ...explore,
+                        aliased: false,
+                    });
                     return [m.getName(), m] as const;
                 }),
             ).values(),
         ];
+        if (fakeErrors.length) {
+            errors.push(...fakeErrors);
+            return true;
+        }
 
         // ONLY ONE CHILD AFTER REMOVING DUPLICATES
         if (children.length === 1) {
-            iterate_metadata(checker)(options)(collection)(
+            iterate_metadata(checker)(options)(collection)(errors)(
                 meta,
                 type.types[0]!,
-                resolved,
-                aliased,
+                explore,
             );
             return true;
         } else if (
@@ -102,9 +109,18 @@ export const iterate_metadata_intersection =
             atomics.size + arrays.size > 1 ||
             individuals.length + objects.length + constants.length !==
                 children.length
-        )
-            throw new Error(message(children));
-        else if (atomics.size === 0 && arrays.size === 0 && constants.length) {
+        ) {
+            errors.push({
+                name: children.map((c) => c.getName()).join(" & "),
+                explore: { ...explore },
+                messages: ["nonsensible intersection"],
+            });
+            return true;
+        } else if (
+            atomics.size === 0 &&
+            arrays.size === 0 &&
+            constants.length
+        ) {
             for (const m of constants) {
                 for (const tpl of m.templates)
                     ArrayUtil.add(
@@ -151,11 +167,16 @@ export const iterate_metadata_intersection =
         else if (target === "array") {
             const name: string = arrays.values().next().value;
             if (!meta.arrays.some((a) => a.type.name === name)) {
-                iterate_metadata_array(checker)(options)(collection)(
+                iterate_metadata_array(checker)(options)(collection)(errors)(
                     meta,
                     type.types[
                         individuals.find((i) => i[0].arrays.length === 1)![1]
                     ]!,
+                    {
+                        ...explore,
+                        aliased: false,
+                        escaped: false,
+                    },
                 );
             }
         }
@@ -163,8 +184,8 @@ export const iterate_metadata_intersection =
         // ASSIGN TAGS
         if (objects.length && target !== "boolean") {
             const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(
-                target,
-            )(objects.map((om) => om.objects).flat());
+                errors,
+            )(target)(objects.map((om) => om.objects).flat(), explore);
             if (tags.length)
                 if (target === "array") meta.arrays.at(-1)!.tags.push(tags);
                 else
@@ -174,8 +195,3 @@ export const iterate_metadata_intersection =
         }
         return true;
     };
-
-const message = (children: Metadata[]) =>
-    `Error on typia.MetadataFactory.analyze(): nonsensible intersection type detected - ${children
-        .map((c) => c.getName())
-        .join(" & ")}.`;

package/src/factories/internal/metadata/iterate_metadata_map.ts

@@ -13,7 +13,12 @@ export const iterate_metadata_map =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         type = checker.getApparentType(type);
 
         const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
@@ -29,10 +34,21 @@ export const iterate_metadata_map =
         ArrayUtil.set(
             meta.maps,
             {
-                key: explore_metadata(checker)(options)(collection)(key, false),
-                value: explore_metadata(checker)(options)(collection)(
+                key: explore_metadata(checker)(options)(collection)(errors)(
+                    key,
+                    {
+                        ...explore,
+                        escaped: false,
+                        aliased: false,
+                    },
+                ),
+                value: explore_metadata(checker)(options)(collection)(errors)(
                     value,
-                    false,
+                    {
+                        ...explore,
+                        escaped: false,
+                        aliased: false,
+                    },
                 ),
             },
             (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,

package/src/factories/internal/metadata/iterate_metadata_object.ts

@@ -13,6 +13,7 @@ export const iterate_metadata_object =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (meta: Metadata, type: ts.Type, ensure: boolean = false): boolean => {
         if (ensure === false) {
             const filter = (flag: ts.TypeFlags) =>
@@ -37,7 +38,7 @@ export const iterate_metadata_object =
 
         const obj: MetadataObject = emplace_metadata_object(checker)(options)(
             collection,
-        )(type, meta.nullable);
+        )(errors)(type, meta.nullable);
         ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
         return true;
     };

package/src/factories/internal/metadata/iterate_metadata_resolve.ts

@@ -10,21 +10,20 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
-// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
 export const iterate_metadata_resolve =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (
         meta: Metadata,
         type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
+        explore: MetadataFactory.IExplore,
     ): boolean => {
-        if (options.escape === false || resolved === true) return false;
+        if (options.escape === false || explore.escaped === true) return false;
 
-        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
+        const escaped: ts.Type | null =
+            TypeFactory.getReturnType(checker)(type)("toJSON");
         if (escaped === null) return false;
 
         if (meta.escaped === null) {
@@ -33,17 +32,21 @@ export const iterate_metadata_resolve =
                 returns: Metadata.initialize(),
             });
         }
-        iterate_metadata(checker)(options)(collection)(
+        iterate_metadata(checker)(options)(collection)(errors)(
             meta.escaped!.original,
             type,
-            true,
-            aliased,
+            {
+                ...explore,
+                escaped: true,
+            },
         );
-        iterate_metadata(checker)(options)(collection)(
+        iterate_metadata(checker)(options)(collection)(errors)(
             meta.escaped!.returns,
             escaped,
-            true,
-            aliased,
+            {
+                ...explore,
+                escaped: true,
+            },
         );
         return true;
     };

package/src/factories/internal/metadata/iterate_metadata_set.ts

@@ -13,7 +13,12 @@ export const iterate_metadata_set =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         type = checker.getApparentType(type);
 
         const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
@@ -26,7 +31,11 @@ export const iterate_metadata_set =
         const key: ts.Type = generic[0]!;
         ArrayUtil.set(
             meta.sets,
-            explore_metadata(checker)(options)(collection)(key, false),
+            explore_metadata(checker)(options)(collection)(errors)(key, {
+                ...explore,
+                escaped: false,
+                aliased: false,
+            }),
             (elem) => elem.getName(),
         );
         return true;

package/src/factories/internal/metadata/iterate_metadata_template.ts

@@ -11,7 +11,12 @@ export const iterate_metadata_template =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
         if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
@@ -26,9 +31,13 @@ export const iterate_metadata_template =
             const binded: ts.Type | undefined = template.types[i];
             if (binded)
                 row.push(
-                    explore_metadata(checker)(options)(collection)(
+                    explore_metadata(checker)(options)(collection)(errors)(
                         binded,
-                        false,
+                        {
+                            ...explore,
+                            escaped: false,
+                            aliased: false,
+                        },
                     ),
                 );
         });

package/src/factories/internal/metadata/iterate_metadata_tuple.ts

@@ -14,12 +14,17 @@ export const iterate_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.TupleType,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!checker.isTupleType(type)) return false;
 
         const tupleType: MetadataTupleType = emplace_metadata_tuple(checker)(
             options,
-        )(collection)(type, meta.nullable);
+        )(collection)(errors)(type, meta.nullable, explore);
         ArrayUtil.add(
             meta.tuples,
             MetadataTuple.create({

package/src/factories/internal/metadata/iterate_metadata_union.ts

@@ -10,15 +10,18 @@ export const iterate_metadata_union =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!type.isUnion()) return false;
         type.types.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                parentResolved,
-                false,
-            ),
+            iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
+                ...explore,
+                aliased: false,
+            }),
         );
         return true;
     };

package/src/programmers/CheckerProgrammer.ts

@@ -15,6 +15,7 @@ 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 { AtomicPredicator } from "./helpers/AtomicPredicator";
@@ -208,15 +209,20 @@ export namespace CheckerProgrammer {
             prefix: config.prefix,
             initializer:
                 ({ checker }) =>
+                (importer) =>
                 (type) => {
                     const collection: MetadataCollection =
                         new MetadataCollection();
-                    const meta: Metadata = MetadataFactory.analyze(checker)({
+                    const result = MetadataFactory.analyze(checker)({
                         escape: false,
                         constant: true,
                         absorb: true,
                     })(collection)(type);
-                    return [collection, meta];
+                    if (result.success === false)
+                        throw TransformerError.from(`typia.${importer.method}`)(
+                            result.errors,
+                        );
+                    return [collection, result.data];
                 },
             addition: config.addition,
             decoder: () =>

package/src/programmers/FeatureProgrammer.ts

@@ -47,6 +47,8 @@ export namespace FeatureProgrammer {
          */
         initializer: (
             project: IProject,
+        ) => (
+            importer: FunctionImporter,
         ) => (type: ts.Type) => [MetadataCollection, Metadata];
 
         /**
@@ -200,7 +202,8 @@ export namespace FeatureProgrammer {
         (config: IConfig) =>
         (importer: FunctionImporter) =>
         (type: ts.Type, name?: string) => {
-            const [collection, meta] = config.initializer(project)(type);
+            const [collection, meta] =
+                config.initializer(project)(importer)(type);
 
             // ITERATE OVER ALL METADATA
             const output: ts.ConciseBody = config.decoder()(

package/src/programmers/IsProgrammer.ts

@@ -23,9 +23,9 @@ export namespace IsProgrammer {
         (options?: Partial<CONFIG.IOptions>) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
             prefix: "$i",
+            equals: !!options?.object,
             trace: false,
             path: false,
-            equals: !!options?.object,
             numeric: OptionPredicator.numeric({
                 numeric: options?.numeric,
             }),

package/src/programmers/RandomProgrammer.ts

@@ -17,6 +17,7 @@ import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../transformers/IProject";
+import { TransformerError } from "../transformers/TransformerError";
 
 import { Escaper } from "../utils/Escaper";
 
@@ -36,23 +37,23 @@ export namespace RandomProgrammer {
             return (type: ts.Type, name?: string) => {
                 // INITIALIZE METADATA
                 const collection: MetadataCollection = new MetadataCollection();
-                const meta: Metadata = MetadataFactory.analyze(project.checker)(
-                    {
-                        escape: false,
-                        constant: true,
-                        absorb: true,
-                        validate: (meta) => {
-                            if (meta.natives.some((n) => n === "WeakSet"))
-                                throw new Error(
-                                    `Error on ${modulo.getText()}(): WeakSet is not supported.`,
-                                );
-                            else if (meta.natives.some((n) => n === "WeakMap"))
-                                throw new Error(
-                                    `Error on ${modulo.getText()}(): WeakMap is not supported.`,
-                                );
-                        },
+                const result = MetadataFactory.analyze(project.checker)({
+                    escape: false,
+                    constant: true,
+                    absorb: true,
+                    validate: (meta) => {
+                        const output: string[] = [];
+                        if (meta.natives.some((n) => n === "WeakSet"))
+                            output.push(`WeakSet is not supported.`);
+                        else if (meta.natives.some((n) => n === "WeakMap"))
+                            output.push(`WeakMap is not supported.`);
+                        return output;
                     },
-                )(collection)(type);
+                })(collection)(type);
+                if (result.success === false)
+                    throw TransformerError.from(`typia.${importer.method}`)(
+                        result.errors,
+                    );
 
                 // GENERATE FUNCTION
                 const functions = {
@@ -64,7 +65,7 @@ export namespace RandomProgrammer {
                 const output: ts.Expression = decode(importer)({
                     function: false,
                     recursive: false,
-                })(meta);
+                })(result.data);
 
                 return ts.factory.createArrowFunction(
                     undefined,

package/src/programmers/TypiaProgrammer.ts

@@ -20,7 +20,7 @@ export namespace TypiaProgrammer {
         props.output = path.resolve(props.output);
 
         if ((await is_directory(props.input)) === false)
-            throw new Error(
+            throw new URIError(
                 "Error on TypiaGenerator.generate(): input path is not a directory.",
             );
         else if (fs.existsSync(props.output) === false)
@@ -28,7 +28,7 @@ export namespace TypiaProgrammer {
         else if ((await is_directory(props.output)) === false) {
             const parent: string = path.join(props.output, "..");
             if ((await is_directory(parent)) === false)
-                throw new Error(
+                throw new URIError(
                     "Error on TypiaGenerator.generate(): output path is not a directory.",
                 );
             await fs.promises.mkdir(props.output);
@@ -56,6 +56,7 @@ export namespace TypiaProgrammer {
         );
 
         // DO TRANSFORM
+        const diagnostics: ts.Diagnostic[] = [];
         const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
             program
                 .getSourceFiles()
@@ -73,11 +74,35 @@ export namespace TypiaProgrammer {
                             p.transform === "typia/lib/transform" ||
                             p.transform === "../src/transform.ts",
                     ) ?? {},
+                    {
+                        addDiagnostic: (diag) => diagnostics.push(diag),
+                    },
                 ),
             ],
             program.getCompilerOptions(),
         );
 
+        // TRACE ERRORS
+        for (const diag of diagnostics) {
+            const file: string = diag.file
+                ? path.relative(diag.file.fileName, process.cwd())
+                : "(unknown file)";
+            const category: string =
+                diag.category === ts.DiagnosticCategory.Warning
+                    ? "warning"
+                    : diag.category === ts.DiagnosticCategory.Error
+                    ? "error"
+                    : diag.category === ts.DiagnosticCategory.Suggestion
+                    ? "suggestion"
+                    : diag.category === ts.DiagnosticCategory.Message
+                    ? "message"
+                    : "unkown";
+            console.error(
+                `${file}:${diag.start}:${diag.length} - ${category} TS(${diag.code}): ${diag.messageText}`,
+            );
+        }
+        if (diagnostics.length) process.exit(-1);
+
         // ARCHIVE TRANSFORMED FILES
         const printer: ts.Printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,

package/src/programmers/internal/{application_resolved.ts → application_escaped.ts}

@@ -5,7 +5,7 @@ import { IJsonComponents, IJsonSchema } from "../../module";
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
 import { application_schema } from "./application_schema";
 
-export const application_resolved =
+export const application_escaped =
     (options: JsonApplicationProgrammer.IOptions) =>
     <BlockNever extends boolean>(blockNever: BlockNever) =>
     (components: IJsonComponents) =>