typia 8.0.0 → 8.0.1

package/lib/programmers/internal/prune_object_properties.mjs

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { metadata_to_pattern } from './metadata_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const prune_object_properties = (object) => {
+    const input = ts.factory.createIdentifier("input");
+    const key = ts.factory.createIdentifier("key");
+    const condition = object.properties.map((prop) => {
+        const name = prop.key.getSoleLiteral();
+        if (name !== null)
+            return ts.factory.createStrictEquality(ts.factory.createStringLiteral(name), ts.factory.createIdentifier("key"));
+        return ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: prop.key,
+        })}/).test`), undefined, [key]);
+    });
+    const statements = [];
+    if (condition.length)
+        statements.push(ts.factory.createIfStatement(condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)), ts.factory.createContinueStatement()));
+    statements.push(ts.factory.createExpressionStatement(ts.factory.createDeleteExpression(ts.factory.createElementAccessExpression(input, key))));
+    return ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("key"), undefined, undefined, undefined),
+    ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createIdentifier("Object.keys"), undefined, [input]), statements.length === 1
+        ? statements[0]
+        : ts.factory.createBlock(statements, true));
+};
+
+export { prune_object_properties };
+//# sourceMappingURL=prune_object_properties.mjs.map

package/lib/programmers/internal/prune_object_properties.mjs.map

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

package/lib/programmers/internal/stringify_dynamic_properties.mjs

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { TemplateFactory } from '../../factories/TemplateFactory.mjs';
+import { metadata_to_pattern } from './metadata_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const stringify_dynamic_properties = (dynamic, regular) => {
+    // BASIC STATMEMENT, CHECK UNDEFINED
+    const statements = [
+        ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createIdentifier("undefined"), ts.factory.createIdentifier("value")), ts.factory.createReturnStatement(ts.factory.createStringLiteral(""))),
+    ];
+    // PREPARE RETURN FUNCTION
+    const output = () => {
+        const mapped = ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("Object.entries"), undefined, [ts.factory.createIdentifier("input")]), "map"), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter(ts.factory.createArrayBindingPattern([
+                    ts.factory.createBindingElement(undefined, undefined, "key"),
+                    ts.factory.createBindingElement(undefined, undefined, "value"),
+                ]), ts.factory.createTypeReferenceNode("[string, any]")),
+            ], undefined, undefined, ts.factory.createBlock(statements)),
+        ]);
+        const filtered = ts.factory.createCallExpression(IdentifierFactory.access(mapped, "filter"), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("str")], undefined, undefined, ts.factory.createStrictInequality(ts.factory.createStringLiteral(""), ts.factory.createIdentifier("str"))),
+        ]);
+        return ts.factory.createCallExpression(IdentifierFactory.access(filtered, "join"), undefined, [ts.factory.createStringLiteral(",")]);
+    };
+    // WHEN REGULAR PROPERTY EXISTS
+    if (regular.length)
+        statements.push(ts.factory.createIfStatement(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createArrayLiteralExpression(regular.map((key) => ts.factory.createStringLiteral(key))), "some"), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("regular")], undefined, undefined, ts.factory.createStrictEquality(ts.factory.createIdentifier("regular"), ts.factory.createIdentifier("key"))),
+        ]), ts.factory.createReturnStatement(ts.factory.createStringLiteral(""))));
+    // ONLY STRING TYPED KEY EXISTS
+    const simple = dynamic.length === 1 &&
+        dynamic[0].key.size() === 1 &&
+        dynamic[0].key.atomics[0]?.type === "string";
+    if (simple === true) {
+        statements.push(stringify(dynamic[0]));
+        return output();
+    }
+    // COMPOSITE TEMPLATE LITERAL TYPES
+    for (const entry of dynamic) {
+        const condition = ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: entry.key,
+        })}/).test`), undefined, [ts.factory.createIdentifier("key")]), stringify(entry));
+        statements.push(condition);
+    }
+    statements.push(ts.factory.createReturnStatement(ts.factory.createStringLiteral("")));
+    return output();
+};
+/**
+ * @internal
+ */
+const stringify = (entry) => ts.factory.createReturnStatement(TemplateFactory.generate([
+    ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.stringify"), [], [ts.factory.createIdentifier("key")]),
+    ts.factory.createStringLiteral(":"),
+    entry.expression,
+]));
+
+export { stringify_dynamic_properties };
+//# sourceMappingURL=stringify_dynamic_properties.mjs.map

