@wordpress-flow/cli 1.0.3 → 1.0.5

package/dist/index.js

@@ -116534,7 +116534,7 @@ var watch = (paths, options) => {
 var $watch = watch;
 
 // src/commands/dev-command.ts
-import * as path15 from "path";
+import * as path16 from "path";
 import * as fs14 from "fs";
 
 // src/build/block-scanner.ts
@@ -117319,7 +117319,7 @@ class MDXDependencyTracker {
 }
 
 // src/commands/build-command.ts
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/build/php-generator.ts
 import * as fs13 from "fs";
@@ -117403,6 +117403,108 @@ add_action('enqueue_block_assets', 'wordpress_flow_enqueue_block_scripts');
   }
 }
 
+// src/build/worker-pool.ts
+import { Worker } from "worker_threads";
+import * as path14 from "path";
+import * as os from "os";
+var __dirname = "/Users/pkrasinski/Clients/RekinySukcesu.pl/wordpress-test/packages/cli/src/build";
+
+class WorkerPool {
+  concurrency;
+  outputDir;
+  webpackConfigPath;
+  scriptsPath;
+  workerPath;
+  constructor(options) {
+    this.concurrency = options.concurrency ?? Math.max(1, os.cpus().length - 1);
+    this.outputDir = options.outputDir;
+    this.webpackConfigPath = options.webpackConfigPath;
+    this.scriptsPath = options.scriptsPath;
+    const distDir = __dirname.replace(/\/src\/build$/, "/dist/build");
+    this.workerPath = path14.join(distDir, "block-build-worker.js");
+  }
+  async buildAll(blocks, onProgress) {
+    const results = [];
+    const queue = [...blocks];
+    let completed = 0;
+    const total = blocks.length;
+    let activeWorkers = 0;
+    logger.info(`Building ${total} block(s) with ${this.concurrency} worker(s)`);
+    return new Promise((resolve5, reject) => {
+      const processNext = () => {
+        while (activeWorkers < this.concurrency && queue.length > 0) {
+          const block = queue.shift();
+          activeWorkers++;
+          this.buildBlockInWorker(block).then((result2) => {
+            results.push(result2);
+            completed++;
+            activeWorkers--;
+            onProgress?.(completed, total, result2.blockName, result2.success);
+            if (queue.length > 0) {
+              processNext();
+            } else if (activeWorkers === 0) {
+              resolve5(results);
+            }
+          }).catch((error) => {
+            const result2 = {
+              success: false,
+              blockName: block.name,
+              error: error.message || String(error)
+            };
+            results.push(result2);
+            completed++;
+            activeWorkers--;
+            onProgress?.(completed, total, block.name, false);
+            if (queue.length > 0) {
+              processNext();
+            } else if (activeWorkers === 0) {
+              resolve5(results);
+            }
+          });
+        }
+      };
+      processNext();
+    });
+  }
+  buildBlockInWorker(block) {
+    return new Promise((resolve5, reject) => {
+      const tempDir = path14.join(process.cwd(), ".wordpress-flow-temp", `worker-${block.name}-${Date.now()}`);
+      const workerData = {
+        block: {
+          name: block.name,
+          filePath: block.filePath,
+          scripts: block.scripts
+        },
+        outputDir: this.outputDir,
+        webpackConfigPath: this.webpackConfigPath,
+        scriptsPath: this.scriptsPath,
+        tempDir
+      };
+      const worker = new Worker(this.workerPath, { workerData });
+      const timeout = setTimeout(() => {
+        worker.terminate();
+        reject(new Error(`Worker timeout for block: ${block.name}`));
+      }, 5 * 60 * 1000);
+      worker.on("message", (result2) => {
+        clearTimeout(timeout);
+        worker.terminate();
+        resolve5(result2);
+      });
+      worker.on("error", (error) => {
+        clearTimeout(timeout);
+        worker.terminate();
+        reject(error);
+      });
+      worker.on("exit", (code2) => {
+        clearTimeout(timeout);
+        if (code2 !== 0) {
+          reject(new Error(`Worker exited with code ${code2} for block: ${block.name}`));
+        }
+      });
+    });
+  }
+}
+
 // src/commands/build-command.ts
 class BuildCommand {
   configManager;
@@ -117432,34 +117534,72 @@ class BuildCommand {
       if (scriptsPath) {
         logger.info(`Scripts directory: ${scriptsPath}`);
       }
-      const blocks = await this.blockScanner.scanBlocks(blocksDir);
+      let blocks = await this.blockScanner.scanBlocks(blocksDir);
       if (blocks.length === 0) {
         logger.warn("No blocks found in the specified directory");
         return;
       }
-      logger.info(`Found ${blocks.length} block(s): ${blocks.map((b) => b.name).join(", ")}`);
-      for (let i2 = 0;i2 < blocks.length; i2++) {
-        const block = blocks[i2];
-        logger.step(i2 + 1, blocks.length, `Building block: ${block.name}`);
-        try {
-          await this.blockBuilder.buildBlock(block, outputDir, webpackConfig, scriptsPath);
-          if (block.scripts && block.scripts.length > 0) {
-            const scriptPaths = block.scripts.map((script) => `scripts/${path14.basename(script).replace(/\.ts$/, ".js")}`);
+      if (options.blocks && options.blocks.length > 0) {
+        const requestedBlocks = options.blocks;
+        const allBlockNames = blocks.map((b) => b.name);
+        const filteredBlocks = blocks.filter((block) => requestedBlocks.includes(block.name));
+        const foundBlockNames = filteredBlocks.map((b) => b.name);
+        const notFoundBlocks = requestedBlocks.filter((name2) => !foundBlockNames.includes(name2));
+        if (notFoundBlocks.length > 0) {
+          logger.warn(`Requested blocks not found: ${notFoundBlocks.join(", ")}`);
+          logger.info(`Available blocks: ${allBlockNames.join(", ")}`);
+        }
+        if (filteredBlocks.length === 0) {
+          logger.warn("No matching blocks found to build");
+          return;
+        }
+        blocks = filteredBlocks;
+        logger.info(`Building ${blocks.length} specified block(s): ${blocks.map((b) => b.name).join(", ")}`);
+      } else {
+        logger.info(`Found ${blocks.length} block(s): ${blocks.map((b) => b.name).join(", ")}`);
+      }
+      const workerPool = new WorkerPool({
+        concurrency: options.concurrency,
+        outputDir,
+        webpackConfigPath: webpackConfig,
+        scriptsPath
+      });
+      const results = await workerPool.buildAll(blocks, (completed, total, blockName, success) => {
+        if (success) {
+          logger.success(`✅ Built: ${blockName} [${completed}/${total}]`);
+        } else {
+          logger.error(`❌ Failed: ${blockName} [${completed}/${total}]`);
+        }
+      });
+      for (const block of blocks) {
+        if (block.scripts && block.scripts.length > 0) {
+          const result2 = results.find((r) => r.blockName === block.name);
+          if (result2?.success) {
+            const scriptPaths = block.scripts.map((script) => `scripts/${path15.basename(script).replace(/\.ts$/, ".js")}`);
             this.blockScripts.set(block.name, scriptPaths);
           }
-          logger.success(`Built: ${block.name}`);
-        } catch (error) {
-          logger.error(`Failed to build block: ${block.name}`);
-          logger.error(`Block file: ${block.filePath}`);
-          throw error;
+        }
+      }
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        logger.error(`
+Failed to build ${failures.length} block(s):`);
+        for (const failure of failures) {
+          logger.error(`  - ${failure.blockName}: ${failure.error}`);
         }
       }
       if (this.blockScripts.size > 0) {
-        const phpPath = path14.join(path14.dirname(outputDir), "functions-blocks-scripts.php");
+        const phpPath = path15.join(path15.dirname(outputDir), "functions-blocks-scripts.php");
         this.phpGenerator.generateScriptRegistrationPHP(this.blockScripts, phpPath);
       }
       await this.generateTypeDefinitions(outputDir);
-      logger.success(`Build completed successfully! Built ${blocks.length} block(s).`);
+      const successCount = results.filter((r) => r.success).length;
+      if (failures.length > 0) {
+        logger.warn(`Build completed with errors. Built ${successCount}/${blocks.length} block(s).`);
+        process.exit(1);
+      } else {
+        logger.success(`Build completed successfully! Built ${successCount} block(s).`);
+      }
     } catch (error) {
       logger.error("Build operation failed");
       process.exit(1);
@@ -117473,7 +117613,7 @@ class BuildCommand {
         logger.warn("No blocks found for type generation");
         return;
       }
-      const typesPath = path14.join(outputDir, "blocks.d.ts");
+      const typesPath = path15.join(outputDir, "blocks.d.ts");
       await this.typeGenerator.generateDefinitions(blocks, typesPath);
       logger.success(`✅ Generated TypeScript definitions for ${blocks.length} block(s)`);
     } catch (error) {
@@ -117640,7 +117780,7 @@ class DevCommand {
     return new Promise(() => {});
   }
   handleFileEvent(eventType, filePath2, options) {
-    const fullPath = path15.resolve(this.configManager.resolvePath(this.configManager.getConfig().paths.mdxOutputDir), filePath2);
+    const fullPath = path16.resolve(this.configManager.resolvePath(this.configManager.getConfig().paths.mdxOutputDir), filePath2);
     logger.debug(`File ${eventType}: ${filePath2}`);
     if (eventType === "unlink") {
       logger.warn(`File deleted: ${filePath2} - Manual WordPress cleanup may be required`);
@@ -117659,7 +117799,7 @@ class DevCommand {
   }
   async handleLocalFileChange(filePath2, options) {
     try {
-      logger.info(`\uD83D\uDD04 Processing local file change: ${path15.relative(process.cwd(), filePath2)}`);
+      logger.info(`\uD83D\uDD04 Processing local file change: ${path16.relative(process.cwd(), filePath2)}`);
       await this.pushCommand.execute({
         files: [filePath2],
         force: options.conflictResolution === "local-wins",
@@ -117709,13 +117849,13 @@ class DevCommand {
   handleBlockFileEvent(eventType, filePath2, options) {
     const config2 = this.configManager.getConfig();
     const blocksDir = this.configManager.resolvePath(config2.build?.blocksDir || "./theme/blocks");
-    const fullPath = path15.resolve(blocksDir, filePath2);
+    const fullPath = path16.resolve(blocksDir, filePath2);
     logger.debug(`Block file ${eventType}: ${filePath2}`);
     if (eventType === "unlink") {
       logger.warn(`Block file deleted: ${filePath2} - Manual cleanup may be required`);
       return;
     }
-    const blockName = path15.basename(filePath2, path15.extname(filePath2));
+    const blockName = path16.basename(filePath2, path16.extname(filePath2));
     this.buildQueue.add(blockName);
     const debounceKey = `block-${blockName}`;
     const existingTimer = this.debounceTimers.get(debounceKey);
@@ -117785,8 +117925,8 @@ class DevCommand {
       const sourceBlocks = await this.blockScanner.scanBlocks(this.configManager.resolvePath(config2.build?.blocksDir || "./theme/blocks"));
       const missingBuilds = [];
       for (const block of sourceBlocks) {
-        const blockBuildDir = path15.join(outputDir, block.name);
-        const blockJsonPath = path15.join(blockBuildDir, "block.json");
+        const blockBuildDir = path16.join(outputDir, block.name);
+        const blockJsonPath = path16.join(blockBuildDir, "block.json");
         if (!fs14.existsSync(blockJsonPath)) {
           missingBuilds.push(block.name);
         }
@@ -117841,7 +117981,7 @@ class DevCommand {
       if (blocks.length === 0) {
         return;
       }
-      const typesPath = path15.join(outputDir, "blocks.d.ts");
+      const typesPath = path16.join(outputDir, "blocks.d.ts");
       await this.typeGenerator.generateDefinitions(blocks, typesPath);
       logger.debug(`\uD83D\uDD27 Updated TypeScript definitions for ${blocks.length} block(s)`);
     } catch (error) {
@@ -117864,7 +118004,7 @@ class DevCommand {
         return;
       }
       logger.info(`\uD83D\uDCC4 Found ${dependentFiles.size} content file(s) that depend on changed blocks`);
-      logger.debug(`Dependent files: ${Array.from(dependentFiles).map((f) => path15.basename(f)).join(", ")}`);
+      logger.debug(`Dependent files: ${Array.from(dependentFiles).map((f) => path16.basename(f)).join(", ")}`);
       const config2 = this.configManager.getConfig();
       const contentDir = this.configManager.resolvePath(config2.paths.mdxOutputDir);
       await this.mdxDependencyTracker.scanMDXDependencies(contentDir);
@@ -117899,7 +118039,7 @@ class DevCommand {
 
 // src/commands/build-templates-command.ts
 import * as fs15 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 class BuildTemplatesCommand {
   configManager;
   constructor() {
@@ -117941,8 +118081,8 @@ class BuildTemplatesCommand {
     let errorCount = 0;
     for (let i2 = 0;i2 < templateFiles.length; i2++) {
       const templateFile = templateFiles[i2];
-      const relativePath = path16.relative(templatesDir, templateFile);
-      const templateName = path16.basename(templateFile, ".mdx");
+      const relativePath = path17.relative(templatesDir, templateFile);
+      const templateName = path17.basename(templateFile, ".mdx");
       logger.step(i2 + 1, templateFiles.length, `Building template: ${relativePath}`);
       try {
         await this.buildTemplate(templateFile, templateName, outputDir, renderer);
@@ -117966,15 +118106,15 @@ class BuildTemplatesCommand {
     const cleanContent = this.removeFrontmatter(mdxContent);
     const html5 = await renderer.renderMDXToHTML(cleanContent);
     const cleanHTML = renderer.postProcessHTML(html5);
-    const outputPath = path16.join(outputDir, `${templateName}.html`);
+    const outputPath = path17.join(outputDir, `${templateName}.html`);
     fs15.writeFileSync(outputPath, cleanHTML, "utf8");
-    logger.info(`✓ Generated: ${path16.relative(process.cwd(), outputPath)}`);
+    logger.info(`✓ Generated: ${path17.relative(process.cwd(), outputPath)}`);
   }
   findMDXFiles(dir) {
     const files = [];
     const entries = fs15.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...this.findMDXFiles(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
@@ -117988,10 +118128,63 @@ class BuildTemplatesCommand {
     return content4.replace(frontmatterRegex, "").trim();
   }
 }
+// package.json
+var package_default = {
+  name: "@wordpress-flow/cli",
+  version: "1.0.5",
+  type: "module",
+  description: "TypeScript-based WordPress block creation system",
+  main: "dist/index.js",
+  bin: {
+    "wordpress-flow": "./dist/index.js"
+  },
+  scripts: {
+    build: "bun build ./src/index.ts --outdir ./dist --target node && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node"
+  },
+  dependencies: {
+    "@babel/core": "^7.28.4",
+    "@babel/preset-react": "^7.27.1",
+    "@mdx-js/mdx": "^3.1.1",
+    "@mdx-js/react": "^3.1.1",
+    "@types/react": "^18.3.24",
+    "@types/wordpress__block-editor": "^11.5.17",
+    "@wordpress/block-editor": "^15.4.0",
+    "@wordpress/block-serialization-default-parser": "^5.33.0",
+    "@wordpress/blocks": "^15.6.0",
+    "@wordpress/element": "^6.33.0",
+    ajv: "^8.17.1",
+    axios: "^1.12.2",
+    chalk: "^4.1.2",
+    chokidar: "^3.5.3",
+    commander: "^11.0.0",
+    dotenv: "^17.2.3",
+    esbuild: "^0.19.0",
+    glob: "^11.0.3",
+    mysql2: "^3.15.2",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  devDependencies: {
+    "@types/glob": "^9.0.0",
+    "@types/mysql": "^2.15.27",
+    "@types/node": "^20.0.0",
+    "@wordpress/scripts": "^30.24.0",
+    typescript: "^5.0.0",
+    "webpack-cli": "^6.0.1"
+  },
+  keywords: [
+    "wordpress",
+    "blocks",
+    "cli",
+    "typescript"
+  ],
+  author: "Przemysław Krasiński",
+  license: "MIT"
+};
 
 // src/index.ts
 var program2 = new Command;
-program2.name("wordpress-flow").description("Build WordPress sites with React, TypeScript, and MDX - A content-first development framework").version("0.0.1");
+program2.name("wordpress-flow").description("Build WordPress sites with React, TypeScript, and MDX - A content-first development framework").version(package_default.version);
 program2.option("-v, --verbose", "Enable verbose logging").option("-q, --quiet", "Suppress non-error output").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.verbose) {
@@ -118009,7 +118202,7 @@ program2.command("setup").description("Run the configuration wizard").action(asy
     process.exit(1);
   }
 });
-program2.command("build").description("Build WordPress blocks for Gutenberg").option("--blocks-dir <dir>", "Source directory for blocks").option("--output-dir <dir>", "Output directory for built blocks").option("--webpack-config <path>", "Path to webpack config file").option("--watch", "Watch mode for development").action(async (options) => {
+program2.command("build").description("Build WordPress blocks for Gutenberg").option("--blocks-dir <dir>", "Source directory for blocks").option("--output-dir <dir>", "Output directory for built blocks").option("--webpack-config <path>", "Path to webpack config file").option("--watch", "Watch mode for development").option("-b, --blocks <names...>", "Specific block names to build").option("-c, --concurrency <number>", "Number of parallel workers (default: CPU cores - 1)").action(async (options) => {
   try {
     await ensureConfiguration();
     const command = new BuildCommand;
@@ -118017,7 +118210,9 @@ program2.command("build").description("Build WordPress blocks for Gutenberg").op
       blocksDir: options.blocksDir,
       outputDir: options.outputDir,
       webpackConfig: options.webpackConfig,
-      watch: options.watch || false
+      watch: options.watch || false,
+      blocks: options.blocks,
+      concurrency: options.concurrency ? parseInt(options.concurrency, 10) : undefined
     });
     logger.info("Build command completed successfully");
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordpress-flow/cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "module",
   "description": "TypeScript-based WordPress block creation system",
   "main": "dist/index.js",
@@ -8,7 +8,7 @@
     "wordpress-flow": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node"
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node"
   },
   "dependencies": {
     "@babel/core": "^7.28.4",