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

package/src/programmers/AssertPruneProgrammer.ts

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

package/src/programmers/CheckerProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataObject } from "../metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
+import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
@@ -36,7 +37,7 @@ export namespace CheckerProgrammer {
         equals: boolean;
         numeric: boolean;
         combiner: IConfig.Combiner;
-        decoder?: FeatureProgrammer.Decoder<Metadata>;
+        decoder?: FeatureProgrammer.Decoder<Metadata, ts.Expression>;
         joiner: IConfig.IJoiner;
         success: ts.Expression;
     }
@@ -53,7 +54,10 @@ export namespace CheckerProgrammer {
             };
         }
         export interface IJoiner {
-            object(entries: IExpressionEntry[]): ts.Expression;
+            object(
+                input: ts.Expression,
+                entries: IExpressionEntry[],
+            ): ts.Expression;
             array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
             tuple?(exprs: ts.Expression[]): ts.Expression;
 
@@ -246,6 +250,7 @@ export namespace CheckerProgrammer {
             //----
             // CHECK OPTIONAL
             //----
+            // @todo -> should be elaborated
             const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
 
             // NULLABLE
@@ -288,12 +293,14 @@ export namespace CheckerProgrammer {
             //----
             // CONSTANT VALUES
             for (const constant of meta.constants)
-                for (const val of constant.values)
-                    add(true, getConstantValue(val));
+                if (AtomicPredicator.constant(meta)(constant.type))
+                    for (const val of constant.values)
+                        add(true, getConstantValue(val));
 
             // ATOMIC VALUES
             for (const type of meta.atomics)
-                if (type === "number")
+                if (AtomicPredicator.atomic(meta)(type) === false) continue;
+                else if (type === "number")
                     binaries.push({
                         expression: check_number(project, config.numeric)(
                             input,
@@ -320,14 +327,15 @@ export namespace CheckerProgrammer {
 
             // TEMPLATE LITERAL VALUES
             if (meta.templates.length)
-                binaries.push({
-                    expression: check_template(importer)(
-                        input,
-                        meta.templates,
-                        tags,
-                    ),
-                    combined: false,
-                });
+                if (AtomicPredicator.template(meta))
+                    binaries.push({
+                        expression: check_template(importer)(
+                            input,
+                            meta.templates,
+                            tags,
+                        ),
+                        combined: false,
+                    });
 
             // NATIVE CLASSES
             for (const native of meta.natives)

package/src/programmers/FeatureProgrammer.ts

@@ -21,29 +21,135 @@ export namespace FeatureProgrammer {
     /* -----------------------------------------------------------
         PARAMETERS
     ----------------------------------------------------------- */
-    export interface IConfig {
+    export interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
+        /**
+         * Prefix name of functions for specific object types.
+         */
         functors: string;
+
+        /**
+         * Prefix name of functions for union object types.
+         */
         unioners: string;
+
+        /**
+         * Whether to archive access path or not.
+         */
         path: boolean;
+
+        /**
+         * Whether to trace exception or not.
+         */
         trace: boolean;
-        initializer: Initializer;
-        decoder: Decoder<Metadata>;
+
+        /**
+         * Initializer of metadata.
+         */
+        initializer(
+            project: IProject,
+            type: ts.Type,
+        ): [MetadataCollection, Metadata];
+
+        /**
+         * Decoder, station of every types.
+         */
+        decoder: Decoder<Metadata, Output>;
+
+        /**
+         * Object configurator.
+         */
         objector: IConfig.IObjector;
+
+        /**
+         * Generator of functions for object types.
+         */
         generator?: Partial<IConfig.IGenerator>;
     }
     export namespace IConfig {
         export interface IObjector {
-            checker: Decoder<Metadata>;
-            decoder: Decoder<MetadataObject>;
-            joiner: ObjectJoiner;
-            unionizer: Decoder<MetadataObject[]>;
-            failure: (
+            /**
+             * Type checker when union object type comes.
+             */
+            checker: Decoder<Metadata, ts.Expression>;
+
+            /**
+             * Decoder, function call expression generator of specific typed objects.
+             */
+            decoder: Decoder<MetadataObject, ts.Expression>;
+
+            /**
+             * Joiner of expressions from properties.
+             */
+            joiner(
+                input: ts.Expression,
+                entries: IExpressionEntry[],
+                parent: MetadataObject,
+            ): ts.ConciseBody;
+
+            /**
+             * Union type specificator.
+             *
+             * Expression of an algorithm specifying object type and calling
+             * the `decoder` function of the specified object type.
+             */
+            unionizer: Decoder<MetadataObject[], ts.Expression>;
+
+            /**
+             * Handler of union type specification failure.
+             *
+             * @param value Expression of input parameter
+             * @param expected Expected type name
+             * @param explore Exploration info
+             * @returns Statement of failure
+             */
+            failure(
                 value: ts.Expression,
                 expected: string,
                 explore?: IExplore,
-            ) => ts.Statement;
-            is?: (exp: ts.Expression) => ts.Expression;
-            required?: (exp: ts.Expression) => ts.Expression;
+            ): ts.Statement;
+
+            /**
+             * Transformer of type checking expression by discrimination.
+             *
+             * When an object type has been specified by a discrimination without full
+             * iteration, the `unionizer` will decode the object instance after
+             * the last type checking.
+             *
+             * In such circumtance, you can transform the last type checking function.
+             *
+             * @param exp Current expression about type checking
+             * @returns Transformed expression
+             * @deprecated
+             */
+            is?(exp: ts.Expression): ts.Expression;
+
+            /**
+             * Transformer of non-undefined type checking by discrimination.
+             *
+             * When specifying an union type of objects, `typia` tries to find
+             * descrimination way just by checking only one property type.
+             * If succeeded to find the discrimination way, `typia` will check the target
+             * property type and in the checking, non-undefined type checking would be
+             * done.
+             *
+             * In such process, you can transform the non-undefined type checking.
+             *
+             * @param exp
+             * @returns Transformed expression
+             * @deprecated
+             */
+            required?(exp: ts.Expression): ts.Expression;
+
+            /**
+             * Conditon wrapper when unable to specify any object type.
+             *
+             * When failed to specify an object type through discrimination, full
+             * iteration type checking would be happend. In such circumstance, you
+             * can wrap the condition with additional function.
+             *
+             * @param condition Current condition
+             * @returns A function wrapped current condition
+             */
             full?: (
                 condition: ts.Expression,
             ) => (
@@ -53,10 +159,20 @@ export namespace FeatureProgrammer {
             ) => ts.Expression;
         }
         export interface IGenerator {
+            /**
+             *
+             * @param col
+             */
             functors(col: MetadataCollection): ts.VariableStatement[];
+
+            /**
+             *
+             * @param col
+             */
             unioners(col: MetadataCollection): ts.VariableStatement[];
         }
     }
+
     export interface IExplore {
         tracable: boolean;
         source: "top" | "object";
@@ -65,24 +181,30 @@ export namespace FeatureProgrammer {
         start?: number;
     }
 
-    export interface Initializer {
-        (project: IProject, type: ts.Type): [MetadataCollection, Metadata];
-    }
-    export interface Decoder<T> {
+    export interface Decoder<
+        T,
+        Output extends ts.ConciseBody = ts.ConciseBody,
+    > {
         (
             input: ts.Expression,
             target: T,
             explore: IExplore,
             tags: IMetadataTag[],
-        ): ts.Expression;
-    }
-    export interface ObjectJoiner {
-        (entries: IExpressionEntry[], parent: MetadataObject): ts.ConciseBody;
+        ): Output;
     }
 
     /* -----------------------------------------------------------
         GENERATORS
     ----------------------------------------------------------- */
+    /**
+     * Generates a decoder function for a specific type.
+     *
+     * @param project Project configuration
+     * @param config Detailed configuration for programming
+     * @param importer Function importer
+     * @param addition Generator of additinal statements in the top of function
+     * @returns Currying function generating type decoder function
+     */
     export const generate =
         (
             project: IProject,
@@ -96,7 +218,7 @@ export namespace FeatureProgrammer {
             const [collection, meta] = config.initializer(project, type);
 
             // ITERATE OVER ALL METADATA
-            const output: ts.Expression = config.decoder(
+            const output: ts.ConciseBody = config.decoder(
                 ValueFactory.INPUT(),
                 meta,
                 {
@@ -130,7 +252,9 @@ export namespace FeatureProgrammer {
                         ...(added || []),
                         ...functors,
                         ...unioners,
-                        ts.factory.createReturnStatement(output),
+                        ...(ts.isBlock(output)
+                            ? output.statements
+                            : [ts.factory.createReturnStatement(output)]),
                     ],
                     true,
                 ),
@@ -170,6 +294,7 @@ export namespace FeatureProgrammer {
                 undefined,
                 undefined,
                 config.objector.joiner(
+                    ts.factory.createIdentifier("input"),
                     feature_object_entries(config)(obj)(
                         ts.factory.createIdentifier("input"),
                     ),

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/IsPruneProgrammer.ts

@@ -0,0 +1,63 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { IsProgrammer } from "./IsProgrammer";
+import { PruneProgrammer } from "./PruneProgrammer";
+
+export namespace IsPruneProgrammer {
+    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(
+                        "prune",
+                        PruneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createFalse(),
+                        ),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("prune"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(ts.factory.createTrue()),
+                ]),
+            );
+}