typia 8.0.0 → 8.0.1

package/lib/programmers/misc/MiscValidateCloneProgrammer.mjs

@@ -0,0 +1,69 @@
+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 { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { MiscCloneProgrammer } from './MiscCloneProgrammer.mjs';
+
+var MiscValidateCloneProgrammer;
+(function (MiscValidateCloneProgrammer) {
+    MiscValidateCloneProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            config: {
+                equals: false,
+            },
+        });
+        const clone = MiscCloneProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...validate.functions,
+                ...clone.functions,
+            },
+            statements: [
+                ...validate.statements,
+                ...clone.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__clone",
+                    value: clone.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [clone.arrow.type ?? TypeFactory.keyword("any")],
+            }), undefined, ts.factory.createBlock([
+                StatementFactory.constant({
+                    name: "result",
+                    value: ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [ts.factory.createIdentifier("input")]), TypeFactory.keyword("any")),
+                }),
+                ts.factory.createIfStatement(ts.factory.createIdentifier("result.success"), ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("result.data"), ts.SyntaxKind.EqualsToken, ts.factory.createCallExpression(ts.factory.createIdentifier("__clone"), undefined, [ts.factory.createIdentifier("input")])))),
+                ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+            ], true)),
+        };
+    };
+    MiscValidateCloneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = MiscValidateCloneProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(MiscValidateCloneProgrammer || (MiscValidateCloneProgrammer = {}));
+
+export { MiscValidateCloneProgrammer };
+//# sourceMappingURL=MiscValidateCloneProgrammer.mjs.map

package/lib/programmers/misc/MiscValidateCloneProgrammer.mjs.map

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

package/lib/programmers/misc/MiscValidatePruneProgrammer.mjs

@@ -0,0 +1,75 @@
+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 { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { MiscPruneProgrammer } from './MiscPruneProgrammer.mjs';
+
+var MiscValidatePruneProgrammer;
+(function (MiscValidatePruneProgrammer) {
+    MiscValidatePruneProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            config: {
+                equals: false,
+            },
+        });
+        const prune = MiscPruneProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...validate.functions,
+                ...prune.functions,
+            },
+            statements: [
+                ...validate.statements,
+                ...prune.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__prune",
+                    value: prune.arrow,
+                }),
+            ],
+            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([
+                StatementFactory.constant({
+                    name: "result",
+                    value: ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [ts.factory.createIdentifier("input")]),
+                }),
+                ts.factory.createIfStatement(ts.factory.createIdentifier("result.success"), ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("__prune"), undefined, [ts.factory.createIdentifier("input")]))),
+                ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+            ], true)),
+        };
+    };
+    MiscValidatePruneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = MiscValidatePruneProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(MiscValidatePruneProgrammer || (MiscValidatePruneProgrammer = {}));
+
+export { MiscValidatePruneProgrammer };
+//# sourceMappingURL=MiscValidatePruneProgrammer.mjs.map

package/lib/programmers/misc/MiscValidatePruneProgrammer.mjs.map

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

package/lib/programmers/notations/NotationAssertGeneralProgrammer.mjs

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

package/lib/programmers/notations/NotationAssertGeneralProgrammer.mjs.map

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