typia 6.0.0-dev.20240122 → 6.0.0

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

@@ -6,6 +6,7 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 export const emend_metadata_atomics = (meta: Metadata) => {
   // ATOMICS
   for (const a of meta.atomics) {
+    if (is_not_pure(a)) continue;
     const index: number = meta.constants.findIndex((c) => c.type === a.type);
     if (index !== -1) meta.constants.splice(index, 1);
   }
@@ -21,17 +22,24 @@ export const emend_metadata_atomics = (meta: Metadata) => {
         () =>
           MetadataAtomic.create({
             type: "boolean" as const,
-            tags: temp.tags ?? [],
+            tags: temp.values[0]!.tags ?? [],
           }),
       );
-      temp.tags = undefined;
     }
   }
 
   // TEMPLATE
-  if (
-    meta.templates.length &&
-    meta.atomics.find((a) => a.type === "string") !== undefined
-  )
-    meta.templates.splice(0, meta.templates.length);
+  if (meta.templates.length) {
+    const atomic: MetadataAtomic | undefined = meta.atomics.find(
+      (a) => a.type === "string",
+    );
+    if (atomic !== undefined && false === is_not_pure(atomic))
+      meta.templates.splice(0, meta.templates.length);
+  }
 };
+
+const is_not_pure = (atomic: MetadataAtomic): boolean =>
+  atomic.tags.length !== 0 &&
+  atomic.tags.every(
+    (row) => row.length !== 0 && row.every((c) => !!c.validate?.length),
+  );

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

@@ -37,7 +37,7 @@ export const emplace_metadata_object =
           return (
             kind !== ts.SyntaxKind.PrivateKeyword &&
             kind !== ts.SyntaxKind.ProtectedKeyword &&
-            (ts.isParameter(node) || isProperty(node))
+            isProperty(node)
           );
         }
       : (node) => isProperty(node);
@@ -163,6 +163,7 @@ export const emplace_metadata_object =
   };
 
 const isProperty = (node: ts.Declaration) =>
+  ts.isParameter(node) ||
   ts.isPropertyDeclaration(node) ||
   ts.isPropertyAssignment(node) ||
   ts.isPropertySignature(node) ||

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

@@ -10,11 +10,11 @@ import { iterate_metadata_array } from "./iterate_metadata_array";
 import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
 import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
 import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_escape } from "./iterate_metadata_escape";
 import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
 import { iterate_metadata_map } from "./iterate_metadata_map";
 import { iterate_metadata_native } from "./iterate_metadata_native";
 import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
 import { iterate_metadata_set } from "./iterate_metadata_set";
 import { iterate_metadata_template } from "./iterate_metadata_template";
 import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
@@ -52,7 +52,7 @@ export const iterate_metadata =
         type,
         explore,
       ) ||
-      iterate_metadata_resolve(checker)(options)(collection)(errors)(
+      iterate_metadata_escape(checker)(options)(collection)(errors)(
         meta,
         type,
         explore,

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

@@ -20,7 +20,18 @@ export const iterate_metadata_array =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    if (!checker.isArrayType(type)) return false;
+    if (checker.isArrayType(type) === false) {
+      const array: ts.Type | null = find_array_extended(checker)(new Map())(
+        type,
+      );
+      if (array !== null)
+        return iterate_metadata_array(checker)(options)(collection)(errors)(
+          meta,
+          array,
+          explore,
+        );
+      return false;
+    }
 
     const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
       options,
@@ -35,3 +46,25 @@ export const iterate_metadata_array =
     );
     return true;
   };
+
+const find_array_extended =
+  (checker: ts.TypeChecker) =>
+  (memory: Map<ts.Type, ts.Type | null>) =>
+  (type: ts.Type): ts.Type | null => {
+    const cached = memory.get(type);
+    if (cached !== undefined) return null;
+
+    memory.set(type, null);
+    const res: ts.Type | null = (() => {
+      if (type.isClassOrInterface() === false) return null;
+      for (const t of type.resolvedBaseTypes ?? [])
+        if (checker.isArrayType(t)) return t;
+        else {
+          const res: ts.Type | null = find_array_extended(checker)(memory)(t);
+          if (res !== null) return res;
+        }
+      return null;
+    })();
+    memory.set(type, res);
+    return res;
+  };

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

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -28,7 +29,14 @@ export const iterate_metadata_constant =
             values: [],
           }),
       );
