npm - typia - Versions diffs - 6.7.0 → 6.7.1 - Mend

typia 6.7.0 → 6.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (85) hide show

package/lib/programmers/AssertProgrammer.d.ts +0 -1
package/lib/programmers/AssertProgrammer.js.map +1 -1
package/lib/programmers/CheckerProgrammer.d.ts +1 -1
package/lib/programmers/FeatureProgrammer.d.ts +1 -1
package/lib/programmers/IsProgrammer.d.ts +1 -1
package/lib/programmers/RandomProgrammer.d.ts +10 -1
package/lib/programmers/RandomProgrammer.js +62 -37
package/lib/programmers/RandomProgrammer.js.map +1 -1
package/lib/programmers/ValidateProgrammer.d.ts +1 -1
package/lib/programmers/json/JsonIsParseProgrammer.d.ts +1 -1
package/lib/programmers/json/JsonIsStringifyProgrammer.d.ts +1 -1
package/lib/programmers/json/JsonStringifyProgrammer.d.ts +1 -1
package/lib/programmers/json/JsonStringifyProgrammer.js +1 -3
package/lib/programmers/json/JsonStringifyProgrammer.js.map +1 -1
package/lib/programmers/json/JsonValidateParseProgrammer.d.ts +1 -1
package/lib/programmers/json/JsonValidateStringifyProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscCloneProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscCloneProgrammer.js +33 -14
package/lib/programmers/misc/MiscCloneProgrammer.js.map +1 -1
package/lib/programmers/misc/MiscIsCloneProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscIsPruneProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscPruneProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscValidateCloneProgrammer.d.ts +1 -1
package/lib/programmers/misc/MiscValidatePruneProgrammer.d.ts +1 -1
package/lib/programmers/notations/NotationGeneralProgrammer.d.ts +1 -1
package/lib/programmers/notations/NotationGeneralProgrammer.js +30 -11
package/lib/programmers/notations/NotationGeneralProgrammer.js.map +1 -1
package/lib/programmers/notations/NotationValidateGeneralProgrammer.d.ts +1 -1
package/package.json +1 -1
package/src/programmers/AssertProgrammer.ts +397 -398
package/src/programmers/CheckerProgrammer.ts +1138 -1138
package/src/programmers/FeatureProgrammer.ts +549 -549
package/src/programmers/IsProgrammer.ts +1 -1
package/src/programmers/RandomProgrammer.ts +112 -77
package/src/programmers/ValidateProgrammer.ts +382 -382
package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts +141 -141
package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts +108 -108
package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts +98 -98
package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts +72 -72
package/src/programmers/functional/FunctionalIsParametersProgrammer.ts +101 -101
package/src/programmers/functional/FunctionalIsReturnProgrammer.ts +106 -106
package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts +123 -123
package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts +267 -267
package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts +126 -126
package/src/programmers/helpers/FunctionImporter.ts +97 -97
package/src/programmers/http/HttpAssertFormDataProgrammer.ts +91 -91
package/src/programmers/http/HttpAssertHeadersProgrammer.ts +91 -91
package/src/programmers/http/HttpAssertQueryProgrammer.ts +93 -93
package/src/programmers/http/HttpFormDataProgrammer.ts +278 -278
package/src/programmers/http/HttpHeadersProgrammer.ts +347 -347
package/src/programmers/http/HttpIsFormDataProgrammer.ts +102 -102
package/src/programmers/http/HttpIsHeadersProgrammer.ts +102 -102
package/src/programmers/http/HttpIsQueryProgrammer.ts +104 -104
package/src/programmers/http/HttpQueryProgrammer.ts +298 -298
package/src/programmers/http/HttpValidateFormDataProgrammer.ts +85 -85
package/src/programmers/http/HttpValidateHeadersProgrammer.ts +85 -85
package/src/programmers/http/HttpValidateQueryProgrammer.ts +87 -87
package/src/programmers/json/JsonAssertParseProgrammer.ts +96 -96
package/src/programmers/json/JsonAssertStringifyProgrammer.ts +104 -104
package/src/programmers/json/JsonIsParseProgrammer.ts +110 -110
package/src/programmers/json/JsonIsStringifyProgrammer.ts +102 -102
package/src/programmers/json/JsonStringifyProgrammer.ts +909 -910
package/src/programmers/json/JsonValidateParseProgrammer.ts +87 -87
package/src/programmers/json/JsonValidateStringifyProgrammer.ts +111 -111
package/src/programmers/misc/MiscAssertCloneProgrammer.ts +87 -87
package/src/programmers/misc/MiscAssertPruneProgrammer.ts +87 -87
package/src/programmers/misc/MiscCloneProgrammer.ts +781 -759
package/src/programmers/misc/MiscIsCloneProgrammer.ts +93 -93
package/src/programmers/misc/MiscIsPruneProgrammer.ts +94 -94
package/src/programmers/misc/MiscPruneProgrammer.ts +560 -560
package/src/programmers/misc/MiscValidateCloneProgrammer.ts +104 -104
package/src/programmers/misc/MiscValidatePruneProgrammer.ts +98 -98
package/src/programmers/notations/NotationAssertGeneralProgrammer.ts +91 -91
package/src/programmers/notations/NotationGeneralProgrammer.ts +709 -685
package/src/programmers/notations/NotationIsGeneralProgrammer.ts +97 -97
package/src/programmers/notations/NotationValidateGeneralProgrammer.ts +107 -107
package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts +91 -91
package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts +95 -95
package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts +646 -646
package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts +852 -852
package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts +104 -104
package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts +93 -93
package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts +85 -85
package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts +109 -109
package/src/transformers/internal/GenericTransformer.ts +104 -104

