typia 8.0.0 → 8.0.1

package/lib/programmers/RandomProgrammer.mjs.map

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

package/lib/programmers/TypiaProgrammer.mjs

@@ -0,0 +1,126 @@
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+import { ImportTransformer } from '../transformers/ImportTransformer.mjs';
+import { transform } from '../transform.mjs';
+
+var TypiaProgrammer;
+(function (TypiaProgrammer) {
+    TypiaProgrammer.build = async (location) => {
+        location.input = path.resolve(location.input);
+        location.output = path.resolve(location.output);
+        if ((await is_directory(location.input)) === false)
+            throw new URIError("Error on TypiaGenerator.generate(): input path is not a directory.");
+        else if (fs.existsSync(location.output) === false)
+            await fs.promises.mkdir(location.output, { recursive: true });
+        else if ((await is_directory(location.output)) === false) {
+            const parent = path.join(location.output, "..");
+            if ((await is_directory(parent)) === false)
+                throw new URIError("Error on TypiaGenerator.generate(): output path is not a directory.");
+            await fs.promises.mkdir(location.output);
+        }
+        // CREATE PROGRAM
+        const { options: compilerOptions } = ts.parseJsonConfigFileContent(ts.readConfigFile(location.project, ts.sys.readFile).config, {
+            fileExists: ts.sys.fileExists,
+            readFile: ts.sys.readFile,
+            readDirectory: ts.sys.readDirectory,
+            useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        }, path.dirname(location.project));
+        const program = ts.createProgram(await (async () => {
+            const container = [];
+            await gather({
+                location,
+                container,
+                from: location.input,
+                to: location.output,
+            });
+            return container;
+        })(), compilerOptions);
+        // DO TRANSFORM
+        const diagnostics = [];
+        const result = ts.transform(program
+            .getSourceFiles()
+            .filter((file) => !file.isDeclarationFile &&
+            path.resolve(file.fileName).indexOf(location.input) !== -1), [
+            ImportTransformer.transform({
+                from: location.input,
+                to: location.output,
+            }),
+            transform(program, (compilerOptions.plugins ?? []).find((p) => p.transform === "typia/lib/transform" ||
+                p.transform === "../src/transform.ts") ?? {}, {
+                addDiagnostic: (diag) => diagnostics.push(diag),
+            }),
+        ], program.getCompilerOptions());
+        // TRACE ERRORS
+        for (const diag of diagnostics) {
+            const file = diag.file
+                ? path.relative(diag.file.fileName, process.cwd())
+                : "(unknown file)";
+            const category = diag.category === ts.DiagnosticCategory.Warning
+                ? "warning"
+                : diag.category === ts.DiagnosticCategory.Error
+                    ? "error"
+                    : diag.category === ts.DiagnosticCategory.Suggestion
+                        ? "suggestion"
+                        : diag.category === ts.DiagnosticCategory.Message
+                            ? "message"
+                            : "unknown";
+            const [line, pos] = diag.file
+                ? (() => {
+                    const lines = diag
+                        .file.text.substring(0, diag.start)
+                        .split("\n");
+                    if (lines.length === 0)
+                        return [0, 0];
+                    return [lines.length, lines.at(-1).length + 1];
+                })()
+                : [0, 0];
+            console.error(`${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`);
+        }
+        if (diagnostics.length)
+            process.exit(-1);
+        // ARCHIVE TRANSFORMED FILES
+        const printer = ts.createPrinter({
+            newLine: ts.NewLineKind.LineFeed,
+        });
+        for (const file of result.transformed) {
+            const to = path
+                .resolve(file.fileName)
+                .replace(location.input, location.output);
+            const content = printer.printFile(file);
+            await fs.promises.writeFile(to, content, "utf8");
+        }
+    };
+    const is_directory = async (current) => {
+        const stat = await fs.promises.stat(current);
+        return stat.isDirectory();
+    };
+    const gather = async (props) => {
+        if (props.from === props.location.output)
+            return;
+        else if (fs.existsSync(props.to) === false)
+            await fs.promises.mkdir(props.to);
+        for (const file of await fs.promises.readdir(props.from)) {
+            const next = path.join(props.from, file);
+            const stat = await fs.promises.stat(next);
+            if (stat.isDirectory()) {
+                await gather({
+                    location: props.location,
+                    container: props.container,
+                    from: next,
+                    to: path.join(props.to, file),
+                });
+                continue;
+            }
+            else if (is_supported_extension(file))
+                props.container.push(next);
+        }
+    };
+    const is_supported_extension = (filename) => {
+        return ((filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
+            (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx")));
+    };
+})(TypiaProgrammer || (TypiaProgrammer = {}));
+
+export { TypiaProgrammer };
+//# sourceMappingURL=TypiaProgrammer.mjs.map

package/lib/programmers/TypiaProgrammer.mjs.map

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

package/lib/programmers/ValidateProgrammer.mjs

@@ -0,0 +1,228 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../factories/StatementFactory.mjs';
+import { TypeFactory } from '../factories/TypeFactory.mjs';
+import { CheckerProgrammer } from './CheckerProgrammer.mjs';
+import { FeatureProgrammer } from './FeatureProgrammer.mjs';
+import { IsProgrammer } from './IsProgrammer.mjs';
+import { FunctionProgrammer } from './helpers/FunctionProgrammer.mjs';
+import { OptionPredicator } from './helpers/OptionPredicator.mjs';
+import { check_everything } from './internal/check_everything.mjs';
+import { check_object } from './internal/check_object.mjs';
+
+var ValidateProgrammer;
+(function (ValidateProgrammer) {
+    ValidateProgrammer.decompose = (props) => {
+        const is = IsProgrammer.decompose(props);
+        const composed = CheckerProgrammer.compose({
+            ...props,
+            config: {
+                prefix: "_v",
+                path: true,
+                trace: true,
+                numeric: OptionPredicator.numeric(props.context.options),
+                equals: props.config.equals,
+                atomist: (next) => [
+                    ...(next.entry.expression ? [next.entry.expression] : []),
+                    ...(next.entry.conditions.length === 0
+                        ? []
+                        : next.entry.conditions.length === 1
+                            ? next.entry.conditions[0].map((cond) => ts.factory.createLogicalOr(cond.expression, create_report_call({
+                                exceptionable: next.explore.from === "top"
+                                    ? ts.factory.createTrue()
+                                    : ts.factory.createIdentifier("_exceptionable"),
+                                path: ts.factory.createIdentifier(next.explore.postfix
+                                    ? `_path + ${next.explore.postfix}`
+                                    : "_path"),
+                                expected: cond.expected,
+                                input: next.input,
+                            })))
+                            : [
+                                ts.factory.createLogicalOr(next.entry.conditions
+                                    .map((set) => set
+                                    .map((s) => s.expression)
+                                    .reduce((a, b) => ts.factory.createLogicalAnd(a, b)))
+                                    .reduce((a, b) => ts.factory.createLogicalOr(a, b)), create_report_call({
+                                    exceptionable: next.explore.from === "top"
+                                        ? ts.factory.createTrue()
+                                        : ts.factory.createIdentifier("_exceptionable"),
+                                    path: ts.factory.createIdentifier(next.explore.postfix
+                                        ? `_path + ${next.explore.postfix}`
+                                        : "_path"),
+                                    expected: next.entry.expected,
+                                    input: next.input,
+                                })),
+                            ]),
+                ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                combiner: combine(props),
+                joiner: joiner(props),
+                success: ts.factory.createTrue(),
+            },
+        });
+        const arrow = ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], props.context.importer.type({
+            file: "typia",
+            name: "IValidation",
+            arguments: [
+                ts.factory.createTypeReferenceNode(props.name ??
+                    TypeFactory.getFullName({
+                        checker: props.context.checker,
+                        type: props.type,
+                    })),
+            ],
+        }), undefined, ts.factory.createBlock([
+            // validate when false === is<T>(input)
+            ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createCallExpression(ts.factory.createIdentifier("__is"), undefined, [ts.factory.createIdentifier("input")])), ts.factory.createBlock([
+                // prepare errors
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("errors"), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createArrayLiteralExpression([]))),
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("_report"), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createCallExpression(ts.factory.createAsExpression(props.context.importer.internal("validateReport"), TypeFactory.keyword("any")), [], [ts.factory.createIdentifier("errors")]))),
+                ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, composed.parameters, undefined, undefined, composed.body), undefined, [
+                    ts.factory.createIdentifier("input"),
+                    ts.factory.createStringLiteral("$input"),
+                    ts.factory.createTrue(),
+                ])),
+                StatementFactory.constant({
+                    name: "success",
+                    value: ts.factory.createStrictEquality(ExpressionFactory.number(0), ts.factory.createIdentifier("errors.length")),
+                }),
+                ts.factory.createReturnStatement(ts.factory.createAsExpression(create_output(), TypeFactory.keyword("any"))),
+            ])),
+            ts.factory.createReturnStatement(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("success", ts.factory.createTrue()),
+                ts.factory.createPropertyAssignment("data", ts.factory.createIdentifier("input")),
+            ], true), TypeFactory.keyword("any"))),
+        ], true));
+        return {
+            functions: {
+                ...is.functions,
+                ...composed.functions,
+            },
+            statements: [
+                ...is.statements,
+                ...composed.statements,
+                StatementFactory.constant({
+                    name: "__is",
+                    value: is.arrow,
+                }),
+                StatementFactory.mut({ name: "errors" }),
+                StatementFactory.mut({ name: "_report" }),
+            ],
+            arrow,
+        };
+    };
+    ValidateProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = ValidateProgrammer.decompose({
+            config: props.config,
+            context: props.context,
+            modulo: props.modulo,
+            functor,
+            type: props.type,
+            name: props.name,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(ValidateProgrammer || (ValidateProgrammer = {}));
+const combine = (props) => (next) => {
+    if (next.explore.tracable === false)
+        return IsProgrammer.configure({
+            options: {
+                object: (v) => validate_object({
+                    context: props.context,
+                    functor: props.functor,
+                    config: props.config,
+                    entries: v.entries,
+                    input: v.input,
+                }),
+                numeric: true,
+            },
+            context: props.context,
+            functor: props.functor,
+        }).combiner(next);
+    const path = next.explore.postfix
+        ? `_path + ${next.explore.postfix}`
+        : "_path";
+    return next.logic === "and"
+        ? next.binaries
+            .map((binary) => binary.combined
+            ? binary.expression
+            : ts.factory.createLogicalOr(binary.expression, create_report_call({
+                exceptionable: next.explore.source === "top"
+                    ? ts.factory.createTrue()
+                    : ts.factory.createIdentifier("_exceptionable"),
+                path: ts.factory.createIdentifier(path),
+                expected: next.expected,
+                input: next.input,
+            })))
+            .reduce(ts.factory.createLogicalAnd)
+        : ts.factory.createLogicalOr(next.binaries
+            .map((binary) => binary.expression)
+            .reduce(ts.factory.createLogicalOr), create_report_call({
+            exceptionable: next.explore.source === "top"
+                ? ts.factory.createTrue()
+                : ts.factory.createIdentifier("_exceptionable"),
+            path: ts.factory.createIdentifier(path),
+            expected: next.expected,
+            input: next.input,
+        }));
+};
+const validate_object = (props) => check_object({
+    config: {
+        equals: props.config.equals,
+        undefined: true,
+        assert: false,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (input) => create_report_call({
+            path: ts.factory.createAdd(ts.factory.createIdentifier("_path"), ts.factory.createCallExpression(props.context.importer.internal("accessExpressionAsString"), undefined, [ts.factory.createIdentifier("key")])),
+            expected: "undefined",
+            input,
+        }),
+        halt: (expr) => ts.factory.createLogicalOr(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createIdentifier("_exceptionable")), expr),
+    },
+    context: props.context,
+    entries: props.entries,
+    input: props.input,
+});
+const joiner = (props) => ({
+    object: (v) => validate_object({
+        context: props.context,
+        functor: props.functor,
+        config: props.config,
+        entries: v.entries,
+        input: v.input,
+    }),
+    array: (props) => check_everything(ts.factory.createCallExpression(IdentifierFactory.access(props.input, "map"), undefined, [props.arrow])),
+    failure: (next) => create_report_call({
+        exceptionable: next.explore?.from === "top"
+            ? ts.factory.createTrue()
+            : ts.factory.createIdentifier("_exceptionable"),
+        path: ts.factory.createIdentifier(next.explore?.postfix ? `_path + ${next.explore.postfix}` : "_path"),
+        expected: next.expected,
+        input: next.input,
+    }),
+    tuple: (binaries) => check_everything(ts.factory.createArrayLiteralExpression(binaries, true)),
+});
+const create_output = () => ts.factory.createConditionalExpression(ts.factory.createIdentifier("success"), undefined, ts.factory.createObjectLiteralExpression([
+    ts.factory.createShorthandPropertyAssignment("success"),
+    ts.factory.createPropertyAssignment("data", ts.factory.createIdentifier("input")),
+], true), undefined, ts.factory.createObjectLiteralExpression([
+    ts.factory.createShorthandPropertyAssignment("success"),
+    ts.factory.createShorthandPropertyAssignment("errors"),
+    ts.factory.createPropertyAssignment("data", ts.factory.createIdentifier("input")),
+], true));
+const create_report_call = (props) => ts.factory.createCallExpression(ts.factory.createIdentifier("_report"), undefined, [
+    props.exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
+    ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment("path", props.path),
+        ts.factory.createPropertyAssignment("expected", ts.factory.createStringLiteral(props.expected)),
+        ts.factory.createPropertyAssignment("value", props.input),
+    ], true),
+]);
+
+export { ValidateProgrammer };
+//# sourceMappingURL=ValidateProgrammer.mjs.map