-      ArrayUtil.add(constant.values as Array<any>, value, (a, b) => a === b);
+      ArrayUtil.add(
+        constant.values,
+        MetadataConstantValue.create({
+          value,
+          tags: [],
+        }),
+        (a, b) => a.value === b.value,
+      );
       return true;
     } else if (filter(ts.TypeFlags.BooleanLiteral)) {
       const value: boolean = checker.typeToString(type) === "true";
@@ -41,7 +49,14 @@ export const iterate_metadata_constant =
             values: [],
           }),
       );
-      ArrayUtil.add(constant.values as boolean[], value, (a, b) => a === b);
+      ArrayUtil.add(
+        constant.values,
+        MetadataConstantValue.create({
+          value,
+          tags: [],
+        }),
+        (a, b) => a.value === b.value,
+      );
       return true;
     }
     return false;

package/src/factories/internal/metadata/{iterate_metadata_resolve.ts → iterate_metadata_escape.ts}

@@ -10,7 +10,7 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
-export const iterate_metadata_resolve =
+export const iterate_metadata_escape =
   (checker: ts.TypeChecker) =>
   (options: MetadataFactory.IOptions) =>
   (collection: MetadataCollection) =>

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

@@ -4,6 +4,7 @@ import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -68,30 +69,6 @@ export const iterate_metadata_intersection =
     } else if (children.every((c) => c.objects.length === c.size()))
       return false;
 
-    // CONSIDER BOOLEAN TYPE CASE
-    const booleanLiteral: boolean | null = (() => {
-      const found = children.find(
-        (c) =>
-          c.size() === 1 &&
-          c.constants.length === 1 &&
-          c.constants[0]!.type === "boolean",
-      )?.constants[0]?.values[0];
-      if (found === undefined) return null;
-      return children.every(
-        (c) =>
-          c.atomics.length === 0 ||
-          c.atomics.every((a) => a.type !== "boolean"),
-      )
-        ? (found as boolean)
-        : null;
-    })();
-    if (booleanLiteral !== null && meta.boolean_literal_intersected_ === true) {
-      (
-        meta.constants.find((c) => c.type === "boolean")!.values as boolean[]
-      ).push(booleanLiteral);
-      return true;
-    }
-
     // VALIDATE EACH TYPES
     const individuals: (readonly [Metadata, number])[] = children
       .map((child, i) => [child, i] as const)
@@ -99,16 +76,11 @@ export const iterate_metadata_intersection =
         ([c]) =>
           c.size() === 1 &&
           (c.atomics.length === 1 ||
-            (c.constants.length === 1 && c.constants[0]!.type === "boolean") ||
+            (c.constants.length === 1 && c.constants[0]!.values.length === 1) ||
             c.arrays.length === 1),
       );
-    const constants: Metadata[] = children.filter(
-      (m) =>
-        m.size() ===
-          m.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-            m.templates.length &&
-        !(m.size() === 1 && m.constants[0]!.type === "boolean"),
-    );
+    if (individuals.length !== 1) return false;
+
     const objects: Metadata[] = children.filter(
       (c) =>
         c.nullable === false &&
@@ -117,22 +89,20 @@ export const iterate_metadata_intersection =
         c.objects.length === c.size() &&
         c.objects.every((o) => o.properties.every((p) => p.value.optional)),
     );
-    const atomics: Set<"boolean" | "bigint" | "number" | "string"> = new Set(
-      individuals
-        .map(([c]) => [
-          ...c.atomics.map((a) => a.type),
-          ...c.constants.filter((l) => l.type === "boolean").map((l) => l.type),
-        ])
-        .flat(),
-    );
     const arrays: Set<string> = new Set(
       individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
     );
