typia 5.0.0-dev.20230823 → 5.0.0-dev.20230824

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -8,10 +8,12 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -26,7 +28,9 @@ import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
 export namespace MiscCloneProgrammer {
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             return FeatureProgrammer.write(project)({
                 ...configure(project)(importer),
                 addition: (collection) => [
@@ -118,8 +122,8 @@ export namespace MiscCloneProgrammer {
             // ANY TYPE
             if (
                 meta.any ||
-                meta.arrays.some((a) => a.value.any) ||
-                meta.tuples.some((t) => t.elements.every((e) => e.any))
+                meta.arrays.some((a) => a.type.value.any) ||
+                meta.tuples.some((t) => t.type.elements.every((e) => e.any))
             )
                 return ts.factory.createCallExpression(
                     importer.use("any"),
@@ -137,19 +141,6 @@ export namespace MiscCloneProgrammer {
             //----
             // LIST UP UNION TYPES
             //----
-            // toJSON() METHOD
-            if (meta.resolved !== null)
-                unions.push({
-                    type: "resolved",
-                    is: () => IsProgrammer.decode_to_json(true)(input),
-                    value: () =>
-                        decode_to_json(project)(config)(importer)(
-                            input,
-                            meta.resolved!.returns,
-                            explore,
-                        ),
-                });
-
             // TUPLES
             for (const tuple of meta.tuples)
                 unions.push({
@@ -195,13 +186,26 @@ export namespace MiscCloneProgrammer {
                 unions.push({
                     type: "set",
                     is: () => ExpressionFactory.isInstanceOf("Set")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    value: () =>
+                        explore_sets(project)(config)(importer)(
+                            input,
+                            meta.sets,
+                            { ...explore, from: "array" },
+                        ),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
                     is: () => ExpressionFactory.isInstanceOf("Map")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    value: () =>
+                        explore_maps(project)(config)(importer)(
+                            input,
+                            meta.maps,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                        ),
                 });
             for (const native of meta.natives)
                 unions.push({
@@ -216,7 +220,7 @@ export namespace MiscCloneProgrammer {
                                   undefined,
                                   undefined,
                               )
-                            : ts.factory.createIdentifier("{}"),
+                            : decode_native(native)(input),
                 });
 
             // OBJECTS
@@ -251,26 +255,6 @@ export namespace MiscCloneProgrammer {
             );
         };
 
-    const decode_to_json =
-        (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
-        (importer: FunctionImporter) =>
-        (
-            input: ts.Expression,
-            resolved: Metadata,
-            explore: FeatureProgrammer.IExplore,
-        ): ts.Expression => {
-            return decode(project)(config)(importer)(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(input)("toJSON"),
-                    undefined,
-                    [],
-                ),
-                resolved,
-                explore,
-            );
-        };
-
     const decode_object = (importer: FunctionImporter) =>
         FeatureProgrammer.decode_object({
             trace: false,
@@ -286,10 +270,12 @@ export namespace MiscCloneProgrammer {
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
-            array.recursive
+            array.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}a${array.index}`),
+                          importer.useLocal(
+                              `${config.prefix}a${array.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -298,14 +284,18 @@ export namespace MiscCloneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
@@ -325,10 +315,12 @@ export namespace MiscCloneProgrammer {
             tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                          importer.useLocal(
+                              `${config.prefix}t${tuple.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -338,7 +330,7 @@ export namespace MiscCloneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -348,7 +340,7 @@ export namespace MiscCloneProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -393,9 +385,204 @@ export namespace MiscCloneProgrammer {
             return CloneJoiner.tuple(children, rest);
         };
 
+    /* -----------------------------------------------------------
+        NATIVE CLASSES
+    ----------------------------------------------------------- */
+    const decode_native = (type: string) => (input: ts.Expression) =>
+        type === "Date" ||
+        type === "Uint8Array" ||
+        type === "Uint8ClampedArray" ||
+        type === "Uint16Array" ||
+        type === "Uint32Array" ||
+        type === "BigUint64Array" ||
+        type === "Int8Array" ||
+        type === "Int16Array" ||
+        type === "Int32Array" ||
+        type === "BigInt64Array" ||
+        type === "Float32Array" ||
+        type === "Float64Array"
+            ? decode_native_copyable(type)(input)
+            : type === "ArrayBuffer" || type === "SharedArrayBuffer"
+            ? decode_native_buffer(type)(input)
+            : type === "DataView"
+            ? decode_native_data_view(input)
+            : ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(type),
+                  undefined,
+                  [],
+              );
+
+    const decode_native_copyable = (type: string) => (input: ts.Expression) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier(type),
+            undefined,
+            [input],
+        );
+
+    const decode_native_buffer =
+        (type: "ArrayBuffer" | "SharedArrayBuffer") => (input: ts.Expression) =>
+            ExpressionFactory.selfCall(
+                ts.factory.createBlock(
+                    [
+                        StatementFactory.constant(
+                            "buffer",
+                            ts.factory.createNewExpression(
+                                ts.factory.createIdentifier(type),
+                                undefined,
+                                [IdentifierFactory.access(input)("byteLength")],
+                            ),
+                        ),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(
+                                    ts.factory.createNewExpression(
+                                        ts.factory.createIdentifier(
+                                            "Uint8Array",
+                                        ),
+                                        undefined,
+                                        [ts.factory.createIdentifier("buffer")],
+                                    ),
+                                )("set"),
+                                undefined,
+                                [
+                                    ts.factory.createNewExpression(
+                                        ts.factory.createIdentifier(
+                                            "Uint8Array",
+                                        ),
+                                        undefined,
+                                        [input],
+                                    ),
+                                ],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createIdentifier("buffer"),
+                        ),
+                    ],
+                    true,
+                ),
+            );
+
+    const decode_native_data_view = (input: ts.Expression) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier("DataView"),
+            undefined,
+            [IdentifierFactory.access(input)("buffer")],
+        );
+
     /* -----------------------------------------------------------
         EXPLORERS FOR UNION TYPES
     ----------------------------------------------------------- */
+    const explore_sets =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            sets: Metadata[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.set({
+                    checker: IsProgrammer.decode(project)(importer),
+                    decoder: (input, array, explore) =>
+                        ts.factory.createNewExpression(
+                            ts.factory.createIdentifier("Set"),
+                            [TypeFactory.keyword("any")],
+                            [
+                                decode_array(config)(importer)(
+                                    input,
+                                    array,
+                                    explore,
+                                ),
+                            ],
+                        ),
+                    empty: ts.factory.createNewExpression(
+                        ts.factory.createIdentifier("Set"),
+                        [TypeFactory.keyword("any")],
+                        [],
+                    ),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                })([])(input, sets, explore, [], []),
+                undefined,
+                undefined,
+            );
+
+    const explore_maps =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            maps: Metadata.Entry[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.map({
+                    checker: (top, entry, explore) => {
+                        const func = IsProgrammer.decode(project)(importer);
+                        return ts.factory.createLogicalAnd(
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    top,
+                                    0,
+                                ),
+                                entry[0],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[0]`,
+                                },
+                                [],
+                                [],
+                            ),
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    top,
+                                    1,
+                                ),
+                                entry[1],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[1]`,
+                                },
+                                [],
+                                [],
+                            ),
+                        );
+                    },
+                    decoder: (input, array, explore) =>
+                        ts.factory.createNewExpression(
+                            ts.factory.createIdentifier("Map"),
+                            [
+                                TypeFactory.keyword("any"),
+                                TypeFactory.keyword("any"),
+                            ],
+                            [
+                                decode_array(config)(importer)(
+                                    input,
+                                    array,
+                                    explore,
+                                ),
+                            ],
+                        ),
+                    empty: ts.factory.createNewExpression(
+                        ts.factory.createIdentifier("Map"),
+                        [
+                            TypeFactory.keyword("any"),
+                            TypeFactory.keyword("any"),
+                        ],
+                        [],
+                    ),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                })([])(input, maps, explore, [], []),
+                undefined,
+                undefined,
+            );
+
     const explore_objects =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
@@ -450,7 +637,7 @@ export namespace MiscCloneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -464,7 +651,7 @@ export namespace MiscCloneProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -480,7 +667,7 @@ export namespace MiscCloneProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -514,7 +701,7 @@ export namespace MiscCloneProgrammer {
                         ),
                     output: (type, name) =>
                         ts.factory.createTypeReferenceNode(
-                            `typia.Primitive<${
+                            `typia.Resolved<${
                                 name ??
                                 TypeFactory.getFullName(project.checker)(type)
                             }>`,
@@ -523,7 +710,7 @@ export namespace MiscCloneProgrammer {
                 prefix: PREFIX,
                 trace: false,
                 path: false,
-                initializer,
+                initializer: initializer(importer.method),
                 decoder: () => decode(project)(config)(importer),
                 objector: {
                     checker: () => IsProgrammer.decode(project)(importer),
@@ -547,14 +734,25 @@ export namespace MiscCloneProgrammer {
             return config;
         };
 
-    const initializer: FeatureProgrammer.IConfig["initializer"] =
+    const initializer =
+        (method: string): FeatureProgrammer.IConfig["initializer"] =>
         ({ checker }) =>
         (type) => {
             const collection = new MetadataCollection();
             const meta = MetadataFactory.analyze(checker)({
-                resolve: true,
+                escape: false,
                 constant: true,
                 absorb: true,
+                validate: (meta) => {
+                    if (meta.natives.some((n) => n === "WeakSet"))
+                        throw new Error(
+                            `Error on ${method}(): WeakSet is not supported.`,
+                        );
+                    else if (meta.natives.some((n) => n === "WeakMap"))
+                        throw new Error(
+                            `Error on ${method}(): WeakMap is not supported.`,
+                        );
+                },
             })(collection)(type);
             return [collection, meta];
         };

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -25,7 +25,7 @@ export namespace MiscIsCloneProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        `typia.Primitive<${
+                        `typia.Resolved<${
                             name ??
                             TypeFactory.getFullName(project.checker)(type)
                         }>`,

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -15,7 +15,7 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 export namespace MiscLiteralsProgrammer {
     export const write = (project: IProject) => (type: ts.Type) => {
         const meta: Metadata = MetadataFactory.analyze(project.checker)({
-            resolve: true,
+            escape: true,
             constant: true,
             absorb: true,
             validate: (meta) => {
@@ -23,7 +23,7 @@ export namespace MiscLiteralsProgrammer {
                     meta.constants
                         .map((c) => c.values.length)
                         .reduce((a, b) => a + b, 0) +
-                    meta.atomics.filter((type) => type === "boolean").length;
+                    meta.atomics.filter((a) => a.type === "boolean").length;
                 if (0 === length) throw new Error(ErrorMessages.NO);
                 else if (meta.size() !== length)
                     throw new Error(ErrorMessages.ONLY);
@@ -31,7 +31,7 @@ export namespace MiscLiteralsProgrammer {
         })(new MetadataCollection())(type);
         const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
-            ...(meta.atomics.filter((type) => type === "boolean").length
+            ...(meta.atomics.filter((a) => a.type === "boolean").length
                 ? [true, false]
                 : []),
             ...(meta.nullable ? [null] : []),

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -8,10 +8,12 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -26,7 +28,9 @@ import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
 export namespace MiscPruneProgrammer {
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             return FeatureProgrammer.write(project)({
                 ...configure(project)(importer),
                 addition: (collection) => [
@@ -128,8 +132,8 @@ export namespace MiscPruneProgrammer {
             // LIST UP UNION TYPES
             //----
             // TUPLES
-            for (const tuple of meta.tuples.filter((t) =>
-                t.elements.some((e) => filter(e.rest ?? e)),
+            for (const tuple of meta.tuples.filter((tuple) =>
+                tuple.type.elements.some((e) => filter(e.rest ?? e)),
             ))
                 unions.push({
                     type: "tuple",
@@ -154,7 +158,7 @@ export namespace MiscPruneProgrammer {
                 });
 
             // ARRAYS
-            if (meta.arrays.filter((a) => filter(a.value)).length)
+            if (meta.arrays.filter((a) => filter(a.type.value)).length)
                 unions.push({
                     type: "array",
                     is: () => ExpressionFactory.isArray(input),
@@ -237,10 +241,12 @@ export namespace MiscPruneProgrammer {
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
-            array.recursive
+            array.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}a${array.index}`),
+                          importer.useLocal(
+                              `${config.prefix}a${array.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -249,14 +255,18 @@ export namespace MiscPruneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
             FeatureProgrammer.decode_array(config)(importer)(PruneJoiner.array)(
@@ -276,10 +286,12 @@ export namespace MiscPruneProgrammer {
             tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression | ts.Block =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                          importer.useLocal(
+                              `${config.prefix}t${tuple.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -289,7 +301,7 @@ export namespace MiscPruneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -299,7 +311,7 @@ export namespace MiscPruneProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Block => {
             const children: ts.ConciseBody[] = tuple.elements
@@ -402,7 +414,7 @@ export namespace MiscPruneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -416,7 +428,7 @@ export namespace MiscPruneProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -432,7 +444,7 @@ export namespace MiscPruneProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -454,9 +466,9 @@ export namespace MiscPruneProgrammer {
         meta.any === false &&
         (meta.objects.length !== 0 ||
             meta.tuples.some((t) =>
-                t.elements.some((e) => filter(e.rest ?? e)),
+                t.type.elements.some((e) => filter(e.rest ?? e)),
             ) ||
-            meta.arrays.some((e) => filter(e.value)));
+            meta.arrays.some((e) => filter(e.type.value)));
 
     /* -----------------------------------------------------------
         CONFIGURATIONS
@@ -507,7 +519,7 @@ export namespace MiscPruneProgrammer {
         (type) => {
             const collection = new MetadataCollection();
             const meta = MetadataFactory.analyze(checker)({
-                resolve: false,
+                escape: false,
                 constant: true,
                 absorb: true,
             })(collection)(type);

package/src/programmers/misc/MiscValidateCloneProgrammer.ts

@@ -24,7 +24,7 @@ export namespace MiscValidateCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${
+                    `typia.IValidation<typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
                     }>>`,
                 ),