package/lib/programmers/ValidateProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalAssertFunctionProgrammer.mjs

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FunctionalAssertParametersProgrammer } from './FunctionalAssertParametersProgrammer.mjs';
+import { FunctionAssertReturnProgrammer } from './FunctionalAssertReturnProgrammer.mjs';
+
+var FunctionalAssertFunctionProgrammer;
+(function (FunctionalAssertFunctionProgrammer) {
+    FunctionalAssertFunctionProgrammer.write = (props) => {
+        const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+            context: props.context,
+            parameters: props.declaration.parameters,
+            init: props.init,
+        });
+        const p = FunctionalAssertParametersProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            config: props.config,
+            parameters: props.declaration.parameters,
+            wrapper: wrapper.name,
+        });
+        const r = FunctionAssertReturnProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            config: props.config,
+            expression: props.expression,
+            declaration: props.declaration,
+            wrapper: wrapper.name,
+        });
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            wrapper.variable,
+            ...p.functions,
+            ...r.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, props.declaration.type, undefined, ts.factory.createBlock([
+                ...p.expressions.map(ts.factory.createExpressionStatement),
+                ts.factory.createReturnStatement(r.value),
+            ]))),
+        ], true));
+    };
+    FunctionalAssertFunctionProgrammer.errorFactoryWrapper = (props) => {
+        const name = StringUtil.escapeDuplicate({
+            keep: props.parameters.map((p) => p.name.getText()),
+            input: "errorFactoryWrapper",
+        });
+        const variable = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(name, undefined, AssertProgrammer.Guardian.type(props.context), props.init ??
+                props.context.importer.internal("functionalTypeGuardErrorFactory")),
+        ], ts.NodeFlags.Const));
+        return { name, variable };
+    };
+    FunctionalAssertFunctionProgrammer.hookPath = (props) => ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("p")], undefined, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier(props.wrapper), undefined, [
+        ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
+            ts.factory.createPropertyAssignment("path", ts.factory.createConditionalExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("p"), "path"), undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("p"), "path"), "replace"), undefined, [
+                ts.factory.createStringLiteral("$input"),
+                ts.factory.createStringLiteral(props.replacer),
+            ]), undefined, ts.factory.createIdentifier("undefined"))),
+        ]),
+    ]));
+})(FunctionalAssertFunctionProgrammer || (FunctionalAssertFunctionProgrammer = {}));
+
+export { FunctionalAssertFunctionProgrammer };
+//# sourceMappingURL=FunctionalAssertFunctionProgrammer.mjs.map

