typia 5.2.6 → 5.3.0-dev.20231112

package/src/functional/Namespace.ts

@@ -1,168 +1,175 @@
-import { NamingConvention } from "../utils/NamingConvention";
-import { RandomGenerator } from "../utils/RandomGenerator";
-
-import { IValidation } from "../IValidation";
-import { TypeGuardError } from "../TypeGuardError";
-import { $HeadersReader } from "./$HeadersReader";
-import { $ParameterReader } from "./$ParameterReader";
-import { $ProtobufReader } from "./$ProtobufReader";
-import { $ProtobufSizer } from "./$ProtobufSizer";
-import { $ProtobufWriter } from "./$ProtobufWriter";
-import { $QueryReader } from "./$QueryReader";
-import { $any } from "./$any";
-import { $convention } from "./$convention";
-import { $every } from "./$every";
-import { $guard } from "./$guard";
-import { $is_between } from "./$is_between";
-import { $join } from "./$join";
-import { $number } from "./$number";
-import { $report } from "./$report";
-import { $rest } from "./$rest";
-import { $is_bigint_string } from "./$stoll";
-import { $string } from "./$string";
-import { $strlen } from "./$strlen";
-import { $tail } from "./$tail";
-
-/**
- * @internal
- */
-export namespace Namespace {
-    export const is = () => ({
-        is_between: $is_between,
-        is_bigint_string: $is_bigint_string,
-    });
-
-    export const assert = (method: string) => ({
-        ...is(),
-        join: $join,
-        every: $every,
-        guard: $guard(`typia.${method}`),
-        predicate: (
-            matched: boolean,
-            exceptionable: boolean,
-            closure: () => Omit<TypeGuardError.IProps, "method">,
-        ): boolean => {
-            if (matched === false && exceptionable === true)
-                throw new TypeGuardError({
-                    ...closure(),
-                    method: `typia.${method}`,
-                });
-            return matched;
-        },
-    });
-
-    export const validate = () => ({
-        ...is(),
-        join: $join,
-        report: $report,
-        predicate:
-            (res: IValidation) =>
-            (
-                matched: boolean,
-                exceptionable: boolean,
-                closure: () => IValidation.IError,
-            ) => {
-                // CHECK FAILURE
-                if (matched === false && exceptionable === true)
-                    (() => {
-                        res.success &&= false;
-                        const errorList = (res as IValidation.IFailure).errors;
-
-                        // TRACE ERROR
-                        const error = closure();
-                        if (errorList.length) {
-                            const last = errorList[errorList.length - 1]!.path;
-                            if (
-                                last.length >= error.path.length &&
-                                last.substring(0, error.path.length) ===
-                                    error.path
-                            )
-                                return;
-                        }
-                        errorList.push(error);
-                        return;
-                    })();
-                return matched;
-            },
-    });
-
-    export namespace json {
-        export const stringify = (method: string) => ({
-            ...is(),
-            number: $number,
-            string: $string,
-            tail: $tail,
-            rest: $rest,
-            throws: $throws(`json.${method}`),
-        });
-    }
-
-    export namespace protobuf {
-        export const decode = (method: string) => ({
-            ...is(),
-            Reader: $ProtobufReader,
-            throws: $throws(`protobuf.${method}`),
-        });
-
-        export const encode = (method: string) => ({
-            ...is(),
-            Sizer: $ProtobufSizer,
-            Writer: $ProtobufWriter,
-            strlen: $strlen,
-            throws: $throws(method),
-        });
-    }
-
-    export namespace http {
-        export const query = () => $QueryReader;
-        export const headers = () => $HeadersReader;
-        export const parameter = () => $ParameterReader;
-    }
-
-    export namespace misc {
-        export const clone = (method: string) => ({
-            ...is(),
-            throws: $throws(`misc.${method}`),
-            any: $any,
-        });
-
-        export const prune = (method: string) => ({
-            ...is(),
-            throws: $throws(`misc.${method}`),
-        });
-    }
-
-    export namespace notations {
-        export const camel = (method: string) => ({
-            ...base(method),
-            any: $convention(NamingConvention.camel),
-        });
-        export const pascal = (method: string) => ({
-            ...base(method),
-            any: $convention(NamingConvention.pascal),
-        });
-        export const snake = (method: string) => ({
-            ...base(method),
-            any: $convention(NamingConvention.snake),
-        });
-
-        const base = (method: string) => ({
-            ...is(),
-            throws: $throws(`notations.${method}`),
-        });
-    }
-
-    export const random = () => ({
-        generator: RandomGenerator,
-        pick: RandomGenerator.pick,
-    });
-
-    const $throws =
-        (method: string) =>
-        (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {
-            throw new TypeGuardError({
-                ...props,
-                method: `typia.${method}`,
-            });
-        };
-}
+import { NamingConvention } from "../utils/NamingConvention";
+import { RandomGenerator } from "../utils/RandomGenerator";
+
+import { IValidation } from "../IValidation";
+import { TypeGuardError } from "../TypeGuardError";
+import { $HeadersReader } from "./$HeadersReader";
+import { $ParameterReader } from "./$ParameterReader";
+import { $ProtobufReader } from "./$ProtobufReader";
+import { $ProtobufSizer } from "./$ProtobufSizer";
+import { $ProtobufWriter } from "./$ProtobufWriter";
+import { $QueryReader } from "./$QueryReader";
+import { $any } from "./$any";
+import { $convention } from "./$convention";
+import { $every } from "./$every";
+import { $from } from "./$from";
+import { $guard } from "./$guard";
+import { $is_between } from "./$is_between";
+import { $join } from "./$join";
+import { $number } from "./$number";
+import { $report } from "./$report";
+import { $rest } from "./$rest";
+import { $is_bigint_string } from "./$stoll";
+import { $string } from "./$string";
+import { $strlen } from "./$strlen";
+import { $tail } from "./$tail";
+
+/**
+ * @internal
+ */
+export namespace Namespace {
+    export const is = () => ({
+        is_between: $is_between,
+        is_bigint_string: $is_bigint_string,
+    });
+
+    export const assert = (method: string) => ({
+        ...is(),
+        join: $join,
+        every: $every,
+        guard: $guard(`typia.${method}`),
+        predicate: (
+            matched: boolean,
+            exceptionable: boolean,
+            closure: () => Omit<TypeGuardError.IProps, "method">,
+        ): boolean => {
+            if (matched === false && exceptionable === true)
+                throw new TypeGuardError({
+                    ...closure(),
+                    method: `typia.${method}`,
+                });
+            return matched;
+        },
+    });
+
+    export const validate = () => ({
+        ...is(),
+        join: $join,
+        report: $report,
+        predicate:
+            (res: IValidation) =>
+            (
+                matched: boolean,
+                exceptionable: boolean,
+                closure: () => IValidation.IError,
+            ) => {
+                // CHECK FAILURE
+                if (matched === false && exceptionable === true)
+                    (() => {
+                        res.success &&= false;
+                        const errorList = (res as IValidation.IFailure).errors;
+
+                        // TRACE ERROR
+                        const error = closure();
+                        if (errorList.length) {
+                            const last = errorList[errorList.length - 1]!.path;
+                            if (
+                                last.length >= error.path.length &&
+                                last.substring(0, error.path.length) ===
+                                    error.path
+                            )
+                                return;
+                        }
+                        errorList.push(error);
+                        return;
+                    })();
+                return matched;
+            },
+    });
+
+    export namespace json {
+        export const stringify = (method: string) => ({
+            ...is(),
+            number: $number,
+            string: $string,
+            tail: $tail,
+            rest: $rest,
+            throws: $throws(`json.${method}`),
+        });
+    }
+
+    export namespace protobuf {
+        export const decode = (method: string) => ({
+            ...is(),
+            Reader: $ProtobufReader,
+            throws: $throws(`protobuf.${method}`),
+        });
+
+        export const encode = (method: string) => ({
+            ...is(),
+            Sizer: $ProtobufSizer,
+            Writer: $ProtobufWriter,
+            strlen: $strlen,
+            throws: $throws(method),
+        });
+    }
+
+    export namespace reflect {
+        export const metadata = () => ({
+            from: $from,
+        });
+    }
+
+    export namespace http {
+        export const query = () => $QueryReader;
+        export const headers = () => $HeadersReader;
+        export const parameter = () => $ParameterReader;
+    }
+
+    export namespace misc {
+        export const clone = (method: string) => ({
+            ...is(),
+            throws: $throws(`misc.${method}`),
+            any: $any,
+        });
+
+        export const prune = (method: string) => ({
+            ...is(),
+            throws: $throws(`misc.${method}`),
+        });
+    }
+
+    export namespace notations {
+        export const camel = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.camel),
+        });
+        export const pascal = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.pascal),
+        });
+        export const snake = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.snake),
+        });
+
+        const base = (method: string) => ({
+            ...is(),
+            throws: $throws(`notations.${method}`),
+        });
+    }
+
+    export const random = () => ({
+        generator: RandomGenerator,
+        pick: RandomGenerator.pick,
+    });
+
+    const $throws =
+        (method: string) =>
+        (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {
+            throw new TypeGuardError({
+                ...props,
+                method: `typia.${method}`,
+            });
+        };
+}

package/src/module.ts

@@ -1,7 +1,5 @@
 import { Namespace } from "./functional/Namespace";
 
-import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
-
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
@@ -11,6 +9,7 @@ export * as json from "./json";
 export * as misc from "./misc";
 export * as notations from "./notations";
 export * as protobuf from "./protobuf";
+export * as reflect from "./reflect";
 export * as tags from "./tags";
 
 export * from "./schemas/json/IJsonApplication";
@@ -425,23 +424,6 @@ export function random(): never {
 }
 Object.assign(random, Namespace.random());
 
-/**
- * @internal
- */
-export function metadata(): never;
-
-/**
- * @internal
- */
-export function metadata<Types extends unknown[]>(): IMetadataApplication;
-
-/**
- * @internal
- */
-export function metadata(): never {
-    halt("metadata");
-}
-
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */