typia 5.2.4 → 5.2.5

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

@@ -126,6 +126,34 @@ export const emplace_metadata_object =
             const key: Metadata = analyzer(index.keyType)(null);
             const value: Metadata = analyzer(index.type)({});
 
+            if (
+                key.atomics.length +
+                    key.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    key.templates.length +
+                    key.natives.filter(
+                        (type) =>
+                            type === "Boolean" ||
+                            type === "BigInt" ||
+                            type === "Number" ||
+                            type === "String",
+                    ).length !==
+                key.size()
+            )
+                errors.push({
+                    name: key.getName(),
+                    explore: {
+                        top: false,
+                        object: obj,
+                        property: "[key]",
+                        nested: null,
+                        escaped: false,
+                        aliased: false,
+                    },
+                    messages: [],
+                });
+
             // INSERT WITH REQUIRED CONFIGURATION
             insert(key)(value)(
                 index.declaration?.parent

package/src/functional/$convention.ts

@@ -1,40 +1,40 @@
-export const $convention = (rename: (str: string) => string) => {
-    const main = (input: any): any => {
-        if (typeof input === "object")
-            if (input === null) return null;
-            else if (Array.isArray(input)) return input.map(main);
-            else if (
-                input instanceof Boolean ||
-                input instanceof BigInt ||
-                input instanceof Number ||
-                input instanceof String
-            )
-                return input.valueOf();
-            else if (input instanceof Date) return new Date(input);
-            else if (
-                input instanceof Uint8Array ||
-                input instanceof Uint8ClampedArray ||
-                input instanceof Uint16Array ||
-                input instanceof Uint32Array ||
-                input instanceof BigUint64Array ||
-                input instanceof Int8Array ||
-                input instanceof Int16Array ||
-                input instanceof Int32Array ||
-                input instanceof BigInt64Array ||
-                input instanceof Float32Array ||
-                input instanceof Float64Array ||
-                input instanceof DataView
-            )
-                return input;
-            else return object(input);
-        return input;
-    };
-    const object = (input: Record<string, any>) =>
-        Object.fromEntries(
-            Object.entries(input).map(([key, value]) => [
-                rename(key),
-                main(value),
-            ]),
-        );
-    return main;
-};
+export const $convention = (rename: (str: string) => string) => {
+    const main = (input: any): any => {
+        if (typeof input === "object")
+            if (input === null) return null;
+            else if (Array.isArray(input)) return input.map(main);
+            else if (
+                input instanceof Boolean ||
+                input instanceof BigInt ||
+                input instanceof Number ||
+                input instanceof String
+            )
+                return input.valueOf();
+            else if (input instanceof Date) return new Date(input);
+            else if (
+                input instanceof Uint8Array ||
+                input instanceof Uint8ClampedArray ||
+                input instanceof Uint16Array ||
+                input instanceof Uint32Array ||
+                input instanceof BigUint64Array ||
+                input instanceof Int8Array ||
+                input instanceof Int16Array ||
+                input instanceof Int32Array ||
+                input instanceof BigInt64Array ||
+                input instanceof Float32Array ||
+                input instanceof Float64Array ||
+                input instanceof DataView
+            )
+                return input;
+            else return object(input);
+        return input;
+    };
+    const object = (input: Record<string, any>) =>
+        Object.fromEntries(
+            Object.entries(input).map(([key, value]) => [
+                rename(key),
+                main(value),
+            ]),
+        );
+    return main;
+};

package/src/functional/$stoll.ts

@@ -0,0 +1,8 @@
+export const $is_bigint_string = (str: string): boolean => {
+    try {
+        BigInt(str);
+        return true;
+    } catch {
+        return false;
+    }
+};

package/src/functional/Namespace.ts

@@ -1,164 +1,168 @@
-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 { $string } from "./$string";
-import { $strlen } from "./$strlen";
-import { $tail } from "./$tail";
-
-/**
- * @internal
- */
-export namespace Namespace {
-    export const is = () => ({
-        is_between: $is_between,
-    });
-
-    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) => ({
-            Reader: $ProtobufReader,
-            throws: $throws(`protobuf.${method}`),
-        });
-
-        export const encode = (method: string) => ({
-            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 { $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}`,
+            });
+        };
+}