typia 5.0.0-dev.20230820 → 5.0.0-dev.20230821

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

@@ -1,12 +1,12 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-export namespace MetadataHelper {
-    export const literal_to_metadata = (key: string): Metadata => {
-        const metadata: Metadata = Metadata.initialize();
-        metadata.constants.push({
-            type: "string",
-            values: [key],
-        });
-        return metadata;
-    };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+export namespace MetadataHelper {
+    export const literal_to_metadata = (key: string): Metadata => {
+        const metadata: Metadata = Metadata.initialize();
+        metadata.constants.push({
+            type: "string",
+            values: [key],
+        });
+        return metadata;
+    };
+}

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

@@ -1,33 +1,33 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-export const emend_metadata_atomics = (meta: Metadata) => {
-    // ATOMICS
-    for (const type of meta.atomics) {
-        const index: number = meta.constants.findIndex((c) => c.type === type);
-        if (index !== -1) meta.constants.splice(index, 1);
-    }
-
-    // BOOLEAN
-    {
-        const index: number = meta.constants.findIndex(
-            (c) => c.type === "boolean",
-        );
-        if (index !== -1 && meta.constants[index]!.values.length === 2) {
-            meta.constants.splice(index, 1);
-            ArrayUtil.take(
-                meta.atomics,
-                (type) => type === "boolean",
-                () => "boolean",
-            );
-        }
-    }
-
-    // TEMPLATE
-    if (
-        meta.templates.length &&
-        meta.atomics.find((type) => type === "string") !== undefined
-    )
-        meta.templates.splice(0, meta.templates.length);
-};
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+export const emend_metadata_atomics = (meta: Metadata) => {
+    // ATOMICS
+    for (const type of meta.atomics) {
+        const index: number = meta.constants.findIndex((c) => c.type === type);
+        if (index !== -1) meta.constants.splice(index, 1);
+    }
+
+    // BOOLEAN
+    {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === "boolean",
+        );
+        if (index !== -1 && meta.constants[index]!.values.length === 2) {
+            meta.constants.splice(index, 1);
+            ArrayUtil.take(
+                meta.atomics,
+                (type) => type === "boolean",
+                () => "boolean",
+            );
+        }
+    }
+
+    // TEMPLATE
+    if (
+        meta.templates.length &&
+        meta.atomics.find((type) => type === "string") !== undefined
+    )
+        meta.templates.splice(0, meta.templates.length);
+};

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

@@ -1,40 +1,40 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_alias =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataAlias => {
-        // CHECK EXISTENCE
-        const [alias, newbie, closure] = collection.emplaceAlias(
-            checker,
-            type,
-            type.aliasSymbol!,
-        );
-        ArrayUtil.add(alias.nullables, nullable);
-        if (newbie === false) return alias;
-
-        // CONSTRUCT VALUE TYPE
-        const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type,
-            false,
-            true,
-        );
-        closure(value);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
-        return alias;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTagFactory } from "../../MetadataTagFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_alias =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataAlias => {
+        // CHECK EXISTENCE
+        const [alias, newbie, closure] = collection.emplaceAlias(
+            checker,
+            type,
+            type.aliasSymbol!,
+        );
+        ArrayUtil.add(alias.nullables, nullable);
+        if (newbie === false) return alias;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type,
+            false,
+            true,
+        );
+        closure(value);
+        alias.tags.push(
+            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
+                () => alias.name,
+            ),
+        );
+        return alias;
+    };

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

@@ -1,34 +1,34 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_array =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArray => {
-        // CHECK EXISTENCE
-        const [array, newbie, setValue] = collection.emplaceArray(
-            checker,
-            type,
-        );
-        ArrayUtil.add(array.nullables, nullable);
-        if (newbie === false) return array;
-
-        // CONSTRUCT VALUE TYPE
-        const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type.getNumberIndexType()!,
-            false,
-            false,
-        );
-        setValue(value);
-
-        return array;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataArray => {
+        // CHECK EXISTENCE
+        const [array, newbie, setValue] = collection.emplaceArray(
+            checker,
+            type,
+        );
+        ArrayUtil.add(array.nullables, nullable);
+        if (newbie === false) return array;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type.getNumberIndexType()!,
+            false,
+            false,
+        );
+        setValue(value);
+
+        return array;
+    };

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

@@ -1,136 +1,136 @@
-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";
-
-export const emplace_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (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 &&
-                      (ts.isParameter(node) || 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,
-                    tags: [],
-                });
-                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)
-                    : "getTypeOfPropertyOfType" in checker
-                    ? (checker as any).getTypeOfPropertyOfType(
-                          parent,
-                          prop.name,
-                      )
-                    : undefined;
-                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,
-            )(type, false);
-
-            // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
-            if (node?.questionToken) Writable(value).optional = true;
-            insert(key)(value)(prop);
-        }
-
-        //----
-        // DYNAMIC PROPERTIES
-        //----
-        for (const index of checker.getIndexInfosOfType(parent)) {
-            // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
-
-            // 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.isPropertyDeclaration(node) ||
-    ts.isPropertyAssignment(node) ||
-    ts.isPropertySignature(node) ||
-    ts.isTypeLiteralNode(node);
+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";
+
+export const emplace_metadata_object =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (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 &&
+                      (ts.isParameter(node) || 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,
+                    tags: [],
+                });
+                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)
+                    : "getTypeOfPropertyOfType" in checker
+                    ? (checker as any).getTypeOfPropertyOfType(
+                          parent,
+                          prop.name,
+                      )
+                    : undefined;
+                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,
+            )(type, false);
+
+            // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
+            if (node?.questionToken) Writable(value).optional = true;
+            insert(key)(value)(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) =>
+                explore_metadata(checker)(options)(collection)(type, false);
+            const key: Metadata = analyzer(index.keyType);
+            const value: Metadata = analyzer(index.type);
+
+            // 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.isPropertyDeclaration(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isPropertySignature(node) ||
+    ts.isTypeLiteralNode(node);

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

@@ -1,50 +1,50 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
-
-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) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
-        // 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,
-                )(elem, false, 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 { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+
+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) =>
+    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+        // 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,
+                )(elem, false, 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;
+    };