typia 4.0.0-dev.20230527 → 4.0.0-dev.20230604

package/src/programmers/internal/check_array.ts

@@ -1,31 +1,30 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_array_length } from "./check_array_length";
-import { check_custom } from "./check_custom";
-
-/**
- * @internal
- */
-export const check_array =
-    (tsc: typeof ts) =>
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry => ({
-        expression: ExpressionFactory.isArray(tsc)(input),
-        tags: [
-            ...check_array_length(tsc)(metaTags)(
-                IdentifierFactory.access(tsc)(input)("length"),
-            ),
-            ...check_custom(tsc)("array", "Array")(importer)(jsDocTags)(input),
-            // check custom array for legacy (3.7.0)
-        ],
-    });
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_array_length } from "./check_array_length";
+import { check_custom } from "./check_custom";
+
+/**
+ * @internal
+ */
+export const check_array =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => ({
+        expression: ExpressionFactory.isArray(input),
+        tags: [
+            ...check_array_length(metaTags)(
+                IdentifierFactory.access(input)("length"),
+            ),
+            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+            // check custom array for legacy (3.7.0)
+        ],
+    });

package/src/programmers/internal/check_array_length.ts

@@ -1,35 +1,35 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-/**
- * @internal
- */
-export const check_array_length =
-    (tsc: typeof ts) => (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
-        metaTags
-            .map((tag) => ({
-                tag,
-                expression:
-                    tag.kind === "items"
-                        ? tsc.factory.createStrictEquality(
-                              tsc.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "minItems"
-                        ? tsc.factory.createLessThanEquals(
-                              tsc.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "maxItems"
-                        ? tsc.factory.createGreaterThanEquals(
-                              tsc.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : null!,
-            }))
-            .filter((tuple) => tuple.expression !== null)
-            .map(({ tag, expression }) => ({
-                expected: `Array.length (@${tag.kind} ${tag.value})`,
-                expression,
-            }));
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+/**
+ * @internal
+ */
+export const check_array_length =
+    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+        metaTags
+            .map((tag) => ({
+                tag,
+                expression:
+                    tag.kind === "items"
+                        ? ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : tag.kind === "minItems"
+                        ? ts.factory.createLessThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : tag.kind === "maxItems"
+                        ? ts.factory.createGreaterThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : null!,
+            }))
+            .filter((tuple) => tuple.expression !== null)
+            .map(({ tag, expression }) => ({
+                expected: `Array.length (@${tag.kind} ${tag.value})`,
+                expression,
+            }));

package/src/programmers/internal/check_bigint.ts

@@ -1,95 +1,82 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-
-/**
- * @internal
- */
-export const check_bigint =
-    (tsc: typeof ts) =>
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTag: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, ts.Expression][] = [];
-        for (const tag of metaTags) {
-            if (tag.kind === "multipleOf")
-                entries.push([
-                    tag,
-                    tsc.factory.createStrictEquality(
-                        cast(tsc)(0),
-                        tsc.factory.createModulo(input, cast(tsc)(tag.value)),
-                    ),
-                ]);
-            else if (tag.kind === "step") {
-                const modulo = tsc.factory.createModulo(
-                    input,
-                    cast(tsc)(tag.value),
-                );
-                const minimum =
-                    (metaTags.find(
-                        (tag) =>
-                            tag.kind === "minimum" ||
-                            tag.kind === "exclusiveMinimum",
-                    )?.value as number | undefined) ?? undefined;
-                entries.push([
-                    tag,
-                    tsc.factory.createStrictEquality(
-                        cast(tsc)(0),
-                        minimum !== undefined
-                            ? tsc.factory.createSubtract(
-                                  modulo,
-                                  cast(tsc)(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (tag.kind === "minimum")
-                entries.push([
-                    tag,
-                    tsc.factory.createLessThanEquals(
-                        cast(tsc)(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "maximum")
-                entries.push([
-                    tag,
-                    tsc.factory.createGreaterThanEquals(
-                        cast(tsc)(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMinimum")
-                entries.push([
-                    tag,
-                    tsc.factory.createLessThan(cast(tsc)(tag.value), input),
-                ]);
-            else if (tag.kind === "exclusiveMaximum")
-                entries.push([
-                    tag,
-                    tsc.factory.createGreaterThan(cast(tsc)(tag.value), input),
-                ]);
-        }
-        return {
-            expression: tsc.factory.createStrictEquality(
-                tsc.factory.createStringLiteral("bigint"),
-                tsc.factory.createTypeOfExpression(input),
-            ),
-            tags: [
-                ...entries.map(([tag, expression]) => ({
-                    expected: `bigint (@${tag.kind} ${tag.value})`,
-                    expression,
-                })),
-                ...check_custom(tsc)("bigint")(importer)(jsDocTag)(input),
-            ],
-        };
-    };
-
-const cast = (tsc: typeof ts) => (value: number) =>
-    tsc.factory.createIdentifier(`${Math.floor(value)}n`);
+import ts from "typescript";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
+
+/**
+ * @internal
+ */
+export const check_bigint =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of metaTags) {
+            if (tag.kind === "multipleOf")
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        cast(0),
+                        ts.factory.createModulo(input, cast(tag.value)),
+                    ),
+                ]);
+            else if (tag.kind === "step") {
+                const modulo = ts.factory.createModulo(input, cast(tag.value));
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        cast(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(modulo, cast(minimum))
+                            : modulo,
+                    ),
+                ]);
+            } else if (tag.kind === "minimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThanEquals(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "maximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThanEquals(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "exclusiveMinimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThan(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "exclusiveMaximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThan(cast(tag.value), input),
+                ]);
+        }
+        return {
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `bigint (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("bigint")(importer)(jsDocTag)(input),
+            ],
+        };
+    };
+
+const cast = (value: number) =>
+    ts.factory.createIdentifier(`${Math.floor(value)}n`);

package/src/programmers/internal/check_custom.ts

@@ -1,32 +1,31 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { get_comment_tags } from "./get_comment_tags";
-
-/**
- * @internal
- */
-export const check_custom =
-    (tsc: typeof ts) =>
-    (type: string, alias?: string) =>
-    (importer: FunctionImporter) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry.ITag[] =>
-        get_comment_tags(true)(jsDocTags).map((tag) => ({
-            expected: `${alias ?? type} (@${tag.name}${
-                tag.value?.length ? ` ${tag.value}` : ""
-            })`,
-            expression: tsc.factory.createCallExpression(
-                importer.use("is_custom"),
-                undefined,
-                [
-                    tsc.factory.createStringLiteral(tag.name),
-                    tsc.factory.createStringLiteral(type),
-                    tsc.factory.createStringLiteral(tag.value ?? ""),
-                    input,
-                ],
-            ),
-        }));
+import ts from "typescript";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { get_comment_tags } from "./get_comment_tags";
+
+/**
+ * @internal
+ */
+export const check_custom =
+    (type: string, alias?: string) =>
+    (importer: FunctionImporter) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] =>
+        get_comment_tags(true)(jsDocTags).map((tag) => ({
+            expected: `${alias ?? type} (@${tag.name}${
+                tag.value?.length ? ` ${tag.value}` : ""
+            })`,
+            expression: ts.factory.createCallExpression(
+                importer.use("is_custom"),
+                undefined,
+                [
+                    ts.factory.createStringLiteral(tag.name),
+                    ts.factory.createStringLiteral(type),
+                    ts.factory.createStringLiteral(tag.value ?? ""),
+                    input,
+                ],
+            ),
+        }));