typia 8.0.0 → 8.0.1

package/lib/factories/internal/metadata/iterate_metadata.mjs

@@ -0,0 +1,51 @@
+import { TypeFactory } from '../../TypeFactory.mjs';
+import { iterate_metadata_alias } from './iterate_metadata_alias.mjs';
+import { iterate_metadata_array } from './iterate_metadata_array.mjs';
+import { iterate_metadata_atomic } from './iterate_metadata_atomic.mjs';
+import { iterate_metadata_coalesce } from './iterate_metadata_coalesce.mjs';
+import { iterate_metadata_constant } from './iterate_metadata_constant.mjs';
+import { iterate_metadata_escape } from './iterate_metadata_escape.mjs';
+import { iterate_metadata_function } from './iterate_metadata_function.mjs';
+import { iterate_metadata_intersection } from './iterate_metadata_intersection.mjs';
+import { iterate_metadata_map } from './iterate_metadata_map.mjs';
+import { iterate_metadata_native } from './iterate_metadata_native.mjs';
+import { iterate_metadata_object } from './iterate_metadata_object.mjs';
+import { iterate_metadata_set } from './iterate_metadata_set.mjs';
+import { iterate_metadata_template } from './iterate_metadata_template.mjs';
+import { iterate_metadata_tuple } from './iterate_metadata_tuple.mjs';
+import { iterate_metadata_union } from './iterate_metadata_union.mjs';
+
+const iterate_metadata = (props) => {
+    if (props.type.isTypeParameter() === true) {
+        props.errors.push({
+            name: TypeFactory.getFullName({
+                checker: props.checker,
+                type: props.type,
+            }),
+            explore: { ...props.explore },
+            messages: ["non-specified generic argument found."],
+        });
+        return;
+    }
+    // CHECK SPECIAL CASES
+    if ((props.explore.aliased !== true && iterate_metadata_alias(props)) ||
+        iterate_metadata_intersection(props) ||
+        iterate_metadata_union(props) ||
+        iterate_metadata_escape(props))
+        return;
+    // ITERATE CASES
+    iterate_metadata_coalesce(props) ||
+        iterate_metadata_function(props) ||
+        iterate_metadata_constant(props) ||
+        iterate_metadata_template(props) ||
+        iterate_metadata_atomic(props) ||
+        iterate_metadata_tuple(props) ||
+        iterate_metadata_array(props) ||
+        iterate_metadata_native(props) ||
+        iterate_metadata_map(props) ||
+        iterate_metadata_set(props) ||
+        iterate_metadata_object(props);
+};
+
+export { iterate_metadata };
+//# sourceMappingURL=iterate_metadata.mjs.map

package/lib/factories/internal/metadata/iterate_metadata.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_alias.mjs

@@ -0,0 +1,21 @@
+import { MetadataAlias } from '../../../schemas/metadata/MetadataAlias.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { emplace_metadata_alias } from './emplace_metadata_alias.mjs';
+
+const iterate_metadata_alias = (props) => {
+    if (props.options.absorb !== false || props.type.aliasSymbol === undefined)
+        return false;
+    const node = props.type.aliasSymbol.declarations?.[0];
+    if (node === undefined)
+        return false;
+    // CONSTRUCT DEFINITION
+    const type = emplace_metadata_alias(props);
+    ArrayUtil.take(props.metadata.aliases, (elem) => elem.type.name === type.name, () => MetadataAlias.create({
+        type,
+        tags: [],
+    }));
+    return true;
+};
+
+export { iterate_metadata_alias };
+//# sourceMappingURL=iterate_metadata_alias.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_alias.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_alias.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_array.mjs

