typia 5.0.0-dev.20230823 → 5.0.0-dev.20230824

package/src/schemas/metadata/MetadataArray.ts

@@ -1,55 +1,31 @@
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataArray } from "./IMetadataArray";
-import { Metadata } from "./Metadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataArrayType } from "./MetadataArrayType";
 
 export class MetadataArray {
-    public readonly name: string;
-    public readonly value: Metadata;
-    public readonly nullables: boolean[];
-    public readonly recursive: boolean;
-    public readonly index: number | null;
+    public readonly type: MetadataArrayType;
+    public readonly tags: IMetadataTypeTag[][];
 
     /**
      * @hidden
      */
     private constructor(props: ClassProperties<MetadataArray>) {
-        this.name = props.name;
-        this.value = props.value;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
-    /**
-     * @internal
-     */
-    public static _From_without_value(
-        props: Omit<IMetadataArray, "value">,
-    ): MetadataArray {
-        return this.create({
-            name: props.name,
-            value: null!,
-            index: props.index,
-            recursive: props.recursive,
-            nullables: props.nullables,
-        });
-    }
-
-    /**
-     * @internal
-     */
     public static create(props: ClassProperties<MetadataArray>): MetadataArray {
         return new MetadataArray(props);
     }
 
     public toJSON(): IMetadataArray {
         return {
-            name: this.name,
-            value: this.value.toJSON(),
-            nullables: this.nullables,
-            recursive: this.recursive,
-            index: this.index,
+            type: this.type.toJSON(),
+            tags: $clone(this.tags),
         };
     }
 }

package/src/schemas/metadata/MetadataArrayType.ts

@@ -0,0 +1,57 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { Metadata } from "./Metadata";
+
+export class MetadataArrayType {
+    public readonly name: string;
+    public readonly value: Metadata;
+    public readonly nullables: boolean[];
+    public readonly recursive: boolean;
+    public readonly index: number | null;
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataArrayType>) {
+        this.name = props.name;
+        this.value = props.value;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_value(
+        props: Omit<IMetadataArrayType, "value">,
+    ): MetadataArrayType {
+        return this.create({
+            name: props.name,
+            value: null!,
+            index: props.index,
+            recursive: props.recursive,
+            nullables: props.nullables,
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataArrayType>,
+    ): MetadataArrayType {
+        return new MetadataArrayType(props);
+    }
+
+    public toJSON(): IMetadataArrayType {
+        return {
+            name: this.name,
+            value: this.value.toJSON(),
+            nullables: this.nullables,
+            recursive: this.recursive,
+            index: this.index,
+        };
+    }
+}

package/src/schemas/metadata/{MetadataResolved.ts → MetadataEscaped.ts}

@@ -1,17 +1,17 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataResolved } from "./IMetadataResolved";
+import { IMetadataEscaped } from "./IMetadataEscaped";
 import { Metadata } from "./Metadata";
 
-export class MetadataResolved {
+export class MetadataEscaped {
     public readonly original: Metadata;
     public readonly returns: Metadata;
 
     /**
      * @hidden
      */
-    private constructor(props: ClassProperties<MetadataResolved>) {
+    private constructor(props: ClassProperties<MetadataEscaped>) {
         this.original = props.original;
         this.returns = props.returns;
     }
@@ -20,9 +20,9 @@ export class MetadataResolved {
      * @internal
      */
     public static _From(
-        props: IMetadataResolved,
+        props: IMetadataEscaped,
         dict: IMetadataDictionary,
-    ): MetadataResolved {
+    ): MetadataEscaped {
         return this.create({
             original: Metadata._From(props.original, dict),
             returns: Metadata._From(props.returns, dict),
@@ -33,16 +33,16 @@ export class MetadataResolved {
      * @internal
      */
     public static create(
-        props: ClassProperties<MetadataResolved>,
-    ): MetadataResolved {
-        return new MetadataResolved(props);
+        props: ClassProperties<MetadataEscaped>,
+    ): MetadataEscaped {
+        return new MetadataEscaped(props);
     }
 
     public getName(): string {
         return this.returns.getName();
     }
 
-    public toJSON(): IMetadataResolved {
+    public toJSON(): IMetadataEscaped {
         return {
             original: this.original.toJSON(),
             returns: this.returns.toJSON(),

package/src/schemas/metadata/MetadataProperty.ts

@@ -1,16 +1,16 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataProperty } from "./IMetadataProperty";
-import { IMetadataTag } from "./IMetadataTag";
 import { Metadata } from "./Metadata";
 
 export class MetadataProperty {
     public readonly key: Metadata;
     public readonly value: Metadata;
     public readonly description: string | null;
-    public readonly tags: IMetadataTag[];
+    public readonly tags: IMetadataCommentTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
 
     /* -----------------------------------------------------------

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,45 +1,21 @@
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataTuple } from "./IMetadataTuple";
-import { Metadata } from "./Metadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 export class MetadataTuple {
-    public readonly name: string;
-    public readonly elements: Metadata[];
-
-    public readonly index: number | null;
-    public readonly recursive: boolean;
-    public readonly nullables: boolean[];
-
-    /**
-     * @internal
-     */
-    public of_map?: boolean;
+    public readonly type: MetadataTupleType;
+    public readonly tags: IMetadataTypeTag[][];
 
     /**
      * @internal
      */
     private constructor(props: ClassProperties<MetadataTuple>) {
-        this.name = props.name;
-        this.elements = props.elements;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_elements(
-        props: Omit<IMetadataTuple, "elements">,
-    ): MetadataTuple {
-        return this.create({
-            name: props.name,
-            index: props.index,
-            elements: null!,
-            recursive: props.recursive,
-            nullables: props.nullables.slice(),
-        });
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
     public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
@@ -48,11 +24,8 @@ export class MetadataTuple {
 
     public toJSON(): IMetadataTuple {
         return {
-            name: this.name,
-            index: this.index,
-            elements: this.elements.map((elem) => elem.toJSON()),
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
+            type: this.type.toJSON(),
+            tags: $clone(this.tags),
         };
     }
 }

package/src/schemas/metadata/MetadataTupleType.ts

@@ -0,0 +1,67 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { Metadata } from "./Metadata";
+
+export class MetadataTupleType {
+    public readonly name: string;
+    public readonly elements: Metadata[];
+
+    public readonly index: number | null;
+    public readonly recursive: boolean;
+    public readonly nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    public of_map?: boolean;
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataTupleType>) {
+        this.name = props.name;
+        this.elements = props.elements;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_elements(
+        props: Omit<IMetadataTupleType, "elements">,
+    ): MetadataTupleType {
+        return this.create({
+            name: props.name,
+            index: props.index,
+            elements: null!,
+            recursive: props.recursive,
+            nullables: props.nullables.slice(),
+        });
+    }
+
+    public static create(
+        props: ClassProperties<MetadataTupleType>,
+    ): MetadataTupleType {
+        return new MetadataTupleType(props);
+    }
+
+    public isRest(): boolean {
+        return (
+            this.elements.length > 0 &&
+            this.elements[this.elements.length - 1]!.rest !== null
+        );
+    }
+
+    public toJSON(): IMetadataTupleType {
+        return {
+            name: this.name,
+            index: this.index,
+            elements: this.elements.map((elem) => elem.toJSON()),
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}

package/src/tags/ExclusiveMaximum.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMaximum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "exclusiveMaximum";
+        value: Fixed;
+        validate?: `$input < ${Fixed}`;
+    };
+};

package/src/tags/ExclusiveMinimum.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMinimum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "exclusiveMinimum";
+        value: Fixed;
+        validate?: `${Fixed} < $input`;
+    };
+};

package/src/tags/Format.ts

@@ -0,0 +1,29 @@
+export type Format<
+    Value extends
+        | "email"
+        | "uuid"
+        | "ipv4"
+        | "ipv6"
+        | "url"
+        | "date"
+        | "date-time",
+> = {
+    "typia.tag"?: {
+        target: "string";
+        kind: "format";
+        value: Value;
+        validate: Value extends "email"
+            ? `/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test($input)`
+            : Value extends "uuid"
+            ? `/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i.test($input)`
+            : Value extends "ipv4"
+            ? `/^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test($input)`
+            : Value extends "ipv6"
+            ? `/^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/.test($input)`
+            : Value extends "url"
+            ? `/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test($input)`
+            : Value extends "date"
+            ? `/^(\d{4})-(\d{2})-(\d{2})$/.test($input)`
+            : `!isNaN(new Date($input).getTime())`;
+    };
+};

package/src/tags/MaxItems.ts

@@ -0,0 +1,8 @@
+export type MaxItems<Size extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "maxItems";
+        value: Size;
+        validate: `$input.length <= ${Size}`;
+    };
+};

package/src/tags/MaxLength.ts

@@ -0,0 +1,8 @@
+export type MaxLength<Fixed extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "maxLength";
+        value: number;
+        validate: `$input.length <= ${Fixed}`;
+    };
+};

package/src/tags/Maximum.ts

@@ -0,0 +1,8 @@
+export type Maximum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "maximum";
+        value: Fixed;
+        validate: `$input <= ${Fixed}`;
+    };
+};

package/src/tags/MinItems.ts

@@ -0,0 +1,8 @@
+export type MinItems<Size extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "minItems";
+        value: Size;
+        validate: `${Size} <= $input.length`;
+    };
+};

package/src/tags/MinLength.ts

@@ -0,0 +1,8 @@
+export type MinLength<Fixed extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "minLength";
+        value: number;
+        validate: `${Fixed} <= $input.length`;
+    };
+};

package/src/tags/Minimum.ts

@@ -0,0 +1,8 @@
+export type Minimum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "minimum";
+        value: Fixed;
+        validate?: `${Fixed} <= $input`;
+    };
+};

package/src/tags/MultipleOf.ts

@@ -0,0 +1,10 @@
+export type MultipleOf<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends bigint ? "bigint" : "number";
+        kind: "multipleOf";
+        value: Fixed;
+        validate: `$input % ${Fixed} === ${Fixed extends bigint
+            ? "bigint"
+            : "number"}`;
+    };
+};

