typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/programmers/internal/check_string.ts

@@ -1,25 +1,45 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_string =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: ts.JSDocTagInfo[]) =>
-    (input: ts.Expression) => ({
-        expression: ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("string"),
-            ts.factory.createTypeOfExpression(input),
-        ),
-        tags: [
-            ...check_string_tags(importer)(metaTags)(input),
-            ...check_custom("string")(importer)(jsDocTags)(input),
-        ],
-    });
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry => {
+        const conditions: ICheckEntry.ICondition[][] =
+            check_string_type_tags(project)(atomic)(input);
+
+        return {
+            expected: atomic.getName(),
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            conditions,
+        };
+    };
+
+/**
+ * @internal
+ */
+const check_string_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) =>
+            row.map((tag) => ({
+                expected: `string & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_template.ts

@@ -1,22 +1,14 @@
 import ts from "typescript";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
 import { template_to_pattern } from "./template_to_pattern";
 
 /**
  * @internal
  */
 export const check_template =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
     (templates: Metadata[][]) =>
     (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
@@ -48,9 +40,22 @@ export const check_template =
             expression: conditions.reduce((x, y) =>
                 ts.factory.createLogicalAnd(x, y),
             ),
-            tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
-            ],
+            conditions: [],
+            expected: templates
+                .map(
+                    (tpl) =>
+                        "`" +
+                        tpl
+                            .map((child) =>
+                                child.isConstant() && child.size() === 1
+                                    ? child.constants[0]!.values[0]!
+                                    : `$\{${child.getName()}\}`,
+                            )
+                            .join("")
+                            .split("`")
+                            .join("\\`") +
+                        "`",
+                )
+                .join(" | "),
         };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -4,8 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 
 import { CheckerProgrammer } from "../CheckerProgrammer";
@@ -25,8 +25,6 @@ export const check_union_array_like =
         input: ts.Expression,
         origins: Origin[],
         explore: FeatureProgrammer.IExplore,
-        tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
     ): ts.ArrowFunction => {
         // ONLY ONE TYPE
         const targets: Array<Category> = origins.map(accessor.transform);
@@ -37,13 +35,7 @@ export const check_union_array_like =
                 parameters,
                 undefined,
                 undefined,
-                props.decoder(
-                    accessor.array(input),
-                    targets[0]!,
-                    explore,
-                    tags,
-                    jsDocTags,
-                ),
+                props.decoder(accessor.array(input), targets[0]!, explore),
             );
 
         const array = ts.factory.createIdentifier("array");
@@ -66,7 +58,7 @@ export const check_union_array_like =
                         [
                             IdentifierFactory.parameter(
                                 "top",
-                                meta instanceof MetadataArray
+                                meta instanceof MetadataArrayType
                                     ? TypeFactory.keyword("any")
                                     : ts.factory.createTypeReferenceNode(
                                           "any[]",
@@ -82,12 +74,10 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: false,
                                 postfix:
-                                    meta instanceof MetadataArray
+                                    meta instanceof MetadataArrayType
                                         ? `"[0]"`
                                         : "",
                             },
-                            tags,
-                            jsDocTags,
                             array,
                         ),
                     ),
@@ -109,8 +99,6 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: true,
                             },
-                            tags,
-                            jsDocTags,
                         ),
                     ),
                 ],
@@ -300,8 +288,6 @@ export namespace check_union_array_like {
             front: ts.Expression,
             target: Element,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
             container: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<Category>;

package/src/programmers/internal/feature_object_entries.ts

@@ -41,23 +41,17 @@ export const feature_object_entries =
                 input: propInput,
                 key: prop.key,
                 meta: prop.value,
-                expression: config.decoder()(
-                    propInput,
-                    prop.value,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from,
-                        postfix:
-                            sole !== null
-                                ? IdentifierFactory.postfix(sole)
-                                : (() => {
-                                      importer.use("join");
-                                      return `$join(key)`;
-                                  })(),
-                    },
-                    prop.tags,
-                    prop.jsDocTags,
-                ),
+                expression: config.decoder()(propInput, prop.value, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from,
+                    postfix:
+                        sole !== null
+                            ? IdentifierFactory.postfix(sole)
+                            : (() => {
+                                  importer.use("join");
+                                  return `$join(key)`;
+                              })(),
+                }),
             };
         });

package/src/programmers/internal/metadata_to_pattern.ts

@@ -11,7 +11,7 @@ import { template_to_pattern } from "./template_to_pattern";
 export const metadata_to_pattern =
     (top: boolean) =>
     (meta: Metadata): string => {
-        if (meta.atomics.find((type) => type === "string") !== undefined)
+        if (meta.atomics.find((a) => a.type === "string") !== undefined)
             return "(.*)";
 
         const values: string[] = ArrayUtil.flat(
@@ -21,10 +21,10 @@ export const metadata_to_pattern =
                 return c.values.map((str) => PatternUtil.escape(str));
             }),
         );
-        for (const type of meta.atomics)
-            if (type === "number" || type === "bigint")
+        for (const a of meta.atomics)
+            if (a.type === "number" || a.type === "bigint")
                 values.push(PatternUtil.NUMBER);
-            else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
+            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
         for (const childTpl of meta.templates)
             values.push("(" + template_to_pattern(false)(childTpl) + ")");
 

package/src/programmers/internal/random_custom.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { LiteralFactory } from "../../factories/LiteralFactory";
 
-import { ICommentTag } from "../../schemas/metadata/ICommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 import { Customizable } from "../../typings/Customizable";
 
