typia 7.0.0-dev.20241005 → 7.0.0-dev.20241007

package/src/factories/LiteralFactory.ts

@@ -4,15 +4,15 @@ import { ExpressionFactory } from "./ExpressionFactory";
 import { IdentifierFactory } from "./IdentifierFactory";
 
 export namespace LiteralFactory {
-  export const generate = (input: any): ts.Expression => {
+  export const write = (input: any): ts.Expression => {
     if (input === null) return ts.factory.createNull();
     else if (ts.isIdentifier(input)) return input;
-    else if (input instanceof Array) return generate_array(input);
-    else if (typeof input === "object") return generate_object(input);
-    else if (typeof input === "string") return generate_string(input);
-    else if (typeof input === "boolean") return generate_value(input);
-    else if (typeof input === "number") return generate_value(input);
-    else if (typeof input === "bigint") return generate_bigint(input);
+    else if (input instanceof Array) return writeArray(input);
+    else if (typeof input === "object") return writeObject(input);
+    else if (typeof input === "boolean") return writeBoolean(input);
+    else if (typeof input === "bigint") return writeBigint(input);
+    else if (typeof input === "number") return writeNumber(input);
+    else if (typeof input === "string") return writeStrinng(input);
     // unreachable code
     else if (typeof input === "function")
       return ts.factory.createIdentifier("undefined");
@@ -20,28 +20,31 @@ export namespace LiteralFactory {
       throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
   };
 
-  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
+  const writeObject = (obj: object): ts.ObjectLiteralExpression =>
     ts.factory.createObjectLiteralExpression(
       Object.entries(obj)
         .filter((tuple) => tuple[1] !== undefined)
         .map(([key, value]) =>
           ts.factory.createPropertyAssignment(
             IdentifierFactory.identifier(key),
-            generate(value),
+            write(value),
           ),
         ),
       true,
     );
 
-  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(array.map(generate), true);
+  const writeArray = (array: any[]): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(array.map(write), true);
 
-  const generate_value = (value: number | boolean | bigint): ts.Expression =>
-    ts.factory.createIdentifier(value.toString());
+  const writeBoolean = (value: boolean): ts.Expression =>
+    value ? ts.factory.createTrue() : ts.factory.createFalse();
 
-  const generate_bigint = (value: bigint): ts.Expression =>
+  const writeNumber = (value: number): ts.Expression =>
+    ExpressionFactory.number(value);
+
+  const writeBigint = (value: bigint): ts.Expression =>
     ExpressionFactory.bigint(value);
 
-  const generate_string = (value: string): ts.StringLiteral =>
+  const writeStrinng = (value: string): ts.StringLiteral =>
     ts.factory.createStringLiteral(value);
 }

package/src/factories/MetadataCollection.ts

@@ -1,278 +1,278 @@
-import ts from "typescript";
-
-import { IMetadataComponents } from "../schemas/metadata/IMetadataComponents";
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
-
-import { Writable } from "../typings/Writable";
-
-import { MapUtil } from "../utils/MapUtil";
-
-import { CommentFactory } from "./CommentFactory";
-import { TypeFactory } from "./TypeFactory";
-
-export class MetadataCollection {
-  private objects_: Map<ts.Type, MetadataObject>;
-  private object_unions_: Map<string, MetadataObject[]>;
-  private aliases_: Map<ts.Type, MetadataAlias>;
-  private arrays_: Map<ts.Type, MetadataArrayType>;
-  private tuples_: Map<ts.Type, MetadataTupleType>;
-
-  private names_: Map<string, Map<ts.Type, string>>;
-  private object_index_: number;
-  private recursive_array_index_: number;
-  private recursive_tuple_index_: number;
-
-  public constructor(
-    private readonly options?: Partial<MetadataCollection.IOptions>,
-  ) {
-    this.objects_ = new Map();
-    this.object_unions_ = new Map();
-    this.aliases_ = new Map();
-    this.arrays_ = new Map();
-    this.tuples_ = new Map();
-
-    this.names_ = new Map();
-    this.object_index_ = 0;
-    this.recursive_array_index_ = 0;
-    this.recursive_tuple_index_ = 0;
-  }
-
-  public clone(): MetadataCollection {
-    const output: MetadataCollection = new MetadataCollection();
-    output.objects_ = new Map(this.objects_);
-    output.object_unions_ = new Map(this.object_unions_);
-    output.aliases_ = new Map(this.aliases_);
-    output.arrays_ = new Map(this.arrays_);
-    output.tuples_ = new Map(this.tuples_);
-    output.names_ = new Map(this.names_);
-    output.object_index_ = this.object_index_;
-    output.recursive_array_index_ = this.recursive_array_index_;
-    output.recursive_tuple_index_ = this.recursive_tuple_index_;
-    return output;
-  }
-
-  /* -----------------------------------------------------------
-        ACCESSORS
-    ----------------------------------------------------------- */
-  public aliases(): MetadataAlias[] {
-    return [...this.aliases_.values()];
-  }
-
-  public objects(): MetadataObject[] {
-    return [...this.objects_.values()];
-  }
-
-  public unions(): MetadataObject[][] {
-    return [...this.object_unions_.values()];
-  }
-
-  public arrays(): MetadataArrayType[] {
-    return [...this.arrays_.values()];
-  }
-
-  public tuples(): MetadataTupleType[] {
-    return [...this.tuples_.values()];
-  }
-
-  private getName(checker: ts.TypeChecker, type: ts.Type): string {
-    const name: string = (() => {
-      const str: string = TypeFactory.getFullName({
-        checker,
-        type,
-      });
-      return this.options?.replace ? this.options.replace(str) : str;
-    })();
-
-    const duplicates: Map<ts.Type, string> = MapUtil.take(
-      this.names_,
-      name,
-      () => new Map(),
-    );
-    const oldbie: string | undefined = duplicates.get(type);
-    if (oldbie !== undefined) return oldbie;
-
-    const addicted: string = duplicates.size
-      ? `${name}.o${duplicates.size}`
-      : name;
-    duplicates.set(type, addicted);
-    return addicted;
-  }
-
-  /**
-   * @internal
-   */
-  public getUnionIndex(meta: Metadata): number {
-    const key: string = meta.objects.map((obj) => obj.name).join(" | ");
-    MapUtil.take(this.object_unions_, key, () => meta.objects);
-    return [...this.object_unions_.keys()].indexOf(key);
-  }
-
-  /* -----------------------------------------------------------
-        INSTANCES
-    ----------------------------------------------------------- */
-  public emplace(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-  ): [MetadataObject, boolean] {
-    const oldbie = this.objects_.get(type);
-    if (oldbie !== undefined) return [oldbie, false];
-
-    const $id: string = this.getName(checker, type);
-    const obj: MetadataObject = MetadataObject.create({
-      name: $id,
-      properties: [],
-      description:
-        (type.aliasSymbol && CommentFactory.description(type.aliasSymbol)) ??
-        (type.symbol && CommentFactory.description(type.symbol)) ??
-        undefined,
-      jsDocTags:
-        type.aliasSymbol?.getJsDocTags() ?? type.symbol?.getJsDocTags() ?? [],
-      validated: false,
-      index: this.object_index_++,
-      recursive: null!,
-      nullables: [],
-    });
-    this.objects_.set(type, obj);
-    return [obj, true];
-  }
-
-  public emplaceAlias(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    symbol: ts.Symbol,
-  ): [MetadataAlias, boolean, (meta: Metadata) => void] {
-    const oldbie = this.aliases_.get(type);
-    if (oldbie !== undefined) return [oldbie, false, () => {}];
-
-    const $id: string = this.getName(checker, type);
-    const alias: MetadataAlias = MetadataAlias.create({
-      name: $id,
-      value: null!,
-      description: CommentFactory.description(symbol) ?? null,
-      recursive: null!,
-      nullables: [],
-      jsDocTags: symbol.getJsDocTags() ?? [],
-    });
-    this.aliases_.set(type, alias);
-    return [alias, true, (meta) => (Writable(alias).value = meta)];
-  }
-
-  public emplaceArray(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-  ): [MetadataArrayType, boolean, (meta: Metadata) => void] {
-    const oldbie = this.arrays_.get(type);
-    if (oldbie !== undefined) return [oldbie, false, () => {}];
-
-    const $id = this.getName(checker, type);
-    const array: MetadataArrayType = MetadataArrayType.create({
-      name: $id,
-      value: null!,
-      index: null,
-      recursive: null!,
-      nullables: [],
-    });
-    this.arrays_.set(type, array);
-    return [array, true, (meta) => (Writable(array).value = meta)];
-  }
-
-  public emplaceTuple(
-    checker: ts.TypeChecker,
-    type: ts.TupleType,
-  ): [MetadataTupleType, boolean, (elements: Metadata[]) => void] {
-    const oldbie = this.tuples_.get(type);
-    if (oldbie !== undefined) return [oldbie, false, () => {}];
-
-    const $id = this.getName(checker, type);
-    const tuple: MetadataTupleType = MetadataTupleType.create({
-      name: $id,
-      elements: null!,
-      index: null,
-      recursive: null!,
-      nullables: [],
-    });
-    this.tuples_.set(type, tuple);
-    return [tuple, true, (elements) => (Writable(tuple).elements = elements)];
-  }
-
-  /**
-   * @internal
-   */
-  public setObjectRecursive(obj: MetadataObject, recursive: boolean): void {
-    Writable(obj).recursive = recursive;
-  }
-
-  /**
-   * @internal
-   */
-  public setAliasRecursive(alias: MetadataAlias, recursive: boolean): void {
-    Writable(alias).recursive = recursive;
-  }
-
-  /**
-   * @internal
-   */
-  public setArrayRecursive(array: MetadataArrayType, recursive: boolean): void {
-    Writable(array).recursive = recursive;
-    if (recursive) Writable(array).index = this.recursive_array_index_++;
-  }
-
-  public setTupleRecursive(tuple: MetadataTupleType, recursive: boolean): void {
-    Writable(tuple).recursive = recursive;
-    if (recursive) Writable(tuple).index = this.recursive_tuple_index_++;
-  }
-
-  public toJSON(): IMetadataComponents {
-    return {
-      objects: this.objects().map((o) => o.toJSON()),
-      aliases: this.aliases().map((d) => d.toJSON()),
-      arrays: [...this.arrays_.values()].map((a) => a.toJSON()),
-      tuples: [...this.tuples_.values()].map((t) => t.toJSON()),
-    };
-  }
-}
-export namespace MetadataCollection {
-  export interface IOptions {
-    replace?(str: string): string;
-  }
-
-  export const replace = (str: string): string => {
-    let replaced: string = str;
-    for (const [before] of REPLACERS)
-      replaced = replaced.split(before).join("");
-    if (replaced.length !== 0) return replaced;
-
-    for (const [before, after] of REPLACERS)
-      str = str.split(before).join(after);
-    return str;
-  };
-
-  export const escape = (str: string): string => {
-    for (const [before, after] of REPLACERS)
-      if (after !== "") str = str.split(after).join(before);
-    return str;
-  };
-}
-const REPLACERS: [string, string][] = [
-  ["$", "_dollar_"],
-  ["&", "_and_"],
-  ["|", "_or_"],
-  ["{", "_blt_"],
-  ["}", "_bgt_"],
-  ["<", "_lt_"],
-  [">", "_gt_"],
-  ["[", "_alt_"],
-  ["]", "_agt_"],
-  [",", "_comma_"],
-  ["`", "_backquote_"],
-  ["'", "_singlequote_"],
-  ['"', "_doublequote_"],
-  [" ", "_space_"],
-  ["?", "_question_"],
-  [":", "_colon_"],
-  [";", "_semicolon_"],
-];
+import ts from "typescript";
+
+import { IMetadataComponents } from "../schemas/metadata/IMetadataComponents";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+
+import { Writable } from "../typings/Writable";
+
+import { MapUtil } from "../utils/MapUtil";
+
+import { CommentFactory } from "./CommentFactory";
+import { TypeFactory } from "./TypeFactory";
+
+export class MetadataCollection {
+  private objects_: Map<ts.Type, MetadataObject>;
+  private object_unions_: Map<string, MetadataObject[]>;
+  private aliases_: Map<ts.Type, MetadataAlias>;
+  private arrays_: Map<ts.Type, MetadataArrayType>;
+  private tuples_: Map<ts.Type, MetadataTupleType>;
+
+  private names_: Map<string, Map<ts.Type, string>>;
+  private object_index_: number;
+  private recursive_array_index_: number;
+  private recursive_tuple_index_: number;
+
+  public constructor(
+    private readonly options?: Partial<MetadataCollection.IOptions>,
+  ) {
+    this.objects_ = new Map();
+    this.object_unions_ = new Map();
+    this.aliases_ = new Map();
+    this.arrays_ = new Map();
+    this.tuples_ = new Map();
+
+    this.names_ = new Map();
+    this.object_index_ = 0;
+    this.recursive_array_index_ = 0;
+    this.recursive_tuple_index_ = 0;
+  }
+
+  public clone(): MetadataCollection {
+    const output: MetadataCollection = new MetadataCollection();
+    output.objects_ = new Map(this.objects_);
+    output.object_unions_ = new Map(this.object_unions_);
+    output.aliases_ = new Map(this.aliases_);
+    output.arrays_ = new Map(this.arrays_);
+    output.tuples_ = new Map(this.tuples_);
+    output.names_ = new Map(this.names_);
+    output.object_index_ = this.object_index_;
+    output.recursive_array_index_ = this.recursive_array_index_;
+    output.recursive_tuple_index_ = this.recursive_tuple_index_;
+    return output;
+  }
+
+  /* -----------------------------------------------------------
+        ACCESSORS
+    ----------------------------------------------------------- */
+  public aliases(): MetadataAlias[] {
+    return [...this.aliases_.values()];
+  }
+
+  public objects(): MetadataObject[] {
+    return [...this.objects_.values()];
+  }
+
+  public unions(): MetadataObject[][] {
+    return [...this.object_unions_.values()];
+  }
+
+  public arrays(): MetadataArrayType[] {
+    return [...this.arrays_.values()];
+  }
+
+  public tuples(): MetadataTupleType[] {
+    return [...this.tuples_.values()];
+  }
+
+  private getName(checker: ts.TypeChecker, type: ts.Type): string {
+    const name: string = (() => {
+      const str: string = TypeFactory.getFullName({
+        checker,
+        type,
+      });
+      return this.options?.replace ? this.options.replace(str) : str;
+    })();
+
+    const duplicates: Map<ts.Type, string> = MapUtil.take(
+      this.names_,
+      name,
+      () => new Map(),
+    );
+    const oldbie: string | undefined = duplicates.get(type);
+    if (oldbie !== undefined) return oldbie;
+
+    const addicted: string = duplicates.size
+      ? `${name}.o${duplicates.size}`
+      : name;
+    duplicates.set(type, addicted);
+    return addicted;
+  }
+
+  /**
+   * @internal
+   */
+  public getUnionIndex(meta: Metadata): number {
+    const key: string = meta.objects.map((obj) => obj.name).join(" | ");
+    MapUtil.take(this.object_unions_, key, () => meta.objects);
+    return [...this.object_unions_.keys()].indexOf(key);
+  }
+
+  /* -----------------------------------------------------------
+        INSTANCES
+    ----------------------------------------------------------- */
+  public emplace(
+    checker: ts.TypeChecker,
+    type: ts.Type,
+  ): [MetadataObject, boolean] {
+    const oldbie = this.objects_.get(type);
+    if (oldbie !== undefined) return [oldbie, false];
+
+    const $id: string = this.getName(checker, type);
+    const obj: MetadataObject = MetadataObject.create({
+      name: $id,
+      properties: [],
+      description:
+        (type.aliasSymbol && CommentFactory.description(type.aliasSymbol)) ??
+        (type.symbol && CommentFactory.description(type.symbol)) ??
+        undefined,
+      jsDocTags:
+        type.aliasSymbol?.getJsDocTags() ?? type.symbol?.getJsDocTags() ?? [],
+      validated: false,
+      index: this.object_index_++,
+      recursive: null!,
+      nullables: [],
+    });
+    this.objects_.set(type, obj);
+    return [obj, true];
+  }
+
+  public emplaceAlias(
+    checker: ts.TypeChecker,
+    type: ts.Type,
+    symbol: ts.Symbol,
+  ): [MetadataAlias, boolean, (meta: Metadata) => void] {
+    const oldbie = this.aliases_.get(type);
+    if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+    const $id: string = this.getName(checker, type);
+    const alias: MetadataAlias = MetadataAlias.create({
+      name: $id,
+      value: null!,
+      description: CommentFactory.description(symbol) ?? null,
+      recursive: null!,
+      nullables: [],
+      jsDocTags: symbol.getJsDocTags() ?? [],
+    });
+    this.aliases_.set(type, alias);
+    return [alias, true, (meta) => (Writable(alias).value = meta)];
+  }
+
+  public emplaceArray(
+    checker: ts.TypeChecker,
+    type: ts.Type,
+  ): [MetadataArrayType, boolean, (meta: Metadata) => void] {
+    const oldbie = this.arrays_.get(type);
+    if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+    const $id = this.getName(checker, type);
+    const array: MetadataArrayType = MetadataArrayType.create({
+      name: $id,
+      value: null!,
+      index: null,
+      recursive: null!,
+      nullables: [],
+    });
+    this.arrays_.set(type, array);
+    return [array, true, (meta) => (Writable(array).value = meta)];
+  }
+
+  public emplaceTuple(
+    checker: ts.TypeChecker,
+    type: ts.TupleType,
+  ): [MetadataTupleType, boolean, (elements: Metadata[]) => void] {
+    const oldbie = this.tuples_.get(type);
+    if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+    const $id = this.getName(checker, type);
+    const tuple: MetadataTupleType = MetadataTupleType.create({
+      name: $id,
+      elements: null!,
+      index: null,
+      recursive: null!,
+      nullables: [],
+    });
+    this.tuples_.set(type, tuple);
+    return [tuple, true, (elements) => (Writable(tuple).elements = elements)];
+  }
+
+  /**
+   * @internal
+   */
+  public setObjectRecursive(obj: MetadataObject, recursive: boolean): void {
+    Writable(obj).recursive = recursive;
+  }
+
+  /**
+   * @internal
+   */
+  public setAliasRecursive(alias: MetadataAlias, recursive: boolean): void {
+    Writable(alias).recursive = recursive;
+  }
+
+  /**
+   * @internal
+   */
+  public setArrayRecursive(array: MetadataArrayType, recursive: boolean): void {
+    Writable(array).recursive = recursive;
+    if (recursive) Writable(array).index = this.recursive_array_index_++;
+  }
+
+  public setTupleRecursive(tuple: MetadataTupleType, recursive: boolean): void {
+    Writable(tuple).recursive = recursive;
+    if (recursive) Writable(tuple).index = this.recursive_tuple_index_++;
+  }
+
+  public toJSON(): IMetadataComponents {
+    return {
+      objects: this.objects().map((o) => o.toJSON()),
+      aliases: this.aliases().map((d) => d.toJSON()),
+      arrays: [...this.arrays_.values()].map((a) => a.toJSON()),
+      tuples: [...this.tuples_.values()].map((t) => t.toJSON()),
+    };
+  }
+}
+export namespace MetadataCollection {
+  export interface IOptions {
+    replace?(str: string): string;
+  }
+
+  export const replace = (str: string): string => {
+    let replaced: string = str;
+    for (const [before] of REPLACERS)
+      replaced = replaced.split(before).join("");
+    if (replaced.length !== 0) return replaced;
+
+    for (const [before, after] of REPLACERS)
+      str = str.split(before).join(after);
+    return str;
+  };
+
+  export const escape = (str: string): string => {
+    for (const [before, after] of REPLACERS)
+      if (after !== "") str = str.split(after).join(before);
+    return str;
+  };
+}
+const REPLACERS: [string, string][] = [
+  ["$", "_dollar_"],
+  ["&", "_and_"],
+  ["|", "_or_"],
+  ["{", "_blt_"],
+  ["}", "_bgt_"],
+  ["<", "_lt_"],
+  [">", "_gt_"],
+  ["[", "_alt_"],
+  ["]", "_agt_"],
+  [",", "_comma_"],
+  ["`", "_backquote_"],
+  ["'", "_singlequote_"],
+  ['"', "_doublequote_"],
+  [" ", "_space_"],
+  ["?", "_question_"],
+  [":", "_colon_"],
+  [";", "_semicolon_"],
+];