typia 6.6.2 → 6.7.0-dev.20240802

package/src/factories/internal/metadata/emplace_metadata_array_type.ts

@@ -1,42 +1,42 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_array_type =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    aliasType: ts.Type,
-    arrayType: ts.Type,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataArrayType => {
-    // CHECK EXISTENCE
-    const [array, newbie, setValue] = collection.emplaceArray(
-      checker,
-      aliasType,
-    );
-    ArrayUtil.add(array.nullables, nullable);
-    if (newbie === false) return array;
-
-    // CONSTRUCT VALUE TYPE
-    const value: Metadata = explore_metadata(checker)(options)(collection)(
-      errors,
-    )(arrayType.getNumberIndexType()!, {
-      ...explore,
-      escaped: false,
-      aliased: false,
-    });
-    setValue(value);
-
-    return array;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_array_type =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    aliasType: ts.Type,
+    arrayType: ts.Type,
+    nullable: boolean,
+    explore: MetadataFactory.IExplore,
+  ): MetadataArrayType => {
+    // CHECK EXISTENCE
+    const [array, newbie, setValue] = collection.emplaceArray(
+      checker,
+      aliasType,
+    );
+    ArrayUtil.add(array.nullables, nullable);
+    if (newbie === false) return array;
+
+    // CONSTRUCT VALUE TYPE
+    const value: Metadata = explore_metadata(checker)(options)(collection)(
+      errors,
+    )(arrayType.getNumberIndexType()!, {
+      ...explore,
+      escaped: false,
+      aliased: false,
+    });
+    setValue(value);
+
+    return array;
+  };

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -1,176 +1,176 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
-export const emplace_metadata_object =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (parent: ts.Type, nullable: boolean): MetadataObject => {
-    // EMPLACE OBJECT
-    const [obj, newbie] = collection.emplace(checker, parent);
-    ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-
-    if (newbie === false) return obj;
-
-    // PREPARE ASSETS
-    const isClass: boolean = parent.isClass();
-    const pred: (node: ts.Declaration) => boolean = isClass
-      ? (node) => {
-          const kind: ts.SyntaxKind | undefined = node
-            .getChildren()[0]
-            ?.getChildren()[0]?.kind;
-          return (
-            kind !== ts.SyntaxKind.PrivateKeyword &&
-            kind !== ts.SyntaxKind.ProtectedKeyword &&
-            isProperty(node)
-          );
-        }
-      : (node) => isProperty(node);
-
-    const insert =
-      (key: Metadata) =>
-      (value: Metadata) =>
-      (
-        symbol: ts.Symbol | undefined,
-        filter?: (doc: ts.JSDocTagInfo) => boolean,
-      ): MetadataProperty => {
-        // COMMENTS AND TAGS
-        const description: string | null = symbol
-          ? CommentFactory.description(symbol) ?? null
-          : null;
-        const jsDocTags: ts.JSDocTagInfo[] = (
-          symbol?.getJsDocTags() ?? []
-        ).filter(filter ?? (() => true));
-
-        // THE PROPERTY
-        const property = MetadataProperty.create({
-          key,
-          value,
-          description,
-          jsDocTags,
-        });
-        obj.properties.push(property);
-        return property;
-      };
-
-    //----
-    // REGULAR PROPERTIES
-    //----
-    for (const prop of parent.getApparentProperties()) {
-      // CHECK INTERNAL TAG
-      if (
-        (prop.getJsDocTags(checker) ?? []).find(
-          (tag) => tag.name === "internal",
-        ) !== undefined
-      )
-        continue;
-
-      // CHECK NODE IS A FORMAL PROPERTY
-      const [node, type] = (() => {
-        const node = prop.getDeclarations()?.[0] as
-          | ts.PropertyDeclaration
-          | undefined;
-        const type: ts.Type | undefined = node
-          ? checker.getTypeOfSymbolAtLocation(prop, node)
-          : checker.getTypeOfPropertyOfType(parent, prop.name);
-        return [node, type];
-      })();
-      if ((node && pred(node) === false) || type === undefined) continue;
-
-      // GET EXACT TYPE
-      const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
-      const value: Metadata = explore_metadata(checker)(options)(collection)(
-        errors,
-      )(type, {
-        top: false,
-        object: obj,
-        property: prop.name,
-        nested: null,
-        escaped: false,
-        aliased: false,
-      });
-      Writable(value).optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
-      insert(key)(value)(prop);
-    }
-
-    //----
-    // DYNAMIC PROPERTIES
-    //----
-    for (const index of checker.getIndexInfosOfType(parent)) {
-      // GET EXACT TYPE
-      const analyzer = (type: ts.Type) => (property: {} | null) =>
-        explore_metadata(checker)(options)(collection)(errors)(type, {
-          top: false,
-          object: obj,
-          property,
-          nested: null,
-          escaped: false,
-          aliased: false,
-        });
-      const key: Metadata = analyzer(index.keyType)(null);
-      const value: Metadata = analyzer(index.type)({});
-
-      if (
-        key.atomics.length +
-          key.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-          key.templates.length +
-          key.natives.filter(
-            (type) =>
-              type === "Boolean" ||
-              type === "BigInt" ||
-              type === "Number" ||
-              type === "String",
-          ).length !==
-        key.size()
-      )
-        errors.push({
-          name: key.getName(),
-          explore: {
-            top: false,
-            object: obj,
-            property: "[key]",
-            nested: null,
-            escaped: false,
-            aliased: false,
-          },
-          messages: [],
-        });
-
-      // INSERT WITH REQUIRED CONFIGURATION
-      insert(key)(value)(
-        index.declaration?.parent
-          ? checker.getSymbolAtLocation(index.declaration.parent)
-          : undefined,
-        (doc) => doc.name !== "default",
-      );
-    }
-    return obj;
-  };
-
-const isProperty = (node: ts.Declaration) =>
-  ts.isParameter(node) ||
-  ts.isPropertyDeclaration(node) ||
-  ts.isPropertyAssignment(node) ||
-  ts.isPropertySignature(node) ||
-  ts.isTypeLiteralNode(node);
-
-const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
-  if (type.isUnionOrIntersection())
-    type.types.forEach((child) => iterate_optional_coalesce(meta, child));
-  else iterate_metadata_coalesce(meta, type);
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+
+export const emplace_metadata_object =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (parent: ts.Type, nullable: boolean): MetadataObject => {
+    // EMPLACE OBJECT
+    const [obj, newbie] = collection.emplace(checker, parent);
+    ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+
+    if (newbie === false) return obj;
+
+    // PREPARE ASSETS
+    const isClass: boolean = parent.isClass();
+    const pred: (node: ts.Declaration) => boolean = isClass
+      ? (node) => {
+          const kind: ts.SyntaxKind | undefined = node
+            .getChildren()[0]
+            ?.getChildren()[0]?.kind;
+          return (
+            kind !== ts.SyntaxKind.PrivateKeyword &&
+            kind !== ts.SyntaxKind.ProtectedKeyword &&
+            isProperty(node)
+          );
+        }
+      : (node) => isProperty(node);
+
+    const insert =
+      (key: Metadata) =>
+      (value: Metadata) =>
+      (
+        symbol: ts.Symbol | undefined,
+        filter?: (doc: ts.JSDocTagInfo) => boolean,
+      ): MetadataProperty => {
+        // COMMENTS AND TAGS
+        const description: string | null = symbol
+          ? CommentFactory.description(symbol) ?? null
+          : null;
+        const jsDocTags: ts.JSDocTagInfo[] = (
+          symbol?.getJsDocTags() ?? []
+        ).filter(filter ?? (() => true));
+
+        // THE PROPERTY
+        const property = MetadataProperty.create({
+          key,
+          value,
+          description,
+          jsDocTags,
+        });
+        obj.properties.push(property);
+        return property;
+      };
+
+    //----
+    // REGULAR PROPERTIES
+    //----
+    for (const prop of parent.getApparentProperties()) {
+      // CHECK INTERNAL TAG
+      if (
+        (prop.getJsDocTags(checker) ?? []).find(
+          (tag) => tag.name === "internal",
+        ) !== undefined
+      )
+        continue;
+
+      // CHECK NODE IS A FORMAL PROPERTY
+      const [node, type] = (() => {
+        const node = prop.getDeclarations()?.[0] as
+          | ts.PropertyDeclaration
+          | undefined;
+        const type: ts.Type | undefined = node
+          ? checker.getTypeOfSymbolAtLocation(prop, node)
+          : checker.getTypeOfPropertyOfType(parent, prop.name);
+        return [node, type];
+      })();
+      if ((node && pred(node) === false) || type === undefined) continue;
+
+      // GET EXACT TYPE
+      const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+      const value: Metadata = explore_metadata(checker)(options)(collection)(
+        errors,
+      )(type, {
+        top: false,
+        object: obj,
+        property: prop.name,
+        nested: null,
+        escaped: false,
+        aliased: false,
+      });
+      Writable(value).optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+      insert(key)(value)(prop);
+    }
+
+    //----
+    // DYNAMIC PROPERTIES
+    //----
+    for (const index of checker.getIndexInfosOfType(parent)) {
+      // GET EXACT TYPE
+      const analyzer = (type: ts.Type) => (property: {} | null) =>
+        explore_metadata(checker)(options)(collection)(errors)(type, {
+          top: false,
+          object: obj,
+          property,
+          nested: null,
+          escaped: false,
+          aliased: false,
+        });
+      const key: Metadata = analyzer(index.keyType)(null);
+      const value: Metadata = analyzer(index.type)({});
+
+      if (
+        key.atomics.length +
+          key.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+          key.templates.length +
+          key.natives.filter(
+            (type) =>
+              type === "Boolean" ||
+              type === "BigInt" ||
+              type === "Number" ||
+              type === "String",
+          ).length !==
+        key.size()
+      )
+        errors.push({
+          name: key.getName(),
+          explore: {
+            top: false,
+            object: obj,
+            property: "[key]",
+            nested: null,
+            escaped: false,
+            aliased: false,
+          },
+          messages: [],
+        });
+
+      // INSERT WITH REQUIRED CONFIGURATION
+      insert(key)(value)(
+        index.declaration?.parent
+          ? checker.getSymbolAtLocation(index.declaration.parent)
+          : undefined,
+        (doc) => doc.name !== "default",
+      );
+    }
+    return obj;
+  };
+
+const isProperty = (node: ts.Declaration) =>
+  ts.isParameter(node) ||
+  ts.isPropertyDeclaration(node) ||
+  ts.isPropertyAssignment(node) ||
+  ts.isPropertySignature(node) ||
+  ts.isTypeLiteralNode(node);
+
+const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
+  if (type.isUnionOrIntersection())
+    type.types.forEach((child) => iterate_optional_coalesce(meta, child));
+  else iterate_metadata_coalesce(meta, type);
+};

