typia 3.5.0-dev.20221219 → 3.5.0-dev.20230107

package/src/programmers/internal/check_array_length.ts

@@ -0,0 +1,45 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { check_length } from "./check_length";
+
+/**
+ * @internal
+ */
+export function check_array_length(
+    input: ts.Expression,
+    tagList: IMetadataTag[],
+): ts.Expression | null {
+    const conditions: ts.Expression[] = [];
+
+    // CHECK TAGS
+    for (const tag of tagList)
+        if (tag.kind === "minItems")
+            conditions.push(
+                ts.factory.createLessThanEquals(
+                    ts.factory.createNumericLiteral(tag.value),
+                    IdentifierFactory.join(input, "length"),
+                ),
+            );
+        else if (tag.kind === "maxItems")
+            conditions.push(
+                ts.factory.createGreaterThanEquals(
+                    ts.factory.createNumericLiteral(tag.value),
+                    IdentifierFactory.join(input, "length"),
+                ),
+            );
+        else if (tag.kind === "items")
+            check_length(
+                conditions,
+                IdentifierFactory.join(input, "length"),
+                tag,
+            );
+
+    // COMBINATION
+    return conditions.length
+        ? conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y))
+        : null;
+}

package/src/programmers/internal/check_bigint.ts

@@ -0,0 +1,85 @@
+import ts from "typescript";
+
+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`);
+
+    // TYPEOF STATEMENT
+    const conditions: ts.Expression[] = [
+        ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("bigint"),
+            ts.factory.createTypeOfExpression(input),
+        ),
+    ];
+
+    // 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;
+                    else if (tag.kind === "range" && tag.minimum !== undefined)
+                        return tag.minimum.value;
+                return undefined;
+            })();
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    caster(0),
+                    minimum !== undefined
+                        ? ts.factory.createSubtract(modulo(), caster(minimum))
+                        : modulo(),
+                ),
+            );
+        } else if (tag.kind === "range") {
+            if (tag.minimum !== undefined)
+                conditions.push(
+                    (tag.minimum.include
+                        ? ts.factory.createLessThanEquals
+                        : ts.factory.createLessThan)(
+                        caster(tag.minimum.value),
+                        input,
+                    ),
+                );
+            if (tag.maximum !== undefined)
+                conditions.push(
+                    (tag.maximum.include
+                        ? ts.factory.createLessThanEquals
+                        : ts.factory.createLessThan)(
+                        input,
+                        caster(tag.maximum.value),
+                    ),
+                );
+        } 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),
+            );
+
+    // COMBINATION
+    return conditions.length === 1
+        ? conditions[0]!
+        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+}

package/src/programmers/internal/check_number.ts

@@ -9,9 +9,10 @@ import { OptionPredicator } from "../helpers/OptionPredicator";
 /**
  * @internal
  */
-export function check_number(project: IProject, numeric: boolean) {
-    return function (input: ts.Expression, tagList: IMetadataTag[]) {
-        // TYPEOF
+export const check_number =
+    ({ options }: IProject, numeric: boolean) =>
+    (input: ts.Expression, tagList: IMetadataTag[]) => {
+        // TYPEOF STATEMENT
         const conditions: ts.Expression[] = [
             ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("number"),
@@ -19,6 +20,47 @@ export function check_number(project: IProject, numeric: boolean) {
             ),
         ];
 
+        // CHECK FINITE AND NAN
+        const finite: boolean =
+            !!tagList.find(
+                (tag) =>
+                    tag.kind === "range" &&
+                    tag.minimum !== undefined &&
+                    tag.maximum !== undefined,
+            ) ||
+            (!!tagList.find(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
+            ) &&
+                !!tagList.find(
+                    (tag) =>
+                        tag.kind === "maximum" ||
+                        tag.kind === "exclusiveMaximum",
+                )) ||
+            !!tagList.find(
+                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
+            );
+
+        if (numeric === true && finite === false)
+            if (OptionPredicator.finite(options))
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Number.isFinite"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (OptionPredicator.numeric(options))
+                conditions.push(
+                    ts.factory.createLogicalNot(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+
         // TAG (RANGE)
         for (const tag of tagList)
             if (tag.kind === "type") {
@@ -126,56 +168,8 @@ export function check_number(project: IProject, numeric: boolean) {
                     ),
                 );
 
-        // NUMERIC VALIDATION
-        const finite: boolean =
-            !!tagList.find(
-                (tag) =>
-                    tag.kind === "range" &&
-                    tag.minimum !== undefined &&
-                    tag.maximum !== undefined,
-            ) ||
-            (!!tagList.find(
-                (tag) =>
-                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-            ) &&
-                !!tagList.find(
-                    (tag) =>
-                        tag.kind === "maximum" ||
-                        tag.kind === "exclusiveMaximum",
-                )) ||
-            !!tagList.find(
-                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
-            );
-        const valid: boolean =
-            finite || tagList.find((tag) => tag.kind === "type") !== undefined;
-
-        if (
-            numeric &&
-            OptionPredicator.numeric(project.options, "checker") === false
-        ) {
-            if (finite === false)
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            if (valid === false)
-                conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-        }
-
         // COMBINATION
         return conditions.length === 1
             ? conditions[0]!
             : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
     };
-}

package/src/programmers/internal/check_union_array_like.ts

@@ -0,0 +1,242 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { UnionExplorer } from "../helpers/UnionExplorer";
+
+export const check_union_array_like =
+    <T>(accessor: check_union_array_like.IAccessor<T>) =>
+    (props: check_union_array_like.IProps<T>) =>
+    (
+        input: ts.Expression,
+        targets: T[],
+        explore: FeatureProgrammer.IExplore,
+        tags: IMetadataTag[],
+    ) => {
+        // ONLY ONE TYPE
+        if (targets.length === 1)
+            return props.decoder(
+                accessor.array(input),
+                targets[0]!,
+                explore,
+                tags,
+            );
+
+        //----
+        // LIST UP VARIABLES
+        //----
+        // TUPLES
+        const tupleListVariable: ts.VariableStatement =
+            StatementFactory.constant(
+                "tupleList",
+                ts.factory.createArrayLiteralExpression(
+                    targets.map((meta) =>
+                        ts.factory.createArrayLiteralExpression([
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter("top")],
+                                undefined,
+                                undefined,
+                                props.checker(
+                                    ts.factory.createIdentifier("top"),
+                                    meta,
+                                    {
+                                        ...explore,
+                                        tracable: false,
+                                        postfix: `"[0]"`,
+                                    },
+                                    tags,
+                                    input,
+                                ),
+                            ),
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter("top")],
+                                undefined,
+                                undefined,
+                                props.decoder(
+                                    ts.factory.createIdentifier("top"),
+                                    meta,
+                                    {
+                                        ...explore,
+                                        tracable: true,
+                                    },
+                                    tags,
+                                ),
+                            ),
+                        ]),
+                    ),
+                ),
+            );
+
+        // FILTERED TUPLES
+        const filteredVariable = StatementFactory.constant(
+            "filtered",
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("tupleList.filter"),
+                undefined,
+                [
+                    ts.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [IdentifierFactory.parameter("tuple")],
+                        undefined,
+                        undefined,
+                        ts.factory.createStrictEquality(
+                            props.success,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("tuple[0]"),
+                                undefined,
+                                [ts.factory.createIdentifier("front")],
+                            ),
+                        ),
+                    ),
+                ],
+            ),
+        );
+
+        //----
+        // STATEMENTS
+        //----
+        // ONLY ONE TYPE
+        const uniqueStatement = ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+                ts.factory.createNumericLiteral(1),
+                ts.factory.createIdentifier("filtered.length"),
+            ),
+            ts.factory.createReturnStatement(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(`filtered[0][1]`),
+                    undefined,
+                    [accessor.array(input)],
+                ),
+            ),
+        );
+
+        // UNION TYPE
+        const forOfStatement = ts.factory.createForOfStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [ts.factory.createVariableDeclaration("tuple")],
+                ts.NodeFlags.Const,
+            ),
+            // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
+            ts.factory.createIdentifier("filtered"),
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(
+                        ts.factory.createIdentifier("array"),
+                        "every",
+                    ),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [IdentifierFactory.parameter("value")],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                props.success,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("tuple[0]"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("value")],
+                                ),
+                            ),
+                        ),
+                    ],
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(`tuple[1]`),
+                        undefined,
+                        [ts.factory.createIdentifier("array")],
+                    ),
+                ),
+            ),
+        );
+        const unionStatement = ts.factory.createIfStatement(
+            ts.factory.createLessThan(
+                ts.factory.createNumericLiteral(1),
+                ts.factory.createIdentifier("filtered.length"),
+            ),
+            forOfStatement,
+        );
+
+        const block = [
+            // ARRAY.LENGTH := 0
+            ...(accessor.size !== null
+                ? [
+                      ts.factory.createIfStatement(
+                          ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(0),
+                              accessor.size(input),
+                          ),
+                          ts.factory.createReturnStatement(props.empty),
+                      ),
+                  ]
+                : []),
+
+            // UNION PREDICATORS
+            tupleListVariable,
+            StatementFactory.constant("front", accessor.front(input)),
+            filteredVariable,
+            uniqueStatement,
+
+            // CONDITIONAL STATEMENTS
+            StatementFactory.constant("array", accessor.array(input)),
+            unionStatement,
+            props.failure(
+                input,
+                `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
+                explore,
+            ),
+        ];
+
+        return ts.factory.createCallExpression(
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                ts.factory.createBlock(block, true),
+            ),
+            undefined,
+            undefined,
+        );
+    };
+export namespace check_union_array_like {
+    export interface IProps<T> {
+        checker(
+            front: ts.Expression,
+            target: T,
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+            array: ts.Expression,
+        ): ts.Expression;
+        decoder: UnionExplorer.Decoder<T>;
+        empty: ts.Expression;
+        success: ts.Expression;
+        failure(
+            input: ts.Expression,
+            expected: string,
+            explore: CheckerProgrammer.IExplore,
+        ): ts.Statement;
+    }
+
+    export interface IAccessor<T> {
+        name(target: T): string;
+        front(input: ts.Expression): ts.Expression;
+        array(input: ts.Expression): ts.Expression;
+        size: null | ((input: ts.Expression) => ts.Expression);
+    }
+}

