typia 4.0.9 → 4.0.10-dev.20230616

package/src/metadata/Metadata.ts

@@ -12,6 +12,7 @@ import { MetadataArray } from "./MetadataArray";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataProperty } from "./MetadataProperty";
+import { MetadataResolved } from "./MetadataResolved";
 import { MetadataTuple } from "./MetadataTuple";
 
 export class Metadata {
@@ -21,7 +22,7 @@ export class Metadata {
     public nullable: boolean;
     public functional: boolean;
 
-    public resolved: Metadata | null;
+    public resolved: MetadataResolved | null;
     public atomics: Atomic.Literal[];
     public constants: MetadataConstant[];
     public templates: Metadata[][];
@@ -207,7 +208,9 @@ export class Metadata {
             templates: meta.templates.map((tpl) =>
                 tpl.map((meta) => this._From(meta, dict)),
             ),
-            resolved: meta.resolved ? this._From(meta.resolved, dict) : null,
+            resolved: meta.resolved
+                ? MetadataResolved._From(meta.resolved, dict)
+                : null,
 
             rest: meta.rest ? this._From(meta.rest, dict) : null,
             arrays: meta.arrays.map((id) => {
@@ -482,8 +485,18 @@ export namespace Metadata {
 
             resolved:
                 x.resolved !== null && y.resolved !== null
-                    ? merge(x.resolved, y.resolved)
-                    : x.resolved || y.resolved,
+                    ? //? merge(x.resolved, y.resolved)
+                      MetadataResolved.create({
+                          original: merge(
+                              x.resolved.original,
+                              y.resolved.original,
+                          ),
+                          returns: merge(
+                              x.resolved.returns,
+                              y.resolved.returns,
+                          ),
+                      })
+                    : x.resolved ?? y.resolved,
             atomics: [...new Set([...x.atomics, ...y.atomics])],
             constants: [...x.constants],
             templates: x.templates.slice(),

package/src/metadata/MetadataArray.ts

@@ -11,7 +11,7 @@ export class MetadataArray {
     public readonly index: number | null;
 
     /**
-     * @internal
+     * @hidden
      */
     private constructor(props: ClassProperties<MetadataArray>) {
         this.name = props.name;
@@ -36,6 +36,9 @@ export class MetadataArray {
         });
     }
 
+    /**
+     * @internal
+     */
     public static create(props: ClassProperties<MetadataArray>): MetadataArray {
         return new MetadataArray(props);
     }

package/src/metadata/MetadataResolved.ts

@@ -0,0 +1,51 @@
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataResolved } from "./IMetadataResolved";
+import { Metadata } from "./Metadata";
+
+export class MetadataResolved {
+    public readonly original: Metadata;
+    public readonly returns: Metadata;
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataResolved>) {
+        this.original = props.original;
+        this.returns = props.returns;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From(
+        props: IMetadataResolved,
+        dict: IMetadataDictionary,
+    ): MetadataResolved {
+        return this.create({
+            original: Metadata._From(props.original, dict),
+            returns: Metadata._From(props.returns, dict),
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataResolved>,
+    ): MetadataResolved {
+        return new MetadataResolved(props);
+    }
+
+    public getName(): string {
+        return this.returns.getName();
+    }
+
+    public toJSON(): IMetadataResolved {
+        return {
+            original: this.original.toJSON(),
+            returns: this.returns.toJSON(),
+        };
+    }
+}

package/src/programmers/CloneProgrammer.ts

@@ -153,7 +153,7 @@ export namespace CloneProgrammer {
                     value: () =>
                         decode_to_json(project)(config)(importer)(
                             input,
-                            meta.resolved!,
+                            meta.resolved!.returns,
                             explore,
                         ),
                 });

package/src/programmers/RandomProgrammer.ts

@@ -263,7 +263,11 @@ export namespace RandomProgrammer {
             // INSTANCE TYPES
             if (meta.resolved)
                 expressions.push(
-                    decode(importer)(explore)(meta.resolved, tags, comments),
+                    decode(importer)(explore)(
+                        meta.resolved.returns,
+                        tags,
+                        comments,
+                    ),
                 );
             for (const array of meta.arrays)
                 expressions.push(