uiBundleGenerator.ts

/*
 * Copyright (c) 2025, salesforce.com, inc.
 * All rights reserved.
 * Licensed under the BSD 3-Clause license.
 * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
 */
import { camelCaseToTitleCase } from '@salesforce/kit';
import * as path from 'path';
import { CreateUtil } from '../utils';
import { UI_BUNDLES_DIR } from '../utils/constants';
import { UIBundleOptions } from '../utils/types';
import { BaseGenerator } from './baseGenerator';

export default class UIBundleGenerator extends BaseGenerator<UIBundleOptions> {
  public validateOptions(): void {
    CreateUtil.checkInputs(this.options.bundlename);
    CreateUtil.checkInputs(this.options.template);

    // Ensure output directory includes 'uiBundles' folder
    if (!this.options.internal) {
      const fileparts = path
        .resolve(this.outputdir)
        .split(path.sep)
        .filter(Boolean);
      const endsWithUiBundles =
        fileparts[fileparts.length - 1] === UI_BUNDLES_DIR;
      if (!endsWithUiBundles) {
        this.outputdir = path.join(this.outputdir, UI_BUNDLES_DIR);
      }
    }
  }

  public async generate(): Promise<void> {
    const { bundlename } = this.options;
    const template = this.options.template.toLowerCase();
    const masterLabel =
      this.options.masterlabel || camelCaseToTitleCase(bundlename);
    const bundleDir = path.join(this.outputdir, bundlename);

    switch (template) {
      case 'reactbasic':
        await this.generateReactBasic(bundleDir, bundlename, masterLabel);
        break;
      case 'angularbasic':
        await this.generateAngularBasic(bundleDir, bundlename, masterLabel);
        break;
      default:
        await this.generateDefault(bundleDir, bundlename, masterLabel);
    }
  }

  private async generateDefault(
    bundleDir: string,
    bundlename: string,
    masterLabel: string
  ): Promise<void> {
    this.sourceRootWithPartialPath(path.join('uiBundles', 'webappbasic'));

    await this.render(
      this.templatePath('_uibundle.uibundle-meta.xml'),
      this.destinationPath(
        path.join(bundleDir, `${bundlename}.uibundle-meta.xml`)
      ),
      { apiVersion: this.apiversion, masterLabel }
    );

    const templatePath = this.sourceRoot();
    await this.copyDirectoryRecursive(
      templatePath,
      bundleDir,
      new Set(['_uibundle.uibundle-meta.xml'])
    );
  }

  private async generateReactBasic(
    bundleDir: string,
    bundlename: string,
    masterLabel: string
  ): Promise<void> {
    this.sourceRootWithPartialPath(path.join('uiBundles', 'reactbasic'));

    await this.render(
      this.templatePath('_uibundle.uibundle-meta.xml'),
      this.destinationPath(
        path.join(bundleDir, `${bundlename}.uibundle-meta.xml`)
      ),
      { apiVersion: this.apiversion, masterLabel }
    );

    await this.render(
      this.templatePath('package.json'),
      this.destinationPath(path.join(bundleDir, 'package.json')),
      { bundlename }
    );

    const templatePath = this.sourceRoot();
    await this.copyDirectoryRecursive(
      templatePath,
      bundleDir,
      new Set(['_uibundle.uibundle-meta.xml', 'package.json'])
    );
  }

  private async generateAngularBasic(
    bundleDir: string,
    bundlename: string,
    masterLabel: string
  ): Promise<void> {
    this.sourceRootWithPartialPath(path.join('uiBundles', 'angularbasic'));

    await this.render(
      this.templatePath('_uibundle.uibundle-meta.xml'),
      this.destinationPath(
        path.join(bundleDir, `${bundlename}.uibundle-meta.xml`)
      ),
      { apiVersion: this.apiversion, masterLabel }
    );

    await this.render(
      this.templatePath('package.json'),
      this.destinationPath(path.join(bundleDir, 'package.json')),
      { bundlename }
    );

    await this.render(
      this.templatePath('angular.json'),
      this.destinationPath(path.join(bundleDir, 'angular.json')),
      { bundlename }
    );

    const templatePath = this.sourceRoot();
    await this.copyDirectoryRecursive(
      templatePath,
      bundleDir,
      new Set(['_uibundle.uibundle-meta.xml', 'package.json', 'angular.json'])
    );
  }

  private async copyDirectoryRecursive(
    sourceDir: string,
    destDir: string,
    excludeFiles: ReadonlySet<string> = new Set()
  ): Promise<void> {
    if (!this._fs.existsSync(sourceDir)) {
      return;
    }

    await this._fs.promises.mkdir(destDir, { recursive: true });

    const entries = this._fs.readdirSync(sourceDir, { withFileTypes: true });

    for (const entry of entries) {
      const sourcePath = path.join(sourceDir, entry.name);
      const destPath = path.join(destDir, entry.name);

      // Skip template files that were rendered
      if (excludeFiles.has(entry.name)) {
        continue;
      }

      if (entry.isDirectory()) {
        await this.copyDirectoryRecursive(sourcePath, destPath, excludeFiles);
      } else if (!this._fs.existsSync(destPath)) {
        // Copy file and track it
        const content = await this._fs.promises.readFile(sourcePath);
        await this._fs.promises.mkdir(path.dirname(destPath), {
          recursive: true,
        });
        await this._fs.promises.writeFile(destPath, content as Uint8Array);

        // Register the created file
        const relativePath = path.relative(this._cwd, destPath);
        this.changes.created.push(relativePath);
      }
    }
  }
}