typia 3.5.0-dev.20221219 → 3.5.0-dev.20230107

package/src/factories/internal/protocols/iterate_protocol_tuple.ts

@@ -2,17 +2,14 @@ import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 
 import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { MetadataCollection } from "../../MetadataCollection";
 import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
 import { emplace_protocol_object } from "./emplace_protocol_object";
 
 export const iterate_protocol_tuple =
     (dict: Map<string, IProtocolMessage>) =>
     (tuple: Metadata[]): string => {
-        const name: string = MetadataCollection.replace(
-            `[${tuple.map((m) => m.getName()).join(", ")}]`,
-        );
-        if (dict.has(name)) return MetadataCollection.escape(name);
+        const name: string = `[${tuple.map((m) => m.getName()).join(", ")}]`;
+        if (dict.has(name)) return name;
 
         const obj: MetadataObject = ProtocolMetadataUtil.object(
             name,
@@ -24,5 +21,5 @@ export const iterate_protocol_tuple =
             ),
         );
         emplace_protocol_object(dict)(obj);
-        return MetadataCollection.escape(obj.name);
+        return obj.name;
     };

package/src/functional/$number.ts

@@ -1,19 +1,12 @@
 import { TypeGuardError } from "../TypeGuardError";
 
 export function $number(value: number): number {
-    if (!isFinite(value))
+    if (isFinite(value) === false)
         throw new TypeGuardError({
             method: "typia.stringify",
             expected: "number",
             value,
-            message: "Error on typia.stringify(): infinite number.",
-        });
-    else if (isNaN(value))
-        throw new TypeGuardError({
-            method: "typia.stringify",
-            expected: "number",
-            value,
-            message: "Error on typia.stringify(): not a valid number.",
+            message: "Error on typia.stringify(): infinite or not a number.",
         });
     return value;
 }

package/src/metadata/Metadata.ts

@@ -315,7 +315,9 @@ export namespace Metadata {
         // TUPLES
         for (const xt of x.tuples)
             for (const yt of y.tuples)
-                if (
+                if (xt.length === 0 || yt.length === 0)
+                    return xt.length === 0 && yt.length === 0;
+                else if (
                     xt
                         .slice(0, Math.min(xt.length, yt.length))
                         .some((xv, i) => intersects(xv, yt[i]!, deep))
@@ -371,6 +373,7 @@ export namespace Metadata {
         // TUPLES
         for (const yt of y.tuples)
             if (
+                yt.length !== 0 &&
                 x.tuples.some(
                     (xt) =>
                         xt.length >= yt.length &&
@@ -447,6 +450,12 @@ function getName(metadata: Metadata): string {
                 "`",
         );
 
+    // NATIVES
+    for (const native of metadata.natives) elements.push(native);
+    for (const set of metadata.sets) elements.push(`Set<${set.getName()}>`);
+    for (const map of metadata.maps)
+        elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
+
     // ARRAY
     if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
     for (const tuple of metadata.tuples)
@@ -458,12 +467,6 @@ function getName(metadata: Metadata): string {
     for (const object of metadata.objects) elements.push(object.name);
     if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
 
-    // NATIVES
-    for (const native of metadata.natives) elements.push(native);
-    for (const set of metadata.sets) elements.push(`Set<${set.getName()}>`);
-    for (const map of metadata.maps)
-        elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
-
     // RETURNS
     if (elements.length === 0) return "unknown";
     else if (elements.length === 1) return elements[0]!;

package/src/programmers/AssertParseProgrammer.ts

@@ -20,7 +20,17 @@ export namespace AssertParseProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/AssertProgrammer.ts

@@ -8,6 +8,7 @@ import { IProject } from "../transformers/IProject";
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 // /* -----------------------------------------------------------
@@ -31,7 +32,7 @@ import { check_object } from "./internal/check_object";
 //                     unioners: "$au",
 //                     path: true,
 //                     trace: true,
-//                     numeric: !!project.options.numeric,
+//                     numeric: OptionPredicator.numeric(project.options),
 //                     equals,
 //                     combiner,
 //                     joiner: joiner(equals)(importer),
@@ -237,7 +238,7 @@ export namespace AssertProgrammer {
                     unioners: "$au",
                     path: true,
                     trace: true,
-                    numeric: !!project.options.numeric,
+                    numeric: OptionPredicator.numeric(project.options),
                     equals,
                     combiner: combiner(equals)(importer),
                     joiner: joiner(equals)(importer),
@@ -279,7 +280,7 @@ export namespace AssertProgrammer {
         (equals: boolean) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
         (explore: CheckerProgrammer.IExplore) => {
-            if (explore.tracable === false && explore.from !== "top")
+            if (explore.tracable === false)
                 return IsProgrammer.CONFIG({
                     object: assert_object(equals)(importer),
                     numeric: true,

package/src/programmers/AssertStringifyProgrammer.ts

@@ -21,11 +21,31 @@ export namespace AssertStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(project, modulo)(type),
+                        StringifyProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createCallExpression(