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

package/src/schemas/metadata/MetadataAtomic.ts

@@ -0,0 +1,42 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataAtomic {
+    public readonly type: "boolean" | "bigint" | "number" | "string";
+    public readonly tags: IMetadataTypeTag[][];
+
+    private name_?: string;
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataAtomic>) {
+        this.type = props.type;
+        this.tags = props.tags;
+    }
+
+    public static create(
+        props: ClassProperties<MetadataAtomic>,
+    ): MetadataAtomic {
+        return new MetadataAtomic(props);
+    }
+
+    public getName(): string {
+        return (this.name_ ??= (() => {
+            if (this.tags.length === 0) return this.type;
+            else if (this.tags.length === 1) {
+                const str: string = [
+                    this.type,
+                    ...this.tags[0]!.map((t) => t.name),
+                ].join(" & ");
+                return `(${str})`;
+            }
+            const rows: string[] = this.tags.map((row) => {
+                const str: string = row.map((t) => t.name).join(" & ");
+                return row.length === 1 ? str : `(${str})`;
+            });
+            return `(${this.type} & (${rows.join(" | ")}))`;
+        })());
+    }
+}

package/src/schemas/metadata/MetadataProperty.ts

@@ -3,14 +3,12 @@ import { ClassProperties } from "../../typings/ClassProperties";
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 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 jsDocTags: IJsDocTagInfo[];
 
     /* -----------------------------------------------------------
@@ -23,7 +21,6 @@ export class MetadataProperty {
         this.key = props.key;
         this.value = props.value;
         this.description = props.description;
-        this.tags = props.tags;
         this.jsDocTags = props.jsDocTags;
     }
 
@@ -47,7 +44,6 @@ export class MetadataProperty {
             key: Metadata._From(property.key, dict),
             value: Metadata._From(property.value, dict),
             description: property.description,
-            tags: property.tags.slice(),
             jsDocTags: property.jsDocTags.slice(),
         });
     }
@@ -57,7 +53,6 @@ export class MetadataProperty {
             key: this.key.toJSON(),
             value: this.value.toJSON(),
             description: this.description,
-            tags: this.tags,
             jsDocTags: this.jsDocTags,
         };
     }

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,58 +1,32 @@
 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
+     * @hidden
      */
     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;
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
     /**
      * @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(),
-        });
-    }
-
     public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
         return new MetadataTuple(props);
     }
 
     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: this.tags.map((row) => row.slice()),
         };
     }
 }

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,13 @@
+import { TagBase } from "./TagBase";
+
+export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "exclusiveMaximum";
+    value: Value;
+    validate: `$input < ${Numeric<Value>}`;
+    exclusive: ["exclusiveMaximum", "maximum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/ExclusiveMinimum.ts

@@ -0,0 +1,13 @@
+import { TagBase } from "./TagBase";
+
+export type ExclusiveMinimum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "exclusiveMinimum";
+    value: Value;
+    validate: `${Numeric<Value>} < $input`;
+    exclusive: ["exclusiveMinimum", "minimum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/Format.ts

@@ -0,0 +1,30 @@
+import { TagBase } from "./TagBase";
+
+export type Format<
+    Value extends
+        | "email"
+        | "uuid"
+        | "ipv4"
+        | "ipv6"
+        | "url"
+        | "date"
+        | "date-time",
+> = TagBase<{
+    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())`;
+    exclusive: ["pattern"];
+}>;

package/src/tags/MaxItems.ts

@@ -0,0 +1,9 @@
+import { TagBase } from "./TagBase";
+
+export type MaxItems<Value extends number> = TagBase<{
+    target: "array";
+    kind: "maxItems";
+    value: Value;
+    validate: `$input.length <= ${Value}`;
+    exclusive: true;
+}>;

package/src/tags/MaxLength.ts

@@ -0,0 +1,9 @@
+import { TagBase } from "./TagBase";
+
+export type MaxLength<Value extends number> = TagBase<{
+    target: "string";
+    kind: "maxLength";
+    value: Value;
+    validate: `$input.length <= ${Value}`;
+    exclusive: true;
+}>;

package/src/tags/Maximum.ts

@@ -0,0 +1,13 @@
+import { TagBase } from "./TagBase";
+
+export type Maximum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "maximum";
+    value: Value;
+    validate: `$input <= ${Numeric<Value>}`;
+    exclusive: ["maximum", "exclusiveMaximum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/MinItems.ts

@@ -0,0 +1,9 @@
+import { TagBase } from "./TagBase";
+
+export type MinItems<Value extends number> = TagBase<{
+    target: "array";
+    kind: "minItems";
+    value: Value;
+    validate: `${Value} <= $input.length`;
+    exclusive: true;
+}>;

package/src/tags/MinLength.ts

@@ -0,0 +1,9 @@
+import { TagBase } from "./TagBase";
+
+export type MinLength<Value extends number> = TagBase<{
+    target: "string";
+    kind: "minLength";
+    value: Value;
+    validate: `${Value} <= $input.length`;
+    exclusive: true;
+}>;

package/src/tags/Minimum.ts

@@ -0,0 +1,13 @@
+import { TagBase } from "./TagBase";
+
+export type Minimum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "minimum";
+    value: Value;
+    validate: `${Numeric<Value>} <= $input`;
+    exclusive: ["minimum", "exclusiveMinimum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/MultipleOf.ts

@@ -0,0 +1,15 @@
+import { TagBase } from "./TagBase";
+
+export type MultipleOf<Value extends number | bigint> = TagBase<{
+    target: Value extends bigint ? "bigint" : "number";
+    kind: "multipleOf";
+    value: Value;
+    validate: `$input % ${Numeric<Value>} === ${Value extends bigint
+        ? Numeric<0n>
+        : 0}`;
+    exclusive: true;
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/Pattern.ts

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

package/src/tags/TagBase.ts

@@ -0,0 +1,22 @@
+export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
+    "typia.tag"?: Props;
+};
+export namespace TagBase {
+    export interface IProps<
+        Target extends "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[],
+    > {
+        target: Target;
+        kind: Kind;
+        value: Value;
+        validate: Validate;
+        exclusive?: Exclusive | string[];
+    }
+}

package/src/tags/Type.ts

@@ -0,0 +1,27 @@
+import { TagBase } from "./TagBase";
+
+export type Type<
+    Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
+> = TagBase<{
+    target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+    kind: "type";
+    value: Value;
+    validate: Value extends "int32"
+        ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
+        : Value extends "uint32"
+        ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
+        : Value extends "int64"
+        ? {
+              number: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
+              bigint: `true`;
+          }
+        : Value extends "uint64"
+        ? {
+              number: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`;
+              bigint: `BigInt(0) <= $input`;
+          }
+        : Value extends "float"
+        ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+        : `true`;
+    exclusive: true;
+}>;

package/src/tags/index.ts

@@ -0,0 +1,13 @@
+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 "./MultipleOf";
+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,
             );
         };
@@ -34,13 +34,13 @@ export namespace FileTransformer {
             } catch (exp) {
                 if (!(exp instanceof Error)) throw exp;
 
-                const file: ts.SourceFile = node.getSourceFile();
+                const file: ts.SourceFile | undefined = node.getSourceFile();
+                if (file === undefined) throw exp;
+
                 const { line, character } = file.getLineAndCharacterOfPosition(
                     node.pos,
                 );
-                exp.message += ` - ${file.fileName}:${line + 1}:${
-                    character + 1
-                }`;
+                console.error(`${file.fileName}:${line}:${character}:`, exp);
                 throw exp;
             }
         };

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

@@ -54,11 +54,12 @@ export namespace JsonApplicationTransformer {
                     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/MiscCreateIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateIsPruneTransformer {
     export const transform = GenericTransformer.factory("createIsPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

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

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscIsPruneTransformer {
     export const transform = GenericTransformer.scalar("isPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

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/typings/ProtobufAtomic.ts

@@ -0,0 +1,19 @@
+export type ProtobufAtomic =
+    | "bool"
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double"
+    | "string";
+export namespace ProtobufAtomic {
+    export type Numeric =
+        | "int32"
+        | "uint32"
+        | "int64"
+        | "uint64"
+        | "float"
+        | "double";
+    export type BigNumeric = "int64" | "uint64";
+}

package/lib/CustomValidatorMap.d.ts

@@ -1,110 +0,0 @@
-import { Customizable } from "./typings/Customizable";
-/**
- * Map of custom validators.
- *
- * Map of custom validator functions, storing tag name and type of target value
- * as key, and custom validator function as value.
- *
- * When you want to add a custom validation logic utilizing comment tags, you
- * can insert a custom validator function with specific tag name and type of
- * the target value like below.
- *
- * ```ts
- * typia.customValidators.insert("powerOf")("number")(
- *     (text: string) => {
- *         const denominator: number = Math.log(Number(text));
- *         return (value: number) => {
- *             value = Math.log(value) / denominator;
- *             return value === Math.floor(value);
- *         };
- *     }
- * );
- * typia.customValidators.insert("dollar")("string")(
- *     () => (value: string) => value.startsWith("$"),
- * );
- *
- * interface TagCustom {
- *    /**
- *     * @powerOf 10
- *     *\/
- *    powerOf: number;
- *
- *    /**
- *     * @dollar
- *     *\/
- *    dollar: string;
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export interface CustomValidatorMap {
-    /**
-     * Get number of stored tags.
-     *
-     * @return Number of stored tags
-     */
-    size(): number;
-    /**
-     * Get number of stored types of the specified tag name.
-     *
-     * In other words, number of stored custom validator functions of
-     * the specified tag name.
-     *
-     * @param name Tag name
-     * @return Number of stored types function
-     */
-    size(name: string): number;
-    /**
-     * Test whether custom validator function exists or not.
-     *
-     * @param name Tag name
-     * @param type Type of the target value
-     * @returns Whether exists or not
-     */
-    has: (name: string) => (type: keyof Customizable) => boolean;
-    /**
-     * Get custom validator function.
-     *
-     * @param name Tag name
-     * @param type Type of the target value
-     * @returns Custom validator function or undefined value
-     */
-    get(name: string): <Type extends keyof Customizable>(type: Type) => CustomValidatorMap.Closure<Type> | undefined;
-    /**
-     * Insert a new custom validator function.
-     *
-     * You can add a custom validation logic utilizing comment tags,
-     * by inserting a function which returns a boolean value, with specific
-     * tag name and type of the target value.
-     *
-     * However, if you try to insert a duplicated tag name and type, the
-     * closure function would not be enrolled and `false` value would be
-     * returned.
-     *
-     * @param name Tag name
-     * @param type Type of the target value
-     * @param closure Custom validator function
-     * @returns Whether succeeded to insert or not
-     */
-    insert(name: string): <Type extends keyof Customizable>(type: Type) => (closure: CustomValidatorMap.Closure<Type>) => boolean;
-    /**
-     * Erase custom validator function.
-     *
-     * @param name Tag name
-     * @param type Type of the target value
-     * @returns Whether succeeded to erase or not
-     */
-    erase(name: string): (type: keyof Customizable) => boolean;
-}
-export declare namespace CustomValidatorMap {
-    /**
-     * Type of closure function of custom validation.
-     *
-     * @template Type Type of the target value
-     * @param text Text of the tag. For example, if the tag is `@powerOf 10`, `text` is 10.
-     * @param value Value to validate
-     * @returns Whether the value is valid or not
-     */
-    type Closure<Type extends keyof Customizable> = (text: string) => (value: Customizable[Type]) => boolean;
-}

package/lib/CustomValidatorMap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CustomValidatorMap.js","sourceRoot":"","sources":["../src/CustomValidatorMap.ts"],"names":[],"mappings":""}