wlmaker 1.6.0 → 1.8.0

package/dist/chunk-ELYQ3PL5.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+// src/generators/collaborative/collaborative-templates.ts
+import { camelCase, pascalCase } from "change-case";
+var WORKSPACE_PACKAGES = /* @__PURE__ */ new Set(["app_base", "core", "design_system", "localization"]);
+var COLLABORATIVE_DEPS = [
+  "app_base",
+  "dio",
+  "equatable",
+  "flutter_bloc",
+  "freezed_annotation",
+  "get_it",
+  "go_router",
+  "injectable",
+  "json_annotation"
+];
+var COLLABORATIVE_DEV_DEPS = [
+  "build_runner",
+  "freezed",
+  "injectable_generator",
+  "json_serializable",
+  "very_good_analysis"
+];
+var COLLABORATIVE_OVERRIDE_EXCLUDE = /* @__PURE__ */ new Set([
+  "analyzer",
+  "dart_style",
+  "build_runner",
+  "source_gen"
+]);
+function collaborativePubspec(featureName, description, versions, pubWorkspace = false) {
+  if (pubWorkspace) {
+    const depLines2 = [
+      "  flutter:",
+      "    sdk: flutter"
+    ];
+    for (const dep of COLLABORATIVE_DEPS) {
+      depLines2.push(
+        WORKSPACE_PACKAGES.has(dep) ? `  ${dep}:` : `  ${dep}: any`
+      );
+    }
+    const devDepLines2 = [
+      "  flutter_test:",
+      "    sdk: flutter"
+    ];
+    for (const dep of COLLABORATIVE_DEV_DEPS) {
+      devDepLines2.push(`  ${dep}: any`);
+    }
+    return `name: ${featureName}
+description: "${description}"
+version: 0.0.1
+publish_to: none
+
+environment:
+  sdk: ^3.8.1
+  flutter: ">=1.17.0"
+
+resolution: workspace
+
+dependencies:
+${depLines2.join("\n")}
+
+dev_dependencies:
+${devDepLines2.join("\n")}
+
+flutter:
+  uses-material-design: true
+`;
+  }
+  const depLines = ["  app_base:"];
+  for (const dep of COLLABORATIVE_DEPS) {
+    if (dep === "app_base") continue;
+    const version = versions.dependencies[dep] ?? versions.devDependencies[dep];
+    if (version) {
+      depLines.push(`  ${dep}: ${version}`);
+    }
+  }
+  const devDepLines = [
+    "  flutter_test:",
+    "    sdk: flutter"
+  ];
+  for (const dep of COLLABORATIVE_DEV_DEPS) {
+    const version = versions.devDependencies[dep] ?? versions.dependencies[dep];
+    if (version) {
+      devDepLines.push(`  ${dep}: ${version}`);
+    }
+  }
+  const overrideLines = [];
+  for (const [name, version] of Object.entries(versions.dependencyOverrides)) {
+    if (!COLLABORATIVE_OVERRIDE_EXCLUDE.has(name)) {
+      overrideLines.push(`  ${name}: ${version}`);
+    }
+  }
+  const overridesSection = overrideLines.length > 0 ? `
+dependency_overrides:
+${overrideLines.join("\n")}
+` : "";
+  return `name: ${featureName}
+description: "${description}"
+version: 0.0.1
+publish_to: none
+
+environment:
+  sdk: ^3.8.1
+  flutter: ">=1.17.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+${depLines.join("\n")}
+
+dev_dependencies:
+${devDepLines.join("\n")}
+${overridesSection}
+flutter:
+  uses-material-design: true
+`;
+}
+function featureDiTemplate(featureName) {
+  const pascal = pascalCase(featureName);
+  return `import 'package:injectable/injectable.dart';
+
+@InjectableInit.microPackage()
+void init${pascal}Package() {}
+`;
+}
+function blocsModuleTemplate(featureName) {
+  return `import 'package:injectable/injectable.dart';
+
+@module
+abstract class BlocsModule {}
+`;
+}
+function datasourcesModuleTemplate(featureName) {
+  return `import 'package:injectable/injectable.dart';
+
+@module
+abstract class DatasourcesModule {}
+`;
+}
+function repositoriesModuleTemplate(featureName) {
+  return `import 'package:injectable/injectable.dart';
+
+@module
+abstract class RepositoriesModule {}
+`;
+}
+function usecasesModuleTemplate(featureName) {
+  return `import 'package:injectable/injectable.dart';
+
+@module
+abstract class UseCasesModule {}
+`;
+}
+function collaborativeBlocTemplate(featureName, pascal) {
+  return `import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part '${featureName}_bloc.freezed.dart';
+part '${featureName}_event.dart';
+part '${featureName}_state.dart';
+
+class ${pascal}Bloc extends Bloc<${pascal}Event, ${pascal}State> {
+  ${pascal}Bloc() : super(const ${pascal}State.initial()) {
+    on<_Started>(_onStarted);
+  }
+
+  Future<void> _onStarted(
+    _Started event,
+    Emitter<${pascal}State> emit,
+  ) async {
+    emit(const ${pascal}State.loading());
+  }
+}
+`;
+}
+function collaborativeBlocEventTemplate(featureName, pascal) {
+  return `part of '${featureName}_bloc.dart';
+
+@freezed
+sealed class ${pascal}Event with _$${pascal}Event {
+  const factory ${pascal}Event.started() = _Started;
+}
+`;
+}
+function collaborativeBlocStateTemplate(featureName, pascal) {
+  return `part of '${featureName}_bloc.dart';
+
+@freezed
+sealed class ${pascal}State with _$${pascal}State {
+  const factory ${pascal}State.initial() = _Initial;
+  const factory ${pascal}State.loading() = _Loading;
+  const factory ${pascal}State.error(String message) = _Error;
+}
+`;
+}
+function collaborativePageTemplate(featureName, pascal) {
+  const routePath = "/" + featureName.replace(/^feature_/, "");
+  return `import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:${featureName}/presentation/pages/views/views.dart';
+
+class ${pascal}Page extends GoRoute {
+  ${pascal}Page({super.name, super.routes})
+      : super(
+          path: fullPath,
+          pageBuilder: (context, state) =>
+              const MaterialPage(child: ${pascal}View()),
+        );
+
+  static const fullPath = '${routePath}';
+
+  static void open(BuildContext context) => context.go(fullPath);
+}
+`;
+}
+function collaborativeViewTemplate(pascal) {
+  return `import 'package:flutter/material.dart';
+
+class ${pascal}View extends StatelessWidget {
+  const ${pascal}View({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('${pascal}')),
+      body: const Center(child: Text('${pascal}')),
+    );
+  }
+}
+`;
+}
+function emptyBarrelTemplate() {
+  return "";
+}
+function mainBarrelTemplate(featureName) {
+  return `export 'data/api/bff/bff.dart';
+export 'data/datasources/datasources.dart';
+export 'data/models/models.dart';
+export 'data/repositories/repositories.dart';
+export 'domain/entities/entities.dart';
+export 'domain/repositories/repositories.dart';
+export 'domain/usecases/usecases.dart';
+export 'presentation/bloc/bloc.dart';
+export 'presentation/pages/pages.dart';
+export 'presentation/pages/views/views.dart';
+export 'di/${featureName}_di.dart';
+`;
+}
+function collaborativeGitignore() {
+  return `# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.buildlog/
+.history
+.svn/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# Flutter/Dart/Pub related
+/pubspec.lock
+**/doc/api/
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+build/
+
+coverage/
+`;
+}
+function blocRegistrationSnippet(featureName, pascal) {
+  const blocClass = `${pascal}Bloc`;
+  const blocVar = camelCase(blocClass);
+  return `  @injectable
+  ${blocClass} ${blocVar}() => ${blocClass}();`;
+}
+
+export {
+  collaborativePubspec,
+  featureDiTemplate,
+  blocsModuleTemplate,
+  datasourcesModuleTemplate,
+  repositoriesModuleTemplate,
+  usecasesModuleTemplate,
+  collaborativeBlocTemplate,
+  collaborativeBlocEventTemplate,
+  collaborativeBlocStateTemplate,
+  collaborativePageTemplate,
+  collaborativeViewTemplate,
+  emptyBarrelTemplate,
+  mainBarrelTemplate,
+  collaborativeGitignore,
+  blocRegistrationSnippet
+};

package/dist/chunk-P7W5YVTZ.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import {
+  injectExport
+} from "./chunk-7KUDXB2F.mjs";
+import {
+  collaborativePageTemplate,
+  collaborativeViewTemplate
+} from "./chunk-ELYQ3PL5.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-V4S7DQDN.mjs

@@ -0,0 +1,178 @@
+#!/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 isMonorepoRoot(dir) {
+  if (fs.existsSync(path.join(dir, "melos.yaml"))) {
+    return true;
+  }
+  const pubspecPath = path.join(dir, "pubspec.yaml");
+  if (!fs.existsSync(pubspecPath)) return false;
+  try {
+    const pubspec = YAML.parse(fs.readFileSync(pubspecPath, "utf8"));
+    return Boolean(pubspec?.workspace) || Boolean(pubspec?.melos);
+  } catch {
+    return false;
+  }
+}
+function findMonorepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (isMonorepoRoot(dir)) {
+      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,
+  isMonorepoRoot,
+  findMonorepoRoot,
+  discoverPackages,
+  discoverCollaborativeFeatures,
+  resolveWorkspaceVersions,
+  discoverProjects
+};