typia 5.5.5 → 5.5.6-dev.20240320

package/lib/tags/ExclusiveMinimum.d.ts

@@ -5,6 +5,10 @@ export type ExclusiveMinimum<Value extends number | bigint> = TagBase<{
     value: Value;
     validate: `${Numeric<Value>} < $input`;
     exclusive: ["exclusiveMinimum", "minimum"];
+    schema: Value extends number ? {
+        exclusiveMinimum: true;
+        minimum: Value;
+    } : undefined;
 }>;
 type Numeric<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
 export {};

package/lib/tags/Format.d.ts

@@ -6,6 +6,9 @@ export type Format<Value extends keyof Format.Validator> = TagBase<{
     value: Value;
     validate: Format.Validator[Value];
     exclusive: ["format", "pattern"];
+    schema: {
+        format: Value;
+    };
 }>;
 export declare namespace Format {
     type Validator = typeof FormatCheatSheet;

package/lib/tags/MaxItems.d.ts

@@ -5,4 +5,7 @@ export type MaxItems<Value extends number> = TagBase<{
     value: Value;
     validate: `$input.length <= ${Value}`;
     exclusive: true;
+    schema: {
+        maxItems: Value;
+    };
 }>;

package/lib/tags/MaxLength.d.ts

@@ -5,4 +5,7 @@ export type MaxLength<Value extends number> = TagBase<{
     value: Value;
     validate: `$input.length <= ${Value}`;
     exclusive: true;
+    schema: {
+        maxLength: Value;
+    };
 }>;

package/lib/tags/Maximum.d.ts

@@ -5,6 +5,9 @@ export type Maximum<Value extends number | bigint> = TagBase<{
     value: Value;
     validate: `$input <= ${Numeric<Value>}`;
     exclusive: ["maximum", "exclusiveMaximum"];
+    schema: Value extends number ? {
+        maximum: Value;
+    } : undefined;
 }>;
 type Numeric<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
 export {};

package/lib/tags/MinItems.d.ts

@@ -5,4 +5,7 @@ export type MinItems<Value extends number> = TagBase<{
     value: Value;
     validate: `${Value} <= $input.length`;
     exclusive: true;
+    schema: {
+        minItems: Value;
+    };
 }>;

package/lib/tags/MinLength.d.ts

@@ -5,4 +5,7 @@ export type MinLength<Value extends number> = TagBase<{
     value: Value;
     validate: `${Value} <= $input.length`;
     exclusive: true;
+    schema: {
+        minLength: Value;
+    };
 }>;

package/lib/tags/Minimum.d.ts

@@ -5,6 +5,9 @@ export type Minimum<Value extends number | bigint> = TagBase<{
     value: Value;
     validate: `${Numeric<Value>} <= $input`;
     exclusive: ["minimum", "exclusiveMinimum"];
+    schema: Value extends number ? {
+        minimum: Value;
+    } : undefined;
 }>;
 type Numeric<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
 export {};

package/lib/tags/MultipleOf.d.ts

@@ -5,6 +5,9 @@ export type MultipleOf<Value extends number | bigint> = TagBase<{
     value: Value;
     validate: `$input % ${Numeric<Value>} === ${Value extends bigint ? Numeric<0n> : 0}`;
     exclusive: true;
+    schema: Value extends number ? {
+        multipleOf: Value;
+    } : undefined;
 }>;
 type Numeric<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
 export {};

package/lib/tags/Pattern.d.ts

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

package/lib/tags/TagBase.d.ts

@@ -1,4 +1,4 @@
-export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
+export type TagBase<Props extends TagBase.IProps<any, any, any, any, any, any>> = {
     /**
      * This is a dummy property for compilation.
      *
@@ -9,7 +9,7 @@ export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
 export declare namespace TagBase {
     interface IProps<Target extends "boolean" | "bigint" | "number" | "string" | "array", Kind extends string, Value extends boolean | bigint | number | string | undefined, Validate extends string | {
         [key in Target]?: string;
-    }, Exclusive extends boolean | string[]> {
+    }, Exclusive extends boolean | string[], Schema extends object | undefined> {
         /**
          * Target type.
          *
@@ -52,5 +52,9 @@ export declare namespace TagBase {
          * @default false
          */
         exclusive?: Exclusive | string[];
+        /**
+         * Additional schema info assigned to the {@link IJsonSchema} object.
+         */
+        schema?: Schema;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.5.5",
+  "version": "5.5.6-dev.20240320",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/factories/MetadataCommentTagFactory.ts

@@ -117,8 +117,9 @@ type TagRecord = {
   [P in Target]?: NotDeterminedTypeTag[];
 };
 type Target = "bigint" | "number" | "string" | "array";
-type NotDeterminedTypeTag = Omit<IMetadataTypeTag, "validate"> & {
+type NotDeterminedTypeTag = Omit<IMetadataTypeTag, "validate" | "schema"> & {
   validate: string | null;
+  schema: object | undefined;
 };
 
 const PARSER: Record<
@@ -139,6 +140,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minItems: parse_integer(report)(true)(Value),
+        },
       },
       {
         name: `MaxItems<${Value}>`,
@@ -147,6 +151,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -159,6 +166,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -171,6 +181,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -203,15 +216,16 @@ const PARSER: Record<
             Value === "int32"
               ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
               : Value === "uint32"
-              ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
-              : Value === "int64"
-              ? `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`
-              : Value === "uint64"
-              ? `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`
-              : Value === "float"
-              ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
-              : `true`,
+                ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
+                : Value === "int64"
+                  ? `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`
+                  : Value === "uint64"
+                    ? `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`
+                    : Value === "float"
+                      ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+                      : `true`,
           exclusive: true,
+          schema: undefined,
         },
       ],
       bigint:
