typia 7.0.0-dev.20241005 → 7.0.0-dev.20241008

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

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[][] | undefined;
-  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[][] | undefined;
+  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/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/MetadataObject.ts

@@ -1,139 +1,139 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataObject } from "./IMetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
-
-export class MetadataObject {
-  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<MetadataObject>, "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<MetadataObject>, "tagged_">,
-  ) {
-    return new MetadataObject(props);
-  }
-
-  /**
-   * @internal
-   */
-  public static _From_without_properties(obj: IMetadataObject): MetadataObject {
-    return MetadataObject.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]!.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(): IMetadataObject {
-    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 MetadataObject {
-  export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
-    x.properties.some(
-      (prop) =>
-        y.properties.find(
-          (oppo) => prop.key.getName() === oppo.key.getName(),
-        ) !== undefined,
-    );
-
-  export const covers = (x: MetadataObject, y: MetadataObject): 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 { IMetadataObject } from "./IMetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObject {
+  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<MetadataObject>, "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<MetadataObject>, "tagged_">,
+  ) {
+    return new MetadataObject(props);
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_properties(obj: IMetadataObject): MetadataObject {
+    return MetadataObject.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]!.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(): IMetadataObject {
+    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 MetadataObject {
+  export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
+    x.properties.some(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+
+  export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
+    x.properties.length >= y.properties.length &&
+    x.properties.every(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+}