typia 4.2.2 → 4.2.3

package/src/factories/StatementFactory.ts

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-export namespace StatementFactory {
-    export const constant = (name: string, initializer?: ts.Expression) =>
-        ts.factory.createVariableStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-                [
-                    ts.factory.createVariableDeclaration(
-                        name,
-                        undefined,
-                        undefined,
-                        initializer,
-                    ),
-                ],
-                ts.NodeFlags.Const,
-            ),
-        );
-
-    export const transpile = (script: string) =>
-        ts.factory.createExpressionStatement(
-            ts.factory.createIdentifier(ts.transpile(script)),
-        );
-}
+import ts from "typescript";
+
+export namespace StatementFactory {
+    export const constant = (name: string, initializer?: ts.Expression) =>
+        ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Const,
+            ),
+        );
+
+    export const transpile = (script: string) =>
+        ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(ts.transpile(script)),
+        );
+}

package/src/factories/TemplateFactory.ts

@@ -1,58 +1,58 @@
-import ts from "typescript";
-
-export namespace TemplateFactory {
-    export const generate = (expressions: ts.Expression[]): ts.Expression => {
-        if (expressions.every((exp) => ts.isStringLiteral(exp)))
-            return ts.factory.createStringLiteral(
-                (expressions as ts.StringLiteral[])
-                    .map((str) => str.text)
-                    .join(""),
-            );
-
-        const it: IIterator = {
-            value: "",
-            index: 0,
-        };
-        gather(expressions)(it);
-
-        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
-        const spans: ts.TemplateSpan[] = [];
-
-        while (true) {
-            const elem: ts.Expression = expressions[it.index++]!;
-            gather(expressions)(it);
-
-            const broken: boolean = it.index === expressions.length;
-            spans.push(
-                ts.factory.createTemplateSpan(
-                    elem,
-                    broken
-                        ? ts.factory.createTemplateTail(it.value)
-                        : ts.factory.createTemplateMiddle(it.value),
-                ),
-            );
-            if (broken === true) break;
-        }
-        return ts.factory.createTemplateExpression(head, spans);
-    };
-
-    const gather =
-        (expressions: ts.Expression[]) =>
-        (it: IIterator): void => {
-            const found: number = expressions.findIndex(
-                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-            );
-
-            const last: number = found !== -1 ? found : expressions.length;
-            it.value = expressions
-                .slice(it.index, last)
-                .map((elem) => (elem as ts.StringLiteral).text)
-                .reduce((x, y) => x + y, "");
-            it.index = last;
-        };
-
-    interface IIterator {
-        value: string;
-        index: number;
-    }
-}
+import ts from "typescript";
+
+export namespace TemplateFactory {
+    export const generate = (expressions: ts.Expression[]): ts.Expression => {
+        if (expressions.every((exp) => ts.isStringLiteral(exp)))
+            return ts.factory.createStringLiteral(
+                (expressions as ts.StringLiteral[])
+                    .map((str) => str.text)
+                    .join(""),
+            );
+
+        const it: IIterator = {
+            value: "",
+            index: 0,
+        };
+        gather(expressions)(it);
+
+        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+        const spans: ts.TemplateSpan[] = [];
+
+        while (true) {
+            const elem: ts.Expression = expressions[it.index++]!;
+            gather(expressions)(it);
+
+            const broken: boolean = it.index === expressions.length;
+            spans.push(
+                ts.factory.createTemplateSpan(
+                    elem,
+                    broken
+                        ? ts.factory.createTemplateTail(it.value)
+                        : ts.factory.createTemplateMiddle(it.value),
+                ),
+            );
+            if (broken === true) break;
+        }
+        return ts.factory.createTemplateExpression(head, spans);
+    };
+
+    const gather =
+        (expressions: ts.Expression[]) =>
+        (it: IIterator): void => {
+            const found: number = expressions.findIndex(
+                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+            );
+
+            const last: number = found !== -1 ? found : expressions.length;
+            it.value = expressions
+                .slice(it.index, last)
+                .map((elem) => (elem as ts.StringLiteral).text)
+                .reduce((x, y) => x + y, "");
+            it.index = last;
+        };
+
+    interface IIterator {
+        value: string;
+        index: number;
+    }
+}

