typia 3.7.0-dev.20230310 → 3.7.0-dev.20230331

package/src/programmers/internal/check_array.ts

@@ -2,21 +2,30 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { check_array_length } from "./check_array_length";
+import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
-export function check_array(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression {
-    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
+export const check_array =
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        metaTags: IMetadataTag[],
+        jsDocTags: IJsDocTagInfo[],
+    ): ts.Expression => {
+        const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
 
-    const length: ts.Expression | null = check_array_length(input, tagList);
-    if (length !== null) conditions.push(length);
-
-    return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+        const length: ts.Expression | null = check_array_length(
+            input,
+            metaTags,
+        );
+        if (length !== null) conditions.push(length);
+        conditions.push(...check_custom("array")(importer)(input, jsDocTags));
+        return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };

package/src/programmers/internal/check_bigint.ts

@@ -1,64 +1,84 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
-export function check_bigint(input: ts.Expression, tagList: IMetadataTag[]) {
-    const caster = (value: number) =>
-        ts.factory.createIdentifier(`${Math.floor(value)}n`);
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_custom } from "./check_custom";
 
-    // TYPEOF STATEMENT
-    const conditions: ts.Expression[] = [
-        ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("bigint"),
-            ts.factory.createTypeOfExpression(input),
-        ),
-    ];
+export const check_bigint =
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        metaTags: IMetadataTag[],
+        jsDocTags: IJsDocTagInfo[],
+    ): ts.Expression => {
+        const caster = (value: number) =>
+            ts.factory.createIdentifier(`${Math.floor(value)}n`);
 
-    // TAG (RANGE)
-    for (const tag of tagList)
-        if (tag.kind === "multipleOf")
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    caster(0),
-                    ts.factory.createModulo(input, caster(tag.value)),
-                ),
-            );
-        else if (tag.kind === "step") {
-            const modulo = () =>
-                ts.factory.createModulo(input, caster(tag.value));
-            const minimum = (() => {
-                for (const tag of tagList)
-                    if (tag.kind === "minimum") return tag.value;
-                    else if (tag.kind === "exclusiveMinimum") return tag.value;
-                return undefined;
-            })();
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    caster(0),
-                    minimum !== undefined
-                        ? ts.factory.createSubtract(modulo(), caster(minimum))
-                        : modulo(),
-                ),
-            );
-        } else if (tag.kind === "minimum")
-            conditions.push(
-                ts.factory.createLessThanEquals(caster(tag.value), input),
-            );
-        else if (tag.kind === "maximum")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(caster(tag.value), input),
-            );
-        else if (tag.kind === "exclusiveMinimum")
-            conditions.push(
-                ts.factory.createLessThan(caster(tag.value), input),
-            );
-        else if (tag.kind === "exclusiveMaximum")
-            conditions.push(
-                ts.factory.createGreaterThan(caster(tag.value), input),
-            );
+        // TYPEOF STATEMENT
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
 
-    // COMBINATION
-    return conditions.length === 1
-        ? conditions[0]!
-        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+        // TAG (RANGE)
+        for (const tag of metaTags)
+            if (tag.kind === "multipleOf")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        caster(0),
+                        ts.factory.createModulo(input, caster(tag.value)),
+                    ),
+                );
+            else if (tag.kind === "step") {
+                const modulo = () =>
+                    ts.factory.createModulo(input, caster(tag.value));
+                const minimum = (() => {
+                    for (const tag of metaTags)
+                        if (tag.kind === "minimum") return tag.value;
+                        else if (tag.kind === "exclusiveMinimum")
+                            return tag.value;
+                    return undefined;
+                })();
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        caster(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(
+                                  modulo(),
+                                  caster(minimum),
+                              )
+                            : modulo(),
+                    ),
+                );
+            } else if (tag.kind === "minimum")
+                conditions.push(
+                    ts.factory.createLessThanEquals(caster(tag.value), input),
+                );
+            else if (tag.kind === "maximum")
+                conditions.push(
+                    ts.factory.createGreaterThanEquals(
+                        caster(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "exclusiveMinimum")
+                conditions.push(
+                    ts.factory.createLessThan(caster(tag.value), input),
+                );
+            else if (tag.kind === "exclusiveMaximum")
+                conditions.push(
+                    ts.factory.createGreaterThan(caster(tag.value), input),
+                );
+
+        // CUSTOM TAGS
+        conditions.push(...check_custom("bigint")(importer)(input, jsDocTags));
+
+        // COMBINATION
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };

package/src/programmers/internal/check_custom.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+
+export const check_custom =
+    (type: string) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, jsDocTags: IJsDocTagInfo[]) =>
+        jsDocTags
+            .filter(
+                (tag) =>
+                    tag.name !== "random" &&
+                    MetadataTagFactory._PARSER[tag.name] === undefined,
+            )
+            .map((tag) =>
+                ts.factory.createCallExpression(
+                    importer.use("is_custom"),
+                    undefined,
+                    [
+                        ts.factory.createStringLiteral(tag.name),
+                        ts.factory.createStringLiteral(type),
+                        ts.factory.createStringLiteral(
+                            tag.text?.[0]?.text ?? "",
+                        ),
+                        input,
+                    ],
+                ),
+            );

