typia 7.0.0-dev.20241007 → 7.0.0-dev.20241008

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -1,115 +1,115 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-
-export namespace HttpParameterProgrammer {
-  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
-    const result = MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      },
-      collection: new MetadataCollection(),
-      type: props.type,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: props.modulo.getText(),
-        errors: result.errors,
-      });
-
-    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-    const block: ts.Statement[] = [
-      StatementFactory.constant({
-        name: "assert",
-        value: AssertProgrammer.write({
-          ...props,
-          context: {
-            ...props.context,
-            options: {
-              numeric: true,
-            },
-          },
-          config: {
-            equals: false,
-            guard: false,
-          },
-        }),
-      }),
-      StatementFactory.constant({
-        name: "value",
-        value: ts.factory.createCallExpression(
-          props.context.importer.internal(
-            `httpParameterRead${StringUtil.capitalize(atomic)}`,
-          ),
-          undefined,
-          [ts.factory.createIdentifier("input")],
-        ),
-      }),
-      ts.factory.createReturnStatement(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("assert"),
-          undefined,
-          [ts.factory.createIdentifier("value")],
-        ),
-      ),
-    ];
-
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [
-        IdentifierFactory.parameter(
-          "input",
-          ts.factory.createTypeReferenceNode("string"),
-        ),
-      ],
-      ts.factory.createTypeReferenceNode(
-        props.name ??
-          TypeFactory.getFullName({
-            checker: props.context.checker,
-            type: props.type,
-          }),
-      ),
-      undefined,
-      ts.factory.createBlock(block, true),
-    );
-  };
-
-  export const validate = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = HttpMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpParameterProgrammer {
+  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: props.modulo.getText(),
+        errors: result.errors,
+      });
+
+    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
+    const block: ts.Statement[] = [
+      StatementFactory.constant({
+        name: "assert",
+        value: AssertProgrammer.write({
+          ...props,
+          context: {
+            ...props.context,
+            options: {
+              numeric: true,
+            },
+          },
+          config: {
+            equals: false,
+            guard: false,
+          },
+        }),
+      }),
+      StatementFactory.constant({
+        name: "value",
+        value: ts.factory.createCallExpression(
+          props.context.importer.internal(
+            `httpParameterRead${StringUtil.capitalize(atomic)}`,
+          ),
+          undefined,
+          [ts.factory.createIdentifier("input")],
+        ),
+      }),
+      ts.factory.createReturnStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [ts.factory.createIdentifier("value")],
+        ),
+      ),
+    ];
+
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [
+        IdentifierFactory.parameter(
+          "input",
+          ts.factory.createTypeReferenceNode("string"),
+        ),
+      ],
+      ts.factory.createTypeReferenceNode(
+        props.name ??
+          TypeFactory.getFullName({
+            checker: props.context.checker,
+            type: props.type,
+          }),
+      ),
+      undefined,
+      ts.factory.createBlock(block, true),
+    );
+  };
+
+  export const validate = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = HttpMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+}