package/src/programmers/internal/check_union_tuple.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+
+/**
+ * @internal
+ * @todo Faster union checking logic is required
+ */
+export const check_union_tuple =
+    (
+        project: IProject,
+        config: CheckerProgrammer.IConfig,
+        importer: FunctionImporter,
+    ) =>
+    (
+        _front: ts.Expression,
+        elements: Metadata[],
+        explore: CheckerProgrammer.IExplore,
+        tags: IMetadataTag[],
+        array: ts.Expression,
+    ) =>
+        CheckerProgrammer.decode_tuple(project, config, importer, true)(
+            array,
+            elements,
+            explore,
+            tags,
+        );

package/src/schemas/IJsonSchema.ts

@@ -8,11 +8,9 @@ export namespace IJsonSchema {
     export type NotUnknown =
         | IEnumeration<"boolean">
         | IEnumeration<"number">
-        | IEnumeration<"bigint">
         | IEnumeration<"string">
         | IBoolean
         | INumber
-        | IBigInt
         | IString
         | IArray
         | ITuple
@@ -24,11 +22,12 @@ export namespace IJsonSchema {
     /* -----------------------------------------------------------
         ATOMICS
     ----------------------------------------------------------- */
-    export interface IEnumeration<Literal extends Atomic.Literal>
-        extends IAtomic<Literal> {
+    export interface IEnumeration<
+        Literal extends Exclude<Atomic.Literal, "bigint">,
+    > extends IAtomic<Literal> {
         enum: Array<Atomic.Mapper[Literal]>;
     }
-    export interface IAtomic<Literal extends Atomic.Literal>
+    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
         extends ISignificant<Literal> {
         default?: Atomic.Mapper[Literal];
     }
@@ -46,7 +45,6 @@ export namespace IJsonSchema {
         multipleOf?: number;
     }
     export interface IBoolean extends IAtomic<"boolean"> {}
-    export interface IBigInt extends IAtomic<"bigint"> {}
 
     /* -----------------------------------------------------------
         OBJECTS

package/src/transformers/ITransformOptions.ts

@@ -1,4 +1,47 @@
 export interface ITransformOptions {
-    functional?: boolean | "checker" | "stringify";
-    numeric?: boolean | "checker" | "stringify";
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isNaN().
+     *
+     * However, whatever you configure, it would be ignored when marshaling or parsing.
+     *
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    finite?: boolean;
+
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isFinite().
+     *
+     * However, whatever you configure, it can be ignored in below case.
+     *
+     *   - when `finite` option is true, this option would be ignored
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    numeric?: boolean;
+
+    /**
+     * Whether to validate functional type or not.
+     *
+     * However, whatever you configure, it becomes false when marshaling or parsing.
+     *
+     * @default false
+     */
+    functional?: boolean;
 }

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

@@ -59,13 +59,15 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
+        const collection: MetadataCollection = new MetadataCollection();
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,
                 constant: true,
+                validate: (meta) => {
+                    if (meta.atomics.find((str) => str === "bigint"))
+                        throw new Error(ErrorMessages.NO_BIGIT);
+                },
             }),
         );
 
@@ -111,4 +113,6 @@ export namespace ApplicationTransformer {
 const enum ErrorMessages {
     NO_GENERIC_ARGUMENT = "Error on typia.application(): no generic argument.",
     GENERIC_ARGUMENT = "Error on typia.application(): non-specified generic argument(s).",
+    NO_BIGIT = "Error on typia.application(): does not allow bigint type.",
+    NO_ZERO_LENGTH_TUPLE = "Error on typia.application(): swagger does not support zero length tuple type.",
 }

package/src/transformers/features/stringifiers/StringifyTransformer.ts

@@ -23,7 +23,17 @@ export namespace StringifyTransformer {
             throw new Error(ErrorMessages.GENERIC_ARGUMENT);
 
         return ts.factory.createCallExpression(
-            StringifyProgrammer.generate(project, modulo)(type),
+            StringifyProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: true,
+                    },
+                },
+                modulo,
+            )(type),
             undefined,
             [expression.arguments[0]!],
         );

package/src/utils/NameEncoder.ts

@@ -0,0 +1,32 @@
+export namespace NameEncoder {
+    export function encode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function decode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];