react-hcl 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # react-hcl
 
-A transpiler that converts TSX into Terraform `.tf` files. Write Terraform configurations using JSX/TSX syntax with a custom JSX runtime (no React dependency).
+A transpiler that converts JSX/TSX into Terraform `.tf` files. Write Terraform configurations using JSX/TSX syntax with a custom JSX runtime (no React dependency).
 
 ## Why React for IaC?
 
@@ -263,4 +263,4 @@ bun run build
 ## Documentation
 
 - [Design Document](docs/design-doc.md)
-- [Implementation Plan](docs/plan.md)
+- [Product Requirements](docs/prd.md)

package/dist/cli.d.ts

@@ -1,10 +1,11 @@
 /**
  * CLI entry point for react-hcl.
  *
- * Usage: bun src/cli.ts <input.tsx> [-o <file>]
+ * Usage: bun src/cli.ts <input.(j|t)sx|-> [-o <file>]
+ *        cat input.jsx | bun src/cli.ts [-o <file>]
  *
  * Pipeline:
- *   1. Takes a user-authored .tsx file as input
+ *   1. Takes a user-authored JSX/TSX file as input
  *   2. Transpiles and bundles it with esbuild (JSX → custom runtime calls)
  *   3. Writes the bundled ESM code to a temp file and dynamically imports it
  *   4. render() evaluates the JSXElement tree into Block[] IR

package/dist/cli.js

@@ -31,6 +31,150 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/arg/index.js
+var require_arg = __commonJS({
+  "node_modules/arg/index.js"(exports, module) {
+    var flagSymbol = /* @__PURE__ */ Symbol("arg flag");
+    var ArgError = class _ArgError extends Error {
+      constructor(msg, code) {
+        super(msg);
+        this.name = "ArgError";
+        this.code = code;
+        Object.setPrototypeOf(this, _ArgError.prototype);
+      }
+    };
+    function arg(opts, {
+      argv = process.argv.slice(2),
+      permissive = false,
+      stopAtPositional = false
+    } = {}) {
+      if (!opts) {
+        throw new ArgError(
+          "argument specification object is required",
+          "ARG_CONFIG_NO_SPEC"
+        );
+      }
+      const result = { _: [] };
+      const aliases = {};
+      const handlers = {};
+      for (const key of Object.keys(opts)) {
+        if (!key) {
+          throw new ArgError(
+            "argument key cannot be an empty string",
+            "ARG_CONFIG_EMPTY_KEY"
+          );
+        }
+        if (key[0] !== "-") {
+          throw new ArgError(
+            `argument key must start with '-' but found: '${key}'`,
+            "ARG_CONFIG_NONOPT_KEY"
+          );
+        }
+        if (key.length === 1) {
+          throw new ArgError(
+            `argument key must have a name; singular '-' keys are not allowed: ${key}`,
+            "ARG_CONFIG_NONAME_KEY"
+          );
+        }
+        if (typeof opts[key] === "string") {
+          aliases[key] = opts[key];
+          continue;
+        }
+        let type = opts[key];
+        let isFlag = false;
+        if (Array.isArray(type) && type.length === 1 && typeof type[0] === "function") {
+          const [fn] = type;
+          type = (value, name, prev = []) => {
+            prev.push(fn(value, name, prev[prev.length - 1]));
+            return prev;
+          };
+          isFlag = fn === Boolean || fn[flagSymbol] === true;
+        } else if (typeof type === "function") {
+          isFlag = type === Boolean || type[flagSymbol] === true;
+        } else {
+          throw new ArgError(
+            `type missing or not a function or valid array type: ${key}`,
+            "ARG_CONFIG_VAD_TYPE"
+          );
+        }
+        if (key[1] !== "-" && key.length > 2) {
+          throw new ArgError(
+            `short argument keys (with a single hyphen) must have only one character: ${key}`,
+            "ARG_CONFIG_SHORTOPT_TOOLONG"
+          );
+        }
+        handlers[key] = [type, isFlag];
+      }
+      for (let i = 0, len = argv.length; i < len; i++) {
+        const wholeArg = argv[i];
+        if (stopAtPositional && result._.length > 0) {
+          result._ = result._.concat(argv.slice(i));
+          break;
+        }
+        if (wholeArg === "--") {
+          result._ = result._.concat(argv.slice(i + 1));
+          break;
+        }
+        if (wholeArg.length > 1 && wholeArg[0] === "-") {
+          const separatedArguments = wholeArg[1] === "-" || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split("").map((a) => `-${a}`);
+          for (let j = 0; j < separatedArguments.length; j++) {
+            const arg2 = separatedArguments[j];
+            const [originalArgName, argStr] = arg2[1] === "-" ? arg2.split(/=(.*)/, 2) : [arg2, void 0];
+            let argName = originalArgName;
+            while (argName in aliases) {
+              argName = aliases[argName];
+            }
+            if (!(argName in handlers)) {
+              if (permissive) {
+                result._.push(arg2);
+                continue;
+              } else {
+                throw new ArgError(
+                  `unknown or unexpected option: ${originalArgName}`,
+                  "ARG_UNKNOWN_OPTION"
+                );
+              }
+            }
+            const [type, isFlag] = handlers[argName];
+            if (!isFlag && j + 1 < separatedArguments.length) {
+              throw new ArgError(
+                `option requires argument (but was followed by another short argument): ${originalArgName}`,
+                "ARG_MISSING_REQUIRED_SHORTARG"
+              );
+            }
+            if (isFlag) {
+              result[argName] = type(true, argName, result[argName]);
+            } else if (argStr === void 0) {
+              if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === "-" && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number || // eslint-disable-next-line no-undef
+              typeof BigInt !== "undefined" && type === BigInt))) {
+                const extended = originalArgName === argName ? "" : ` (alias for ${argName})`;
+                throw new ArgError(
+                  `option requires argument: ${originalArgName}${extended}`,
+                  "ARG_MISSING_REQUIRED_LONGARG"
+                );
+              }
+              result[argName] = type(argv[i + 1], argName, result[argName]);
+              ++i;
+            } else {
+              result[argName] = type(argStr, argName, result[argName]);
+            }
+          }
+        } else {
+          result._.push(wholeArg);
+        }
+      }
+      return result;
+    }
+    arg.flag = (fn) => {
+      fn[flagSymbol] = true;
+      return fn;
+    };
+    arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
+    arg.ArgError = ArgError;
+    module.exports = arg;
+  }
+});
+
 // node_modules/hcl2-parser/dist/index.js
 var require_dist = __commonJS({
   "node_modules/hcl2-parser/dist/index.js"(exports, module) {
@@ -210584,6 +210728,8 @@ var require_dist = __commonJS({
 });
 
 // src/cli.ts
+var import_arg = __toESM(require_arg(), 1);
+import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -210910,28 +211056,81 @@ function render(element) {
 // src/cli.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  let inputFile;
-  let output;
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === "-o" || args[i] === "--output") && i + 1 < args.length) {
-      output = args[++i];
-    } else if (!inputFile) {
-      inputFile = args[i];
+function resolvePackageEntrypoint(candidates) {
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
     }
   }
-  if (!inputFile) {
-    console.error("Usage: react-hcl <input.tsx> [-o <file>]");
-    process.exit(1);
+  return candidates[0];
+}
+function parseArgs(argv) {
+  const args = (0, import_arg.default)(
+    {
+      "--help": Boolean,
+      "--output": String,
+      "-h": "--help",
+      "-o": "--output"
+    },
+    { argv: argv.slice(2), permissive: true }
+  );
+  return {
+    inputFile: args._[0] ?? "",
+    output: args["--output"],
+    help: Boolean(args["--help"])
+  };
+}
+function printUsage() {
+  console.error("Usage: react-hcl <input.(j|t)sx|-> [-o <file>]");
+}
+function printHelp() {
+  process.stdout.write(
+    [
+      "react-hcl - Convert JSX/TSX to Terraform HCL",
+      "",
+      "Usage:",
+      "  react-hcl <input.(j|t)sx|-> [-o <file>]",
+      "  cat input.jsx | react-hcl [-o <file>]",
+      "",
+      "Options:",
+      "  -o, --output <file>  Write output to file instead of stdout",
+      "  -h, --help           Show help",
+      ""
+    ].join("\n")
+  );
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
   }
-  return { inputFile, output };
+  return Buffer.concat(chunks).toString("utf8");
 }
 async function main() {
-  const { inputFile, output } = parseArgs(process.argv);
-  const absoluteInput = resolve(inputFile);
-  const result = await esbuild.build({
-    entryPoints: [absoluteInput],
+  let parsedArgs;
+  try {
+    parsedArgs = parseArgs(process.argv);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    printUsage();
+    process.exit(1);
+  }
+  const { inputFile, output, help } = parsedArgs;
+  if (help) {
+    printHelp();
+    return;
+  }
+  const stdinContents = process.stdin.isTTY ? "" : await readStdin();
+  const hasStdin = stdinContents.trim().length > 0;
+  const wantsStdin = inputFile === "-" || !inputFile && hasStdin;
+  const hasFileInput = Boolean(inputFile && inputFile !== "-");
+  if (hasFileInput && hasStdin) {
+    console.error("Cannot use stdin and input file together.");
+    printUsage();
+    process.exit(1);
+  }
+  const buildBaseOptions = {
     bundle: true,
     format: "esm",
     platform: "node",
@@ -210939,11 +211138,46 @@ async function main() {
     jsxImportSource: "react-hcl",
     write: false,
     alias: {
-      "react-hcl/jsx-runtime": resolve(__dirname, "../src/jsx-runtime.ts"),
-      "react-hcl": resolve(__dirname, "../src/index.ts")
+      "react-hcl/jsx-runtime": resolvePackageEntrypoint([
+        resolve(__dirname, "jsx-runtime.js"),
+        resolve(__dirname, "../src/jsx-runtime.ts")
+      ]),
+      "react-hcl": resolvePackageEntrypoint([
+        resolve(__dirname, "index.js"),
+        resolve(__dirname, "../src/index.ts")
+      ])
+    }
+  };
+  let result;
+  if (wantsStdin) {
+    if (!hasStdin) {
+      printUsage();
+      process.exit(1);
     }
-  });
-  const code = result.outputFiles[0].text;
+    result = await esbuild.build({
+      ...buildBaseOptions,
+      stdin: {
+        contents: stdinContents,
+        loader: "tsx",
+        resolveDir: process.cwd(),
+        sourcefile: "stdin.tsx"
+      }
+    });
+  } else if (inputFile) {
+    const absoluteInput = resolve(inputFile);
+    result = await esbuild.build({
+      ...buildBaseOptions,
+      entryPoints: [absoluteInput]
+    });
+  } else {
+    printUsage();
+    process.exit(1);
+  }
+  const outputFile = result.outputFiles?.[0];
+  if (!outputFile) {
+    throw new Error("esbuild did not produce any output file.");
+  }
+  const code = outputFile.text;
   const tmpDir = await mkdtemp(join(tmpdir(), "react-hcl-"));
   const tmpFile = join(tmpDir, "bundle.mjs");
   try {

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * Public API entry point for the react-hcl package.
  *
  * This module re-exports all user-facing components and utilities.
- * Users import from "react-hcl" in their TSX files:
+ * Users import from "react-hcl" in their JSX/TSX files:
  *
  *   import { Resource, Fragment } from "react-hcl";
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-hcl",
-  "version": "0.1.0",
-  "description": "TSX to Terraform (.tf) transpiler with a custom JSX runtime",
+  "version": "0.1.1",
+  "description": "JSX/TSX to Terraform (.tf) transpiler with a custom JSX runtime",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,6 +41,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.15",
     "@types/bun": "^1.3.9",
+    "arg": "^5.0.2",
     "hcl2-parser": "^1.0.3"
   },
   "peerDependencies": {