@adobe/ccweb-add-on-scaffolder 3.0.0 → 3.2.0

package/src/app/AddOnBuilder.ts

@@ -9,10 +9,10 @@
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -22,27 +22,83 @@
  * SOFTWARE.
  ********************************************************************************/
 
-import type { PackageJson, TemplateJson } from "@adobe/ccweb-add-on-core";
+import type { Logger } from "@adobe/ccweb-add-on-core";
+import {
+    ADDITIONAL_ADD_ON_INFO,
+    DEFAULT_ADD_ON_VERSION,
+    ITypes as ICoreTypes,
+    PackageJson,
+    TemplateJson,
+    getJSONString,
+    isNullOrWhiteSpace
+} from "@adobe/ccweb-add-on-core";
+import type { CreateManifestResult, ManifestEntrypoint } from "@adobe/ccweb-add-on-manifest";
+import { AddOnManifest, EntrypointType } from "@adobe/ccweb-add-on-manifest";
+import fs from "fs-extra";
+import { inject, injectable } from "inversify";
+import { createRequire } from "module";
+import os from "os";
+import path from "path";
 import "reflect-metadata";
+import format from "string-template";
+import { v4 as uuidv4 } from "uuid";
+import { MANIFEST_JSON, PACKAGE_JSON, TEMPLATE_JSON, TEMP_TEMPLATE_PATH } from "../constants.js";
 import type { ScaffolderOptions } from "../models/ScaffolderOptions.js";
 
 /**
- * Add-on builder interface for constructing the Add-on project.
+ * Add-on builder factory.
+ */
+export type AddOnBuilderFactory = (options: ScaffolderOptions) => AddOnBuilder;
+
+/**
+ * Builder class for constructing the add-on project.
  */
