@typia/core 12.0.0-dev.20260225

package/lib/programmers/json/JsonStringifyProgrammer.mjs

@@ -0,0 +1,697 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { JsonMetadataFactory } from '../../factories/JsonMetadataFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { ValueFactory } from '../../factories/ValueFactory.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataAtomic } from '../../schemas/metadata/MetadataAtomic.mjs';
+import { MetadataSchema } from '../../schemas/metadata/MetadataSchema.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { AtomicPredicator } from '../helpers/AtomicPredicator.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { OptionPredicator } from '../helpers/OptionPredicator.mjs';
+import { StringifyJoiner } from '../helpers/StringifyJoinder.mjs';
+import { StringifyPredicator } from '../helpers/StringifyPredicator.mjs';
+import { UnionExplorer } from '../helpers/UnionExplorer.mjs';
+import { FeatureProgrammer } from '../internal/FeatureProgrammer.mjs';
+import { check_native } from '../iterate/check_native.mjs';
+import { decode_union_object } from '../iterate/decode_union_object.mjs';
+import { postfix_of_tuple } from '../iterate/postfix_of_tuple.mjs';
+import { wrap_metadata_rest_tuple } from '../iterate/wrap_metadata_rest_tuple.mjs';
+
+var JsonStringifyProgrammer;
+(function (JsonStringifyProgrammer) {
+    /* -----------------------------------------------------------
+      WRITER
+    ----------------------------------------------------------- */
+    JsonStringifyProgrammer.decompose = (props) => {
+        const config = configure(props);
+        if (props.validated === false)
+            config.addition = (collection) => IsProgrammer.write_function_statements({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            });
+        const composed = FeatureProgrammer.compose({
+            ...props,
+            config,
+        });
+        return {
+            functions: composed.functions,
+            statements: composed.statements,
+            arrow: ts.factory.createArrowFunction(undefined, undefined, composed.parameters, composed.response, undefined, composed.body),
+        };
+    };
+    JsonStringifyProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonStringifyProgrammer.decompose({
+            ...props,
+            validated: false,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    const write_array_functions = (props) => props.collection
+        .arrays()
+        .filter((a) => a.recursive)
+        .map((type, i) => StatementFactory.constant({
+        name: `${props.config.prefix}a${i}`,
+        value: ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory.keyword("any"),
+            input: ts.factory.createIdentifier("input"),
+        }), TypeFactory.keyword("any"), undefined, decode_array_inline({
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            array: MetadataArray.create({
+                type,
+                tags: [],
+            }),
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    const write_tuple_functions = (props) => props.collection
+        .tuples()
+        .filter((t) => t.recursive)
+        .map((tuple, i) => StatementFactory.constant({
+        name: `${props.config.prefix}t${i}`,
+        value: ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory.keyword("any"),
+            input: ts.factory.createIdentifier("input"),
+        }), TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    /* -----------------------------------------------------------
+      DECODERS
+    ----------------------------------------------------------- */
+    const decode = (props) => {
+        // ANY TYPE
+        if (props.metadata.any === true)
+            return wrap_required({
+                input: props.input,
+                metadata: props.metadata,
+                explore: props.explore,
+                expression: wrap_functional({
+                    input: props.input,
+                    metadata: props.metadata,
+                    explore: props.explore,
+                    expression: ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.stringify"), undefined, [props.input]),
+                }),
+            });
+        // ONLY NULL OR UNDEFINED
+        const size = props.metadata.size();
+        if (size === 0 &&
+            (props.metadata.isRequired() === false ||
+                props.metadata.nullable === true)) {
+            if (props.metadata.isRequired() === false &&
+                props.metadata.nullable === true)
+                return props.explore.from === "array"
+                    ? ts.factory.createStringLiteral("null")
+                    : ts.factory.createConditionalExpression(ts.factory.createStrictEquality(ts.factory.createNull(), props.input), undefined, ts.factory.createStringLiteral("null"), undefined, ts.factory.createIdentifier("undefined"));
+            else if (props.metadata.isRequired() === false)
+                return props.explore.from === "array"
+                    ? ts.factory.createStringLiteral("null")
+                    : ts.factory.createIdentifier("undefined");
+            else
+                return ts.factory.createStringLiteral("null");
+        }
+        //----
+        // LIST UP UNION TYPES
+        //----
+        const unions = [];
+        // toJSON() METHOD
+        if (props.metadata.escaped !== null)
+            unions.push({
+                type: "resolved",
+                is: props.metadata.escaped.original.size() === 1 &&
+                    props.metadata.escaped.original.natives[0]?.name === "Date"
+                    ? () => check_native({
+                        name: "Date",
+                        input: props.input,
+                    })
+                    : () => IsProgrammer.decode_to_json({
+                        checkNull: false,
+                        input: props.input,
+                    }),
+                value: () => decode_to_json({
+                    ...props,
+                    metadata: props.metadata.escaped.returns,
+                }),
+            });
+        else if (props.metadata.functions.length)
+            unions.push({
+                type: "functional",
+                is: () => IsProgrammer.decode_functional(props.input),
+                value: () => decode_functional(props.explore),
+            });
+        // TEMPLATES
+        if (props.metadata.templates.length)
+            if (AtomicPredicator.template(props.metadata)) {
+                const partial = MetadataSchema.initialize();
+                (partial.atomics.push(MetadataAtomic.create({ type: "string", tags: [] })),
+                    unions.push({
+                        type: "template literal",
+                        is: () => IsProgrammer.decode({
+                            ...props,
+                            metadata: partial,
+                        }),
+                        value: () => decode_atomic({
+                            ...props,
+                            type: "string",
+                        }),
+                    }));
+            }
+        // CONSTANTS
+        for (const constant of props.metadata.constants)
+            if (AtomicPredicator.constant({
+                metadata: props.metadata,
+                name: constant.type,
+            }) === false)
+                continue;
+            else if (constant.type !== "string")
+                unions.push({
+                    type: "atomic",
+                    is: () => IsProgrammer.decode({
+                        ...props,
+                        metadata: (() => {
+                            const partial = MetadataSchema.initialize();
+                            partial.atomics.push(MetadataAtomic.create({
+                                type: constant.type,
+                                tags: [],
+                            }));
+                            return partial;
+                        })(),
+                    }),
+                    value: () => decode_atomic({
+                        ...props,
+                        type: constant.type,
+                    }),
+                });
+            else if (props.metadata.templates.length === 0)
+                unions.push({
+                    type: "const string",
+                    is: () => IsProgrammer.decode({
+                        ...props,
+                        metadata: (() => {
+                            const partial = MetadataSchema.initialize();
+                            partial.atomics.push(MetadataAtomic.create({
+                                type: "string",
+                                tags: [],
+                            }));
+                            return partial;
+                        })(),
+                    }),
+                    value: () => decode_constant_string({
+                        ...props,
+                        values: [...constant.values.map((v) => v.value)],
+                    }),
+                });
+        /// ATOMICS
+        for (const a of props.metadata.atomics)
+            if (AtomicPredicator.atomic({
+                metadata: props.metadata,
+                name: a.type,
+            }))
+                unions.push({
+                    type: "atomic",
+                    is: () => IsProgrammer.decode({
+                        ...props,
+                        metadata: (() => {
+                            const partial = MetadataSchema.initialize();
+                            partial.atomics.push(a);
+                            return partial;
+                        })(),
+                    }),
+                    value: () => decode_atomic({
+                        ...props,
+                        type: a.type,
+                    }),
+                });
+        // TUPLES
+        for (const tuple of props.metadata.tuples)
+            unions.push({
+                type: "tuple",
+                is: () => IsProgrammer.decode({
+                    ...props,
+                    metadata: (() => {
+                        const partial = MetadataSchema.initialize();
+                        partial.tuples.push(tuple);
+                        return partial;
+                    })(),
+                }),
+                value: () => decode_tuple({
+                    ...props,
+                    tuple,
+                }),
+            });
+        // ARRAYS
+        if (props.metadata.arrays.length) {
+            const value = props.metadata.arrays.length === 1
+                ? () => decode_array({
+                    ...props,
+                    array: props.metadata.arrays[0],
+                    explore: {
+                        ...props.explore,
+                        from: "array",
+                    },
+                })
+                : props.metadata.arrays.some((elem) => elem.type.value.any)
+                    ? () => ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.stringify"), undefined, [props.input])
+                    : () => explore_arrays({
+                        ...props,
+                        arrays: props.metadata.arrays,
+                        explore: {
+                            ...props.explore,
+                            from: "array",
+                        },
+                    });
+            unions.push({
+                type: "array",
+                is: () => ExpressionFactory.isArray(props.input),
+                value,
+            });
+        }
+        // BUILT-IN CLASSES
+        if (props.metadata.natives.length)
+            for (const native of props.metadata.natives)
+                unions.push({
+                    type: "object",
+                    is: () => check_native({
+                        name: native.name,
+                        input: props.input,
+                    }),
+                    value: () => AtomicPredicator.native(native.name)
+                        ? decode_atomic({
+                            ...props,
+                            type: native.name.toLowerCase(),
+                        })
+                        : ts.factory.createStringLiteral("{}"),
+                });
+        // SETS
+        if (props.metadata.sets.length)
+            unions.push({
+                type: "object",
+                is: () => ExpressionFactory.isInstanceOf("Set", props.input),
+                value: () => ts.factory.createStringLiteral("{}"),
+            });
+        // MAPS
+        if (props.metadata.maps.length)
+            unions.push({
+                type: "object",
+                is: () => ExpressionFactory.isInstanceOf("Map", props.input),
+                value: () => ts.factory.createStringLiteral("{}"),
+            });
+        // OBJECTS
+        if (props.metadata.objects.length)
+            unions.push({
+                type: "object",
+                is: () => ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: props.metadata.objects.some((object) => object.type.properties.every((prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired())),
+                    input: props.input,
+                }),
+                value: () => explore_objects({
+                    ...props,
+                    explore: {
+                        ...props.explore,
+                        from: "object",
+                    },
+                }),
+            });
+        //----
+        // RETURNS
+        //----
+        // CHECK NULL AND UNDEFINED
+        const wrapper = (output) => wrap_required({
+            input: props.input,
+            metadata: props.metadata,
+            explore: props.explore,
+            expression: wrap_nullable({
+                input: props.input,
+                metadata: props.metadata,
+                expression: output,
+            }),
+        });
+        // DIRECT RETURN
+        if (unions.length === 0)
+            return ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.stringify"), undefined, [props.input]);
+        else if (unions.length === 1)
+            return wrapper(unions[0].value());
+        // RETURN WITH TYPE CHECKING
+        return wrapper(ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, iterate({
+            context: props.context,
+            functor: props.functor,
+            input: props.input,
+            expected: props.metadata.getName(),
+            unions,
+        })), undefined, undefined));
+    };
+    const decode_object = (props) => FeatureProgrammer.decode_object({
+        config: {
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        },
+        functor: props.functor,
+        object: props.object,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_array = (props) => props.array.type.recursive
+        ? ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}a${props.array.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            input: props.input,
+            explore: {
+                ...props.explore,
+                source: "function",
+                from: "array",
+            },
+        }))
+        : decode_array_inline(props);
+    const decode_array_inline = (props) => FeatureProgrammer.decode_array({
+        config: props.config,
+        functor: props.functor,
+        combiner: StringifyJoiner.array,
+        array: props.array,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_tuple = (props) => props.tuple.type.recursive
+        ? ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}t${props.tuple.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+                ...props.explore,
+                source: "function",
+            },
+            input: props.input,
+        }))
+        : decode_tuple_inline({
+            ...props,
+            tuple: props.tuple.type,
+        });
+    const decode_tuple_inline = (props) => {
+        const elements = props.tuple.elements
+            .filter((elem) => elem.rest === null)
+            .map((elem, index) => decode({
+            ...props,
+            input: ts.factory.createElementAccessExpression(props.input, index),
+            metadata: elem,
+            explore: {
+                ...props.explore,
+                from: "array",
+                postfix: props.explore.postfix.length
+                    ? `${postfix_of_tuple(props.explore.postfix)}[${index}]"`
+                    : `"[${index}]"`,
+            },
+        }));
+        const rest = (() => {
+            if (props.tuple.elements.length === 0)
+                return null;
+            const last = props.tuple.elements.at(-1);
+            if (last.rest === null)
+                return null;
+            const code = decode({
+                ...props,
+                input: ts.factory.createCallExpression(IdentifierFactory.access(props.input, "slice"), undefined, [ExpressionFactory.number(props.tuple.elements.length - 1)]),
+                metadata: wrap_metadata_rest_tuple(props.tuple.elements.at(-1).rest),
+                explore: {
+                    ...props.explore,
+                    start: props.tuple.elements.length - 1,
+                },
+            });
+            return ts.factory.createCallExpression(props.context.importer.internal("jsonStringifyRest"), undefined, [code]);
+        })();
+        return StringifyJoiner.tuple({
+            elements,
+            rest,
+        });
+    };
+    const decode_atomic = (props) => {
+        if (props.type === "string")
+            return ts.factory.createCallExpression(props.context.importer.internal("jsonStringifyString"), undefined, [props.input]);
+        else if (props.type === "number" &&
+            OptionPredicator.numeric(props.context.options))
+            props = {
+                ...props,
+                input: ts.factory.createCallExpression(props.context.importer.internal("jsonStringifyNumber"), undefined, [props.input]),
+            };
+        return props.explore.from !== "top"
+            ? props.input
+            : ts.factory.createCallExpression(IdentifierFactory.access(props.input, "toString"), undefined, undefined);
+    };
+    const decode_constant_string = (props) => {
+        if (props.values.every((v) => !StringifyPredicator.require_escape(v)))
+            return [
+                ts.factory.createStringLiteral('"'),
+                props.input,
+                ts.factory.createStringLiteral('"'),
+            ].reduce((x, y) => ts.factory.createAdd(x, y));
+        return decode_atomic({
+            ...props,
+            type: "string",
+        });
+    };
+    const decode_to_json = (props) => {
+        return decode({
+            ...props,
+            input: ts.factory.createCallExpression(IdentifierFactory.access(props.input, "toJSON"), undefined, []),
+        });
+    };
+    const decode_functional = (explore) => explore.from === "array"
+        ? ts.factory.createStringLiteral("null")
+        : ts.factory.createIdentifier("undefined");
+    /* -----------------------------------------------------------
+      EXPLORERS
+    ----------------------------------------------------------- */
+    const explore_objects = (props) => props.metadata.objects.length === 1
+        ? decode_object({
+            functor: props.functor,
+            input: props.input,
+            object: props.metadata.objects[0].type,
+            explore: props.explore,
+        })
+        : ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${PREFIX}u${props.metadata.union_index}`)), undefined, FeatureProgrammer.argumentsArray(props));
+    const explore_arrays = (props) => explore_array_like_union_types({
+        ...props,
+        elements: props.arrays,
+        factory: (next) => UnionExplorer.array({
+            config: {
+                checker: (v) => IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+                empty: ts.factory.createStringLiteral("[]"),
+                success: ts.factory.createTrue(),
+                failure: (v) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: v.expected,
+                    input: v.input,
+                }),
+            },
+            parameters: next.parameters,
+            input: next.input,
+            arrays: next.definitions,
+            explore: next.explore,
+        }),
+        //(next.parameters)(next.input, next.elements, next.explore),
+    });
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            definitions: props.elements,
+            parameters: next.parameters,
+            input: next.input,
+            explore: next.explore,
+        });
+        if (props.elements.every((e) => e.type.recursive === false))
+            ts.factory.createCallExpression(arrow({
+                parameters: [],
+                explore: props.explore,
+                input: props.input,
+            }), undefined, []);
+        const arrayExplore = {
+            ...props.explore,
+            source: "function",
+            from: "array",
+        };
+        return ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.elements.map((e) => e.type.name).join(" | "), () => arrow({
+            parameters: FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory.keyword("any"),
+                input: ts.factory.createIdentifier("input"),
+            }),
+            explore: {
+                ...arrayExplore,
+                postfix: "",
+            },
+            input: ts.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: arrayExplore,
+            input: props.input,
+        }));
+    };
+    /* -----------------------------------------------------------
+      RETURN SCRIPTS
+    ----------------------------------------------------------- */
+    const wrap_required = (props) => {
+        if (props.metadata.isRequired() === true && props.metadata.any === false)
+            return props.expression;
+        return ts.factory.createConditionalExpression(ts.factory.createStrictInequality(ts.factory.createIdentifier("undefined"), props.input), undefined, props.expression, undefined, props.explore.from === "array"
+            ? ts.factory.createStringLiteral("null")
+            : ts.factory.createIdentifier("undefined"));
+    };
+    const wrap_nullable = (props) => {
+        if (props.metadata.nullable === false)
+            return props.expression;
+        return ts.factory.createConditionalExpression(ts.factory.createStrictInequality(ts.factory.createNull(), props.input), undefined, props.expression, undefined, ts.factory.createStringLiteral("null"));
+    };
+    const wrap_functional = (props) => {
+        if (props.metadata.functions.length === 0)
+            return props.expression;
+        return ts.factory.createConditionalExpression(ts.factory.createStrictInequality(ts.factory.createStringLiteral("function"), ValueFactory.TYPEOF(props.input)), undefined, props.expression, undefined, decode_functional(props.explore));
+    };
+    const iterate = (props) => ts.factory.createBlock([
+        ...props.unions.map((u) => ts.factory.createIfStatement(u.is(), ts.factory.createReturnStatement(u.value()))),
+        create_throw_error(props),
+    ], true);
+    /* -----------------------------------------------------------
+      CONFIGURATIONS
+    ----------------------------------------------------------- */
+    const PREFIX = "_s";
+    const configure = (props) => {
+        const config = {
+            types: {
+                input: (type, name) => ts.factory.createTypeReferenceNode(name ??
+                    TypeFactory.getFullName({ checker: props.context.checker, type })),
+                output: () => TypeFactory.keyword("string"),
+            },
+            prefix: PREFIX,
+            trace: false,
+            path: false,
+            initializer,
+            decoder: (next) => decode({
+                context: props.context,
+                functor: props.functor,
+                config,
+                metadata: next.metadata,
+                input: next.input,
+                explore: next.explore,
+            }),
+            objector: {
+                checker: (next) => IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    metadata: next.metadata,
+                    input: next.input,
+                    explore: next.explore,
+                }),
+                decoder: (next) => decode_object({
+                    functor: props.functor,
+                    input: next.input,
+                    object: next.object,
+                    explore: next.explore,
+                }),
+                joiner: (next) => StringifyJoiner.object({
+                    ...next,
+                    context: props.context,
+                }),
+                unionizer: (next) => decode_union_object({
+                    checker: (v) => IsProgrammer.decode_object({
+                        context: props.context,
+                        functor: props.functor,
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => decode_object({
+                        functor: props.functor,
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    success: (exp) => exp,
+                    escaper: (v) => create_throw_error({
+                        context: props.context,
+                        functor: props.functor,
+                        expected: v.expected,
+                        input: v.input,
+                    }),
+                    objects: next.objects,
+                    explore: next.explore,
+                    input: next.input,
+                }),
+                failure: (next) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: next.expected,
+                    input: next.input,
+                }),
+            },
+            generator: {
+                arrays: (collection) => write_array_functions({
+                    config,
+                    functor: props.functor,
+                    collection,
+                }),
+                tuples: (collection) => write_tuple_functions({
+                    config,
+                    context: props.context,
+                    functor: props.functor,
+                    collection,
+                }),
+            },
+        };
+        return config;
+    };
+    const initializer = (props) => JsonMetadataFactory.analyze({
+        method: props.functor.method,
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        type: props.type,
+    });
+    const create_throw_error = (props) => ts.factory.createExpressionStatement(ts.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
+        ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment("method", ts.factory.createStringLiteral(props.functor.method)),
+            ts.factory.createPropertyAssignment("expected", ts.factory.createStringLiteral(props.expected)),
+            ts.factory.createPropertyAssignment("value", props.input),
+        ], true),
+    ]));
+})(JsonStringifyProgrammer || (JsonStringifyProgrammer = {}));
+
+export { JsonStringifyProgrammer };
+//# sourceMappingURL=JsonStringifyProgrammer.mjs.map