+    const atomics: Set<"boolean" | "bigint" | "number" | "string"> = new Set(
+      individuals.map(([c]) => [...c.atomics.map((a) => a.type)]).flat(),
+    );
+    const constants: Metadata[] = individuals
+      .filter((i) => i[0].constants.length === 1)
+      .map(([c]) => c);
 
     // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
     if (
-      atomics.size + arrays.size > 1 ||
-      individuals.length + objects.length + constants.length !== children.length
+      atomics.size + constants.length + arrays.size > 1 ||
+      individuals.length + objects.length !== children.length
     ) {
       errors.push({
         name: children.map((c) => c.getName()).join(" & "),
@@ -140,60 +110,16 @@ export const iterate_metadata_intersection =
         messages: ["nonsensible intersection"],
       });
       return true;
-    } else if (atomics.size === 0 && arrays.size === 0 && constants.length) {
-      for (const m of constants) {
-        for (const tpl of m.templates)
-          ArrayUtil.add(
-            meta.templates,
-            tpl,
-            (a, b) =>
-              a.map((ab) => ab.getName()).join(" | ") ===
-              b.map((bb) => bb.getName()).join(" | "),
-          );
-        for (const c of m.constants) {
-          const oldbie = meta.constants.find((o) => o.type === c.type);
-          if (oldbie)
-            for (const elem of c.values)
-              ArrayUtil.add(oldbie.values, elem, (a, b) => a === b);
-          else meta.constants.push(MetadataConstant.create(c));
-        }
-      }
-      return true;
     }
 
     // RE-GENERATE TYPE
     const target: "boolean" | "bigint" | "number" | "string" | "array" =
-      booleanLiteral
-        ? "boolean"
+      arrays.size
+        ? "array"
         : atomics.size
-        ? atomics.values().next().value
-        : "array";
-    if (
-      target === "boolean" ||
-      target === "bigint" ||
-      target === "number" ||
-      target === "string"
-    )
-      if (booleanLiteral === null)
-        ArrayUtil.add(
-          meta.atomics,
-          MetadataAtomic.create({
-            type: atomics.values().next().value as "string",
-            tags: [],
-          }),
-          (a, b) => a.type === b.type,
-        );
-      else
-        ArrayUtil.take<MetadataConstant>(
-          meta.constants,
-          (x) => x.type === "boolean",
-          () =>
-            MetadataConstant.create({
-              type: "boolean",
-              values: [booleanLiteral],
-            }),
-        );
-    else if (target === "array") {
+          ? atomics.values().next().value
+          : constants[0]!.constants[0]!.type;
+    if (target === "array") {
       const name: string = arrays.values().next().value;
       if (!meta.arrays.some((a) => a.type.name === name)) {
         iterate_metadata_array(checker)(options)(collection)(errors)(
@@ -206,7 +132,33 @@ export const iterate_metadata_intersection =
           },
         );
       }
-    }
+    } else if (atomics.size)
+      ArrayUtil.add(
+        meta.atomics,
+        MetadataAtomic.create({
+          type: atomics.values().next().value as "string",
+          tags: [],
+        }),
+        (a, b) => a.type === b.type,
+      );
+    else
+      ArrayUtil.take(
+        ArrayUtil.take(
+          meta.constants,
+          (o) => o.type === target,
+          () =>
+            MetadataConstant.create({
+              type: target,
+              values: [],
+            }),
+        ).values,
+        (o) => o.value === constants[0]!.constants[0]!.values[0]!.value,
+        () =>
+          MetadataConstantValue.create({
+            value: constants[0]!.constants[0]!.values[0]!.value,
+            tags: [],
+          }),
+      );
 
     // ASSIGN TAGS
     if (objects.length) {
@@ -215,16 +167,18 @@ export const iterate_metadata_intersection =
       )(objects.map((om) => om.objects).flat(), explore);
       if (tags.length)
         if (target === "array") meta.arrays.at(-1)!.tags.push(tags);
-        else if (booleanLiteral === null)
+        else if (atomics.size)
           meta.atomics.find((a) => a.type === target)!.tags.push(tags);
         else {
           const constant: MetadataConstant = meta.constants.find(
-            (c) => c.type === "boolean",
+            (c) => c.type === target,
+          )!;
+          const value: MetadataConstantValue = constant.values.find(
+            (v) => v.value === constants[0]!.constants[0]!.values[0]!.value,
           )!;
-          constant.tags ??= [];
-          constant.tags.push(tags);
+          value.tags ??= [];
+          value.tags.push(tags);
         }
     }
