wlmaker 1.0.0

package/README.md

@@ -0,0 +1 @@
+# wlmaker-cli

package/dist/cli.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/core/create-bloc.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk from "chalk";
+import { pascalCase } from "change-case";
+
+// src/core/templates.ts
+function blocTemplate(name, pascal) {
+  return `import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part '${name}_bloc.freezed.dart';
+part '${name}_event.dart';
+part '${name}_state.dart';
+
+class ${pascal}Bloc extends Bloc<${pascal}Event, ${pascal}State> {
+  ${pascal}Bloc() : super(${pascal}State.initial()) {
+    on<_Started>(_startedEvent);
+  }
+
+  void _startedEvent(_Started event, Emitter<${pascal}State> emit) {
+    // TODO: implement event
+  }
+}
+`;
+}
+function blocEventTemplate(name, pascal) {
+  return `part of '${name}_bloc.dart';
+
+@freezed
+sealed class ${pascal}Event with _$${pascal}Event {
+  const factory ${pascal}Event.started() = _Started;
+}
+`;
+}
+function blocStateTemplate(name, pascal) {
+  return `part of '${name}_bloc.dart';
+
+@freezed
+sealed class ${pascal}State with _$${pascal}State {
+  const factory ${pascal}State({
+    @Default(false) bool fakeVar,
+  }) = _${pascal}State;
+
+  const ${pascal}State._();
+
+  factory ${pascal}State.initial() => const ${pascal}State();
+}
+`;
+}
+
+// src/core/barrel.ts
+import * as fs from "fs";
+import * as path from "path";
+function updateBarrelFile(parentDir, name) {
+  const barrelPath = path.join(parentDir, "bloc.dart");
+  const exportLine = `export '${name}/${name}_bloc.dart';`;
+  if (fs.existsSync(barrelPath)) {
+    const content = fs.readFileSync(barrelPath, "utf8");
+    if (content.includes(exportLine)) {
+      return;
+    }
+    fs.writeFileSync(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
+  } else {
+    fs.writeFileSync(barrelPath, exportLine + "\n");
+  }
+}
+
+// src/core/build-runner.ts
+import { spawn } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function findPubspecDir(startDir) {
+  let dir = startDir;
+  while (dir !== path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, "pubspec.yaml"))) {
+      return dir;
+    }
+    dir = path2.dirname(dir);
+  }
+  return void 0;
+}
+function hasBuildRunner(projectRoot) {
+  const pubspec = fs2.readFileSync(path2.join(projectRoot, "pubspec.yaml"), "utf8");
+  return /build_runner/.test(pubspec);
+}
+function runBuildRunner(projectRoot) {
+  return new Promise((resolve2) => {
+    const child = spawn(
+      "dart",
+      ["run", "build_runner", "build", "--delete-conflicting-outputs"],
+      { cwd: projectRoot, stdio: "inherit" }
+    );
+    child.on("close", (code) => {
+      resolve2();
+    });
+    child.on("error", () => {
+      resolve2();
+    });
+  });
+}
+
+// src/core/create-bloc.ts
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createBloc(name, options) {
+  const targetDir = path3.resolve(options.dir);
+  if (!name || name.trim().length === 0) {
+    console.error(chalk.red("Error: Name cannot be empty."));
+    process.exit(1);
+  }
+  if (!SNAKE_CASE_REGEX.test(name)) {
+    console.error(chalk.red("Error: Name must be snake_case (lowercase letters, digits, underscores)."));
+    process.exit(1);
+  }
+  if (fs3.existsSync(path3.join(targetDir, name))) {
+    console.error(chalk.red(`Error: Directory "${name}" already exists.`));
+    process.exit(1);
+  }
+  const pascal = pascalCase(name);
+  const blocDir = path3.join(targetDir, name);
+  try {
+    fs3.mkdirSync(blocDir, { recursive: true });
+    fs3.writeFileSync(path3.join(blocDir, `${name}_bloc.dart`), blocTemplate(name, pascal));
+    fs3.writeFileSync(path3.join(blocDir, `${name}_event.dart`), blocEventTemplate(name, pascal));
+    fs3.writeFileSync(path3.join(blocDir, `${name}_state.dart`), blocStateTemplate(name, pascal));
+    updateBarrelFile(targetDir, name);
+    console.log(chalk.green(`\u2713 BLoC "${pascal}Bloc" created successfully.`));
+    if (options.buildRunner) {
+      const projectRoot = findPubspecDir(targetDir);
+      if (projectRoot && hasBuildRunner(projectRoot)) {
+        console.log(chalk.blue("Running build_runner..."));
+        await runBuildRunner(projectRoot);
+        console.log(chalk.green("\u2713 build_runner completed."));
+      } else {
+        console.log(chalk.yellow("Skipping build_runner (no pubspec.yaml or build_runner dependency found)."));
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to create BLoC: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("wlmaker").description("Create Flutter BLoCs with Freezed sealed classes from the terminal").version("1.0.0");
+program.command("bloc").description("Create a new BLoC with Freezed sealed classes").argument("<name>", "BLoC name in snake_case (e.g. user_login)").option("-d, --dir <path>", "target directory", process.cwd()).option("--no-build-runner", "skip build_runner execution").action(async (name, options) => {
+  await createBloc(name, options);
+});
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "wlmaker",
+  "version": "1.0.0",
+  "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
+  "keywords": [
+    "flutter",
+    "bloc",
+    "freezed",
+    "dart",
+    "code generation",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MatiasZL/wlmaker-cli"
+  },
+  "license": "MIT",
+  "bin": {
+    "wlmaker": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "change-case": "^5.4.0",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}