package/src/factories/TypeFactory.ts

@@ -1,124 +1,124 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-    export const resolve =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): ts.Type | null =>
-            getReturnType(checker)(type)("toJSON");
-
-    export const isFunction = (type: ts.Type): boolean =>
-        getFunction(type) !== null;
-
-    const getFunction = (type: ts.Type) => {
-        const node = type.symbol?.declarations?.[0];
-        if (node === undefined) return null;
-
-        return ts.isFunctionLike(node)
-            ? node
-            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-            ? ts.isFunctionLike(node.initializer)
-                ? node.initializer
-                : null
-            : null;
-    };
-
-    export const getReturnType =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (name: string): ts.Type | null => {
-            // FIND TO-JSON METHOD
-            const symbol: ts.Symbol | undefined = type.getProperty(name);
-            if (!symbol) return null;
-            else if (!symbol.valueDeclaration) return null;
-
-            // GET FUNCTION DECLARATION
-            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-                symbol,
-                symbol.valueDeclaration,
-            );
-
-            // RETURNS THE RETURN-TYPE
-            const signature: ts.Signature | undefined =
-                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
-            return signature ? signature.getReturnType() : null;
-        };
-
-    export const getFullName =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type, symbol?: ts.Symbol): string => {
-            // PRIMITIVE
-            symbol ??= type.aliasSymbol ?? type.getSymbol();
-            if (symbol === undefined) return checker.typeToString(type);
-
-            // UNION OR INTERSECT
-            if (
-                type.aliasSymbol === undefined &&
-                type.isUnionOrIntersection()
-            ) {
-                const joiner: string = type.isIntersection() ? " & " : " | ";
-                return type.types
-                    .map((child) => getFullName(checker)(child))
-                    .join(joiner);
-            }
-
-            //----
-            // SPECIALIZATION
-            //----
-            const name: string = get_name(symbol);
-
-            // CHECK GENERIC
-            const generic: readonly ts.Type[] = type.aliasSymbol
-                ? type.aliasTypeArguments || []
-                : checker.getTypeArguments(type as ts.TypeReference);
-            return generic.length
-                ? name === "Promise"
-                    ? getFullName(checker)(generic[0]!)
-                    : `${name}<${generic
-                          .map((child) => getFullName(checker)(child))
-                          .join(", ")}>`
-                : name;
-        };
-
-    const explore_name =
-        (decl: ts.Node) =>
-        (name: string): string =>
-            ts.isModuleBlock(decl)
-                ? explore_name(decl.parent.parent)(
-                      `${decl.parent.name.getFullText().trim()}.${name}`,
-                  )
-                : name;
-
-    const get_name = (symbol: ts.Symbol): string => {
-        const parent = symbol.getDeclarations()?.[0]?.parent;
-        return parent
-            ? explore_name(parent)(symbol.escapedName.toString())
-            : "__type";
-    };
-
-    export const keyword = (
-        type:
-            | "void"
-            | "any"
-            | "unknown"
-            | "boolean"
-            | "number"
-            | "bigint"
-            | "string",
-    ) => {
-        return ts.factory.createKeywordTypeNode(
-            type === "void"
-                ? ts.SyntaxKind.VoidKeyword
-                : type === "any"
-                ? ts.SyntaxKind.AnyKeyword
-                : type === "unknown"
-                ? ts.SyntaxKind.UnknownKeyword
-                : type === "boolean"
-                ? ts.SyntaxKind.BooleanKeyword
-                : type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : type === "bigint"
-                ? ts.SyntaxKind.BigIntKeyword
-                : ts.SyntaxKind.StringKeyword,
-        );
-    };
-}
+import ts from "typescript";
+
+export namespace TypeFactory {
+    export const resolve =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): ts.Type | null =>
+            getReturnType(checker)(type)("toJSON");
+
+    export const isFunction = (type: ts.Type): boolean =>
+        getFunction(type) !== null;
+
+    const getFunction = (type: ts.Type) => {
+        const node = type.symbol?.declarations?.[0];
+        if (node === undefined) return null;
+
+        return ts.isFunctionLike(node)
+            ? node
+            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
+            ? ts.isFunctionLike(node.initializer)
+                ? node.initializer
+                : null
+            : null;
+    };
+
+    export const getReturnType =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (name: string): ts.Type | null => {
+            // FIND TO-JSON METHOD
+            const symbol: ts.Symbol | undefined = type.getProperty(name);
+            if (!symbol) return null;
+            else if (!symbol.valueDeclaration) return null;
+
+            // GET FUNCTION DECLARATION
+            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
+                symbol,
+                symbol.valueDeclaration,
+            );
+
+            // RETURNS THE RETURN-TYPE
+            const signature: ts.Signature | undefined =
+                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+            return signature ? signature.getReturnType() : null;
+        };
+
+    export const getFullName =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type, symbol?: ts.Symbol): string => {
+            // PRIMITIVE
+            symbol ??= type.aliasSymbol ?? type.getSymbol();
+            if (symbol === undefined) return checker.typeToString(type);
+
+            // UNION OR INTERSECT
+            if (
+                type.aliasSymbol === undefined &&
+                type.isUnionOrIntersection()
+            ) {
+                const joiner: string = type.isIntersection() ? " & " : " | ";
+                return type.types
+                    .map((child) => getFullName(checker)(child))
+                    .join(joiner);
+            }
+
+            //----
+            // SPECIALIZATION
+            //----
+            const name: string = get_name(symbol);
+
+            // CHECK GENERIC
+            const generic: readonly ts.Type[] = type.aliasSymbol
+                ? type.aliasTypeArguments || []
+                : checker.getTypeArguments(type as ts.TypeReference);
+            return generic.length
+                ? name === "Promise"
+                    ? getFullName(checker)(generic[0]!)
+                    : `${name}<${generic
+                          .map((child) => getFullName(checker)(child))
+                          .join(", ")}>`
+                : name;
+        };
+
+    const explore_name =
+        (decl: ts.Node) =>
+        (name: string): string =>
+            ts.isModuleBlock(decl)
+                ? explore_name(decl.parent.parent)(
+                      `${decl.parent.name.getFullText().trim()}.${name}`,
+                  )
+                : name;
+
+    const get_name = (symbol: ts.Symbol): string => {
+        const parent = symbol.getDeclarations()?.[0]?.parent;
+        return parent
+            ? explore_name(parent)(symbol.escapedName.toString())
+            : "__type";
+    };
+
+    export const keyword = (
+        type:
+            | "void"
+            | "any"
+            | "unknown"
+            | "boolean"
+            | "number"
+            | "bigint"
+            | "string",
+    ) => {
+        return ts.factory.createKeywordTypeNode(
+            type === "void"
+                ? ts.SyntaxKind.VoidKeyword
+                : type === "any"
+                ? ts.SyntaxKind.AnyKeyword
+                : type === "unknown"
+                ? ts.SyntaxKind.UnknownKeyword
+                : type === "boolean"
+                ? ts.SyntaxKind.BooleanKeyword
+                : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                ? ts.SyntaxKind.BigIntKeyword
+                : ts.SyntaxKind.StringKeyword,
+        );
+    };
+}

package/src/factories/ValueFactory.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-export namespace ValueFactory {
-    export const NULL = () => ts.factory.createNull();
-    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
-    export const BOOLEAN = (value: boolean) =>
-        value ? ts.factory.createTrue() : ts.factory.createFalse();
-    export const INPUT = (str: string = "input") =>
-        ts.factory.createIdentifier(str);
-    export const TYPEOF = (input: ts.Expression) =>
-        ts.factory.createTypeOfExpression(input);
-}
+import ts from "typescript";
+
+export namespace ValueFactory {
+    export const NULL = () => ts.factory.createNull();
+    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
+    export const BOOLEAN = (value: boolean) =>
+        value ? ts.factory.createTrue() : ts.factory.createFalse();
+    export const INPUT = (str: string = "input") =>
+        ts.factory.createIdentifier(str);
+    export const TYPEOF = (input: ts.Expression) =>
+        ts.factory.createTypeOfExpression(input);
+}

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

@@ -1,12 +1,12 @@
-import { Metadata } from "../../../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 "../../../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 "../../../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 "../../../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 "../../../metadata/Metadata";
-import { MetadataAlias } from "../../../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 "../../../metadata/Metadata";
+import { MetadataAlias } from "../../../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;
+    };