package/lib/programmers/internal/stringify_dynamic_properties.mjs.map

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

package/lib/programmers/internal/stringify_native.mjs

@@ -0,0 +1,9 @@
+import ts from 'typescript';
+
+/**
+ * @internal
+ */
+const stringify_native = () => ts.factory.createStringLiteral("{}");
+
+export { stringify_native };
+//# sourceMappingURL=stringify_native.mjs.map

package/lib/programmers/internal/stringify_native.mjs.map

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

package/lib/programmers/internal/stringify_regular_properties.mjs

@@ -0,0 +1,52 @@
+import ts from 'typescript';
+import { TemplateFactory } from '../../factories/TemplateFactory.mjs';
+import { ValueFactory } from '../../factories/ValueFactory.mjs';
+
+/**
+ * @internal
+ */
+const stringify_regular_properties = (props) => {
+    const output = [];
+    props.regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+    props.regular.forEach((entry, index) => {
+        // BASE ELEMENTS
+        const key = entry.key.getSoleLiteral();
+        const base = [
+            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+            entry.expression,
+        ];
+        if (index !== props.regular.length - 1 || props.dynamic.length !== 0)
+            base.push(ts.factory.createStringLiteral(`,`));
+        const empty = (entry.meta.isRequired() === false &&
+            entry.meta.nullable === false &&
+            entry.meta.size() === 0) ||
+            (!!entry.meta.functions.length &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 1);
+        if (empty === true)
+            return;
+        else if (entry.meta.isRequired() === false ||
+            entry.meta.functions.length ||
+            entry.meta.any === true)
+            output.push(ts.factory.createConditionalExpression((() => {
+                const conditions = [];
+                if (entry.meta.isRequired() === false || entry.meta.any)
+                    conditions.push(ts.factory.createStrictEquality(ts.factory.createIdentifier("undefined"), entry.input));
+                if (entry.meta.functions.length || entry.meta.any)
+                    conditions.push(ts.factory.createStrictEquality(ts.factory.createStringLiteral("function"), ValueFactory.TYPEOF(entry.input)));
+                return conditions.length === 1
+                    ? conditions[0]
+                    : conditions.reduce((x, y) => ts.factory.createLogicalOr(x, y));
+            })(), undefined, ts.factory.createStringLiteral(""), undefined, TemplateFactory.generate(base)));
+        else
+            output.push(...base);
+    });
+    return output;
+};
+/**
+ * @internal
+ */
+const sequence = (meta) => meta.any || !meta.isRequired() || meta.functions.length ? 0 : 1;
+
+export { stringify_regular_properties };
+//# sourceMappingURL=stringify_regular_properties.mjs.map

package/lib/programmers/internal/stringify_regular_properties.mjs.map

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

package/lib/programmers/internal/template_to_pattern.mjs

@@ -0,0 +1,18 @@
+import { PatternUtil } from '../../utils/PatternUtil.mjs';
+import { metadata_to_pattern } from './metadata_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const template_to_pattern = (props) => {
+    const pattern = props.template
+        .map((meta) => metadata_to_pattern({
+        top: false,
+        metadata: meta,
+    }))
+        .join("");
+    return props.top ? PatternUtil.fix(pattern) : pattern;
+};
+
+export { template_to_pattern };
+//# sourceMappingURL=template_to_pattern.mjs.map

package/lib/programmers/internal/template_to_pattern.mjs.map

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

package/lib/programmers/internal/wrap_metadata_rest_tuple.mjs

@@ -0,0 +1,24 @@
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+
+/**
+ * @internal
+ */
+const wrap_metadata_rest_tuple = (rest) => {
+    const wrapper = Metadata.initialize();
+    wrapper.arrays.push(MetadataArray.create({
+        type: MetadataArrayType.create({
+            name: `...${rest.getName()}`,
+            value: rest,
+            nullables: [],
+            recursive: false,
+            index: null,
+        }),
+        tags: [],
+    }));
+    return wrapper;
+};
+
+export { wrap_metadata_rest_tuple };
+//# sourceMappingURL=wrap_metadata_rest_tuple.mjs.map