-export interface AddOnBuilder {
+@injectable()
+export class AddOnBuilder {
+    private readonly _logger: Logger;
+
+    private _options!: ScaffolderOptions;
+    private _require!: NodeRequire;
+    private _templateRootDirectory!: string;
+
+    private _gitignoreExists = false;
+    private _readmeExists = false;
+
+    /**
+     * Instantiate {@link AddOnBuilder}.
+     * @param options - {@link ScaffolderOptions}.
+     * @param logger - {@link Logger} reference.
+     * @returns Reference to a new {@link AddOnBuilder} instance.
+     */
+    constructor(options: ScaffolderOptions, @inject(ICoreTypes.Logger) logger: Logger) {
+        this._options = options;
+        this._logger = logger;
+
+        this._require = createRequire(import.meta.url);
+        this._templateRootDirectory = path.join(process.cwd(), TEMP_TEMPLATE_PATH);
+    }
+
     /**
      * Get {@link PackageJson}.
      *
      * @returns Reference of {@link PackageJson}.
      */
-    getPackageJson(): PackageJson;
+    getPackageJson(): PackageJson {
+        const packageJsonPath = path.join(this._options.addOnDirectory, PACKAGE_JSON);
+        return new PackageJson(this._require(packageJsonPath));
+    }
 
     /**
      * Get {@link TemplateJson}.
      *
      * @returns Reference of {@link TemplateJson}.
      */
-    getTemplateJson(): TemplateJson;
+    getTemplateJson(): TemplateJson {
+        const templateJsonPath = path.join(this._templateRootDirectory, TEMPLATE_JSON);
+        return fs.existsSync(templateJsonPath)
+            ? new TemplateJson(this._require(templateJsonPath))
+            : new TemplateJson({});
+    }
 
     /**
      * Get template devDependencies.
@@ -50,7 +106,16 @@ export interface AddOnBuilder {
      * @param template - {@link TemplateJson}
      * @returns Set of template devDependencies.
      */
-    getDevDependenciesToInstall(template: TemplateJson): Set<string>;
+    getDevDependenciesToInstall(template: TemplateJson): Set<string> {
+        const devDependencies = new Set<string>();
+        if (template.devDependencies) {
+            template.devDependencies.forEach((value, key) => {
+                devDependencies.add(`${key}@${value}`);
+            });
+        }
+
+        return devDependencies;
+    }
 
     /**
      * Get template dependencies.
@@ -58,22 +123,200 @@ export interface AddOnBuilder {
      * @param template - {@link TemplateJson}
      * @returns Set of template dependencies.
      */
-    getDependenciesToInstall(template: TemplateJson): Set<string>;
+    getDependenciesToInstall(template: TemplateJson): Set<string> {
+        const dependencies = new Set<string>();
+        if (template.dependencies) {
+            template.dependencies.forEach((value, key) => {
+                dependencies.add(`${key}@${value}`);
+            });
+        }
+
+        return dependencies;
+    }
 
     /**
      * Build the Add-on.
      *
      * @param packageJson - {@link PackageJson}
      */
-    build(packageJson: string): void;
+    build(packageJson: string): void {
+        fs.writeFileSync(path.join(this._options.addOnDirectory, PACKAGE_JSON), packageJson + os.EOL);
+
+        this._updateReadMe();
+        this._copyTemplateFiles();
+        this._updateGitIgnore();
+        this._updateManifest();
+        this._removeTemplateTempFiles();
+    }
 
     /**
      * Display success message.
      */
-    displaySuccess(): void;
+    displaySuccess(): void {
+        let cdPath;
+        if (
+            !isNullOrWhiteSpace(this._options.rootDirectory) &&
+            path.join(this._options.rootDirectory, this._options.addOnName) === this._options.addOnDirectory
+        ) {
+            cdPath = this._options.addOnName;
+        } else {
+            cdPath = this._options.addOnDirectory;
+        }
+
+        this._logger.success(
+            format(LOGS.successCreatedAddOn, {
+                addOnName: this._options.addOnName,
+                addOnDirectory: this._options.addOnDirectory
+            })
+        );
+        this._logger.success(LOGS.insideDirectoryCommandsToRun, { postfix: LOGS.newLine });
+
+        this._logger.information(LOGS.npmRunBuild, { prefix: `${LOGS.tab}` });
+        this._logger.message(LOGS.buildsTheAddOn, { prefix: `${LOGS.tab}${LOGS.tab}` });
+        this._logger.information(LOGS.npmRunStart, { prefix: LOGS.tab });
+        this._logger.message(LOGS.startsTheAddOn, { prefix: `${LOGS.tab}${LOGS.tab}` });
+
+        this._logger.message(LOGS.suggestBeginByTyping, {
+            prefix: LOGS.newLine,
+            postfix: LOGS.newLine
+        });
+
+        this._logger.warning(format(LOGS.changeDirectoryIntoCreatedApp, { cdPath }), {
+            prefix: LOGS.tab
+        });
+        this._logger.information(LOGS.npmRunBuild, { prefix: LOGS.tab });
+        this._logger.information(LOGS.npmRunStart, { prefix: LOGS.tab, postfix: LOGS.newLine });
+
+        if (this._readmeExists) {
+            this._logger.warning(LOGS.renamedReadme, { postfix: LOGS.newLine });
+        }
+
+        if (this._gitignoreExists) {
+            this._logger.warning(LOGS.mergedGitIgnore, { postfix: LOGS.newLine });
+        }
+
+        this._logger.warning(LOGS.whatWillYouCreateToday, { postfix: LOGS.newLine });
+    }
+
+    private _updateReadMe(): void {
+        this._readmeExists = fs.existsSync(path.join(this._options.addOnDirectory, "README.md"));
+        if (this._readmeExists) {
+            fs.renameSync(
+                path.join(this._options.addOnDirectory, "README.md"),
+                path.join(this._options.addOnDirectory, "README.OLD.md")
+            );
+        }
+    }
+
+    private _copyTemplateFiles(): void {
+        const templateContentDirectory = path.join(this._templateRootDirectory, "template");
+        if (fs.existsSync(templateContentDirectory)) {
+            fs.copySync(templateContentDirectory, this._options.addOnDirectory);
+        } else {
+            this._logger.warning(format(LOGS.couldNotLocateTemplate, { templateContentDirectory }));
+            process.exit(1);
+        }
+    }
+
+    private _updateGitIgnore(): void {
+        this._gitignoreExists = fs.existsSync(path.join(this._options.addOnDirectory, ".gitignore"));
+        if (this._gitignoreExists) {
+            const data = fs.readFileSync(path.join(this._options.addOnDirectory, "gitignore"));
+            fs.appendFileSync(path.join(this._options.addOnDirectory, ".gitignore"), data);
+            fs.unlinkSync(path.join(this._options.addOnDirectory, "gitignore"));
+        } else {
+            fs.moveSync(
+                path.join(this._options.addOnDirectory, "gitignore"),
+                path.join(this._options.addOnDirectory, ".gitignore")
+            );
+        }
+    }
+
+    private _updateManifest(): void {
+        const manifestJsonPath = path.join(this._options.addOnDirectory, "src", MANIFEST_JSON);
+        const manifestExists = fs.existsSync(manifestJsonPath);
+
+        let createManifestResult: CreateManifestResult;
+        if (manifestExists) {
+            const manifestFile = this._require(manifestJsonPath);
+            const addOnName = this._getAddOnName(this._options.addOnName);
+            const manifestEntryPoints = (manifestFile.entryPoints as ManifestEntrypoint[]) ?? [];
+            createManifestResult = AddOnManifest.createManifest({
+                manifest: {
+                    ...manifestFile,
+                    testId: uuidv4(),
+                    name: addOnName,
+                    version: DEFAULT_ADD_ON_VERSION,
+                    entryPoints: manifestEntryPoints
+                },
+                additionalInfo: ADDITIONAL_ADD_ON_INFO
+            });
+
+            fs.unlinkSync(manifestJsonPath);
+        } else {
+            createManifestResult = AddOnManifest.createManifest({
+                manifest: {
+                    testId: uuidv4(),
+                    name: this._getAddOnName(this._options.addOnName),
+                    version: DEFAULT_ADD_ON_VERSION,
+                    manifestVersion: 2,
+                    requirements: {
+                        apps: [
+                            {
+                                name: "Express",
+                                apiVersion: 1
+                            }
+                        ]
+                    },
+                    entryPoints: [
+                        {
+                            type: EntrypointType.PANEL,
+                            id: this._options.addOnName,
+                            main: ""
+                        }
+                    ]
+                },
+                additionalInfo: ADDITIONAL_ADD_ON_INFO
+            });
+        }
+
+        if (createManifestResult.manifest === undefined) {
+            return this._logger.warning(
+                format(LOGS.invalidManifestInTemplate, {
+                    templateName: this._options.templateName,
+                    error: getJSONString(createManifestResult.manifestValidationResult)
+                })
+            );
+        }
+
+        fs.writeFileSync(manifestJsonPath, getJSONString(createManifestResult.manifest.manifestProperties) + os.EOL);
+    }
+
+    private _getAddOnName(addOnName: string): string {
+        const camelCase = addOnName.replace(/[-_]\w/g, text => text.replace(/[-_]/, "").toUpperCase());
+        const wordCase = camelCase.replace(/([A-Z])/g, " $1");
+        return wordCase.charAt(0).toUpperCase() + wordCase.slice(1);
+    }
+
+    private _removeTemplateTempFiles(): void {
+        fs.removeSync(this._templateRootDirectory);
+    }
 }
 
-/**
- * Add-on builder factory.
- */
-export type AddOnBuilderFactory = (options: ScaffolderOptions) => AddOnBuilder;
+const LOGS = {
+    newLine: "\n",
+    tab: "  ",
+    couldNotLocateTemplate: "Could not locate template: {templateContentDirectory}",
+    invalidManifestInTemplate: "Invalid manifest in the template: {templateName}. Error: {error}",
+    successCreatedAddOn: "Success! Created {addOnName} at {addOnDirectory}.",
+    insideDirectoryCommandsToRun: "Inside this directory, you can run the following commands:",
+    npmRunBuild: "npm run build",
+    npmRunStart: "npm run start",
+    buildsTheAddOn: "Builds the Add-on.",
+    startsTheAddOn: "Starts the development server and hosts the Add-on.",
+    suggestBeginByTyping: "We suggest that you begin by typing:",
+    changeDirectoryIntoCreatedApp: "cd {cdPath}",
+    renamedReadme: "You had a 'README.md' file, we renamed it to 'README.OLD.md'",
+    mergedGitIgnore: "You had a '.gitignore' file, we merged it with the template '.gitignore'",
+    whatWillYouCreateToday: "So what will you create today?"
+};

package/src/app/AddOnScaffolder.ts

@@ -22,16 +22,133 @@
  * SOFTWARE.
  ********************************************************************************/
 
+import type { Logger, Process } from "@adobe/ccweb-add-on-core";
+import { DEFAULT_HOST_NAME, ITypes as ICoreTypes } from "@adobe/ccweb-add-on-core";
+import type { CommandExecutor as SSLCommandExecutor } from "@adobe/ccweb-add-on-ssl";
+import { ITypes as ISSLTypes, SetupCommandOptions as SSLSetupCommandOptions } from "@adobe/ccweb-add-on-ssl";
+import { inject, injectable, named } from "inversify";
+import "reflect-metadata";
+import { ITypes } from "../config/inversify.types.js";
 import type { ScaffolderOptions } from "../models/ScaffolderOptions.js";
+import type { TemplateValidator } from "../validators/TemplateValidator.js";
+import type { AddOnBuilderFactory } from "./AddOnBuilder.js";
+import type { PackageBuilderFactory } from "./PackageBuilder.js";
 
 /**
- * Add-on scaffolder interface for orchestrating the creation of the Add-on project.
+ * Scaffolder class for orchestrating the creation of the add-on project.
  */
-export interface AddOnScaffolder {
+@injectable()
+export class AddOnScaffolder {
+    private readonly _addOnBuilderFactory: AddOnBuilderFactory;
+    private readonly _packageBuilderFactory: PackageBuilderFactory;
+    private readonly _templateValidator: TemplateValidator;
+
+    private readonly _sslCommandExecutor: SSLCommandExecutor<SSLSetupCommandOptions>;
+
+    private readonly _process: Process;
+    private readonly _logger: Logger;
+
+    /**
+     * Instantiate {@link TemplateAppScaffolder}.
+     * @param addOnBuilderFactory - {@link AddOnBuilderFactory} reference.
+     * @param packageBuilderFactory - {@link PackageBuilderFactory} reference.
+     * @param templateValidator - {@link TemplateValidator} reference.
+     * @param sslCommandExecutor - {@link SSLCommandExecutor} reference.
+     * @param cliProcess - {@link Process} reference.
+     * @param logger - {@link Logger} reference.
+     * @returns Reference to a new {@link TemplateAppScaffolder} instance.
+     */
+    constructor(
+        @inject(ITypes.AddOnBuilder) addOnBuilderFactory: AddOnBuilderFactory,
+        @inject(ITypes.PackageBuilder) packageBuilderFactory: PackageBuilderFactory,
+        @inject(ITypes.TemplateValidator) templateValidator: TemplateValidator,
+        @inject(ISSLTypes.CommandExecutor)
+        @named("setup")
+        sslCommandExecutor: SSLCommandExecutor<SSLSetupCommandOptions>,
+        @inject(ICoreTypes.Process) cliProcess: Process,
+        @inject(ICoreTypes.Logger) logger: Logger
+    ) {
+        this._addOnBuilderFactory = addOnBuilderFactory;
+        this._packageBuilderFactory = packageBuilderFactory;
+        this._templateValidator = templateValidator;
+
+        this._sslCommandExecutor = sslCommandExecutor;
+
+        this._process = cliProcess;
+        this._logger = logger;
+    }
+
     /**
      * Run the scaffolder to create the Add-on project from the provided options.
      * @param options - {@link ScaffolderOptions} reference.
      * @returns Promise.
      */
-    run(options: ScaffolderOptions): Promise<void>;
+    async run(options: ScaffolderOptions): Promise<void> {
+        try {
+            this._templateValidator.validateTemplate(options.templateName);
+
+            const addOnBuilder = this._addOnBuilderFactory(options);
+            const packageJson = addOnBuilder.getPackageJson();
+            const templateJson = addOnBuilder.getTemplateJson();
+
+            const packageBuilder = this._packageBuilderFactory(packageJson)(templateJson);
+            const combinedPackage = packageBuilder.build();
+
+            addOnBuilder.build(combinedPackage.toJSON());
+
+            const templateDevDependencies = addOnBuilder.getDevDependenciesToInstall(templateJson);
+            await this._installDevDependencies(templateDevDependencies, options.verbose);
+
+            const templateDependencies = addOnBuilder.getDependenciesToInstall(templateJson);
+            await this._installDependencies(templateDependencies, options.verbose);
+
+            await this._setupSSL(options.verbose);
+
+            addOnBuilder.displaySuccess();
+        } catch (error) {
+            this._process.handleError(error);
+            process.exit(1);
+        }
+    }
+
+    private async _installDevDependencies(templateDevDependencies: Set<string>, verbose: boolean) {
+        if (templateDevDependencies.size > 0) {
+            const devDependencyArgs = ["install", "--save-dev", "--save-exact", ...templateDevDependencies];
+            if (verbose) {
+                devDependencyArgs.push("--verbose");
+            }
+
+            this._logger.information(LOGS.installingTemplateDevDependencies, {
+                prefix: LOGS.newLine
+            });
+
+            await this._process.execute("npm", devDependencyArgs, { stdio: "inherit" });
+        }
+    }
+
+    private async _installDependencies(templateDependencies: Set<string>, verbose: boolean) {
+        if (templateDependencies.size > 0) {
+            const dependencyArgs = ["install", "--save", "--save-exact", ...templateDependencies];
+            if (verbose) {
+                dependencyArgs.push("--verbose");
+            }
+
+            this._logger.information(LOGS.installingTemplateDependencies, {
+                prefix: LOGS.newLine
+            });
+
+            await this._process.execute("npm", dependencyArgs, { stdio: "inherit" });
+        }
+    }
+
+    private async _setupSSL(verbose: boolean): Promise<void> {
+        const setupCommandOptions = new SSLSetupCommandOptions(DEFAULT_HOST_NAME, true, verbose);
+        await this._sslCommandExecutor.execute(setupCommandOptions);
+    }
 }
+
+const LOGS = {
+    newLine: "\n",
+    installingTemplateDevDependencies: "Installing template dev dependencies ...",
+    installingTemplateDependencies: "Installing template dependencies ..."
+};

package/src/app/PackageBuilder.ts

@@ -22,19 +22,85 @@
  * SOFTWARE.
  ********************************************************************************/
 
-import type { PackageJson, TemplateJson } from "@adobe/ccweb-add-on-core";
+import type { TemplateJson } from "@adobe/ccweb-add-on-core";
+import { PackageJson } from "@adobe/ccweb-add-on-core";
+import { injectable } from "inversify";
 
 /**
- * Package builder interface for constructing the package.json of the Add-on project.
+ * Package builder factory.
+ */
+export type PackageBuilderFactory = (packageJson: PackageJson) => (templateJson: TemplateJson) => PackageBuilder;
+
+/**
+ * Package builder class for constructing the package.json of the add-on project.
  */
-export interface PackageBuilder {
+@injectable()
+export class PackageBuilder {
+    private _combinedPackage: PackageJson;
+    private _templateJson: TemplateJson;
+
+    /**
+     * Instantiate {@link PackageBuilder}.
+     *
+     * @param packageJson - {@link PackageJson}.
+     * @param templateJson - {@link TemplateJson}.
+     * @returns Reference to a new {@link PackageBuilder} instance.
+     */
+    constructor(packageJson: PackageJson, templateJson: TemplateJson) {
+        this._combinedPackage = new PackageJson({ ...packageJson });
+        this._templateJson = templateJson;
+    }
+
     /**
      * Build {@link PackageJson}.
      */
-    build(): PackageJson;
-}
+    build(): PackageJson {
+        this._buildDevDependencies();
+        this._buildDependencies();
+        this._buildScripts();
 
-/**
- * Package builder factory.
- */
-export type PackageBuilderFactory = (packageJson: PackageJson) => (templateJson: TemplateJson) => PackageBuilder;
+        return this._combinedPackage;
+    }
+
+    private _buildDevDependencies(): void {
+        if (!this._templateJson.devDependencies || this._templateJson.devDependencies.size === 0) {
+            return;
+        }
+
+        this._templateJson.devDependencies.forEach((value, key) => {
+            if (!this._combinedPackage.devDependencies) {
+                this._combinedPackage.devDependencies = new Map<string, string>();
+            }
+
+            this._combinedPackage.devDependencies.set(key, value);
+        });
+    }
+
+    private _buildDependencies(): void {
+        if (!this._templateJson.dependencies || this._templateJson.dependencies.size === 0) {
+            return;
+        }
+
+        this._templateJson.dependencies.forEach((value, key) => {
+            if (!this._combinedPackage.dependencies) {
+                this._combinedPackage.dependencies = new Map<string, string>();
+            }
+
+            this._combinedPackage.dependencies.set(key, value);
+        });
+    }
+
+    private _buildScripts(): void {
+        if (!this._templateJson.scripts || this._templateJson.scripts.size === 0) {
+            return;
+        }
+
+        this._templateJson.scripts.forEach((value, key) => {
+            if (!this._combinedPackage.scripts) {
+                this._combinedPackage.scripts = new Map<string, string>();
+            }
+
+            this._combinedPackage.scripts.set(key, value);
+        });
+    }
+}

package/src/app/index.ts

@@ -25,6 +25,3 @@
 export * from "./AddOnBuilder.js";
 export * from "./AddOnScaffolder.js";
 export * from "./PackageBuilder.js";
-export * from "./TemplateAddOnBuilder.js";
-export * from "./TemplateAddOnScaffolder.js";
-export * from "./TemplatePackageBuilder.js";

package/src/config/inversify.config.ts

@@ -26,11 +26,11 @@ import type { Logger, PackageJson, TemplateJson } from "@adobe/ccweb-add-on-core
 import { IContainer as ICoreContainer, ITypes as ICoreTypes } from "@adobe/ccweb-add-on-core";
 import type { Container, interfaces } from "inversify";
 import "reflect-metadata";
-import type { AddOnBuilder, AddOnScaffolder, PackageBuilder } from "../app/index.js";
-import { TemplateAddOnBuilder, TemplateAddOnScaffolder, TemplatePackageBuilder } from "../app/index.js";
+import { AddOnBuilder } from "../app/AddOnBuilder.js";
+import { AddOnScaffolder } from "../app/AddOnScaffolder.js";
+import { PackageBuilder } from "../app/PackageBuilder.js";
 import type { ScaffolderOptions } from "../models/ScaffolderOptions.js";
-import type { TemplateValidator } from "../validators/index.js";
-import { AddOnTemplateValidator } from "../validators/index.js";
+import { TemplateValidator } from "../validators/TemplateValidator.js";
 import { ITypes } from "./inversify.types.js";
 
 const container: Container = ICoreContainer;
@@ -39,7 +39,7 @@ container
     .bind<interfaces.Factory<AddOnBuilder>>(ITypes.AddOnBuilder)
     .toFactory<AddOnBuilder, [ScaffolderOptions]>(context => {
         return (options: ScaffolderOptions) => {
-            return new TemplateAddOnBuilder(options, context.container.get<Logger>(ICoreTypes.Logger));
+            return new AddOnBuilder(options, context.container.get<Logger>(ICoreTypes.Logger));
         };
     });
 
@@ -47,12 +47,12 @@ container
     .bind<interfaces.Factory<PackageBuilder>>(ITypes.PackageBuilder)
     .toFactory<PackageBuilder, [PackageJson], [TemplateJson]>(() => {
         return (packageJson: PackageJson) => (templateJson: TemplateJson) => {
-            return new TemplatePackageBuilder(packageJson, templateJson);
+            return new PackageBuilder(packageJson, templateJson);
         };
     });
 
-container.bind<TemplateValidator>(ITypes.TemplateValidator).to(AddOnTemplateValidator).inSingletonScope();
+container.bind<AddOnScaffolder>(ITypes.AddOnScaffolder).to(AddOnScaffolder).inSingletonScope();
 
-container.bind<AddOnScaffolder>(ITypes.AddOnScaffolder).to(TemplateAddOnScaffolder).inSingletonScope();
+container.bind<TemplateValidator>(ITypes.TemplateValidator).to(TemplateValidator).inSingletonScope();
 
 export { container as IContainer };

package/src/config/inversify.types.ts

@@ -23,13 +23,11 @@
  ********************************************************************************/
 
 export const ITypes: {
-    Command: symbol;
     AddOnScaffolder: symbol;
     AddOnBuilder: symbol;
     PackageBuilder: symbol;
     TemplateValidator: symbol;
 } = {
-    Command: Symbol.for("Command"),
     AddOnScaffolder: Symbol.for("AddOnScaffolder"),
     AddOnBuilder: Symbol.for("AddOnBuilder"),
     PackageBuilder: Symbol.for("PackageBuilder"),

package/src/index.ts

@@ -22,7 +22,7 @@
  * SOFTWARE.
  ********************************************************************************/
 
-export * from "./app/AddOnScaffolder.js";
+export type * from "./app/AddOnScaffolder.js";
 export * from "./config/index.js";
 export * from "./constants.js";
 export * from "./models/index.js";