typia 3.3.12 → 3.4.0-dev.20221212

package/src/factories/TemplateFactory.ts

@@ -0,0 +1,56 @@
+import ts from "typescript";
+
+export namespace TemplateFactory {
+    export function 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: IIerator = {
+            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);
+    }
+
+    function gather(expressions: ts.Expression[], it: IIerator): 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 IIerator {
+        value: string;
+        index: number;
+    }
+}

package/src/factories/TypeFactory.ts

@@ -0,0 +1,101 @@
+import ts from "typescript";
+
+export namespace TypeFactory {
+    export function resolve(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+    ): ts.Type | null {
+        return getReturnType(checker, type, "toJSON");
+    }
+
+    export function isFunction(type: ts.Type): boolean {
+        return getFunction(type) !== null;
+    }
+    function 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 function 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 function 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;
+    }
+
+    function explore_name(name: string, decl: ts.Node): string {
+        return ts.isModuleBlock(decl)
+            ? explore_name(
+                  `${decl.parent.name.getText()}.${name}`,
+                  decl.parent.parent,
+              )
+            : name;
+    }
+
+    function get_name(symbol: ts.Symbol): string {
+        const parent = symbol.getDeclarations()?.[0]?.parent;
+        return parent
+            ? explore_name(symbol.escapedName.toString(), parent)
+            : "__type";
+    }
+}

package/src/factories/ValueFactory.ts

@@ -0,0 +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);
+}

package/src/factories/internal/MetadataHelper.ts

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

package/src/factories/internal/emplace_metadata_object.ts

@@ -0,0 +1,140 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataProperty } from "../../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 { MetadataTagFactory } from "../MetadataTagFactory";
+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) || ts.isPropertyDeclaration(node))
+                  );
+              }
+            : (node) =>
+                  ts.isPropertyDeclaration(node) ||
+                  ts.isPropertyAssignment(node) ||
+                  ts.isPropertySignature(node) ||
+                  ts.isTypeLiteralNode(node);
+
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (identifier: () => string) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: ts.JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | undefined =
+                    CommentFactory.generate(
+                        symbol?.getDocumentationComment(checker) || [],
+                    ) || undefined;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() || []
+                ).filter(filter || (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                    tags: MetadataTagFactory.generate(
+                        () => identifier(),
+                        value,
+                        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)
+                    : "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);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            if (node?.questionToken) Writable(value).required = false;
+            insert(key)(value)(() => `${obj.name}.${prop.name}`)(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)(() => `${obj.name}[${key.getName()}]`)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
+            );
+        }
+
+        return obj;
+    };

package/src/factories/internal/explore_metadata.ts

@@ -0,0 +1,91 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../MetadataCollection";
+import { MetadataFactory } from "../MetadataFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type | null, parentResolved: boolean): Metadata => {
+        // CONSTRUCT METADATA
+        const meta: Metadata = Metadata.initialize(parentResolved);
+        if (type !== null)
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                type,
+                parentResolved,
+            );
+
+        // SORT OBJECTS
+        if (meta.objects.length > 1) {
+            meta.objects.sort((x, y) =>
+                MetadataObject.covers(x, y)
+                    ? -1
+                    : MetadataObject.covers(y, x)
+                    ? 1
+                    : 0,
+            );
+            if (parentResolved === false)
+                meta.union_index = collection.getUnionIndex(meta);
+        }
+
+        // SORT ARRAYS AND TUPLES
+        if (meta.arrays.length > 1)
+            meta.arrays.sort((x, y) =>
+                Metadata.covers(x, y) ? -1 : Metadata.covers(y, x) ? 1 : 0,
+            );
+        if (meta.tuples.length > 1)
+            meta.tuples.sort((x, y) => {
+                const xt = Metadata.initialize();
+                const yt = Metadata.initialize();
+
+                xt.tuples.push(x);
+                yt.tuples.push(y);
+
+                return Metadata.covers(xt, yt)
+                    ? -1
+                    : Metadata.covers(yt, xt)
+                    ? 1
+                    : 0;
+            });
+
+        // EMEND 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);
+        }
+
+        // EMEND 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",
+                );
+            }
+        }
+
+        // EMEND TEMPLATE
+        if (
+            meta.templates.length &&
+            meta.atomics.find((type) => type === "string") !== undefined
+        )
+            meta.templates.splice(0, meta.templates.length);
+
+        // RETURNS
+        return meta;
+    };

package/src/factories/internal/iterate_metadata.ts

