typia 3.4.13 → 3.4.15

package/src/programmers/internal/application_string.ts

@@ -1,49 +1,49 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { application_default_string } from "./application_default_string";
-
-/**
- * @internal
- */
-export const application_string = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
-
-    // FORMAT TAG OF METADATA
-    const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
-        (tag) => tag.name === "format",
-    );
-    if (formatJsdocTag?.text?.length)
-        output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
-
-    // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
-    for (const tag of attribute["x-typia-metaTags"] || []) {
-        // RANGE
-        if (tag.kind === "minLength") output.minLength = tag.value;
-        else if (tag.kind === "maxLength") output.maxLength = tag.value;
-        else if (tag.kind === "length") {
-            if (tag.minimum !== undefined)
-                output.minLength =
-                    tag.minimum.value + (tag.minimum.include ? 0 : 1);
-            if (tag.maximum !== undefined)
-                output.maxLength =
-                    tag.maximum.value - (tag.maximum.include ? 0 : 1);
-        }
-        // FORMAT AND PATTERN
-        else if (tag.kind === "format") output.format = tag.value;
-        else if (tag.kind === "pattern") output.pattern = tag.value;
-    }
-
-    // DEFAULT CONFIGURATION
-    output.default = application_default_string(meta, attribute)(output);
-
-    // RETURNS
-    return output;
-};
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { application_default_string } from "./application_default_string";
+
+/**
+ * @internal
+ */
+export const application_string = (
+    meta: Metadata,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IString => {
+    const output: IJsonSchema.IString = {
+        type: "string",
+        nullable: meta.nullable,
+        ...attribute,
+    };
+
+    // FORMAT TAG OF METADATA
+    const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
+        (tag) => tag.name === "format",
+    );
+    if (formatJsdocTag?.text?.length)
+        output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
+
+    // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
+    for (const tag of attribute["x-typia-metaTags"] || []) {
+        // RANGE
+        if (tag.kind === "minLength") output.minLength = tag.value;
+        else if (tag.kind === "maxLength") output.maxLength = tag.value;
+        else if (tag.kind === "length") {
+            if (tag.minimum !== undefined)
+                output.minLength =
+                    tag.minimum.value + (tag.minimum.include ? 0 : 1);
+            if (tag.maximum !== undefined)
+                output.maxLength =
+                    tag.maximum.value - (tag.maximum.include ? 0 : 1);
+        }
+        // FORMAT AND PATTERN
+        else if (tag.kind === "format") output.format = tag.value;
+        else if (tag.kind === "pattern") output.pattern = tag.value;
+    }
+
+    // DEFAULT CONFIGURATION
+    output.default = application_default_string(meta, attribute)(output);
+
+    // RETURNS
+    return output;
+};

package/src/programmers/internal/application_templates.ts

