typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/factories/MetadataTagFactory.ts

@@ -1,365 +0,0 @@
-import ts from "typescript";
-
-import { IMetadataAtomic } from "../schemas/metadata/IMetadataAtomic";
-import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
-import { Metadata } from "../schemas/metadata/Metadata";
-
-export namespace MetadataTagFactory {
-    export const generate =
-        (metadata: Metadata) =>
-        (tagList: ts.JSDocTagInfo[]) =>
-        (identifier: () => string): IMetadataCommentTag[] => {
-            const output: IMetadataCommentTag[] = [];
-            for (const tag of tagList) {
-                const elem: IMetadataCommentTag | null = parse(
-                    identifier,
-                    metadata,
-                    tag,
-                    output,
-                );
-                if (elem !== null) output.push(elem);
-            }
-            return output;
-        };
-
-    const parse = (
-        identifier: () => string,
-        metadata: Metadata,
-        tag: ts.JSDocTagInfo,
-        output: IMetadataCommentTag[],
-    ): IMetadataCommentTag | null => {
-        const closure = _PARSER[tag.name];
-        if (closure === undefined) return null;
-
-        const text = (tag.text || [])[0]?.text;
-        if (text === undefined)
-            throw new Error(`${LABEL}: no tag value on ${identifier()}`);
-
-        return closure(identifier, metadata, text, output);
-    };
-
-    /**
-     * @internal
-     */
-    export const _PARSER: Record<
-        string,
-        (
-            identifier: () => string,
-            metadata: Metadata,
-            text: string,
-            output: IMetadataCommentTag[],
-        ) => IMetadataCommentTag | null
-    > = {
-        /* -----------------------------------------------------------
-            ARRAY
-        ----------------------------------------------------------- */
-        items: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "items", "array", [
-                "minItems",
-            ]);
-            return {
-                kind: "items",
-                value: parse_number(identifier, text),
-            };
-        },
-        minItems: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "minItems", "array", [
-                "items",
-            ]);
-            return {
-                kind: "minItems",
-                value: parse_number(identifier, text),
-            };
-        },
-        maxItems: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "maxItems", "array", [
-                "items",
-            ]);
-            return {
-                kind: "maxItems",
-                value: parse_number(identifier, text),
-            };
-        },
-
-        /* -----------------------------------------------------------
-            NUMBER
-        ----------------------------------------------------------- */
-        type: (_identifier, metadata, text, _output) => {
-            if (text.startsWith("{") && text.endsWith("}"))
-                text = text.substring(1, text.length - 1);
-            return has_atomic("number")(new Set())(metadata) &&
-                (text === "int" ||
-                    text === "uint" ||
-                    text === "int32" ||
-                    text === "uint32" ||
-                    text === "int64" ||
-                    text === "uint64" ||
-                    text === "float")
-                ? { kind: "type", value: text }
-                : null;
-        },
-        minimum: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "minimum", "number", [
-                "exclusiveMinimum",
-            ]);
-            return {
-                kind: "minimum",
-                value: parse_number(identifier, text),
-            };
-        },
-        maximum: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "maximum", "number", [
-                "exclusiveMaximum",
-            ]);
-            return {
-                kind: "maximum",
-                value: parse_number(identifier, text),
-            };
-        },
-        exclusiveMinimum: (identifier, metadata, text, output) => {
-            validate(
-                identifier,
-                metadata,
-                output,
-                "exclusiveMinimum",
-                "number",
-                ["minimum"],
-            );
-            return {
-                kind: "exclusiveMinimum",
-                value: parse_number(identifier, text),
-            };
-        },
-        exclusiveMaximum: (identifier, metadata, text, output) => {
-            validate(
-                identifier,
-                metadata,
-                output,
-                "exclusiveMaximum",
-                "number",
-                ["maximum"],
-            );
-            return {
-                kind: "exclusiveMaximum",
-                value: parse_number(identifier, text),
-            };
-        },
-        multipleOf: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "multipleOf", "number", [
-                "step",
-            ]);
-            return {
-                kind: "multipleOf",
-                value: parse_number(identifier, text),
-            };
-        },
-        step: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "step", "number", [
-                "multipleOf",
-            ]);
-
-            const minimum: boolean = output.some(
-                (tag) =>
-                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-            );
-            if (minimum === undefined)
-                throw new Error(
-                    `${LABEL}: step requires minimum or exclusiveMinimum tag on "${identifier()}".`,
-                );
-
-            return {
-                kind: "step",
-                value: parse_number(identifier, text),
-            };
-        },
-
-        /* -----------------------------------------------------------
-            STRING
-        ----------------------------------------------------------- */
-        // Ignore arbitrary @format values in the internal metadata,
-        // these are currently only supported on the typia.application() API.
-        format: (identifier, metadata, str, output) => {
-            const value: IMetadataCommentTag.IFormat["value"] | undefined =
-                FORMATS.get(str);
-            validate(
-                identifier,
-                metadata,
-                output,
-                "format",
-                value === "date" || value === "datetime" ? "Date" : "string",
-                ["pattern"],
-            );
-            if (value === undefined) return null;
-            return {
-                kind: "format",
-                value,
-            };
-        },
-        pattern: (identifier, metadata, value, output) => {
-            validate(identifier, metadata, output, "pattern", "string", [
-                "format",
-            ]);
-            return {
-                kind: "pattern",
-                value,
-            };
-        },
-        length: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "length", "string", [
-                "minLength",
-                "maxLength",
-            ]);
-            return {
-                kind: "length",
-                value: parse_number(identifier, text),
-            };
-        },
-        minLength: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "minLength", "string", [
-                "length",
-            ]);
-            return {
-                kind: "minLength",
-                value: parse_number(identifier, text),
-            };
-        },
-        maxLength: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "maxLength", "string", [
-                "length",
-            ]);
-            return {
-                kind: "maxLength",
-                value: parse_number(identifier, text),
-            };
-        },
-    };
-}
-
-const parse_number = (identifier: () => string, str: string): number => {
-    const value: number = Number(str);
-    if (isNaN(value) === true)
-        throw new Error(`${LABEL}: invalid number on "${identifier()}".`);
-    return value;
-};
-
-const LABEL = "Error on typia.MetadataTagFactory.generate()";
-const FORMATS: Map<string, IMetadataCommentTag.IFormat["value"]> = new Map([
-    ["uuid", "uuid"],
-    ["email", "email"],
-    ["url", "url"],
-    ["ipv4", "ipv4"],
-    ["ipv6", "ipv6"],
-    ["date", "date"],
-    ["datetime", "datetime"],
-    ["date-time", "datetime"],
-    ["dateTime", "datetime"],
-]);
-
-const WRONG_TYPE = (
-    tag: string,
-    type: "string" | "number" | "array",
-    identifier: () => string,
-) => `${LABEL}: ${tag} requires ${type} type, but no "${identifier()}".`;
-
-const validate = (
-    identifier: () => string,
-    metadata: Metadata,
-    output: IMetadataCommentTag[],
-    kind: IMetadataCommentTag["kind"],
-    type: "array" | "string" | "number" | "Date",
-    neighbors: IMetadataCommentTag["kind"][],
-): void => {
-    // TYPE CHECKING
-    if (type === "array") {
-        if (has_array(new Set())(metadata) === false)
-            throw new Error(WRONG_TYPE(kind, "array", identifier));
-    } else if (type === "Date") {
-        if (
-            has_native("Date")(new Set())(metadata) === false &&
-            has_atomic("string")(new Set())(metadata) === false
-        )
-            throw new Error(WRONG_TYPE(kind, "string", identifier));
-    } else if (has_atomic(type)(new Set())(metadata) === false)
-        throw new Error(WRONG_TYPE(kind, type, identifier));
-
-    // DUPLICATED TAG
-    if (output.some((tag) => tag.kind === kind))
-        throw new Error(
-            `${LABEL}: duplicated ${kind} tags on "${identifier()}".`,
-        );
-
-    // NEIGHBOR TAG
-    for (const name of neighbors)
-        if (output.some((tag) => tag.kind === name))
-            throw new Error(
-                `${LABEL}: ${kind} and ${name} tags on "${identifier()}".`,
-            );
-};
-
-const has_atomic =
-    (type: "string" | "number" | "bigint") =>
-    (visited: Set<Metadata>) =>
-    (metadata: Metadata): boolean => {
-        if (visited.has(metadata)) return false;
-        visited.add(metadata);
-        return (
-            metadata.atomics.find(
-                type === "number"
-                    ? (atom: IMetadataAtomic) =>
-                          atom.type === type || atom.type === "bigint"
-                    : (atom: IMetadataAtomic) => atom.type === type,
-            ) !== undefined ||
-            metadata.arrays.some((array) =>
-                has_atomic(type)(visited)(array.type.value),
-            ) ||
-            metadata.tuples.some((tuple) =>
-                tuple.type.elements.some(has_atomic(type)(visited)),
-            ) ||
-            metadata.maps.some((map) => has_atomic(type)(visited)(map.value)) ||
-            metadata.aliases.some((alias) =>
-                has_atomic(type)(visited)(alias.value),
-            ) ||
-            (metadata.escaped !== null &&
-                has_atomic(type)(visited)(metadata.escaped.returns))
-        );
-    };
-
-const has_native =
-    (type: string) =>
-    (visited: Set<Metadata>) =>
-    (metadata: Metadata): boolean => {
-        if (visited.has(metadata)) return false;
-        visited.add(metadata);
-        return (
-            metadata.natives.find((native) => native === type) !== undefined ||
-            metadata.arrays.some((child) =>
-                has_native(type)(visited)(child.type.value),
-            ) ||
-            metadata.tuples.some((tuple) =>
-                tuple.type.elements.some(has_native(type)(visited)),
-            ) ||
-            metadata.maps.some((map) => has_native(type)(visited)(map.value)) ||
-            metadata.aliases.some((alias) =>
-                has_native(type)(visited)(alias.value),
-            ) ||
-            (metadata.escaped !== null &&
-                has_native(type)(visited)(metadata.escaped.returns))
-        );
-    };
-
-const has_array =
-    (visited: Set<Metadata>) =>
-    (metadata: Metadata): boolean => {
-        if (visited.has(metadata)) return false;
-        visited.add(metadata);
-        return (
-            metadata.arrays.length !== 0 ||
-            metadata.tuples.some((tuple) =>
-                tuple.type.elements.some(has_array(visited)),
-            ) ||
-            metadata.maps.some((map) => has_array(visited)(map.value)) ||
-            metadata.aliases.some((alias) => has_array(visited)(alias.value)) ||
-            (metadata.escaped !== null &&
-                has_array(visited)(metadata.escaped.returns))
-        );
-    };

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

