typia 8.0.0 → 8.0.1

package/lib/factories/MetadataFactory.mjs

@@ -0,0 +1,291 @@
+import ts from 'typescript';
+import { Metadata } from '../schemas/metadata/Metadata.mjs';
+import { MetadataConstant } from '../schemas/metadata/MetadataConstant.mjs';
+import { MetadataObject } from '../schemas/metadata/MetadataObject.mjs';
+import { explore_metadata } from './internal/metadata/explore_metadata.mjs';
+import { iterate_metadata_collection } from './internal/metadata/iterate_metadata_collection.mjs';
+import { iterate_metadata_sort } from './internal/metadata/iterate_metadata_sort.mjs';
+import { ExpressionFactory } from './ExpressionFactory.mjs';
+
+var MetadataFactory;
+(function (MetadataFactory) {
+    MetadataFactory.analyze = (props) => {
+        const errors = [];
+        const metadata = explore_metadata({
+            ...props,
+            errors,
+            explore: {
+                top: true,
+                object: null,
+                property: null,
+                parameter: null,
+                nested: null,
+                aliased: false,
+                escaped: false,
+                output: false,
+            },
+            intersected: false,
+        });
+        iterate_metadata_collection({
+            errors,
+            collection: props.collection,
+        });
+        iterate_metadata_sort({
+            collection: props.collection,
+            metadata: metadata,
+        });
+        if (props.options.validate)
+            errors.push(...MetadataFactory.validate({
+                transformer: props.transformer,
+                options: props.options,
+                functor: props.options.validate,
+                metadata,
+            }));
+        return errors.length
+            ? {
+                success: false,
+                errors,
+            }
+            : {
+                success: true,
+                data: metadata,
+            };
+    };
+    /**
+     * @internal
+     */
+    MetadataFactory.soleLiteral = (value) => {
+        const meta = Metadata.initialize();
+        meta.constants.push(MetadataConstant.from({
+            values: [
+                {
+                    value,
+                    tags: [],
+                },
+            ],
+            type: "string",
+        }));
+        return meta;
+    };
+    MetadataFactory.validate = (props) => {
+        const visitor = {
+            functor: props.functor,
+            errors: [],
+            objects: new Set(),
+            arrays: new Set(),
+            tuples: new Set(),
+            aliases: new Set(),
+            functions: new Set(),
+        };
+        validateMeta({
+            ...props,
+            visitor,
+            explore: {
+                object: null,
+                property: null,
+                parameter: null,
+                nested: null,
+                top: true,
+                aliased: false,
+                escaped: false,
+                output: false,
+            },
+        });
+        return visitor.errors;
+    };
+    const validateMeta = (props) => {
+        const result = [];
+        for (const atomic of props.metadata.atomics)
+            for (const row of atomic.tags)
+                for (const tag of row.filter((t) => t.validate !== undefined && t.predicate === undefined))
+                    try {
+                        tag.predicate = ExpressionFactory.transpile({
+                            script: tag.validate,
+                        });
+                    }
+                    catch {
+                        result.push(`Unable to transpile type tag script: ${JSON.stringify(tag.validate)}`);
+                        tag.predicate = () => ts.factory.createTrue();
+                    }
+        result.push(...props.visitor.functor(props.metadata, props.explore));
+        if (result.length)
+            props.visitor.errors.push({
+                name: props.metadata.getName(),
+                explore: { ...props.explore },
+                messages: [...new Set(result)],
+            });
+        for (const alias of props.metadata.aliases)
+            validateAlias({
+                ...props,
+                alias: alias.type,
+            });
+        for (const array of props.metadata.arrays)
+            validateArray({
+                ...props,
+                array: array.type,
+            });
+        for (const tuple of props.metadata.tuples)
+            validateTuple({
+                ...props,
+                tuple: tuple.type,
+            });
+        for (const object of props.metadata.objects)
+            validateObject({
+                ...props,
+                object: object.type,
+            });
+        for (const func of props.metadata.functions)
+            validateFunction({
+                ...props,
+                function: func,
+            });
+        for (const set of props.metadata.sets)
+            validateMeta({
+                ...props,
+                metadata: set.value,
+            });
+        for (const map of props.metadata.maps) {
+            validateMeta({
+                ...props,
+                metadata: map.key,
+            });
+            validateMeta({
+                ...props,
+                metadata: map.value,
+            });
+        }
+        if (props.options.escape === true && props.metadata.escaped !== null)
+            validateMeta({
+                ...props,
+                metadata: props.metadata.escaped.returns,
+                explore: {
+                    ...props.explore,
+                    escaped: true,
+                },
+            });
+    };
+    const validateAlias = (props) => {
+        if (props.visitor.aliases.has(props.alias))
+            return;
+        props.visitor.aliases.add(props.alias);
+        validateMeta({
+            ...props,
+            metadata: props.alias.value,
+            explore: {
+                ...props.explore,
+                nested: props.alias,
+                aliased: true,
+            },
+        });
+    };
+    const validateArray = (props) => {
+        if (props.visitor.arrays.has(props.array))
+            return;
+        props.visitor.arrays.add(props.array);
+        validateMeta({
+            ...props,
+            metadata: props.array.value,
+            explore: {
+                ...props.explore,
+                nested: props.array,
+                top: false,
+            },
+        });
+    };
+    const validateTuple = (props) => {
+        if (props.visitor.tuples.has(props.tuple))
+            return;
+        props.visitor.tuples.add(props.tuple);
+        for (const elem of props.tuple.elements)
+            validateMeta({
+                ...props,
+                metadata: elem,
+                explore: {
+                    ...props.explore,
+                    nested: props.tuple,
+                    top: false,
+                },
+            });
+    };
+    const validateObject = (props) => {
+        if (props.visitor.objects.has(props.object))
+            return;
+        props.visitor.objects.add(props.object);
+        if (props.options.validate) {
+            const explore = {
+                object: props.object,
+                top: false,
+                property: null,
+                parameter: null,
+                nested: null,
+                aliased: false,
+                escaped: false,
+                output: false,
+            };
+            const errors = props.options.validate(Metadata.create({
+                ...Metadata.initialize(),
+                objects: [
+                    MetadataObject.create({
+                        type: props.object,
+                        tags: [],
+                    }),
+                ],
+            }), explore);
+            if (errors.length)
+                props.visitor.errors.push({
+                    name: props.object.name,
+                    explore,
+                    messages: [...new Set(errors)],
+                });
+        }
+        for (const property of props.object.properties)
+            validateMeta({
+                ...props,
+                metadata: property.value,
+                explore: {
+                    object: props.object,
+                    property: property.key.isSoleLiteral()
+                        ? property.key.getSoleLiteral()
+                        : {},
+                    parameter: null,
+                    nested: null,
+                    top: false,
+                    aliased: false,
+                    escaped: false,
+                    output: false,
+                },
+            });
+    };
+    const validateFunction = (props) => {
+        if (props.visitor.functions.has(props.function))
+            return;
+        props.visitor.functions.add(props.function);
+        for (const param of props.function.parameters)
+            validateMeta({
+                ...props,
+                metadata: param.type,
+                explore: {
+                    ...props.explore,
+                    parameter: param.name,
+                    nested: null,
+                    top: false,
+                    output: false,
+                },
+            });
+        if (props.function.output)
+            validateMeta({
+                ...props,
+                metadata: props.function.output,
+                explore: {
+                    ...props.explore,
+                    parameter: null,
+                    nested: null,
+                    top: false,
+                    output: true,
+                },
+            });
+    };
+})(MetadataFactory || (MetadataFactory = {}));
+
+export { MetadataFactory };
+//# sourceMappingURL=MetadataFactory.mjs.map