package/src/programmers/internal/check_number.ts

@@ -4,14 +4,21 @@ import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { IProject } from "../../transformers/IProject";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { OptionPredicator } from "../helpers/OptionPredicator";
+import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
 export const check_number =
     ({ options }: IProject, numeric: boolean) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        metaTags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
+    ) => {
         // TYPEOF STATEMENT
         const conditions: ts.Expression[] = [
             ts.factory.createStrictEquality(
@@ -22,16 +29,16 @@ export const check_number =
 
         // CHECK FINITE AND NAN
         const finite: boolean =
-            (!!tagList.find(
+            (!!metaTags.find(
                 (tag) =>
                     tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
             ) &&
-                !!tagList.find(
+                !!metaTags.find(
                     (tag) =>
                         tag.kind === "maximum" ||
                         tag.kind === "exclusiveMaximum",
                 )) ||
-            !!tagList.find(
+            !!metaTags.find(
                 (tag) => tag.kind === "step" || tag.kind === "multipleOf",
             );
 
@@ -56,7 +63,7 @@ export const check_number =
                 );
 
         // TAG (RANGE)
-        for (const tag of tagList)
+        for (const tag of metaTags)
             if (tag.kind === "type") {
                 conditions.push(
                     ts.factory.createStrictEquality(
@@ -92,7 +99,7 @@ export const check_number =
                         ts.factory.createNumericLiteral(tag.value),
                     );
                 const minimum = (() => {
-                    for (const tag of tagList)
+                    for (const tag of metaTags)
                         if (tag.kind === "minimum") return tag.value;
                         else if (tag.kind === "exclusiveMinimum")
                             return tag.value;
@@ -138,6 +145,9 @@ export const check_number =
                     ),
                 );
 
+        // CUSTOM TAGS
+        conditions.push(...check_custom("number")(importer)(input, jsDocTags));
+
         // COMBINATION
         return conditions.length === 1
             ? conditions[0]!

package/src/programmers/internal/check_string.ts

@@ -3,19 +3,25 @@ import ts from "typescript";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_custom } from "./check_custom";
 import { check_string_tags } from "./check_string_tags";
 
 /**
  * @internal
  */
 export function check_string(importer: FunctionImporter) {
-    return function (input: ts.Expression, tagList: IMetadataTag[]) {
+    return function (
+        input: ts.Expression,
+        metaTags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
+    ) {
         const conditions: ts.Expression[] = [
             ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("string"),
                 ts.factory.createTypeOfExpression(input),
             ),
-            ...check_string_tags(importer)(input, tagList),
+            ...check_string_tags(importer)(input, metaTags),
+            ...check_custom("string")(importer)(input, jsDocTags),
         ];
         return conditions.length === 1
             ? conditions[0]!

package/src/programmers/internal/check_union_array_like.ts

@@ -18,6 +18,7 @@ export const check_union_array_like =
         targets: T[],
         explore: FeatureProgrammer.IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => {
         // ONLY ONE TYPE
         if (targets.length === 1)
@@ -26,6 +27,7 @@ export const check_union_array_like =
                 targets[0]!,
                 explore,
                 tags,
+                jsDocTags,
             );
 
         //----
@@ -58,6 +60,7 @@ export const check_union_array_like =
                                         postfix: `"[0]"`,
                                     },
                                     tags,
+                                    jsDocTags,
                                     input,
                                 ),
                             ),
@@ -80,6 +83,7 @@ export const check_union_array_like =
                                         tracable: true,
                                     },
                                     tags,
+                                    jsDocTags,
                                 ),
                             ),
                         ]),
@@ -239,6 +243,7 @@ export namespace check_union_array_like {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
             array: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<T>;

package/src/programmers/internal/check_union_tuple.ts

@@ -23,6 +23,7 @@ export const check_union_tuple =
         elements: Metadata[],
         explore: CheckerProgrammer.IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
         array: ts.Expression,
     ) =>
         CheckerProgrammer.decode_tuple(project, config, importer, true)(
@@ -30,4 +31,5 @@ export const check_union_tuple =
             elements,
             explore,
             tags,
+            jsDocTags,
         );

package/src/programmers/internal/feature_object_entries.ts

@@ -54,6 +54,7 @@ export const feature_object_entries =
                                   })(),
                     },
                     prop.tags,