@@ -1,183 +0,0 @@
-import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
-
-export const iterate_metadata_type_tags =
-    (type: "bigint" | "number" | "string" | "array") =>
-    (objects: MetadataObject[]): IMetadataTypeTag[] => {
-        const filtered: MetadataObject[] = objects.filter((obj) => {
-            //----
-            // VALIDATION PROCESS
-            //----
-            // ONLY ONE PROPERTY
-            if (obj.properties.length !== 1) return false;
-
-            // THE TAG.TYPE PROPERTY MUST BE
-            const top: MetadataProperty = obj.properties[0]!;
-            if (
-                top.key.getSoleLiteral() !== "typia.tag" ||
-                top.value.size() !== 1 ||
-                top.value.objects.length !== 1
-            )
-                return false;
-            else if (top.value.optional === false)
-                throw error(null)("must be optional object");
-
-            // CHECK LIST OF PROPERTIES
-            const tag: MetadataObject = top.value.objects[0]!;
-            const statics: string[] = tag.properties
-                .map((p) => p.key.getSoleLiteral()!)
-                .filter((str) => str !== null);
-            if (FIELDS.some((f) => !statics.includes(f)))
-                throw error(null)(
-                    `must have four properties - ${FIELDS.map(
-                        (str) => `'${str}'`,
-                    ).join(", ")}`,
-                );
-
-            for (const p of tag.properties) {
-                const key: string | null = p.key.getSoleLiteral();
-                if (key === null) continue;
-                else if (FIELDS.includes(key) === false) continue;
-                else if (
-                    // TARGET
-                    key === "target" &&
-                    (p.value.constants.length !== 1 ||
-                        p.value.constants[0]!.values.length !==
-                            p.value.size() ||
-                        p.value.constants[0]!.values.some(
-                            (v) =>
-                                v !== "bigint" &&
-                                v !== "number" &&
-                                v !== "string" &&
-                                v !== "array",
-                        ))
-                )
-                    throw error(key)(
-                        `must be one of 'bigint', 'number', 'string', 'array'`,
-                    );
-                else if (
-                    // KIND
-                    key === "kind" &&
-                    (p.value.size() !== 1 ||
-                        p.value.constants.length !== 1 ||
-                        p.value.constants[0]!.type !== "string" ||
-                        p.value.constants[0]!.values.length !== 1)
-                )
-                    throw error(key)("must be a string literal type");
-                else if (
-                    // VALUE
-                    key === "value" &&
-                    (p.value.size() !== 1 ||
-                        p.value.constants.length !== 1 ||
-                        p.value.constants[0]!.values.length !== 1)
-                )
-                    throw error(key)("must be a constant literal type");
-                else if (key === "validate") {
-                    //----
-                    // VALIDATE
-                    //----
-                    // STRING CASE
-                    const single: boolean =
-                        p.value.size() === 1 &&
-                        p.value.constants.length === 1 &&
-                        p.value.constants[0]!.type === "string" &&
-                        p.value.constants[0]!.values.length === 1;
-                    if (single === true) continue;
-
-                    // RECORD<TARGET, STRING>
-                    const target: string[] | undefined =
-                        p.value.objects[0]?.properties.find(
-                            (p) => p.key.getSoleLiteral()! === "target",
-                        )?.value?.constants?.[0]?.values as
-                            | string[]
-                            | undefined;
-                    if (target === undefined)
-                        throw error("target")(
-                            `must be one of 'bigint', 'number', 'string', 'array'`,
-                        );
-                    const variadic: boolean =
-                        p.value.size() === 1 &&
-                        p.value.objects.length === 1 &&
-                        p.value.objects[0]!.properties.every(
-                            (vp) =>
-                                vp.value.size() === 1 &&
-                                vp.value.isRequired() &&
-                                vp.value.nullable === false &&
-                                vp.value.constants.length === 1 &&
-                                vp.value.constants[0]!.type === "string" &&
-                                vp.value.constants[0]!.values.length === 1 &&
-                                target.includes(vp.key.getSoleLiteral()!),
-                        );
-                    if (variadic === false)
-                        throw error(key)(
-                            `must be a string literal type or Record<Target, string> type.`,
-                        );
-                }
-            }
-            return true;
-        });
-
-        const tagList: ITypedTag[] = filtered.map((obj) => {
-            const find = (key: string): MetadataProperty =>
-                obj.properties[0]!.value.objects[0]!.properties.find(
-                    (p) => p.key.getSoleLiteral() === key,
-                )!;
-
-            const target = find("target").value.constants[0]!
-                .values as ITypedTag["target"];
-            const kind: string = find("kind").value.constants[0]!
-                .values[0] as string;
-            const value: boolean | bigint | number | string =
-                find("value").value.constants[0]!.values[0]!;
-            const validate: Record<string, string> = (() => {
-                const validate = find("validate").value;
-                if (validate.constants.length)
-                    return {
-                        [target[0]!]: validate.constants[0]!
-                            .values[0] as string,
-                    };
-                return Object.fromEntries(
-                    validate.objects[0]!.properties.map((p) => [
-                        p.key.getSoleLiteral()!,
-                        p.value.constants[0]!.values[0]! as string,
-                    ]),
-                );
-            })();
-
-            return { name: obj.name, target, kind, value, validate };
-        });
-        if (filtered.length === 0) return [];
-
-        for (const tag of tagList)
-            if (tag.target.includes(type))
-                error(null)(
-                    `target must constains ${type} type - ${JSON.stringify(
-                        tag,
-                    )}`,
-                );
-
-        return tagList.map((tag) => ({
-            name: tag.name,
-            kind: tag.kind,
-            value: tag.value,
-            validate: tag.validate[type]!,
-        }));
-    };
-
-interface ITypedTag {
-    name: string;
-    target: Array<"bigint" | "number" | "string" | "array">;
-    kind: string;
-    value: boolean | bigint | number | string;
-    validate: Record<string, string>;
-}
-
-const FIELDS = ["target", "kind", "value", "validate"];
-
-const error = (property: string | null) => (msg: string) =>
-    new Error(
-        `Error on typia.MetadataFactory.analyze(): the property '${
-            property === null ? `["typia.tag"]` : `["typia.tag.${property}"]`
-        }' ${msg}.`,
-    );

