typia 3.7.0-dev.20230310 → 3.7.0-dev.20230401

package/src/metadata/Metadata.ts

@@ -205,7 +205,6 @@ export class Metadata {
     public empty(): boolean {
         return this.bucket() === 0 || this.size() === 0;
     }
-
     public size(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -224,7 +223,6 @@ export class Metadata {
             this.maps.length
         );
     }
-
     public bucket(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -241,7 +239,6 @@ export class Metadata {
             (this.maps.length ? 1 : 0)
         );
     }
-
     public isConstant(): boolean {
         return this.bucket() === (this.constants.length ? 1 : 0);
     }
@@ -511,15 +508,15 @@ function getName(metadata: Metadata): string {
         elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
 
     // ARRAY
-    if (metadata.rest !== null)
-        elements.push(`Rest<${metadata.rest.getName()}>`);
+    if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
     for (const tuple of metadata.tuples)
         elements.push(`[${tuple.map((elem) => elem.getName()).join(", ")}]`);
     for (const array of metadata.arrays)
         elements.push(`Array<${array.getName()}>`);
 
     // OBJECT
-    for (const object of metadata.objects) elements.push(object.name);
+    for (const object of metadata.objects)
+        elements.push(`Resolve<${object.name}>`);
     if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
 
     // RETURNS

package/src/module.ts

@@ -1,8 +1,11 @@
+import { $dictionary } from "./functional/$dictionary";
 import { Namespace } from "./functional/Namespace";
 
 import { IMetadataApplication } from "./metadata/IMetadataApplication";
 import { IJsonApplication } from "./schemas/IJsonApplication";
 
+import { Customizable } from "./typings/Customizable";
+
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
@@ -20,7 +23,6 @@ export * from "./TypeGuardError";
     SINGLE FUNCTIONS
         - BASIC VALIDATORS
         - STRICT VALIDATORS
-        - PROTOCOL BUFFER FUNCTIONS
         - JSON FUNCTIONS
         - MISCELLANEOUS
 ==============================================================
@@ -411,15 +413,42 @@ export function validateEquals(): never {
 }
 Object.assign(validateEquals, Namespace.validate());
 
-/* -----------------------------------------------------------
-    PROTOCOL BUFFER FUNCTIONS
------------------------------------------------------------ */
-export function message(): never;
-export function message<T>(): string;
-
-export function message(): string {
-    halt("message");
-}
+/**
+ * Add validation tag.
+ *
+ * If you want to add a custom validation logic, you can use this function.
+ *
+ * ```ts
+ * typia.addValidationTag("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.addValidationTag("dollar")("string")(
+ *     () => (value: string) => value.startsWith("$"),
+ * );
+ * ```
+ *
+ * @param name Name of tag (`@name`)
+ * @returns Currying function
+ */
+export const addValidationTag =
+    (name: string) =>
+    /**
+     * @param type Type of target value
+     */
+    <Type extends keyof Customizable>(type: Type) =>
+    /**
+     * @param closure Closure function for custom validation
+     */
+    (closure: (text: string) => (value: Customizable[Type]) => boolean) => {
+        const key = `${name}:${type}` as const;
+        if (!$dictionary.has(key)) $dictionary.set(key, closure);
+    };
 
 /* -----------------------------------------------------------
     JSON FUNCTIONS

package/src/programmers/AssertProgrammer.ts

@@ -30,6 +30,30 @@ export namespace AssertProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_guard_call(importer)(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
+                                    ),
+                                ),
+                            ),
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                     combiner: combiner(equals)(importer),
                     joiner: joiner(equals)(importer),
                     success: ts.factory.createTrue(),

package/src/programmers/CheckerProgrammer.ts

@@ -16,6 +16,7 @@ import { IProject } from "../transformers/IProject";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
@@ -39,6 +40,9 @@ export namespace CheckerProgrammer {
         numeric: boolean;
         combiner: IConfig.Combiner;
         decoder?: FeatureProgrammer.Decoder<Metadata, ts.Expression>;
+        atomist: (
+            explore: IExplore,
+        ) => (check: ICheckEntry) => (input: ts.Expression) => ts.Expression;
         joiner: IConfig.IJoiner;
         success: ts.Expression;
     }
@@ -217,6 +221,7 @@ export namespace CheckerProgrammer {
         meta: Metadata,
         explore: IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => ts.Expression;
 
     /**
@@ -232,6 +237,7 @@ export namespace CheckerProgrammer {
         meta: Metadata,
         explore: IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => ts.Expression;
 
     /**
@@ -246,7 +252,8 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression {
             if (meta.any) return config.success;
 
@@ -315,20 +322,25 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.atomic(meta)(type) === false) continue;
                 else if (type === "number")
                     binaries.push({
-                        expression: check_number(project, config.numeric)(
-                            input,
-                            tags,
-                        ),
+                        expression: config.atomist(explore)(
+                            check_number(project, config.numeric)(importer)(
+                                metaTags,
+                            )(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else if (type === "bigint")
                     binaries.push({
-                        expression: check_bigint(input, tags),
+                        expression: config.atomist(explore)(
+                            check_bigint(importer)(metaTags)(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else if (type === "string")
                     binaries.push({
-                        expression: check_string(importer)(input, tags),
+                        expression: config.atomist(explore)(
+                            check_string(importer)(metaTags)(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else
@@ -342,11 +354,11 @@ export namespace CheckerProgrammer {
             if (meta.templates.length)
                 if (AtomicPredicator.template(meta))
                     binaries.push({
-                        expression: check_template(importer)(
-                            input,
-                            meta.templates,
-                            tags,
-                        ),
+                        expression: config.atomist(explore)(
+                            check_template(importer)(metaTags)(jsDocTags)(
+                                meta.templates,
+                            )(input),
+                        )(input),
                         combined: false,
                     });
 
@@ -394,6 +406,7 @@ export namespace CheckerProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                     );
             }
@@ -418,6 +431,7 @@ export namespace CheckerProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                     );
             }
@@ -425,7 +439,11 @@ export namespace CheckerProgrammer {
             // ARRAYS AND TUPLES
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
-                    check_array(input, meta.tuples.length === 0 ? tags : []),
+                    config.atomist(explore)(
+                        check_array(importer)(
+                            meta.tuples.length === 0 ? metaTags : [],
+                        )(jsDocTags)(input),
+                    )(input),
                     [...meta.tuples, ...meta.arrays]
                         .map((elem) =>
                             Array.isArray(elem)
@@ -445,7 +463,8 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
                 else if (meta.arrays.some((elem) => elem.any)) install(null);
@@ -459,7 +478,8 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
                 else
@@ -468,7 +488,8 @@ export namespace CheckerProgrammer {
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
             }
@@ -580,6 +601,7 @@ export namespace CheckerProgrammer {
             tuple: Array<Metadata>,
             explore: IExplore,
             tagList: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression {
             const binaries: ts.Expression[] = tuple
                 .filter((meta) => meta.rest === null)
@@ -595,6 +617,7 @@ export namespace CheckerProgrammer {
                                 : `[${index}]`,
                         },
                         tagList,
+                        jsDocTags,
                     ),
                 );
             const rest: ts.Expression | null =
@@ -621,6 +644,7 @@ export namespace CheckerProgrammer {
                               start: tuple.length - 1,
                           },
                           tagList,
+                          jsDocTags,
                       )
                     : null;
 
@@ -728,12 +752,14 @@ export namespace CheckerProgrammer {
                         entry[0],
                         { ...explore, postfix: `${explore.postfix}[0]` },
                         [],
+                        [],
                     ),
                     func(
                         ts.factory.createElementAccessExpression(input, 1),
                         entry[1],
                         { ...explore, postfix: `${explore.postfix}[1]` },
                         [],
+                        [],
                     ),
                 );
             },
@@ -759,6 +785,7 @@ export namespace CheckerProgrammer {
                     }),
                     explore,
                     [],
+                    [],
                 ),
             empty: config.success,
             success: config.success,
@@ -806,39 +833,41 @@ export namespace CheckerProgrammer {
         importer: FunctionImporter,
     ) =>
         UnionExplorer.array_or_tuple({
-            checker: (front, target, explore, tags, array) => {
-                if (Array.isArray(target))
-                    return check_union_tuple(project, config, importer)(
-                        front,
-                        target,
-                        explore,
-                        tags,
-                        array,
-                    );
-                const condition = decode(project, config, importer)(
-                    front,
-                    target,
-                    explore,
-                    tags,
-                );
-                const length = check_array_length(array, tags);
-                return length !== null
-                    ? ts.factory.createBitwiseAnd(condition, length)
-                    : condition;
-            },
-            decoder: (input, target, explore, tags) =>
+            checker: (front, target, explore, tags, jsDocTags, array) =>
+                Array.isArray(target)
+                    ? check_union_tuple(project, config, importer)(
+                          front,
+                          target,
+                          explore,
+                          tags,
+                          jsDocTags,
+                          array,
+                      )
+                    : config.atomist(explore)({
+                          expression: decode(project, config, importer)(
+                              front,
+                              target,
+                              explore,
+                              tags,
+                              jsDocTags,
+                          ),
+                          tags: check_array_length(tags)(array),
+                      })(array),
+            decoder: (input, target, explore, tags, jsDocTags) =>
                 Array.isArray(target)
                     ? decode_tuple(project, config, importer, true)(
                           input,
                           target,
                           explore,
                           tags,
+                          jsDocTags,
                       )
                     : decode_array(project, config, importer, true)(
                           input,
                           target,
                           explore,
                           tags,
+                          jsDocTags,
                       ),
             empty: config.success,
             success: config.success,

package/src/programmers/CloneProgrammer.ts

@@ -109,6 +109,7 @@ export namespace CloneProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(input, tuple, explore),
@@ -128,6 +129,7 @@ export namespace CloneProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                 });
 

package/src/programmers/FeatureProgrammer.ts

@@ -6,6 +6,7 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
 import { MetadataObject } from "../metadata/MetadataObject";
@@ -202,7 +203,8 @@ export namespace FeatureProgrammer {
             input: ts.Expression,
             target: T,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): Output;
     }
 
@@ -241,6 +243,7 @@ export namespace FeatureProgrammer {
                     postfix: '""',
                 },
                 [],
+                [],
             );
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
@@ -350,6 +353,7 @@ export namespace FeatureProgrammer {
                         postfix: "",
                     },
                     [],
+                    [],
                 ),
             );
     }
@@ -363,7 +367,8 @@ export namespace FeatureProgrammer {
         combiner: (
             input: ts.Expression,
             arrow: ts.ArrowFunction,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ) => ts.Expression,
     ) {
         const rand: string = importer.increment().toString();
@@ -381,7 +386,8 @@ export namespace FeatureProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
         ) => {
             const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                 undefined,
@@ -406,10 +412,11 @@ export namespace FeatureProgrammer {
                             explore.postfix,
                         )(rand),
                     },
-                    tags,
+                    metaTags,
+                    jsDocTags,
                 ),
             );
-            return combiner(input, arrow, tags);
+            return combiner(input, arrow, metaTags, jsDocTags);
         };
     }
 

package/src/programmers/IsProgrammer.ts

@@ -27,6 +27,11 @@ export namespace IsProgrammer {
             numeric: OptionPredicator.numeric({
                 numeric: options?.numeric,
             }),
+            atomist: () => (entry) => () =>
+                [
+                    entry.expression,
+                    ...entry.tags.map((tag) => tag.expression),
+                ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {
                 const initial: ts.TrueLiteral | ts.FalseLiteral =
                     type === "and"
@@ -105,7 +110,7 @@ export namespace IsProgrammer {
         })(importer);
         config.trace = equals;
 
-        config.decoder = (input, target, explore, tags) => {
+        config.decoder = (input, target, explore, tags, jsDocTags) => {
             if (
                 target.size() === 1 &&
                 target.objects.length === 1 &&
@@ -137,6 +142,7 @@ export namespace IsProgrammer {
                 target,
                 explore,
                 tags,
+                jsDocTags,
             );
         };
 

package/src/programmers/PruneProgrammer.ts

@@ -88,6 +88,7 @@ export namespace PruneProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(input, tuple, explore),
@@ -107,6 +108,7 @@ export namespace PruneProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                 });
 

package/src/programmers/RandomProgrammer.ts

@@ -344,10 +344,7 @@ export namespace RandomProgrammer {
         (importer: FunctionImporter) =>
         (tags: IMetadataTag[]): ts.Expression => {
             for (const t of tags)
-                if (
-                    t.kind === "format" &&
-                    ["uuid", "email", "url", "ipv4", "ipv6"].includes(t.value)
-                )
+                if (t.kind === "format")
                     return ts.factory.createCallExpression(
                         COALESCE(importer)(t.value),
                         undefined,

package/src/programmers/StringifyProgrammer.ts

@@ -172,6 +172,7 @@ export namespace StringifyProgrammer {
                                     partial,
                                     explore,
                                     [],
+                                    [],
                                 ),
                             value: () =>
                                 decode_atomic(project, importer)(
@@ -200,6 +201,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_atomic(project, importer)(
@@ -222,6 +224,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_constant_string(project, importer)(
@@ -246,6 +249,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_atomic(project, importer)(
@@ -275,6 +279,7 @@ export namespace StringifyProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(
@@ -311,6 +316,7 @@ export namespace StringifyProgrammer {
                                   from: "array",
                               },
                               [],
+                              [],
                           );
 
                 unions.push({

package/src/programmers/ValidateProgrammer.ts

@@ -31,6 +31,30 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_report_call(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
+                                    ),
+                                ),
+                            ),
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                     combiner: combine(equals)(importer),
                     joiner: joiner(equals)(importer),
                     success: ts.factory.createTrue(),

package/src/programmers/helpers/ICheckEntry.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+
+export interface ICheckEntry {
+    expression: ts.Expression;
+    tags: ICheckEntry.ITag[];
+}
+export namespace ICheckEntry {
+    export interface ITag {
+        expected: string;
+        expression: ts.Expression;
+    }
+}