package/lib/programmers/functional/FunctionalAssertFunctionProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalAssertParametersProgrammer.mjs

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FunctionalAssertFunctionProgrammer } from './FunctionalAssertFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionalAssertParametersProgrammer;
+(function (FunctionalAssertParametersProgrammer) {
+    FunctionalAssertParametersProgrammer.write = (props) => {
+        const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+            context: props.context,
+            parameters: props.declaration.parameters,
+            init: props.init,
+        });
+        const { async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const result = FunctionalAssertParametersProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            config: props.config,
+            parameters: props.declaration.parameters,
+            wrapper: wrapper.name,
+        });
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            wrapper.variable,
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, props.declaration.type, undefined, ts.factory.createBlock([
+                ...result.expressions.map(ts.factory.createExpressionStatement),
+                ts.factory.createReturnStatement(ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())))),
+            ], true))),
+        ], true));
+    };
+    FunctionalAssertParametersProgrammer.decompose = (props) => ({
+        functions: props.parameters.map((p, i) => StatementFactory.constant({
+            name: `__assert_param_${i}`,
+            value: AssertProgrammer.write({
+                context: props.context,
+                modulo: props.modulo,
+                config: {
+                    equals: props.config.equals,
+                    guard: false,
+                },
+                type: p.type
+                    ? props.context.checker.getTypeFromTypeNode(p.type)
+                    : props.context.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+                name: undefined,
+                init: FunctionalAssertFunctionProgrammer.hookPath({
+                    wrapper: props.wrapper,
+                    replacer: `$input.parameters[${i}]`,
+                }),
+            }),
+        })),
+        expressions: props.parameters.map((p, i) => ts.factory.createCallExpression(ts.factory.createIdentifier(`__assert_param_${i}`), undefined, [ts.factory.createIdentifier(p.name.getText())])),
+    });
+})(FunctionalAssertParametersProgrammer || (FunctionalAssertParametersProgrammer = {}));
+
+export { FunctionalAssertParametersProgrammer };
+//# sourceMappingURL=FunctionalAssertParametersProgrammer.mjs.map

