typia 3.5.0-dev.20230125 → 3.5.0-dev.20230211

package/src/programmers/IsProgrammer.ts

@@ -16,61 +16,68 @@ 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: OptionPredicator.numeric({
-            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 const CONFIG =
+        (options?: Partial<CONFIG.IOptions>) =>
+        (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
+            functors: "$io",
+            unioners: "$iu",
+            trace: false,
+            path: false,
+            equals: !!options?.object,
+            numeric: OptionPredicator.numeric({
+                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,
+                        undefined: OptionPredicator.undefined({
+                            undefined: options?.undefined,
+                        }),
+                        assert: true,
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
+                    })(importer),
+                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;
+            undefined: boolean;
+            object: (
+                input: ts.Expression,
+                entries: IExpressionEntry<ts.Expression>[],
+            ) => ts.Expression;
         }
     }
 
@@ -88,45 +95,48 @@ export namespace IsProgrammer {
         const config = CONFIG({
             object: check_object({
                 equals,
+                undefined: OptionPredicator.undefined(project.options),
                 assert: true,
                 reduce: ts.factory.createLogicalAnd,
                 positive: ts.factory.createTrue(),
                 superfluous: () => ts.factory.createFalse(),
-            }),
+            })(importer),
             numeric: OptionPredicator.numeric(project.options),
-        });
+        })(importer);
         config.trace = equals;
 