@@ -0,0 +1,81 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../MetadataCollection";
+import { MetadataFactory } from "../MetadataFactory";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): void => {
+        if (type.isTypeParameter() === true)
+            throw new Error(
+                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
+            );
+
+        // CHECK UNION & toJSON()
+        if (
+            iterate_metadata_union(checker)(options)(collection)(
+                meta,
+                type,
+                parentResolved,
+            ) ||
+            iterate_metadata_resolve(checker)(options)(collection)(
+                meta,
+                type,
+                parentResolved,
+            )
+        )
+            return;
+
+        // VALIDATE NODE
+        const node: ts.TypeNode | undefined = checker.typeToTypeNode(
+            type,
+            undefined,
+            undefined,
+        );
+        if (node === undefined) {
+            // EMPTY TUPLE CASE CAN BE
+            ArrayUtil.set(meta.tuples, [], () => "[]");
+            return;
+        }
+
+        // ITERATE CASES
+        iterate_metadata_coalesce(meta, type) ||
+            iterate_metadata_constant(checker)(options)(meta, type) ||
+            iterate_metadata_template(checker)(options)(collection)(
+                meta,
+                type,
+            ) ||
+            iterate_metadata_atomic(meta, type) ||
+            iterate_metadata_tuple(checker)(options)(collection)(
+                meta,
+                type,
+                node,
+            ) ||
+            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_native(checker)(meta, type) ||
+            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_object(checker)(options)(collection)(
+                meta,
+                type,
+                parentResolved,
+            );
+    };

package/src/factories/internal/iterate_metadata_array.ts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../MetadataCollection";
+import { MetadataFactory } from "../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        if (
+            !(checker as any).isArrayType(type) &&
+            !(checker as any).isArrayLikeType(type)
+        )
+            return false;
+
+        const value: ts.Type | null = type.getNumberIndexType() || null;
+        ArrayUtil.set(
+            meta.arrays,
+            explore_metadata(checker)(options)(collection)(value, false),
+            (elem) => elem.getName(),
+        );
+        return true;
+    };

package/src/factories/internal/iterate_metadata_atomic.ts

@@ -0,0 +1,59 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+const same = (type: ts.Type | null) => {
+    if (type === null) return () => false;
+    return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+};
+
+export const iterate_metadata_atomic = (
+    meta: Metadata,
+    type: ts.Type,
+): boolean => {
+    // PREPARE INTERNAL FUNCTIONS
+    const filter = same(type);
+    const check = (info: IAtomicInfo) => {
+        if (filter(info.atomic) || filter(info.literal)) {
+            ArrayUtil.add(meta.atomics, info.name);
+            return true;
+        }
+        return false;
+    };
+
+    // CHECK EACH TYPES
+    return ATOMICS.some((info) => check(info));
+};
+
+const ATOMICS: IAtomicInfo[] = [
+    {
+        name: "boolean",
+        atomic: ts.TypeFlags.BooleanLike,
+        literal: ts.TypeFlags.BooleanLiteral,
+    },
+    {
+        name: "number",
+        atomic: ts.TypeFlags.NumberLike,
+        literal: ts.TypeFlags.NumberLiteral,
+    },
+    {
+        name: "bigint",
+        atomic: ts.TypeFlags.BigInt,
+        literal: ts.TypeFlags.BigIntLiteral,
+    },
+    {
+        name: "string",
+        atomic: ts.TypeFlags.StringLike,
+        literal: ts.TypeFlags.StringLiteral,
+    },
+];
+
+interface IAtomicInfo {
+    name: Atomic.Literal;
+    atomic: ts.TypeFlags;
+    literal: ts.TypeFlags;
+}

package/src/factories/internal/iterate_metadata_coalesce.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { Writable } from "../../typings/Writable";
+
+import { TypeFactory } from "../TypeFactory";
+
+export const iterate_metadata_coalesce = (
+    meta: Metadata,
+    type: ts.Type,
+): boolean => {
+    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
+        Writable(meta).any = true;
+        return true;
+    } else if (filter(ts.TypeFlags.Null)) {
+        Writable(meta).nullable = true;
+        return true;
+    } else if (
+        filter(ts.TypeFlags.Undefined) ||
+        filter(ts.TypeFlags.Never) ||
+        filter(ts.TypeFlags.Void) ||
+        filter(ts.TypeFlags.VoidLike)
+    ) {
+        Writable(meta).required = false;
+        return true;
+    } else if (TypeFactory.isFunction(type) === true) {
+        Writable(meta).functional = true;
+        return true;
+    }
+    return false;
+};

package/src/factories/internal/iterate_metadata_constant.ts

@@ -0,0 +1,58 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataConstant } from "../../metadata/MetadataConstant";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { MetadataFactory } from "../MetadataFactory";
+
+export const iterate_metadata_constant =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        if (!options.constant) return false;
+
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+        if (type.isLiteral()) {
+            const value: string | number | bigint =
+                typeof type.value === "object"
+                    ? BigInt(
+                          `${type.value.negative ? "-" : ""}${
+                              type.value.base10Value
+                          }`,
+                      )
+                    : type.value;
+            const constant: MetadataConstant = ArrayUtil.take(
+                meta.constants,
+                (elem) => elem.type === typeof value,
+                () => ({
+                    type: typeof value as "number",
+                    values: [],
+                }),
+            );
+            ArrayUtil.add(
+                constant.values as Array<any>,
+                value,
+                (a, b) => a === b,
+            );
+            return true;
+        } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+            const value: boolean = checker.typeToString(type) === "true";
+            const constant: MetadataConstant = ArrayUtil.take(
+                meta.constants,
+                (elem) => elem.type === "boolean",
+                () => ({
+                    type: "boolean",
+                    values: [],
+                }),
+            );
+            ArrayUtil.add(
+                constant.values as boolean[],
+                value,
+                (a, b) => a === b,
+            );
+            return true;
+        }
+        return false;
+    };