typia 5.0.0-dev.2023084 → 5.0.0

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

@@ -1,69 +1,69 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCollection } from "../../MetadataCollection";
-
-export const iterate_metadata_sort =
-    (collection: MetadataCollection) => (meta: Metadata) => {
-        const visited: Set<Metadata> = new Set();
-        for (const array of collection.arrays())
-            iterate(visited)(collection)(array.value);
-        for (const tuple of collection.tuples())
-            for (const element of tuple.elements)
-                iterate(visited)(collection)(element);
-        for (const object of collection.objects())
-            for (const property of object.properties)
-                iterate(visited)(collection)(property.value);
-        iterate(visited)(collection)(meta);
-    };
-
-const iterate =
-    (visited: Set<Metadata>) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata) => {
-        if (visited.has(meta)) return;
-        visited.add(meta);
-
-        // ITERATE CHILDREN
-        for (const map of meta.maps) iterate(visited)(collection)(map.value);
-        for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.escaped !== null)
-            iterate(visited)(collection)(meta.escaped.returns);
-        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
-
-        // SORT OBJECTS
-        if (meta.objects.length > 1) {
-            meta.objects.sort((x, y) =>
-                MetadataObject.covers(x, y)
-                    ? -1
-                    : MetadataObject.covers(y, x)
-                    ? 1
-                    : 0,
-            );
-            meta.union_index = collection.getUnionIndex(meta);
-        }
-
-        // SORT ARRAYS AND TUPLES
-        if (meta.arrays.length > 1)
-            meta.arrays.sort((x, y) =>
-                Metadata.covers(x.value, y.value)
-                    ? -1
-                    : Metadata.covers(y.value, x.value)
-                    ? 1
-                    : 0,
-            );
-        if (meta.tuples.length > 1)
-            meta.tuples.sort((x, y) => {
-                const xt = Metadata.initialize();
-                const yt = Metadata.initialize();
-
-                xt.tuples.push(x);
-                yt.tuples.push(y);
-
-                return Metadata.covers(xt, yt)
-                    ? -1
-                    : Metadata.covers(yt, xt)
-                    ? 1
-                    : 0;
-            });
-    };
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCollection } from "../../MetadataCollection";
+
+export const iterate_metadata_sort =
+    (collection: MetadataCollection) => (meta: Metadata) => {
+        const visited: Set<Metadata> = new Set();
+        for (const array of collection.arrays())
+            iterate(visited)(collection)(array.value);
+        for (const tuple of collection.tuples())
+            for (const element of tuple.elements)
+                iterate(visited)(collection)(element);
+        for (const object of collection.objects())
+            for (const property of object.properties)
+                iterate(visited)(collection)(property.value);
+        iterate(visited)(collection)(meta);
+    };
+
+const iterate =
+    (visited: Set<Metadata>) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata) => {
+        if (visited.has(meta)) return;
+        visited.add(meta);
+
+        // ITERATE CHILDREN
+        for (const map of meta.maps) iterate(visited)(collection)(map.value);
+        for (const set of meta.sets) iterate(visited)(collection)(set);
+        if (meta.escaped !== null)
+            iterate(visited)(collection)(meta.escaped.returns);
+        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
+
+        // SORT OBJECTS
+        if (meta.objects.length > 1) {
+            meta.objects.sort((x, y) =>
+                MetadataObject.covers(x, y)
+                    ? -1
+                    : MetadataObject.covers(y, x)
+                    ? 1
+                    : 0,
+            );
+            meta.union_index = collection.getUnionIndex(meta);
+        }
+
+        // SORT ARRAYS AND TUPLES
+        if (meta.arrays.length > 1)
+            meta.arrays.sort((x, y) =>
+                Metadata.covers(x.type.value, y.type.value)
+                    ? -1
+                    : Metadata.covers(y.type.value, x.type.value)
+                    ? 1
+                    : 0,
+            );
+        if (meta.tuples.length > 1)
+            meta.tuples.sort((x, y) => {
+                const xt = Metadata.initialize();
+                const yt = Metadata.initialize();
+
+                xt.tuples.push(x);
+                yt.tuples.push(y);
+
+                return Metadata.covers(xt, yt)
+                    ? -1
+                    : Metadata.covers(yt, xt)
+                    ? 1
+                    : 0;
+            });
+    };

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

@@ -11,7 +11,12 @@ export const iterate_metadata_template =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
         if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
@@ -26,9 +31,13 @@ export const iterate_metadata_template =
             const binded: ts.Type | undefined = template.types[i];
             if (binded)
                 row.push(
-                    explore_metadata(checker)(options)(collection)(
+                    explore_metadata(checker)(options)(collection)(errors)(
                         binded,
-                        false,
+                        {
+                            ...explore,
+                            escaped: false,
+                            aliased: false,
+                        },
                     ),
                 );
         });

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

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -13,12 +14,24 @@ export const iterate_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.TupleType,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!checker.isTupleType(type)) return false;
 
