typia 3.5.0-dev.20230126 → 3.5.0-dev.20230212

package/src/programmers/PruneProgrammer.ts

@@ -0,0 +1,323 @@
+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 converter = (
+                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(), converter(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,
+                    ),
+                ],
+            ),
+        );
+}

package/src/programmers/StringifyProgrammer.ts

@@ -12,6 +12,8 @@ import { MetadataObject } from "../metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
 
+import { Atomic } from "../typings/Atomic";
+
 import { ArrayUtil } from "../utils/ArrayUtil";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
@@ -23,6 +25,7 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { StringifyJoiner } from "./helpers/StringifyJoinder";
 import { StringifyPredicator } from "./helpers/StringifyPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
+import { check_native } from "./internal/check_native";
 import { decode_union_object } from "./internal/decode_union_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
@@ -177,10 +180,9 @@ export namespace StringifyProgrammer {
 
             // CONSTANTS
             for (const constant of meta.constants)
-                if (
-                    constant.type !== "string" &&
-                    AtomicPredicator.constant(meta)(constant.type)
-                )
+                if (AtomicPredicator.constant(meta)(constant.type) === false)
+                    continue;
+                else if (constant.type !== "string")
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -223,28 +225,31 @@ export namespace StringifyProgrammer {
                                 explore,
                             ),
                     });
+
+            /// ATOMICS
             for (const type of meta.atomics)
-                unions.push({
-                    type: "atomic",
-                    is: () =>
-                        IsProgrammer.decode(project, importer)(
-                            input,
-                            (() => {
-                                const partial = Metadata.initialize();
-                                partial.atomics.push(type);
-                                return partial;
-                            })(),
-                            explore,
-                            [],
-                        ),
-                    value: () =>
-                        decode_atomic(project, importer)(
-                            input,
-                            type,
-                            explore,
-                            tags,
-                        ),
-                });
+                if (AtomicPredicator.atomic(meta)(type))
+                    unions.push({
+                        type: "atomic",
+                        is: () =>
+                            IsProgrammer.decode(project, importer)(
+                                input,
+                                (() => {
+                                    const partial = Metadata.initialize();
+                                    partial.atomics.push(type);
+                                    return partial;
+                                })(),
+                                explore,
+                                [],
+                            ),
+                        value: () =>
+                            decode_atomic(project, importer)(
+                                input,
+                                type,
+                                explore,
+                                tags,
+                            ),
+                    });
 
             // TUPLES
             for (const tuple of meta.tuples) {
@@ -315,8 +320,16 @@ export namespace StringifyProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "object",
-                        is: () => ExpressionFactory.isInstanceOf(input, native),
-                        value: () => ts.factory.createStringLiteral("{}"),
+                        is: () => check_native(native)(input),
+                        value: () =>
+                            AtomicPredicator.native(native)
+                                ? decode_atomic(project, importer)(
+                                      input,
+                                      native.toLowerCase() as Atomic.Literal,
+                                      explore,
+                                      tags,
+                                  )
+                                : ts.factory.createStringLiteral("{}"),
                     });
 
             // SETS
@@ -356,13 +369,16 @@ export namespace StringifyProgrammer {
                         meta.objects[0]!._Is_simple()
                             ? (() => {
                                   const obj: MetadataObject = meta.objects[0]!;
-                                  const entries: IExpressionEntry[] =
-                                      feature_object_entries({
+                                  const entries: IExpressionEntry<ts.Expression>[] =
+                                      feature_object_entries<ts.Expression>({
                                           decoder: decode(project, importer),
                                           trace: false,
                                           path: false,
-                                      })(obj)(input);
+                                      })(obj)(
+                                          input,
+                                      );
                                   return StringifyJoiner.object(importer)(
+                                      input,
                                       entries,
                                   );
                               })()
@@ -691,7 +707,10 @@ export namespace StringifyProgrammer {
         objector: OBJECTOR(project, importer),
     });
 
