typia 3.3.12 → 3.4.0-dev.20221212

package/src/programmers/FeatureProgrammer.ts

@@ -0,0 +1,327 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { StatementFactory } from "../factories/StatementFactory";
+import { ValueFactory } from "../factories/ValueFactory";
+
+import { IMetadataTag } from "../metadata/IMetadataTag";
+import { Metadata } from "../metadata/Metadata";
+import { MetadataObject } from "../metadata/MetadataObject";
+
+import { IProject } from "../transformers/IProject";
+
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { UnionExplorer } from "./helpers/UnionExplorer";
+import { feature_object_entries } from "./internal/feature_object_entries";
+
+export namespace FeatureProgrammer {
+    /* -----------------------------------------------------------
+        PARAMETERS
+    ----------------------------------------------------------- */
+    export interface IConfig {
+        functors: string;
+        unioners: string;
+        path: boolean;
+        trace: boolean;
+        initializer: Initializer;
+        decoder: Decoder<Metadata>;
+        objector: IConfig.IObjector;
+        generator?: Partial<IConfig.IGenerator>;
+    }
+    export namespace IConfig {
+        export interface IObjector {
+            checker: Decoder<Metadata>;
+            decoder: Decoder<MetadataObject>;
+            joiner: ObjectJoiner;
+            unionizer: Decoder<MetadataObject[]>;
+            failure: (
+                value: ts.Expression,
+                expected: string,
+                explore?: IExplore,
+            ) => ts.Statement;
+            is?: (exp: ts.Expression) => ts.Expression;
+            required?: (exp: ts.Expression) => ts.Expression;
+            full?: (
+                condition: ts.Expression,
+            ) => (
+                input: ts.Expression,
+                expected: string,
+                explore: IExplore,
+            ) => ts.Expression;
+        }
+        export interface IGenerator {
+            functors(col: MetadataCollection): ts.VariableStatement[];
+            unioners(col: MetadataCollection): ts.VariableStatement[];
+        }
+    }
+    export interface IExplore {
+        tracable: boolean;
+        source: "top" | "object";
+        from: "top" | "array" | "object";
+        postfix: string;
+        start?: number;
+    }
+
+    export interface Initializer {
+        (project: IProject, type: ts.Type): [MetadataCollection, Metadata];
+    }
+    export interface Decoder<T> {
+        (
+            input: ts.Expression,
+            target: T,
+            explore: IExplore,
+            tags: IMetadataTag[],
+        ): ts.Expression;
+    }
+    export interface ObjectJoiner {
+        (entries: IExpressionEntry[], parent: MetadataObject): ts.ConciseBody;
+    }
+
+    /* -----------------------------------------------------------
+        GENERATORS
+    ----------------------------------------------------------- */
+    export const generate =
+        (
+            project: IProject,
+            config: IConfig,
+            importer: FunctionImporter,
+            addition: (
+                collection: MetadataCollection,
+            ) => ts.Statement[] | undefined,
+        ) =>
+        (type: ts.Type) => {
+            const [collection, meta] = config.initializer(project, type);
+
+            // ITERATE OVER ALL METADATA
+            const output: ts.Expression = config.decoder(
+                ValueFactory.INPUT(),
+                meta,
+                {
+                    tracable: config.path || config.trace,
+                    source: "top",
+                    from: "top",
+                    postfix: '""',
+                },
+                [],
+            );
+
+            // RETURNS THE OPTIMAL ARROW FUNCTION
+            const functors: ts.VariableStatement[] =
+                config.generator?.functors !== undefined
+                    ? config.generator.functors(collection)
+                    : generate_functors(config, importer)(collection);
+            const unioners: ts.VariableStatement[] =
+                config.generator?.unioners !== undefined
+                    ? config.generator.unioners(collection)
+                    : generate_unioners(config)(collection);
+            const added: ts.Statement[] | undefined = addition(collection);
+
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                PARAMETERS(config)(ValueFactory.INPUT()),
+                undefined,
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        ...(added || []),
+                        ...functors,
+                        ...unioners,
+                        ts.factory.createReturnStatement(output),
+                    ],
+                    true,
+                ),
+            );
+        };
+
+    export const generate_functors =
+        (config: IConfig, importer: FunctionImporter) =>
+        (collection: MetadataCollection) =>
+            collection
+                .objects()
+                .map((obj, i) =>
+                    StatementFactory.constant(
+                        `${config.functors}${i}`,
+                        generate_object(config, importer)(obj),
+                    ),
+                );
+
+    export const generate_unioners =
+        (config: IConfig) => (collection: MetadataCollection) =>
+            collection
+                .unions()
+                .map((union, i) =>
+                    StatementFactory.constant(
+                        `${config.unioners}${i}`,
+                        generate_union(config)(union),
+                    ),
+                );
+
+    function generate_object(config: IConfig, importer: FunctionImporter) {
+        if (config.path === true) importer.use("join");
+        return (obj: MetadataObject) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                PARAMETERS(config)(ValueFactory.INPUT()),
+                undefined,
+                undefined,
+                config.objector.joiner(
+                    feature_object_entries(config)(obj)(
+                        ts.factory.createIdentifier("input"),
+                    ),
+                    obj,
+                ),
+            );
+    }
+
+    function generate_union(config: IConfig) {
+        const explorer = UnionExplorer.object(config);
+        const input = ValueFactory.INPUT();
+
+        return (meta: MetadataObject[]) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                PARAMETERS(config)(ValueFactory.INPUT()),
+                undefined,
+                undefined,
+                explorer(
+                    input,
+                    meta,
+                    {
+                        tracable: config.path || config.trace,
+                        source: "object",
+                        from: "object",
+                        postfix: "",
+                    },
+                    [],
+                ),
+            );
+    }
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    export function decode_array(
+        config: Pick<IConfig, "trace" | "path" | "decoder">,
+        importer: FunctionImporter,
+        combiner: (
+            input: ts.Expression,
+            arrow: ts.ArrowFunction,
+            tags: IMetadataTag[],
+        ) => ts.Expression,
+    ) {
+        const rand: string = importer.increment().toString();
+        const tail =
+            config.path || config.trace
+                ? [IdentifierFactory.parameter("index" + rand)]
+                : [];
+
+        return (
+            input: ts.Expression,
+            meta: Metadata,
+            explore: IExplore,
+            tags: IMetadataTag[],
+        ) => {
+            const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("elem"), ...tail],
+                undefined,
+                undefined,
+                config.decoder(
+                    ValueFactory.INPUT("elem"),
+                    meta,
+                    {
+                        tracable: explore.tracable,
+                        source: explore.source,
+                        from: "array",
+                        postfix: INDEX_SYMBOL(explore.start ?? null)(
+                            explore.postfix,
+                        )(rand),
+                    },
+                    tags,
+                ),
+            );
+            return combiner(input, arrow, tags);
+        };
+    }
+
+    export const decode_object =
+        (config: Pick<IConfig, "trace" | "path" | "functors">) =>
+        (input: ts.Expression, obj: MetadataObject, explore: IExplore) =>
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(`${config.functors}${obj.index}`),
+                undefined,
+                get_object_arguments(config)(explore)(input),
+            );
+
+    export const get_object_arguments =
+        (config: Pick<IConfig, "path" | "trace">) =>
+        (explore: FeatureProgrammer.IExplore) => {
+            const tail: ts.Expression[] =
+                config.path === false && config.trace === false
+                    ? []
+                    : config.path === true && config.trace === true
+                    ? [
+                          ts.factory.createIdentifier(
+                              explore.postfix
+                                  ? `path + ${explore.postfix}`
+                                  : "path",
+                          ),
+                          explore.source === "object"
+                              ? ts.factory.createIdentifier(
+                                    `${explore.tracable} && exceptionable`,
+                                )
+                              : explore.tracable
+                              ? ts.factory.createTrue()
+                              : ts.factory.createFalse(),
+                      ]
+                    : config.path === true
+                    ? [
+                          ts.factory.createIdentifier(
+                              explore.postfix
+                                  ? `path + ${explore.postfix}`
+                                  : "path",
+                          ),
+                      ]
+                    : [
+                          explore.source === "object"
+                              ? ts.factory.createIdentifier(
+                                    `${explore.tracable} && exceptionable`,
+                                )
+                              : explore.tracable
+                              ? ts.factory.createTrue()
+                              : ts.factory.createFalse(),
+                      ];
+            return (input: ts.Expression) => [input, ...tail];
+        };
+}
+
+const INDEX_SYMBOL =
+    (start: number | null) => (prev: string) => (rand: string) => {
+        const tail: string =
+            start !== null
+                ? `"[" + (${start} + index${rand}) + "]"`
+                : `"[" + index${rand} + "]"`;
+        if (prev === "") return tail;
+        else if (prev[prev.length - 1] === `"`)
+            return prev.substring(0, prev.length - 1) + tail.substring(1);
+        return prev + ` + ${tail}`;
+    };
+const PARAMETERS = (
+    props: Pick<CheckerProgrammer.IConfig, "path" | "trace">,
+) => {
+    const tail: ts.ParameterDeclaration[] = [];
+    if (props.path) tail.push(IdentifierFactory.parameter("path"));
+    if (props.trace) tail.push(IdentifierFactory.parameter("exceptionable"));
+
+    return (input: ts.Identifier) => [
+        IdentifierFactory.parameter(input),
+        ...tail,
+    ];
+};

