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

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -7,7 +7,7 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-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 { MetadataObject } from "../../schemas/metadata/MetadataObject";
@@ -205,7 +205,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const wrapper: (block: ts.Block) => ts.Block =
                 meta.isRequired() && meta.nullable === false
@@ -388,7 +388,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             map: Metadata.Entry,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const each: ts.Statement[] = [
                 ts.factory.createExpressionStatement(
@@ -442,7 +442,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             object: MetadataObject,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const top: MetadataProperty = object.properties[0]!;
             if (top.key.isSoleLiteral() === false)
@@ -502,9 +502,9 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
-            const wire = get_standalone_wire(array.value, tags);
+            const wire = get_standalone_wire(array.type.value, tags);
             const forLoop = (index: number | null) =>
                 ts.factory.createForOfStatement(
                     undefined,
@@ -515,7 +515,7 @@ export namespace ProtobufEncodeProgrammer {
                     input,
                     decode(project)(importer)(index)(
                         ts.factory.createIdentifier("elem"),
-                        array.value,
+                        array.type.value,
                         explore,
                         tags,
                     ),
@@ -568,7 +568,7 @@ export namespace ProtobufEncodeProgrammer {
         (
             input: ts.Expression,
             atomic: Atomic.Literal,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             if (atomic === "string")
                 return decode_bytes("string")(index!)(input);
@@ -593,9 +593,9 @@ export namespace ProtobufEncodeProgrammer {
                     );
             if (atomic === "boolean") return out(ProtobufWire.VARIANT)("bool");
 
-            const type: IMetadataTag.INumberType | undefined = tags.find(
+            const type: IMetadataCommentTag.INumberType | undefined = tags.find(
                 (tag) => tag.kind === "type",
-            ) as IMetadataTag.INumberType | undefined;
+            ) as IMetadataCommentTag.INumberType | undefined;
             if (atomic === "bigint")
                 return out(ProtobufWire.VARIANT)(
                     type?.value === "uint64" ? "uint64" : "int64",
@@ -641,7 +641,7 @@ export namespace ProtobufEncodeProgrammer {
 
     const get_standalone_wire = (
         meta: Metadata,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
     ): ProtobufWire => {
         if (
             meta.arrays.length ||
@@ -655,9 +655,9 @@ export namespace ProtobufEncodeProgrammer {
         if (v === "string") return ProtobufWire.LEN;
         else if (v === "boolean" || v === "bigint") return ProtobufWire.VARIANT;
 
-        const type: IMetadataTag.INumberType | undefined = tags.find(
+        const type: IMetadataCommentTag.INumberType | undefined = tags.find(
             (t) => t.kind === "type",
-        ) as IMetadataTag.INumberType | undefined;
+        ) as IMetadataCommentTag.INumberType | undefined;
         if (type === undefined) return ProtobufWire.I64;
         else if (type.value === "float") return ProtobufWire.I32;
         return ProtobufWire.VARIANT;
@@ -675,7 +675,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             indexes?: Map<MetadataObject, number>,
         ): ts.Block => {
             if (targets.length === 1)

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
@@ -104,14 +104,14 @@ export namespace ProtobufMessageProgrammer {
     ----------------------------------------------------------- */
     const decode =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (meta: Metadata): string => {
             const elements: Set<string> = new Set();
             if (meta.natives.length) elements.add("bytes");
             for (const atomic of ProtobufUtil.getAtomics(meta))
                 elements.add(decode_atomic(tags)(atomic));
             for (const array of meta.arrays)
-                elements.add(`repeated ${decode(ptr)(tags)(array.value)}`);
+                elements.add(`repeated ${decode(ptr)(tags)(array.type.value)}`);
             for (const obj of meta.objects)
                 elements.add(
                     is_dynamic_object(obj)
@@ -135,7 +135,7 @@ export namespace ProtobufMessageProgrammer {
         };
 
     const decode_atomic =
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (literal: Atomic.Literal): string => {
             if (literal === "boolean") return "bool";
             else if (literal === "bigint")
@@ -146,7 +146,7 @@ export namespace ProtobufMessageProgrammer {
                     : "int64";
             else if (literal === "number") {
                 const type = tags.find((t) => t.kind === "type") as
-                    | IMetadataTag.INumberType
+                    | IMetadataCommentTag.INumberType
                     | undefined;
                 if (type?.value === undefined) return "double";
                 else if (type.value === "int") return "int32";
@@ -158,7 +158,7 @@ export namespace ProtobufMessageProgrammer {
 
     const decode_map =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (prop: Metadata.Entry): string =>
             `map<${decode(ptr)([])(prop.key)}, ${decode(ptr)(tags)(
                 prop.value,

package/src/schemas/json/IJsonSchema.ts

@@ -1,5 +1,5 @@
 import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../metadata/IMetadataCommentTag";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -124,7 +124,7 @@ export namespace IJsonSchema {
         deprecated?: boolean;
         title?: string;
         description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-metaTags"?: IMetadataCommentTag[];
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;

package/src/schemas/metadata/IMetadata.ts

@@ -1,8 +1,8 @@
-import { Atomic } from "../../typings/Atomic";
-
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataConstant } from "./IMetadataConstant";
 import { IMetadataEntry } from "./IMetadataEntry";
 import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadata {
     any: boolean;
@@ -11,14 +11,20 @@ export interface IMetadata {
     nullable: boolean;
     functional: boolean;
 
-    atomics: Atomic.Literal[];
+    atomics: IMetadataAtomic[];
     constants: IMetadataConstant[];
     templates: IMetadata[][];
     escaped: IMetadataEscaped | null;
 
     rest: IMetadata | null;
-    arrays: string[];
-    tuples: string[];
+    arrays: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
+    tuples: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
     objects: string[];
     aliases: string[];
 

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,6 +1,6 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 
 export interface IMetadataAlias {
     name: string;
@@ -8,7 +8,7 @@ export interface IMetadataAlias {
     nullables: boolean[];
 
     description: string | null;
-    tags: IMetadataTag[];
+    tags: IMetadataCommentTag[];
     jsDocTags: IJsDocTagInfo[];
     recursive: boolean;
 }

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataArray {
-    name: string;
-    value: IMetadata;
-
-    nullables: boolean[];
-    recursive: boolean;
-    index: number | null;
+    type: IMetadataArrayType;
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataArrayType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArrayType {
+    name: string;
+    value: IMetadata;
+
+    nullables: boolean[];
+    recursive: boolean;
+    index: number | null;
+}

package/src/schemas/metadata/IMetadataAtomic.ts

@@ -0,0 +1,6 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAtomic {
+    type: "boolean" | "bigint" | "number" | "string";
+    tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataCollection.ts

@@ -1,11 +1,11 @@
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataArrayType } from "./IMetadataArrayType";
 import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTupleType } from "./IMetadataTupleType";
 
 export interface IMetadataCollection {
     objects: IMetadataObject[];
     aliases: IMetadataAlias[];
-    arrays: IMetadataArray[];
-    tuples: IMetadataTuple[];
+    arrays: IMetadataArrayType[];
+    tuples: IMetadataTupleType[];
 }

package/src/schemas/metadata/{IMetadataTag.ts → IMetadataCommentTag.ts}

@@ -1,24 +1,24 @@
-export type IMetadataTag =
+export type IMetadataCommentTag =
     // NUMBER
-    | IMetadataTag.INumberType
-    | IMetadataTag.IMinimum
-    | IMetadataTag.IMaximum
-    | IMetadataTag.IExclusiveMinimum
-    | IMetadataTag.IExclusiveMaximum
-    | IMetadataTag.IMultipleOf
-    | IMetadataTag.IStep
+    | IMetadataCommentTag.INumberType
+    | IMetadataCommentTag.IMinimum
+    | IMetadataCommentTag.IMaximum
+    | IMetadataCommentTag.IExclusiveMinimum
+    | IMetadataCommentTag.IExclusiveMaximum
+    | IMetadataCommentTag.IMultipleOf
+    | IMetadataCommentTag.IStep
     // STRING
-    | IMetadataTag.IFormat
-    | IMetadataTag.IPattern
-    | IMetadataTag.ILength
-    | IMetadataTag.IMinLength
-    | IMetadataTag.IMaxLength
+    | IMetadataCommentTag.IFormat
+    | IMetadataCommentTag.IPattern
+    | IMetadataCommentTag.ILength
+    | IMetadataCommentTag.IMinLength
+    | IMetadataCommentTag.IMaxLength
     // ARRAY
-    | IMetadataTag.IItems
-    | IMetadataTag.IMinItems
-    | IMetadataTag.IMaxItems;
+    | IMetadataCommentTag.IItems
+    | IMetadataCommentTag.IMinItems
+    | IMetadataCommentTag.IMaxItems;
 
-export namespace IMetadataTag {
+export namespace IMetadataCommentTag {
     /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,7 +1,7 @@
 import { MetadataAlias } from "./MetadataAlias";
-import { MetadataArray } from "./MetadataArray";
+import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObject } from "./MetadataObject";
-import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 /**
  * @internal
@@ -9,6 +9,6 @@ import { MetadataTuple } from "./MetadataTuple";
 export interface IMetadataDictionary {
     objects: Map<string, MetadataObject>;
     aliases: Map<string, MetadataAlias>;
-    arrays: Map<string, MetadataArray>;
-    tuples: Map<string, MetadataTuple>;
+    arrays: Map<string, MetadataArrayType>;
+    tuples: Map<string, MetadataTupleType>;
 }

package/src/schemas/metadata/IMetadataProperty.ts

@@ -1,11 +1,11 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 
 export interface IMetadataProperty {
     key: IMetadata;
     value: IMetadata;
     description: string | null;
-    tags: IMetadataTag[];
+    tags: IMetadataCommentTag[];
     jsDocTags: IJsDocTagInfo[];
 }

package/src/schemas/metadata/IMetadataTuple.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataTuple {
-    name: string;
-    elements: IMetadata[];
-
-    index: number | null;
-    recursive: boolean;
-    nullables: boolean[];
+    type: IMetadataTupleType;
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataTupleType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataTupleType {
+    name: string;
+    elements: IMetadata[];
+
+    index: number | null;
+    recursive: boolean;
+    nullables: boolean[];
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -0,0 +1,6 @@
+export interface IMetadataTypeTag {
+    name: string;
+    kind: string;
+    value: any;
+    validate: string;
+}