typia 5.0.4 → 5.0.5-dev.20230921

package/src/factories/StatementFactory.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-export namespace StatementFactory {
-    export const mut = (name: string, initializer?: ts.Expression) =>
-        ts.factory.createVariableStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-                [
-                    ts.factory.createVariableDeclaration(
-                        name,
-                        undefined,
-                        undefined,
-                        initializer,
-                    ),
-                ],
-                ts.NodeFlags.Let,
-            ),
-        );
-
-    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 entry = (key: string) => (value: string) =>
-        ts.factory.createVariableDeclarationList(
-            [
-                ts.factory.createVariableDeclaration(
-                    ts.factory.createArrayBindingPattern([
-                        ts.factory.createBindingElement(
-                            undefined,
-                            undefined,
-                            ts.factory.createIdentifier(key),
-                            undefined,
-                        ),
-                        ts.factory.createBindingElement(
-                            undefined,
-                            undefined,
-                            ts.factory.createIdentifier(value),
-                            undefined,
-                        ),
-                    ]),
-                    undefined,
-                    undefined,
-                    undefined,
-                ),
-            ],
-            ts.NodeFlags.Const,
-        );
-
-    export const transpile = (script: string) =>
-        ts.factory.createExpressionStatement(
-            ts.factory.createIdentifier(ts.transpile(script)),
-        );
-
-    export const block = (expression: ts.Expression) =>
-        ts.factory.createBlock(
-            [ts.factory.createExpressionStatement(expression)],
-            true,
-        );
-}
+import ts from "typescript";
+
+export namespace StatementFactory {
+    export const mut = (name: string, initializer?: ts.Expression) =>
+        ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Let,
+            ),
+        );
+
+    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 entry = (key: string) => (value: string) =>
+        ts.factory.createVariableDeclarationList(
+            [
+                ts.factory.createVariableDeclaration(
+                    ts.factory.createArrayBindingPattern([
+                        ts.factory.createBindingElement(
+                            undefined,
+                            undefined,
+                            ts.factory.createIdentifier(key),
+                            undefined,
+                        ),
+                        ts.factory.createBindingElement(
+                            undefined,
+                            undefined,
+                            ts.factory.createIdentifier(value),
+                            undefined,
+                        ),
+                    ]),
+                    undefined,
+                    undefined,
+                    undefined,
+                ),
+            ],
+            ts.NodeFlags.Const,
+        );
+
+    export const transpile = (script: string) =>
+        ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(ts.transpile(script)),
+        );
+
+    export const block = (expression: ts.Expression) =>
+        ts.factory.createBlock(
+            [ts.factory.createExpressionStatement(expression)],
+            true,
+        );
+}

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,119 +1,119 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-    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 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 "../../../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,40 +1,40 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-export const emend_metadata_atomics = (meta: Metadata) => {
-    // ATOMICS
-    for (const a of meta.atomics) {
-        const index: number = meta.constants.findIndex(
-            (c) => c.type === a.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,
-                (a) => a.type === "boolean",
-                () =>
-                    MetadataAtomic.create({
-                        type: "boolean" as const,
-                        tags: [],
-                    }),
-            );
-        }
-    }
-
-    // TEMPLATE
-    if (
-        meta.templates.length &&
-        meta.atomics.find((a) => a.type === "string") !== undefined
-    )
-        meta.templates.splice(0, meta.templates.length);
-};
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+export const emend_metadata_atomics = (meta: Metadata) => {
+    // ATOMICS
+    for (const a of meta.atomics) {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === a.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,
+                (a) => a.type === "boolean",
+                () =>
+                    MetadataAtomic.create({
+                        type: "boolean" as const,
+                        tags: [],
+                    }),
+            );
+        }
+    }
+
+    // TEMPLATE
+    if (
+        meta.templates.length &&
+        meta.atomics.find((a) => a.type === "string") !== undefined
+    )
+        meta.templates.splice(0, meta.templates.length);
+};