typia 7.0.0-dev.20241012 → 7.0.0-dev.20241018

package/src/schemas/metadata/MetadataArray.ts

@@ -1,49 +1,49 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataArray } from "./IMetadataArray";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataArrayType } from "./MetadataArrayType";
-
-export class MetadataArray {
-  public readonly type: MetadataArrayType;
-  public readonly tags: IMetadataTypeTag[][];
-
-  private name_?: string;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataArray>) {
-    this.type = props.type;
-    this.tags = props.tags;
-  }
-
-  public static create(props: ClassProperties<MetadataArray>): MetadataArray {
-    return new MetadataArray(props);
-  }
-
-  public getName(): string {
-    return (this.name_ ??= (() => {
-      if (this.tags.length === 0) return this.type.name;
-      else if (this.tags.length === 1) {
-        const str: string = [
-          this.type.name,
-          ...this.tags[0]!.map((t) => t.name),
-        ].join(" & ");
-        return `(${str})`;
-      }
-      const rows: string[] = this.tags.map((row) => {
-        const str: string = row.map((t) => t.name).join(" & ");
-        return row.length === 1 ? str : `(${str})`;
-      });
-      return `(${this.type.name} & (${rows.join(" | ")}))`;
-    })());
-  }
-
-  public toJSON(): IMetadataArray {
-    return {
-      name: this.type.name,
-      tags: this.tags.map((row) => row.slice()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataArrayType } from "./MetadataArrayType";
+
+export class MetadataArray {
+  public readonly type: MetadataArrayType;
+  public readonly tags: IMetadataTypeTag[][];
+
+  private name_?: string;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataArray>) {
+    this.type = props.type;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataArray>): MetadataArray {
+    return new MetadataArray(props);
+  }
+
+  public getName(): string {
+    return (this.name_ ??= (() => {
+      if (this.tags.length === 0) return this.type.name;
+      else if (this.tags.length === 1) {
+        const str: string = [
+          this.type.name,
+          ...this.tags[0]!.map((t) => t.name),
+        ].join(" & ");
+        return `(${str})`;
+      }
+      const rows: string[] = this.tags.map((row) => {
+        const str: string = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+      });
+      return `(${this.type.name} & (${rows.join(" | ")}))`;
+    })());
+  }
+
+  public toJSON(): IMetadataArray {
+    return {
+      name: this.type.name,
+      tags: this.tags.map((row) => row.slice()),
+    };
+  }
+}

package/src/schemas/metadata/MetadataComponents.ts

@@ -4,14 +4,14 @@ import { Writable } from "../../typings/Writable";
 import { IMetadataComponents } from "./IMetadataComponents";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { Metadata } from "./Metadata";
-import { MetadataAlias } from "./MetadataAlias";
+import { MetadataAliasType } from "./MetadataAliasType";
 import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTupleType } from "./MetadataTupleType";
 
 export class MetadataComponents {
-  public readonly aliases: MetadataAlias[];
+  public readonly aliases: MetadataAliasType[];
   public readonly objects: MetadataObjectType[];
   public readonly arrays: MetadataArrayType[];
   public readonly tuples: MetadataTupleType[];
@@ -37,7 +37,7 @@ export class MetadataComponents {
       aliases: new Map(
         json.aliases.map((alias) => [
           alias.name,
-          MetadataAlias._From_without_value(alias),
+          MetadataAliasType._From_without_value(alias),
         ]),
       ),
       arrays: new Map(

package/src/schemas/metadata/MetadataConstantValue.ts

@@ -6,7 +6,7 @@ import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export class MetadataConstantValue {
   public readonly value: boolean | bigint | number | string;
-  public tags: IMetadataTypeTag[][] | undefined;
+  public tags: IMetadataTypeTag[][];
   public readonly description?: string | null;
   public readonly jsDocTags?: IJsDocTagInfo[];
   private name_?: string;

package/src/schemas/metadata/MetadataMap.ts

@@ -0,0 +1,48 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataMap } from "./IMetadataMap";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+
+export class MetadataMap {
+  public readonly key: Metadata;
+  public readonly value: Metadata;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataMap>) {
+    this.key = props.key;
+    this.value = props.value;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataMap>): MetadataMap {
+    return new MetadataMap(props);
+  }
+
+  public getName(): string {
+    return (this.name_ ??= (() => {
+      const symbol: string = `Map<${this.key.getName()}, ${this.value.getName()}>`;
+      if (this.tags.length === 0) return symbol;
+      else if (this.tags.length === 1) {
+        const str: string = [symbol, ...this.tags[0]!.map((t) => t.name)].join(
+          " & ",
+        );
+        return `(${str})`;
+      }
+      const rows: string[] = this.tags.map((row) => {
+        const str: string = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+      });
+      return `(${symbol} & (${rows.join(" | ")}))`;
+    })());
+  }
+
+  public toJSON(): IMetadataMap {
+    return {
+      key: this.key.toJSON(),
+      value: this.value.toJSON(),
+      tags: this.tags,
+    };
+  }
+}

package/src/schemas/metadata/MetadataNative.ts

@@ -0,0 +1,44 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataNative } from "./IMetadataNative";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataNative {
+  public readonly name: string;
+  public readonly tags: IMetadataTypeTag[][];
+  private typeName_?: string;
+
+  private constructor(props: ClassProperties<MetadataNative>) {
+    this.name = props.name;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataNative>): MetadataNative {
+    return new MetadataNative(props);
+  }
+
+  public getName(): string {
+    return (this.typeName_ ??= (() => {
+      if (this.tags.length === 0) return this.name;
+      else if (this.tags.length === 1) {
+        const str: string = [
+          this.name,
+          ...this.tags[0]!.map((t) => t.name),
+        ].join(" & ");
+        return `(${str})`;
+      }
+      const rows: string[] = this.tags.map((row) => {
+        const str: string = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+      });
+      return `(${this.name} & (${rows.join(" | ")}))`;
+    })());
+  }
+
+  public toJSON(): IMetadataNative {
+    return {
+      name: this.name,
+      tags: this.tags,
+    };
+  }
+}

package/src/schemas/metadata/MetadataProperty.ts

@@ -11,6 +11,11 @@ export class MetadataProperty {
   public readonly description: string | null;
   public readonly jsDocTags: IJsDocTagInfo[];
 
+  /**
+   * @internal
+   */
+  public readonly sequences_?: Set<number>;
+
   /* -----------------------------------------------------------
         CONSTRUCTORS
     ----------------------------------------------------------- */

package/src/schemas/metadata/MetadataSet.ts

@@ -0,0 +1,45 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataSet } from "./IMetadataSet";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+
+export class MetadataSet {
+  public readonly value: Metadata;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataSet>) {
+    this.value = props.value;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataSet>): MetadataSet {
+    return new MetadataSet(props);
+  }
+
+  public getName(): string {
+    return (this.name_ ??= (() => {
+      const symbol: string = `Set<${this.value.getName()}>`;
+      if (this.tags.length === 0) return symbol;
+      else if (this.tags.length === 1) {
+        const str: string = [symbol, ...this.tags[0]!.map((t) => t.name)].join(
+          " & ",
+        );
+        return `(${str})`;
+      }
+      const rows: string[] = this.tags.map((row) => {
+        const str: string = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+      });
+      return `(${symbol} & (${rows.join(" | ")}))`;
+    })());
+  }
+
+  public toJSON(): IMetadataSet {
+    return {
+      value: this.value.toJSON(),
+      tags: this.tags,
+    };
+  }
+}

