typia 5.1.2-dev.20230927 → 5.1.3-dev.20230927

package/src/programmers/internal/application_schema.ts

@@ -80,13 +80,11 @@ export const application_schema =
         for (const a of meta.atomics)
             if (a.type === "bigint") throw new TypeError(NO_BIGINT);
             else if (a.type === "boolean")
-                insert(application_boolean(attribute));
+                application_boolean(a)(attribute).forEach(insert);
             else if (a.type === "number")
-                application_number(a)(attribute).forEach((s) => insert(s));
+                application_number(a)(attribute).forEach(insert);
             else if (a.type === "string")
-                application_string(meta)(a)(attribute).forEach((s) =>
-                    insert(s),
-                );
+                application_string(meta)(a)(attribute).forEach(insert);
 
         // ARRAY
         for (const array of meta.arrays)
@@ -105,7 +103,14 @@ export const application_schema =
                 if (meta.atomics.some((a) => a.type === type)) continue;
                 else if (type === "bigint") throw new TypeError(NO_BIGINT);
                 else if (type === "boolean")
-                    insert(application_boolean(attribute));
+                    insert(
+                        application_boolean(
+                            MetadataAtomic.create({
+                                type: "boolean",
+                                tags: [],
+                            }),
+                        )(attribute)[0]!,
+                    );
                 else if (type === "number")
                     insert(
                         application_number(

package/src/programmers/internal/application_string.ts

@@ -18,7 +18,8 @@ export const application_string =
             type: "string",
         };
         const out = (schema: IJsonSchema.IString) => {
-            schema.default = application_default_string(meta)(attribute)(base);
+            schema.default ??=
+                application_default_string(meta)(attribute)(base);
             return schema;
         };
         if (atomic.tags.length === 0) return [out(base)];
@@ -46,6 +47,8 @@ const application_string_tags =
             else if (tag.kind === "format" && typeof tag.value === "string")
                 base.format = tag.value;
             else if (tag.kind === "pattern") base.pattern = tag.value;
+            else if (tag.kind === "default" && typeof tag.value === "string")
+                base.default = tag.value;
         base["x-typia-typeTags"] = row;
         return base;
     };

package/src/programmers/internal/check_array_length.ts