package/lib/factories/MetadataFactory.mjs.map

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

package/lib/factories/MetadataTypeTagFactory.mjs

@@ -0,0 +1,316 @@
+import { MetadataTypeTagSchemaFactory } from './MetadataTypeTagSchemaFactory.mjs';
+
+var MetadataTypeTagFactory;
+(function (MetadataTypeTagFactory) {
+    MetadataTypeTagFactory.is = (obj) => {
+        if (obj.properties.length !== 1)
+            return false;
+        const top = obj.properties[0];
+        if (top.key.isSoleLiteral() === false)
+            return false;
+        else if (top.key.getSoleLiteral() !== "typia.tag")
+            return false;
+        const value = top.value;
+        if (value.size() !== 1 ||
+            value.objects.length !== 1 ||
+            value.isRequired() === true ||
+            value.nullable === true)
+            return false;
+        const tag = top.value.objects[0].type;
+        const statics = tag.properties
+            .map((p) => p.key.getSoleLiteral())
+            .filter((str) => str !== null);
+        if (ESSENTIAL_FIELDS.some((f) => !statics.includes(f)))
+            return false;
+        return true;
+    };
+    MetadataTypeTagFactory.analyze = (props) => {
+        const messages = [];
+        const report = (next) => {
+            messages.push(`the property ${next.property === null
+                ? `["typia.tag"]`
+                : `["typia.tag.${next.property}"]`} ${next.message}.`);
+            return false;
+        };
+        //----
+        // VALIDATION PROCESS
+        //----
+        const filtered = props.objects.filter((obj) => {
+            // ONLY ONE PROPERTY
+            if (obj.properties.length !== 1)
+                return false;
+            // THE TAG.TYPE PROPERTY MUST BE
+            const top = 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)
+                return report({
+                    property: null,
+                    message: "must be optional object",
+                });
+            // CHECK LIST OF PROPERTIES
+            const tag = top.value.objects[0].type;
+            const statistics = tag.properties
+                .map((p) => p.key.getSoleLiteral())
+                .filter((str) => str !== null);
+            if (ESSENTIAL_FIELDS.some((f) => !statistics.includes(f)))
+                return report({
+                    property: null,
+                    message: `must have at least three properties - ${ESSENTIAL_FIELDS.map((str) => `'${str}'`).join(", ")}`,
+                });
+            const each = tag.properties.map((p) => {
+                const key = p.key.getSoleLiteral();
+                if (key === null)
+                    return true;
+                else if (FIELDS.includes(key) === false)
+                    return true;
+                return validate_property({
+                    report,
+                    key,
+                    value: p.value,
+                });
+            });
+            return each.every((v) => v === true);
+        });
+        if (filtered.length === 0)
+            return [];
+        //----
+        // CONSTRUCT TYPE TAGS
+        //----
+        // CREATE 1ST
+        const tagList = filtered.map((object) => create_metadata_type_tag({
+            report,
+            object,
+        }));
+        const output = [];
+        for (const tag of tagList)
+            if (tag !== null)
+                output.push({
+                    target: tag.target.some((str) => str === props.type)
+                        ? props.type
+                        : null,
+                    name: tag.name,
+                    kind: tag.kind,
+                    value: tag.value,
+                    validate: tag.validate[props.type],
+                    exclusive: tag.exclusive,
+                    schema: tag.schema,
+                });
+        MetadataTypeTagFactory.validate({
+            report,
+            type: props.type,
+            tags: output,
+        });
+        if (messages.length > 0) {
+            props.errors.push({
+                name: [props.type, ...props.objects.map((o) => o.name)].join(" & "),
+                explore: props.explore,
+                messages,
+            });
+            return [];
+        }
+        return output;
+    };
+    MetadataTypeTagFactory.validate = (props) => {
+        let success = true;
+        for (const tag of props.tags)
+            if (tag.target !== props.type) {
+                success &&= props.report({
+                    property: null,
+                    message: `target must contain ${props.type} type`,
+                });
+            }
+        props.tags.forEach((tag, i) => {
+            if (tag.exclusive === false)
+                return;
+            else if (tag.exclusive === true) {
+                const some = props.tags.some((opposite, j) => i !== j && opposite.kind === tag.kind);
+                if (some === true)
+                    success &&= props.report({
+                        property: null,
+                        message: `kind '${tag.kind}' can't be duplicated`,
+                    });
+            }
+            else if (Array.isArray(tag.exclusive)) {
+                const some = props.tags.find((opposite, j) => i !== j &&
+                    opposite.kind === tag.kind &&
+                    tag.exclusive.includes(opposite.name));
+                if (some !== undefined)
+                    success ??= props.report({
+                        property: null,
+                        message: `kind '${tag.kind}' can't be used with '${some.name}'`,
+                    });
+            }
+        });
+        return success;
+    };
+    const validate_property = (props) => {
+        if (
+        // TARGET
+        props.key === "target" &&
+            (props.value.constants.length !== 1 ||
+                props.value.constants[0].values.length !== props.value.size() ||
+                props.value.constants[0].values.some((v) => v.value !== "boolean" &&
+                    v.value !== "bigint" &&
+                    v.value !== "number" &&
+                    v.value !== "string" &&
+                    v.value !== "array" &&
+                    v.value !== "object")))
+            return props.report({
+                property: props.key,
+                message: `must be one of 'boolean', 'bigint', 'number', 'string', 'array', 'object'`,
+            });
+        else if (
+        // KIND
+        props.key === "kind" &&
+            (props.value.size() !== 1 ||
+                props.value.constants.length !== 1 ||
+                props.value.constants[0].type !== "string" ||
+                props.value.constants[0].values.length !== 1))
+            return props.report({
+                property: props.key,
+                message: "must be a string literal type",
+            });
+        else if (
+        // VALUE
+        props.key === "value" &&
+            !((props.value.size() === 0 && props.value.isRequired() === false) ||
+                (props.value.size() === 1 &&
+                    (props.value.objects.length === 1 ||
+                        props.value.constants.length === 1))))
+            return props.report({
+                property: props.key,
+                message: "must be a literal type or undefined value",
+            });
+        else if (props.key === "exclusive")
+            return get_exclusive(props) !== null;
+        else if (props.key === "validate") {
+            //----
+            // VALIDATE
+            //----
+            // UNDEFINED CASE
+            if (props.value.size() === 0 &&
+                props.value.isRequired() === false &&
+                props.value.nullable === false)
+                return true;
+            // STRING CASE
+            if (props.value.size() === 1 &&
+                props.value.constants.length === 1 &&
+                props.value.constants[0].type === "string" &&
+                (props.value.constants[0].values.length === 1) === true)
+                return true;
+            // RECORD<TARGET, STRING>
+            const target = props.value.objects[0]?.type.properties
+                .map((p) => p.key.getSoleLiteral())
+                .filter((str) => str !== null);
+            if (target === undefined)
+                return props.report({
+                    property: "target",
+                    message: `must be one of 'boolean', 'bigint', 'number', 'string', 'array', 'object`,
+                });
+            const variadic = props.value.size() === 1 &&
+                props.value.objects.length === 1 &&
+                props.value.objects[0].type.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)
+                return props.report({
+                    property: props.key,
+                    message: `must be a string literal type or Record<Target, string> type.`,
+                });
+        }
+        return true;
+    };
+    const create_metadata_type_tag = (props) => {
+        const find = (key) => props.object.properties[0]?.value.objects[0]?.type.properties.find((p) => p.key.getSoleLiteral() === key);
+        const target = find("target").value.constants[0].values.map((v) => v.value);
+        const kind = find("kind").value.constants[0].values[0]
+            .value;
+        const value = find("value")?.value.constants[0]?.values[0].value;
+        const exclusive = get_exclusive({
+            report: props.report,
+            key: "exclusive",
+            value: find("exclusive")?.value,
+        });
+        if (exclusive === null)
+            return null;
+        const validate = (() => {
+            const validate = find("validate")?.value;
+            if (!validate || validate.size() === 0)
+                return {};
+            else if (validate.constants.length)
+                return Object.fromEntries(target.map((t) => [
+                    t,
+                    validate.constants[0].values[0].value,
+                ]));
+            return Object.fromEntries(validate.objects[0].type.properties.map((p) => [
+                p.key.getSoleLiteral(),
+                p.value.constants[0].values[0].value,
+            ]));
+        })();
+        const schema = (() => {
+            const p = find("schema")?.value;
+            if (p === undefined)
+                return undefined;
+            else if (p.size() === 0 && p.isRequired() === false)
+                return undefined;
+            else if (p.size() === 1 &&
+                p.nullable === false &&
+                p.isRequired() === true &&
+                p.any === false)
+                return MetadataTypeTagSchemaFactory.object({
+                    report: (message) => props.report({
+                        property: "schema",
+                        message,
+                    }),
+                    object: p.objects[0].type,
+                });
+            props.report({
+                property: "schema",
+                message: "must be an object type",
+            });
+            return undefined;
+        })();
+        return {
+            name: props.object.name,
+            target,
+            kind,
+            value,
+            validate,
+            exclusive: exclusive ?? false,
+            schema,
+        };
+    };
+    const get_exclusive = (props) => {
+        if (props.value === undefined)
+            return false;
+        else if (props.value.size() === 1 &&
+            props.value.constants.length === 1 &&
+            props.value.constants[0].type === "boolean" &&
+            props.value.constants[0].values.length === 1)
+            return props.value.constants[0].values[0].value;
+        else if (props.value.size() === 1 &&
+            props.value.tuples.length === 1 &&
+            props.value.tuples[0].type.elements.every((elem) => elem.size() === 1 &&
+                elem.constants.length === 1 &&
+                elem.constants[0].type === "string" &&
+                elem.constants[0].values.length === 1))
+            return props.value.tuples[0].type.elements.map((elem) => elem.constants[0].values[0].value);
+        props.report({
+            property: props.key,
+            message: "must a boolean literal type or a tuple of string literal types.",
+        });
+        return null;
+    };
+})(MetadataTypeTagFactory || (MetadataTypeTagFactory = {}));
+const ESSENTIAL_FIELDS = ["target", "kind", "value"];
+const FIELDS = [...ESSENTIAL_FIELDS, "validate", "exclusive"];
+
+export { MetadataTypeTagFactory };
+//# sourceMappingURL=MetadataTypeTagFactory.mjs.map

