typia 3.5.0-dev.20221219 → 3.5.0-dev.20221222

package/src/metadata/MetadataObject.ts

@@ -1,131 +1,131 @@
-import { ClassProperties } from "../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataObject } from "./IMetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
-
-export class MetadataObject {
-    public readonly name: string;
-    public readonly properties: Array<MetadataProperty>;
-    public readonly description: string | undefined;
-    public readonly jsDocTags: IJsDocTagInfo[];
-
-    /**
-     * @internal
-     */
-    public readonly index: number;
-
-    /**
-     * @internal
-     */
-    public validated: boolean;
-
-    /**
-     * @internal
-     */
-    public recursive: boolean;
-
-    /**
-     * @internal
-     */
-    public nullables: boolean[] = [];
-
-    /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-    /**
-     * @hidden
-     */
-    private constructor(props: ClassProperties<MetadataObject>) {
-        this.name = props.name;
-        this.properties = props.properties;
-        this.description = props.description;
-        this.jsDocTags = props.jsDocTags;
-
-        this.index = props.index;
-        this.validated = props.validated;
-        this.recursive = false;
-        this.nullables = [];
-    }
-
-    /**
-     * @internal
-     */
-    public static create(props: ClassProperties<MetadataObject>) {
-        return new MetadataObject(props);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_properties(
-        obj: IMetadataObject,
-    ): MetadataObject {
-        return this.create({
-            name: obj.name,
-            properties: [],
-            description: obj.description,
-            jsDocTags: obj.jsDocTags,
-
-            index: obj.index,
-            validated: obj.validated,
-            recursive: obj.recursive,
-            nullables: obj.nullables.slice(),
-        });
-    }
-
-    /**
-     * @internal
-     */
-    public _Is_simple(): boolean {
-        return (
-            this.properties.length < 4 &&
-            this.properties.every(
-                (property) =>
-                    property.key.isSoleLiteral() &&
-                    property.value.size() === 1 &&
-                    property.value.atomics.length === 1 &&
-                    property.value.nullable === false &&
-                    property.value.required === true,
-            )
-        );
-    }
-
-    public toJSON(): IMetadataObject {
-        return {
-            name: this.name,
-            properties: this.properties.map((property) => property.toJSON()),
-            description: this.description,
-            jsDocTags: this.jsDocTags,
-
-            index: this.index,
-            validated: this.validated,
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
-        };
-    }
-}
-
-/**
- * @internal
- */
-export namespace MetadataObject {
-    export function intersects(x: MetadataObject, y: MetadataObject): boolean {
-        return x.properties.some(
-            (prop) =>
-                y.properties.find((oppo) => prop.key === oppo.key) !==
-                undefined,
-        );
-    }
-
-    export function covers(x: MetadataObject, y: MetadataObject): boolean {
-        return (
-            x.properties.length >= y.properties.length &&
-            x.properties.every(
-                (prop) =>
-                    y.properties.find((oppo) => prop.key === oppo.key) !==
-                    undefined,
-            )
-        );
-    }
-}
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObject } from "./IMetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObject {
+    public readonly name: string;
+    public readonly properties: Array<MetadataProperty>;
+    public readonly description: string | undefined;
+    public readonly jsDocTags: IJsDocTagInfo[];
+
+    /**
+     * @internal
+     */
+    public readonly index: number;
+
+    /**
+     * @internal
+     */
+    public validated: boolean;
+
+    /**
+     * @internal
+     */
+    public recursive: boolean;
+
+    /**
+     * @internal
+     */
+    public nullables: boolean[] = [];
+
+    /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataObject>) {
+        this.name = props.name;
+        this.properties = props.properties;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+
+        this.index = props.index;
+        this.validated = props.validated;
+        this.recursive = false;
+        this.nullables = [];
+    }
+
+    /**
+     * @internal
+     */
+    public static create(props: ClassProperties<MetadataObject>) {
+        return new MetadataObject(props);
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_properties(
+        obj: IMetadataObject,
+    ): MetadataObject {
+        return this.create({
+            name: obj.name,
+            properties: [],
+            description: obj.description,
+            jsDocTags: obj.jsDocTags,
+
+            index: obj.index,
+            validated: obj.validated,
+            recursive: obj.recursive,
+            nullables: obj.nullables.slice(),
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public _Is_simple(): boolean {
+        return (
+            this.properties.length < 4 &&
+            this.properties.every(
+                (property) =>
+                    property.key.isSoleLiteral() &&
+                    property.value.size() === 1 &&
+                    property.value.atomics.length === 1 &&
+                    property.value.nullable === false &&
+                    property.value.required === true,
+            )
+        );
+    }
+
+    public toJSON(): IMetadataObject {
+        return {
+            name: this.name,
+            properties: this.properties.map((property) => property.toJSON()),
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+
+            index: this.index,
+            validated: this.validated,
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}
+
+/**
+ * @internal
+ */
+export namespace MetadataObject {
+    export function intersects(x: MetadataObject, y: MetadataObject): boolean {
+        return x.properties.some(
+            (prop) =>
+                y.properties.find((oppo) => prop.key === oppo.key) !==
+                undefined,
+        );
+    }
+
+    export function covers(x: MetadataObject, y: MetadataObject): boolean {
+        return (
+            x.properties.length >= y.properties.length &&
+            x.properties.every(
+                (prop) =>
+                    y.properties.find((oppo) => prop.key === oppo.key) !==
+                    undefined,
+            )
+        );
+    }
+}

package/src/metadata/MetadataProperty.ts

@@ -1,64 +1,64 @@
-import { ClassProperties } from "../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataProperty } from "./IMetadataProperty";
-import { IMetadataTag } from "./IMetadataTag";
-import { Metadata } from "./Metadata";
-import { MetadataObject } from "./MetadataObject";
-
-export class MetadataProperty {
-    public readonly key: Metadata;
-    public readonly value: Metadata;
-    public readonly description: string | undefined;
-    public readonly tags: IMetadataTag[];
-    public readonly jsDocTags: IJsDocTagInfo[];
-
-    /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-    /**
-     * @hidden
-     */
-    private constructor(props: ClassProperties<MetadataProperty>) {
-        this.key = props.key;
-        this.value = props.value;
-        this.description = props.description;
-        this.tags = props.tags;
-        this.jsDocTags = props.jsDocTags;
-    }
-
-    /**
-     * @internal
-     */
-    public static create(
-        props: ClassProperties<MetadataProperty>,
-    ): MetadataProperty {
-        return new MetadataProperty(props);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From(
-        property: IMetadataProperty,
-        objects: Map<string, MetadataObject>,
-    ) {
-        return this.create({
-            key: Metadata._From(property.key, objects),
-            value: Metadata._From(property.value, objects),
-            description: property.description,
-            tags: property.tags.slice(),
-            jsDocTags: property.jsDocTags.slice(),
-        });
-    }
-
-    public toJSON(): IMetadataProperty {
-        return {
-            key: this.key.toJSON(),
-            value: this.value.toJSON(),
-            description: this.description,
-            tags: this.tags,
-            jsDocTags: this.jsDocTags,
-        };
-    }
-}
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+import { IMetadataTag } from "./IMetadataTag";
+import { Metadata } from "./Metadata";
+import { MetadataObject } from "./MetadataObject";
+
+export class MetadataProperty {
+    public readonly key: Metadata;
+    public readonly value: Metadata;
+    public readonly description: string | undefined;
+    public readonly tags: IMetadataTag[];
+    public readonly jsDocTags: IJsDocTagInfo[];
+
+    /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataProperty>) {
+        this.key = props.key;
+        this.value = props.value;
+        this.description = props.description;
+        this.tags = props.tags;
+        this.jsDocTags = props.jsDocTags;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataProperty>,
+    ): MetadataProperty {
+        return new MetadataProperty(props);
+    }
+
+    /**
+     * @internal
+     */
+    public static _From(
+        property: IMetadataProperty,
+        objects: Map<string, MetadataObject>,
+    ) {
+        return this.create({
+            key: Metadata._From(property.key, objects),
+            value: Metadata._From(property.value, objects),
+            description: property.description,
+            tags: property.tags.slice(),
+            jsDocTags: property.jsDocTags.slice(),
+        });
+    }
+
+    public toJSON(): IMetadataProperty {
+        return {
+            key: this.key.toJSON(),
+            value: this.value.toJSON(),
+            description: this.description,
+            tags: this.tags,
+            jsDocTags: this.jsDocTags,
+        };
+    }
+}

package/src/programmers/ApplicationProgrammer.ts

@@ -1,55 +1,55 @@
-import { Metadata } from "../metadata/Metadata";
-import { IJsonApplication } from "../schemas/IJsonApplication";
-import { IJsonComponents } from "../schemas/IJsonComponents";
-import { IJsonSchema } from "../schemas/IJsonSchema";
-
-import { application_schema } from "./internal/application_schema";
-
-export namespace ApplicationProgrammer {
-    export const AJV_PREFIX = "components#/schemas";
-    export const SWAGGER_PREFIX = "#/components/schemas";
-
-    export interface IOptions {
-        purpose: "swagger" | "ajv";
-        prefix: string;
-    }
-
-    /**
-     * @internal
-     */
-    export namespace IOptions {
-        export function complement(options?: Partial<IOptions>): IOptions {
-            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
-            return {
-                purpose,
-                prefix:
-                    options?.prefix ||
-                    (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
-            };
-        }
-    }
-
-    export function generate(
-        metadatas: Array<Metadata>,
-        options?: Partial<IOptions>,
-    ): IJsonApplication {
-        const fullOptions: IOptions = IOptions.complement(options);
-        const components: IJsonComponents = {
-            schemas: {},
-        };
-        const generator = application_schema(fullOptions)(components)(true);
-
-        return {
-            schemas: metadatas.map((meta, i) => {
-                const schema: IJsonSchema | null = generator(meta, {});
-                if (schema === null)
-                    throw new Error(
-                        `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                    );
-                return schema;
-            }),
-            components,
-            ...fullOptions,
-        };
-    }
-}
+import { Metadata } from "../metadata/Metadata";
+import { IJsonApplication } from "../schemas/IJsonApplication";
+import { IJsonComponents } from "../schemas/IJsonComponents";
+import { IJsonSchema } from "../schemas/IJsonSchema";
+
+import { application_schema } from "./internal/application_schema";
+
+export namespace ApplicationProgrammer {
+    export const AJV_PREFIX = "components#/schemas";
+    export const SWAGGER_PREFIX = "#/components/schemas";
+
+    export interface IOptions {
+        purpose: "swagger" | "ajv";
+        prefix: string;
+    }
+
+    /**
+     * @internal
+     */
+    export namespace IOptions {
+        export function complement(options?: Partial<IOptions>): IOptions {
+            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
+            return {
+                purpose,
+                prefix:
+                    options?.prefix ||
+                    (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
+            };
+        }
+    }
+
+    export function generate(
+        metadatas: Array<Metadata>,
+        options?: Partial<IOptions>,
+    ): IJsonApplication {
+        const fullOptions: IOptions = IOptions.complement(options);
+        const components: IJsonComponents = {
+            schemas: {},
+        };
+        const generator = application_schema(fullOptions)(components)(true);
+
+        return {
+            schemas: metadatas.map((meta, i) => {
+                const schema: IJsonSchema | null = generator(meta, {});
+                if (schema === null)
+                    throw new Error(
+                        `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
+                    );
+                return schema;
+            }),
+            components,
+            ...fullOptions,
+        };
+    }
+}

package/src/programmers/AssertParseProgrammer.ts

@@ -20,7 +20,17 @@ export namespace AssertParseProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/AssertProgrammer.ts

@@ -8,6 +8,7 @@ import { IProject } from "../transformers/IProject";
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 // /* -----------------------------------------------------------
@@ -31,7 +32,7 @@ import { check_object } from "./internal/check_object";
 //                     unioners: "$au",
 //                     path: true,
 //                     trace: true,
-//                     numeric: !!project.options.numeric,
+//                     numeric: OptionPredicator.numeric(project.options),
 //                     equals,
 //                     combiner,
 //                     joiner: joiner(equals)(importer),
@@ -237,7 +238,7 @@ export namespace AssertProgrammer {
                     unioners: "$au",
                     path: true,
                     trace: true,
-                    numeric: !!project.options.numeric,
+                    numeric: OptionPredicator.numeric(project.options),
                     equals,
                     combiner: combiner(equals)(importer),
                     joiner: joiner(equals)(importer),

package/src/programmers/AssertStringifyProgrammer.ts

@@ -21,11 +21,31 @@ export namespace AssertStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(project, modulo)(type),
+                        StringifyProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createCallExpression(

package/src/programmers/CheckerProgrammer.ts

@@ -18,6 +18,7 @@ import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { check_array } from "./internal/check_array";
+import { check_bigint } from "./internal/check_bigint";
 import { check_native } from "./internal/check_native";
 import { check_number } from "./internal/check_number";
 import { check_string } from "./internal/check_string";
@@ -299,6 +300,11 @@ export namespace CheckerProgrammer {
                         ),
                         combined: false,
                     });
+                else if (type === "bigint")
+                    binaries.push({
+                        expression: check_bigint(input, tags),
+                        combined: false,
+                    });
                 else if (type === "string")
                     binaries.push({
                         expression: check_string(importer)(input, tags),