typia 7.6.2-dev.20250205 → 7.6.2

package/src/schemas/metadata/MetadataFunction.ts

@@ -1,49 +1,49 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataFunction } from "./IMetadataFunction";
-import { Metadata } from "./Metadata";
-import { MetadataParameter } from "./MetadataParameter";
-
-export class MetadataFunction {
-  public parameters: MetadataParameter[];
-  public output: Metadata;
-  public async: boolean;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataFunction>) {
-    this.parameters = props.parameters;
-    this.output = props.output;
-    this.async = props.async;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: ClassProperties<MetadataFunction>,
-  ): MetadataFunction {
-    return new MetadataFunction(props);
-  }
-
-  public static from(
-    json: IMetadataFunction,
-    dict: IMetadataDictionary,
-  ): MetadataFunction {
-    return MetadataFunction.create({
-      parameters: json.parameters.map((p) => MetadataParameter.from(p, dict)),
-      output: Metadata.from(json.output, dict),
-      async: json.async,
-    });
-  }
-
-  public toJSON(): IMetadataFunction {
-    return {
-      parameters: this.parameters.map((p) => p.toJSON()),
-      output: this.output.toJSON(),
-      async: this.async,
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataFunction } from "./IMetadataFunction";
+import { Metadata } from "./Metadata";
+import { MetadataParameter } from "./MetadataParameter";
+
+export class MetadataFunction {
+  public parameters: MetadataParameter[];
+  public output: Metadata;
+  public async: boolean;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataFunction>) {
+    this.parameters = props.parameters;
+    this.output = props.output;
+    this.async = props.async;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataFunction>,
+  ): MetadataFunction {
+    return new MetadataFunction(props);
+  }
+
+  public static from(
+    json: IMetadataFunction,
+    dict: IMetadataDictionary,
+  ): MetadataFunction {
+    return MetadataFunction.create({
+      parameters: json.parameters.map((p) => MetadataParameter.from(p, dict)),
+      output: Metadata.from(json.output, dict),
+      async: json.async,
+    });
+  }
+
+  public toJSON(): IMetadataFunction {
+    return {
+      parameters: this.parameters.map((p) => p.toJSON()),
+      output: this.output.toJSON(),
+      async: this.async,
+    };
+  }
+}

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()),
+    };
+  }
+}

package/src/schemas/metadata/MetadataObjectType.ts