-    const initializer: FeatureProgrammer.Initializer = ({ checker }, type) => {
+    const initializer: FeatureProgrammer.IConfig["initializer"] = (
+        { checker },
+        type,
+    ) => {
         const collection: MetadataCollection = new MetadataCollection();
         const meta: Metadata = MetadataFactory.generate(
             checker,
@@ -716,15 +735,13 @@ export namespace StringifyProgrammer {
         checker: IsProgrammer.decode(project, importer),
         decoder: decode_object(),
         joiner: StringifyJoiner.object(importer),
-        unionizer: decode_union_object(IsProgrammer.decode_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),
-        is: (expr) => expr,
-        required: (expr) => expr,
     });
 
     function create_throw_error(

package/src/programmers/ValidateProgrammer.ts

@@ -92,7 +92,7 @@ const combine =
             return IsProgrammer.CONFIG({
                 object: validate_object(equals)(importer),
                 numeric: true,
-            }).combiner(explore);
+            })(importer).combiner(explore);
 
         const path: string = explore.postfix
             ? `path + ${explore.postfix}`
@@ -134,6 +134,7 @@ const combine =
 const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
     check_object({
         equals,
+        undefined: true,
         assert: false,
         reduce: ts.factory.createLogicalAnd,
         positive: ts.factory.createTrue(),
@@ -158,7 +159,7 @@ const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
                 ),
                 expr,
             ),
-    });
+    })(importer);
 
 const joiner =
     (equals: boolean) =>

package/src/programmers/ValidatePruneProgrammer.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { PruneProgrammer } from "./PruneProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidatePruneProgrammer {
+    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(
+                        "validate",
+                        ValidateProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "prune",
+                        PruneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("prune"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,8 +8,24 @@ export namespace AtomicPredicator {
     export const constant =
         (meta: Metadata) =>
         (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
+            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
 
     export const template = (meta: Metadata): boolean =>
         !ArrayUtil.has(meta.atomics, (type) => type === "string");
 }
+
+const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/IExpressionEntry.ts

@@ -2,9 +2,11 @@ import ts from "typescript";
 
 import { Metadata } from "../../metadata/Metadata";
 
-export interface IExpressionEntry {
+export interface IExpressionEntry<
+    Expression extends ts.ConciseBody = ts.ConciseBody,
+> {
     input: ts.Expression;
     key: Metadata;
     meta: Metadata;
-    expression: ts.Expression;
+    expression: Expression;
 }

package/src/programmers/helpers/OptionPredicator.ts

@@ -12,4 +12,8 @@ export namespace OptionPredicator {
     export function finite(options: ITransformOptions): boolean {
         return options.finite === true;
     }
+
+    export function undefined(options: ITransformOptions): boolean {
+        return options.undefined !== false;
+    }
 }

package/src/programmers/helpers/PruneJoiner.ts

@@ -0,0 +1,52 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { prune_object_properties } from "../internal/prune_object_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace PruneJoiner {
+    export const object = (
+        _input: ts.Expression,
+        entries: IExpressionEntry[],
+        obj: MetadataObject,
+    ): ts.ConciseBody => {
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entries.map((entry) =>
+                ts.isBlock(entry.expression)
+                    ? [...entry.expression.statements]
+                    : [ts.factory.createExpressionStatement(entry.expression)],
+            ),
+        );
+        statements.push(prune_object_properties(obj));
+        return ts.factory.createBlock(statements, true);
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.join(input, "forEach"),
+            undefined,
+            [arrow],
+        );
+
+    export const tuple = (
+        children: ts.ConciseBody[],
+        rest: ts.ConciseBody | null,
+    ): ts.Block => {
+        const entire: ts.ConciseBody[] = [...children];
+        if (rest !== null) entire.push(rest);
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entire.map((elem) =>
+                ts.isBlock(elem)
+                    ? [...elem.statements]
+                    : [ts.factory.createExpressionStatement(elem)],
+            ),
+        );
+        return ts.factory.createBlock(statements, true);
+    };
+}