block-dev-tool/platforms/wordpress/wordpress-adapter.js

import path from "path";
import fs, {mkdir, copyFile} from "fs/promises";
import {capitalize, createFiles, getBlockName, getConfigs, readJSONFile} from "../../helpers.js";
import {fileURLToPath} from 'url';
import {copy} from "fs-extra";
import {exec} from 'child_process';
import execPhp from "exec-php";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

export async function buildWordPress(blockName, args = {}) {
  const {modulesPath, projectPath} = getConfigs();

  const distPath = path.join(projectPath, 'exports', args.platform);
  // await mkdir(distPath, {recursive: true})
  await mkdir(path.join(distPath, 'templates'), {recursive: true})

  const blockFilePath = path.join(projectPath, 'block.json');

  let data = await readJSONFile(blockFilePath);
  Object.assign(data, getBlockName(data.name));

  const title = capitalize(data.name);
  const owner = capitalize(data.project);

  data = Object.assign(data, {
    title,
    blockClassModel: title.replace(/ /ig, '_'),
    blockFilename: title.toLowerCase().replace(/ /ig, '-'),
    blockClassName: title.toLowerCase().replace(/ /ig, '_'),
    owner,
    ownerClass: owner.replace(/ /ig, '_'),
    ownerFilename: owner.toLowerCase().replace(/ /ig, '-'),
    templateFormat: 'php',
    include_script: true,
  });

  await copyFile(blockFilePath, path.join(distPath, data.blockFilename + '.block.json'));

  const backPath = modulesPath ? modulesPath.split('/').map(() => '..').join('/') : '';

  const phpGeneratorPath = path.join(modulesPath, 'platforms', 'php');
  await execCommand(`cd ${phpGeneratorPath} && composer install`);
  await execPHPFile(path.join(phpGeneratorPath, 'build.php'), 'build', {
    blockName,
    backPath,
    projectPath,
    platform: args.platform
  });

  await copyStaticFile(
    path.join(projectPath, 'src', 'styles', `${data.blockFilename}.min.css`),
    path.join(distPath, 'templates', 'styles', `${data.blockFilename}.min.css`),
  );

  await copyStaticFile(
    path.join(projectPath, 'src', 'scripts', `${data.blockFilename}.min.js`),
    path.join(distPath, 'templates', 'scripts', `${data.blockFilename}.min.js`),
  );

  try {
    const imagesPath = path.join(projectPath, 'src', 'images');
    await fs.access(imagesPath);

    await copy(
      path.join(imagesPath),
      path.join(distPath, 'templates', 'images'),
    );
  } catch (err) {
    // Folder doesn't exist.
  }

  const phpDataObject = await execPHPFile(path.join(phpGeneratorPath, 'build.php'), 'jsonToPhp', {
    json: await readJSONFile(path.join(projectPath, 'data', 'default.json'), "utf8"),
  });

  await createFiles(data, [{
    from: `templates/helpers/Template_Elementor_Widget.php`,
    to: `helpers/${data.blockClassModel}_Elementor_Widget.php`,
  }], {
    pathDist: distPath,
    generatorsPath: path.join(__dirname)
  });

  await createFiles(data, [{
    from: `templates/Template_Basic_Component.php`,
    to: `${data.blockClassModel}_Component.php`,
  }], {
    pathDist: distPath,
    generatorsPath: path.join(__dirname)
  });
}

export function execCommand(cmd = '') {
  return new Promise((resolve, reject) => {

    exec(cmd, function (error) {
      if (error) {
        console.log('Error:', error)
        reject(error);
      }

      // console.log(stdout);
      resolve();
    });

  });
}

function execPHPFile(file = '', functionName = '', args = {}) {
  return new Promise((resolve, reject) => {
    execPhp(file, 'php', (err, php, out) => {
      if (err) {
        console.error(out);
        return reject(err);
      }

      php[functionName.toLowerCase()](args, (err, res, out) => {
        if (err) {
          console.error(out);
          return reject(err);
        }

        return resolve(res);
      })
    })
  });
}

async function copyStaticFile(from = '', to = '') {
  await mkdir(path.dirname(to), {recursive: true})
  await copyFile(from, to);
}