package/lib/programmers/functional/FunctionalAssertParametersProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalAssertReturnProgrammer.mjs

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { AssertProgrammer } from '../AssertProgrammer.mjs';
+import { FunctionalAssertFunctionProgrammer } from './FunctionalAssertFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionAssertReturnProgrammer;
+(function (FunctionAssertReturnProgrammer) {
+    FunctionAssertReturnProgrammer.write = (props) => {
+        const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+            context: props.context,
+            parameters: props.declaration.parameters,
+            init: props.init,
+        });
+        const result = FunctionAssertReturnProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            config: props.config,
+            expression: props.expression,
+            declaration: props.declaration,
+            wrapper: wrapper.name,
+        });
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            wrapper.variable,
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, props.declaration.type, undefined, result.value)),
+        ], true));
+    };
+    FunctionAssertReturnProgrammer.decompose = (props) => {
+        const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const caller = ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())));
+        return {
+            async,
+            functions: [
+                StatementFactory.constant({
+                    name: "__assert_return",
+                    value: AssertProgrammer.write({
+                        context: props.context,
+                        modulo: props.modulo,
+                        config: {
+                            equals: props.config.equals,
+                            guard: false,
+                        },
+                        type,
+                        name: undefined,
+                        init: FunctionalAssertFunctionProgrammer.hookPath({
+                            wrapper: props.wrapper,
+                            replacer: "$input.return",
+                        }),
+                    }),
+                }),
+            ],
+            value: ts.factory.createCallExpression(ts.factory.createIdentifier("__assert_return"), undefined, [async ? ts.factory.createAwaitExpression(caller) : caller]),
+        };
+    };
+})(FunctionAssertReturnProgrammer || (FunctionAssertReturnProgrammer = {}));
+
+export { FunctionAssertReturnProgrammer };
+//# sourceMappingURL=FunctionalAssertReturnProgrammer.mjs.map