+                    prop.jsDocTags,
                 ),
             };
         });

package/src/transformers/CallExpressionTransformer.ts

@@ -28,7 +28,6 @@ import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransf
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -95,7 +94,7 @@ const CLI_PATH = path.resolve(
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // VALIDATORS
+    // SINGLE FUNCTIONS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -108,23 +107,13 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    //----
-    // PROTOCOL BUFFER
-    //----
-    message: () => MessageTransformer.transform,
-
-    //----
-    // JSON FUNCTIONS
-    //----
-    // SCHEMA DEFINITION
-    application: () => ApplicationTransformer.transform,
-
-    // PARSER FUNCTIONS
+    // PARSE FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
+    application: () => ApplicationTransformer.transform,
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
@@ -147,19 +136,23 @@ const FUNCTORS: Record<string, () => Task> = {
     //----
     // FACTORY FUNCTIONS
     //----
-    // VALIDATORS
+    // BASIC VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // JSON FUNCTIONS
+    // PARSE FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -59,7 +59,9 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
+        const collection: MetadataCollection = new MetadataCollection({
+            replace: MetadataCollection.replace,
+        });
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,

package/src/transformers/features/miscellaneous/CreateRandomGenerator.ts

@@ -32,7 +32,7 @@ export namespace CreateRandomTransformer {
                 },
             },
             modulo,
-        )(type, node.getText());
+        )(type, node.getFullText().trim());
     }
 }
 

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -33,7 +33,7 @@ export namespace RandomTransformer {
                     },
                 },
                 modulo,
-            )(type, node.getText()),
+            )(type, node.getFullText().trim()),
             undefined,
             expression.arguments.length
                 ? [expression.arguments[0]!]

package/src/transformers/internal/GenericTransformer.ts

@@ -47,7 +47,7 @@ export namespace GenericTransformer {
                 programmer(project, modulo)(
                     type,
                     generic
-                        ? node.getText()
+                        ? node.getFullText().trim()
                         : name(project.checker)(type)(node),
                 ),
                 undefined,
@@ -84,7 +84,7 @@ export namespace GenericTransformer {
                 );
 
             // DO TRANSFORM
-            return programmer(project, modulo)(type, node.getText());
+            return programmer(project, modulo)(type, node.getFullText().trim());
         };
 
     const name =

package/src/typings/Customizable.ts

@@ -0,0 +1,7 @@
+export type Customizable = {
+    boolean: boolean;
+    number: number;
+    string: string;
+    bigint: bigint;
+    array: any[];
+};

package/src/utils/RandomGenerator.ts

