typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/internal/check_number.ts

@@ -1,107 +1,107 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { OptionPredicator } from "../helpers/OptionPredicator";
-
-/**
- * @internal
- */
-export const check_number =
-  (project: IProject, numeric: boolean) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const base = ts.factory.createStrictEquality(
-      ts.factory.createStringLiteral("number"),
-      ts.factory.createTypeOfExpression(input),
-    );
-    const addition: ts.Expression | null =
-      numeric === true
-        ? OptionPredicator.finite(project.options)
-          ? ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Number.isFinite"),
-              undefined,
-              [input],
-            )
-          : OptionPredicator.numeric(project.options)
-            ? ts.factory.createLogicalNot(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Number.isNaN"),
-                  undefined,
-                  [input],
-                ),
-              )
-            : null
-        : null;
-
-    const conditions: ICheckEntry.ICondition[][] =
-      check_numeric_type_tags(project)(atomic)(addition)(input);
-
-    return {
-      expected: atomic.getName(),
-      expression:
-        addition !== null && conditions.length === 0
-          ? ts.factory.createLogicalAnd(base, addition)
-          : base,
-      conditions,
-    };
-  };
-
-/**
- * @internal
- */
-const check_numeric_type_tags =
-  (project: IProject) =>
-  (atomic: MetadataAtomic) =>
-  (addition: ts.Expression | null) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) => [
-        ...(addition === null
-          ? []
-          : row.some(
-                (tag) =>
-                  tag.kind === "type" &&
-                  (tag.value === "int32" ||
-                    tag.value === "uint32" ||
-                    tag.value === "int64" ||
-                    tag.value === "uint64" ||
-                    tag.value === "float"),
-              ) ||
-              row.some(
-                (tag) =>
-                  tag.kind === "multipleOf" && typeof tag.value === "number",
-              ) ||
-              (row.some(
-                (tag) =>
-                  (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
-                  typeof tag.value === "number",
-              ) &&
-                row.some(
-                  (tag) =>
-                    (tag.kind === "maximum" ||
-                      tag.kind === "exclusiveMaximum") &&
-                    typeof tag.value === "number",
-                ))
-            ? []
-            : [
-                {
-                  expected: "number",
-                  expression: addition!,
-                },
-              ]),
-        ...row.map((tag) => ({
-          expected: `number & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.context)(tag.validate!)
-          )(input),
-        })),
-      ]);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { OptionPredicator } from "../helpers/OptionPredicator";
+
+/**
+ * @internal
+ */
+export const check_number =
+  (project: IProject, numeric: boolean) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry => {
+    const base = ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("number"),
+      ts.factory.createTypeOfExpression(input),
+    );
+    const addition: ts.Expression | null =
+      numeric === true
+        ? OptionPredicator.finite(project.options)
+          ? ts.factory.createCallExpression(
+              ts.factory.createIdentifier("Number.isFinite"),
+              undefined,
+              [input],
+            )
+          : OptionPredicator.numeric(project.options)
+            ? ts.factory.createLogicalNot(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("Number.isNaN"),
+                  undefined,
+                  [input],
+                ),
+              )
+            : null
+        : null;
+
+    const conditions: ICheckEntry.ICondition[][] =
+      check_numeric_type_tags(project)(atomic)(addition)(input);
+
+    return {
+      expected: atomic.getName(),
+      expression:
+        addition !== null && conditions.length === 0
+          ? ts.factory.createLogicalAnd(base, addition)
+          : base,
+      conditions,
+    };
+  };
+
+/**
+ * @internal
+ */
+const check_numeric_type_tags =
+  (project: IProject) =>
+  (atomic: MetadataAtomic) =>
+  (addition: ts.Expression | null) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    atomic.tags
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) => [
+        ...(addition === null
+          ? []
+          : row.some(
+                (tag) =>
+                  tag.kind === "type" &&
+                  (tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64" ||
+                    tag.value === "float"),
+              ) ||
+              row.some(
+                (tag) =>
+                  tag.kind === "multipleOf" && typeof tag.value === "number",
+              ) ||
+              (row.some(
+                (tag) =>
+                  (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
+                  typeof tag.value === "number",
+              ) &&
+                row.some(
+                  (tag) =>
+                    (tag.kind === "maximum" ||
+                      tag.kind === "exclusiveMaximum") &&
+                    typeof tag.value === "number",
+                ))
+            ? []
+            : [
+                {
+                  expected: "number",
+                  expression: addition!,
+                },
+              ]),
+        ...row.map((tag) => ({
+          expected: `number & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.context)(tag.validate!)
+          )(input),
+        })),
+      ]);

package/src/programmers/internal/check_object.ts

