typia 3.4.26 → 3.4.28

package/src/programmers/StringifyProgrammer.ts

@@ -12,6 +12,8 @@ import { MetadataObject } from "../metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
 
+import { Atomic } from "../typings/Atomic";
+
 import { ArrayUtil } from "../utils/ArrayUtil";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
@@ -23,6 +25,7 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { StringifyJoiner } from "./helpers/StringifyJoinder";
 import { StringifyPredicator } from "./helpers/StringifyPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
+import { check_native } from "./internal/check_native";
 import { decode_union_object } from "./internal/decode_union_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
@@ -177,10 +180,9 @@ export namespace StringifyProgrammer {
 
             // CONSTANTS
             for (const constant of meta.constants)
-                if (
-                    constant.type !== "string" &&
-                    AtomicPredicator.constant(meta)(constant.type)
-                )
+                if (AtomicPredicator.constant(meta)(constant.type) === false)
+                    continue;
+                else if (constant.type !== "string")
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -223,28 +225,31 @@ export namespace StringifyProgrammer {
                                 explore,
                             ),
                     });
+
+            /// ATOMICS
             for (const type of meta.atomics)
-                unions.push({
-                    type: "atomic",
-                    is: () =>
-                        IsProgrammer.decode(project, importer)(
-                            input,
-                            (() => {
-                                const partial = Metadata.initialize();
-                                partial.atomics.push(type);
-                                return partial;
-                            })(),
-                            explore,
-                            [],
-                        ),
-                    value: () =>
-                        decode_atomic(project, importer)(
-                            input,
-                            type,
-                            explore,
-                            tags,
-                        ),
-                });
+                if (AtomicPredicator.atomic(meta)(type))
+                    unions.push({
+                        type: "atomic",
+                        is: () =>
+                            IsProgrammer.decode(project, importer)(
+                                input,
+                                (() => {
+                                    const partial = Metadata.initialize();
+                                    partial.atomics.push(type);
+                                    return partial;
+                                })(),
+                                explore,
+                                [],
+                            ),
+                        value: () =>
+                            decode_atomic(project, importer)(
+                                input,
+                                type,
+                                explore,
+                                tags,
+                            ),
+                    });
 
             // TUPLES
             for (const tuple of meta.tuples) {
@@ -315,8 +320,16 @@ export namespace StringifyProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "object",
-                        is: () => ExpressionFactory.isInstanceOf(input, native),
-                        value: () => ts.factory.createStringLiteral("{}"),
+                        is: () => check_native(native)(input),
+                        value: () =>
+                            AtomicPredicator.native(native)
+                                ? decode_atomic(project, importer)(
+                                      input,
+                                      native.toLowerCase() as Atomic.Literal,
+                                      explore,
+                                      tags,
+                                  )
+                                : ts.factory.createStringLiteral("{}"),
                     });
 
             // SETS

package/src/programmers/ValidateProgrammer.ts

@@ -4,7 +4,6 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
 
 import { IProject } from "../transformers/IProject";
-import { ITransformOptions } from "../transformers/ITransformOptions";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
@@ -31,8 +30,8 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
-                    combiner: combine(project.options)(equals)(importer),
-                    joiner: joiner(project.options)(equals)(importer),
+                    combiner: combine(equals)(importer),
+                    joiner: joiner(equals)(importer),
                     success: ts.factory.createTrue(),
                 },
                 importer,
@@ -86,13 +85,12 @@ export namespace ValidateProgrammer {
 }
 
 const combine =
-    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
             return IsProgrammer.CONFIG({
-                object: validate_object(options)(equals)(importer),
+                object: validate_object(equals)(importer),
                 numeric: true,
             })(importer).combiner(explore);
 
@@ -133,44 +131,40 @@ const combine =
                   );
     };
 