@@ -84,7 +84,13 @@ export namespace RandomGenerator {
 
     export function date(min?: number, max?: number): string {
         min ??= 0;
-        max ??= Date.now();
-        return new Date(number(min, max)).toString();
+        max ??= Date.now() * 2;
+        return new Date(number(min, max)).toISOString().substring(0, 10);
+    }
+
+    export function datetime(min?: number, max?: number): string {
+        min ??= 0;
+        max ??= Date.now() * 2;
+        return new Date(number(min, max)).toISOString();
     }
 }

package/lib/factories/ProtocolFactory.d.ts

@@ -1,8 +0,0 @@
-import ts from "typescript";
-import { Metadata } from "../metadata/Metadata";
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-import { MetadataCollection } from "./MetadataCollection";
-export declare namespace ProtocolFactory {
-    const metadata: (checker: ts.TypeChecker) => (collection: MetadataCollection) => (type: ts.Type) => Metadata;
-    const generate: (collection: MetadataCollection) => (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => void;
-}

package/lib/factories/ProtocolFactory.js

@@ -1,112 +0,0 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolFactory = void 0;
-var MetadataFactory_1 = require("./MetadataFactory");
-var emplace_protocol_object_1 = require("./internal/protocols/emplace_protocol_object");
-var iterate_protocol_main_1 = require("./internal/protocols/iterate_protocol_main");
-var ProtocolFactory;
-(function (ProtocolFactory) {
-    ProtocolFactory.metadata = function (checker) {
-        return function (collection) {
-            return function (type) {
-                return MetadataFactory_1.MetadataFactory.generate(checker, collection, type, {
-                    resolve: false,
-                    constant: true,
-                    validate: function (meta) {
-                        if (meta.any)
-                            throw new Error("Error on typia.message(): any type is not supported in protocol buffer.");
-                        else if (meta.functional && meta.size() !== 1)
-                            throw new Error("Error on typia.message(): functional type is not supported in protocol buffer.");
-                        else if (meta.objects.find(function (o) { return o.name === "__Main"; }))
-                            throw new Error("Error on typia.message(): reserved type \"__Main\" has been detected.");
-                        else if (meta.objects.find(function (o) { return o.name === "__Timestamp"; }))
-                            throw new Error("Error on typia.message(): reserved type \"__Timestamp\" has been detected.");
-                        else if (meta.objects.some(function (o) {
-                            return o.properties.some(function (p) { return !is_atomic_key(p.key); });
-                        }) ||
-                            meta.maps.some(function (m) { return !is_atomic_key(m.key); }))
-                            throw new Error("Error on typia.message(): only atomic key type is supported in protocol buffer.");
-                    },
-                });
-            };
-        };
-    };
-    ProtocolFactory.generate = function (collection) {
-        return function (dict) {
-            return function (meta) {
-                var e_1, _a;
-                try {
-                    for (var _b = __values(collection.objects()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var obj = _c.value;
-                        (0, emplace_protocol_object_1.emplace_protocol_object)(dict)(obj);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                (0, iterate_protocol_main_1.iterate_protocol_main)(dict)(meta);
-            };
-        };
-    };
-    var is_atomic_key = function (key) {
-        var e_2, _a, e_3, _b;
-        if (key.required &&
-            key.nullable === false &&
-            key.functional === false &&
-            key.resolved === null &&
-            key.size() ===
-                key.atomics.length +
-                    key.constants
-                        .map(function (c) { return c.values.length; })
-                        .reduce(function (a, b) { return a + b; }, 0) +
-                    key.templates.length) {
-            var set = new Set();
-            try {
-                for (var _c = __values(key.atomics), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var atomic = _d.value;
-                    set.add(atomic);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            try {
-                for (var _e = __values(key.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var constant = _f.value;
-                    set.add(constant.type);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            if (key.templates.length)
-                set.add("string");
-            return set.size === 1;
-        }
-        return false;
-    };
-})(ProtocolFactory = exports.ProtocolFactory || (exports.ProtocolFactory = {}));
-//# sourceMappingURL=ProtocolFactory.js.map

package/lib/factories/ProtocolFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProtocolFactory.js","sourceRoot":"","sources":["../../src/factories/ProtocolFactory.ts"],"names":[],"mappings":"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"}