@nomadmystic/wordpress-scaffold-cli/dist/bin/scaffold-plugin.js

This project is created to speed up WordPress development

#!/usr/bin/env node
import 'dotenv/config';
import InquirerCli from '../cli/inquirer-cli.js';
import AbstractScaffold from '../abstract/AbstractScaffold.js';
import { ProjectJson } from '../scaffold/common/update-internal-json.js';
import PathUtils from '../utils/path-utils.js';
import StringUtils from '../utils/string-utils.js';
import getPluginOptions from '../config/plugin-options.js';
import UpdateTypeFiles from '../scaffold/common/update-type-files.js';
import MessagingUtils from '../utils/messaging-utils.js';
import CreateObjectArrays from '../scaffold/common/create-object-arrays.js';
import DebugUtils from "../utils/debug-utils.js";
class ScaffoldPlugin extends AbstractScaffold {
    static isDebugFullMode = false;
    static composerAlreadyExists = false;
    static packageAlreadyExists = false;
    static pluginValues;
    static initializeScaffolding = async () => {
        try {
            await PathUtils.checkForWordPressInstall();
            this.isDebugFullMode = await DebugUtils.isDebugFullMode();
            const answers = await InquirerCli.performPromptsTasks(await getPluginOptions()).catch((err) => console.error(err));
            await this.scaffoldFiles(answers);
        }
        catch (err) {
            console.log('ScaffoldTheme.performScaffolding()');
            console.error(err);
        }
    };
    static scaffoldFiles = async (answers) => {
        try {
            this.pluginValues = await this.buildValueObject(answers);
            if (this.isDebugFullMode) {
                console.log(this.pluginValues);
            }
            await PathUtils.validateIsPathWithDisplay(this.pluginValues.finalPath, 'There is already a plugin with that name. Please use another name.', true);
            let pluginConfig = await this.updateProjectConfig(this.pluginValues);
            await this.performScaffold(this.pluginValues, pluginConfig);
            await MessagingUtils.displayEndingMessages(this.pluginValues, this.composerAlreadyExists, this.packageAlreadyExists);
        }
        catch (err) {
            console.log('ScaffoldTheme.scaffoldFiles()');
            console.error(err);
        }
    };
    static buildValueObject = async (answers) => {
        try {
            const pluginsPath = await PathUtils.getPluginsFolderPath();
            const projectName = answers.projectName ? answers.projectName : '';
            const name = answers.name ? answers.name.trim() : '';
            const description = answers.description ? answers.description.trim() : '';
            const frontEndFramework = answers.frontEndFramework ? answers.frontEndFramework : '';
            const siteUrl = answers.siteUrl;
            const devSiteUrl = answers.devSiteUrl;
            const safeName = await StringUtils.addDashesToString(name);
            const finalPluginPath = `${pluginsPath}/${safeName}`;
            const capAndSnakeCasePlugin = await StringUtils.capAndSnakeCaseString(safeName);
            const pluginNamespace = await StringUtils.pascalCaseString(safeName);
            return {
                type: 'plugin',
                projectName: projectName,
                name: name,
                safeName: safeName,
                pluginsPath: pluginsPath,
                finalPath: finalPluginPath,
                description: description,
                frontEndFramework: frontEndFramework,
                siteUrl: siteUrl,
                devSiteUrl: devSiteUrl,
                capAndSnakeCasePlugin: capAndSnakeCasePlugin,
                namespace: pluginNamespace,
            };
        }
        catch (err) {
            console.log('ScaffoldTheme.buildValueObject()');
            console.error(err);
        }
    };
    static updateProjectConfig = async (pluginValues) => {
        try {
            let { projectName, name, finalPath, description, frontEndFramework, } = pluginValues;
            let configUpdates = {
                'plugin-name': name,
                'plugin-path': finalPath,
                'plugin-description': description,
                'plugin-front-end-framework': frontEndFramework,
            };
            if (projectName && typeof projectName !== 'undefined') {
                configUpdates['project-name'] = projectName;
                configUpdates['project-namespace'] = await StringUtils.pascalCaseString(projectName);
            }
            configUpdates = await ProjectJson.update(configUpdates, 'plugin');
            return configUpdates;
        }
        catch (err) {
            console.log('ScaffoldPlugin.updateProjectConfig()');
            console.error(err);
        }
    };
    static performScaffold = async (pluginValues, pluginConfig) => {
        try {
            const updateObjectsArray = await this.buildUpdateObjectArray(pluginValues);
            const foldersToCopy = await this.buildFoldersToCopy(pluginValues);
            await UpdateTypeFiles.copyFiles(foldersToCopy);
            await UpdateTypeFiles.updateFiles(pluginValues, updateObjectsArray);
            await UpdateTypeFiles.updateClassFiles(pluginValues);
            await UpdateTypeFiles.updateWebpack(pluginValues, 'plugin');
        }
        catch (err) {
            console.log('ScaffoldPlugin.performScaffold()');
            console.error(err);
        }
    };
    static buildFoldersToCopy = async (pluginValues) => {
        try {
            const foldersToCopy = [
                {
                    source: 'scaffolding/plugin',
                    destination: `${pluginValues.finalPath}`,
                },
                {
                    source: 'scaffolding/common/classes',
                    destination: `${pluginValues.finalPath}/classes`,
                },
                {
                    source: `scaffolding/common/front-end-scaffolding/${pluginValues.frontEndFramework?.toLowerCase()}/js`,
                    destination: `${pluginValues.finalPath}/src/js`,
                },
                {
                    source: `scaffolding/common/front-end-scaffolding/${pluginValues.frontEndFramework?.toLowerCase()}/scss`,
                    destination: `${pluginValues.finalPath}/src/scss`,
                },
                {
                    source: `scaffolding/common/front-end-scaffolding/${pluginValues.frontEndFramework?.toLowerCase()}/project-root`,
                    destination: `${pluginValues.finalPath}`,
                },
                {
                    source: 'scaffolding/common/project-root',
                    destination: `${pluginValues.finalPath}`,
                },
            ];
            return foldersToCopy;
        }
        catch (err) {
            console.log('ScaffoldPlugin.buildFoldersToCopy()');
            console.error(err);
        }
    };
    static buildUpdateObjectArray = async (pluginValues) => {
        try {
            const updateObjectsArray = [
                {
                    fileName: 'plugin-name.php',
                    stringToUpdate: 'SCAFFOLD_NAME',
                    updateString: pluginValues.name,
                },
                {
                    fileName: 'plugin-name.php',
                    stringToUpdate: 'SCAFFOLD_DESCRIPTION',
                    updateString: pluginValues.description,
                },
                {
                    fileName: 'plugin-name.php',
                    stringToUpdate: 'SCAFFOLD_DESCRIPTION',
                    updateString: pluginValues.description,
                },
                {
                    fileName: 'plugin-name.php',
                    stringToUpdate: 'CAPS_AND_SNAKE_NAME',
                    updateString: pluginValues.capAndSnakeCasePlugin,
                },
                {
                    fileName: 'webpack.config.js',
                    stringToUpdate: 'SCAFFOLD_NAME',
                    updateString: pluginValues.name,
                },
                {
                    fileName: 'classes/BootstrapClasses.php',
                    stringToUpdate: 'CAPS_AND_SNAKE_NAME',
                    updateString: pluginValues.capAndSnakeCasePlugin,
                },
            ];
            const composerObjects = await CreateObjectArrays.readComposerObjects(pluginValues, this.composerAlreadyExists);
            if (!this.composerAlreadyExists) {
                updateObjectsArray.push(...composerObjects);
            }
            const packageObjects = await CreateObjectArrays.readPackageObjects(pluginValues, this.packageAlreadyExists);
            if (!this.packageAlreadyExists) {
                updateObjectsArray.push(...packageObjects);
            }
            return updateObjectsArray;
        }
        catch (err) {
            console.log('ScaffoldPlugin.buildUpdateObjectArray()');
            console.error(err);
        }
    };
}
ScaffoldPlugin.initializeScaffolding().catch(err => console.error(err));