@@ -0,0 +1,51 @@
+import { MetadataArray } from '../../../schemas/metadata/MetadataArray.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { emplace_metadata_array_type } from './emplace_metadata_array_type.mjs';
+
+const iterate_metadata_array = (props) => {
+    const array = props.checker.isArrayType(props.type) === false
+        ? find_array_extended({
+            checker: props.checker,
+            memory: new Map(),
+            type: props.type,
+        })
+        : props.type;
+    if (array === null)
+        return false;
+    const arrayType = emplace_metadata_array_type({
+        ...props,
+        array,
+    });
+    ArrayUtil.add(props.metadata.arrays, MetadataArray.create({
+        type: arrayType,
+        tags: [],
+    }), (elem) => elem.type.name === arrayType.name);
+    return true;
+};
+const find_array_extended = (props) => {
+    const cached = props.memory.get(props.type);
+    if (cached !== undefined)
+        return null;
+    props.memory.set(props.type, null);
+    const res = (() => {
+        if (props.type.isClassOrInterface() === false)
+            return null;
+        for (const t of props.type.resolvedBaseTypes ?? [])
+            if (props.checker.isArrayType(t))
+                return t;
+            else {
+                const res = find_array_extended({
+                    ...props,
+                    type: t,
+                });
+                if (res !== null)
+                    return res;
+            }
+        return null;
+    })();
+    props.memory.set(props.type, res);
+    return res;
+};
+
+export { iterate_metadata_array };
+//# sourceMappingURL=iterate_metadata_array.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_array.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_atomic.mjs

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+import { MetadataAtomic } from '../../../schemas/metadata/MetadataAtomic.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+
+const same = (type) => {
+    if (type === null)
+        return () => false;
+    return (flag) => (type.getFlags() & flag) !== 0;
+};
+const iterate_metadata_atomic = (props) => {
+    // PREPARE INTERNAL FUNCTIONS
+    const filter = same(props.type);
+    const check = (info) => {
+        if (filter(info.atomic) || filter(info.literal)) {
+            ArrayUtil.add(props.metadata.atomics, MetadataAtomic.create({ type: info.name, tags: [] }), (x, y) => x.type === y.type);
+            return true;
+        }
+        return false;
+    };
+    // CHECK EACH TYPES
+    return ATOMICS.some((info) => check(info));
+};
+const ATOMICS = [
+    {
+        name: "boolean",
+        atomic: ts.TypeFlags.BooleanLike,
+        literal: ts.TypeFlags.BooleanLiteral,
+    },
+    {
+        name: "number",
+        atomic: ts.TypeFlags.NumberLike,
+        literal: ts.TypeFlags.NumberLiteral,
+    },
+    {
+        name: "bigint",
+        atomic: ts.TypeFlags.BigInt,
+        literal: ts.TypeFlags.BigIntLiteral,
+    },
+    {
+        name: "string",
+        atomic: ts.TypeFlags.StringLike,
+        literal: ts.TypeFlags.StringLiteral,
+    },
+];
+
+export { iterate_metadata_atomic };
+//# sourceMappingURL=iterate_metadata_atomic.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_atomic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_atomic.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_coalesce.mjs

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { Writable } from '../../../typings/Writable.mjs';
+
+const iterate_metadata_coalesce = (props) => {
+    const filter = (flag) => (props.type.getFlags() & flag) !== 0;
+    if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
+        Writable(props.metadata).any = true;
+        return true;
+    }
+    else if (filter(ts.TypeFlags.Null)) {
+        Writable(props.metadata).nullable = true;
+        return true;
+    }
+    else if (filter(ts.TypeFlags.Undefined) ||
+        filter(ts.TypeFlags.Never) ||
+        filter(ts.TypeFlags.Void) ||
+        filter(ts.TypeFlags.VoidLike)) {
+        Writable(props.metadata).required = false;
+        return true;
+    }
+    return false;
+};
+
+export { iterate_metadata_coalesce };
+//# sourceMappingURL=iterate_metadata_coalesce.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_coalesce.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_coalesce.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_collection.mjs