package/src/programmers/IsParseProgrammer.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { IsProgrammer } from "./IsProgrammer";
+
+export namespace IsParseProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.generate(project, modulo)(type),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createIdentifier("input"),
+                            ts.SyntaxKind.EqualsToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("JSON.parse"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createConditionalExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            undefined,
+                            ts.factory.createIdentifier("input"),
+                            undefined,
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/IsProgrammer.ts

@@ -0,0 +1,169 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { ValueFactory } from "../factories/ValueFactory";
+
+import { MetadataObject } from "../metadata/MetadataObject";
+
+import { IProject } from "../transformers/IProject";
+
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { check_object } from "./internal/check_object";
+import { feature_object_entries } from "./internal/feature_object_entries";
+
+export namespace IsProgrammer {
+    export const CONFIG = (
+        options?: Partial<CONFIG.IOptions>,
+    ): CheckerProgrammer.IConfig => ({
+        functors: "$io",
+        unioners: "$iu",
+        trace: false,
+        path: false,
+        equals: !!options?.object,
+        numeric: !!options?.numeric,
+        combiner: () => (type: "and" | "or") => {
+            const initial: ts.TrueLiteral | ts.FalseLiteral =
+                type === "and"
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse();
+            const binder =
+                type === "and"
+                    ? ts.factory.createLogicalAnd
+                    : ts.factory.createLogicalOr;
+            return (
+                _input: ts.Expression,
+                binaries: CheckerProgrammer.IBinary[],
+            ) =>
+                binaries.length
+                    ? binaries
+                          .map((binary) => binary.expression)
+                          .reduce((x, y) => binder(x, y))
+                    : initial;
+        },
+        joiner: {
+            object:
+                options?.object ||
+                check_object({
+                    equals: !!options?.object,
+                    assert: true,
+                    reduce: ts.factory.createLogicalAnd,
+                    positive: ts.factory.createTrue(),
+                    superfluous: () => ts.factory.createFalse(),
+                }),
+            array: (input, arrow) =>
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(input, "every"),
+                    undefined,
+                    [arrow],
+                ),
+            failure: () => ts.factory.createFalse(),
+        },
+        success: ts.factory.createTrue(),
+    });
+
+    export namespace CONFIG {
+        export interface IOptions {
+            numeric: boolean;
+            object: (entries: IExpressionEntry[]) => ts.Expression;
+        }
+    }
+
+    /* -----------------------------------------------------------
+        GENERATORS
+    ----------------------------------------------------------- */
+    export function generate(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        equals: boolean = false,
+    ) {
+        const importer: FunctionImporter = new FunctionImporter();
+
+        // CONFIGURATION
+        const config = CONFIG({
+            object: check_object({
+                equals,
+                assert: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: () => ts.factory.createFalse(),
+            }),
+            numeric: !!project.options.numeric,
+        });
+        config.trace = equals;
+
+        if (equals === false)
+            config.decoder = (input, target, explore, tags) => {
+                if (
+                    target.size() === 1 &&
+                    target.objects.length === 1 &&
+                    target.required === true &&
+                    target.nullable === false
+                ) {
+                    // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
+                    const obj: MetadataObject = target.objects[0]!;
+                    if (obj._Is_simple())
+                        return ts.factory.createLogicalAnd(
+                            ExpressionFactory.isObject(input, true),
+                            config.joiner.object(
+                                feature_object_entries(config as any)(obj)(
+                                    input,
+                                ),
+                            ),
+                        );
+                }
+                return CheckerProgrammer.decode(project, config, importer)(
+                    input,
+                    target,
+                    explore,
+                    tags,
+                );
+            };
+
+        // GENERATE CHECKER
+        return CheckerProgrammer.generate(project, config, importer, () =>
+            importer.declare(modulo),
+        );
+    }
+
+    export const generate_functors = (
+        project: IProject,
+        importer: FunctionImporter,
+    ) => CheckerProgrammer.generate_functors(project, CONFIG(), importer);
+
+    export const generate_unioners = (
+        project: IProject,
+        importer: FunctionImporter,
+    ) => CheckerProgrammer.generate_unioners(project, CONFIG(), importer);
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    export const decode = (project: IProject, importer: FunctionImporter) =>
+        CheckerProgrammer.decode(project, CONFIG(), importer);
+
+    export const decode_object = () =>
+        CheckerProgrammer.decode_object(CONFIG());
+
+    export function decode_to_json(input: ts.Expression): ts.Expression {
+        return ts.factory.createLogicalAnd(
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("object"),
+                ValueFactory.TYPEOF(input),
+            ),
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("function"),
+                ValueFactory.TYPEOF(IdentifierFactory.join(input, "toJSON")),
+            ),
+        );
+    }
+
+    export function decode_functional(input: ts.Expression) {
+        return ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("function"),
+            ValueFactory.TYPEOF(input),
+        );
+    }
+}

package/src/programmers/IsStringifyProgrammer.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { IsProgrammer } from "./IsProgrammer";
+import { StringifyProgrammer } from "./StringifyProgrammer";
+
+export namespace IsStringifyProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.generate(project, modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "stringify",
+                        StringifyProgrammer.generate(project, modulo)(type),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createConditionalExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            undefined,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("stringify"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            undefined,
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                ]),
+            );
+}