wlmaker 1.5.0 → 1.7.0

package/dist/chunk-7KUDXB2F.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+// src/dart/injector.ts
+import * as fs from "fs";
+function injectMethod(filePath, className, methodCode, dedupKey) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const dedup = dedupKey ?? findSignature(methodCode);
+  if (dedup && content.includes(dedup)) {
+    return;
+  }
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    throw new Error(`Class "${className}" not found in ${filePath}`);
+  }
+  const classStart = content.indexOf(classMatch[0]);
+  let braceCount = 0;
+  let classEnd = -1;
+  let foundOpen = false;
+  for (let i = classStart; i < content.length; i++) {
+    if (content[i] === "{") {
+      braceCount++;
+      foundOpen = true;
+    } else if (content[i] === "}") {
+      braceCount--;
+      if (foundOpen && braceCount === 0) {
+        classEnd = i;
+        break;
+      }
+    }
+  }
+  if (classEnd === -1) {
+    throw new Error(`Could not find closing brace for class "${className}" in ${filePath}`);
+  }
+  const indentedMethod = methodCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+  const newContent = content.slice(0, classEnd) + "\n" + indentedMethod + "\n" + content.slice(classEnd);
+  fs.writeFileSync(filePath, newContent);
+}
+function injectImport(filePath, importLine) {
+  const content = fs.readFileSync(filePath, "utf8");
+  if (content.includes(importLine.trim())) {
+    return;
+  }
+  const importRegex = /^import\s+[^;]+;/gm;
+  const imports = [...content.matchAll(importRegex)];
+  if (imports.length > 0) {
+    const lastImport = imports[imports.length - 1];
+    const insertPos = lastImport.index + lastImport[0].length;
+    const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+    fs.writeFileSync(filePath, newContent);
+  } else {
+    fs.writeFileSync(filePath, importLine + "\n\n" + content);
+  }
+}
+function injectExport(filePath, exportLine) {
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf8");
+  }
+  if (content.includes(exportLine)) {
+    return;
+  }
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  lines.push(exportLine);
+  lines.sort();
+  fs.writeFileSync(filePath, lines.join("\n") + "\n");
+}
+function findSignature(methodCode) {
+  const lines = methodCode.trim().split("\n");
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped && !stripped.startsWith("@")) {
+      return stripped;
+    }
+  }
+  return null;
+}
+
+export {
+  injectMethod,
+  injectImport,
+  injectExport
+};