@@ -224,6 +238,7 @@ const PARSER: Record<
                 value: Value,
                 validate: Value === "int64" ? "true" : "BigInt(0) <= $input",
                 exclusive: true,
+                schema: undefined,
               },
             ]
           : [],
@@ -238,6 +253,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: {
+          minimum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -251,6 +269,7 @@ const PARSER: Record<
         })(),
         validate: `${Value} <= $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: undefined,
       },
     ],
   }),
@@ -263,6 +282,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input <= ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: {
+          maximum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -276,6 +298,7 @@ const PARSER: Record<
         })(),
         validate: `$input <= ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: undefined,
       },
     ],
   }),
@@ -288,6 +311,10 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} < $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: {
+          exclusiveMinimum: true,
+          minimum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -301,6 +328,7 @@ const PARSER: Record<
         })(),
         validate: `${Value} < $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: undefined,
       },
     ],
   }),
@@ -313,6 +341,10 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input < ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: {
+          exclusiveMaximum: true,
+          maximum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -326,6 +358,7 @@ const PARSER: Record<
         })(),
         validate: `$input < ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: undefined,
       },
     ],
   }),
@@ -338,6 +371,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input % ${Value} === 0`,
         exclusive: true,
+        schema: {
+          multipleOf: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -351,6 +387,7 @@ const PARSER: Record<
         })(),
         validate: `$input % ${Value}n === 0n`,
         exclusive: true,
+        schema: undefined,
       },
     ],
   }),
@@ -370,6 +407,9 @@ const PARSER: Record<
           value: matched[0],
           validate: matched[1],
           exclusive: true,
+          schema: {
+            format: matched[0],
+          },
         },
       ],
     };
@@ -383,6 +423,9 @@ const PARSER: Record<
         value: Value,
         validate: `RegExp(/${Value}/).test($input)`,
         exclusive: ["format"],
+        schema: {
+          pattern: Value,
+        },
       },
     ],
   }),
@@ -395,6 +438,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minLength: parse_number(report)(Value),
+        },
       },
       {
         name: `MaxLength<${Value}>`,
@@ -403,6 +449,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxLength: parse_number(report)(Value),
+        },
       },
     ],
   }),
@@ -415,6 +464,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minLength: parse_number(report)(Value),
+        },
       },
     ],
   }),
@@ -427,6 +479,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxLength: parse_number(report)(Value),
+        },
       },
     ],
   }),

package/src/factories/MetadataTypeTagFactory.ts

@@ -4,6 +4,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../schemas/metadata/MetadataProperty";
 
 import { MetadataFactory } from "./MetadataFactory";
+import { MetadataTypeTagSchemaFactory } from "./MetadataTypeTagSchemaFactory";
 
 export namespace MetadataTypeTagFactory {
   export const analyze =
@@ -83,6 +84,7 @@ export namespace MetadataTypeTagFactory {
             value: tag.value,
             validate: tag.validate[type]!,
             exclusive: tag.exclusive,
+            schema: tag.schema,
           });
       validate(report)(type)(output);
 
@@ -256,7 +258,22 @@ export namespace MetadataTypeTagFactory {
           ]),
         );
       })();
-
+      const schema: object | undefined = (() => {
+        const p: Metadata | undefined = find("schema")?.value;
+        if (p === undefined) return undefined;
+        else if (p.size() === 0 && p.isRequired() === false) return undefined;
+        else if (
+          p.size() === 1 &&
+          p.nullable === false &&
+          p.isRequired() === true &&
+          p.any === false
+        )
+          return MetadataTypeTagSchemaFactory.object((msg) =>
+            report("schema")(msg),
+          )(p.objects[0]!);
+        report("schema")("must be an object type");
+        return undefined;
+      })();
       return {
         name: obj.name,
         target,
@@ -264,6 +281,7 @@ export namespace MetadataTypeTagFactory {
         value,
         validate,
         exclusive: exclusive ?? false,
+        schema,
       };
     };
 
@@ -307,6 +325,7 @@ interface ITypeTag {
   value?: undefined | boolean | bigint | number | string;
   validate: Record<string, string>;
   exclusive: boolean | string[];
+  schema?: undefined | any;
 }
 
 const ESSENTIAL_FIELDS = ["target", "kind", "value"];

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -0,0 +1,58 @@
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+export namespace MetadataTypeTagSchemaFactory {
+  export const object =
+    (report: (msg: string) => false) =>
+    (obj: MetadataObject): object | undefined => {
+      if (obj.recursive) {
+        report(`${obj.name} has recursive type`);
+        return undefined;
+      }
+      const output: any = {};
+      for (const p of obj.properties) {
+        const key: string | null = p.key.getSoleLiteral()!;
+        if (key === null) {
+          report(`${obj.name} has non-literal key type: ${p.key.getName()}`);
+          continue;
+        }
+        output[key] = iterate(report)({ object: obj, key })(p.value);
+      }
+      return output;
+    };
+
+  const iterate =
+    (report: (msg: string) => false) =>
+    (parent: { object: MetadataObject; key: string }) =>
+    (meta: Metadata): any => {
+      if (
+        meta.any ||
+        meta.atomics.length ||
+        meta.arrays.length ||
+        meta.natives.length ||
+        meta.functional
+      )
+        report(`${parent.object.name}.${parent.key} has non-literal type`);
+      else if (meta.size() > 1)
+        report(`${parent.object.name}.${parent.key} has union type`);
+      else if (meta.size() === 0)
+        if (meta.nullable) return null;
+        else if (meta.isRequired() === true)
+          report(`${parent.object.name}.${parent.key} has non-literal type`);
+        else return undefined;
+      else if (meta.constants.length) return meta.constants[0]!.values[0]!;
+      else if (meta.tuples.length) {
+        const tuple = meta.tuples[0]!;
+        if (tuple.type.isRest())
+          report(`${parent.object.name}.${parent.key} has rest tuple type`);
+        else if (tuple.type.recursive)
+          report(
+            `${parent.object.name}.${parent.key} has recursive tuple type`,
+          );
+        else if (tuple.type.elements.some((e) => e.required === false))
+          report(`${parent.object.name}.${parent.key} has optional tuple type`);
+        return tuple.type.elements.map(iterate(report)(parent));
+      } else if (meta.objects.length) return object(report)(meta.objects[0]!);
+      else report(`${parent.object.name}.${parent.key} has non-literal type`);
+    };
+}

package/src/programmers/internal/application_array.ts

@@ -41,11 +41,15 @@ const application_array_tags =
   (options: JsonApplicationProgrammer.IOptions) =>
   (schema: IJsonSchema.IArray) =>
   (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
-    for (const tag of row.slice().sort((a, b) => a.kind.localeCompare(b.kind)))
+    for (const tag of row
+      .slice()
+      .sort((a, b) => a.kind.localeCompare(b.kind))) {
       if (tag.kind === "minItems" && typeof tag.value === "number")
         schema.minItems = tag.value;
       else if (tag.kind === "maxItems" && typeof tag.value === "number")
         schema.maxItems = tag.value;
+      if (tag.schema) Object.assign(schema, tag.schema);
+    }
     if (options.surplus)
       schema["x-typia-typeTags"] = row.map((tag) => ({
         target: tag.target,

package/src/programmers/internal/application_boolean.ts

@@ -19,17 +19,26 @@ export const application_boolean =
       type: "boolean",
     };
     const defaultTags: IMetadataTypeTag[] = atomic.tags
-      .filter((row) => row.some((tag) => tag.kind === "default"))
-      .map((row) => row.filter((tag) => tag.kind === "default"))
+      .filter((row) =>
+        row.some((tag) => tag.kind === "default" || tag.schema !== undefined),
+      )
+      .map((row) =>
+        row.filter((tag) => tag.kind === "default" || tag.schema !== undefined),
+      )
       .flat();
     if (defaultTags.length === 0) return [base];
     return defaultTags.map((tag) => ({
       ...base,
-      default: tag.value,
+      ...(tag.kind === "default"
+        ? {
+            default: tag.value,
+          }
+        : {}),
       ...(options.surplus
         ? {
             "x-typia-typeTags": defaultTags,
           }
         : {}),
+      ...tag.schema,
     }));
   };

package/src/programmers/internal/application_string.ts

@@ -38,7 +38,9 @@ const application_string_tags =
   (options: JsonApplicationProgrammer.IOptions) =>
   (base: IJsonSchema.IString) =>
   (row: IMetadataTypeTag[]): IJsonSchema.IString | null => {
-    for (const tag of row.slice().sort((a, b) => a.kind.localeCompare(b.kind)))
+    for (const tag of row
+      .slice()
+      .sort((a, b) => a.kind.localeCompare(b.kind))) {
       if (tag.kind === "minLength" && typeof tag.value === "number")
         base.minLength = tag.value;
       else if (tag.kind === "maxLength" && typeof tag.value === "number")
@@ -48,6 +50,8 @@ const application_string_tags =
       else if (tag.kind === "pattern") base.pattern = tag.value;
       else if (tag.kind === "default" && typeof tag.value === "string")
         base.default = tag.value;
+      if (tag.schema) Object.assign(base, tag.schema);
+    }
     if (options.surplus)
       base["x-typia-typeTags"] = row.map((tag) => ({
         target: tag.target,

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -7,6 +7,7 @@ export interface IMetadataTypeTag {
   exclusive: boolean | string[];
   value?: any;
   validate?: string | undefined;
+  schema?: object | undefined;
 
   /**
    * @internal

package/src/schemas/metadata/MetadataAtomic.ts

@@ -77,6 +77,7 @@ export class MetadataAtomic {
               : tag.value,
           validate: tag.validate,
           exclusive: tag.exclusive,
+          schema: this.type !== "bigint" ? tag.schema : undefined,
         })),
       ),
     };

package/src/tags/Default.ts

@@ -5,11 +5,14 @@ export type Default<Value extends boolean | bigint | number | string> =
     target: Value extends boolean
       ? "boolean"
       : Value extends bigint
-      ? "bigint"
-      : Value extends number
-      ? "number"
-      : "string";
+        ? "bigint"
+        : Value extends number
+          ? "number"
+          : "string";
     kind: "default";
     value: Value;
     exclusive: true;
+    schema: {
+      default: Value;
+    };
   }>;

package/src/tags/ExclusiveMaximum.ts

@@ -6,6 +6,12 @@ export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
   value: Value;
   validate: `$input < ${Numeric<Value>}`;
   exclusive: ["exclusiveMaximum", "maximum"];
+  schema: Value extends number
+    ? {
+        exclusiveMaximum: true;
+        maximum: Value;
+      }
+    : undefined;
 }>;
 
 type Numeric<Value extends number | bigint> = Value extends number

package/src/tags/ExclusiveMinimum.ts

@@ -6,6 +6,12 @@ export type ExclusiveMinimum<Value extends number | bigint> = TagBase<{
   value: Value;
   validate: `${Numeric<Value>} < $input`;
   exclusive: ["exclusiveMinimum", "minimum"];
+  schema: Value extends number
+    ? {
+        exclusiveMinimum: true;
+        minimum: Value;
+      }
+    : undefined;
 }>;
 
 type Numeric<Value extends number | bigint> = Value extends number

package/src/tags/Format.ts

@@ -7,6 +7,9 @@ export type Format<Value extends keyof Format.Validator> = TagBase<{
   value: Value;
   validate: Format.Validator[Value];
   exclusive: ["format", "pattern"];
+  schema: {
+    format: Value;
+  };
 }>;
 export namespace Format {
   export type Validator = typeof FormatCheatSheet;

package/src/tags/MaxItems.ts

@@ -6,4 +6,7 @@ export type MaxItems<Value extends number> = TagBase<{
   value: Value;
   validate: `$input.length <= ${Value}`;
   exclusive: true;
+  schema: {
+    maxItems: Value;
+  };
 }>;

package/src/tags/MaxLength.ts

@@ -6,4 +6,7 @@ export type MaxLength<Value extends number> = TagBase<{
   value: Value;
   validate: `$input.length <= ${Value}`;
   exclusive: true;
+  schema: {
+    maxLength: Value;
+  };
 }>;

package/src/tags/Maximum.ts

@@ -6,6 +6,11 @@ export type Maximum<Value extends number | bigint> = TagBase<{
   value: Value;
   validate: `$input <= ${Numeric<Value>}`;
   exclusive: ["maximum", "exclusiveMaximum"];
+  schema: Value extends number
+    ? {
+        maximum: Value;
+      }
+    : undefined;
 }>;
 
 type Numeric<Value extends number | bigint> = Value extends number

package/src/tags/MinItems.ts

@@ -6,4 +6,7 @@ export type MinItems<Value extends number> = TagBase<{
   value: Value;
   validate: `${Value} <= $input.length`;
   exclusive: true;
+  schema: {
+    minItems: Value;
+  };
 }>;

package/src/tags/MinLength.ts

@@ -6,4 +6,7 @@ export type MinLength<Value extends number> = TagBase<{
   value: Value;
   validate: `${Value} <= $input.length`;
   exclusive: true;
+  schema: {
+    minLength: Value;
+  };
 }>;