package/src/functional/$is_custom.ts

@@ -1,14 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-export const $is_datetime = (value: string): boolean =>
-    !isNaN(new Date(value).getTime());

package/src/functional/$is_email.ts

@@ -1,4 +0,0 @@
-export const $is_email = (str: string): boolean => REGEX.test(str);
-
-const REGEX =
-    /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

package/src/functional/$is_ipv4.ts

@@ -1,4 +0,0 @@
-export const $is_ipv4 = (str: string): boolean => REGEX.test(str);
-
-const REGEX =
-    /^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;

package/src/functional/$is_ipv6.ts

@@ -1,4 +0,0 @@
-export const $is_ipv6 = (str: string): boolean => REGEX.test(str);
-
-const REGEX =
-    /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;

package/src/functional/$is_url.ts

@@ -1,4 +0,0 @@
-export const $is_url = (str: string): boolean => REGEX.test(str);
-
-const REGEX =
-    /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;

package/src/functional/$is_uuid.ts

@@ -1,4 +0,0 @@
-export const $is_uuid = (str: string): boolean => REGEX.test(str);
-
-const REGEX =
-    /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;

package/src/programmers/internal/check_array_tags.ts

@@ -1,45 +0,0 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_array_length } from "./check_array_length";
-
-/**
- * @internal
- */
-export const check_array_tags =
-    (project: IProject) =>
-    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
-    (input: ts.Expression): ICheckEntry => ({
-        expression: is_array(project)(matrix)(input),
-        tags: matrix.length
-            ? []
-            : check_array_length(metaTags)(
-                  IdentifierFactory.access(input)("length"),
-              ),
-    });
-
-const is_array =
-    (project: IProject) =>
-    (matrix: IMetadataTypeTag[][]) =>
-    (input: ts.Expression) =>
-        matrix.length === 0
-            ? null
-            : matrix
-                  .map((row) =>
-                      row
-                          .map((tag) =>
-                              ExpressionFactory.transpile(project.context)(
-                                  tag.validate,
-                              )(input),
-                          )
-                          .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                  )
-                  .reduce((a, b) => ts.factory.createLogicalOr(a, b));