-    if (booleanLiteral !== null) meta.boolean_literal_intersected_ = true;
     return true;
   };

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/factories/internal/metadata/iterate_metadata_object.ts

@@ -23,16 +23,6 @@ export const iterate_metadata_object =
         (type as any).intrinsicName !== "object"
       )
         return false;
-      // else if (
-      //     type.isIntersection() &&
-      //     !type.types.every(
-      //         (child) =>
-      //             (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
-      //             !checker.isArrayType(child) &&
-      //             !checker.isTupleType(child),
-      //     )
-      // )
-      //     return false;
     }
 
     const obj: MetadataObject = emplace_metadata_object(checker)(options)(

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

@@ -45,8 +45,8 @@ const iterate =
         Metadata.covers(x.type.value, y.type.value)
           ? -1
           : Metadata.covers(y.type.value, x.type.value)
-          ? 1
-          : 0,
+            ? 1
+            : 0,
       );
     if (meta.tuples.length > 1)
       meta.tuples.sort((x, y) => {
@@ -58,4 +58,17 @@ const iterate =
 
         return Metadata.covers(xt, yt) ? -1 : Metadata.covers(yt, xt) ? 1 : 0;
       });
+
+    // SORT CONSTANT VALUES
+    for (const constant of meta.constants)
+      if (constant.type === "string") constant.values.sort();
+      else if (constant.type === "number")
+        constant.values.sort(
+          (a, b) => (a.value as number) - (b.value as number),
+        );
+      else if (constant.type === "bigint")
+        constant.values.sort((a, b) =>
+          (a.value as bigint) < (b.value as bigint) ? -1 : 1,
+        );
+      else constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
   };

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

@@ -0,0 +1,83 @@
+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 | Blob | null): Blob | null | undefined =>
+  input instanceof Blob
+    ? input
+    : input === null
+      ? undefined
+      : input === "null"
+        ? null
+        : (input as any);
+
+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/$HeadersReader/$HeadersReader.ts

@@ -0,0 +1,26 @@
+export const boolean = (value: string | undefined) =>
+  value !== undefined
+    ? value === "true"
+      ? true
+      : value === "false"
+        ? false
+        : value
+    : undefined;
+export const bigint = (value: string | undefined) =>
+  value !== undefined ? toBigint(value) : undefined;
+export const number = (value: string | undefined) =>
+  value !== undefined ? toNumber(value) : undefined;
+export const string = (value: string | undefined) => value;
+
+const toBigint = (str: string): bigint | string => {
+  try {
+    return BigInt(str);
+  } catch {
+    return str;
+  }
+};
+
+const toNumber = (str: string): number | string => {
+  const value: number = Number(str);
+  return isNaN(value) ? str : value;
+};

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

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

package/src/functional/$ParameterReader/$ParameterReader.ts

@@ -0,0 +1,29 @@
+export const boolean = (value: string) =>
+  value !== "null"
+    ? value === "true" || value === "1"
+      ? true
+      : value === "false" || value === "0"
+        ? false
+        : value
+    : null;
+
+export const bigint = (value: string) =>
+  value !== "null" ? toBigint(value) : null;
+
+export const number = (value: string) =>
+  value !== "null" ? toNumber(value) : null;
+
+export const string = (value: string) => (value !== "null" ? value : null);
+
+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/$ParameterReader/index.ts

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

package/src/functional/$ProtobufReader.ts

@@ -1,9 +1,6 @@
 import { ProtobufWire } from "../programmers/helpers/ProtobufWire";
 
-/**
- * @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedReader.ts
- * @internal
- */
+/// @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedReader.ts
 export class $ProtobufReader {
   /**
    * Read buffer
@@ -192,18 +189,7 @@ export class $ProtobufReader {
   }
 }
 
-/**
- * @internal
- */
-const utf8 = new TextDecoder();
-
-/**
- * @internal
- */
-const N01 = BigInt(0x01);
-
-/**
- * @internal
- */
-const N7F = BigInt(0x7f);
-const N80 = BigInt(0x80);
+const utf8 = /** @__PURE__ */ new TextDecoder();
+const N01 = /** @__PURE__ */ BigInt(0x01);
+const N7F = /** @__PURE__ */ BigInt(0x7f);
+const N80 = /** @__PURE__ */ BigInt(0x80);