package/src/schemas/metadata/MetadataTemplate.ts

@@ -1,80 +1,80 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataTemplate } from "./IMetadataTemplate";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { Metadata } from "./Metadata";
-
-export class MetadataTemplate {
-  public readonly row: Metadata[];
-  public tags: IMetadataTypeTag[][] | undefined;
-
-  private name_?: string;
-
-  private constructor(props: ClassProperties<MetadataTemplate>) {
-    this.row = props.row.map(Metadata.create);
-    this.tags = props.tags;
-  }
-
-  public static create(
-    props: ClassProperties<MetadataTemplate>,
-  ): MetadataTemplate {
-    return new MetadataTemplate(props);
-  }
-
-  public static from(
-    json: IMetadataTemplate,
-    dict: IMetadataDictionary,
-  ): MetadataTemplate {
-    return new MetadataTemplate({
-      row: json.row.map((m) => Metadata.from(m, dict)),
-      tags: json.tags,
-    });
-  }
-
-  public getName(): string {
-    return (this.name_ ??= getName(this));
-  }
-
-  /**
-   * @internal
-   */
-  public getBaseName(): string {
-    return (
-      "`" +
-      this.row
-        .map((child) =>
-          child.isConstant() && child.size() === 1
-            ? child.constants[0]!.values[0]!.value
-            : `$\{${child.getName()}\}`,
-        )
-        .join("")
-        .split("`")
-        .join("\\`") +
-      "`"
-    );
-  }
-
-  public toJSON(): IMetadataTemplate {
-    return {
-      row: this.row.map((m) => m.toJSON()),
-      tags: this.tags,
-    };
-  }
-}
-
-const getName = (template: MetadataTemplate): string => {
-  const base: string = template.getBaseName();
-  if (!template.tags?.length) return base;
-  else if (template.tags.length === 1) {
-    const str: string = [base, ...template.tags[0]!.map((t) => t.name)].join(
-      " & ",
-    );
-    return `(${str})`;
-  }
-  const rows: string[] = template.tags.map((row) => {
-    const str: string = row.map((t) => t.name).join(" & ");
-    return row.length === 1 ? str : `(${str})`;
-  });
-  return `(${base} & (${rows.join(" | ")}))`;
-};
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+
+export class MetadataTemplate {
+  public readonly row: Metadata[];
+  public readonly tags: IMetadataTypeTag[][];
+
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataTemplate>) {
+    this.row = props.row.map(Metadata.create);
+    this.tags = props.tags;
+  }
+
+  public static create(
+    props: ClassProperties<MetadataTemplate>,
+  ): MetadataTemplate {
+    return new MetadataTemplate(props);
+  }
+
+  public static from(
+    json: IMetadataTemplate,
+    dict: IMetadataDictionary,
+  ): MetadataTemplate {
+    return new MetadataTemplate({
+      row: json.row.map((m) => Metadata.from(m, dict)),
+      tags: json.tags,
+    });
+  }
+
+  public getName(): string {
+    return (this.name_ ??= getName(this));
+  }
+
+  /**
+   * @internal
+   */
+  public getBaseName(): string {
+    return (
+      "`" +
+      this.row
+        .map((child) =>
+          child.isConstant() && child.size() === 1
+            ? child.constants[0]!.values[0]!.value
+            : `$\{${child.getName()}\}`,
+        )
+        .join("")
+        .split("`")
+        .join("\\`") +
+      "`"
+    );
+  }
+
+  public toJSON(): IMetadataTemplate {
+    return {
+      row: this.row.map((m) => m.toJSON()),
+      tags: this.tags,
+    };
+  }
+}
+
+const getName = (template: MetadataTemplate): string => {
+  const base: string = template.getBaseName();
+  if (!template.tags?.length) return base;
+  else if (template.tags.length === 1) {
+    const str: string = [base, ...template.tags[0]!.map((t) => t.name)].join(
+      " & ",
+    );
+    return `(${str})`;
+  }
+  const rows: string[] = template.tags.map((row) => {
+    const str: string = row.map((t) => t.name).join(" & ");
+    return row.length === 1 ? str : `(${str})`;
+  });
+  return `(${base} & (${rows.join(" | ")}))`;
+};

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,32 +1,32 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataTuple } from "./IMetadataTuple";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataTupleType } from "./MetadataTupleType";
-
-export class MetadataTuple {
-  public readonly type: MetadataTupleType;
-  public readonly tags: IMetadataTypeTag[][];
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataTuple>) {
-    this.type = props.type;
-    this.tags = props.tags;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
-    return new MetadataTuple(props);
-  }
-
-  public toJSON(): IMetadataTuple {
-    return {
-      name: this.type.name,
-      tags: this.tags.map((row) => row.slice()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataTuple {
+  public readonly type: MetadataTupleType;
+  public readonly tags: IMetadataTypeTag[][];
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataTuple>) {
+    this.type = props.type;
+    this.tags = props.tags;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
+    return new MetadataTuple(props);
+  }
+
+  public toJSON(): IMetadataTuple {
+    return {
+      name: this.type.name,
+      tags: this.tags.map((row) => row.slice()),
+    };
+  }
+}

package/src/tags/Example.ts

@@ -1,17 +1,24 @@
-import { TagBase } from "./TagBase";
-
-export type Example<
-  Value extends boolean | bigint | number | string | Array<unknown> | null,
-> = TagBase<{
-  target: "boolean" | "bigint" | "number" | "string" | "array";
-  kind: "example";
-  value: Value;
-  exclusive: true;
-  schema: Value extends bigint
-    ? { example: Numeric<Value> }
-    : { example: Value };
-}>;
-
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+export type Example<
+  Value extends
+    | boolean
+    | bigint
+    | number
+    | string
+    | object
+    | Array<unknown>
+    | null,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "example";
+  value: Value;
+  exclusive: true;
+  schema: Value extends bigint
+    ? { example: Numeric<Value> }
+    : { example: Value };
+}>;
+
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/Examples.ts

@@ -1,16 +1,16 @@
-import { TagBase } from "./TagBase";
-
-export type Examples<
-  Dict extends Record<
-    string,
-    boolean | bigint | number | string | Array<unknown> | null
-  >,
-> = TagBase<{
-  target: "boolean" | "bigint" | "number" | "string" | "array";
-  kind: "examples";
-  value: Dict;
-  exclusive: true;
-  schema: {
-    examples: Dict;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+export type Examples<
+  Dict extends Record<
+    string,
+    boolean | bigint | number | string | object | Array<unknown> | null
+  >,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "examples";
+  value: Dict;
+  exclusive: true;
+  schema: {
+    examples: Dict;
+  };
+}>;

package/src/tags/JsonSchemaPlugin.ts

@@ -1,8 +1,8 @@
-import { TagBase } from "./TagBase";
-
-export type JsonSchemaPlugin<Schema extends object> = TagBase<{
-  target: "string" | "boolean" | "bigint" | "number" | "array";
-  kind: "jsonPlugin";
-  value: undefined;
-  schema: Schema;
-}>;
+import { TagBase } from "./TagBase";
+
+export type JsonSchemaPlugin<Schema extends object> = TagBase<{
+  target: "string" | "boolean" | "bigint" | "number" | "array" | "object";
+  kind: "jsonPlugin";
+  value: undefined;
+  schema: Schema;
+}>;

package/src/tags/Sequence.ts

@@ -0,0 +1,10 @@
+import { TagBase } from "./TagBase";
+
+export type Sequence<N extends number> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "sequence";
+  value: N;
+  schema: {
+    "x-protobuf-sequence": N;
+  };
+}>;