@@ -1,27 +1,27 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { application_default_string } from "./application_default_string";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const application_templates = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    // CONSTRUCT PATTERN
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
-    output.pattern = metadata_to_pattern(true)(meta);
-
-    // DEFAULT VALUE
-    output.default = application_default_string(meta, attribute)(output);
-
-    // RETURNS
-    return output;
-};
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { application_default_string } from "./application_default_string";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const application_templates = (
+    meta: Metadata,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IString => {
+    // CONSTRUCT PATTERN
+    const output: IJsonSchema.IString = {
+        type: "string",
+        nullable: meta.nullable,
+        ...attribute,
+    };
+    output.pattern = metadata_to_pattern(true)(meta);
+
+    // DEFAULT VALUE
+    output.default = application_default_string(meta, attribute)(output);
+
+    // RETURNS
+    return output;
+};

package/src/programmers/internal/application_tuple.ts

@@ -1,25 +1,25 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonComponents } from "../../schemas/IJsonComponents";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_tuple =
-    (options: ApplicationProgrammer.IOptions) =>
-    (components: IJsonComponents) =>
-    (
-        items: Array<Metadata>,
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.ITuple => ({
-        type: "array",
-        items: items.map((meta) =>
-            application_schema(options)(components)(false)(meta, attribute),
-        ),
-        nullable,
-        ...attribute,
-    });
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_tuple =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (
+        items: Array<Metadata>,
+        nullable: boolean,
+        attribute: IJsonSchema.IAttribute,
+    ): IJsonSchema.ITuple => ({
+        type: "array",
+        items: items.map((meta) =>
+            application_schema(options)(components)(false)(meta, attribute),
+        ),
+        nullable,
+        ...attribute,
+    });

package/src/programmers/internal/check_array.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { check_length } from "./check_length";
-
-/**
- * @internal
- */
-export function check_array(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression {
-    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
-
-    // 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.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { check_length } from "./check_length";
+
+/**
+ * @internal
+ */
+export function check_array(
+    input: ts.Expression,
+    tagList: IMetadataTag[],
+): ts.Expression {
+    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
+
+    // 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.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+}

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_dynamic_properties.ts

@@ -1,146 +1,146 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_everything } from "./check_everything";
-import { check_object } from "./check_object";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const check_dynamic_properties =
-    (props: check_object.IProps) =>
-    (
-        regular: IExpressionEntry[],
-        dynamic: IExpressionEntry[],
-    ): ts.Expression => {
-        const criteria = props.entries
-            ? ts.factory.createCallExpression(props.entries, undefined, [
-                  ts.factory.createCallExpression(
-                      ts.factory.createIdentifier("Object.keys"),
-                      undefined,
-                      [ts.factory.createIdentifier("input")],
-                  ),
-                  check_dynamic_property(props)(regular, dynamic),
-              ])
-            : ts.factory.createCallExpression(
-                  IdentifierFactory.join(
-                      ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("Object.keys"),
-                          undefined,
-                          [ts.factory.createIdentifier("input")],
-                      ),
-                      props.assert ? "every" : "map",
-                  ),
-                  undefined,
-                  [check_dynamic_property(props)(regular, dynamic)],
-              );
-        return (props.halt || ((elem) => elem))(
-            props.assert ? criteria : check_everything(criteria),
-        );
-    };
-
-const check_dynamic_property =
-    (props: check_object.IProps) =>
-    (regular: IExpressionEntry[], dynamic: IExpressionEntry[]) => {
-        //----
-        // IF CONDITIONS
-        //----
-        // PREPARE ASSETS
-        const key = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
-
-        const statements: ts.Statement[] = [];
-        const add = (exp: ts.Expression, output: ts.Expression) =>
-            statements.push(
-                ts.factory.createIfStatement(
-                    exp,
-                    ts.factory.createReturnStatement(output),
-                ),
-            );
-
-        // GATHER CONDITIONS
-        if (props.equals === true && regular.length)
-            add(is_regular_property(regular), props.positive);
-        statements.push(
-            StatementFactory.constant(
-                "value",
-                ts.factory.createIdentifier("input[key]"),
-            ),
-        );
-        add(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                value,
-            ),
-            props.positive,
-        );
-        for (const entry of dynamic)
-            add(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
-                    ),
-                    undefined,
-                    [key],
-                ),
-                entry.expression,
-            );
-
-        //----
-        // FUNCTION BODY
-        //----
-        // CLOSURE BLOCK
-        const block: ts.Block = ts.factory.createBlock(
-            [
-                ...statements,
-                ts.factory.createReturnStatement(
-                    props.equals === true
-                        ? props.superfluous(value)
-                        : props.positive,
-                ),
-            ],
-            true,
-        );
-
-        // RETURNS
-        return ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [IdentifierFactory.parameter("key")],
-            undefined,
-            undefined,
-            block,
-        );
-    };
-
-const is_regular_property = (regular: IExpressionEntry[]) =>
-    ts.factory.createCallExpression(
-        IdentifierFactory.join(
-            ts.factory.createArrayLiteralExpression(
-                regular.map((entry) =>
-                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
-                ),
-            ),
-            "some",
-        ),
-        undefined,
-        [
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("prop")],
-                undefined,
-                undefined,
-                ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("key"),
-                    ts.factory.createIdentifier("prop"),
-                ),
-            ),
-        ],
-    );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_everything } from "./check_everything";
+import { check_object } from "./check_object";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_dynamic_properties =
+    (props: check_object.IProps) =>
+    (
+        regular: IExpressionEntry[],
+        dynamic: IExpressionEntry[],
+    ): ts.Expression => {
+        const criteria = props.entries
+            ? ts.factory.createCallExpression(props.entries, undefined, [
+                  ts.factory.createCallExpression(
+                      ts.factory.createIdentifier("Object.keys"),
+                      undefined,
+                      [ts.factory.createIdentifier("input")],
+                  ),
+                  check_dynamic_property(props)(regular, dynamic),
+              ])
+            : ts.factory.createCallExpression(
+                  IdentifierFactory.join(
+                      ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("Object.keys"),
+                          undefined,
+                          [ts.factory.createIdentifier("input")],
+                      ),
+                      props.assert ? "every" : "map",
+                  ),
+                  undefined,
+                  [check_dynamic_property(props)(regular, dynamic)],
+              );
+        return (props.halt || ((elem) => elem))(
+            props.assert ? criteria : check_everything(criteria),
+        );
+    };
+
+const check_dynamic_property =
+    (props: check_object.IProps) =>
+    (regular: IExpressionEntry[], dynamic: IExpressionEntry[]) => {
+        //----
+        // IF CONDITIONS
+        //----
+        // PREPARE ASSETS
+        const key = ts.factory.createIdentifier("key");
+        const value = ts.factory.createIdentifier("value");
+
+        const statements: ts.Statement[] = [];
+        const add = (exp: ts.Expression, output: ts.Expression) =>
+            statements.push(
+                ts.factory.createIfStatement(
+                    exp,
+                    ts.factory.createReturnStatement(output),
+                ),
+            );
+
+        // GATHER CONDITIONS
+        if (props.equals === true && regular.length)
+            add(is_regular_property(regular), props.positive);
+        statements.push(
+            StatementFactory.constant(
+                "value",
+                ts.factory.createIdentifier("input[key]"),
+            ),
+        );
+        add(
+            ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                value,
+            ),
+            props.positive,
+        );
+        for (const entry of dynamic)
+            add(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [key],
+                ),
+                entry.expression,
+            );
+
+        //----
+        // FUNCTION BODY
+        //----
+        // CLOSURE BLOCK
+        const block: ts.Block = ts.factory.createBlock(
+            [
+                ...statements,
+                ts.factory.createReturnStatement(
+                    props.equals === true
+                        ? props.superfluous(value)
+                        : props.positive,
+                ),
+            ],
+            true,
+        );
+
+        // RETURNS
+        return ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("key")],
+            undefined,
+            undefined,
+            block,
+        );
+    };
+
+const is_regular_property = (regular: IExpressionEntry[]) =>
+    ts.factory.createCallExpression(
+        IdentifierFactory.join(
+            ts.factory.createArrayLiteralExpression(
+                regular.map((entry) =>
+                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
+                ),
+            ),
+            "some",
+        ),
+        undefined,
+        [
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("prop")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("key"),
+                    ts.factory.createIdentifier("prop"),
+                ),
+            ),
+        ],
+    );