-const validate_object =
-    (options: ITransformOptions) =>
-    (equals: boolean) =>
-    (importer: FunctionImporter) =>
-        check_object({
-            equals,
-            undefined: OptionPredicator.undefined(options),
-            assert: false,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: (value) =>
-                create_report_call()(
-                    ts.factory.createAdd(
-                        ts.factory.createIdentifier("path"),
-                        ts.factory.createCallExpression(
-                            importer.use("join"),
-                            undefined,
-                            [ts.factory.createIdentifier("key")],
-                        ),
+const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
+    check_object({
+        equals,
+        undefined: true,
+        assert: false,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (value) =>
+            create_report_call()(
+                ts.factory.createAdd(
+                    ts.factory.createIdentifier("path"),
+                    ts.factory.createCallExpression(
+                        importer.use("join"),
+                        undefined,
+                        [ts.factory.createIdentifier("key")],
                     ),
-                    "undefined",
-                    value,
                 ),
-            halt: (expr) =>
-                ts.factory.createLogicalOr(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createIdentifier("exceptionable"),
-                    ),
-                    expr,
+                "undefined",
+                value,
+            ),
+        halt: (expr) =>
+            ts.factory.createLogicalOr(
+                ts.factory.createStrictEquality(
+                    ts.factory.createFalse(),
+                    ts.factory.createIdentifier("exceptionable"),
                 ),
-        })(importer);
+                expr,
+            ),
+    })(importer);
 
 const joiner =
-    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(options)(equals)(importer),
+        object: validate_object(equals)(importer),
         array: (input, arrow) =>
             check_everything(
                 ts.factory.createCallExpression(

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,8 +8,24 @@ export namespace AtomicPredicator {
     export const constant =
         (meta: Metadata) =>
         (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
+            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
 
     export const template = (meta: Metadata): boolean =>
         !ArrayUtil.has(meta.atomics, (type) => type === "string");
 }
+
+const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/internal/application_schema.ts

@@ -46,27 +46,28 @@ export const application_schema =
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))
             union.push(application_templates(meta, attribute));
-        for (const constant of meta.constants) {
+        for (const constant of meta.constants)
             if (constant.type === "bigint") throw new Error(NO_BIGINT);
             else if (
                 (constant.type === "string" && meta.templates.length) ||
                 AtomicPredicator.constant(meta)(constant.type) === false
             )
                 continue;
-            union.push(
-                application_constant(constant, meta.nullable, attribute),
-            );
-        }
-        for (const type of meta.atomics) {
+            else
+                union.push(
+                    application_constant(constant, meta.nullable, attribute),
+                );
+        for (const type of meta.atomics)
             if (type === "bigint") throw new Error(NO_BIGINT);
-            union.push(
-                type === "string"
-                    ? application_string(meta, attribute)
-                    : type === "boolean"
-                    ? application_boolean(meta.nullable, attribute)
-                    : application_number(meta.nullable, attribute),
-            );
-        }
+            else if (AtomicPredicator.atomic(meta)(type) === false) continue;
+            else
+                union.push(
+                    type === "string"
+                        ? application_string(meta, attribute)
+                        : type === "boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
 
         // ARRAY
         for (const schema of meta.arrays.values())
@@ -109,12 +110,21 @@ export const application_schema =
 
         // NATIVES
         for (const native of meta.natives)
-            union.push(
-                application_native(options)(components)(native)(
-                    meta.nullable,
-                    attribute,
-                ),
-            );
+            if (AtomicPredicator.native(native))
+                union.push(
+                    native === "String"
+                        ? application_string(meta, attribute)
+                        : native === "Boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
+            else
+                union.push(
+                    application_native(options)(components)(native)(
+                        meta.nullable,
+                        attribute,
+                    ),
+                );
         if (meta.sets.length)
             union.push(
                 application_native(options)(components)(`Set`)(

package/src/programmers/internal/check_dynamic_properties.ts

@@ -128,6 +128,7 @@ const check_dynamic_property =
                 ),
                 props.positive,
             );
+
         for (const entry of dynamic)
             add(
                 ts.factory.createCallExpression(

package/src/programmers/internal/check_native.ts

@@ -5,5 +5,17 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 /**
  * @internal
  */
-export const check_native = (type: string) => (input: ts.Expression) =>
-    ExpressionFactory.isInstanceOf(input, type);
+export const check_native = (type: string) => (input: ts.Expression) => {
+    const instanceOf = ExpressionFactory.isInstanceOf(input, type);
+    return ATOMIC_LIKE.has(type)
+        ? ts.factory.createLogicalOr(
+              ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral(type.toLowerCase()),
+                  ts.factory.createTypeOfExpression(input),
+              ),
+              instanceOf,
+          )
+        : instanceOf;
+};
+
+const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/transformers/ITransformOptions.ts

@@ -52,6 +52,10 @@ export interface ITransformOptions {
      * issue when validating without allowing superfluous properties. Should undefined
      * value assigned superfluous property be allowed or not?
      *
+     * Note that, this option only works on {@link equals} function. Other function
+     * like {@link assertEquals} or {@link validateEquals} would ignore this option
+     * value and always allow the `undefined` value.
+     *
      * @default true
      */
     undefined?: boolean;