typia 5.3.5-dev.20231206 → 5.3.5

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 { MetadataAlias } from "./MetadataAlias";
-import { MetadataArrayType } from "./MetadataArrayType";
-import { MetadataObject } from "./MetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
-import { MetadataTupleType } from "./MetadataTupleType";
-
-export class MetadataComponents {
-  public readonly aliases: MetadataAlias[];
-  public readonly objects: MetadataObject[];
-  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,
-          MetadataObject._From_without_properties(obj),
-        ]),
-      ),
-      aliases: new Map(
-        json.aliases.map((alias) => [
-          alias.name,
-          MetadataAlias._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 { MetadataAlias } from "./MetadataAlias";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataComponents {
+  public readonly aliases: MetadataAlias[];
+  public readonly objects: MetadataObject[];
+  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,
+          MetadataObject._From_without_properties(obj),
+        ]),
+      ),
+      aliases: new Map(
+        json.aliases.map((alias) => [
+          alias.name,
+          MetadataAlias._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/MetadataConstant.ts

@@ -1,46 +1,46 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export class MetadataConstant {
-  public readonly type: "boolean" | "bigint" | "number" | "string";
-  public readonly values: boolean[] | bigint[] | number[] | string[];
-
-  /**
-   * @internal
-   */
-  public tags?: IMetadataTypeTag[][] | undefined;
-
-  private constructor(props: ClassProperties<MetadataConstant>) {
-    this.type = props.type;
-    this.values = props.values;
-    this.tags = props.tags;
-  }
-
-  public static create(
-    props: ClassProperties<MetadataConstant>,
-  ): MetadataConstant {
-    return new MetadataConstant(props);
-  }
-
-  public static from(json: IMetadataConstant): MetadataConstant {
-    return MetadataConstant.create({
-      type: json.type,
-      values:
-        json.type === "bigint"
-          ? json.values.map((v) => BigInt(v))
-          : (json.values as any[]),
-    });
-  }
-
-  public toJSON(): IMetadataConstant {
-    return {
-      type: this.type,
-      values:
-        this.type === "bigint"
-          ? this.values.map((v) => v.toString())
-          : (this.values as any[]),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataConstant {
+  public readonly type: "boolean" | "bigint" | "number" | "string";
+  public readonly values: boolean[] | bigint[] | number[] | string[];
+
+  /**
+   * @internal
+   */
+  public tags?: IMetadataTypeTag[][] | undefined;
+
+  private constructor(props: ClassProperties<MetadataConstant>) {
+    this.type = props.type;
+    this.values = props.values;
+    this.tags = props.tags;
+  }
+
+  public static create(
+    props: ClassProperties<MetadataConstant>,
+  ): MetadataConstant {
+    return new MetadataConstant(props);
+  }
+
+  public static from(json: IMetadataConstant): MetadataConstant {
+    return MetadataConstant.create({
+      type: json.type,
+      values:
+        json.type === "bigint"
+          ? json.values.map((v) => BigInt(v))
+          : (json.values as any[]),
+    });
+  }
+
+  public toJSON(): IMetadataConstant {
+    return {
+      type: this.type,
+      values:
+        this.type === "bigint"
+          ? this.values.map((v) => v.toString())
+          : (this.values as any[]),
+    };
+  }
+}

package/src/schemas/metadata/MetadataEscaped.ts

@@ -1,51 +1,51 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataEscaped } from "./IMetadataEscaped";
-import { Metadata } from "./Metadata";
-
-export class MetadataEscaped {
-  public readonly original: Metadata;
-  public readonly returns: Metadata;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataEscaped>) {
-    this.original = props.original;
-    this.returns = props.returns;
-  }
-
-  /**
-   * @internal
-   */
-  public static from(
-    props: IMetadataEscaped,
-    dict: IMetadataDictionary,
-  ): MetadataEscaped {
-    return MetadataEscaped.create({
-      original: Metadata.from(props.original, dict),
-      returns: Metadata.from(props.returns, dict),
-    });
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: ClassProperties<MetadataEscaped>,
-  ): MetadataEscaped {
-    return new MetadataEscaped(props);
-  }
-
-  public getName(): string {
-    return this.returns.getName();
-  }
-
-  public toJSON(): IMetadataEscaped {
-    return {
-      original: this.original.toJSON(),
-      returns: this.returns.toJSON(),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { Metadata } from "./Metadata";
+
+export class MetadataEscaped {
+  public readonly original: Metadata;
+  public readonly returns: Metadata;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataEscaped>) {
+    this.original = props.original;
+    this.returns = props.returns;
+  }
+
+  /**
+   * @internal
+   */
+  public static from(
+    props: IMetadataEscaped,
+    dict: IMetadataDictionary,
+  ): MetadataEscaped {
+    return MetadataEscaped.create({
+      original: Metadata.from(props.original, dict),
+      returns: Metadata.from(props.returns, dict),
+    });
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataEscaped>,
+  ): MetadataEscaped {
+    return new MetadataEscaped(props);
+  }
+
+  public getName(): string {
+    return this.returns.getName();
+  }
+
+  public toJSON(): IMetadataEscaped {
+    return {
+      original: this.original.toJSON(),
+      returns: this.returns.toJSON(),
+    };
+  }
+}

package/src/schemas/metadata/MetadataObject.ts

@@ -1,135 +1,135 @@
-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;
-
-  /* -----------------------------------------------------------
-        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: obj.validated,
-      recursive: obj.recursive,
-      nullables: obj.nullables.slice(),
-    });
-  }
-
-  /**
-   * @internal
-   */
-  public _Messagable(): boolean {
-    return (
-      this.properties.length >= 1 &&
-      this.properties.every((p) => p.key.isSoleLiteral())
-    );
-  }
-
-  /**
-   * @internal
-   */
-  public _Is_simple(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]!._Is_simple(level + 1))),
-      )
-    );
-  }
-
-  public toJSON(): IMetadataObject {
-    return {
-      name: this.name,
-      properties: this.properties.map((property) => property.toJSON()),
-      description: this.description,
-      jsDocTags: this.jsDocTags,
-
-      index: this.index,
-      validated: this.validated,
-      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;
+
+  /* -----------------------------------------------------------
+        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: obj.validated,
+      recursive: obj.recursive,
+      nullables: obj.nullables.slice(),
+    });
+  }
+
+  /**
+   * @internal
+   */
+  public _Messagable(): boolean {
+    return (
+      this.properties.length >= 1 &&
+      this.properties.every((p) => p.key.isSoleLiteral())
+    );
+  }
+
+  /**
+   * @internal
+   */
+  public _Is_simple(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]!._Is_simple(level + 1))),
+      )
+    );
+  }
+
+  public toJSON(): IMetadataObject {
+    return {
+      name: this.name,
+      properties: this.properties.map((property) => property.toJSON()),
+      description: this.description,
+      jsDocTags: this.jsDocTags,
+
+      index: this.index,
+      validated: this.validated,
+      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,
+    );
+}