typia 4.2.3 → 4.3.0

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

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_set =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        type = checker.getApparentType(type);
-
-        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
-        const generic = type.aliasSymbol
-            ? type.aliasTypeArguments
-            : checker.getTypeArguments(type as ts.TypeReference);
-        if (name.substring(0, 4) !== "Set<" || generic?.length !== 1)
-            return false;
-
-        const key: ts.Type = generic[0]!;
-        ArrayUtil.set(
-            meta.sets,
-            explore_metadata(checker)(options)(collection)(key, false),
-            (elem) => elem.getName(),
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_set =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        type = checker.getApparentType(type);
+
+        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+        const generic = type.aliasSymbol
+            ? type.aliasTypeArguments
+            : checker.getTypeArguments(type as ts.TypeReference);
+        if (name.substring(0, 4) !== "Set<" || generic?.length !== 1)
+            return false;
+
+        const key: ts.Type = generic[0]!;
+        ArrayUtil.set(
+            meta.sets,
+            explore_metadata(checker)(options)(collection)(key, false),
+            (elem) => elem.getName(),
+        );
+        return true;
+    };

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

@@ -1,69 +1,69 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../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.resolved !== null)
-            iterate(visited)(collection)(meta.resolved.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 "../../../metadata/Metadata";
+import { MetadataObject } from "../../../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.resolved !== null)
+            iterate(visited)(collection)(meta.resolved.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;
+            });
+    };

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

@@ -1,31 +1,31 @@
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { Writable } from "../../../typings/Writable";
-
-import { Escaper } from "../../../utils/Escaper";
-
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-
-export const iterate_metadata_tag = (obj: MetadataObject) => {
-    if (obj.tagged_ === true) return;
-    obj.tagged_ = true;
-
-    for (const prop of obj.properties) {
-        const key: string = prop.key.getName();
-        const variable: string | null =
-            key.length >= 3 &&
-            key[0] === '"' &&
-            key[key.length - 1] === '"' &&
-            Escaper.variable(key.slice(1, -1))
-                ? key.slice(1, -1)
-                : null;
-
-        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
-            prop.jsDocTags,
-        )(
-            variable !== null
-                ? () => `${obj.name}.${variable}`
-                : () => `${obj.name}[${key}]`,
-        );
-    }
-};
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { Writable } from "../../../typings/Writable";
+
+import { Escaper } from "../../../utils/Escaper";
+
+import { MetadataTagFactory } from "../../MetadataTagFactory";
+
+export const iterate_metadata_tag = (obj: MetadataObject) => {
+    if (obj.tagged_ === true) return;
+    obj.tagged_ = true;
+
+    for (const prop of obj.properties) {
+        const key: string = prop.key.getName();
+        const variable: string | null =
+            key.length >= 3 &&
+            key[0] === '"' &&
+            key[key.length - 1] === '"' &&
+            Escaper.variable(key.slice(1, -1))
+                ? key.slice(1, -1)
+                : null;
+
+        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
+            prop.jsDocTags,
+        )(
+            variable !== null
+                ? () => `${obj.name}.${variable}`
+                : () => `${obj.name}[${key}]`,
+        );
+    }
+};

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

@@ -1,38 +1,38 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_template =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-        if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
-
-        const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
-        const row: Metadata[] = [];
-
-        template.texts.forEach((text, i) => {
-            // TEXT LITERAL TYPE
-            if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
-
-            // BINDED TEMPLATE TYPE
-            const binded: ts.Type | undefined = template.types[i];
-            if (binded)
-                row.push(
-                    explore_metadata(checker)(options)(collection)(
-                        binded,
-                        false,
-                    ),
-                );
-        });
-        meta.templates.push(row);
-
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_template =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+        if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
+
+        const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
+        const row: Metadata[] = [];
+
+        template.texts.forEach((text, i) => {
+            // TEXT LITERAL TYPE
+            if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
+
+            // BINDED TEMPLATE TYPE
+            const binded: ts.Type | undefined = template.types[i];
+            if (binded)
+                row.push(
+                    explore_metadata(checker)(options)(collection)(
+                        binded,
+                        false,
+                    ),
+                );
+        });
+        meta.templates.push(row);
+
+        return true;
+    };

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

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataTuple } from "../../../metadata/MetadataTuple";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
-
-export const iterate_metadata_tuple =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): 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);
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
+
+export const iterate_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.TupleType): 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);
+        return true;
+    };

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

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_union =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        if (!type.isUnion()) return false;
-        type.types.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                parentResolved,
-                false,
-            ),
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_union =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+        if (!type.isUnion()) return false;
+        type.types.forEach((t) =>
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                t,
+                parentResolved,
+                false,
+            ),
+        );
+        return true;
+    };

package/src/functional/$any.ts

@@ -1,2 +1,2 @@
-export const $any = (val: any): any =>
-    val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;
+export const $any = (val: any): any =>
+    val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;

package/src/functional/$dictionary.ts