@@ -1,61 +1,61 @@
-import ts from "typescript";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_dynamic_properties } from "./check_dynamic_properties";
-import { check_everything } from "./check_everything";
-
-/**
- * @internal
- */
-export const check_object =
-  (props: check_object.IProps) =>
-  (project: IProject) =>
-  (importer: FunctionImporter) =>
-  (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
-    // PREPARE ASSETS
-    const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-    const flags: ts.Expression[] = regular.map((entry) => entry.expression);
-
-    // REGULAR WITHOUT DYNAMIC PROPERTIES
-    if (props.equals === false && dynamic.length === 0)
-      return regular.length === 0 ? props.positive : reduce(props)(flags);
-
-    // CHECK DYNAMIC PROPERTIES
-    flags.push(
-      check_dynamic_properties(props)(project)(importer)(
-        input,
-        regular,
-        dynamic,
-      ),
-    );
-    return reduce(props)(flags);
-  };
-
-/**
- * @internal
- */
-export namespace check_object {
-  export interface IProps {
-    equals: boolean;
-    assert: boolean;
-    undefined: boolean;
-    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
-    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
-    positive: ts.Expression;
-    superfluous: (value: ts.Expression) => ts.Expression;
-    entries?: undefined | ts.Identifier;
-  }
-}
-
-/**
- * @internal
- */
-const reduce =
-  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-    props.assert
-      ? expressions.reduce(props.reduce)
-      : check_everything(ts.factory.createArrayLiteralExpression(expressions));
+import ts from "typescript";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_properties } from "./check_dynamic_properties";
+import { check_everything } from "./check_everything";
+
+/**
+ * @internal
+ */
+export const check_object =
+  (props: check_object.IProps) =>
+  (project: IProject) =>
+  (importer: FunctionImporter) =>
+  (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
+    // PREPARE ASSETS
+    const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+    const flags: ts.Expression[] = regular.map((entry) => entry.expression);
+
+    // REGULAR WITHOUT DYNAMIC PROPERTIES
+    if (props.equals === false && dynamic.length === 0)
+      return regular.length === 0 ? props.positive : reduce(props)(flags);
+
+    // CHECK DYNAMIC PROPERTIES
+    flags.push(
+      check_dynamic_properties(props)(project)(importer)(
+        input,
+        regular,
+        dynamic,
+      ),
+    );
+    return reduce(props)(flags);
+  };
+
+/**
+ * @internal
+ */
+export namespace check_object {
+  export interface IProps {
+    equals: boolean;
+    assert: boolean;
+    undefined: boolean;
+    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
+    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
+    positive: ts.Expression;
+    superfluous: (value: ts.Expression) => ts.Expression;
+    entries?: undefined | ts.Identifier;
+  }
+}
+
+/**
+ * @internal
+ */
+const reduce =
+  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
+    props.assert
+      ? expressions.reduce(props.reduce)
+      : check_everything(ts.factory.createArrayLiteralExpression(expressions));

package/src/programmers/internal/check_string.ts

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_string =
-  (project: IProject) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] =
-      check_string_type_tags(project)(atomic)(input);
-    return {
-      expected: atomic.getName(),
-      expression: ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("string"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-      conditions,
-    };
-  };
-
-/**
- * @internal
- */
-const check_string_type_tags =
-  (project: IProject) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `string & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.context)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_string =
+  (project: IProject) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry => {
+    const conditions: ICheckEntry.ICondition[][] =
+      check_string_type_tags(project)(atomic)(input);
+    return {
+      expected: atomic.getName(),
+      expression: ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("string"),
+        ts.factory.createTypeOfExpression(input),
+      ),
+      conditions,
+    };
+  };
+
+/**
+ * @internal
+ */
+const check_string_type_tags =
+  (project: IProject) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    atomic.tags
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) =>
+        row.map((tag) => ({
+          expected: `string & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.context)(tag.validate!)
+          )(input),
+        })),
+      );

package/src/programmers/internal/check_template.ts

@@ -1,46 +1,46 @@
-import ts from "typescript";
-
-import { MetadataTemplate } from "../../schemas/metadata/MetadataTemplate";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const check_template =
-  (templates: MetadataTemplate[]) =>
-  (input: ts.Expression): ICheckEntry => {
-    // TYPEOF STRING & TAGS
-    const conditions: ts.Expression[] = [
-      ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("string"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-    ];
-
-    // TEMPLATES
-    const internal: ts.Expression[] = templates.map((tpl) =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          `RegExp(/${template_to_pattern(true)(tpl.row)}/).test`,
-        ),
-        undefined,
-        [input],
-      ),
-    );
-    conditions.push(
-      internal.length === 1
-        ? internal[0]!
-        : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
-    );
-
-    // COMBINATION
-    return {
-      expression: conditions.reduce((x, y) =>
-        ts.factory.createLogicalAnd(x, y),
-      ),
-      conditions: [],
-      expected: templates.map((tpl) => tpl.getName()).join(" | "),
-    };
-  };
+import ts from "typescript";
+
+import { MetadataTemplate } from "../../schemas/metadata/MetadataTemplate";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+  (templates: MetadataTemplate[]) =>
+  (input: ts.Expression): ICheckEntry => {
+    // TYPEOF STRING & TAGS
+    const conditions: ts.Expression[] = [
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("string"),
+        ts.factory.createTypeOfExpression(input),
+      ),
+    ];
+
+    // TEMPLATES
+    const internal: ts.Expression[] = templates.map((tpl) =>
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          `RegExp(/${template_to_pattern(true)(tpl.row)}/).test`,
+        ),
+        undefined,
+        [input],
+      ),
+    );
+    conditions.push(
+      internal.length === 1
+        ? internal[0]!
+        : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+    );
+
+    // COMBINATION
+    return {
+      expression: conditions.reduce((x, y) =>
+        ts.factory.createLogicalAnd(x, y),
+      ),
+      conditions: [],
+      expected: templates.map((tpl) => tpl.getName()).join(" | "),
+    };
+  };