package/src/tags/Pattern.ts

@@ -0,0 +1,8 @@
+export type Pattern<Value extends string> = {
+    "typia.tag"?: {
+        target: "string";
+        kind: "pattern";
+        value: Value;
+        validate: `RegExp(/${Value}/).test($input)`;
+    };
+};

package/src/tags/TagBase.ts

@@ -0,0 +1,17 @@
+export type TagBase<
+    Target extends "bigint" | "number" | "string" | "array",
+    Kind extends string,
+    Value extends boolean | bigint | number | string,
+    Validate extends
+        | string
+        | {
+              [key in Target]?: string;
+          },
+> = {
+    "typia.tag"?: {
+        target: Target;
+        kind: Kind;
+        value: Value;
+        validate: Validate;
+    };
+};

package/src/tags/Type.ts

@@ -0,0 +1,30 @@
+export type Type<
+    Target extends
+        | "int"
+        | "uint"
+        | "int32"
+        | "uint32"
+        | "int64"
+        | "uint64"
+        | "float",
+> = {
+    "typia.tag"?: {
+        target: Target extends "uint64" ? "bigint" : "number" | "bigint";
+        kind: "type";
+        value: Target;
+        validate: Target extends "int" | "int32"
+            ? `Number.isInteger($input) && -2147483648 <= $input && $input <= 2147483647`
+            : Target extends "uint" | "uint32"
+            ? `Number.isInteger($input) && 0 <= $input && $input <= 4294967295`
+            : Target extends "int64"
+            ? {
+                  number: `Number.isInteger($input) && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
+              }
+            : Target extends "uint64"
+            ? {
+                  number: `Number.isInteger($input) && 0 <= $input && $input <= 18446744073709551615`;
+                  bigint: `BigInt(0) <= $input && $input <= BigInt(18446744073709551615)`;
+              }
+            : `-1.175494351e38 <= $input <= 3.4028235e38`;
+    };
+};

package/src/tags/index.ts

@@ -0,0 +1,12 @@
+export * from "./ExclusiveMaximum";
+export * from "./ExclusiveMinimum";
+export * from "./Format";
+export * from "./Maximum";
+export * from "./MaxItems";
+export * from "./MaxLength";
+export * from "./Minimum";
+export * from "./MinItems";
+export * from "./MinLength";
+export * from "./Pattern";
+export * from "./TagBase";
+export * from "./Type";

package/src/transformers/FileTransformer.ts

@@ -5,13 +5,13 @@ import { NodeTransformer } from "./NodeTransformer";
 
 export namespace FileTransformer {
     export const transform =
-        (project: IProject) =>
+        (project: Omit<IProject, "context">) =>
         (context: ts.TransformationContext) =>
         (file: ts.SourceFile): ts.SourceFile => {
             if (file.isDeclarationFile) return file;
             return ts.visitEachChild(
                 file,
-                (node) => iterate_node(project)(context)(node),
+                (node) => iterate_node({ ...project, context })(context)(node),
                 context,
             );
         };

package/src/transformers/IProject.ts

@@ -8,4 +8,5 @@ export interface IProject {
     checker: ts.TypeChecker;
     printer: ts.Printer;
     options: ITransformOptions;
+    context: ts.TransformationContext;
 }

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -50,15 +50,16 @@ export namespace JsonApplicationTransformer {
             const collection: MetadataCollection = new MetadataCollection();
             const metadatas: Array<Metadata> = types.map((type) =>
                 MetadataFactory.analyze(checker)({
-                    resolve: true,
+                    escape: true,
                     constant: true,
                     absorb: false,
                     validate: (meta) => {
-                        if (meta.atomics.find((str) => str === "bigint"))
+                        if (meta.atomics.find((atom) => atom.type === "bigint"))
                             throw new Error(NO_BIGIT);
                         else if (
                             meta.arrays.some(
-                                (array) => array.value.isRequired() === false,
+                                (array) =>
+                                    array.type.value.isRequired() === false,
                             )
                         )
                             throw new Error(NO_UNDEFINED_IN_ARRAY);

package/src/transformers/features/misc/MetadataTransformer.ts

@@ -33,7 +33,7 @@ export namespace MetadataTransformer {
             const collection: MetadataCollection = new MetadataCollection();
             const metadatas: Array<Metadata> = types.map((type) =>
                 MetadataFactory.analyze(checker)({
-                    resolve: true,
+                    escape: true,
                     constant: true,
                     absorb: true,
                 })(collection)(type),

package/src/typings/Atomic.ts

@@ -1,5 +1,6 @@
 export namespace Atomic {
     export type Type = boolean | number | string | bigint;
+
     export type Literal =
         | "boolean"
         | "integer"

package/src/utils/RandomGenerator.ts

@@ -74,8 +74,10 @@ export namespace RandomGenerator {
     };
 
     export const datetime = (min?: number, max?: number) => {
-        min ??= 0;
-        max ??= Date.now() * 2;
+        min ??= Date.now() - 30 * DAY;
+        max ??= Date.now() + 7 * DAY;
         return new Date(number(min, max)).toISOString();
     };
 }
+
+const DAY = 1000 * 60 * 60 * 24;