package/lib/programmers/functional/FunctionalAssertReturnProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalIsFunctionProgrammer.mjs

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { FunctionalIsParametersProgrammer } from './FunctionalIsParametersProgrammer.mjs';
+import { FunctionalIsReturnProgrammer } from './FunctionalIsReturnProgrammer.mjs';
+
+var FunctionalIsFunctionProgrammer;
+(function (FunctionalIsFunctionProgrammer) {
+    FunctionalIsFunctionProgrammer.write = (props) => {
+        const p = FunctionalIsParametersProgrammer.decompose(props);
+        const r = FunctionalIsReturnProgrammer.decompose(props);
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...p.functions,
+            ...r.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: r.async,
+            }), undefined, ts.factory.createBlock([...p.statements, ...r.statements], true))),
+        ], true));
+    };
+    FunctionalIsFunctionProgrammer.getReturnTypeNode = (props) => props.declaration.type
+        ? props.async
+            ? !!props.declaration.type.typeArguments?.[0]
+                ? ts.factory.createTypeReferenceNode("Promise", [
+                    ts.factory.createUnionTypeNode([
+                        props.declaration.type
+                            .typeArguments[0],
+                        ts.factory.createTypeReferenceNode("null"),
+                    ]),
+                ])
+                : undefined
+            : ts.factory.createUnionTypeNode([
+                props.declaration.type,
+                ts.factory.createTypeReferenceNode("null"),
+            ])
+        : undefined;
+})(FunctionalIsFunctionProgrammer || (FunctionalIsFunctionProgrammer = {}));
+
+export { FunctionalIsFunctionProgrammer };
+//# sourceMappingURL=FunctionalIsFunctionProgrammer.mjs.map

package/lib/programmers/functional/FunctionalIsFunctionProgrammer.mjs.map

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