package/lib/factories/MetadataTypeTagFactory.mjs.map

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

package/lib/factories/MetadataTypeTagSchemaFactory.mjs

@@ -0,0 +1,68 @@
+var MetadataTypeTagSchemaFactory;
+(function (MetadataTypeTagSchemaFactory) {
+    MetadataTypeTagSchemaFactory.object = (props) => {
+        if (props.object.recursive) {
+            props.report(`${props.object.name} has recursive type`);
+            return undefined;
+        }
+        const output = {};
+        for (const p of props.object.properties) {
+            const key = p.key.getSoleLiteral();
+            if (key === null) {
+                props.report(`${props.object.name} has non-literal key type: ${p.key.getName()}`);
+                continue;
+            }
+            output[key] = iterate({
+                report: props.report,
+                object: props.object,
+                key,
+                metadata: p.value,
+            });
+        }
+        return output;
+    };
+    const iterate = (props) => {
+        if (props.metadata.any ||
+            props.metadata.atomics.length ||
+            props.metadata.arrays.length ||
+            props.metadata.natives.length ||
+            props.metadata.functions.length)
+            props.report(`${props.object.name}.${props.key} has non-literal type`);
+        else if (props.metadata.size() > 1)
+            props.report(`${props.object.name}.${props.key} has union type`);
+        else if (props.metadata.size() === 0)
+            if (props.metadata.nullable)
+                return null;
+            else if (props.metadata.isRequired() === true)
+                props.report(`${props.object.name}.${props.key} has non-literal type`);
+            else
+                return undefined;
+        else if (props.metadata.constants.length)
+            return props.metadata.constants[0].values[0].value;
+        else if (props.metadata.tuples.length) {
+            const tuple = props.metadata.tuples[0];
+            if (tuple.type.isRest())
+                props.report(`${props.object.name}.${props.key} has rest tuple type`);
+            else if (tuple.type.recursive)
+                props.report(`${props.object.name}.${props.key} has recursive tuple type`);
+            else if (tuple.type.elements.some((e) => e.required === false))
+                props.report(`${props.object.name}.${props.key} has optional tuple type`);
+            return tuple.type.elements.map((elem) => iterate({
+                report: props.report,
+                object: props.object,
+                key: props.key,
+                metadata: elem,
+            }));
+        }
+        else if (props.metadata.objects.length)
+            return MetadataTypeTagSchemaFactory.object({
+                report: props.report,
+                object: props.metadata.objects[0].type,
+            });
+        else
+            props.report(`${props.object.name}.${props.key} has non-literal type`);
+    };
+})(MetadataTypeTagSchemaFactory || (MetadataTypeTagSchemaFactory = {}));
+
+export { MetadataTypeTagSchemaFactory };
+//# sourceMappingURL=MetadataTypeTagSchemaFactory.mjs.map

package/lib/factories/MetadataTypeTagSchemaFactory.mjs.map

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