typia 5.2.6 → 5.2.7-dev.20231109

package/src/factories/MetadataFactory.ts

@@ -11,6 +11,7 @@ import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort
 
 import { ValidationPipe } from "../typings/ValidationPipe";
 
+import { ExpressionFactory } from "./ExpressionFactory";
 import { MetadataCollection } from "./MetadataCollection";
 
 export namespace MetadataFactory {
@@ -40,7 +41,7 @@ export namespace MetadataFactory {
     }
 
     export const analyze =
-        (checker: ts.TypeChecker) =>
+        (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (collection: MetadataCollection) =>
         (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
@@ -59,7 +60,9 @@ export namespace MetadataFactory {
             iterate_metadata_sort(collection)(meta);
 
             if (options.validate)
-                errors.push(...validate(options)(options.validate)(meta));
+                errors.push(
+                    ...validate(context)(options)(options.validate)(meta),
+                );
             return errors.length
                 ? {
                       success: false,
@@ -84,6 +87,7 @@ export namespace MetadataFactory {
     };
 
     const validate =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (functor: Validator) =>
         (meta: Metadata): IError[] => {
@@ -95,7 +99,7 @@ export namespace MetadataFactory {
                 tuples: new Set(),
                 aliases: new Set(),
             };
-            validateMeta(options)(visitor)(meta, {
+            validateMeta(context)(options)(visitor)(meta, {
                 object: null,
                 property: null,
                 nested: null,
@@ -107,47 +111,70 @@ export namespace MetadataFactory {
         };
 
     const validateMeta =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (meta: Metadata, explore: IExplore) => {
-            const result: Set<string> = new Set(visitor.functor(meta, explore));
-            if (result.size)
+            const result: string[] = [];
+            if (context !== undefined)
+                for (const atomic of meta.atomics)
+                    for (const row of atomic.tags)
+                        for (const tag of row.filter(
+                            (t) =>
+                                t.validate !== undefined &&
+                                t.predicate === undefined,
+                        ))
+                            try {
+                                tag.predicate = ExpressionFactory.transpile(
+                                    context,
+                                )(tag.validate!);
+                            } catch {
+                                result.push(
+                                    `Unable to transpile type tag script: ${JSON.stringify(
+                                        tag.validate,
+                                    )}`,
+                                );
+                                tag.predicate = () => ts.factory.createTrue();
+                            }
+            result.push(...visitor.functor(meta, explore));
+            if (result.length)
                 visitor.errors.push({
                     name: meta.getName(),
                     explore: { ...explore },
-                    messages: [...result],
+                    messages: [...new Set(result)],
                 });
 
             for (const alias of meta.aliases)
-                validateAlias(options)(visitor)(alias, explore);
+                validateAlias(context)(options)(visitor)(alias, explore);
             for (const array of meta.arrays)
-                validateArray(options)(visitor)(array.type, explore);
+                validateArray(context)(options)(visitor)(array.type, explore);
             for (const tuple of meta.tuples)
-                validateTuple(options)(visitor)(tuple.type, explore);
+                validateTuple(context)(options)(visitor)(tuple.type, explore);
             for (const obj of meta.objects)
-                validateObject(options)(visitor)(obj);
+                validateObject(context)(options)(visitor)(obj);
             for (const set of meta.sets)
-                validateMeta(options)(visitor)(set, explore);
+                validateMeta(context)(options)(visitor)(set, explore);
             for (const map of meta.maps) {
-                validateMeta(options)(visitor)(map.key, explore);
-                validateMeta(options)(visitor)(map.value, explore);
+                validateMeta(context)(options)(visitor)(map.key, explore);
+                validateMeta(context)(options)(visitor)(map.value, explore);
             }
 
             if (options.escape === true && meta.escaped !== null)
-                validateMeta(options)(visitor)(meta.escaped.returns, {
+                validateMeta(context)(options)(visitor)(meta.escaped.returns, {
                     ...explore,
                     escaped: true,
                 });
         };
 
     const validateAlias =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (alias: MetadataAlias, explore: IExplore) => {
             if (visitor.aliases.has(alias)) return;
             visitor.aliases.add(alias);
 
-            validateMeta(options)(visitor)(alias.value, {
+            validateMeta(context)(options)(visitor)(alias.value, {
                 ...explore,
                 nested: alias,
                 aliased: true,
@@ -155,13 +182,14 @@ export namespace MetadataFactory {
         };
 
     const validateArray =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (array: MetadataArrayType, explore: IExplore) => {
             if (visitor.arrays.has(array)) return;
             visitor.arrays.add(array);
 
-            validateMeta(options)(visitor)(array.value, {
+            validateMeta(context)(options)(visitor)(array.value, {
                 ...explore,
                 nested: array,
                 top: false,
@@ -169,6 +197,7 @@ export namespace MetadataFactory {
         };
 
     const validateTuple =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (tuple: MetadataTupleType, explore: IExplore) => {
@@ -176,7 +205,7 @@ export namespace MetadataFactory {
             visitor.tuples.add(tuple);
 
             for (const elem of tuple.elements)
-                validateMeta(options)(visitor)(elem, {
+                validateMeta(context)(options)(visitor)(elem, {
                     ...explore,
                     nested: tuple,
                     top: false,
@@ -184,6 +213,7 @@ export namespace MetadataFactory {
         };
 
     const validateObject =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (object: MetadataObject) => {
@@ -215,7 +245,7 @@ export namespace MetadataFactory {
             }
 
             for (const property of object.properties)
-                validateMeta(options)(visitor)(property.value, {
+                validateMeta(context)(options)(visitor)(property.value, {
                     object,
                     property: property.key.isSoleLiteral()
                         ? property.key.getSoleLiteral()!

package/src/factories/NumericRangeFactory.ts

@@ -6,28 +6,67 @@ import { ExpressionFactory } from "./ExpressionFactory";
 
 export namespace NumericRangeFactory {
     export const number =
-        (context: ts.TransformationContext) =>
         (type: ProtobufAtomic.Numeric) =>
         (input: ts.Expression): ts.Expression =>
-            ExpressionFactory.transpile(context)(NUMBER_TEXT[type])(input);
+            NumberPredicator[type](input);
 
     export const bigint =
-        (context: ts.TransformationContext) =>
         (type: ProtobufAtomic.BigNumeric) =>
         (input: ts.Expression): ts.Expression =>
-            ExpressionFactory.transpile(context)(BIGINT_TEXT[type])(input);
+            BigIntPredicator[type](input);
 }
 
-const NUMBER_TEXT = {
-    int32: `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`,
-    uint32: `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`,
-    int64: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`,
-    uint64: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`,
-    float: `-1.175494351e38 <= $input && $input <= 3.4028235e38`,
-    double: `true`,
-};
-
-const BIGINT_TEXT = {
-    int64: `true`,
-    uint64: `BigInt(0) <= $input`,
-};
+namespace NumberPredicator {
+    export const int32 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("-2147483648", "2147483647")(input),
+        );
+    export const uint32 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("0", "4294967295")(input),
+        );
+    export const int64 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("-9223372036854775808", "9223372036854775807")(input),
+        );
+    export const uint64 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("0", "18446744073709551615")(input),
+        );
+    export const float = (input: ts.Expression) =>
+        between("-1.175494351e38", "3.4028235e38")(input);
+    export const double = () => ts.factory.createTrue();
+}
+
+namespace BigIntPredicator {
+    export const int64 = () => ts.factory.createTrue();
+    export const uint64 = (input: ts.Expression) =>
+        ts.factory.createLessThanEquals(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
+                undefined,
+                [ExpressionFactory.number(0)],
+            ),
+            input,
+        );
+}
+
+const integer = (input: ts.Expression) =>
+    ts.factory.createStrictEquality(
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Math.floor"),
+            undefined,
+            [input],
+        ),
+        input,
+    );
+
+const between = (x: string, y: string) => (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+        ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
+        ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
+    );

package/src/factories/ProtobufFactory.ts

@@ -17,12 +17,15 @@ import { MetadataFactory } from "./MetadataFactory";
 export namespace ProtobufFactory {
     export const metadata =
         (method: string) =>
-        (checker: ts.TypeChecker) =>
+        (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
         (collection: MetadataCollection) =>
         (type: ts.Type): Metadata => {
             // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
             const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-                MetadataFactory.analyze(checker)({
+                MetadataFactory.analyze(
+                    checker,
+                    context,
+                )({
                     escape: false,
                     constant: true,
                     absorb: true,

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -1,178 +1,178 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
-export const emplace_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (errors: MetadataFactory.IError[]) =>
-    (parent: ts.Type, nullable: boolean): MetadataObject => {
-        // EMPLACE OBJECT
-        const [obj, newbie] = collection.emplace(checker, parent);
-        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-
-        if (newbie === false) return obj;
-
-        // PREPARE ASSETS
-        const isClass: boolean = parent.isClass();
-        const pred: (node: ts.Declaration) => boolean = isClass
-            ? (node) => {
-                  const kind: ts.SyntaxKind | undefined = node
-                      .getChildren()[0]
-                      ?.getChildren()[0]?.kind;
-                  return (
-                      kind !== ts.SyntaxKind.PrivateKeyword &&
-                      kind !== ts.SyntaxKind.ProtectedKeyword &&
-                      (ts.isParameter(node) || isProperty(node))
-                  );
-              }
-            : (node) => isProperty(node);
-
-        const insert =
-            (key: Metadata) =>
-            (value: Metadata) =>
-            (
-                symbol: ts.Symbol | undefined,
-                filter?: (doc: ts.JSDocTagInfo) => boolean,
-            ): MetadataProperty => {
-                // COMMENTS AND TAGS
-                const description: string | null = symbol
-                    ? CommentFactory.description(symbol) ?? null
-                    : null;
-                const jsDocTags: ts.JSDocTagInfo[] = (
-                    symbol?.getJsDocTags() ?? []
-                ).filter(filter ?? (() => true));
-
-                // THE PROPERTY
-                const property = MetadataProperty.create({
-                    key,
-                    value,
-                    description,
-                    jsDocTags,
-                });
-                obj.properties.push(property);
-                return property;
-            };
-
-        //----
-        // REGULAR PROPERTIES
-        //----
-        for (const prop of parent.getApparentProperties()) {
-            // CHECK INTERNAL TAG
-            if (
-                (prop.getJsDocTags(checker) ?? []).find(
-                    (tag) => tag.name === "internal",
-                ) !== undefined
-            )
-                continue;
-
-            // CHECK NODE IS A FORMAL PROPERTY
-            const [node, type] = (() => {
-                const node = prop.getDeclarations()?.[0] as
-                    | ts.PropertyDeclaration
-                    | undefined;
-                const type: ts.Type | undefined = node
-                    ? checker.getTypeOfSymbolAtLocation(prop, node)
-                    : checker.getTypeOfPropertyOfType(parent, prop.name);
-                return [node, type];
-            })();
-            if ((node && pred(node) === false) || type === undefined) continue;
-
-            // GET EXACT TYPE
-            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
-            const value: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(errors)(type, {
-                top: false,
-                object: obj,
-                property: prop.name,
-                nested: null,
-                escaped: false,
-                aliased: false,
-            });
-            Writable(value).optional =
-                (prop.flags & ts.SymbolFlags.Optional) !== 0;
-            insert(key)(value)(prop);
-        }
-
-        //----
-        // DYNAMIC PROPERTIES
-        //----
-        for (const index of checker.getIndexInfosOfType(parent)) {
-            // GET EXACT TYPE
-            const analyzer = (type: ts.Type) => (property: {} | null) =>
-                explore_metadata(checker)(options)(collection)(errors)(type, {
-                    top: false,
-                    object: obj,
-                    property,
-                    nested: null,
-                    escaped: false,
-                    aliased: false,
-                });
-            const key: Metadata = analyzer(index.keyType)(null);
-            const value: Metadata = analyzer(index.type)({});
-
-            if (
-                key.atomics.length +
-                    key.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    key.templates.length +
-                    key.natives.filter(
-                        (type) =>
-                            type === "Boolean" ||
-                            type === "BigInt" ||
-                            type === "Number" ||
-                            type === "String",
-                    ).length !==
-                key.size()
-            )
-                errors.push({
-                    name: key.getName(),
-                    explore: {
-                        top: false,
-                        object: obj,
-                        property: "[key]",
-                        nested: null,
-                        escaped: false,
-                        aliased: false,
-                    },
-                    messages: [],
-                });
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            insert(key)(value)(
-                index.declaration?.parent
-                    ? checker.getSymbolAtLocation(index.declaration.parent)
-                    : undefined,
-                (doc) => doc.name !== "default",
-            );
-        }
-        return obj;
-    };
-
-const isProperty = (node: ts.Declaration) =>
-    ts.isPropertyDeclaration(node) ||
-    ts.isPropertyAssignment(node) ||
-    ts.isPropertySignature(node) ||
-    ts.isTypeLiteralNode(node);
-
-const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
-    if (type.isUnionOrIntersection())
-        type.types.forEach((child) => iterate_optional_coalesce(meta, child));
-    else iterate_metadata_coalesce(meta, type);
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+
+export const emplace_metadata_object =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
+    (parent: ts.Type, nullable: boolean): MetadataObject => {
+        // EMPLACE OBJECT
+        const [obj, newbie] = collection.emplace(checker, parent);
+        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+
+        if (newbie === false) return obj;
+
+        // PREPARE ASSETS
+        const isClass: boolean = parent.isClass();
+        const pred: (node: ts.Declaration) => boolean = isClass
+            ? (node) => {
+                  const kind: ts.SyntaxKind | undefined = node
+                      .getChildren()[0]
+                      ?.getChildren()[0]?.kind;
+                  return (
+                      kind !== ts.SyntaxKind.PrivateKeyword &&
+                      kind !== ts.SyntaxKind.ProtectedKeyword &&
+                      (ts.isParameter(node) || isProperty(node))
+                  );
+              }
+            : (node) => isProperty(node);
+
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: ts.JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | null = symbol
+                    ? CommentFactory.description(symbol) ?? null
+                    : null;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() ?? []
+                ).filter(filter ?? (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                });
+                obj.properties.push(property);
+                return property;
+            };
+
+        //----
+        // REGULAR PROPERTIES
+        //----
+        for (const prop of parent.getApparentProperties()) {
+            // CHECK INTERNAL TAG
+            if (
+                (prop.getJsDocTags(checker) ?? []).find(
+                    (tag) => tag.name === "internal",
+                ) !== undefined
+            )
+                continue;
+
+            // CHECK NODE IS A FORMAL PROPERTY
+            const [node, type] = (() => {
+                const node = prop.getDeclarations()?.[0] as
+                    | ts.PropertyDeclaration
+                    | undefined;
+                const type: ts.Type | undefined = node
+                    ? checker.getTypeOfSymbolAtLocation(prop, node)
+                    : checker.getTypeOfPropertyOfType(parent, prop.name);
+                return [node, type];
+            })();
+            if ((node && pred(node) === false) || type === undefined) continue;
+
+            // GET EXACT TYPE
+            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+            const value: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(errors)(type, {
+                top: false,
+                object: obj,
+                property: prop.name,
+                nested: null,
+                escaped: false,
+                aliased: false,
+            });
+            Writable(value).optional =
+                (prop.flags & ts.SymbolFlags.Optional) !== 0;
+            insert(key)(value)(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) => (property: {} | null) =>
+                explore_metadata(checker)(options)(collection)(errors)(type, {
+                    top: false,
+                    object: obj,
+                    property,
+                    nested: null,
+                    escaped: false,
+                    aliased: false,
+                });
+            const key: Metadata = analyzer(index.keyType)(null);
+            const value: Metadata = analyzer(index.type)({});
+
+            if (
+                key.atomics.length +
+                    key.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    key.templates.length +
+                    key.natives.filter(
+                        (type) =>
+                            type === "Boolean" ||
+                            type === "BigInt" ||
+                            type === "Number" ||
+                            type === "String",
+                    ).length !==
+                key.size()
+            )
+                errors.push({
+                    name: key.getName(),
+                    explore: {
+                        top: false,
+                        object: obj,
+                        property: "[key]",
+                        nested: null,
+                        escaped: false,
+                        aliased: false,
+                    },
+                    messages: [],
+                });
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            insert(key)(value)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
+            );
+        }
+        return obj;
+    };
+
+const isProperty = (node: ts.Declaration) =>
+    ts.isPropertyDeclaration(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isPropertySignature(node) ||
+    ts.isTypeLiteralNode(node);
+
+const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
+    if (type.isUnionOrIntersection())
+        type.types.forEach((child) => iterate_optional_coalesce(meta, child));
+    else iterate_metadata_coalesce(meta, type);
+};

package/src/functional/$stoll.ts

@@ -1,8 +1,8 @@
-export const $is_bigint_string = (str: string): boolean => {
-    try {
-        BigInt(str);
-        return true;
-    } catch {
-        return false;
-    }
-};
+export const $is_bigint_string = (str: string): boolean => {
+    try {
+        BigInt(str);
+        return true;
+    } catch {
+        return false;
+    }
+};