package/src/factories/internal/metadata/emplace_metadata_tuple.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_tuple =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    type: ts.TupleType,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataTupleType => {
-    // CHECK EXISTENCE
-    const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
-    ArrayUtil.add(tuple.nullables, nullable);
-    if (newbie === false) return tuple;
-
-    // CONSTRUCT ELEMENT TYPES
-    const flagList: readonly ts.ElementFlags[] =
-      type.elementFlags ?? (type.target as ts.TupleType)?.elementFlags ?? [];
-    const elements: Metadata[] = checker
-      .getTypeArguments(type as ts.TypeReference)
-      .map((elem, i) => {
-        const child: Metadata = explore_metadata(checker)(options)(collection)(
-          errors,
-        )(elem, {
-          ...explore,
-          nested: tuple,
-          aliased: false,
-          escaped: false,
-        });
-
-        // CHECK OPTIONAL
-        const flag: ts.ElementFlags | undefined = flagList[i];
-        if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
-
-        // REST TYPE
-        if (flag !== ts.ElementFlags.Rest) return child;
-        const wrapper: Metadata = Metadata.initialize();
-        Writable(wrapper).rest = child;
-        return wrapper;
-      });
-    closure(elements);
-
-    return tuple;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    type: ts.TupleType,
+    nullable: boolean,
+    explore: MetadataFactory.IExplore,
+  ): MetadataTupleType => {
+    // CHECK EXISTENCE
+    const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
+    ArrayUtil.add(tuple.nullables, nullable);
+    if (newbie === false) return tuple;
+
+    // CONSTRUCT ELEMENT TYPES
+    const flagList: readonly ts.ElementFlags[] =
+      type.elementFlags ?? (type.target as ts.TupleType)?.elementFlags ?? [];
+    const elements: Metadata[] = checker
+      .getTypeArguments(type as ts.TypeReference)
+      .map((elem, i) => {
+        const child: Metadata = explore_metadata(checker)(options)(collection)(
+          errors,
+        )(elem, {
+          ...explore,
+          nested: tuple,
+          aliased: false,
+          escaped: false,
+        });
+
+        // CHECK OPTIONAL
+        const flag: ts.ElementFlags | undefined = flagList[i];
+        if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
+
+        // REST TYPE
+        if (flag !== ts.ElementFlags.Rest) return child;
+        const wrapper: Metadata = Metadata.initialize();
+        Writable(wrapper).rest = child;
+        return wrapper;
+      });
+    closure(elements);
+
+    return tuple;
+  };

package/src/factories/internal/metadata/explore_metadata.ts

@@ -1,28 +1,28 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
-    // CONSTRUCT METADATA
-    const meta: Metadata = Metadata.initialize(explore.escaped);
-    if (type === null) return meta;
-
-    // ITERATE TYPESCRIPT TYPES
-    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
-    emend_metadata_atomics(meta);
-    if (meta.escaped) {
-      emend_metadata_atomics(meta.escaped.original);
-      emend_metadata_atomics(meta.escaped.returns);
-    }
-    return meta;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
+    // CONSTRUCT METADATA
+    const meta: Metadata = Metadata.initialize(explore.escaped);
+    if (type === null) return meta;
+
+    // ITERATE TYPESCRIPT TYPES
+    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
+    emend_metadata_atomics(meta);
+    if (meta.escaped) {
+      emend_metadata_atomics(meta.escaped.original);
+      emend_metadata_atomics(meta.escaped.returns);
+    }
+    return meta;
+  };