typia 3.7.0-dev.20230310 → 3.7.0-dev.20230331

package/src/factories/MetadataTagFactory.ts

@@ -28,7 +28,7 @@ export namespace MetadataTagFactory {
         tag: ts.JSDocTagInfo,
         output: IMetadataTag[],
     ): IMetadataTag | null {
-        const closure = PARSER[tag.name];
+        const closure = _PARSER[tag.name];
         if (closure === undefined) return null;
 
         const text = (tag.text || [])[0]?.text;
@@ -37,166 +37,193 @@ export namespace MetadataTagFactory {
 
         return closure(identifier, metadata, text, output);
     }
-}
 
-const PARSER: Record<
-    string,
-    (
-        identifier: () => string,
-        metadata: Metadata,
-        text: string,
-        output: IMetadataTag[],
-    ) => IMetadataTag | null
-> = {
-    /* -----------------------------------------------------------
+    /**
+     * @internal
+     */
+    export const _PARSER: Record<
+        string,
+        (
+            identifier: () => string,
+            metadata: Metadata,
+            text: string,
+            output: IMetadataTag[],
+        ) => IMetadataTag | null
+    > = {
+        /* -----------------------------------------------------------
         ARRAY
     ----------------------------------------------------------- */
-    items: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "items", "array", ["minItems"]);
-        return {
-            kind: "items",
-            value: parse_number(identifier, text),
-        };
-    },
-    minItems: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "minItems", "array", ["items"]);
-        return {
-            kind: "minItems",
-            value: parse_number(identifier, text),
-        };
-    },
-    maxItems: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "maxItems", "array", ["items"]);
-        return {
-            kind: "maxItems",
-            value: parse_number(identifier, text),
-        };
-    },
+        items: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "items", "array", [
+                "minItems",
+            ]);
+            return {
+                kind: "items",
+                value: parse_number(identifier, text),
+            };
+        },
+        minItems: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "minItems", "array", [
+                "items",
+            ]);
+            return {
+                kind: "minItems",
+                value: parse_number(identifier, text),
+            };
+        },
+        maxItems: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "maxItems", "array", [
+                "items",
+            ]);
+            return {
+                kind: "maxItems",
+                value: parse_number(identifier, text),
+            };
+        },
 
-    /* -----------------------------------------------------------
+        /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */
-    type: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "type", "number", []);
-        if (text !== "int" && text !== "uint")
-            throw new Error(`${LABEL}: invalid type tag on "${identifier()}".`);
-        return { kind: "type", value: text };
-    },
-    minimum: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "minimum", "number", [
-            "exclusiveMinimum",
-        ]);
-        return {
-            kind: "minimum",
-            value: parse_number(identifier, text),
-        };
-    },
-    maximum: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "maximum", "number", [
-            "exclusiveMaximum",
-        ]);
-        return {
-            kind: "maximum",
-            value: parse_number(identifier, text),
-        };
-    },
-    exclusiveMinimum: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "exclusiveMinimum", "number", [
-            "minimum",
-        ]);
-        return {
-            kind: "exclusiveMinimum",
-            value: parse_number(identifier, text),
-        };
-    },
-    exclusiveMaximum: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "exclusiveMaximum", "number", [
-            "maximum",
-        ]);
-        return {
-            kind: "exclusiveMaximum",
-            value: parse_number(identifier, text),
-        };
-    },
-    multipleOf: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "multipleOf", "number", [
-            "step",
-        ]);
-        return {
-            kind: "multipleOf",
-            value: parse_number(identifier, text),
-        };
-    },
-    step: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "step", "number", [
-            "multipleOf",
-        ]);
+        type: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "type", "number", []);
+            if (text !== "int" && text !== "uint")
+                throw new Error(
+                    `${LABEL}: invalid type tag on "${identifier()}".`,
+                );
+            return { kind: "type", value: text };
+        },
+        minimum: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "minimum", "number", [
+                "exclusiveMinimum",
+            ]);
+            return {
+                kind: "minimum",
+                value: parse_number(identifier, text),
+            };
+        },
+        maximum: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "maximum", "number", [
+                "exclusiveMaximum",
+            ]);
+            return {
+                kind: "maximum",
+                value: parse_number(identifier, text),
+            };
+        },
+        exclusiveMinimum: (identifier, metadata, text, output) => {
+            validate(
+                identifier,
+                metadata,
+                output,
+                "exclusiveMinimum",
+                "number",
+                ["minimum"],
+            );
+            return {
+                kind: "exclusiveMinimum",
+                value: parse_number(identifier, text),
+            };
+        },
+        exclusiveMaximum: (identifier, metadata, text, output) => {
+            validate(
+                identifier,
+                metadata,
+                output,
+                "exclusiveMaximum",
+                "number",
+                ["maximum"],
+            );
+            return {
+                kind: "exclusiveMaximum",
+                value: parse_number(identifier, text),
+            };
+        },
+        multipleOf: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "multipleOf", "number", [
+                "step",
+            ]);
+            return {
+                kind: "multipleOf",
+                value: parse_number(identifier, text),
+            };
+        },
+        step: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "step", "number", [
+                "multipleOf",
+            ]);
 