@@ -13,7 +13,7 @@ import { Customizable } from "../../typings/Customizable";
 export const random_custom =
     (accessor: (name: string) => ts.Expression) =>
     (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
+    (tags: IMetadataTypeTag[]) =>
     (expression: ts.Expression) =>
         ExpressionFactory.coalesce(
             ts.factory.createCallChain(
@@ -24,6 +24,6 @@ export const random_custom =
                 ),
                 ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
                 undefined,
-                [LiteralFactory.generate(comments)],
+                [LiteralFactory.generate(tags)],
             ),
         )(expression);

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -125,7 +125,7 @@ export const stringify_dynamic_properties = (
     const simple: boolean =
         dynamic.length === 1 &&
         dynamic[0]!.key.size() === 1 &&
-        dynamic[0]!.key.atomics[0] === "string";
+        dynamic[0]!.key.atomics[0]?.type === "string";
     if (simple === true) {
         statements.push(stringify(dynamic[0]!));
         return output();

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,15 +1,19 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 
 export const wrap_metadata_rest_tuple = (rest: Metadata) => {
     const wrapper: Metadata = Metadata.initialize();
     wrapper.arrays.push(
         MetadataArray.create({
-            name: `...${rest.getName()}`,
-            value: rest,
-            nullables: [],
-            recursive: false,
-            index: null,
+            type: MetadataArrayType.create({
+                name: `...${rest.getName()}`,
+                value: rest,
+                nullables: [],
+                recursive: false,
+                index: null,
+            }),
+            tags: [],
         }),
     );
     return wrapper;

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -8,12 +8,12 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -66,7 +66,7 @@ export namespace JsonStringifyProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -79,7 +79,10 @@ export namespace JsonStringifyProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -213,7 +216,9 @@ export namespace JsonStringifyProgrammer {
             )
                 if (AtomicPredicator.template(meta)) {
                     const partial = Metadata.initialize();
-                    partial.atomics.push("string"),
+                    partial.atomics.push(
+                        MetadataAtomic.create({ type: "string", tags: [] }),
+                    ),
                         unions.push({
                             type: "template literal",
                             is: () =>
@@ -221,8 +226,6 @@ export namespace JsonStringifyProgrammer {
                                     input,
                                     partial,
                                     explore,
-                                    [],
-                                    [],
                                 ),
                             value: () =>
                                 decode_atomic(project)(importer)(
@@ -245,12 +248,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(constant.type);
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: constant.type,
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
@@ -267,12 +273,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push("string");
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: "string",
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_constant_string(project)(importer)(
@@ -283,8 +292,8 @@ export namespace JsonStringifyProgrammer {
                     });
 
             /// ATOMICS
-            for (const type of meta.atomics)
-                if (AtomicPredicator.atomic(meta)(type))
+            for (const a of meta.atomics)
+                if (AtomicPredicator.atomic(meta)(a.type))
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -292,24 +301,22 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(type);
+                                    partial.atomics.push(a);
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
                                 input,
-                                type,
+                                a.type,
                                 explore,
                             ),
                     });
 
             // TUPLES
             for (const tuple of meta.tuples) {
-                for (const child of tuple.elements)
+                for (const child of tuple.type.elements)
                     if (StringifyPredicator.undefindable(meta))
                         throw new Error(
                             `Error on typia.json.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
@@ -325,8 +332,6 @@ export namespace JsonStringifyProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -340,9 +345,9 @@ export namespace JsonStringifyProgrammer {
             // ARRAYS
             if (meta.arrays.length) {
                 for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.value))
+                    if (StringifyPredicator.undefindable(child.type.value))
                         throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.value.getName()}).`,
+                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
                         );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
@@ -355,7 +360,7 @@ export namespace JsonStringifyProgrammer {
                                       from: "array",
                                   },
                               )
-                        : meta.arrays.some((elem) => elem.value.any)
+                        : meta.arrays.some((elem) => elem.type.value.any)
                         ? () =>
                               ts.factory.createCallExpression(
                                   ts.factory.createIdentifier("JSON.stringify"),
@@ -512,10 +517,12 @@ export namespace JsonStringifyProgrammer {
             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)({
@@ -536,7 +543,7 @@ export namespace JsonStringifyProgrammer {
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(
                 StringifyJoiner.array,
-            )(input, array, explore, [], []);
+            )(input, array, explore);
 
     const decode_tuple =
         (project: IProject) =>
@@ -547,10 +554,12 @@ export namespace JsonStringifyProgrammer {
             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)({
@@ -560,7 +569,7 @@ export namespace JsonStringifyProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -570,7 +579,7 @@ export namespace JsonStringifyProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -749,8 +758,6 @@ export namespace JsonStringifyProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -762,8 +769,8 @@ export namespace JsonStringifyProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+                    factory(parameters)(input, elements, explore);
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -779,7 +786,7 @@ export namespace JsonStringifyProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -905,8 +912,6 @@ export namespace JsonStringifyProgrammer {
                             input,
                             meta,
                             explore,
-                            [],
-                            [],
                         ),
                     decoder: () => decode_object(importer),
                     joiner: StringifyJoiner.object(importer),
@@ -937,11 +942,11 @@ export namespace JsonStringifyProgrammer {
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
-                    if (meta.atomics.find((str) => str === "bigint"))
+                    if (meta.atomics.find((a) => a.type === "bigint"))
                         throw new Error(NO_BIGINT);
                     else if (
                         meta.arrays.some(
-                            (array) => array.value.isRequired() === false,
+                            (array) => array.type.value.isRequired() === false,
                         )
                     )
                         throw new Error(NO_UNDEFINED_IN_ARRAY);