422 statement

README.md

@@ -29,13 +29,11 @@ import {
   logicalAnd,
   type Module,
   notEqual,
-  statementEvaluateExpr,
-  statementIf,
-  statementVariableDefinition,
   stringLiteral,
   typeUnion,
   variable,
-} from "jsr:@narumincho/js-ts-code-generator";
+} from "./mod.ts";
+import * as statement from "./statement.ts";
 
 const serverModule: Module = {
   definitionList: [
@@ -76,7 +74,7 @@ const serverModule: Module = {
       ],
       returnType: { type: "Void" },
       statementList: [
-        statementVariableDefinition({
+        statement.variableDefinition({
           isConst: true,
           name: identifierFromString("accept"),
           type: typeUnion([{ type: "String" }, { type: "Undefined" }]),
@@ -88,7 +86,7 @@ const serverModule: Module = {
             "accept",
           ),
         }),
-        statementIf({
+        statement.if({
           condition: logicalAnd(
             notEqual(
               variable(identifierFromString("accept")),
@@ -101,7 +99,7 @@ const serverModule: Module = {
             ),
           ),
           thenStatementList: [
-            statementEvaluateExpr(
+            statement.evaluateExpr(
               callMethod(
                 variable(identifierFromString("response")),
                 "setHeader",

deno.json

@@ -2,7 +2,10 @@
   "name": "@narumincho/js-ts-code-generator",
   "version": "0.2.0",
   "license": "MIT",
-  "exports": "./mod.ts",
+  "exports": {
+    ".": "./mod.ts",
+    "./statement": "./statement.ts"
+  },
   "compilerOptions": {
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true

interface.ts

@@ -113,7 +113,7 @@ export const typeofExpr = (expr: d.TsExpr): d.TsExpr => ({
 export const exponentiation = (left: d.TsExpr, right: d.TsExpr): d.TsExpr => ({
   type: "BinaryOperator",
   binaryOperatorExpr: {
-    operator: "Multiplication",
+    operator: "Exponentiation",
     left,
     right,
   },
@@ -496,22 +496,6 @@ export const newSet = (initValueList: d.TsExpr): d.TsExpr => ({
   },
 });
 
-/**
- * ```ts
- * console.log(expr)
- * ```
- */
-export const consoleLog = (expr: d.TsExpr): d.Statement => ({
-  type: "EvaluateExpr",
-  tsExpr: callMethod(
-    {
-      type: "GlobalObjects",
-      tsIdentifier: identifier.identifierFromString("console"),
-    },
-    "log",
-    [expr],
-  ),
-});
 /**
  * `Array<elementType>`
  */
@@ -686,16 +670,6 @@ export const typeScopeInFileNoArguments = (
   },
 });
 
-export const statementReturn = (expr: d.TsExpr): d.Statement => ({
-  type: "Return",
-  tsExpr: expr,
-});
-
-export const statementEvaluateExpr = (expr: d.TsExpr): d.Statement => ({
-  type: "EvaluateExpr",
-  tsExpr: expr,
-});
-
 export const newTextDecoder: d.TsExpr = {
   type: "New",
   callExpr: {
@@ -752,30 +726,6 @@ export const call = (
   callExpr: { expr, parameterList },
 });
 
-export const statementIf = (ifStatement: d.IfStatement): d.Statement => ({
-  type: "If",
-  ifStatement,
-});
-
-export const statementVariableDefinition = (
-  variableDefinitionStatement: d.VariableDefinitionStatement,
-): d.Statement => ({
-  type: "VariableDefinition",
-  variableDefinitionStatement,
-});
-
-export const statementFor = (forStatement: d.ForStatement): d.Statement => ({
-  type: "For",
-  forStatement,
-});
-
-export const statementForOf = (
-  forOfStatement: d.ForOfStatement,
-): d.Statement => ({
-  type: "ForOf",
-  forOfStatement,
-});
-
 export const arrayLiteral = (
   arrayItemList: ReadonlyArray<d.ArrayItem>,
 ): d.TsExpr => ({
@@ -788,11 +738,6 @@ export const typeAssertion = (param: d.TypeAssertion): d.TsExpr => ({
   typeAssertion: param,
 });
 
-export const statementSet = (setStatement: d.SetStatement): d.Statement => ({
-  type: "Set",
-  setStatement,
-});
-
 /**
  * ラムダ式の型を抽出する
  */

sample.ts

@@ -7,13 +7,11 @@ import {
   logicalAnd,
   type Module,
   notEqual,
-  statementEvaluateExpr,
-  statementIf,
-  statementVariableDefinition,
   stringLiteral,
   typeUnion,
   variable,
 } from "./mod.ts";
+import * as statement from "./statement.ts";
 
 const serverModule: Module = {
   definitionList: [
@@ -54,7 +52,7 @@ const serverModule: Module = {
       ],
       returnType: { type: "Void" },
       statementList: [
-        statementVariableDefinition({
+        statement.variableDefinition({
           isConst: true,
           name: identifierFromString("accept"),
           type: typeUnion([{ type: "String" }, { type: "Undefined" }]),
@@ -66,7 +64,7 @@ const serverModule: Module = {
             "accept",
           ),
         }),
-        statementIf({
+        statement.if({
           condition: logicalAnd(
             notEqual(
               variable(identifierFromString("accept")),
@@ -79,7 +77,7 @@ const serverModule: Module = {
             ),
           ),
           thenStatementList: [
-            statementEvaluateExpr(
+            statement.evaluateExpr(
               callMethod(
                 variable(identifierFromString("response")),
                 "setHeader",

statement.ts

@@ -0,0 +1,103 @@
+// c:\Users\narum\Documents\GitHub\js-ts-code-generator\statement.ts
+import type {
+  ForOfStatement,
+  ForStatement,
+  IfStatement,
+  SetStatement,
+  Statement,
+  TsExpr,
+  VariableDefinitionStatement,
+} from "./data.ts";
+import { identifierFromString } from "./identifier.ts";
+import { callMethod } from "./interface.ts";
+
+/**
+ * ```ts
+ * console.log(expr)
+ * ```
+ * @param expr 出力する式
+ */
+export const consoleLog = (expr: TsExpr): Statement => ({
+  type: "EvaluateExpr",
+  tsExpr: callMethod(
+    {
+      type: "GlobalObjects",
+      tsIdentifier: identifierFromString("console"),
+    },
+    "log",
+    [expr],
+  ),
+});
+
+/**
+ * return 文 `return expr;`
+ * @param expr 返す式
+ */
+const statementReturn = (expr: TsExpr): Statement => ({
+  type: "Return",
+  tsExpr: expr,
+});
+
+export { statementReturn as return };
+
+/**
+ * 式の評価文 `expr;`
+ * @param expr 評価する式
+ */
+export const evaluateExpr = (expr: TsExpr): Statement => ({
+  type: "EvaluateExpr",
+  tsExpr: expr,
+});
+
+/**
+ * if 文
+ * @param ifStatement if 文のデータ
+ */
+const statementIf = (ifStatement: IfStatement): Statement => ({
+  type: "If",
+  ifStatement,
+});
+
+export { statementIf as if };
+
+/**
+ * 変数定義文 `const name = expr;` または `let name = expr;`
+ * @param variableDefinitionStatement 変数定義文のデータ
+ */
+export const variableDefinition = (
+  variableDefinitionStatement: VariableDefinitionStatement,
+): Statement => ({
+  type: "VariableDefinition",
+  variableDefinitionStatement,
+});
+
+/**
+ * for 文 `for (let i = 0; i < count; ++i) { ... }`
+ * @param forStatement for 文のデータ
+ */
+const statementFor = (forStatement: ForStatement): Statement => ({
+  type: "For",
+  forStatement,
+});
+
+export { statementFor as for };
+
+/**
+ * for-of 文 `for (const element of array) { ... }`
+ * @param forOfStatement for-of 文のデータ
+ */
+export const forOf = (
+  forOfStatement: ForOfStatement,
+): Statement => ({
+  type: "ForOf",
+  forOfStatement,
+});
+
+/**
+ * 代入文 `target = expr;`
+ * @param setStatement 代入文のデータ
+ */
+export const set = (setStatement: SetStatement): Statement => ({
+  type: "Set",
+  setStatement,
+});