package/lib/programmers/internal/wrap_metadata_rest_tuple.mjs.map

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

package/lib/programmers/json/JsonApplicationProgrammer.mjs

@@ -0,0 +1,182 @@
+import { JsonSchemasProgrammer } from './JsonSchemasProgrammer.mjs';
+
+var JsonApplicationProgrammer;
+(function (JsonApplicationProgrammer) {
+    JsonApplicationProgrammer.validate = (metadata, explore) => {
+        if (explore.top === false)
+            return JsonSchemasProgrammer.validate(metadata);
+        const output = [];
+        const valid = metadata.size() === 1 &&
+            metadata.objects.length === 1 &&
+            metadata.isRequired() === true &&
+            metadata.nullable === false;
+        if (valid === false)
+            output.push("JSON application's generic argument must be a class/interface type.");
+        const object = metadata.objects[0]?.type;
+        if (object !== undefined) {
+            if (object.properties.some((p) => p.key.isSoleLiteral() === false))
+                output.push("JSON application does not allow dynamic keys.");
+            let least = false;
+            for (const p of object.properties) {
+                const value = p.value;
+                if (value.functions.length) {
+                    least ||= true;
+                    if (valid === false) {
+                        if (value.functions.length !== 1 || value.size() !== 1)
+                            output.push("JSON application's function type does not allow union type.");
+                        if (value.isRequired() === false)
+                            output.push("JSON application's function type must be required.");
+                        if (value.nullable === true)
+                            output.push("JSON application's function type must not be nullable.");
+                    }
+                }
+            }
+            if (least === false)
+                output.push("JSON application's target type must have at least a function type.");
+        }
+        return output;
+    };
+    JsonApplicationProgrammer.write = (props) => {
+        const errors = JsonApplicationProgrammer.validate(props.metadata, {
+            top: true,
+            object: null,
+            property: null,
+            parameter: null,
+            nested: null,
+            aliased: false,
+            escaped: false,
+            output: false,
+        });
+        if (errors.length)
+            throw new Error("Failed to write LLM application: " + errors.join("\n"));
+        const object = props.metadata.objects[0].type;
+        const definitions = [];
+        const setters = [];
+        const collect = (metadata, setter) => {
+            definitions.push(metadata);
+            setters.push(setter);
+        };
+        const functions = object.properties
+            .filter((p) => p.key.isSoleLiteral() &&
+            p.value.size() === 1 &&
+            p.value.nullable === false &&
+            p.value.isRequired() === true &&
+            p.value.functions.length === 1)
+            .filter((p) => p.jsDocTags.find((tag) => tag.name === "hidden" || tag.name === "internal") === undefined &&
+            (props.filter === undefined || props.filter(p) === true))
+            .map((r) => collectFunction({
+            version: props.version,
+            name: r.key.getSoleLiteral(),
+            function: r.value.functions[0],
+            description: r.description,
+            jsDocTags: r.jsDocTags,
+            collect,
+        }));
+        const { components, schemas } = JsonSchemasProgrammer.write({
+            version: props.version,
+            metadatas: definitions,
+        });
+        schemas.forEach((s, i) => setters[i]?.(s));
+        return {
+            version: props.version,
+            components: components,
+            functions,
+        };
+    };
+    JsonApplicationProgrammer.writeDescription = (props) => {
+        const title = (() => {
+            const [explicit] = getJsDocTexts({
+                jsDocTags: props.jsDocTags,
+                name: props.kind,
+            });
+            if (explicit?.length)
+                return explicit;
+            else if (!props.description?.length)
+                return undefined;
+            const index = props.description.indexOf("\n");
+            const top = (index === -1 ? props.description : props.description.substring(0, index)).trim();
+            return top.endsWith(".") ? top.substring(0, top.length - 1) : undefined;
+        })();
+        return {
+            [props.kind]: title,
+            description: props.description?.length ? props.description : undefined,
+        };
+    };
+    const collectFunction = (props) => {
+        const deprecated = props.jsDocTags.some((tag) => tag.name === "deprecated");
+        const tags = props.jsDocTags
+            .map((tag) => tag.name === "tag"
+            ? (tag.text?.filter((elem) => elem.kind === "text") ?? [])
+            : [])
+            .flat()
+            .map((elem) => elem.text)
+            .map((str) => str.trim().split(" ")[0] ?? "")
+            .filter((str) => !!str.length);
+        return {
+            name: props.name,
+            async: props.function.async,
+            parameters: props.function.parameters.map((param) => {
+                const appParam = {
+                    name: param.name,
+                    ...JsonApplicationProgrammer.writeDescription({
+                        description: param.description ??
+                            param.jsDocTags.find((tag) => tag.name === "description")
+                                ?.text?.[0]?.text ??
+                            props.jsDocTags
+                                .find((tag) => tag.name === "param" && tag.text?.[0]?.text === param.name)
+                                ?.text?.map((e) => e.text)
+                                .join("")
+                                .substring(param.name.length) ??
+                            null,
+                        jsDocTags: props.jsDocTags,
+                        kind: "title",
+                    }),
+                    required: param.type.isRequired(),
+                    schema: null,
+                };
+                props.collect(param.type, (schema) => (appParam.schema = schema));
+                return appParam;
+            }),
+            output: props.function.output.size()
+                ? (() => {
+                    const appOutput = {
+                        schema: null,
+                        required: props.function.output.isRequired(),
+                        description: writeDescriptionFromJsDocTag({
+                            jsDocTags: props.jsDocTags,
+                            name: "return",
+                        }) ??
+                            writeDescriptionFromJsDocTag({
+                                jsDocTags: props.jsDocTags,
+                                name: "returns",
+                            }) ??
+                            undefined,
+                    };
+                    props.collect(props.function.output, (schema) => (appOutput.schema = schema));
+                    return appOutput;
+                })()
+                : undefined,
+            description: props.description ?? undefined,
+            deprecated: deprecated || undefined,
+            tags: tags.length ? tags : undefined,
+        };
+    };
+})(JsonApplicationProgrammer || (JsonApplicationProgrammer = {}));
+const writeDescriptionFromJsDocTag = (props) => {
+    const parametric = props.parameter
+        ? (tag) => tag.text.find((elem) => elem.kind === "parameterName" && elem.text === props.parameter) !== undefined
+        : () => true;
+    const tag = props.jsDocTags.find((tag) => tag.name === props.name && tag.text && parametric(tag));
+    return tag && tag.text
+        ? (tag.text.find((elem) => elem.kind === "text")?.text ?? null)
+        : null;
+};
+const getJsDocTexts = (props) => props.jsDocTags
+    .filter((tag) => tag.name === props.name &&
+    tag.text &&
+    tag.text.find((elem) => elem.kind === "text" && elem.text.length) !==
+        undefined)
+    .map((tag) => tag.text.find((elem) => elem.kind === "text").text);
+
+export { JsonApplicationProgrammer };
+//# sourceMappingURL=JsonApplicationProgrammer.mjs.map