package/dist/chunk-BVPCRMD4.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import {
+  injectExport
+} from "./chunk-7KUDXB2F.mjs";
+import {
+  collaborativePageTemplate,
+  collaborativeViewTemplate
+} from "./chunk-OTFDN3HG.mjs";
+
+// src/generators/collaborative/page/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { pascalCase } from "change-case";
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createCollaborativePage(options) {
+  const { featurePath, pageName } = options;
+  const pascal = pascalCase(pageName);
+  if (!SNAKE_CASE_REGEX.test(pageName)) {
+    throw new Error(
+      "Page name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const lib = path.join(featurePath, "lib");
+  const pagesDir = path.join(lib, "presentation", "pages");
+  const viewsDir = path.join(pagesDir, "views");
+  if (!fs.existsSync(pagesDir)) {
+    throw new Error(
+      `Not a collaborative feature structure. Missing: ${pagesDir}`
+    );
+  }
+  fs.mkdirSync(viewsDir, { recursive: true });
+  const pageFile = path.join(pagesDir, `${pageName}_page.dart`);
+  const viewFile = path.join(viewsDir, `${pageName}_view.dart`);
+  if (fs.existsSync(pageFile)) {
+    throw new Error(`Page "${pageName}" already exists at ${pageFile}`);
+  }
+  const featureName = extractFeatureName(featurePath);
+  fs.writeFileSync(
+    pageFile,
+    collaborativePageTemplate(pageName, pascal)
+  );
+  console.log(chalk.green(`  Page created: ${pageFile}`));
+  fs.writeFileSync(viewFile, collaborativeViewTemplate(pascal));
+  console.log(chalk.green(`  View created: ${viewFile}`));
+  if (featureName) {
+    const viewsBarrel = path.join(viewsDir, "views.dart");
+    injectExport(viewsBarrel, `export '${pageName}_view.dart';`);
+    const pagesBarrel = path.join(pagesDir, "pages.dart");
+    injectExport(pagesBarrel, `export '${pageName}_page.dart';`);
+    injectExport(pagesBarrel, `export 'views/views.dart';`);
+    const mainBarrel = path.join(lib, `${featureName}.dart`);
+    if (fs.existsSync(mainBarrel)) {
+      const content = fs.readFileSync(mainBarrel, "utf8");
+      if (!content.includes(`export 'presentation/pages/${pageName}_page.dart';`)) {
+        injectExport(
+          mainBarrel,
+          `export 'presentation/pages/${pageName}_page.dart';`
+        );
+      }
+      if (!content.includes(`export 'presentation/pages/views/${pageName}_view.dart';`)) {
+        injectExport(
+          mainBarrel,
+          `export 'presentation/pages/views/${pageName}_view.dart';`
+        );
+      }
+    }
+  }
+}
+function extractFeatureName(featurePath) {
+  const normalized = featurePath.replace(/\\/g, "/");
+  const match = normalized.match(/\/([^/]+)\/lib\/?$/);
+  if (match) return match[1];
+  return path.basename(featurePath);
+}
+
+export {
+  createCollaborativePage
+};

package/dist/chunk-FXU2ADDY.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import {
+  resolveWorkspaceVersions
+} from "./chunk-KBIXWYFD.mjs";
+import {
+  blocsModuleTemplate,
+  collaborativeGitignore,
+  collaborativePubspec,
+  datasourcesModuleTemplate,
+  emptyBarrelTemplate,
+  featureDiTemplate,
+  mainBarrelTemplate,
+  repositoriesModuleTemplate,
+  usecasesModuleTemplate
+} from "./chunk-OTFDN3HG.mjs";
+
+// src/generators/collaborative/feature/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import { pascalCase } from "change-case";
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createCollaborativeFeature(options) {
+  const { monorepoRoot, featureName } = options;
+  const pascal = pascalCase(featureName);
+  const description = options.description ?? `${pascal} collaborative feature`;
+  if (!SNAKE_CASE_REGEX.test(featureName)) {
+    throw new Error(
+      "Feature name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const collaborativeDir = path.join(monorepoRoot, "packages", "collaborative");
+  if (!fs.existsSync(collaborativeDir)) {
+    fs.mkdirSync(collaborativeDir, { recursive: true });
+  }
+  const pkgDir = path.join(collaborativeDir, featureName);
+  if (fs.existsSync(pkgDir)) {
+    throw new Error(`packages/collaborative/${featureName} already exists`);
+  }
+  console.log(
+    chalk.bold(`
+Creating collaborative feature: ${chalk.cyan(featureName)}
+`)
+  );
+  console.log(chalk.cyan(" -> Running flutter create..."));
+  execSync(
+    `flutter create --template=package packages/collaborative/${featureName}`,
+    { cwd: monorepoRoot, stdio: "pipe" }
+  );
+  const autoTestFile = path.join(pkgDir, "test", `${featureName}_test.dart`);
+  if (fs.existsSync(autoTestFile)) {
+    fs.unlinkSync(autoTestFile);
+  }
+  console.log(chalk.cyan(" -> Generating feature structure..."));
+  const lib = path.join(pkgDir, "lib");
+  const dirs = [
+    path.join(lib, "data", "api", "bff"),
+    path.join(lib, "data", "datasources"),
+    path.join(lib, "data", "models"),
+    path.join(lib, "data", "repositories"),
+    path.join(lib, "domain", "entities"),
+    path.join(lib, "domain", "repositories"),
+    path.join(lib, "domain", "usecases"),
+    path.join(lib, "presentation", "bloc"),
+    path.join(lib, "presentation", "pages", "views"),
+    path.join(lib, "di")
+  ];
+  for (const dir of dirs) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const workspaceVersions = resolveWorkspaceVersions(monorepoRoot);
+  fs.writeFileSync(
+    path.join(pkgDir, "pubspec.yaml"),
+    collaborativePubspec(featureName, description, workspaceVersions)
+  );
+  fs.writeFileSync(
+    path.join(pkgDir, ".gitignore"),
+    collaborativeGitignore()
+  );
+  const diDir = path.join(lib, "di");
+  fs.writeFileSync(
+    path.join(diDir, `${featureName}_di.dart`),
+    featureDiTemplate(featureName)
+  );
+  fs.writeFileSync(
+    path.join(diDir, "blocs_module.dart"),
+    blocsModuleTemplate(featureName)
+  );
+  fs.writeFileSync(
+    path.join(diDir, "datasources_module.dart"),
+    datasourcesModuleTemplate(featureName)
+  );
+  fs.writeFileSync(
+    path.join(diDir, "repositories_module.dart"),
+    repositoriesModuleTemplate(featureName)
+  );
+  fs.writeFileSync(
+    path.join(diDir, "usecases_module.dart"),
+    usecasesModuleTemplate(featureName)
+  );
+  const barrelPaths = [
+    path.join(lib, "data", "api", "bff", "bff.dart"),
+    path.join(lib, "data", "datasources", "datasources.dart"),
+    path.join(lib, "data", "models", "models.dart"),
+    path.join(lib, "data", "repositories", "repositories.dart"),
+    path.join(lib, "domain", "entities", "entities.dart"),
+    path.join(lib, "domain", "repositories", "repositories.dart"),
+    path.join(lib, "domain", "usecases", "usecases.dart"),
+    path.join(lib, "presentation", "bloc", "bloc.dart"),
+    path.join(lib, "presentation", "pages", "views", "views.dart"),
+    path.join(lib, "presentation", "pages", "pages.dart")
+  ];
+  for (const barrelPath of barrelPaths) {
+    fs.writeFileSync(barrelPath, emptyBarrelTemplate());
+  }
+  fs.writeFileSync(
+    path.join(lib, `${featureName}.dart`),
+    mainBarrelTemplate(featureName)
+  );
+  if (options.runBootstrap !== false) {
+    console.log(chalk.cyan(" -> Running melos bootstrap..."));
+    try {
+      execSync("melos bootstrap", { cwd: monorepoRoot, stdio: "pipe" });
+      console.log(chalk.green("  melos bootstrap completed"));
+    } catch {
+      console.log(
+        chalk.yellow("  melos bootstrap failed (you may need to run it manually)")
+      );
+    }
+  }
+  console.log(
+    chalk.green(`
+Feature "${featureName}" created successfully!`)
+  );
+  console.log(chalk.gray(`  ${pkgDir}`));
+  console.log(chalk.gray(`
+  Next steps:`));
+  console.log(chalk.gray(`    wlmaker collaborative endpoint ...`));
+  console.log(chalk.gray(`    wlmaker collaborative bloc ...`));
+  console.log(chalk.gray(`    wlmaker collaborative page ...`));
+}
+
+export {
+  createCollaborativeFeature
+};

package/dist/chunk-KBIXWYFD.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+// src/analyzer/project.ts
+import * as fs from "fs";
+import * as path from "path";
+import YAML from "yaml";
+function analyzeProject(startDir) {
+  const projectRoot = findPubspecDir(startDir);
+  if (!projectRoot) return null;
+  const pubspecPath = path.join(projectRoot, "pubspec.yaml");
+  const content = fs.readFileSync(pubspecPath, "utf8");
+  const pubspec = YAML.parse(content);
+  const deps = {
+    ...pubspec?.dependencies,
+    ...pubspec?.dev_dependencies
+  };
+  const features = discoverFeatures(projectRoot);
+  return {
+    projectRoot,
+    projectName: pubspec?.name ?? path.basename(projectRoot),
+    hasFreezed: "freezed" in deps || "freezed_annotation" in deps,
+    hasBloc: "flutter_bloc" in deps || "bloc" in deps,
+    hasBuildRunner: "build_runner" in deps,
+    features
+  };
+}
+function findPubspecDir(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "pubspec.yaml"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return void 0;
+}
+function discoverFeatures(projectRoot) {
+  const featuresDir = path.join(projectRoot, "lib", "features");
+  if (!fs.existsSync(featuresDir)) return [];
+  return fs.readdirSync(featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+function findMonorepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "melos.yaml"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return void 0;
+}
+function discoverPackages(monorepoRoot) {
+  const packageDirs = ["packages", "packages/features"];
+  const projects = [];
+  for (const base of packageDirs) {
+    const baseDir = path.join(monorepoRoot, base);
+    if (!fs.existsSync(baseDir)) continue;
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const candidate = path.join(baseDir, entry.name);
+      if (!fs.existsSync(path.join(candidate, "pubspec.yaml"))) continue;
+      const project = analyzeProject(candidate);
+      if (project && (project.hasFreezed || project.hasBloc)) {
+        projects.push(project);
+      }
+    }
+  }
+  return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+function discoverCollaborativeFeatures(monorepoRoot) {
+  const collabDir = path.join(monorepoRoot, "packages", "collaborative");
+  if (!fs.existsSync(collabDir)) return [];
+  const projects = [];
+  const entries = fs.readdirSync(collabDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const candidate = path.join(collabDir, entry.name);
+    if (!fs.existsSync(path.join(candidate, "pubspec.yaml"))) continue;
+    const project = analyzeProject(candidate);
+    if (project) {
+      projects.push(project);
+    }
+  }
+  return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+var REFERENCE_PACKAGES = ["packages/core", "packages/app_base", "packages/design_system"];
+function resolveWorkspaceVersions(monorepoRoot) {
+  const merged = {
+    dependencies: {},
+    devDependencies: {},
+    dependencyOverrides: {}
+  };
+  for (const relPath of REFERENCE_PACKAGES) {
+    const pubspecPath = path.join(monorepoRoot, relPath, "pubspec.yaml");
+    if (!fs.existsSync(pubspecPath)) continue;
+    const content = fs.readFileSync(pubspecPath, "utf8");
+    const pubspec = YAML.parse(content);
+    if (pubspec?.dependencies) {
+      for (const [name, version] of Object.entries(pubspec.dependencies)) {
+        if (typeof version === "string") {
+          merged.dependencies[name] = version;
+        }
+      }
+    }
+    if (pubspec?.dev_dependencies) {
+      for (const [name, version] of Object.entries(pubspec.dev_dependencies)) {
+        if (typeof version === "string") {
+          merged.devDependencies[name] = version;
+        }
+      }
+    }
+    if (pubspec?.dependency_overrides) {
+      for (const [name, version] of Object.entries(pubspec.dependency_overrides)) {
+        if (typeof version === "string") {
+          merged.dependencyOverrides[name] = version;
+        }
+      }
+    }
+  }
+  return merged;
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".dart_tool",
+  "build",
+  ".git",
+  ".idea",
+  ".fvm",
+  "coverage"
+]);
+function discoverProjects(searchDir, maxDepth = 2) {
+  const projects = [];
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    const project = analyzeProject(dir);
+    if (project && (project.hasFreezed || project.hasBloc)) {
+      projects.push(project);
+      return;
+    }
+    if (!fs.existsSync(dir)) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name)) continue;
+      walk(path.join(dir, entry.name), depth + 1);
+    }
+  }
+  walk(searchDir, 0);
+  return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+
+export {
+  analyzeProject,
+  findMonorepoRoot,
+  discoverPackages,
+  discoverCollaborativeFeatures,
+  resolveWorkspaceVersions,
+  discoverProjects
+};

package/dist/chunk-LHUDYCA5.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import {
+  injectMethod
+} from "./chunk-7KUDXB2F.mjs";
+import {
+  blocRegistrationSnippet,
+  collaborativeBlocEventTemplate,
+  collaborativeBlocStateTemplate,
+  collaborativeBlocTemplate
+} from "./chunk-OTFDN3HG.mjs";
+
+// src/generators/collaborative/bloc/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { pascalCase } from "change-case";
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createCollaborativeBloc(options) {
+  const { featurePath, blocName } = options;
+  const pascal = pascalCase(blocName);
+  if (!SNAKE_CASE_REGEX.test(blocName)) {
+    throw new Error(
+      "BLoC name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const lib = path.join(featurePath, "lib");
+  const blocDir = path.join(lib, "presentation", "bloc");
+  if (!fs.existsSync(blocDir)) {
+    throw new Error(
+      `Not a collaborative feature structure. Missing: ${blocDir}`
+    );
+  }
+  const blocFile = path.join(blocDir, `${blocName}_bloc.dart`);
+  if (fs.existsSync(blocFile)) {
+    throw new Error(`BLoC "${blocName}" already exists at ${blocFile}`);
+  }
+  fs.writeFileSync(
+    blocFile,
+    collaborativeBlocTemplate(blocName, pascal)
+  );
+  console.log(chalk.green(`  BLoC created: ${blocFile}`));
+  fs.writeFileSync(
+    path.join(blocDir, `${blocName}_event.dart`),
+    collaborativeBlocEventTemplate(blocName, pascal)
+  );
+  fs.writeFileSync(
+    path.join(blocDir, `${blocName}_state.dart`),
+    collaborativeBlocStateTemplate(blocName, pascal)
+  );
+  console.log(chalk.green(`  Event + State files created`));
+  const barrelPath = path.join(blocDir, "bloc.dart");
+  const exportLine = `export '${blocName}_bloc.dart';`;
+  if (fs.existsSync(barrelPath)) {
+    const content = fs.readFileSync(barrelPath, "utf8");
+    if (!content.includes(exportLine)) {
+      fs.writeFileSync(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
+    }
+  } else {
+    fs.writeFileSync(barrelPath, exportLine + "\n");
+  }
+  const featureName = path.basename(featurePath);
+  const diDir = path.join(lib, "di");
+  const blocsModulePath = path.join(diDir, "blocs_module.dart");
+  if (fs.existsSync(blocsModulePath)) {
+    const snippet = blocRegistrationSnippet(blocName, pascal);
+    const importLine = `import 'package:${featureName}/presentation/bloc/${blocName}_bloc.dart';`;
+    const content = fs.readFileSync(blocsModulePath, "utf8");
+    if (!content.includes(importLine)) {
+      const importRegex = /^import\s+[^;]+;/gm;
+      const imports = [...content.matchAll(importRegex)];
+      if (imports.length > 0) {
+        const lastImport = imports[imports.length - 1];
+        const insertPos = lastImport.index + lastImport[0].length;
+        const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+        fs.writeFileSync(blocsModulePath, newContent);
+      }
+    }
+    injectMethod(blocsModulePath, "BlocsModule", snippet);
+    console.log(chalk.green("  Registered in BlocsModule"));
+  }
+}
+
+export {
+  createCollaborativeBloc
+};