typia 3.5.0-dev.20230125 → 3.5.0-dev.20230211

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,5 +1,6 @@
 import { $every } from "./functional/$every";
 import { $guard } from "./functional/$guard";
+import { $is_between } from "./functional/$is_between";
 import { $is_email } from "./functional/$is_email";
 import { $is_ipv4 } from "./functional/$is_ipv4";
 import { $is_ipv6 } from "./functional/$is_ipv6";
@@ -29,9 +30,8 @@ export * from "./IValidation";
     SINGLE FUNCTIONS
         - BASIC VALIDATORS
         - STRICT VALIDATORS
-        - PROTOCOL BUFFER FUNCTIONS
         - JSON FUNCTIONS
-        - MISC
+        - MISCELLANEOUS
 ==============================================================
     BASIC VALIDATORS
 ----------------------------------------------------------- */
@@ -97,6 +97,7 @@ export namespace assert {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const join = $join;
     export const every = $every;
@@ -224,6 +225,7 @@ export namespace is {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 }
 
 /**
@@ -292,6 +294,7 @@ export namespace validate {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const join = $join;
     export const report = $report;
@@ -396,6 +399,7 @@ export namespace assertEquals {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const join = $join;
     export const every = $every;
@@ -483,6 +487,7 @@ export namespace equals {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
     export const join = $join;
 }
 
@@ -554,6 +559,7 @@ export namespace validateEquals {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
     export const join = $join;
 
     export const report = validate.report;
@@ -589,16 +595,6 @@ export namespace validateEquals {
         };
 }
 
-/* -----------------------------------------------------------
-    PROTOCOL BUFFER FUNCTIONS
------------------------------------------------------------ */
-export function message(): never;
-export function message<T>(): string;
-
-export function message(): string {
-    halt("message");
-}
-
 /* -----------------------------------------------------------
     JSON FUNCTIONS
 ----------------------------------------------------------- */
@@ -721,6 +717,7 @@ export namespace assertParse {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const join = $join;
     export const every = $every;
@@ -937,6 +934,7 @@ export namespace assertStringify {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const number = $number;
     export const string = $string;
@@ -1025,6 +1023,7 @@ export namespace isStringify {
     export const is_url = $is_url;
     export const is_ipv4 = $is_ipv4;
     export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
 
     export const number = $number;
     export const string = $string;
@@ -1091,6 +1090,64 @@ export function validateStringify(): IValidation<string> {
 Object.assign(validateStringify, validate);
 Object.assign(validateStringify, stringify);
 
+/* -----------------------------------------------------------
+    MISCELLANEOUS
+----------------------------------------------------------- */
+/**
+ * @internal
+ */
+export function metadata<Types extends unknown[]>(): IMetadataApplication;
+
+/**
+ * @internal
+ */
+export function metadata(): never {
+    halt("metadata");
+}
+
+/**
+ * Prune, erase superfluous properties.
+ *
+ * Remove every superfluous properties from the `input` object, even including nested
+ * objects. Note that, as every superfluous properties would be deleted, you never can
+ * read those superfluous properties after calling this `prune()` function.
+ *
+ * @template T Type of the input value
+ * @param input target instance to prune
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function prune<T extends object>(input: T): void;
+
+/**
+ * @internal
+ */
+export function prune(): never {
+    halt("prune");
+}
+
+/**
+ * @internal
+ */
+export namespace prune {
+    export const is_uuid = $is_uuid;
+    export const is_email = $is_email;
+    export const is_url = $is_url;
+    export const is_ipv4 = $is_ipv4;
+    export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
+
+    export const rest = $rest;
+    export function throws(
+        props: Pick<TypeGuardError.IProps, "expected" | "value">,
+    ): void {
+        throw new TypeGuardError({
+            ...props,
+            method: "typia.prune",
+        });
+    }
+}
+
 /* ===========================================================
     FACTORY FUNCTIONS
         - BASIC VALIDATORS
@@ -1505,7 +1562,7 @@ export function createValidateStringify(): never;
  *
  * @template T Type of the input value
  * @returns A reusable `validateStringify` function
- *
+
  * @author Jeongho Nam - https://github.com/samchon
  */
 export function createValidateStringify<T>(): (
@@ -1526,16 +1583,33 @@ Object.assign(createValidateStringify, validateStringify);
     MISCELLANEOUS
 ----------------------------------------------------------- */
 /**
- * @internal
+ * Creates a reusable {@link prune} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
  */
-export function metadata<Types extends unknown[]>(): IMetadataApplication;
+export function createPrune(): never;
+
+/**
+ * Creates a resuable {@link prune} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `prune` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createPrune<T extends object>(): (input: T) => void;
 
 /**
  * @internal
  */
-export function metadata(): never {
-    halt("metadata");
+export function createPrune<T extends object>(): (input: T) => void {
+    halt("createPrune");
 }
+Object.assign(createPrune, prune);
 
 /**
  * @internal

package/src/programmers/AssertProgrammer.ts

@@ -284,7 +284,7 @@ export namespace AssertProgrammer {
                 return IsProgrammer.CONFIG({
                     object: assert_object(equals)(importer),
                     numeric: true,
-                }).combiner(explore);
+                })(importer).combiner(explore);
 
             const path: string = explore.postfix
                 ? `path + ${explore.postfix}`
@@ -354,6 +354,7 @@ export namespace AssertProgrammer {
         check_object({
             equals,
             assert: true,
+            undefined: true,
             reduce: ts.factory.createLogicalAnd,
             positive: ts.factory.createTrue(),
             superfluous: (value) =>
@@ -377,7 +378,7 @@ export namespace AssertProgrammer {
                     ),
                     expr,
                 ),
-        });
+        })(importer);
 
     const joiner =
         (equals: boolean) =>

package/src/programmers/CheckerProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataObject } from "../metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
+import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
@@ -36,7 +37,7 @@ export namespace CheckerProgrammer {
         equals: boolean;
         numeric: boolean;
         combiner: IConfig.Combiner;
-        decoder?: FeatureProgrammer.Decoder<Metadata>;
+        decoder?: FeatureProgrammer.Decoder<Metadata, ts.Expression>;
         joiner: IConfig.IJoiner;
         success: ts.Expression;
     }
@@ -53,7 +54,10 @@ export namespace CheckerProgrammer {
             };
         }
         export interface IJoiner {
-            object(entries: IExpressionEntry[]): ts.Expression;
+            object(
+                input: ts.Expression,
+                entries: IExpressionEntry[],
+            ): ts.Expression;
             array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
             tuple?(exprs: ts.Expression[]): ts.Expression;
 
@@ -246,6 +250,7 @@ export namespace CheckerProgrammer {
             //----
             // CHECK OPTIONAL
             //----
+            // @todo -> should be elaborated
             const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
 
             // NULLABLE
@@ -288,12 +293,14 @@ export namespace CheckerProgrammer {
             //----
             // CONSTANT VALUES
             for (const constant of meta.constants)
-                for (const val of constant.values)
-                    add(true, getConstantValue(val));
+                if (AtomicPredicator.constant(meta)(constant.type))
+                    for (const val of constant.values)
+                        add(true, getConstantValue(val));
 
             // ATOMIC VALUES
             for (const type of meta.atomics)
-                if (type === "number")
+                if (AtomicPredicator.atomic(meta)(type) === false) continue;
+                else if (type === "number")
                     binaries.push({
                         expression: check_number(project, config.numeric)(
                             input,
@@ -320,14 +327,15 @@ export namespace CheckerProgrammer {
 
             // TEMPLATE LITERAL VALUES
             if (meta.templates.length)
-                binaries.push({
-                    expression: check_template(importer)(
-                        input,
-                        meta.templates,
-                        tags,
-                    ),
-                    combined: false,
-                });
+                if (AtomicPredicator.template(meta))
+                    binaries.push({
+                        expression: check_template(importer)(
+                            input,
+                            meta.templates,
+                            tags,
+                        ),
+                        combined: false,
+                    });
 
             // NATIVE CLASSES
             for (const native of meta.natives)

package/src/programmers/FeatureProgrammer.ts

@@ -21,29 +21,135 @@ export namespace FeatureProgrammer {
     /* -----------------------------------------------------------
         PARAMETERS
     ----------------------------------------------------------- */
-    export interface IConfig {
+    export interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
+        /**
+         * Prefix name of functions for specific object types.
+         */
         functors: string;
+
+        /**
+         * Prefix name of functions for union object types.
+         */
         unioners: string;
+
+        /**
+         * Whether to archive access path or not.
+         */
         path: boolean;
+
+        /**
+         * Whether to trace exception or not.
+         */
         trace: boolean;
-        initializer: Initializer;
-        decoder: Decoder<Metadata>;
+
+        /**
+         * Initializer of metadata.
+         */
+        initializer(
+            project: IProject,
+            type: ts.Type,
+        ): [MetadataCollection, Metadata];
+
+        /**
+         * Decoder, station of every types.
+         */
+        decoder: Decoder<Metadata, Output>;
+
+        /**
+         * Object configurator.
+         */
         objector: IConfig.IObjector;
+
+        /**
+         * Generator of functions for object types.
+         */
         generator?: Partial<IConfig.IGenerator>;
     }
     export namespace IConfig {
         export interface IObjector {
-            checker: Decoder<Metadata>;
-            decoder: Decoder<MetadataObject>;
-            joiner: ObjectJoiner;
-            unionizer: Decoder<MetadataObject[]>;
-            failure: (
+            /**
+             * Type checker when union object type comes.
+             */
+            checker: Decoder<Metadata, ts.Expression>;
+
+            /**
+             * Decoder, function call expression generator of specific typed objects.
+             */
+            decoder: Decoder<MetadataObject, ts.Expression>;
+
+            /**
+             * Joiner of expressions from properties.
+             */
+            joiner(
+                input: ts.Expression,
+                entries: IExpressionEntry[],
+                parent: MetadataObject,
+            ): ts.ConciseBody;
+
+            /**
+             * Union type specificator.
+             *
+             * Expression of an algorithm specifying object type and calling
+             * the `decoder` function of the specified object type.
+             */
+            unionizer: Decoder<MetadataObject[], ts.Expression>;
+
+            /**
+             * Handler of union type specification failure.
+             *
+             * @param value Expression of input parameter
+             * @param expected Expected type name
+             * @param explore Exploration info
+             * @returns Statement of failure
+             */
+            failure(
                 value: ts.Expression,
                 expected: string,
                 explore?: IExplore,
-            ) => ts.Statement;
-            is?: (exp: ts.Expression) => ts.Expression;
-            required?: (exp: ts.Expression) => ts.Expression;
+            ): ts.Statement;
+
+            /**
+             * Transformer of type checking expression by discrimination.
+             *
+             * When an object type has been specified by a discrimination without full
+             * iteration, the `unionizer` will decode the object instance after
+             * the last type checking.
+             *
+             * In such circumtance, you can transform the last type checking function.
+             *
+             * @param exp Current expression about type checking
+             * @returns Transformed expression
+             * @deprecated
+             */
+            is?(exp: ts.Expression): ts.Expression;
+
+            /**
+             * Transformer of non-undefined type checking by discrimination.
+             *
+             * When specifying an union type of objects, `typia` tries to find
+             * descrimination way just by checking only one property type.
+             * If succeeded to find the discrimination way, `typia` will check the target
+             * property type and in the checking, non-undefined type checking would be
+             * done.
+             *
+             * In such process, you can transform the non-undefined type checking.
+             *
+             * @param exp
+             * @returns Transformed expression
+             * @deprecated
+             */
+            required?(exp: ts.Expression): ts.Expression;
+
+            /**
+             * Conditon wrapper when unable to specify any object type.
+             *
+             * When failed to specify an object type through discrimination, full
+             * iteration type checking would be happend. In such circumstance, you
+             * can wrap the condition with additional function.
+             *
+             * @param condition Current condition
+             * @returns A function wrapped current condition
+             */
             full?: (
                 condition: ts.Expression,
             ) => (
@@ -53,10 +159,20 @@ export namespace FeatureProgrammer {
             ) => ts.Expression;
         }
         export interface IGenerator {
+            /**
+             *
+             * @param col
+             */
             functors(col: MetadataCollection): ts.VariableStatement[];
+
+            /**
+             *
+             * @param col
+             */
             unioners(col: MetadataCollection): ts.VariableStatement[];
         }
     }
+
     export interface IExplore {
         tracable: boolean;
         source: "top" | "object";
@@ -65,24 +181,30 @@ export namespace FeatureProgrammer {
         start?: number;
     }
 
-    export interface Initializer {
-        (project: IProject, type: ts.Type): [MetadataCollection, Metadata];
-    }
-    export interface Decoder<T> {
+    export interface Decoder<
+        T,
+        Output extends ts.ConciseBody = ts.ConciseBody,
+    > {
         (
             input: ts.Expression,
             target: T,
             explore: IExplore,
             tags: IMetadataTag[],
-        ): ts.Expression;
-    }
-    export interface ObjectJoiner {
-        (entries: IExpressionEntry[], parent: MetadataObject): ts.ConciseBody;
+        ): Output;
     }
 
     /* -----------------------------------------------------------
         GENERATORS
     ----------------------------------------------------------- */
+    /**
+     * Generates a decoder function for a specific type.
+     *
+     * @param project Project configuration
+     * @param config Detailed configuration for programming
+     * @param importer Function importer
+     * @param addition Generator of additinal statements in the top of function
+     * @returns Currying function generating type decoder function
+     */
     export const generate =
         (
             project: IProject,
@@ -96,7 +218,7 @@ export namespace FeatureProgrammer {
             const [collection, meta] = config.initializer(project, type);
 
             // ITERATE OVER ALL METADATA
-            const output: ts.Expression = config.decoder(
+            const output: ts.ConciseBody = config.decoder(
                 ValueFactory.INPUT(),
                 meta,
                 {
@@ -130,7 +252,9 @@ export namespace FeatureProgrammer {
                         ...(added || []),
                         ...functors,
                         ...unioners,
-                        ts.factory.createReturnStatement(output),
+                        ...(ts.isBlock(output)
+                            ? output.statements
+                            : [ts.factory.createReturnStatement(output)]),
                     ],
                     true,
                 ),
@@ -170,6 +294,7 @@ export namespace FeatureProgrammer {
                 undefined,
                 undefined,
                 config.objector.joiner(
+                    ts.factory.createIdentifier("input"),
                     feature_object_entries(config)(obj)(
                         ts.factory.createIdentifier("input"),
                     ),