typia 3.5.0-dev.20230126 → 3.5.0-dev.20230212

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -18,10 +18,6 @@ export const iterate_metadata_native =
 
         const simple = SIMPLES.get(name);
         if (simple && validator(simple)) {
-            if (FORBIDDEN.has(name))
-                throw new Error(
-                    `Error on typia.metadata(): typia does not allow "${name}" class type. Use "${name.toLowerCase()}" type instead.`,
-                );
             ArrayUtil.set(meta.natives, name, (str) => str);
             return true;
         }
@@ -210,7 +206,6 @@ const GENERICS: Array<IClassInfo & { name: string }> = [
         return: "boolean",
     })),
 }));
-const FORBIDDEN: Set<string> = new Set(["Bolean", "Number", "String"]);
 
 interface IClassInfo {
     name?: string;

package/src/functional/$is_between.ts

@@ -0,0 +1,7 @@
+export function $is_between(
+    value: number,
+    minimum: number,
+    maximum: number,
+): boolean {
+    return minimum <= value && value <= maximum;
+}

package/src/metadata/IMetadataTag.ts

@@ -10,16 +10,14 @@ export type IMetadataTag =
     | IMetadataTag.IMinLength
     | IMetadataTag.IMaxLength
     // NUMBER
-    | IMetadataTag.INumberType
+    | IMetadataTag.IType
     | IMetadataTag.IRange
     | IMetadataTag.IMinimum
     | IMetadataTag.IMaximum
     | IMetadataTag.IExclusiveMinimum
     | IMetadataTag.IExclusiveMaximum
     | IMetadataTag.IMultipleOf
-    | IMetadataTag.IStep
-    // BIGINT
-    | IMetadataTag.IBigintType;
+    | IMetadataTag.IStep;
 
 export namespace IMetadataTag {
     /* -----------------------------------------------------------
@@ -73,17 +71,9 @@ export namespace IMetadataTag {
     /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */
-    export interface INumberType {
+    export interface IType {
         kind: "type";
-        value:
-            | "int"
-            | "uint"
-            | "int32"
-            | "uint32"
-            | "int64"
-            | "uint64"
-            | "float"
-            | "double";
+        value: "int" | "uint";
     }
 
     export interface IRange {
@@ -125,11 +115,6 @@ export namespace IMetadataTag {
     /* -----------------------------------------------------------
         MISCELLANEOUS
     ----------------------------------------------------------- */
-    export interface IBigintType {
-        kind: "type";
-        value: "int64" | "uint64";
-    }
-
     export interface ISign {
         include: boolean;
         value: number;

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;
@@ -832,8 +829,8 @@ Object.assign(validateParse, validate);
  * than the native `JSON.stringify()` function. The 5x faster principle is because
  * it writes an optimized JSON conversion plan, only for the type `T`.
  *
- * For reference, this `typia.stringify()` does not validate the input value type. It
- * just believes that the input value is following the type `T`. Therefore, if you
+ * For reference, this `typia.stringify()` does not validate the input value type.
+ * It just believes that the input value is following the type `T`. Therefore, if you
  * can't ensure the input value type, it would be better to call one of below functions
  * instead.
  *
@@ -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;
@@ -992,7 +990,7 @@ export function isStringify<T>(input: T): string | null;
  * `typia.isStringify()` is a combination function of {@link is} and
  * {@link stringify}. Therefore, it converts an input value to JSON
  * (JavaScript Object Notation) string, with type checking.
- *
+ *f
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * `null` value. Otherwise, there's no problem on the `input` value, JSON string would
  * be returned.
@@ -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,246 @@ 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.
+ *
+ * For reference, this `typia.prune()` function does not validate the input value type.
+ * It just believes that the input value is following the type `T`. Therefore, if you
+ * can't ensure the input value type, it would better to call one of below functions
+ * instead.
+ *
+ *   - {@link assertPrune}
+ *   - {@link isPrune}
+ *   - {@link validatePrune}
+ *
+ * @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 function throws(
+        props: Pick<TypeGuardError.IProps, "expected" | "value">,
+    ): void {
+        throw new TypeGuardError({
+            ...props,
+            method: "typia.prune",
+        });
+    }
+}
+
+/**
+ * Prune, erase superfluous properties, with type assertion.
+ *
+ * `typia.assertPrune()` is a combination function of {@link assert} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type assertion.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it throws an
+ * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, its
+ * every superfluous properties would be removed, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to assert and prune
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function assertPrune<T>(input: T): T;
+
+/**
+ * Prune, erase superfluous properties, with type assertion.
+ *
+ * `typia.assertPrune()` is a combination function of {@link assert} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type assertion.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it throws an
+ * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, its
+ * every superfluous properties would be removed, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to assert and prune
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function assertPrune<T>(input: unknown): T;
+
+/**
+ * @internal
+ */
+export function assertPrune<T>(): unknown {
+    halt("assertPrune");
+}
+
+/**
+ * @internal
+ */
+export namespace assertPrune {
+    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 join = $join;
+    export const every = $every;
+    export const guard = $guard("typia.assertPrune");
+}
+
+/**
+ * Prune, erase superfluous properties, with type checking.
+ *
+ * `typia.assertPrune()` is a combination function of {@link is} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type checking.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * `false` value. Otherwise, there's no problem on the `input` value, it returns
+ * `true` after removing every superfluous properties, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to check and prune
+ * @returns Whether the parametric value is following the type `T` or not
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function isPrune<T>(input: T): input is T;
+
+/**
+ * Prune, erase superfluous properties, with type checking.
+ *
+ * `typia.assertPrune()` is a combination function of {@link is} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type checking.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * `false` value. Otherwise, there's no problem on the `input` value, it returns
+ * `true` after removing every superfluous properties, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to check and prune
+ * @returns Whether the parametric value is following the type `T` or not
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function isPrune<T>(input: unknown): input is T;
+
+/**
+ * @internal
+ */
+export function isPrune(): never {
+    halt("isPrune");
+}
+
+/**
+ * @internal
+ */
+export namespace isPrune {
+    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 function throws(
+        props: Pick<TypeGuardError.IProps, "expected" | "value">,
+    ): void {
+        throw new TypeGuardError({
+            ...props,
+            method: "typia.prune",
+        });
+    }
+}
+
+/**
+ * Prune, erase superfluous properties, with type validation.
+ *
+ * `typia.validatePrune()` is a combination function of {@link validate} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type validation.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's
+ * no problem on the `input` value, it returns {@link IValidation.ISucess} value after
+ * removing every superfluous properties, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to validate and prune
+ * @returns Validation result
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function validatePrune<T>(input: T): IValidation<T>;
+
+/**
+ * Prune, erase superfluous properties, with type validation.
+ *
+ * `typia.validatePrune()` is a combination function of {@link validate} and {@link prune}.
+ * Therefore, it removes every superfluous properties from the `input` object including
+ * nested objects, with type validation.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's
+ * no problem on the `input` value, it returns {@link IValidation.ISucess} value after
+ * removing every superfluous properties, including nested objects.
+ *
+ * @template T Type of the input value
+ * @param input Target instance to validate and prune
+ * @returns Validation result
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function validatePrune<T>(input: unknown): IValidation<T>;
+
+/**
+ * @internal
+ */
+export function validatePrune<T>(): IValidation<T> {
+    halt("validatePrune");
+}
+Object.assign(validatePrune, prune);
+Object.assign(validatePrune, validate);
+
 /* ===========================================================
     FACTORY FUNCTIONS
         - BASIC VALIDATORS
@@ -1505,7 +1744,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>(): (
@@ -1525,17 +1764,125 @@ Object.assign(createValidateStringify, validateStringify);
 /* -----------------------------------------------------------
     MISCELLANEOUS
 ----------------------------------------------------------- */
+/**
+ * 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 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<Types extends unknown[]>(): IMetadataApplication;
+export function createPrune<T extends object>(): (input: T) => void {
+    halt("createPrune");
+}
+Object.assign(createPrune, prune);
+
+/**
+ * Creates a reusable {@link isPrune} 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 createAssertPrune(): never;
+
+/**
+ * Creates a resuable {@link isPrune} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `isPrune` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createAssertPrune<T extends object>(): (input: T) => T;
 
 /**
  * @internal
  */
-export function metadata(): never {
-    halt("metadata");
+export function createAssertPrune<T extends object>(): (input: T) => T {
+    halt("createAssertPrune");
+}
+Object.assign(createAssertPrune, assertPrune);
+
+/**
+ * Creates a reusable {@link isPrune} 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 createIsPrune(): never;
+
+/**
+ * Creates a resuable {@link isPrune} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `isPrune` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createIsPrune<T extends object>(): (input: T) => input is T;
+
+/**
+ * @internal
+ */
+export function createIsPrune<T extends object>(): (input: T) => input is T {
+    halt("createIsPrune");
+}
+Object.assign(createIsPrune, isPrune);
+
+/**
+ * Creates a reusable {@link validatePrune} 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 createValidatePrune(): never;
+
+/**
+ * Creates a resuable {@link validatePrune} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `validatePrune` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createValidatePrune<T extends object>(): (
+    input: T,
+) => IValidation<T>;
+
+/**
+ * @internal
+ */
+export function createValidatePrune<T extends object>(): (
+    input: T,
+) => IValidation<T> {
+    halt("createValidatePrune");
 }
+Object.assign(createValidatePrune, validatePrune);
 
 /**
  * @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) =>