-        const tuple: MetadataTuple = emplace_metadata_tuple(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.tuples, tuple, (elem) => elem.name === tuple.name);
+        const tupleType: MetadataTupleType = emplace_metadata_tuple(checker)(
+            options,
+        )(collection)(errors)(type, meta.nullable, explore);
+        ArrayUtil.add(
+            meta.tuples,
+            MetadataTuple.create({
+                type: tupleType,
+                tags: [],
+            }),
+            (elem) => elem.type.name === tupleType.name,
+        );
         return true;
     };

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

@@ -10,15 +10,18 @@ export const iterate_metadata_union =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!type.isUnion()) return false;
         type.types.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                parentResolved,
-                false,
-            ),
+            iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
+                ...explore,
+                aliased: false,
+            }),
         );
         return true;
     };

package/src/functional/$ProtobufWriter.ts

@@ -1,151 +1,151 @@
-import { $ProtobufSizer } from "./$ProtobufSizer";
-import { IProtobufWriter } from "./IProtobufWriter";
-
-/// @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedWriter.ts
-export class $ProtobufWriter implements IProtobufWriter {
-    /**
-     * Related sizer
-     */
-    private readonly sizer: $ProtobufSizer;
-
-    /**
-     * Current pointer.
-     */
-    private ptr: number;
-
-    /**
-     * Protobuf buffer.
-     */
-    private buf: Uint8Array;
-
-    /**
-     * DataView for buffer.
-     */
-    private view: DataView;
-
-    /**
-     * Index in varlen array from sizer.
-     */
-    private varlenidx: number;
-
-    constructor(sizer: $ProtobufSizer) {
-        this.sizer = sizer;
-        this.buf = new Uint8Array(sizer.len);
-        this.view = new DataView(this.buf.buffer);
-        this.ptr = 0;
-        this.varlenidx = 0;
-    }
-
-    buffer(): Uint8Array {
-        return this.buf;
-    }
-
-    bool(value: boolean): void {
-        this.byte(value ? 1 : 0);
-    }
-
-    byte(value: number): void {
-        this.buf[this.ptr++] = value & 255;
-    }
-
-    int32(value: number): void {
-        if (value < 0) this.int64(value);
-        else this.variant32(value >>> 0);
-    }
-
-    sint32(value: number): void {
-        this.variant32((value << 1) ^ (value >> 31));
-    }
-
-    uint32(value: number): void {
-        this.variant32(value);
-    }
-
-    sint64(value: number | bigint): void {
-        value = BigInt(value);
-        this.variant64((value << ND01) ^ (value >> ND63));
-    }
-
-    int64(value: number | bigint): void {
-        this.variant64(BigInt(value));
-    }
-
-    uint64(value: number | bigint): void {
-        this.variant64(BigInt(value));
-    }
-
-    float(val: number): void {
-        this.view.setFloat32(this.ptr, val, true);
-        this.ptr += 4;
-    }
-
-    double(val: number): void {
-        this.view.setFloat64(this.ptr, val, true);
-        this.ptr += 8;
-    }
-
-    bytes(value: Uint8Array): void {
-        this.uint32(value.byteLength);
-        for (let i = 0; i < value.byteLength; i++)
-            this.buf[this.ptr++] = value[i]!;
-    }
-
-    string(value: string): void {
-        const len: number = this.varlen(); // use precomputed length
-        this.uint32(len);
-
-        const binary: Uint8Array = utf8.encode(value);
-        for (let i = 0; i < binary.byteLength; i++)
-            this.buf[this.ptr++] = binary[i]!;
-    }
-
-    fork(): void {
-        this.uint32(this.varlen()); // use precomputed length
-    }
-
-    ldelim(): void {
-        // nothing to do - all dirty work done by sizer
-    }
-
-    finish(): Uint8Array {
-        return this.buf;
-    }
-
-    reset(): void {
-        this.buf = new Uint8Array(this.sizer.len);
-        this.view = new DataView(this.buf.buffer);
-        this.ptr = 0;
-        this.varlenidx = 0;
-    }
-
-    private variant32(val: number): void {
-        while (val > 0x7f) {
-            this.buf[this.ptr++] = (val & 0x7f) | 0x80;
-            val = val >>> 7;
-        }
-        this.buf[this.ptr++] = val;
-    }
-
-    private variant64(val: bigint): void {
-        val = BigInt.asUintN(64, val);
-        while (val > NX7F) {
-            this.buf[this.ptr++] = Number((val & NX7F) | NX80);
-            val = val >> ND07;
-        }
-        this.buf[this.ptr++] = Number(val);
-    }
-
-    private varlen(): number {
-        return this.varlenidx >= this.sizer.varlen.length
-            ? 0
-            : this.sizer.varlen[this.varlenidx++]!;
-    }
-}
-
-const utf8 = new TextEncoder();
-
-const ND01 = BigInt(1);
-const ND07 = BigInt(7);
-const ND63 = BigInt(63);
-const NX7F = BigInt(0x7f);
-const NX80 = BigInt(0x80);
+import { $ProtobufSizer } from "./$ProtobufSizer";
+import { IProtobufWriter } from "./IProtobufWriter";
+
+/// @reference https://github.com/piotr-oles/as-proto/blob/main/packages/as-proto/assembly/internal/FixedWriter.ts
+export class $ProtobufWriter implements IProtobufWriter {
+    /**
+     * Related sizer
+     */
+    private readonly sizer: $ProtobufSizer;
+
+    /**
+     * Current pointer.
+     */
+    private ptr: number;
+
+    /**
+     * Protobuf buffer.
+     */
+    private buf: Uint8Array;
+
+    /**
+     * DataView for buffer.
+     */
+    private view: DataView;
+
+    /**
+     * Index in varlen array from sizer.
+     */
+    private varlenidx: number;
+
+    constructor(sizer: $ProtobufSizer) {
+        this.sizer = sizer;
+        this.buf = new Uint8Array(sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    buffer(): Uint8Array {
+        return this.buf;
+    }
+
+    bool(value: boolean): void {
+        this.byte(value ? 1 : 0);
+    }
+
+    byte(value: number): void {
+        this.buf[this.ptr++] = value & 255;
+    }
+
+    int32(value: number): void {
+        if (value < 0) this.int64(value);
+        else this.variant32(value >>> 0);
+    }
+
+    sint32(value: number): void {
+        this.variant32((value << 1) ^ (value >> 31));
+    }
+
+    uint32(value: number): void {
+        this.variant32(value);
+    }
+
+    sint64(value: number | bigint): void {
+        value = BigInt(value);
+        this.variant64((value << ND01) ^ (value >> ND63));
+    }
+
+    int64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    uint64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    float(val: number): void {
+        this.view.setFloat32(this.ptr, val, true);
+        this.ptr += 4;
+    }
+
+    double(val: number): void {
+        this.view.setFloat64(this.ptr, val, true);
+        this.ptr += 8;
+    }
+
+    bytes(value: Uint8Array): void {
+        this.uint32(value.byteLength);
+        for (let i = 0; i < value.byteLength; i++)
+            this.buf[this.ptr++] = value[i]!;
+    }
+
+    string(value: string): void {
+        const len: number = this.varlen(); // use precomputed length
+        this.uint32(len);
+
+        const binary: Uint8Array = utf8.encode(value);
+        for (let i = 0; i < binary.byteLength; i++)
+            this.buf[this.ptr++] = binary[i]!;
+    }
+
+    fork(): void {
+        this.uint32(this.varlen()); // use precomputed length
+    }
+
+    ldelim(): void {
+        // nothing to do - all dirty work done by sizer
+    }
+
+    finish(): Uint8Array {
+        return this.buf;
+    }
+
+    reset(): void {
+        this.buf = new Uint8Array(this.sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    private variant32(val: number): void {
+        while (val > 0x7f) {
+            this.buf[this.ptr++] = (val & 0x7f) | 0x80;
+            val = val >>> 7;
+        }
+        this.buf[this.ptr++] = val;
+    }
+
+    private variant64(val: bigint): void {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F) {
+            this.buf[this.ptr++] = Number((val & NX7F) | NX80);
+            val = val >> ND07;
+        }
+        this.buf[this.ptr++] = Number(val);
+    }
+
+    private varlen(): number {
+        return this.varlenidx >= this.sizer.varlen.length
+            ? 0
+            : this.sizer.varlen[this.varlenidx++]!;
+    }
+}
+
+const utf8 = new TextEncoder();
+
+const ND01 = BigInt(1);
+const ND07 = BigInt(7);
+const ND63 = BigInt(63);
+const NX7F = BigInt(0x7f);
+const NX80 = BigInt(0x80);

package/src/functional/$any.ts

@@ -1,2 +1,4 @@
+import { $clone } from "./$clone";
+
 export const $any = (val: any): any =>
-    val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;
+    val !== undefined ? $clone(val) : undefined;

package/src/functional/$clone.ts

@@ -0,0 +1,4 @@
+import { Primitive } from "../Primitive";
+
+export const $clone = <T>(value: T): Primitive<T> =>
+    JSON.parse(JSON.stringify(value));

package/src/functional/Namespace.ts

@@ -9,14 +9,6 @@ import { $any } from "./$any";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
 import { $is_between } from "./$is_between";
-import { $is_custom } from "./$is_custom";
-import { $is_date } from "./$is_date";
-import { $is_datetime } from "./$is_datetime";
-import { $is_email } from "./$is_email";
-import { $is_ipv4 } from "./$is_ipv4";
-import { $is_ipv6 } from "./$is_ipv6";
-import { $is_url } from "./$is_url";
-import { $is_uuid } from "./$is_uuid";
 import { $join } from "./$join";
 import { $number } from "./$number";
 import { $report } from "./$report";
@@ -30,15 +22,7 @@ import { $tail } from "./$tail";
  */
 export namespace Namespace {
     export const is = () => ({
-        is_uuid: $is_uuid,
-        is_email: $is_email,
-        is_url: $is_url,
-        is_ipv4: $is_ipv4,
-        is_ipv6: $is_ipv6,
         is_between: $is_between,
-        is_date: $is_date,
-        is_datetime: $is_datetime,
-        is_custom: $is_custom,
     });
 
     export const assert = (method: string) => ({