-        if (equals === false)
-            config.decoder = (input, target, explore, tags) => {
+        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 (
-                    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, {
-                                checkNull: true,
-                                checkArray: false,
-                            }),
-                            config.joiner.object(
-                                feature_object_entries(config as any)(obj)(
-                                    input,
-                                ),
-                            ),
-                        );
-                }
-                return CheckerProgrammer.decode(project, config, importer)(
-                    input,
-                    target,
-                    explore,
-                    tags,
-                );
-            };
+                    obj._Is_simple() &&
+                    (equals === false ||
+                        OptionPredicator.undefined(project.options) === false)
+                )
+                    return ts.factory.createLogicalAnd(
+                        ExpressionFactory.isObject(input, {
+                            checkNull: true,
+                            checkArray: false,
+                        }),
+                        config.joiner.object(
+                            input,
+                            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, () =>
@@ -137,21 +147,31 @@ export namespace IsProgrammer {
     export const generate_functors = (
         project: IProject,
         importer: FunctionImporter,
-    ) => CheckerProgrammer.generate_functors(project, CONFIG(), importer);
+    ) =>
+        CheckerProgrammer.generate_functors(
+            project,
+            CONFIG()(importer),
+            importer,
+        );
 
     export const generate_unioners = (
         project: IProject,
         importer: FunctionImporter,
-    ) => CheckerProgrammer.generate_unioners(project, CONFIG(), importer);
+    ) =>
+        CheckerProgrammer.generate_unioners(
+            project,
+            CONFIG()(importer),
+            importer,
+        );
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     export const decode = (project: IProject, importer: FunctionImporter) =>
-        CheckerProgrammer.decode(project, CONFIG(), importer);
+        CheckerProgrammer.decode(project, CONFIG()(importer), importer);
 
-    export const decode_object = () =>
-        CheckerProgrammer.decode_object(CONFIG());
+    export const decode_object = (importer: FunctionImporter) =>
+        CheckerProgrammer.decode_object(CONFIG()(importer));
 
     export function decode_to_json(input: ts.Expression): ts.Expression {
         return ts.factory.createLogicalAnd(

package/src/programmers/PruneProgrammer.ts

@@ -0,0 +1,320 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { PruneJoiner } from "./helpers/PruneJoiner";
+import { UnionExplorer } from "./helpers/UnionExplorer";
+import { decode_union_object } from "./internal/decode_union_object";
+
+export namespace PruneProgrammer {
+    export function generate(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+    ) {
+        const importer: FunctionImporter = new FunctionImporter();
+        return FeatureProgrammer.generate(
+            project,
+            CONFIG(project, importer),
+            importer,
+            (collection) => {
+                const isFunctors = IsProgrammer.generate_functors(
+                    project,
+                    importer,
+                )(collection);
+                const isUnioners = IsProgrammer.generate_unioners(
+                    project,
+                    importer,
+                )(collection);
+
+                return [
+                    ...importer.declare(modulo),
+                    ...isFunctors,
+                    ...isUnioners,
+                ];
+            },
+        );
+    }
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    const decode =
+        (project: IProject, importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            meta: Metadata,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.ConciseBody => {
+            if (filter(meta) === false) return ts.factory.createBlock([]);
+
+            interface IUnion {
+                type: string;
+                is: () => ts.Expression;
+                value: () => ts.Expression | ts.Block | ts.ReturnStatement;
+            }
+            const unions: IUnion[] = [];
+
+            //----
+            // LIST UP UNION TYPES
+            //----
+            // TUPLES
+            for (const tuple of meta.tuples.filter((t) =>
+                t.some((e) => filter(e.rest ?? e)),
+            ))
+                unions.push({
+                    type: "tuple",
+                    is: () =>
+                        IsProgrammer.decode(project, importer)(
+                            input,
+                            (() => {
+                                const partial = Metadata.initialize();
+                                partial.tuples.push(tuple);
+                                return partial;
+                            })(),
+                            explore,
+                            [],
+                        ),
+                    value: () =>
+                        decode_tuple(project, importer)(input, tuple, explore),
+                });
+
+            // ARRAYS
+            if (meta.arrays.filter(filter).length)
+                unions.push({
+                    type: "array",
+                    is: () => ExpressionFactory.isArray(input),
+                    value: () =>
+                        explore_arrays(project, importer)(
+                            input,
+                            meta.arrays,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            [],
+                        ),
+                });
+
+            // BUILT-IN CLASSES
+            if (meta.natives.length)
+                for (const native of meta.natives)
+                    unions.push({
+                        type: "native",
+                        is: () => ExpressionFactory.isInstanceOf(input, native),
+                        value: () => ts.factory.createReturnStatement(),
+                    });
+            if (meta.sets.length)
+                unions.push({
+                    type: "set",
+                    is: () => ExpressionFactory.isInstanceOf(input, "Set"),
+                    value: () => ts.factory.createReturnStatement(),
+                });
+            if (meta.maps.length)
+                unions.push({
+                    type: "map",
+                    is: () => ExpressionFactory.isInstanceOf(input, "Map"),
+                    value: () => ts.factory.createReturnStatement(),
+                });
+
+            // OBJECTS
+            if (meta.objects.length)
+                unions.push({
+                    type: "object",
+                    is: () =>
+                        ExpressionFactory.isObject(input, {
+                            checkNull: true,
+                            checkArray: false,
+                        }),
+                    value: () =>
+                        explore_objects(input, meta, {
+                            ...explore,
+                            from: "object",
+                        }),
+                });
+
+            //----
+            // STATEMENTS
+            //----
+            const value = (v: ts.Expression | ts.Block | ts.ReturnStatement) =>
+                ts.isReturnStatement(v) || ts.isBlock(v)
+                    ? v
+                    : ts.factory.createExpressionStatement(v);
+            const statements: ts.Statement[] = unions.map((u) =>
+                ts.factory.createIfStatement(u.is(), value(u.value())),
+            );
+            return ts.factory.createBlock(statements, true);
+        };
+
+    const decode_tuple =
+        (project: IProject, importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: Metadata[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Block => {
+            const children: ts.ConciseBody[] = tuple
+                .map((elem, index) => [elem, index] as const)
+                .filter(([elem]) => filter(elem) && elem.rest === null)
+                .map(([elem, index]) =>
+                    decode(project, importer)(
+                        ts.factory.createElementAccessExpression(input, index),
+                        elem,
+                        {
+                            ...explore,
+                            from: "array",
+                        },
+                    ),
+                );
+            const rest = (() => {
+                if (tuple.length === 0) return null;
+
+                const last: Metadata = tuple[tuple.length - 1]!;
+                const rest: Metadata | null = last.rest;
+                if (rest === null || filter(rest) === false) return null;
+
+                return decode(project, importer)(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(input, "slice"),
+                        undefined,
+                        [ts.factory.createNumericLiteral(tuple.length - 1)],
+                    ),
+                    (() => {
+                        const wrapper: Metadata = Metadata.initialize();
+                        wrapper.arrays.push(rest);
+                        return wrapper;
+                    })(),
+                    {
+                        ...explore,
+                        start: tuple.length - 1,
+                    },
+                );
+            })();
+            return PruneJoiner.tuple(children, rest);
+        };
+
+    const decode_array = (project: IProject, importer: FunctionImporter) =>
+        FeatureProgrammer.decode_array(
+            CONFIG(project, importer),
+            importer,
+            PruneJoiner.array,
+        );
+
+    const decode_object = () =>
+        FeatureProgrammer.decode_object({
+            trace: false,
+            path: false,
+            functors: FUNCTORS,
+        });
+
+    const explore_arrays = (project: IProject, importer: FunctionImporter) =>
+        UnionExplorer.array({
+            checker: IsProgrammer.decode(project, importer),
+            decoder: decode_array(project, importer),
+            empty: ts.factory.createReturnStatement(),
+            success: ts.factory.createTrue(),
+            failure: (input, expected) =>
+                create_throw_error(importer, input, expected),
+        });
+
+    const explore_objects = (
+        input: ts.Expression,
+        meta: Metadata,
+        explore: FeatureProgrammer.IExplore,
+    ) => {
+        if (meta.objects.length === 1)
+            return decode_object()(input, meta.objects[0]!, explore);
+
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+            undefined,
+            [input],
+        );
+    };
+
+    const filter = (meta: Metadata): boolean =>
+        meta.any === false &&
+        (meta.objects.length !== 0 ||
+            meta.tuples.some((t) => t.some((e) => filter(e.rest ?? e))) ||
+            meta.arrays.some((e) => filter(e)));
+
+    /* -----------------------------------------------------------
+        CONFIGURATIONS
+    ----------------------------------------------------------- */
+    const FUNCTORS = "$po";
+    const UNIONERS = "$pu";
+
+    const CONFIG = (
+        project: IProject,
+        importer: FunctionImporter,
+    ): FeatureProgrammer.IConfig => ({
+        functors: FUNCTORS,
+        unioners: UNIONERS,
+        trace: false,
+        path: false,
+        initializer,
+        decoder: decode(project, importer),
+        objector: OBJECTOR(project, importer),
+    });
+
+    const OBJECTOR = (
+        project: IProject,
+        importer: FunctionImporter,
+    ): FeatureProgrammer.IConfig.IObjector => ({
+        checker: IsProgrammer.decode(project, importer),
+        decoder: decode_object(),
+        joiner: PruneJoiner.object,
+        unionizer: decode_union_object(IsProgrammer.decode_object(importer))(
+            decode_object(),
+        )((exp) => exp)((value, expected) =>
+            create_throw_error(importer, value, expected),
+        ),
+        failure: (input, expected) =>
+            create_throw_error(importer, input, expected),
+    });
+
+    const initializer: FeatureProgrammer.IConfig["initializer"] = (
+        { checker },
+        type,
+    ) => {
+        const collection = new MetadataCollection();
+        const meta = MetadataFactory.generate(checker, collection, type, {
+            resolve: false,
+            constant: true,
+        });
+        return [collection, meta];
+    };
+
+    const create_throw_error = (
+        importer: FunctionImporter,
+        value: ts.Expression,
+        expected: string,
+    ) =>
+        ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+                importer.use("throws"),
+                [],
+                [
+                    ts.factory.createObjectLiteralExpression(
+                        [
+                            ts.factory.createPropertyAssignment(
+                                "expected",
+                                ts.factory.createStringLiteral(expected),
+                            ),
+                            ts.factory.createPropertyAssignment("value", value),
+                        ],
+                        true,
+                    ),
+                ],
+            ),
+        );
+}