typia 8.0.0 → 8.0.1

package/lib/programmers/helpers/UnionPredicator.mjs

@@ -0,0 +1,62 @@
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { ArrayUtil } from '../../utils/ArrayUtil.mjs';
+import { MapUtil } from '../../utils/MapUtil.mjs';
+
+var UnionPredicator;
+(function (UnionPredicator) {
+    UnionPredicator.object = (objects) => {
+        // PROPERTY MATRIX
+        const matrix = new Map();
+        for (const obj of objects)
+            for (const prop of obj.properties) {
+                const key = prop.key.getSoleLiteral();
+                if (key !== null)
+                    MapUtil.take(matrix, key, () => ArrayUtil.repeat(objects.length, () => null));
+            }
+        objects.forEach((obj, i) => {
+            for (const prop of obj.properties) {
+                const key = prop.key.getSoleLiteral();
+                if (key !== null)
+                    matrix.get(key)[i] = prop;
+            }
+        });
+        // EXPLORE SPECIALIZERS
+        const output = [];
+        objects.forEach((obj, i) => {
+            const children = [];
+            obj.properties.forEach((prop) => {
+                // MUST BE REQUIRED
+                if (prop.value.isRequired() === false)
+                    return;
+                const key = prop.key.getSoleLiteral();
+                if (key === null)
+                    return;
+                // FIND NEIGHBORHOOD PROPERTIES
+                const neighbors = matrix
+                    .get(key)
+                    .filter((oppo, k) => i !== k && oppo !== null);
+                // NO NEIGHBORHOOD
+                const unique = neighbors.length === 0 ||
+                    neighbors.every((n) => !Metadata.intersects(prop.value, n.value));
+                if (unique === true)
+                    children.push({
+                        property: prop,
+                        neighbor: neighbors.length !== 0,
+                    });
+            });
+            if (children.length === 0)
+                return;
+            const top = children.find((child) => child.property.value.isConstant()) ||
+                children[0];
+            output.push({
+                index: i,
+                object: obj,
+                ...top,
+            });
+        });
+        return output;
+    };
+})(UnionPredicator || (UnionPredicator = {}));
+
+export { UnionPredicator };
+//# sourceMappingURL=UnionPredicator.mjs.map

package/lib/programmers/helpers/UnionPredicator.mjs.map

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

package/lib/programmers/helpers/disable_function_programmer_declare.mjs

@@ -0,0 +1,14 @@
+const disable_function_programmer_declare = (functor) => disable(functor);
+const disable = (functor) => ({
+    method: functor.method,
+    useLocal: (name) => functor.useLocal(name),
+    hasLocal: (name) => functor.hasLocal(name),
+    declare: () => [],
+    declareUnions: () => [],
+    increment: () => functor.increment(),
+    emplaceUnion: (prefix, name, factory) => functor.emplaceUnion(prefix, name, factory),
+    emplaceVariable: (key, value) => functor.emplaceVariable(key, value),
+});
+
+export { disable_function_programmer_declare };
+//# sourceMappingURL=disable_function_programmer_declare.mjs.map

package/lib/programmers/helpers/disable_function_programmer_declare.mjs.map

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

package/lib/programmers/http/HttpAssertFormDataProgrammer.mjs

@@ -0,0 +1,73 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { HttpFormDataProgrammer } from './HttpFormDataProgrammer.mjs';
+
+var HttpAssertFormDataProgrammer;
+(function (HttpAssertFormDataProgrammer) {
+    HttpAssertFormDataProgrammer.decompose = (props) => {
+        const assert = AssertProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: true,
+                },
+            },
+            config: {
+                equals: false,
+                guard: false,
+            },
+        });
+        const decode = HttpFormDataProgrammer.decompose(props);
+        return {
+            functions: {
+                ...assert.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...assert.statements,
+                ...decode.statements,
+                StatementFactory.constant({
+                    name: "__assert",
+                    value: assert.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+                AssertProgrammer.Guardian.parameter({
+                    context: props.context,
+                    init: props.init,
+                }),
+            ], decode.arrow.type, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__assert"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+                AssertProgrammer.Guardian.identifier(),
+            ])),
+        };
+    };
+    HttpAssertFormDataProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpAssertFormDataProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpAssertFormDataProgrammer || (HttpAssertFormDataProgrammer = {}));
+
+export { HttpAssertFormDataProgrammer };
+//# sourceMappingURL=HttpAssertFormDataProgrammer.mjs.map

package/lib/programmers/http/HttpAssertFormDataProgrammer.mjs.map

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

package/lib/programmers/http/HttpAssertHeadersProgrammer.mjs