@@ -0,0 +1,87 @@
+import { iterate_metadata_comment_tags } from './iterate_metadata_comment_tags.mjs';
+
+const iterate_metadata_collection = (props) => {
+    for (const array of props.collection.arrays())
+        if (array.recursive === null)
+            props.collection.setArrayRecursive(array, isArrayRecursive({
+                visited: new Set(),
+                array,
+                metadata: array.value,
+            }));
+    for (const tuple of props.collection.tuples())
+        if (tuple.recursive === null) {
+            const visited = new Set();
+            props.collection.setTupleRecursive(tuple, tuple.elements.some((e) => isTupleRecursive({
+                visited,
+                tuple,
+                metadata: e,
+            })));
+        }
+    for (const object of props.collection.objects()) {
+        iterate_metadata_comment_tags({
+            errors: props.errors,
+            object,
+        });
+        if (object.recursive === null) {
+            const visited = new Set();
+            props.collection.setObjectRecursive(object, object.properties.some((p) => isObjectRecursive({
+                visited,
+                object,
+                metadata: p.value,
+            })));
+        }
+    }
+};
+const isArrayRecursive = (props) => {
+    if (props.visited.has(props.metadata))
+        return false;
+    props.visited.add(props.metadata);
+    const next = (metadata) => isArrayRecursive({
+        ...props,
+        metadata,
+    });
+    return (props.metadata.arrays.some((a) => a.type === props.array || next(a.type.value)) ||
+        props.metadata.aliases.some((alias) => next(alias.type.value)) ||
+        props.metadata.tuples.some((t) => !t.type.recursive && t.type.elements.some(next)) ||
+        props.metadata.maps.some((m) => next(m.value)) ||
+        props.metadata.sets.some((s) => next(s.value)) ||
+        (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+        (props.metadata.rest !== null && next(props.metadata.rest)));
+};
+const isTupleRecursive = (props) => {
+    if (props.visited.has(props.metadata))
+        return false;
+    props.visited.add(props.metadata);
+    const next = (metadata) => isTupleRecursive({
+        ...props,
+        metadata,
+    });
+    return (props.metadata.tuples.some((t) => t.type === props.tuple || t.type.elements.some(next)) ||
+        props.metadata.arrays.some((a) => !a.type.recursive && next(a.type.value)) ||
+        props.metadata.maps.some((m) => next(m.value)) ||
+        props.metadata.sets.some((s) => next(s.value)) ||
+        props.metadata.aliases.some((alias) => next(alias.type.value)) ||
+        (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+        (props.metadata.rest !== null && next(props.metadata.rest)));
+};
+const isObjectRecursive = (props) => {
+    if (props.visited.has(props.metadata))
+        return false;
+    props.visited.add(props.metadata);
+    const next = (metadata) => isObjectRecursive({
+        ...props,
+        metadata,
+    });
+    return (props.metadata.objects.some((o) => props.object === o.type ||
+        o.type.properties.some((prop) => next(prop.value))) ||
+        props.metadata.aliases.some((alias) => next(alias.type.value)) ||
+        props.metadata.arrays.some((array) => !array.type.recursive && next(array.type.value)) ||
+        props.metadata.tuples.some((tuple) => !tuple.type.recursive && tuple.type.elements.some(next)) ||
+        props.metadata.maps.some((map) => next(map.value)) ||
+        props.metadata.sets.some((set) => next(set.value)) ||
+        (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
+        (props.metadata.rest !== null && next(props.metadata.rest)));
+};
+
+export { iterate_metadata_collection };
+//# sourceMappingURL=iterate_metadata_collection.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_collection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_collection.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_comment_tags.mjs

@@ -0,0 +1,29 @@
+import { MetadataCommentTagFactory } from '../../MetadataCommentTagFactory.mjs';
+
+const iterate_metadata_comment_tags = (props) => {
+    if (props.object.tagged_ === true)
+        return;
+    props.object.tagged_ = true;
+    for (const property of props.object.properties) {
+        MetadataCommentTagFactory.analyze({
+            errors: props.errors,
+            metadata: property.value,
+            tags: property.jsDocTags,
+            explore: {
+                top: false,
+                object: props.object,
+                property: property.key.isSoleLiteral()
+                    ? property.key.getSoleLiteral()
+                    : {},
+                parameter: null,
+                nested: null,
+                aliased: false,
+                escaped: false,
+                output: false,
+            },
+        });
+    }
+};
+
+export { iterate_metadata_comment_tags };
+//# sourceMappingURL=iterate_metadata_comment_tags.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_comment_tags.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_comment_tags.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_constant.mjs

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import { MetadataConstant } from '../../../schemas/metadata/MetadataConstant.mjs';
+import { MetadataConstantValue } from '../../../schemas/metadata/MetadataConstantValue.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { CommentFactory } from '../../CommentFactory.mjs';
+
+const iterate_metadata_constant = (props) => {
+    if (!props.options.constant)
+        return false;
+    const filter = (flag) => (props.type.getFlags() & flag) !== 0;
+    const comment = () => {
+        if (!filter(ts.TypeFlags.EnumLiteral))
+            return {};
+        return {
+            jsDocTags: props.type.symbol?.getJsDocTags(),
+            description: props.type.symbol
+                ? (CommentFactory.description(props.type.symbol) ?? null)
+                : undefined,
+        };
+    };
+    if (props.type.isLiteral()) {
+        const value = typeof props.type.value === "object"
+            ? BigInt(`${props.type.value.negative ? "-" : ""}${props.type.value.base10Value}`)
+            : props.type.value;
+        const constant = ArrayUtil.take(props.metadata.constants, (elem) => elem.type === typeof value, () => MetadataConstant.create({
+            type: typeof value,
+            values: [],
+        }));
+        ArrayUtil.add(constant.values, MetadataConstantValue.create({
+            value,
+            tags: [],
+            ...comment(),
+        }), (a, b) => a.value === b.value);
+        return true;
+    }
+    else if (filter(ts.TypeFlags.BooleanLiteral)) {
+        comment();
+        const value = props.checker.typeToString(props.type) === "true";
+        const constant = ArrayUtil.take(props.metadata.constants, (elem) => elem.type === "boolean", () => MetadataConstant.create({
+            type: "boolean",
+            values: [],
+        }));
+        ArrayUtil.add(constant.values, MetadataConstantValue.create({
+            value,
+            tags: [],
+            ...comment(),
+        }), (a, b) => a.value === b.value);
+        return true;
+    }
+    return false;
+};
+
+export { iterate_metadata_constant };
+//# sourceMappingURL=iterate_metadata_constant.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_constant.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_constant.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_escape.mjs

@@ -0,0 +1,44 @@
+import { Metadata } from '../../../schemas/metadata/Metadata.mjs';
+import { MetadataEscaped } from '../../../schemas/metadata/MetadataEscaped.mjs';
+import { Writable } from '../../../typings/Writable.mjs';
+import { TypeFactory } from '../../TypeFactory.mjs';
+import { iterate_metadata } from './iterate_metadata.mjs';
+
+const iterate_metadata_escape = (props) => {
+    if (props.options.escape === false || props.explore.escaped === true)
+        return false;
+    const escaped = TypeFactory.getReturnTypeOfClassMethod({
+        checker: props.checker,
+        class: props.type,
+        function: "toJSON",
+    });
+    if (escaped === null)
+        return false;
+    if (props.metadata.escaped === null) {
+        Writable(props.metadata).escaped = MetadataEscaped.create({
+            original: Metadata.initialize(),
+            returns: Metadata.initialize(),
+        });
+    }
+    iterate_metadata({
+        ...props,
+        metadata: props.metadata.escaped.original,
+        explore: {
+            ...props.explore,
+            escaped: true,
+        },
+    });
+    iterate_metadata({
+        ...props,
+        metadata: props.metadata.escaped.returns,
+        type: escaped,
+        explore: {
+            ...props.explore,
+            escaped: true,
+        },
+    });
+    return true;
+};
+
+export { iterate_metadata_escape };
+//# sourceMappingURL=iterate_metadata_escape.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_escape.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_escape.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_function.mjs

@@ -0,0 +1,76 @@
+import { FunctionalGeneralProgrammer } from '../../../programmers/functional/internal/FunctionalGeneralProgrammer.mjs';
+import { Metadata } from '../../../schemas/metadata/Metadata.mjs';
+import { MetadataFunction } from '../../../schemas/metadata/MetadataFunction.mjs';
+import { MetadataParameter } from '../../../schemas/metadata/MetadataParameter.mjs';
+import { CommentFactory } from '../../CommentFactory.mjs';
+import { TypeFactory } from '../../TypeFactory.mjs';
+import { explore_metadata } from './explore_metadata.mjs';
+
+const iterate_metadata_function = (props) => {
+    const declaration = TypeFactory.getFunction(props.type);
+    if (declaration === null)
+        return false;
+    else if (!props.options.functional) {
+        if (props.metadata.functions.length === 0)
+            props.metadata.functions.push(MetadataFunction.create({
+                parameters: [],
+                output: Metadata.initialize(),
+                async: false,
+            }));
+    }
+    else {
+        const [signature] = props.type.getCallSignatures();
+        if (signature === undefined || signature.declaration === undefined)
+            props.metadata.functions.push(MetadataFunction.create({
+                parameters: [],
+                output: Metadata.initialize(),
+                async: false,
+            }));
+        else {
+            const { async } = FunctionalGeneralProgrammer.getReturnType({
+                checker: props.checker,
+                declaration,
+            });
+            props.metadata.functions.push(MetadataFunction.create({
+                parameters: signature.parameters.map((p) => MetadataParameter.create({
+                    name: p.name,
+                    type: explore_metadata({
+                        ...props,
+                        type: props.checker.getTypeOfSymbol(p),
+                        explore: {
+                            ...props.explore,
+                            top: false,
+                            parameter: p.name,
+                        },
+                        intersected: false,
+                    }),
+                    tsType: props.checker.getTypeOfSymbol(p),
+                    description: CommentFactory.description(p) ?? null,
+                    jsDocTags: p?.getJsDocTags() ?? [],
+                })),
+                async,
+                output: explore_metadata({
+                    ...props,
+                    options: {
+                        ...props.options,
+                        functional: false,
+                    },
+                    type: async
+                        ? (props.checker.getTypeArguments(signature.getReturnType())?.[0] ??
+                            props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
+                        : signature.getReturnType(),
+                    explore: {
+                        ...props.explore,
+                        top: false,
+                        output: true,
+                    },
+                    intersected: false,
+                }),
+            }));
+        }
+    }
+    return true;
+};
+
+export { iterate_metadata_function };
+//# sourceMappingURL=iterate_metadata_function.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_function.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_function.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}