@@ -1,25 +1,25 @@
-import { Customizable } from "../typings/Customizable";
-
-/**
- * @internal
- */
-const blackhole: any = {};
-
-export const $dictionary = (() => {
-    const glob: {
-        __typia_custom_validator: Map<
-            `${string}`,
-            Map<
-                keyof Customizable,
-                (tagText: string) => (value: any) => boolean
-            >
-        >;
-    } =
-        typeof global === "object" &&
-        typeof global.process === "object" &&
-        typeof global.process.versions === "object" &&
-        typeof global.process.versions.node !== "undefined"
-            ? ((global ?? blackhole) as any)
-            : ((self ?? blackhole) as any);
-    return (glob.__typia_custom_validator ??= new Map());
-})();
+import { Customizable } from "../typings/Customizable";
+
+/**
+ * @internal
+ */
+const blackhole: any = {};
+
+export const $dictionary = (() => {
+    const glob: {
+        __typia_custom_validator: Map<
+            `${string}`,
+            Map<
+                keyof Customizable,
+                (tagText: string) => (value: any) => boolean
+            >
+        >;
+    } =
+        typeof global === "object" &&
+        typeof global.process === "object" &&
+        typeof global.process.versions === "object" &&
+        typeof global.process.versions.node !== "undefined"
+            ? ((global ?? blackhole) as any)
+            : ((self ?? blackhole) as any);
+    return (glob.__typia_custom_validator ??= new Map());
+})();

package/src/functional/$every.ts

@@ -1,11 +1,11 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-export const $every = <T>(
-    array: T[],
-    pred: (value: T, i: number) => null | Omit<TypeGuardError.IProps, "method">,
-): null | Omit<TypeGuardError.IProps, "method"> => {
-    let error: null | Omit<TypeGuardError.IProps, "method"> = null;
-    for (let i: number = 0; i < array.length; ++i)
-        if (null !== (error = pred(array[i]!, i))) return error;
-    return null;
-};
+import { TypeGuardError } from "../TypeGuardError";
+
+export const $every = <T>(
+    array: T[],
+    pred: (value: T, i: number) => null | Omit<TypeGuardError.IProps, "method">,
+): null | Omit<TypeGuardError.IProps, "method"> => {
+    let error: null | Omit<TypeGuardError.IProps, "method"> = null;
+    for (let i: number = 0; i < array.length; ++i)
+        if (null !== (error = pred(array[i]!, i))) return error;
+    return null;
+};

package/src/functional/$guard.ts

@@ -1,35 +1,35 @@
-import { TypeGuardError } from "../TypeGuardError";
-
-/* -----------------------------------------------------------
-    ASSERT V2 -> USE (NULL OR ERROR) CONDITION
------------------------------------------------------------ */
-// /**
-//  * @internal
-//  */
-// export const $guardV2 =
-//     (method: string) => (props: Omit<TypeGuardError.IProps, "method">) =>
-//         new TypeGuardError({
-//             method,
-//             path: props.path,
-//             expected: props.expected,
-//             value: props.value,
-//         });
-
-/* -----------------------------------------------------------
-    ASSERT V3 -> (CONDITION OR THROW(exceptable): FALSE)
------------------------------------------------------------ */
-/**
- * @internal
- */
-export const $guard =
-    (method: string) =>
-    (exceptionable: boolean, props: Omit<TypeGuardError.IProps, "method">) => {
-        if (exceptionable === true)
-            throw new TypeGuardError({
-                method,
-                path: props.path,
-                expected: props.expected,
-                value: props.value,
-            });
-        return false;
-    };
+import { TypeGuardError } from "../TypeGuardError";
+
+/* -----------------------------------------------------------
+    ASSERT V2 -> USE (NULL OR ERROR) CONDITION
+----------------------------------------------------------- */
+// /**
+//  * @internal
+//  */
+// export const $guardV2 =
+//     (method: string) => (props: Omit<TypeGuardError.IProps, "method">) =>
+//         new TypeGuardError({
+//             method,
+//             path: props.path,
+//             expected: props.expected,
+//             value: props.value,
+//         });
+
+/* -----------------------------------------------------------
+    ASSERT V3 -> (CONDITION OR THROW(exceptable): FALSE)
+----------------------------------------------------------- */
+/**
+ * @internal
+ */
+export const $guard =
+    (method: string) =>
+    (exceptionable: boolean, props: Omit<TypeGuardError.IProps, "method">) => {
+        if (exceptionable === true)
+            throw new TypeGuardError({
+                method,
+                path: props.path,
+                expected: props.expected,
+                value: props.value,
+            });
+        return false;
+    };

package/src/functional/$is_between.ts

@@ -1,2 +1,2 @@
-export const $is_between = (value: number, minimum: number, maximum: number) =>
-    minimum <= value && value <= maximum;
+export const $is_between = (value: number, minimum: number, maximum: number) =>
+    minimum <= value && value <= maximum;

package/src/functional/$is_custom.ts

@@ -1,14 +1,14 @@
-import { Customizable } from "../typings/Customizable";
-
-import { $dictionary } from "./$dictionary";
-
-export const $is_custom = <Type extends keyof Customizable>(
-    name: string,
-    type: Type,
-    text: string,
-    value: Customizable[Type],
-): boolean => {
-    const validator = $dictionary.get(name)?.get(type);
-    if (validator === undefined) return true;
-    return validator(text)(value);
-};
+import { Customizable } from "../typings/Customizable";
+
+import { $dictionary } from "./$dictionary";
+
+export const $is_custom = <Type extends keyof Customizable>(
+    name: string,
+    type: Type,
+    text: string,
+    value: Customizable[Type],
+): boolean => {
+    const validator = $dictionary.get(name)?.get(type);
+    if (validator === undefined) return true;
+    return validator(text)(value);
+};

package/src/functional/$is_date.ts

@@ -1,3 +1,3 @@
-export const $is_date = (value: string): boolean => REGEX.test(value);
-
-const REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;
+export const $is_date = (value: string): boolean => REGEX.test(value);
+
+const REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;

package/src/functional/$is_datetime.ts

@@ -1,2 +1,2 @@
-export const $is_datetime = (value: string): boolean =>
-    !isNaN(new Date(value).getTime());
+export const $is_datetime = (value: string): boolean =>
+    !isNaN(new Date(value).getTime());