@@ -0,0 +1,73 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { HttpHeadersProgrammer } from './HttpHeadersProgrammer.mjs';
+
+var HttpAssertHeadersProgrammer;
+(function (HttpAssertHeadersProgrammer) {
+    HttpAssertHeadersProgrammer.decompose = (props) => {
+        const assert = AssertProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+                guard: false,
+            },
+        });
+        const decode = HttpHeadersProgrammer.decompose(props);
+        return {
+            functions: {
+                ...assert.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...assert.statements,
+                ...decode.statements,
+                StatementFactory.constant({
+                    name: "__assert",
+                    value: assert.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+                AssertProgrammer.Guardian.parameter({
+                    context: props.context,
+                    init: props.init,
+                }),
+            ], decode.arrow.type, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__assert"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+                AssertProgrammer.Guardian.identifier(),
+            ])),
+        };
+    };
+    HttpAssertHeadersProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpAssertHeadersProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpAssertHeadersProgrammer || (HttpAssertHeadersProgrammer = {}));
+
+export { HttpAssertHeadersProgrammer };
+//# sourceMappingURL=HttpAssertHeadersProgrammer.mjs.map

package/lib/programmers/http/HttpAssertHeadersProgrammer.mjs.map

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

package/lib/programmers/http/HttpAssertQueryProgrammer.mjs

