typia 5.4.2 → 5.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.4.2",
+  "version": "5.4.3",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/CamelCase.ts

@@ -53,6 +53,8 @@ type CamelizeObject<T extends object> = T extends Array<infer U>
       | ArrayBuffer
       | SharedArrayBuffer
       | DataView
+      | Blob
+      | File
   ? T
   : {
       [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<T[Key]>;

package/src/PascalCase.ts

@@ -53,6 +53,8 @@ type PascalizeObject<T extends object> = T extends Array<infer U>
       | ArrayBuffer
       | SharedArrayBuffer
       | DataView
+      | Blob
+      | File
   ? T
   : {
       [Key in keyof T as PascalizeString<Key & string>]: PascalizeMain<T[Key]>;

package/src/Resolved.ts

@@ -68,6 +68,8 @@ type ResolvedObject<T extends object> = T extends Array<infer U>
       | ArrayBuffer
       | SharedArrayBuffer
       | DataView
+      | Blob
+      | File
   ? T
   : {
       [P in keyof T]: ResolvedMain<T[P]>;

package/src/SnakeCase.ts

@@ -53,6 +53,8 @@ type SnakageObject<T extends object> = T extends Array<infer U>
       | ArrayBuffer
       | SharedArrayBuffer
       | DataView
+      | Blob
+      | File
   ? T
   : {
       [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -110,10 +110,7 @@ const SIMPLES: Map<string, IClassInfo> = new Map([
           name,
           return: "string",
         })),
-        {
-          name: "valueOf",
-          return: "number",
-        },
+        { name: "valueOf", return: "number" },
       ],
     },
   ],
@@ -127,10 +124,7 @@ const SIMPLES: Map<string, IClassInfo> = new Map([
         "trim",
         "replace",
         "substring",
-      ].map((name) => ({
-        name,
-        return: "string",
-      })),
+      ].map((name) => ({ name, return: "string" })),
     },
   ],
   ...[
@@ -148,21 +142,28 @@ const SIMPLES: Map<string, IClassInfo> = new Map([
   ].map((name) => [name, getBinaryProps(name)] as const),
   ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
     const info: IClassInfo = {
-      methods: [
-        {
-          name: "slice",
-          return: className,
-        },
-      ],
-      properties: [
-        {
-          name: "byteLength",
-          type: "number",
-        },
-      ],
+      methods: [{ name: "slice", return: className }],
+      properties: [{ name: "byteLength", type: "number" }],
     };
     return [className, info] as const;
   }),