@@ -1,149 +1,149 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataObjectType } from "./IMetadataObjectType";
-import { MetadataProperty } from "./MetadataProperty";
-
-export class MetadataObjectType {
-  public readonly name: string;
-  public readonly properties: Array<MetadataProperty>;
-  public readonly description: string | undefined;
-  public readonly jsDocTags: IJsDocTagInfo[];
-
-  public readonly index: number;
-  public validated: boolean;
-  public recursive: boolean;
-  public nullables: boolean[] = [];
-
-  /**
-   * @internal
-   */
-  public tagged_: boolean = false;
-
-  /**
-   * @internal
-   */
-  private literal_?: boolean;
-
-  /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-  /**
-   * @hidden
-   */
-  private constructor(
-    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
-  ) {
-    this.name = props.name;
-    this.properties = props.properties;
-    this.description = props.description;
-    this.jsDocTags = props.jsDocTags;
-
-    this.index = props.index;
-    this.validated = props.validated;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables.slice();
-
-    this.tagged_ = false;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
-  ) {
-    return new MetadataObjectType(props);
-  }
-
-  /**
-   * @internal
-   */
-  public static _From_without_properties(
-    obj: IMetadataObjectType,
-  ): MetadataObjectType {
-    return MetadataObjectType.create({
-      name: obj.name,
-      properties: [],
-      description: obj.description,
-      jsDocTags: obj.jsDocTags,
-
-      index: obj.index,
-      validated: false,
-      recursive: obj.recursive,
-      nullables: obj.nullables.slice(),
-    });
-  }
-
-  public isPlain(level: number = 0): boolean {
-    return (
-      this.recursive === false &&
-      this.properties.length < 10 &&
-      this.properties.every(
-        (property) =>
-          property.key.isSoleLiteral() &&
-          property.value.size() === 1 &&
-          property.value.isRequired() === true &&
-          property.value.nullable === false &&
-          (property.value.atomics.length === 1 ||
-            (level < 1 &&
-              property.value.objects.length === 1 &&
-              property.value.objects[0]!.type.isPlain(level + 1))),
-      )
-    );
-  }
-
-  public isLiteral(): boolean {
-    return (this.literal_ ??= (() => {
-      if (this.recursive === true) return false;
-      return (
-        this.name === "__type" ||
-        this.name === "__object" ||
-        this.name.startsWith("__type.") ||
-        this.name.startsWith("__object.") ||
-        this.name.includes("readonly [")
-      );
-    })());
-  }
-
-  public toJSON(): IMetadataObjectType {
-    return {
-      name: this.name,
-      properties: this.properties.map((property) => property.toJSON()),
-      description: this.description,
-      jsDocTags: this.jsDocTags,
-
-      index: this.index,
-      recursive: this.recursive,
-      nullables: this.nullables.slice(),
-    };
-  }
-}
-
-/**
- * @internal
- */
-export namespace MetadataObjectType {
-  export const intersects = (
-    x: MetadataObjectType,
-    y: MetadataObjectType,
-  ): boolean =>
-    x.properties.some(
-      (prop) =>
-        y.properties.find(
-          (oppo) => prop.key.getName() === oppo.key.getName(),
-        ) !== undefined,
-    );
-
-  export const covers = (
-    x: MetadataObjectType,
-    y: MetadataObjectType,
-  ): boolean =>
-    x.properties.length >= y.properties.length &&
-    x.properties.every(
-      (prop) =>
-        y.properties.find(
-          (oppo) => prop.key.getName() === oppo.key.getName(),
-        ) !== undefined,
-    );
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObjectType {
+  public readonly name: string;
+  public readonly properties: Array<MetadataProperty>;
+  public readonly description: string | undefined;
+  public readonly jsDocTags: IJsDocTagInfo[];
+
+  public readonly index: number;
+  public validated: boolean;
+  public recursive: boolean;
+  public nullables: boolean[] = [];
+
+  /**
+   * @internal
+   */
+  public tagged_: boolean = false;
+
+  /**
+   * @internal
+   */
+  private literal_?: boolean;
+
+  /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+  /**
+   * @hidden
+   */
+  private constructor(
+    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
+  ) {
+    this.name = props.name;
+    this.properties = props.properties;
+    this.description = props.description;
+    this.jsDocTags = props.jsDocTags;
+
+    this.index = props.index;
+    this.validated = props.validated;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables.slice();
+
+    this.tagged_ = false;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
+  ) {
+    return new MetadataObjectType(props);
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_properties(
+    obj: IMetadataObjectType,
+  ): MetadataObjectType {
+    return MetadataObjectType.create({
+      name: obj.name,
+      properties: [],
+      description: obj.description,
+      jsDocTags: obj.jsDocTags,
+
+      index: obj.index,
+      validated: false,
+      recursive: obj.recursive,
+      nullables: obj.nullables.slice(),
+    });
+  }
+
+  public isPlain(level: number = 0): boolean {
+    return (
+      this.recursive === false &&
+      this.properties.length < 10 &&
+      this.properties.every(
+        (property) =>
+          property.key.isSoleLiteral() &&
+          property.value.size() === 1 &&
+          property.value.isRequired() === true &&
+          property.value.nullable === false &&
+          (property.value.atomics.length === 1 ||
+            (level < 1 &&
+              property.value.objects.length === 1 &&
+              property.value.objects[0]!.type.isPlain(level + 1))),
+      )
+    );
+  }
+
+  public isLiteral(): boolean {
+    return (this.literal_ ??= (() => {
+      if (this.recursive === true) return false;
+      return (
+        this.name === "__type" ||
+        this.name === "__object" ||
+        this.name.startsWith("__type.") ||
+        this.name.startsWith("__object.") ||
+        this.name.includes("readonly [")
+      );
+    })());
+  }
+
+  public toJSON(): IMetadataObjectType {
+    return {
+      name: this.name,
+      properties: this.properties.map((property) => property.toJSON()),
+      description: this.description,
+      jsDocTags: this.jsDocTags,
+
+      index: this.index,
+      recursive: this.recursive,
+      nullables: this.nullables.slice(),
+    };
+  }
+}
+
+/**
+ * @internal
+ */
+export namespace MetadataObjectType {
+  export const intersects = (
+    x: MetadataObjectType,
+    y: MetadataObjectType,
+  ): boolean =>
+    x.properties.some(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+
+  export const covers = (
+    x: MetadataObjectType,
+    y: MetadataObjectType,
+  ): boolean =>
+    x.properties.length >= y.properties.length &&
+    x.properties.every(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+}