typia 5.2.7-dev.20231109 → 5.3.0-dev.20231117

package/src/schemas/metadata/Metadata.ts

@@ -1,22 +1,17 @@
 import { ClassProperties } from "../../typings/ClassProperties";
-import { Writable } from "../../typings/Writable";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
 
 import { IMetadata } from "./IMetadata";
-import { IMetadataCollection } from "./IMetadataCollection";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArray } from "./MetadataArray";
-import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTuple } from "./MetadataTuple";
-import { MetadataTupleType } from "./MetadataTupleType";
 
 export class Metadata {
     public any: boolean;
@@ -86,7 +81,7 @@ export class Metadata {
      * @internal
      */
     public static initialize(parentResolved: boolean = false): Metadata {
-        const meta: Metadata = this.create({
+        const meta: Metadata = Metadata.create({
             any: false,
             nullable: false,
             required: true,
@@ -120,10 +115,7 @@ export class Metadata {
             functional: this.functional,
 
             atomics: this.atomics.map((a) => a.toJSON()),
-            constants: this.constants.map((c) => ({
-                type: c.type,
-                values: c.values.slice() as any,
-            })),
+            constants: this.constants.map((c) => c.toJSON()),
             templates: this.templates.map((tpl) =>
                 tpl.map((meta) => meta.toJSON()),
             ),
@@ -150,85 +142,24 @@ export class Metadata {
         };
     }
 
-    public static from(
-        meta: IMetadata,
-        collection: IMetadataCollection,
-    ): Metadata {
-        const dict: IMetadataDictionary = {
-            objects: new Map(
-                collection.objects.map((obj) => [
-                    obj.name,
-                    MetadataObject._From_without_properties(obj),
-                ]),
-            ),
-            aliases: new Map(
-                collection.aliases.map((alias) => [
-                    alias.name,
-                    MetadataAlias._From_without_value(alias),
-                ]),
-            ),
-            arrays: new Map(
-                collection.arrays.map((arr) => [
-                    arr.name,
-                    MetadataArrayType._From_without_value(arr),
-                ]),
-            ),
-            tuples: new Map(
-                collection.tuples.map((tpl) => [
-                    tpl.name,
-                    MetadataTupleType._From_without_elements(tpl),
-                ]),
-            ),
-        };
-
-        for (const obj of collection.objects) {
-            const initialized = dict.objects.get(obj.name)!;
-            initialized.properties.push(
-                ...obj.properties.map((prop) =>
-                    MetadataProperty._From(prop, dict),
-                ),
-            );
-        }
-        for (const alias of collection.aliases)
-            Writable(dict.aliases.get(alias.name)!).value = this._From(
-                alias.value,
-                dict,
-            );
-        for (const array of collection.arrays)
-            Writable(dict.arrays.get(array.name)!).value = this._From(
-                array.value,
-                dict,
-            );
-        for (const tuple of collection.tuples)
-            Writable(dict.tuples.get(tuple.name)!).elements =
-                tuple.elements.map((elem) => this._From(elem, dict));
-
-        return this._From(meta, dict);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From(meta: IMetadata, dict: IMetadataDictionary): Metadata {
-        return this.create({
+    public static from(meta: IMetadata, dict: IMetadataDictionary): Metadata {
+        return Metadata.create({
             any: meta.any,
             required: meta.required,
             optional: meta.optional,
             nullable: meta.nullable,
             functional: meta.functional,
 
-            constants: meta.constants.slice(),
-            atomics: meta.atomics.map((a) =>
-                MetadataAtomic.create({ type: a.type, tags: a.tags }),
-            ),
+            constants: meta.constants.map(MetadataConstant.from),
+            atomics: meta.atomics.map(MetadataAtomic.from),
             templates: meta.templates.map((tpl) =>
-                tpl.map((meta) => this._From(meta, dict)),
+                tpl.map((meta) => this.from(meta, dict)),
             ),
             escaped: meta.escaped
-                ? MetadataEscaped._From(meta.escaped, dict)
+                ? MetadataEscaped.from(meta.escaped, dict)
                 : null,
 
-            rest: meta.rest ? this._From(meta.rest, dict) : null,
+            rest: meta.rest ? this.from(meta.rest, dict) : null,
             arrays: meta.arrays.map((ref) => {
                 const type = dict.arrays.get(ref.name);
                 if (type === undefined)
@@ -269,10 +200,10 @@ export class Metadata {
             }),
 
             natives: meta.natives.slice(),
-            sets: meta.sets.map((meta) => this._From(meta, dict)),
+            sets: meta.sets.map((meta) => this.from(meta, dict)),
             maps: meta.maps.map((entry) => ({
-                key: this._From(entry.key, dict),
-                value: this._From(entry.value, dict),
+                key: this.from(entry.key, dict),
+                value: this.from(entry.value, dict),
             })),
         });
     }
@@ -565,10 +496,11 @@ export namespace Metadata {
             const target: MetadataConstant = ArrayUtil.take(
                 output.constants,
                 (elem) => elem.type === constant.type,
-                () => ({
-                    type: constant.type,
-                    values: [],
-                }),
+                () =>
+                    MetadataConstant.create({
+                        type: constant.type,
+                        values: [],
+                    }),
             );
             for (const value of constant.values)
                 ArrayUtil.add(target.values, value);

package/src/schemas/metadata/MetadataAlias.ts

@@ -38,7 +38,7 @@ export class MetadataAlias {
      * @internal
      */
     public static _From_without_value(props: Omit<IMetadataAlias, "value">) {
-        return this.create({
+        return MetadataAlias.create({
             name: props.name,
             value: null!,
             description: props.description,

package/src/schemas/metadata/MetadataApplication.ts

@@ -0,0 +1,44 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataApplication } from "./IMetadataApplication";
+import { Metadata } from "./Metadata";
+import { MetadataComponents } from "./MetadataComponents";
+
+export class MetadataApplication {
+    public readonly metadatas: Metadata[];
+    public readonly components: MetadataComponents;
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataApplication>) {
+        this.metadatas = props.metadatas;
+        this.components = props.components;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataApplication>,
+    ): MetadataApplication {
+        return new MetadataApplication(props);
+    }
+
+    public static from(app: IMetadataApplication): MetadataApplication {
+        const components: MetadataComponents = MetadataComponents.from(
+            app.components,
+        );
+        const metadatas: Metadata[] = app.metadatas.map((metadata) =>
+            Metadata.from(metadata, components.dictionary),
+        );
+        return MetadataApplication.create({ metadatas, components });
+    }
+
+    public toJSON(): IMetadataApplication {
+        return {
+            metadatas: this.metadatas.map((metadata) => metadata.toJSON()),
+            components: this.components.toJSON(),
+        };
+    }
+}

package/src/schemas/metadata/MetadataArrayType.ts

@@ -27,7 +27,7 @@ export class MetadataArrayType {
     public static _From_without_value(
         props: Omit<IMetadataArrayType, "value">,
     ): MetadataArrayType {
-        return this.create({
+        return MetadataArrayType.create({
             name: props.name,
             value: null!,
             index: props.index,

package/src/schemas/metadata/MetadataAtomic.ts

@@ -23,6 +23,27 @@ export class MetadataAtomic {
         return new MetadataAtomic(props);
     }
 
+    public static from(json: IMetadataAtomic): MetadataAtomic {
+        return MetadataAtomic.create({
+            type: json.type,
+            tags: json.tags.map((row) =>
+                row.map((tag) => ({
+                    target: tag.target,
+                    name: tag.name,
+                    kind: tag.kind,
+                    value:
+                        typeof tag.value === "object" &&
+                        tag.value?.type === "bigint" &&
+                        typeof tag.value.value === "string"
+                            ? BigInt(tag.value.value)
+                            : tag.value,
+                    validate: tag.validate,
+                    exclusive: tag.exclusive,
+                })),
+            ),
+        });
+    }
+
     public getName(): string {
         return (this.name_ ??= (() => {
             if (this.tags.length === 0) return this.type;
@@ -49,7 +70,13 @@ export class MetadataAtomic {
                     target: tag.target,
                     name: tag.name,
                     kind: tag.kind,
-                    value: tag.value,
+                    value:
+                        typeof tag.value === "bigint"
+                            ? {
+                                  type: "bigint",
+                                  value: tag.value.toString(),
+                              }
+                            : tag.value,
                     validate: tag.validate,
                     exclusive: tag.exclusive,
                 })),

package/src/schemas/metadata/MetadataComponents.ts

@@ -0,0 +1,98 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { Writable } from "../../typings/Writable";
+
+import { IMetadataComponents } from "./IMetadataComponents";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { Metadata } from "./Metadata";
+import { MetadataAlias } from "./MetadataAlias";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataComponents {
+    public readonly aliases: MetadataAlias[];
+    public readonly objects: MetadataObject[];
+    public readonly arrays: MetadataArrayType[];
+    public readonly tuples: MetadataTupleType[];
+    public readonly dictionary: IMetadataDictionary;
+
+    private constructor(props: ClassProperties<MetadataComponents>) {
+        this.aliases = props.aliases;
+        this.objects = props.objects;
+        this.arrays = props.arrays;
+        this.tuples = props.tuples;
+        this.dictionary = props.dictionary;
+    }
+
+    public static from(json: IMetadataComponents): MetadataComponents {
+        // INITIALIZE COMPONENTS
+        const dictionary: IMetadataDictionary = {
+            objects: new Map(
+                json.objects.map((obj) => [
+                    obj.name,
+                    MetadataObject._From_without_properties(obj),
+                ]),
+            ),
+            aliases: new Map(
+                json.aliases.map((alias) => [
+                    alias.name,
+                    MetadataAlias._From_without_value(alias),
+                ]),
+            ),
+            arrays: new Map(
+                json.arrays.map((arr) => [
+                    arr.name,
+                    MetadataArrayType._From_without_value(arr),
+                ]),
+            ),
+            tuples: new Map(
+                json.tuples.map((tpl) => [
+                    tpl.name,
+                    MetadataTupleType._From_without_elements(tpl),
+                ]),
+            ),
+        };
+
+        // CONSTRUCT METADATA OF THEM
+        for (const obj of json.objects)
+            dictionary.objects
+                .get(obj.name)!
+                .properties.push(
+                    ...obj.properties.map((prop) =>
+                        MetadataProperty.from(prop, dictionary),
+                    ),
+                );
+        for (const alias of json.aliases)
+            Writable(dictionary.aliases.get(alias.name)!).value = Metadata.from(
+                alias.value,
+                dictionary,
+            );
+        for (const array of json.arrays)
+            Writable(dictionary.arrays.get(array.name)!).value = Metadata.from(
+                array.value,
+                dictionary,
+            );
+        for (const tuple of json.tuples)
+            Writable(dictionary.tuples.get(tuple.name)!).elements =
+                tuple.elements.map((elem) => Metadata.from(elem, dictionary));
+
+        // FINALIZE
+        return new MetadataComponents({
+            aliases: [...dictionary.aliases.values()],
+            objects: [...dictionary.objects.values()],
+            arrays: [...dictionary.arrays.values()],
+            tuples: [...dictionary.tuples.values()],
+            dictionary,
+        });
+    }
+
+    public toJSON(): IMetadataComponents {
+        return {
+            aliases: this.aliases.map((alias) => alias.toJSON()),
+            objects: this.objects.map((object) => object.toJSON()),
+            arrays: this.arrays.map((array) => array.toJSON()),
+            tuples: this.tuples.map((tuple) => tuple.toJSON()),
+        };
+    }
+}

package/src/schemas/metadata/MetadataConstant.ts

@@ -1,3 +1,46 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
 import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataConstant {
+    public readonly type: "boolean" | "bigint" | "number" | "string";
+    public readonly values: boolean[] | bigint[] | number[] | string[];
+
+    /**
+     * @internal
+     */
+    public tags?: IMetadataTypeTag[][] | undefined;
+
+    private constructor(props: ClassProperties<MetadataConstant>) {
+        this.type = props.type;
+        this.values = props.values;
+        this.tags = props.tags;
+    }
+
+    public static create(
+        props: ClassProperties<MetadataConstant>,
+    ): MetadataConstant {
+        return new MetadataConstant(props);
+    }
+
+    public static from(json: IMetadataConstant): MetadataConstant {
+        return MetadataConstant.create({
+            type: json.type,
+            values:
+                json.type === "bigint"
+                    ? json.values.map((v) => BigInt(v))
+                    : (json.values as any[]),
+        });
+    }
 
-export type MetadataConstant = IMetadataConstant;
+    public toJSON(): IMetadataConstant {
+        return {
+            type: this.type,
+            values:
+                this.type === "bigint"
+                    ? this.values.map((v) => v.toString())
+                    : (this.values as any[]),
+        };
+    }
+}

package/src/schemas/metadata/MetadataEscaped.ts

@@ -19,13 +19,13 @@ export class MetadataEscaped {
     /**
      * @internal
      */
-    public static _From(
+    public static from(
         props: IMetadataEscaped,
         dict: IMetadataDictionary,
     ): MetadataEscaped {
-        return this.create({
-            original: Metadata._From(props.original, dict),
-            returns: Metadata._From(props.returns, dict),
+        return MetadataEscaped.create({
+            original: Metadata.from(props.original, dict),
+            returns: Metadata.from(props.returns, dict),
         });
     }
 

package/src/schemas/metadata/MetadataObject.ts

@@ -37,7 +37,7 @@ export class MetadataObject {
         this.index = props.index;
         this.validated = props.validated;
         this.recursive = props.recursive;
-        this.nullables = [];
+        this.nullables = props.nullables.slice();
 
         this.tagged_ = false;
     }
@@ -57,7 +57,7 @@ export class MetadataObject {
     public static _From_without_properties(
         obj: IMetadataObject,
     ): MetadataObject {
-        return this.create({
+        return MetadataObject.create({
             name: obj.name,
             properties: [],
             description: obj.description,

package/src/schemas/metadata/MetadataProperty.ts

@@ -36,13 +36,10 @@ export class MetadataProperty {
     /**
      * @internal
      */
-    public static _From(
-        property: IMetadataProperty,
-        dict: IMetadataDictionary,
-    ) {
-        return this.create({
-            key: Metadata._From(property.key, dict),
-            value: Metadata._From(property.value, dict),
+    public static from(property: IMetadataProperty, dict: IMetadataDictionary) {
+        return MetadataProperty.create({
+            key: Metadata.from(property.key, dict),
+            value: Metadata.from(property.value, dict),
             description: property.description,
             jsDocTags: property.jsDocTags.slice(),
         });

package/src/schemas/metadata/MetadataTupleType.ts

@@ -33,7 +33,7 @@ export class MetadataTupleType {
     public static _From_without_elements(
         props: Omit<IMetadataTupleType, "elements">,
     ): MetadataTupleType {
-        return this.create({
+        return MetadataTupleType.create({
             name: props.name,
             index: props.index,
             elements: null!,

package/src/transformers/CallExpressionTransformer.ts

@@ -45,7 +45,6 @@ import { JsonIsStringifyTransformer } from "./features/json/JsonIsStringifyTrans
 import { JsonStringifyTransformer } from "./features/json/JsonStringifyTransformer";
 import { JsonValidateParseTransformer } from "./features/json/JsonValidateParseTransformer";
 import { JsonValidateStringifyTransformer } from "./features/json/JsonValidateStringifyTransformer";
-import { MetadataTransformer } from "./features/misc/MetadataTransformer";
 import { MiscAssertCloneTransformer } from "./features/misc/MiscAssertCloneTransformer";
 import { MiscAssertPruneTransformer } from "./features/misc/MiscAssertPruneTransformer";
 import { MiscCloneTransformer } from "./features/misc/MiscCloneTransformer";
@@ -88,6 +87,7 @@ import { ProtobufIsEncodeTransformer } from "./features/protobuf/ProtobufIsEncod
 import { ProtobufMessageTransformer } from "./features/protobuf/ProtobufMessageTransformer";
 import { ProtobufValidateDecodeTransformer } from "./features/protobuf/ProtobufValidateDecodeTransformer";
 import { ProtobufValidateEncodeTransformer } from "./features/protobuf/ProtobufValidateEncodeTransformer";
+import { ReflectMetadataTransformer } from "./features/reflect/ReflectMetadataTransformer";
 
 export namespace CallExpressionTransformer {
     export const transform =
@@ -162,26 +162,40 @@ type Task = (
 const FUNCTORS: Record<string, Record<string, () => Task>> = {
     module: {
         // BASIC
-        assert: () => AssertTransformer.transform(false),
-        assertType: () => AssertTransformer.transform(false),
+        assert: () =>
+            AssertTransformer.transform({ equals: false, guard: false }),
+        assertGuard: () =>
+            AssertTransformer.transform({ equals: false, guard: true }),
+        assertType: () =>
+            AssertTransformer.transform({ equals: false, guard: false }),
         is: () => IsTransformer.transform(false),
         validate: () => ValidateTransformer.transform(false),
 
         // STRICT
-        assertEquals: () => AssertTransformer.transform(true),
+        assertEquals: () =>
+            AssertTransformer.transform({ equals: true, guard: false }),
+        assertGuardEquals: () =>
+            AssertTransformer.transform({ equals: true, guard: true }),
         equals: () => IsTransformer.transform(true),
         validateEquals: () => ValidateTransformer.transform(true),
 
         // RANDOM + INTERNAL
         random: () => RandomTransformer.transform,
-        metadata: () => (P) => () => MetadataTransformer.transform(P),
+        metadata: () => ReflectMetadataTransformer.transform,
 
         // FACTORIES
-        createAssert: () => CreateAssertTransformer.transform(false),
-        createAssertType: () => CreateAssertTransformer.transform(false),
+        createAssert: () =>
+            CreateAssertTransformer.transform({ equals: false, guard: false }),
+        createAssertGuard: () =>
+            CreateAssertTransformer.transform({ equals: false, guard: true }),
+        createAssertType: () =>
+            CreateAssertTransformer.transform({ equals: false, guard: false }),
         createIs: () => CreateIsTransformer.transform(false),
         createValidate: () => CreateValidateTransformer.transform(false),
-        createAssertEquals: () => CreateAssertTransformer.transform(true),
+        createAssertEquals: () =>
+            CreateAssertTransformer.transform({ equals: true, guard: false }),
+        createAssertGuardEquals: () =>
+            CreateAssertTransformer.transform({ equals: true, guard: true }),
         createEquals: () => CreateIsTransformer.transform(true),
         createValidateEquals: () => CreateValidateTransformer.transform(true),
         createRandom: () => CreateRandomTransformer.transform,
@@ -270,6 +284,9 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         createValidateDecode: () =>
             ProtobufCreateValidateDecodeTransformer.transform,
     },
+    reflect: {
+        metadata: () => ReflectMetadataTransformer.transform,
+    },
     misc: {
         literals: () => (project) => () =>
             MiscLiteralsTransformer.transform(project),

package/src/transformers/features/AssertTransformer.ts

@@ -3,9 +3,17 @@ import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace AssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+    export const transform = (props: { equals: boolean; guard: boolean }) =>
+        GenericTransformer.scalar(
+            props.equals
+                ? props.guard
+                    ? "assertGuardEquals"
+                    : "assertEquals"
+                : props.guard
+                ? "assertGuard"
+                : "assert",
+        )(
             (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
+                AssertProgrammer.write(project)(modulo)(props),
         );
 }

package/src/transformers/features/CreateAssertTransformer.ts

@@ -3,11 +3,17 @@ import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateAssertTransformer {
-    export const transform = (equals: boolean) =>
+    export const transform = (props: { equals: boolean; guard: boolean }) =>
         GenericTransformer.factory(
-            equals ? "createAssertEquals" : "createAssert",
+            props.equals
+                ? props.guard
+                    ? "createAssertGuardEquals"
+                    : "createAssertEquals"
+                : props.guard
+                ? "createAssertGuard"
+                : "createAssert",
         )(
             (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
+                AssertProgrammer.write(project)(modulo)(props),
         );
 }

package/src/transformers/features/{misc/MetadataTransformer.ts → reflect/ReflectMetadataTransformer.ts}

@@ -1,8 +1,10 @@
 import ts from "typescript";
 
+import { IdentifierFactory } from "../../../factories/IdentifierFactory";
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
 import { MetadataFactory } from "../../../factories/MetadataFactory";
+import { TypeFactory } from "../../../factories/TypeFactory";
 
 import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
 import { Metadata } from "../../../schemas/metadata/Metadata";
@@ -10,9 +12,10 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 import { IProject } from "../../IProject";
 import { TransformerError } from "../../TransformerError";
 
-export namespace MetadataTransformer {
+export namespace ReflectMetadataTransformer {
     export const transform =
         (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new TransformerError({
@@ -32,7 +35,7 @@ export namespace MetadataTransformer {
             );
             if (types.some((t) => t.isTypeParameter()))
                 throw new TransformerError({
-                    code: "typia.metadata",
+                    code: "typia.reflect.metadata",
                     message: "non-specified generic argument(s).",
                 });
 
@@ -48,7 +51,7 @@ export namespace MetadataTransformer {
                     absorb: true,
                 })(collection)(type);
                 if (result.success === false)
-                    throw TransformerError.from("typia.metadata")(
+                    throw TransformerError.from("typia.reflect.metadata")(
                         result.errors,
                     );
                 return result.data;
@@ -57,8 +60,19 @@ export namespace MetadataTransformer {
             // CONVERT TO PRIMITIVE TYPE
             const app: IMetadataApplication = {
                 metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.toJSON(),
+                components: collection.toJSON(),
             };
-            return LiteralFactory.generate(app);
+            return ts.factory.createCallExpression(
+                IdentifierFactory.access(
+                    ts.factory.createParenthesizedExpression(
+                        ts.factory.createAsExpression(
+                            modulo,
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                )("from"),
+                undefined,
+                [LiteralFactory.generate(app)],
+            );
         };
 }

package/lib/schemas/metadata/IMetadataCollection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IMetadataCollection.js","sourceRoot":"","sources":["../../../src/schemas/metadata/IMetadataCollection.ts"],"names":[],"mappings":""}