typia 7.2.1 → 7.3.0-dev.20241213

package/src/schemas/metadata/MetadataComponents.ts

@@ -1,98 +1,98 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-import { Writable } from "../../typings/Writable";
-
-import { IMetadataComponents } from "./IMetadataComponents";
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { Metadata } from "./Metadata";
-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: MetadataAliasType[];
-  public readonly objects: MetadataObjectType[];
-  public readonly arrays: MetadataArrayType[];
-  public readonly tuples: MetadataTupleType[];
-  public readonly dictionary: IMetadataDictionary;
-
-  private constructor(props: ClassProperties<MetadataComponents>) {
-    this.aliases = props.aliases;
-    this.objects = props.objects;
-    this.arrays = props.arrays;
-    this.tuples = props.tuples;
-    this.dictionary = props.dictionary;
-  }
-
-  public static from(json: IMetadataComponents): MetadataComponents {
-    // INITIALIZE COMPONENTS
-    const dictionary: IMetadataDictionary = {
-      objects: new Map(
-        json.objects.map((obj) => [
-          obj.name,
-          MetadataObjectType._From_without_properties(obj),
-        ]),
-      ),
-      aliases: new Map(
-        json.aliases.map((alias) => [
-          alias.name,
-          MetadataAliasType._From_without_value(alias),
-        ]),
-      ),
-      arrays: new Map(
-        json.arrays.map((arr) => [
-          arr.name,
-          MetadataArrayType._From_without_value(arr),
-        ]),
-      ),
-      tuples: new Map(
-        json.tuples.map((tpl) => [
-          tpl.name,
-          MetadataTupleType._From_without_elements(tpl),
-        ]),
-      ),
-    };
-
-    // CONSTRUCT METADATA OF THEM
-    for (const obj of json.objects)
-      dictionary.objects
-        .get(obj.name)!
-        .properties.push(
-          ...obj.properties.map((prop) =>
-            MetadataProperty.from(prop, dictionary),
-          ),
-        );
-    for (const alias of json.aliases)
-      Writable(dictionary.aliases.get(alias.name)!).value = Metadata.from(
-        alias.value,
-        dictionary,
-      );
-    for (const array of json.arrays)
-      Writable(dictionary.arrays.get(array.name)!).value = Metadata.from(
-        array.value,
-        dictionary,
-      );
-    for (const tuple of json.tuples)
-      Writable(dictionary.tuples.get(tuple.name)!).elements =
-        tuple.elements.map((elem) => Metadata.from(elem, dictionary));
-
-    // FINALIZE
-    return new MetadataComponents({
-      aliases: [...dictionary.aliases.values()],
-      objects: [...dictionary.objects.values()],
-      arrays: [...dictionary.arrays.values()],
-      tuples: [...dictionary.tuples.values()],
-      dictionary,
-    });
-  }
-
-  public toJSON(): IMetadataComponents {
-    return {
-      aliases: this.aliases.map((alias) => alias.toJSON()),
-      objects: this.objects.map((object) => object.toJSON()),
-      arrays: this.arrays.map((array) => array.toJSON()),
-      tuples: this.tuples.map((tuple) => tuple.toJSON()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+import { Writable } from "../../typings/Writable";
+
+import { IMetadataComponents } from "./IMetadataComponents";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { Metadata } from "./Metadata";
+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: MetadataAliasType[];
+  public readonly objects: MetadataObjectType[];
+  public readonly arrays: MetadataArrayType[];
+  public readonly tuples: MetadataTupleType[];
+  public readonly dictionary: IMetadataDictionary;
+
+  private constructor(props: ClassProperties<MetadataComponents>) {
+    this.aliases = props.aliases;
+    this.objects = props.objects;
+    this.arrays = props.arrays;
+    this.tuples = props.tuples;
+    this.dictionary = props.dictionary;
+  }
+
+  public static from(json: IMetadataComponents): MetadataComponents {
+    // INITIALIZE COMPONENTS
+    const dictionary: IMetadataDictionary = {
+      objects: new Map(
+        json.objects.map((obj) => [
+          obj.name,
+          MetadataObjectType._From_without_properties(obj),
+        ]),
+      ),
+      aliases: new Map(
+        json.aliases.map((alias) => [
+          alias.name,
+          MetadataAliasType._From_without_value(alias),
+        ]),
+      ),
+      arrays: new Map(
+        json.arrays.map((arr) => [
+          arr.name,
+          MetadataArrayType._From_without_value(arr),
+        ]),
+      ),
+      tuples: new Map(
+        json.tuples.map((tpl) => [
+          tpl.name,
+          MetadataTupleType._From_without_elements(tpl),
+        ]),
+      ),
+    };
+
+    // CONSTRUCT METADATA OF THEM
+    for (const obj of json.objects)
+      dictionary.objects
+        .get(obj.name)!
+        .properties.push(
+          ...obj.properties.map((prop) =>
+            MetadataProperty.from(prop, dictionary),
+          ),
+        );
+    for (const alias of json.aliases)
+      Writable(dictionary.aliases.get(alias.name)!).value = Metadata.from(
+        alias.value,
+        dictionary,
+      );
+    for (const array of json.arrays)
+      Writable(dictionary.arrays.get(array.name)!).value = Metadata.from(
+        array.value,
+        dictionary,
+      );
+    for (const tuple of json.tuples)
+      Writable(dictionary.tuples.get(tuple.name)!).elements =
+        tuple.elements.map((elem) => Metadata.from(elem, dictionary));
+
+    // FINALIZE
+    return new MetadataComponents({
+      aliases: [...dictionary.aliases.values()],
+      objects: [...dictionary.objects.values()],
+      arrays: [...dictionary.arrays.values()],
+      tuples: [...dictionary.tuples.values()],
+      dictionary,
+    });
+  }
+
+  public toJSON(): IMetadataComponents {
+    return {
+      aliases: this.aliases.map((alias) => alias.toJSON()),
+      objects: this.objects.map((object) => object.toJSON()),
+      arrays: this.arrays.map((array) => array.toJSON()),
+      tuples: this.tuples.map((tuple) => tuple.toJSON()),
+    };
+  }
+}

package/src/schemas/metadata/MetadataConstantValue.ts

@@ -1,62 +1,62 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataConstantValue } from "./IMetadataConstantValue";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export class MetadataConstantValue {
-  public readonly value: boolean | bigint | number | string;
-  public tags: IMetadataTypeTag[][];
-  public readonly description?: string | null;
-  public readonly jsDocTags?: IJsDocTagInfo[];
-  private name_?: string;
-
-  private constructor(props: ClassProperties<MetadataConstantValue>) {
-    this.value = props.value;
-    this.tags = props.tags;
-    this.description = props.description;
-    this.jsDocTags = props.jsDocTags;
-  }
-
-  public static create(
-    props: ClassProperties<MetadataConstantValue>,
-  ): MetadataConstantValue {
-    return new MetadataConstantValue(props);
-  }
-
-  public static from(json: IMetadataConstantValue<any>): MetadataConstantValue {
-    return MetadataConstantValue.create({
-      value: typeof json.value === "bigint" ? BigInt(json.value) : json.value,
-      tags: json.tags,
-      description: json.description,
-      jsDocTags: json.jsDocTags,
-    });
-  }
-
-  public getName(): string {
-    return (this.name_ ??= getName(this));
-  }
-
-  public toJSON(): IMetadataConstantValue<any> {
-    return {
-      value:
-        typeof this.value === "bigint" ? this.value.toString() : this.value,
-      tags: this.tags,
-      description: this.description,
-      jsDocTags: this.jsDocTags,
-    };
-  }
-}
-
-const getName = (obj: MetadataConstantValue): string => {
-  const base: string =
-    typeof obj.value === "string"
-      ? JSON.stringify(obj.value)
-      : obj.value.toString();
-  if (!obj.tags?.length) return base;
-  const rows: string[] = obj.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 { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataConstantValue {
+  public readonly value: boolean | bigint | number | string;
+  public tags: IMetadataTypeTag[][];
+  public readonly description?: string | null;
+  public readonly jsDocTags?: IJsDocTagInfo[];
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataConstantValue>) {
+    this.value = props.value;
+    this.tags = props.tags;
+    this.description = props.description;
+    this.jsDocTags = props.jsDocTags;
+  }
+
+  public static create(
+    props: ClassProperties<MetadataConstantValue>,
+  ): MetadataConstantValue {
+    return new MetadataConstantValue(props);
+  }
+
+  public static from(json: IMetadataConstantValue<any>): MetadataConstantValue {
+    return MetadataConstantValue.create({
+      value: typeof json.value === "bigint" ? BigInt(json.value) : json.value,
+      tags: json.tags,
+      description: json.description,
+      jsDocTags: json.jsDocTags,
+    });
+  }
+
+  public getName(): string {
+    return (this.name_ ??= getName(this));
+  }
+
+  public toJSON(): IMetadataConstantValue<any> {
+    return {
+      value:
+        typeof this.value === "bigint" ? this.value.toString() : this.value,
+      tags: this.tags,
+      description: this.description,
+      jsDocTags: this.jsDocTags,
+    };
+  }
+}
+
+const getName = (obj: MetadataConstantValue): string => {
+  const base: string =
+    typeof obj.value === "string"
+      ? JSON.stringify(obj.value)
+      : obj.value.toString();
+  if (!obj.tags?.length) return base;
+  const rows: string[] = obj.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/MetadataMap.ts

@@ -1,48 +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,
-    };
-  }
-}
+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

@@ -1,44 +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,
-    };
-  }
-}
+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/MetadataObject.ts

@@ -1,48 +1,48 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataObjectType } from "./MetadataObjectType";
-
-export class MetadataObject {
-  public readonly type: MetadataObjectType;
-  public readonly tags: IMetadataTypeTag[][];
-  private name_?: string;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataObject>) {
-    this.type = props.type;
-    this.tags = props.tags;
-  }
-
-  public static create(props: ClassProperties<MetadataObject>): MetadataObject {
-    return new MetadataObject(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(): IMetadataObject {
-    return {
-      name: this.type.name,
-      tags: this.tags.map((row) => row.slice()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataObjectType } from "./MetadataObjectType";
+
+export class MetadataObject {
+  public readonly type: MetadataObjectType;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataObject>) {
+    this.type = props.type;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataObject>): MetadataObject {
+    return new MetadataObject(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(): IMetadataObject {
+    return {
+      name: this.type.name,
+      tags: this.tags.map((row) => row.slice()),
+    };
+  }
+}