package/lib/programmers/json/JsonApplicationProgrammer.mjs.map

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

package/lib/programmers/json/JsonAssertParseProgrammer.mjs

@@ -0,0 +1,83 @@
+import ts from 'typescript';
+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 { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+
+var JsonAssertParseProgrammer;
+(function (JsonAssertParseProgrammer) {
+    JsonAssertParseProgrammer.decompose = (props) => {
+        JsonMetadataFactory.analyze({
+            method: props.functor.method,
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            type: props.type,
+        });
+        const assert = AssertProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+                guard: false,
+            },
+        });
+        return {
+            functions: assert.functions,
+            statements: [
+                ...assert.statements,
+                StatementFactory.constant({
+                    name: "__assert",
+                    value: assert.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
+                AssertProgrammer.Guardian.parameter({
+                    context: props.context,
+                    init: props.init,
+                }),
+            ], props.context.importer.type({
+                file: "typia",
+                name: "Primitive",
+                arguments: [
+                    ts.factory.createTypeReferenceNode(props.name ??
+                        TypeFactory.getFullName({
+                            checker: props.context.checker,
+                            type: props.type,
+                        })),
+                ],
+            }), undefined, ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__assert"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.parse"), undefined, [ts.factory.createIdentifier("input")]),
+                AssertProgrammer.Guardian.identifier(),
+            ]), TypeFactory.keyword("any"))),
+        };
+    };
+    JsonAssertParseProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonAssertParseProgrammer.decompose({
+            context: props.context,
+            functor,
+            type: props.type,
+            name: props.name,
+            init: props.init,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(JsonAssertParseProgrammer || (JsonAssertParseProgrammer = {}));
+
+export { JsonAssertParseProgrammer };
+//# sourceMappingURL=JsonAssertParseProgrammer.mjs.map

package/lib/programmers/json/JsonAssertParseProgrammer.mjs.map

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

package/lib/programmers/json/JsonAssertStringifyProgrammer.mjs

@@ -0,0 +1,82 @@
+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 { JsonStringifyProgrammer } from './JsonStringifyProgrammer.mjs';
+
+var JsonAssertStringifyProgrammer;
+(function (JsonAssertStringifyProgrammer) {
+    JsonAssertStringifyProgrammer.decompose = (props) => {
+        const assert = AssertProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: true,
+                },
+            },
+            config: {
+                equals: false,
+                guard: false,
+            },
+        });
+        const stringify = JsonStringifyProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...assert.functions,
+                ...stringify.functions,
+            },
+            statements: [
+                ...assert.statements,
+                ...stringify.statements,
+                StatementFactory.constant({
+                    name: "__assert",
+                    value: assert.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__stringify",
+                    value: stringify.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+                AssertProgrammer.Guardian.parameter({
+                    context: props.context,
+                    init: props.init,
+                }),
+            ], stringify.arrow.type, undefined, ts.factory.createBlock([
+                ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("__assert"), undefined, [
+                    ts.factory.createIdentifier("input"),
+                    AssertProgrammer.Guardian.identifier(),
+                ])),
+                ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("__stringify"), undefined, [ts.factory.createIdentifier("input")])),
+            ], true)),
+        };
+    };
+    JsonAssertStringifyProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonAssertStringifyProgrammer.decompose({
+            context: props.context,
+            functor,
+            type: props.type,
+            name: props.name,
+            init: props.init,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(JsonAssertStringifyProgrammer || (JsonAssertStringifyProgrammer = {}));
+
+export { JsonAssertStringifyProgrammer };
+//# sourceMappingURL=JsonAssertStringifyProgrammer.mjs.map

package/lib/programmers/json/JsonAssertStringifyProgrammer.mjs.map

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

package/lib/programmers/json/JsonIsParseProgrammer.mjs

@@ -0,0 +1,71 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+
+var JsonIsParseProgrammer;
+(function (JsonIsParseProgrammer) {
+    JsonIsParseProgrammer.decompose = (props) => {
+        const is = IsProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        return {
+            functions: is.functions,
+            statements: [
+                ...is.statements,
+                StatementFactory.constant({
+                    name: "__is",
+                    value: is.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))], ts.factory.createUnionTypeNode([
+                props.context.importer.type({
+                    file: "typia",
+                    name: "Primitive",
+                    arguments: [
+                        ts.factory.createTypeReferenceNode(props.name ??
+                            TypeFactory.getFullName({
+                                checker: props.context.checker,
+                                type: props.type,
+                            })),
+                    ],
+                }),
+                ts.factory.createTypeReferenceNode("null"),
+            ]), undefined, ts.factory.createBlock([
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("input"), ts.SyntaxKind.EqualsToken, ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.parse"), undefined, [ts.factory.createIdentifier("input")]))),
+                ts.factory.createReturnStatement(ts.factory.createConditionalExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__is"), undefined, [ts.factory.createIdentifier("input")]), undefined, ts.factory.createAsExpression(ts.factory.createIdentifier("input"), TypeFactory.keyword("any")), undefined, ts.factory.createNull())),
+            ])),
+        };
+    };
+    JsonIsParseProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonIsParseProgrammer.decompose({
+            context: props.context,
+            functor,
+            type: props.type,
+            name: props.name,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(JsonIsParseProgrammer || (JsonIsParseProgrammer = {}));
+
+export { JsonIsParseProgrammer };
+//# sourceMappingURL=JsonIsParseProgrammer.mjs.map

package/lib/programmers/json/JsonIsParseProgrammer.mjs.map

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