@@ -31,11 +31,14 @@ const check_string_type_tags =
     (project: IProject) =>
     (matrix: IMetadataTypeTag[][]) =>
     (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        matrix.map((row) =>
-            row.map((tag) => ({
-                expected: `Array<> & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        );
+        matrix
+            .map((row) => row.filter((tag) => !!tag.validate))
+            .filter((row) => !!row.length)
+            .map((row) =>
+                row.map((tag) => ({
+                    expected: `Array<> & ${tag.name}`,
+                    expression: ExpressionFactory.transpile(project.context)(
+                        tag.validate!,
+                    )(input),
+                })),
+            );

package/src/programmers/internal/check_bigint.ts

@@ -35,11 +35,14 @@ const check_bigint_type_tags =
     (project: IProject) =>
     (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        atomic.tags.map((row) =>
-            row.map((tag) => ({
-                expected: `bigint & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        );
+        atomic.tags
+            .map((row) => row.filter((tag) => !!tag.validate))
+            .filter((row) => !!row.length)
+            .map((row) =>
+                row.map((tag) => ({
+                    expected: `bigint & ${tag.name}`,
+                    expression: ExpressionFactory.transpile(project.context)(
+                        tag.validate!,
+                    )(input),
+                })),
+            );

package/src/programmers/internal/check_number.ts

@@ -60,46 +60,49 @@ const check_numeric_type_tags =
     (atomic: MetadataAtomic) =>
     (addition: ts.Expression | null) =>
     (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        atomic.tags.map((row) => [
-            ...(addition === null
-                ? []
-                : row.some(
-                      (tag) =>
-                          tag.kind === "type" &&
-                          (tag.value === "int32" ||
-                              tag.value === "uint32" ||
-                              tag.value === "int64" ||
-                              tag.value === "uint64" ||
-                              tag.value === "float"),
-                  ) ||
-                  row.some(
-                      (tag) =>
-                          tag.kind === "multipleOf" &&
-                          typeof tag.value === "number",
-                  ) ||
-                  (row.some(
-                      (tag) =>
-                          (tag.kind === "minimum" ||
-                              tag.kind === "exclusiveMinimum") &&
-                          typeof tag.value === "number",
-                  ) &&
+        atomic.tags
+            .map((row) => row.filter((tag) => !!tag.validate))
+            .filter((row) => !!row.length)
+            .map((row) => [
+                ...(addition === null
+                    ? []
+                    : row.some(
+                          (tag) =>
+                              tag.kind === "type" &&
+                              (tag.value === "int32" ||
+                                  tag.value === "uint32" ||
+                                  tag.value === "int64" ||
+                                  tag.value === "uint64" ||
+                                  tag.value === "float"),
+                      ) ||
                       row.some(
                           (tag) =>
-                              (tag.kind === "maximum" ||
-                                  tag.kind === "exclusiveMaximum") &&
+                              tag.kind === "multipleOf" &&
+                              typeof tag.value === "number",
+                      ) ||
+                      (row.some(
+                          (tag) =>
+                              (tag.kind === "minimum" ||
+                                  tag.kind === "exclusiveMinimum") &&
                               typeof tag.value === "number",
-                      ))
-                ? []
-                : [
-                      {
-                          expected: "number",
-                          expression: addition!,
-                      },
-                  ]),
-            ...row.map((tag) => ({
-                expected: `number & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        ]);
+                      ) &&
+                          row.some(
+                              (tag) =>
+                                  (tag.kind === "maximum" ||
+                                      tag.kind === "exclusiveMaximum") &&
+                                  typeof tag.value === "number",
+                          ))
+                    ? []
+                    : [
+                          {
+                              expected: "number",
+                              expression: addition!,
+                          },
+                      ]),
+                ...row.map((tag) => ({
+                    expected: `number & ${tag.name}`,
+                    expression: ExpressionFactory.transpile(project.context)(
+                        tag.validate!,
+                    )(input),
+                })),
+            ]);

package/src/programmers/internal/check_string.ts

@@ -35,11 +35,14 @@ const check_string_type_tags =
     (project: IProject) =>
     (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        atomic.tags.map((row) =>
-            row.map((tag) => ({
-                expected: `string & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        );
+        atomic.tags
+            .map((row) => row.filter((tag) => !!tag.validate))
+            .filter((row) => !!row.length)
+            .map((row) =>
+                row.map((tag) => ({
+                    expected: `string & ${tag.name}`,
+                    expression: ExpressionFactory.transpile(project.context)(
+                        tag.validate!,
+                    )(input),
+                })),
+            );

package/src/schemas/json/IJsonSchema.ts

@@ -60,7 +60,9 @@ export namespace IJsonSchema {
         multipleOf?: number & Type<"int32">;
         "x-typia-typeTags"?: IMetadataTypeTag[];
     }
-    export interface IBoolean extends IAtomic<"boolean"> {}
+    export interface IBoolean extends IAtomic<"boolean"> {
+        "x-typia-typeTags"?: IMetadataTypeTag[];
+    }
 
     /* -----------------------------------------------------------
         OBJECTS

package/src/schemas/metadata/IMetadataConstant.ts

@@ -1,5 +1,7 @@
 import { Atomic } from "../../typings/Atomic";
 
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
 export type IMetadataConstant =
     | IMetadataConstant.IBase<"boolean", boolean>
     | IMetadataConstant.IBase<"number", number>
@@ -12,5 +14,12 @@ export namespace IMetadataConstant {
     > {
         type: Type;
         values: Value[];
+
+        /**
+         * @internal
+         */
+        tags?: Type extends "boolean"
+            ? IMetadataTypeTag[][] | undefined
+            : never;
     }
 }

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -1,8 +1,8 @@
 export interface IMetadataTypeTag {
-    target: "bigint" | "number" | "string" | "array";
+    target: "boolean" | "bigint" | "number" | "string" | "array";
     name: string;
     kind: string;
     value: any;
-    validate: string;
+    validate: string | undefined;
     exclusive: boolean | string[];
 }

package/src/schemas/metadata/Metadata.ts

@@ -44,6 +44,7 @@ export class Metadata {
     /** @internal */ private parent_resolved_: boolean = false;
     /** @internal */ public union_index?: number;
     /** @internal */ public fixed_?: number | null;
+    /** @internal */ public boolean_literal_intersected_?: boolean;
 
     /* -----------------------------------------------------------
         CONSTRUCTORS

package/src/tags/Default.ts

@@ -0,0 +1,15 @@
+import { TagBase } from "./TagBase";
+
+export type Default<Value extends boolean | bigint | number | string> =
+    TagBase<{
+        target: Value extends boolean
+            ? "boolean"
+            : Value extends bigint
+            ? "bigint"
+            : Value extends number
+            ? "number"
+            : "string";
+        kind: "default";
+        value: Value;
+        exclusive: true;
+    }>;

package/src/tags/Format.ts

@@ -26,5 +26,5 @@ export type Format<
         : Value extends "date"
         ? `/^(\\d{4})-(\\d{2})-(\\d{2})$/.test($input)`
         : `!isNaN(new Date($input).getTime())`;
-    exclusive: ["pattern"];
+    exclusive: ["format", "pattern"];
 }>;

package/src/tags/Pattern.ts

@@ -5,4 +5,5 @@ export type Pattern<Value extends string> = TagBase<{
     kind: "pattern";
     value: Value;
     validate: `/${Value}/.test($input)`;
+    exclusive: ["format", "pattern"];
 }>;

package/src/tags/TagBase.ts

@@ -8,7 +8,7 @@ export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
 };
 export namespace TagBase {
     export interface IProps<
-        Target extends "bigint" | "number" | "string" | "array",
+        Target extends "boolean" | "bigint" | "number" | "string" | "array",
         Kind extends string,
         Value extends boolean | bigint | number | string | undefined,
         Validate extends
@@ -51,7 +51,7 @@ export namespace TagBase {
          * occured. So, define it with confidence. Compiler will block all your
          * mistakes.
          */
-        validate: Validate;
+        validate?: Validate;
 
         /**
          * Exclusive option.

package/src/tags/index.ts

@@ -1,3 +1,4 @@
+export * from "./Default";
 export * from "./ExclusiveMaximum";
 export * from "./ExclusiveMinimum";
 export * from "./Format";