-        const minimum: boolean = output.some(
-            (tag) => tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-        );
-        if (minimum === undefined)
-            throw new Error(
-                `${LABEL}: step requires minimum or exclusiveMinimum tag on "${identifier()}".`,
+            const minimum: boolean = output.some(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
             );
+            if (minimum === undefined)
+                throw new Error(
+                    `${LABEL}: step requires minimum or exclusiveMinimum tag on "${identifier()}".`,
+                );
 
-        return {
-            kind: "step",
-            value: parse_number(identifier, text),
-        };
-    },
+            return {
+                kind: "step",
+                value: parse_number(identifier, text),
+            };
+        },
 
-    /* -----------------------------------------------------------
+        /* -----------------------------------------------------------
         STRING
     ----------------------------------------------------------- */
-    format: (identifier, metadata, value, output) => {
-        validate(identifier, metadata, output, "format", "string", ["pattern"]);
+        format: (identifier, metadata, str, output) => {
+            validate(identifier, metadata, output, "format", "string", [
+                "pattern",
+            ]);
 
-        // Ignore arbitrary @format values in the internal metadata,
-        // these are currently only supported on the typia.application() API.
-        if (FORMATS.has(value) === false) return null;
-
-        return {
-            kind: "format",
-            value: value as "uuid",
-        };
-    },
-    pattern: (identifier, metadata, value, output) => {
-        validate(identifier, metadata, output, "pattern", "string", ["format"]);
-        return {
-            kind: "pattern",
-            value,
-        };
-    },
-    length: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "length", "string", [
-            "minLength",
-            "maxLength",
-        ]);
-        return {
-            kind: "length",
-            value: parse_number(identifier, text),
-        };
-    },
-    minLength: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "minLength", "string", [
-            "length",
-        ]);
-        return {
-            kind: "minLength",
-            value: parse_number(identifier, text),
-        };
-    },
-    maxLength: (identifier, metadata, text, output) => {
-        validate(identifier, metadata, output, "maxLength", "string", [
-            "length",
-        ]);
-        return {
-            kind: "maxLength",
-            value: parse_number(identifier, text),
-        };
-    },
-};
+            // Ignore arbitrary @format values in the internal metadata,
+            // these are currently only supported on the typia.application() API.
+            const value: IMetadataTag.IFormat["value"] | undefined =
+                FORMATS.get(str);
+            if (value === undefined) return null;
+            return {
+                kind: "format",
+                value,
+            };
+        },
+        pattern: (identifier, metadata, value, output) => {
+            validate(identifier, metadata, output, "pattern", "string", [
+                "format",
+            ]);
+            return {
+                kind: "pattern",
+                value,
+            };
+        },
+        length: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "length", "string", [
+                "minLength",
+                "maxLength",
+            ]);
+            return {
+                kind: "length",
+                value: parse_number(identifier, text),
+            };
+        },
+        minLength: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "minLength", "string", [
+                "length",
+            ]);
+            return {
+                kind: "minLength",
+                value: parse_number(identifier, text),
+            };
+        },
+        maxLength: (identifier, metadata, text, output) => {
+            validate(identifier, metadata, output, "maxLength", "string", [
+                "length",
+            ]);
+            return {
+                kind: "maxLength",
+                value: parse_number(identifier, text),
+            };
+        },
+    };
+}
 
 function parse_number(identifier: () => string, str: string): number {
     const value: number = Number(str);
@@ -206,7 +233,17 @@ function parse_number(identifier: () => string, str: string): number {
 }
 
 const LABEL = "Error on typia.MetadataTagFactory.generate()";
-const FORMATS = new Set(["uuid", "email", "url", "mobile", "ipv4", "ipv6"]);
+const FORMATS: Map<string, IMetadataTag.IFormat["value"]> = new Map([
+    ["uuid", "uuid"],
+    ["email", "email"],
+    ["url", "url"],
+    ["ipv4", "ipv4"],
+    ["ipv6", "ipv6"],
+    ["date", "date"],
+    ["datetime", "datetime"],
+    ["date-time", "datetime"],
+    ["dateTime", "datetime"],
+]);
 
 const WRONG_TYPE = (
     tag: string,

package/src/factories/TypeFactory.ts

@@ -87,7 +87,7 @@ export namespace TypeFactory {
     function explore_name(name: string, decl: ts.Node): string {
         return ts.isModuleBlock(decl)
             ? explore_name(
-                  `${decl.parent.name.getText()}.${name}`,
+                  `${decl.parent.name.getFullText().trim()}.${name}`,
                   decl.parent.parent,
               )
             : name;

package/src/factories/TypiaFileFactory.ts

@@ -40,7 +40,7 @@ export namespace TypiaFileFactory {
         const program: ts.Program = ts.createProgram(
             await (async () => {
                 const container: string[] = [];
-                await gather(container)(props.input)(props.output);
+                await gather(props)(container)(props.input)(props.output);
                 return container;
             })(),
             config.compilerOptions,
@@ -99,19 +99,22 @@ export namespace TypiaFileFactory {
     };
 
     const gather =
-        (container: string[]) => (from: string) => async (to: string) => {
-            if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
-            const directory: string[] = await fs.promises.readdir(from);
-            for (const file of directory) {
+        (props: IProps) =>
+        (container: string[]) =>
+        (from: string) =>
+        async (to: string) => {
+            if (from === props.output) return;
+            else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
+
+            for (const file of await fs.promises.readdir(from)) {
                 const next: string = path.join(from, file);
                 const stat: fs.Stats = await fs.promises.stat(next);
 
                 if (stat.isDirectory()) {
-                    await gather(container)(next)(path.join(to, file));
+                    await gather(props)(container)(next)(path.join(to, file));
                     continue;
                 } else if (file.substring(file.length - 3) === ".ts")
                     container.push(next);
             }
-            return container;
         };
 }

package/src/functional/$dictionary.ts

@@ -0,0 +1,17 @@
+import { Customizable } from "../typings/Customizable";
+
+export const $dictionary = (() => {
+    const glob: {
+        __typia_custom_validator: Map<
+            `${string}:${keyof Customizable}`,
+            (tagText: string) => (value: any) => boolean
+        >;
+    } =
+        typeof global === "object" &&
+        typeof global.process === "object" &&
+        typeof global.process.versions === "object" &&
+        typeof global.process.versions.node !== "undefined"
+            ? (global as any)
+            : (window as any);
+    return (glob.__typia_custom_validator ??= new Map());
+})();

package/src/functional/$is_custom.ts

@@ -0,0 +1,14 @@
+import { Customizable } from "../typings/Customizable";
+
+import { $dictionary } from "./$dictionary";
+
+export function $is_custom<Type extends keyof Customizable>(
+    name: string,
+    type: Type,
+    text: string,
+    value: Customizable[Type],
+): boolean {
+    const validator = $dictionary.get(`${name}:${type}`);
+    if (validator === undefined) return true;
+    return validator(text)(value);
+}

package/src/functional/$is_date.ts

@@ -0,0 +1,4 @@
+export function $is_date(value: string): boolean {
+    return REGEX.test(value);
+}
+const REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;

package/src/functional/$is_datetime.ts

@@ -0,0 +1,3 @@
+export function $is_datetime(value: string): boolean {
+    return !isNaN(new Date(value).getTime());
+}

package/src/functional/Namespace.ts

@@ -6,6 +6,9 @@ import { $any } from "./$any";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
 import { $is_between } from "./$is_between";
+import { $is_custom } from "./$is_custom";
+import { $is_date } from "./$is_date";
+import { $is_datetime } from "./$is_datetime";
 import { $is_email } from "./$is_email";
 import { $is_ipv4 } from "./$is_ipv4";
 import { $is_ipv6 } from "./$is_ipv6";
@@ -29,6 +32,9 @@ export namespace Namespace {
         is_ipv4: $is_ipv4,
         is_ipv6: $is_ipv6,
         is_between: $is_between,
+        is_date: $is_date,
+        is_datetime: $is_datetime,
+        is_custom: $is_custom,
     });
 
     export const assert = (method: string) => ({

package/src/metadata/IMetadataTag.ts

@@ -1,42 +1,59 @@
 export type IMetadataTag =
-    // ARRAY
-    | IMetadataTag.IItems
-    | IMetadataTag.IMinItems
-    | IMetadataTag.IMaxItems
-    // STRING
-    | IMetadataTag.IFormat
-    | IMetadataTag.IPattern
-    | IMetadataTag.ILength
-    | IMetadataTag.IMinLength
-    | IMetadataTag.IMaxLength
     // NUMBER
-    | IMetadataTag.INumberType
-    | IMetadataTag.IBigintType
+    | IMetadataTag.IType
     | IMetadataTag.IMinimum
     | IMetadataTag.IMaximum
     | IMetadataTag.IExclusiveMinimum
     | IMetadataTag.IExclusiveMaximum
     | IMetadataTag.IMultipleOf
     | IMetadataTag.IStep
-    // BIGINT
-    | IMetadataTag.IBigintType;
+    // STRING
+    | IMetadataTag.IFormat
+    | IMetadataTag.IPattern
+    | IMetadataTag.ILength
+    | IMetadataTag.IMinLength
+    | IMetadataTag.IMaxLength
+    // ARRAY
+    | IMetadataTag.IItems
+    | IMetadataTag.IMinItems
+    | IMetadataTag.IMaxItems;
 
 export namespace IMetadataTag {
     /* -----------------------------------------------------------
-        ARRAY   
+        NUMBER
     ----------------------------------------------------------- */
-    export interface IItems {
-        kind: "items";
+    export interface IType {
+        kind: "type";
+        value: "int" | "uint";
+    }
+
+    export interface IMinimum {
+        kind: "minimum";
         value: number;
     }
 
-    export interface IMinItems {
-        kind: "minItems";
+    export interface IMaximum {
+        kind: "maximum";
         value: number;
     }
 
-    export interface IMaxItems {
-        kind: "maxItems";
+    export interface IExclusiveMinimum {
+        kind: "exclusiveMinimum";
+        value: number;
+    }
+
+    export interface IExclusiveMaximum {
+        kind: "exclusiveMaximum";
+        value: number;
+    }
+
+    export interface IMultipleOf {
+        kind: "multipleOf";
+        value: number;
+    }
+
+    export interface IStep {
+        kind: "step";
         value: number;
     }
 
@@ -45,7 +62,7 @@ export namespace IMetadataTag {
     ----------------------------------------------------------- */
     export interface IFormat {
         kind: "format";
-        value: "uuid" | "email" | "url" | "ipv4" | "ipv6";
+        value: "uuid" | "email" | "url" | "ipv4" | "ipv6" | "date" | "datetime";
     }
 
     export interface IPattern {
@@ -69,61 +86,20 @@ export namespace IMetadataTag {
     }
 
     /* -----------------------------------------------------------
-        NUMBER
+        ARRAY   
     ----------------------------------------------------------- */
-    export interface INumberType {
-        kind: "type";
-        value:
-            | "int"
-            | "uint"
-            | "int32"
-            | "uint32"
-            | "int64"
-            | "uint64"
-            | "float"
-            | "double";
-    }
-
-    export interface IMinimum {
-        kind: "minimum";
-        value: number;
-    }
-
-    export interface IMaximum {
-        kind: "maximum";
-        value: number;
-    }
-
-    export interface IExclusiveMinimum {
-        kind: "exclusiveMinimum";
-        value: number;
-    }
-
-    export interface IExclusiveMaximum {
-        kind: "exclusiveMaximum";
-        value: number;
-    }
-
-    export interface IMultipleOf {
-        kind: "multipleOf";
+    export interface IItems {
+        kind: "items";
         value: number;
     }
 
-    export interface IStep {
-        kind: "step";
+    export interface IMinItems {
+        kind: "minItems";
         value: number;
     }
 
-    /* -----------------------------------------------------------
-        MISCELLANEOUS
-    ----------------------------------------------------------- */
-    export interface IBigintType {
-        kind: "type";
-        value: "int64" | "uint64";
-    }
-
-    export interface ISign {
-        include: boolean;
+    export interface IMaxItems {
+        kind: "maxItems";
         value: number;
     }
 }