package/src/programmers/misc/MiscValidateCloneProgrammer.ts CHANGED Viewed

@@ -1,104 +1,104 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { IProject } from "../../transformers/IProject";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-export namespace MiscValidateCloneProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name?: string;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      equals: false,
-    });
-    const clone = MiscCloneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...validate.functions,
-        ...clone.functions,
-      },
-      statements: [
-        ...validate.statements,
-        ...clone.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__clone", clone.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          clone.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
-        undefined,
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant(
-              "result",
-              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,
-        ),
-      ),
-    };
-  };
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IProject } from "../../transformers/IProject";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+export namespace MiscValidateCloneProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    modulo: ts.LeftHandSideExpression;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      equals: false,
+    });
+    const clone = MiscCloneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...validate.functions,
+        ...clone.functions,
+      },
+      statements: [
+        ...validate.statements,
+        ...clone.statements,
+        StatementFactory.constant("__validate", validate.arrow),
+        StatementFactory.constant("__clone", clone.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        ts.factory.createTypeReferenceNode("typia.IValidation", [
+          clone.arrow.type ?? TypeFactory.keyword("any"),
+        ]),
+        undefined,
+        ts.factory.createBlock(
+          [
+            StatementFactory.constant(
+              "result",
+              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,
+        ),
+      ),
+    };
+  };
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        modulo,
+        importer,
+        type,
+        name,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/programmers/misc/MiscValidatePruneProgrammer.ts CHANGED Viewed

@@ -1,98 +1,98 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { IProject } from "../../transformers/IProject";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
-export namespace MiscValidatePruneProgrammer {
-  export const decompose = (props: {
-    project: IProject;
-    modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name?: string;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate: FeatureProgrammer.IDecomposed =
-      ValidateProgrammer.decompose({
-        ...props,
-        equals: false,
-      });
-    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...validate.functions,
-        ...prune.functions,
-      },
-      statements: [
-        ...validate.statements,
-        ...prune.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__prune", prune.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          prune.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
-        undefined,
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant(
-              "result",
-              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,
-        ),
-      ),
-    };
-  };
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IProject } from "../../transformers/IProject";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
+export namespace MiscValidatePruneProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    modulo: ts.LeftHandSideExpression;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate: FeatureProgrammer.IDecomposed =
+      ValidateProgrammer.decompose({
+        ...props,
+        equals: false,
+      });
+    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...validate.functions,
+        ...prune.functions,
+      },
+      statements: [
+        ...validate.statements,
+        ...prune.statements,
+        StatementFactory.constant("__validate", validate.arrow),
+        StatementFactory.constant("__prune", prune.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        ts.factory.createTypeReferenceNode("typia.IValidation", [
+          prune.arrow.type ?? TypeFactory.keyword("any"),
+        ]),
+        undefined,
+        ts.factory.createBlock(
+          [
+            StatementFactory.constant(
+              "result",
+              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,
+        ),
+      ),
+    };
+  };
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        modulo,
+        importer,
+        type,
+        name,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts CHANGED Viewed

@@ -1,91 +1,91 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-import { IProject } from "../../transformers/IProject";
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
-export namespace NotationAssertGeneralProgrammer {
-  export const decompose = (props: {
-    rename: (str: string) => string;
-    project: IProject;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name: string | undefined;
-    init: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      equals: false,
-      guard: false,
-    });
-    const notation: FeatureProgrammer.IDecomposed =
-      NotationGeneralProgrammer.decompose({
-        ...props,
-        validated: true,
-      });
-    return {
-      functions: {
-        ...assert.functions,
-        ...notation.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...notation.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(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(),
-              ],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-  export const write =
-    (rename: (str: string) => string) =>
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        rename,
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IProject } from "../../transformers/IProject";
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
+export namespace NotationAssertGeneralProgrammer {
+  export const decompose = (props: {
+    rename: (str: string) => string;
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      equals: false,
+      guard: false,
+    });
+    const notation: FeatureProgrammer.IDecomposed =
+      NotationGeneralProgrammer.decompose({
+        ...props,
+        validated: true,
+      });
+    return {
+      functions: {
+        ...assert.functions,
+        ...notation.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...notation.statements,
+        StatementFactory.constant("__assert", assert.arrow),
+        StatementFactory.constant("__notation", notation.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(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(),
+              ],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+  export const write =
+    (rename: (str: string) => string) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        rename,
+        project,
+        importer,
+        type,
+        name,
+        init,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}