@@ -0,0 +1,74 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { HttpQueryProgrammer } from './HttpQueryProgrammer.mjs';
+
+var HttpAssertQueryProgrammer;
+(function (HttpAssertQueryProgrammer) {
+    HttpAssertQueryProgrammer.decompose = (props) => {
+        const assert = AssertProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+                guard: false,
+            },
+        });
+        const decode = HttpQueryProgrammer.decompose(props);
+        return {
+            functions: {
+                ...assert.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...assert.statements,
+                ...decode.statements,
+                StatementFactory.constant({
+                    name: "__assert",
+                    value: assert.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+                AssertProgrammer.Guardian.parameter({
+                    context: props.context,
+                    init: props.init,
+                }),
+            ], decode.arrow.type, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__assert"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+                AssertProgrammer.Guardian.identifier(),
+            ])),
+        };
+    };
+    HttpAssertQueryProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpAssertQueryProgrammer.decompose({
+            ...props,
+            functor,
+            allowOptional: !!props.allowOptional,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpAssertQueryProgrammer || (HttpAssertQueryProgrammer = {}));
+
+export { HttpAssertQueryProgrammer };
+//# sourceMappingURL=HttpAssertQueryProgrammer.mjs.map

package/lib/programmers/http/HttpAssertQueryProgrammer.mjs.map

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

package/lib/programmers/http/HttpFormDataProgrammer.mjs

@@ -0,0 +1,201 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { MetadataCollection } from '../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { HttpMetadataUtil } from '../helpers/HttpMetadataUtil.mjs';
+
+var HttpFormDataProgrammer;
+(function (HttpFormDataProgrammer) {
+    HttpFormDataProgrammer.decompose = (props) => {
+        // ANALYZE TYPE
+        const collection = new MetadataCollection();
+        const result = MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate: HttpFormDataProgrammer.validate,
+            },
+            collection,
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError.from({
+                code: props.functor.method,
+                errors: result.errors,
+            });
+        // DO TRANSFORM
+        const object = result.data.objects[0].type;
+        const statements = decode_object({
+            context: props.context,
+            object,
+        });
+        return {
+            functions: {},
+            statements: [],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", ts.factory.createTypeReferenceNode("FormData")),
+            ], props.context.importer.type({
+                file: "typia",
+                name: "Resolved",
+                arguments: [
+                    ts.factory.createTypeReferenceNode(props.name ??
+                        TypeFactory.getFullName({
+                            checker: props.context.checker,
+                            type: props.type,
+                        })),
+                ],
+            }), undefined, ts.factory.createBlock(statements, true)),
+        };
+    };
+    HttpFormDataProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpFormDataProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    HttpFormDataProgrammer.validate = (meta, explore) => {
+        const errors = [];
+        const insert = (msg) => errors.push(msg);
+        if (explore.top === true) {
+            // TOP MUST BE ONLY OBJECT
+            if (meta.objects.length !== 1 || meta.bucket() !== 1)
+                insert("only one object type is allowed.");
+            if (meta.nullable === true)
+                insert("formdata parameters cannot be null.");
+            if (meta.isRequired() === false)
+                insert("formdata parameters cannot be undefined.");
+        }
+        else if (explore.nested !== null &&
+            explore.nested instanceof MetadataArrayType) {
+            //----
+            // ARRAY
+            //----
+            const atomics = HttpMetadataUtil.atomics(meta);
+            const expected = meta.atomics.length +
+                meta.templates.length +
+                meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+                meta.natives.filter((native) => native.name === "Blob" || native.name === "File").length;
+            if (atomics.size > 1)
+                insert("union type is not allowed in array.");
+            if (meta.size() !== expected)
+                insert("only atomic, constant or blob (file) types are allowed in array.");
+        }
+        else if (explore.object && explore.property !== null) {
+            //----
+            // COMMON
+            //----
+            // PROPERTY MUST BE SOLE
+            if (typeof explore.property === "object")
+                insert("dynamic property is not allowed.");
+            // DO NOT ALLOW TUPLE TYPE
+            if (meta.tuples.length)
+                insert("tuple type is not allowed.");
+            // DO NOT ALLOW UNION TYPE
+            if (HttpMetadataUtil.isUnion(meta))
+                insert("union type is not allowed.");
+            // DO NOT ALLOW NESTED OBJECT
+            if (meta.objects.length ||
+                meta.sets.length ||
+                meta.maps.length ||
+                meta.natives.filter((native) => native.name !== "Blob" && native.name !== "File").length)
+                insert("nested object type is not allowed.");
+        }
+        return errors;
+    };
+    const decode_object = (props) => {
+        // const input: ts.Identifier = ts.factory.createIdentifier("input");
+        const output = ts.factory.createIdentifier("output");
+        return [
+            StatementFactory.constant({
+                name: "output",
+                value: ts.factory.createObjectLiteralExpression(props.object.properties.map((p) => decode_regular_property({
+                    context: props.context,
+                    property: p,
+                })), true),
+            }),
+            ts.factory.createReturnStatement(ts.factory.createAsExpression(output, TypeFactory.keyword("any"))),
+        ];
+    };
+    const decode_regular_property = (props) => {
+        const key = props.property.key.constants[0].values[0]
+            .value;
+        const value = props.property.value;
+        const [type, isArray] = value
+            .atomics.length
+            ? [value.atomics[0].type, false]
+            : value.constants.length
+                ? [value.constants[0].type, false]
+                : value.templates.length
+                    ? ["string", false]
+                    : value.natives.some((native) => native.name === "Blob")
+                        ? ["blob", false]
+                        : value.natives.some((native) => native.name === "File")
+                            ? ["file", false]
+                            : (() => {
+                                const meta = value.arrays[0]?.type.value ??
+                                    value.tuples[0].type.elements[0];
+                                return meta.atomics.length
+                                    ? [meta.atomics[0].type, true]
+                                    : meta.templates.length
+                                        ? ["string", true]
+                                        : meta.natives.some((native) => native.name === "Blob")
+                                            ? ["blob", true]
+                                            : meta.natives.some((native) => native.name === "File")
+                                                ? ["file", true]
+                                                : [meta.constants[0].type, true];
+                            })();
+        return ts.factory.createPropertyAssignment(Escaper.variable(key) ? key : ts.factory.createStringLiteral(key), isArray
+            ? decode_array({
+                context: props.context,
+                metadata: value,
+                input: ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("input.getAll"), undefined, [ts.factory.createStringLiteral(key)]), "map"), undefined, [
+                    ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("elem")], undefined, undefined, decode_value({
+                        context: props.context,
+                        type,
+                        coalesce: false,
+                        input: ts.factory.createIdentifier("elem"),
+                    })),
+                ]),
+            })
+            : decode_value({
+                context: props.context,
+                type,
+                coalesce: value.nullable === false && value.isRequired() === false,
+                input: ts.factory.createCallExpression(ts.factory.createIdentifier("input.get"), undefined, [ts.factory.createStringLiteral(key)]),
+            }));
+    };
+    const decode_value = (props) => {
+        const call = ts.factory.createCallExpression(props.context.importer.internal(`httpFormDataRead${StringUtil.capitalize(props.type)}`), undefined, [props.input]);
+        return props.coalesce
+            ? ts.factory.createBinaryExpression(call, ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createIdentifier("undefined"))
+            : call;
+    };
+    const decode_array = (props) => props.metadata.nullable || props.metadata.isRequired() === false
+        ? ts.factory.createCallExpression(props.context.importer.internal("httpFormDataReadArray"), undefined, [
+            props.input,
+            props.metadata.nullable
+                ? ts.factory.createNull()
+                : ts.factory.createIdentifier("undefined"),
+        ])
+        : props.input;
+})(HttpFormDataProgrammer || (HttpFormDataProgrammer = {}));
+
+export { HttpFormDataProgrammer };
+//# sourceMappingURL=HttpFormDataProgrammer.mjs.map

package/lib/programmers/http/HttpFormDataProgrammer.mjs.map

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