typia 5.0.0-dev.20230823-2 → 5.0.0-dev.2023084

package/src/schemas/metadata/MetadataEscaped.ts

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

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"?: {
+        targeet: "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"?: {
+        targeet: "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,
+    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/features/json/JsonApplicationTransformer.ts

@@ -1,111 +1,111 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace JsonApplicationTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            //----
-            // GET ARGUMENTS
-            //----
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
-
-            // ADDITIONAL PARAMETERS
-            const purpose: "swagger" | "ajv" = get_parameter(
-                checker,
-                "Purpose",
-                expression.typeArguments[1],
-                (str) => str === "swagger" || str === "ajv",
-                () => "swagger",
-            );
-
-            //----
-            // GENERATORS
-            //----
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: false,
-                    validate: (meta) => {
-                        if (meta.atomics.find((str) => str === "bigint"))
-                            throw new Error(NO_BIGIT);
-                        else if (
-                            meta.arrays.some(
-                                (array) => array.value.isRequired() === false,
-                            )
-                        )
-                            throw new Error(NO_UNDEFINED_IN_ARRAY);
-                    },
-                })(collection)(type),
-            );
-
-            // APPLICATION
-            const app: IJsonApplication = JsonApplicationProgrammer.write({
-                purpose,
-            })(metadatas);
-
-            // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(app);
-        };
-
-    const get_parameter = <T extends string>(
-        checker: ts.TypeChecker,
-        name: string,
-        node: ts.TypeNode | undefined,
-        predicator: (value: string) => boolean,
-        defaulter: () => T,
-    ): T => {
-        if (!node) return defaulter();
-
-        // CHECK LITERAL TYPE
-        const type: ts.Type = checker.getTypeFromTypeNode(node);
-        if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
-        return value as T;
-    };
-}
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.json.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.json.application(): non-specified generic argument(s).";
-const NO_BIGIT =
-    "Error on typia.json.application(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.application(): does not allow undefined type in array.";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace JsonApplicationTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            //----
+            // GET ARGUMENTS
+            //----
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new Error(GENERIC_ARGUMENT);
+
+            // ADDITIONAL PARAMETERS
+            const purpose: "swagger" | "ajv" = get_parameter(
+                checker,
+                "Purpose",
+                expression.typeArguments[1],
+                (str) => str === "swagger" || str === "ajv",
+                () => "swagger",
+            );
+
+            //----
+            // GENERATORS
+            //----
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    escape: true,
+                    constant: true,
+                    absorb: false,
+                    validate: (meta) => {
+                        if (meta.atomics.find((atom) => atom.type === "bigint"))
+                            throw new Error(NO_BIGIT);
+                        else if (
+                            meta.arrays.some(
+                                (array) => array.value.isRequired() === false,
+                            )
+                        )
+                            throw new Error(NO_UNDEFINED_IN_ARRAY);
+                    },
+                })(collection)(type),
+            );
+
+            // APPLICATION
+            const app: IJsonApplication = JsonApplicationProgrammer.write({
+                purpose,
+            })(metadatas);
+
+            // RETURNS WITH LITERAL EXPRESSION
+            return LiteralFactory.generate(app);
+        };
+
+    const get_parameter = <T extends string>(
+        checker: ts.TypeChecker,
+        name: string,
+        node: ts.TypeNode | undefined,
+        predicator: (value: string) => boolean,
+        defaulter: () => T,
+    ): T => {
+        if (!node) return defaulter();
+
+        // CHECK LITERAL TYPE
+        const type: ts.Type = checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral())
+            throw new Error(
+                `Error on typia.application(): generic argument "${name}" must be constant.`,
+            );
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new Error(
+                `Error on typia.application(): invalid value on generic argument "${name}".`,
+            );
+        return value as T;
+    };
+}
+
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.json.application(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.json.application(): non-specified generic argument(s).";
+const NO_BIGIT =
+    "Error on typia.json.application(): does not allow bigint type.";
+const NO_UNDEFINED_IN_ARRAY =
+    "Error on typia.json.application(): does not allow undefined type in array.";

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

@@ -1,53 +1,53 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { IProject } from "../../IProject";
-
-export namespace MetadataTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
-
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: true,
-                })(collection)(type),
-            );
-
-            // CONVERT TO PRIMITIVE TYPE
-            const app: IMetadataApplication = {
-                metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.toJSON(),
-            };
-            return LiteralFactory.generate(app);
-        };
-}
-
-const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.metadata(): non-specified generic argument(s).";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { IProject } from "../../IProject";
+
+export namespace MetadataTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new Error(GENERIC_ARGUMENT);
+
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    escape: true,
+                    constant: true,
+                    absorb: true,
+                })(collection)(type),
+            );
+
+            // CONVERT TO PRIMITIVE TYPE
+            const app: IMetadataApplication = {
+                metadatas: metadatas.map((metadata) => metadata.toJSON()),
+                collection: collection.toJSON(),
+            };
+            return LiteralFactory.generate(app);
+        };
+}
+
+const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.metadata(): non-specified generic argument(s).";