typia 7.2.1 → 7.3.0-dev.20241213

package/src/schemas/metadata/MetadataAlias.ts

@@ -1,46 +1,46 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataAliasType } from "./MetadataAliasType";
-
-export class MetadataAlias {
-  public readonly type: MetadataAliasType;
-  public readonly tags: IMetadataTypeTag[][];
-  private name_?: string;
-
-  private constructor(props: ClassProperties<MetadataAlias>) {
-    this.type = props.type;
-    this.tags = props.tags;
-    this.type = props.type;
-  }
-
-  public static create(props: ClassProperties<MetadataAlias>): MetadataAlias {
-    return new MetadataAlias(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(): IMetadataAlias {
-    return {
-      name: this.type.name,
-      tags: this.tags,
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataAliasType } from "./MetadataAliasType";
+
+export class MetadataAlias {
+  public readonly type: MetadataAliasType;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataAlias>) {
+    this.type = props.type;
+    this.tags = props.tags;
+    this.type = props.type;
+  }
+
+  public static create(props: ClassProperties<MetadataAlias>): MetadataAlias {
+    return new MetadataAlias(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(): IMetadataAlias {
+    return {
+      name: this.type.name,
+      tags: this.tags,
+    };
+  }
+}

package/src/schemas/metadata/MetadataAliasType.ts

@@ -1,63 +1,63 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataAliasType } from "./IMetadataAliasType";
-import { Metadata } from "./Metadata";
-
-export class MetadataAliasType {
-  public readonly name: string;
-  public readonly value: Metadata;
-  public readonly description: string | null;
-  public readonly jsDocTags: IJsDocTagInfo[];
-  public readonly recursive: boolean;
-  public readonly nullables: boolean[];
-
-  /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataAliasType>) {
-    this.name = props.name;
-    this.value = props.value;
-    this.description = props.description;
-    this.jsDocTags = props.jsDocTags;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: ClassProperties<MetadataAliasType>,
-  ): MetadataAliasType {
-    return new MetadataAliasType(props);
-  }
-
-  /**
-   * @internal
-   */
-  public static _From_without_value(props: Omit<IMetadataAliasType, "value">) {
-    return MetadataAliasType.create({
-      name: props.name,
-      value: null!,
-      description: props.description,
-      recursive: props.recursive,
-      jsDocTags: props.jsDocTags.slice(),
-      nullables: props.nullables.slice(),
-    });
-  }
-
-  public toJSON(): IMetadataAliasType {
-    return {
-      name: this.name,
-      value: this.value.toJSON(),
-      description: this.description,
-      recursive: this.recursive,
-      jsDocTags: this.jsDocTags.slice(),
-      nullables: this.nullables.slice(),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { Metadata } from "./Metadata";
+
+export class MetadataAliasType {
+  public readonly name: string;
+  public readonly value: Metadata;
+  public readonly description: string | null;
+  public readonly jsDocTags: IJsDocTagInfo[];
+  public readonly recursive: boolean;
+  public readonly nullables: boolean[];
+
+  /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataAliasType>) {
+    this.name = props.name;
+    this.value = props.value;
+    this.description = props.description;
+    this.jsDocTags = props.jsDocTags;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataAliasType>,
+  ): MetadataAliasType {
+    return new MetadataAliasType(props);
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_value(props: Omit<IMetadataAliasType, "value">) {
+    return MetadataAliasType.create({
+      name: props.name,
+      value: null!,
+      description: props.description,
+      recursive: props.recursive,
+      jsDocTags: props.jsDocTags.slice(),
+      nullables: props.nullables.slice(),
+    });
+  }
+
+  public toJSON(): IMetadataAliasType {
+    return {
+      name: this.name,
+      value: this.value.toJSON(),
+      description: this.description,
+      recursive: this.recursive,
+      jsDocTags: this.jsDocTags.slice(),
+      nullables: this.nullables.slice(),
+    };
+  }
+}

package/src/schemas/metadata/MetadataApplication.ts

@@ -1,44 +1,44 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataApplication } from "./IMetadataApplication";
-import { Metadata } from "./Metadata";
-import { MetadataComponents } from "./MetadataComponents";
-
-export class MetadataApplication {
-  public readonly metadatas: Metadata[];
-  public readonly components: MetadataComponents;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataApplication>) {
-    this.metadatas = props.metadatas;
-    this.components = props.components;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: ClassProperties<MetadataApplication>,
-  ): MetadataApplication {
-    return new MetadataApplication(props);
-  }
-
-  public static from(app: IMetadataApplication): MetadataApplication {
-    const components: MetadataComponents = MetadataComponents.from(
-      app.components,
-    );
-    const metadatas: Metadata[] = app.metadatas.map((metadata) =>
-      Metadata.from(metadata, components.dictionary),
-    );
-    return MetadataApplication.create({ metadatas, components });
-  }
-
-  public toJSON(): IMetadataApplication {
-    return {
-      metadatas: this.metadatas.map((metadata) => metadata.toJSON()),
-      components: this.components.toJSON(),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataApplication } from "./IMetadataApplication";
+import { Metadata } from "./Metadata";
+import { MetadataComponents } from "./MetadataComponents";
+
+export class MetadataApplication {
+  public readonly metadatas: Metadata[];
+  public readonly components: MetadataComponents;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataApplication>) {
+    this.metadatas = props.metadatas;
+    this.components = props.components;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataApplication>,
+  ): MetadataApplication {
+    return new MetadataApplication(props);
+  }
+
+  public static from(app: IMetadataApplication): MetadataApplication {
+    const components: MetadataComponents = MetadataComponents.from(
+      app.components,
+    );
+    const metadatas: Metadata[] = app.metadatas.map((metadata) =>
+      Metadata.from(metadata, components.dictionary),
+    );
+    return MetadataApplication.create({ metadatas, components });
+  }
+
+  public toJSON(): IMetadataApplication {
+    return {
+      metadatas: this.metadatas.map((metadata) => metadata.toJSON()),
+      components: this.components.toJSON(),
+    };
+  }
+}

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/MetadataAtomic.ts

@@ -1,87 +1,87 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataAtomic } from "./IMetadataAtomic";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export class MetadataAtomic {
-  public readonly type: "boolean" | "bigint" | "number" | "string";
-  public readonly tags: IMetadataTypeTag[][];
-
-  private name_?: string;
-
-  /**
-   * @internal
-   */
-  private constructor(props: ClassProperties<MetadataAtomic>) {
-    this.type = props.type;
-    this.tags = props.tags;
-  }
-
-  public static create(props: ClassProperties<MetadataAtomic>): MetadataAtomic {
-    return new MetadataAtomic(props);
-  }
-
-  public static from(json: IMetadataAtomic): MetadataAtomic {
-    return MetadataAtomic.create({
-      type: json.type,
-      tags: json.tags.map((row) =>
-        row.map((tag) => ({
-          target: tag.target,
-          name: tag.name,
-          kind: tag.kind,
-          value:
-            typeof tag.value === "object" &&
-            tag.value?.type === "bigint" &&
-            typeof tag.value.value === "string"
-              ? BigInt(tag.value.value)
-              : tag.value,
-          validate: tag.validate,
-          exclusive: tag.exclusive,
-          schema: tag.schema,
-        })),
-      ),
-    });
-  }
-
-  public getName(): string {
-    return (this.name_ ??= getName(this));
-  }
-
-  public toJSON(): IMetadataAtomic {
-    return {
-      type: this.type,
-      tags: this.tags.map((row) =>
-        row.map((tag) => ({
-          target: tag.target,
-          name: tag.name,
-          kind: tag.kind,
-          value:
-            typeof tag.value === "bigint"
-              ? {
-                  type: "bigint",
-                  value: tag.value.toString(),
-                }
-              : tag.value,
-          validate: tag.validate,
-          exclusive: tag.exclusive,
-          schema: tag.schema,
-        })),
-      ),
-    };
-  }
-}
-
-const getName = (obj: MetadataAtomic): string => {
-  if (obj.tags.length === 0) return obj.type;
-  else if (obj.tags.length === 1) {
-    const str: string = [obj.type, ...obj.tags[0]!.map((t) => t.name)].join(
-      " & ",
-    );
-    return `(${str})`;
-  }
-  const rows: string[] = obj.tags.map((row) => {
-    const str: string = row.map((t) => t.name).join(" & ");
-    return row.length === 1 ? str : `(${str})`;
-  });
-  return `(${obj.type} & (${rows.join(" | ")}))`;
-};
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataAtomic {
+  public readonly type: "boolean" | "bigint" | "number" | "string";
+  public readonly tags: IMetadataTypeTag[][];
+
+  private name_?: string;
+
+  /**
+   * @internal
+   */
+  private constructor(props: ClassProperties<MetadataAtomic>) {
+    this.type = props.type;
+    this.tags = props.tags;
+  }
+
+  public static create(props: ClassProperties<MetadataAtomic>): MetadataAtomic {
+    return new MetadataAtomic(props);
+  }
+
+  public static from(json: IMetadataAtomic): MetadataAtomic {
+    return MetadataAtomic.create({
+      type: json.type,
+      tags: json.tags.map((row) =>
+        row.map((tag) => ({
+          target: tag.target,
+          name: tag.name,
+          kind: tag.kind,
+          value:
+            typeof tag.value === "object" &&
+            tag.value?.type === "bigint" &&
+            typeof tag.value.value === "string"
+              ? BigInt(tag.value.value)
+              : tag.value,
+          validate: tag.validate,
+          exclusive: tag.exclusive,
+          schema: tag.schema,
+        })),
+      ),
+    });
+  }
+
+  public getName(): string {
+    return (this.name_ ??= getName(this));
+  }
+
+  public toJSON(): IMetadataAtomic {
+    return {
+      type: this.type,
+      tags: this.tags.map((row) =>
+        row.map((tag) => ({
+          target: tag.target,
+          name: tag.name,
+          kind: tag.kind,
+          value:
+            typeof tag.value === "bigint"
+              ? {
+                  type: "bigint",
+                  value: tag.value.toString(),
+                }
+              : tag.value,
+          validate: tag.validate,
+          exclusive: tag.exclusive,
+          schema: tag.schema,
+        })),
+      ),
+    };
+  }
+}
+
+const getName = (obj: MetadataAtomic): string => {
+  if (obj.tags.length === 0) return obj.type;
+  else if (obj.tags.length === 1) {
+    const str: string = [obj.type, ...obj.tags[0]!.map((t) => t.name)].join(
+      " & ",
+    );
+    return `(${str})`;
+  }
+  const rows: string[] = obj.tags.map((row) => {
+    const str: string = row.map((t) => t.name).join(" & ");
+    return row.length === 1 ? str : `(${str})`;
+  });
+  return `(${obj.type} & (${rows.join(" | ")}))`;
+};