typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/programmers/FeatureProgrammer.ts

@@ -6,10 +6,8 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
@@ -49,6 +47,8 @@ export namespace FeatureProgrammer {
          */
         initializer: (
             project: IProject,
+        ) => (
+            importer: FunctionImporter,
         ) => (type: ts.Type) => [MetadataCollection, Metadata];
 
         /**
@@ -191,13 +191,7 @@ export namespace FeatureProgrammer {
         T,
         Output extends ts.ConciseBody = ts.ConciseBody,
     > {
-        (
-            input: ts.Expression,
-            target: T,
-            explore: IExplore,
-            metaTags: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
-        ): Output;
+        (input: ts.Expression, target: T, explore: IExplore): Output;
     }
 
     /* -----------------------------------------------------------
@@ -208,7 +202,8 @@ export namespace FeatureProgrammer {
         (config: IConfig) =>
         (importer: FunctionImporter) =>
         (type: ts.Type, name?: string) => {
-            const [collection, meta] = config.initializer(project)(type);
+            const [collection, meta] =
+                config.initializer(project)(importer)(type);
 
             // ITERATE OVER ALL METADATA
             const output: ts.ConciseBody = config.decoder()(
@@ -220,8 +215,6 @@ export namespace FeatureProgrammer {
                     from: "top",
                     postfix: '""',
                 },
-                [],
-                [],
             );
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
@@ -324,18 +317,12 @@ export namespace FeatureProgrammer {
                 ),
                 TypeFactory.keyword("any"),
                 undefined,
-                explorer(
-                    input,
-                    meta,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from: "object",
-                        postfix: "",
-                    },
-                    [],
-                    [],
-                ),
+                explorer(input, meta, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from: "object",
+                    postfix: "",
+                }),
             );
     };
 
@@ -349,8 +336,6 @@ export namespace FeatureProgrammer {
             combiner: (
                 input: ts.Expression,
                 arrow: ts.ArrowFunction,
-                metaTags: IMetadataCommentTag[],
-                jsDocTags: ts.JSDocTagInfo[],
             ) => ts.Expression,
         ) => {
             const rand: string = importer.increment().toString();
@@ -366,10 +351,8 @@ export namespace FeatureProgrammer {
 
             return (
                 input: ts.Expression,
-                array: MetadataArrayType,
+                array: MetadataArray,
                 explore: IExplore,
-                metaTags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => {
                 const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                     undefined,
@@ -385,7 +368,7 @@ export namespace FeatureProgrammer {
                     undefined,
                     config.decoder()(
                         ValueFactory.INPUT("elem"),
-                        array.value,
+                        array.type.value,
                         {
                             tracable: explore.tracable,
                             source: explore.source,
@@ -394,11 +377,9 @@ export namespace FeatureProgrammer {
                                 explore.postfix,
                             )(rand),
                         },
-                        metaTags,
-                        jsDocTags,
                     ),
                 );
-                return combiner(input, arrow, metaTags, jsDocTags);
+                return combiner(input, arrow);
             };
         };
 

package/src/programmers/IsProgrammer.ts

@@ -23,16 +23,30 @@ export namespace IsProgrammer {
         (options?: Partial<CONFIG.IOptions>) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
             prefix: "$i",
+            equals: !!options?.object,
             trace: false,
             path: false,
-            equals: !!options?.object,
             numeric: OptionPredicator.numeric({
                 numeric: options?.numeric,
             }),
             atomist: () => (entry) => () =>
                 [
                     ...(entry.expression ? [entry.expression] : []),
-                    ...entry.tags.map((tag) => tag.expression),
+                    ...(entry.conditions.length === 0
+                        ? []
+                        : [
+                              entry.conditions
+                                  .map((set) =>
+                                      set
+                                          .map((s) => s.expression)
+                                          .reduce((a, b) =>
+                                              ts.factory.createLogicalAnd(a, b),
+                                          ),
+                                  )
+                                  .reduce((a, b) =>
+                                      ts.factory.createLogicalOr(a, b),
+                                  ),
+                          ]),
                 ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {
                 const initial: ts.TrueLiteral | ts.FalseLiteral =
@@ -119,52 +133,49 @@ export namespace IsProgrammer {
                 addition: () => importer.declare(modulo),
             };
 
-            config.decoder =
-                () => (input, target, explore, tags, jsDocTags) => {
+            config.decoder = () => (input, target, explore) => {
+                if (
+                    target.size() === 1 &&
+                    target.objects.length === 1 &&
+                    target.isRequired() === 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.isRequired() === true &&
-                        target.nullable === false
-                    ) {
-                        // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
-                        const obj: MetadataObject = target.objects[0]!;
-                        if (
-                            obj._Is_simple(explore.from === "top" ? 0 : 1) &&
-                            (equals === false ||
-                                OptionPredicator.undefined(project.options) ===
-                                    false)
-                        )
-                            return ts.factory.createLogicalAnd(
-                                ExpressionFactory.isObject({
-                                    checkNull: true,
-                                    checkArray: false,
-                                })(input),
-                                config.joiner.object(
+                        obj._Is_simple(explore.from === "top" ? 0 : 1) &&
+                        (equals === false ||
+                            OptionPredicator.undefined(project.options) ===
+                                false)
+                    )
+                        return ts.factory.createLogicalAnd(
+                            ExpressionFactory.isObject({
+                                checkNull: true,
+                                checkArray: false,
+                            })(input),
+                            config.joiner.object(
+                                ts.factory.createAsExpression(
+                                    input,
+                                    TypeFactory.keyword("any"),
+                                ),
+                                feature_object_entries(config as any)(importer)(
+                                    obj,
+                                )(
                                     ts.factory.createAsExpression(
                                         input,
                                         TypeFactory.keyword("any"),
                                     ),
-                                    feature_object_entries(config as any)(
-                                        importer,
-                                    )(obj)(
-                                        ts.factory.createAsExpression(
-                                            input,
-                                            TypeFactory.keyword("any"),
-                                        ),
-                                        "top",
-                                    ),
+                                    "top",
                                 ),
-                            );
-                    }
-                    return CheckerProgrammer.decode(project)(config)(importer)(
-                        input,
-                        target,
-                        explore,
-                        tags,
-                        jsDocTags,
-                    );
-                };
+                            ),
+                        );
+                }
+                return CheckerProgrammer.decode(project)(config)(importer)(
+                    input,
+                    target,
+                    explore,
+                );
+            };
 
             // GENERATE CHECKER
             return CheckerProgrammer.write(project)(config)(importer);