+  ...["Blob", "File"].map(
+    (className) =>
+      [
+        className,
+        {
+          methods: [
+            { name: "arrayBuffer", return: "Promise<ArrayBuffer>" },
+            { name: "slice", return: "Blob" },
+            { name: "text", return: "Promise<string>" },
+          ],
+          properties: [
+            { name: "size", type: "number" },
+            { name: "type", type: "string" },
+          ],
+        },
+      ] satisfies [string, IClassInfo],
+  ),
   [
     "DataView",
     {

package/src/functional/$FormDataReader/$FormDataReader.ts

@@ -0,0 +1,77 @@
+export const boolean = (
+  input: string | File | null,
+): boolean | null | undefined =>
+  input instanceof File
+    ? (input as any)
+    : input === null
+    ? undefined
+    : input === "null"
+    ? null
+    : input.length === 0
+    ? true
+    : input === "true" || input === "1"
+    ? true
+    : input === "false" || input === "0"
+    ? false
+    : (input as any); // wrong type
+
+export const number = (
+  input: string | File | null,
+): number | null | undefined =>
+  input instanceof File
+    ? (input as any)
+    : !!input?.length
+    ? input === "null"
+      ? null
+      : (toNumber(input) as any)
+    : undefined;
+
+export const bigint = (
+  input: string | File | null,
+): bigint | null | undefined =>
+  input instanceof File
+    ? (input as any)
+    : !!input?.length
+    ? input === "null"
+      ? null
+      : (toBigint(input) as any)
+    : undefined;
+
+export const string = (
+  input: string | File | null,
+): string | null | undefined =>
+  input instanceof File
+    ? (input as any)
+    : input === null
+    ? undefined
+    : input === "null"
+    ? null
+    : input;
+
+export const array = (input: any[], alternative: null | undefined) =>
+  input.length ? input : alternative;
+
+export const blob = (input: string | File | null): Blob | null | undefined =>
+  file(input);
+
+export const file = (input: string | File | null): File | null | undefined =>
+  input instanceof File
+    ? input
+    : input === null
+    ? undefined
+    : input === "null"
+    ? null
+    : (input as any);
+
+const toNumber = (str: string): number | string => {
+  const value: number = Number(str);
+  return isNaN(value) ? str : value;
+};
+
+const toBigint = (str: string): bigint | string => {
+  try {
+    return BigInt(str);
+  } catch {
+    return str;
+  }
+};

package/src/functional/$FormDataReader/index.ts

@@ -0,0 +1 @@
+export * as $FormDataReader from "./$FormDataReader";

package/src/functional/Namespace/http.ts

@@ -1,7 +1,9 @@
+import { $FormDataReader } from "../$FormDataReader";
 import { $HeadersReader } from "../$HeadersReader";
 import { $ParameterReader } from "../$ParameterReader";
 import { $QueryReader } from "../$QueryReader";
 
-export const query = () => $QueryReader;
+export const formData = () => $FormDataReader;
 export const headers = () => $HeadersReader;
 export const parameter = () => $ParameterReader;
+export const query = () => $QueryReader;

package/src/http.ts

@@ -7,11 +7,330 @@ import { Resolved } from "./Resolved";
 
 /* ===========================================================
     HTTP
+      - FORM-DATA
       - QUERY
       - HEADERS
       - PARAMETER
       - FACTORY FUNCTIONS
 ==============================================================
+    FORM-DATA
+----------------------------------------------------------- */
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Form data decoder.
+ *
+ * `typia.http.formData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.formData()` will cast the value to
+ * the expected type when decoding.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.formData()` function has some limitations. If target type `T` is
+ * not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * Also, `typia.http.formData()` function does not perform validation about the
+ * decoded value. Therefore, if you can't sure that input data is following the
+ * `T` type, it would better to call one of below functions intead.
+ *
+ * - {@link assertFormData}
+ * - {@link isFormData}
+ * - {@link validateFormData}
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function formData(): never;
+
+/**
+ * Form data decoder.
+ *
+ * `typia.http.formData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.formData()` will cast the value to
+ * the expected type when decoding.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.formData()` function has some limitations. If target type `T` is
+ * not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * Also, `typia.http.formData()` function does not perform validation about the
+ * decoded value. Therefore, if you can't sure that input data is following the
+ * `T` type, it would better to call one of below functions intead.
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function formData<T extends object>(input: FormData): Resolved<T>;
+
+/**
+ * @internal
+ */
+function formData(): never {
+  halt("formData");
+}
+const formDataPure = /** @__PURE__ */ Object.assign<typeof formData, {}>(
+  formData,
+  /** @__PURE__ */ Namespace.http.formData(),
+);
+export { formDataPure as formData };
+
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Form data decoder with type assertion.
+ *
+ * `typia.http.assertFormData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.assertFormData()` will cast the value
+ * to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.assertFormData()` performs type assertion to
+ * the decoded value by combining with {@link assert} function. Therefore, when
+ * the decoded value is not following the `T` type, {@link TypeGuardError} would
+ * be thrown.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.assertFormData()` function has some limitations. If target type `T`
+ * is not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function assertFormData(): never;
+
+/**
+ * Form data decoder with type assertion.
+ *
+ * `typia.http.assertFormData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.assertFormData()` will cast the value
+ * to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.assertFormData()` performs type assertion to
+ * the decoded value by combining with {@link assert} function. Therefore, when
+ * the decoded value is not following the `T` type, {@link TypeGuardError} would
+ * be thrown.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.assertFormData()` function has some limitations. If target type `T`
+ * is not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function assertFormData<T extends object>(input: FormData): Resolved<T>;
+
+/**
+ * @internal
+ */
+function assertFormData(): never {
+  halt("assertFormData");
+}
+const assertFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof assertFormData,
+  {},
+  {}
+>(
+  assertFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.assert("http.assertFormData"),
+);
+export { assertFormDataPure as assertFormData };
+
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Form data decoder with type checking.
+ *
+ * `typia.http.isFormData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.isFormData()` will cast the value
+ * to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.isFormData()` performs type checking to the
+ * decoded value by combining with {@link is} function. Therefore, when the
+ * decoded value is not following the `T` type, `null` value would be returned.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.isFormData()` function has some limitations. If target type `T` is
+ * not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData or `null` value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function isFormData(): never;
+
+/**
+ * Form data decoder with type checking.
+ *
+ * `typia.http.isFormData()` is a function decoding `FormData` instance, with
+ * automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.isFormData()` will cast the value
+ * to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.isFormData()` performs type checking to the
+ * decoded value by combining with {@link is} function. Therefore, when the
+ * decoded value is not following the `T` type, `null` value would be returned.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.isFormData()` function has some limitations. If target type `T` is
+ * not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Decoded form FormData or `null` value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function isFormData<T extends object>(input: FormData): Resolved<T> | null;
+
+/**
+ * @internal
+ */
+function isFormData(): never {
+  halt("isFormData");
+}
+const isFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof isFormData,
+  {},
+  {}
+>(
+  isFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { isFormDataPure as isFormData };
+
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Form data decoder with type validation.
+ *
+ * `typia.http.validateFormData()` is a function decoding `FormData` instance,
+ * with automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.validateFormData()` will cast the
+ * value to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.validateFormData()` performs type validation
+ * to the decoded value by combining with {@link validate} function. Therefore,
+ * when the decoded value is not following the `T` type,
+ * {@link IValidation.IFailure} would be returned. Otherwise,
+ * x@xxxx IValidation.ISuccess} would be returned.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.validateFormData()` function has some limitations. If target type
+ * `T` is not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Validation result with decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function validateFormData(): never;
+
+/**
+ * Form data decoder with type validation.
+ *
+ * `typia.http.validateFormData()` is a function decoding `FormData` instance,
+ * with automatic type casting to the expected type. When roperty type be defined
+ * as `boolean` or `Blob` type, `typia.http.validateFormData()` will cast the
+ * value to the expected type when decoding.
+ *
+ * Also, after decoding, `typia.http.validateFormData()` performs type validation
+ * to the decoded value by combining with {@link validate} function. Therefore,
+ * when the decoded value is not following the `T` type,
+ * {@link IValidation.IFailure} would be returned. Otherwise,
+ * x@xxxx IValidation.ISuccess} would be returned.
+ *
+ * By the way, as `FormData` is not enough to express complex data structures,
+ * `typia.http.validateFormData()` function has some limitations. If target type
+ * `T` is not following those restrictions, compilation errors would be occured.
+ *
+ * 1. Type `T` must be an object type
+ * 2. Do not allow dynamic property
+ * 3. Only `boolean`, `bigint`, `number`, `string`, `Blob`, `File` or their array types are allowed
+ * 4. By the way, union type never be not allowed
+ *
+ * @template T Expected type of decoded value
+ * @param input FormData instance
+ * @returns Validation result with decoded form FormData
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function validateFormData<T extends object>(
+  input: FormData,
+): IValidation<Resolved<T>>;
+
+/**
+ * @internal
+ */
+function validateFormData(): never {
+  halt("validateFormData");
+}
+const validateFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof validateFormData,
+  {},
+  {}
+>(
+  validateFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { validateFormDataPure as validateFormData };
+
+/* -----------------------------------------------------------
     QUERY
 ----------------------------------------------------------- */
 /**
@@ -164,7 +483,6 @@ function assertQuery<T extends object>(
 function assertQuery(): never {
   halt("assertQuery");
 }
-
 const assertQueryPure = /** @__PURE__ */ Object.assign<
   typeof assertQuery,
   {},
@@ -890,6 +1208,161 @@ export { parameterPure as parameter };
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */
+/**
+ * Creates a reusable {@link formdata} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @template T The type of the formdata object
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createFormData(): never;
+
+/**
+ * Creates a reusable {@link formdata} function.
+ *
+ * @template T The type of the formdata object
+ * @returns A reusable `formdata` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createFormData<T extends object>(): (input: FormData) => T;
+
+/**
+ * @internal
+ */
+function createFormData<T>(): (input: FormData) => T {
+  halt("createFormData");
+}
+
+const createFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof createFormData,
+  {}
+>(createFormData, /** @__PURE__ */ Namespace.http.formData());
+export { createFormDataPure as createFormData };
+
+/**
+ * Creates a reusable {@link assertFormData} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @template T The type of the formdata object
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createAssertFormData(): never;
+
+/**
+ * Creates a reusable {@link assertFormData} function.
+ *
+ * @template T The type of the formdata object
+ * @returns A reusable `assertFormData` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createAssertFormData<T extends object>(): (input: FormData) => T;
+
+/**
+ * @internal
+ */
+function createAssertFormData<T>(): (input: FormData) => T {
+  halt("createAssertFormData");
+}
+
+const createAssertFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertFormData,
+  {},
+  {}
+>(
+  createAssertFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.assert("http.createAssertFormData"),
+);
+export { createAssertFormDataPure as createAssertFormData };
+
+/**
+ * Creates a reusable {@link isFormData} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @template T The type of the formdata object
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createIsFormData(): never;
+
+/**
+ * Creates a reusable {@link isFormData} function.
+ *
+ * @template T The type of the formdata object
+ * @returns A reusable `isFormData` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createIsFormData<T extends object>(): (input: FormData) => T | null;
+
+/**
+ * @internal
+ */
+function createIsFormData<T>(): (input: FormData) => T | null {
+  halt("createIsFormData");
+}
+
+const createIsFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof createIsFormData,
+  {},
+  {}
+>(
+  createIsFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { createIsFormDataPure as createIsFormData };
+
+/**
+ * Creates a reusable {@link validateFormData} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @template T The type of the formdata object
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createValidateFormData(): never;
+
+/**
+ * Creates a reusable {@link validateFormData} function.
+ *
+ * @template T The type of the formdata object
+ * @returns A reusable `validateFormData` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function createValidateFormData<T extends object>(): (
+  input: FormData,
+) => IValidation<Resolved<T>>;
+
+/**
+ * @internal
+ */
+function createValidateFormData<T>(): (
+  input: FormData,
+) => IValidation<Resolved<T>> {
+  halt("createValidateFormData");
+}
+
+const createValidateFormDataPure = /** @__PURE__ */ Object.assign<
+  typeof createValidateFormData,
+  {},
+  {}
+>(
+  createValidateFormData,
+  /** @__PURE__ */ Namespace.http.formData(),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { createValidateFormDataPure as createValidateFormData };
+
 /**
  * Creates a reusable {@link query} function.
  *