@adobe/create-ccweb-add-on 2.5.0 → 3.0.0

package/src/app/AddOnTemplateSelector.ts

@@ -63,7 +63,7 @@ export class AddOnTemplateSelector implements TemplateSelector {
      * @returns User selected/provided template name.
      */
     async setupTemplate(options: CLIOptions): Promise<string> {
-        await this._validateAddOnKind(options.addOnKind);
+        await this._validateAddOnEntrypoint(options.entrypointType);
 
         if (!isNullOrWhiteSpace(options.templateName)) {
             if (AVAILABLE_ADD_ON_TEMPLATES.includes(options.templateName)) {
@@ -144,14 +144,14 @@ export class AddOnTemplateSelector implements TemplateSelector {
     }
 
     /**
-     * Validate whether addOnKind is valid or not.
-     * @param addOnKind - Kind of Add-on. For example: panel.
+     * Validate whether entrypointType is valid or not.
+     * @param entrypointType - Add-on entrypoint. For example: panel.
      */
-    private async _validateAddOnKind(addOnKind: EntrypointType): Promise<void> {
-        if (addOnKind !== EntrypointType.PANEL) {
-            this._logger.warning(LOGS.chooseValidKind);
+    private async _validateAddOnEntrypoint(entrypointType: EntrypointType): Promise<void> {
+        if (entrypointType !== EntrypointType.PANEL) {
+            this._logger.warning(LOGS.chooseValidEntrypointType);
             this._logger.warning(
-                format(LOGS.executeProgramWithValidKind, {
+                format(LOGS.executeProgramWithValidEntrypointType, {
                     PROGRAM_NAME
                 }),
                 {
@@ -160,7 +160,7 @@ export class AddOnTemplateSelector implements TemplateSelector {
             );
             this._logger.message(LOGS.forExample, { prefix: LOGS.newLine });
             this._logger.information(
-                format(LOGS.executeProgramWithValidKindExample, {
+                format(LOGS.executeProgramWithValidEntrypointTypeExample, {
                     PROGRAM_NAME
                 }),
                 {
@@ -170,7 +170,7 @@ export class AddOnTemplateSelector implements TemplateSelector {
 
             await this._analyticsService.postEvent(
                 AnalyticsErrorMarkers.ERROR_INVALID_KIND,
-                LOGS.analyticsInvalidKind,
+                LOGS.analyticsInvalidEntrypointType,
                 false
             );
             return process.exit(0);
@@ -181,12 +181,12 @@ const LOGS = {
     newLine: "\n",
     tab: "  ",
     setupTemplate: "Please select a template which you want to scaffold the Add-on project with",
-    chooseValidKind: "Please choose a valid Add-on kind (valid kind: panel)",
-    executeProgramWithValidKind: "{PROGRAM_NAME} <add-on-name> --kind <panel>",
-    executeProgramWithValidKindExample: "{PROGRAM_NAME} my-add-on --kind panel",
+    chooseValidEntrypointType: "Please choose a valid Add-on entrypoint (valid entrypoint: panel)",
+    executeProgramWithValidEntrypointType: "{PROGRAM_NAME} <add-on-name> --entrypoint <panel>",
+    executeProgramWithValidEntrypointTypeExample: "{PROGRAM_NAME} my-add-on --entrypoint panel",
     chooseValidTemplate: "You have chosen an invalid template.",
     forExample: "For example:",
-    analyticsInvalidKind: "Invalid Add-on kind specified",
+    analyticsInvalidEntrypointType: "Invalid Add-on entrypoint specified",
     includeDocumentSandbox: "Do you want to include document sandbox runtime?",
     yes: "Yes",
     no: "No"

package/src/app/WxpAddOnFactory.ts

@@ -42,7 +42,7 @@ import { TEMP_TEMPLATE_PATH } from "../constants.js";
 import type { CLIOptions } from "../models/CLIOptions.js";
 import type { DirectoryValidator, EnvironmentValidator } from "../validators/index.js";
 import type { AddOnFactory } from "./AddOnFactory.js";
-import { AddOnManager } from "./AddOnManager.js";
+import { AddOnPackageManager } from "./AddOnPackageManager.js";
 import type { TemplateSelector } from "./TemplateSelector.js";
 
 /**
@@ -114,7 +114,7 @@ export class WxpAddOnFactory implements AddOnFactory {
 
             const templateName = await this._templateSelector.setupTemplate(options);
 
-            const packageJson = AddOnManager.getPackageJson(options.addOnKind, options.addOnName);
+            const packageJson = AddOnPackageManager.getPackageJson(options.entrypointType, options.addOnName);
             const packageJsonPath = path.join(addOnDirectory, PACKAGE_JSON);
 
             fs.writeFileSync(packageJsonPath, packageJson.toJSON() + os.EOL);
@@ -141,7 +141,7 @@ export class WxpAddOnFactory implements AddOnFactory {
             const scaffolderOptions = new ScaffolderOptions(
                 addOnDirectory,
                 options.addOnName,
-                options.addOnKind,
+                options.entrypointType,
                 rootDirectory,
                 templateName,
                 options.verbose
@@ -156,8 +156,8 @@ export class WxpAddOnFactory implements AddOnFactory {
             const analyticsEventData = [
                 "--addOnName",
                 options.addOnName,
-                "--kind",
-                options.addOnKind,
+                "--entrypointType",
+                options.entrypointType,
                 "--template",
                 templateName
             ];

package/src/app/index.ts

@@ -23,7 +23,7 @@
  ********************************************************************************/
 
 export * from "./AddOnFactory.js";
-export * from "./AddOnManager.js";
+export * from "./AddOnPackageManager.js";
 export * from "./AddOnTemplateSelector.js";
 export * from "./TemplateSelector.js";
 export * from "./WxpAddOnFactory.js";

package/src/commands/create.ts

@@ -22,12 +22,12 @@
  * SOFTWARE.
  ********************************************************************************/
 
-import type { AnalyticsConsent, AnalyticsService } from "@adobe/ccweb-add-on-analytics";
-import { CLIProgram, ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import { BaseCommand, CLIProgram } from "@adobe/ccweb-add-on-analytics";
 import { UncaughtExceptionHandler } from "@adobe/ccweb-add-on-core";
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 import type { Config } from "@oclif/core";
-import { Args, Command, Flags } from "@oclif/core";
+import { Args, Flags } from "@oclif/core";
+import { Arg, CustomOptions, OptionFlag } from "@oclif/core/lib/interfaces/parser.js";
 import "reflect-metadata";
 import { AnalyticsErrorMarkers } from "../AnalyticsMarkers.js";
 import type { AddOnFactory } from "../app/AddOnFactory.js";
@@ -38,20 +38,20 @@ import { CLIOptions } from "../models/CLIOptions.js";
 /**
  * Implementation class of the create-ccweb-add-on command.
  */
-export class CreateCCWebAddOn extends Command {
-    private readonly _analyticsConsent: AnalyticsConsent;
-    private readonly _analyticsService: AnalyticsService;
-
+export class Create extends BaseCommand {
     private readonly _addOnFactory: AddOnFactory;
 
     static description = "Create an Adobe Creative Cloud Web Add-on.";
 
-    static examples = ["create-ccweb-add-on <add-on-name> --template <javascript>"];
+    static examples: string[] = ["create-ccweb-add-on <add-on-name> --template <javascript>"];
 
-    static flags = {
-        kind: Flags.string({
-            char: "k",
-            description: "Kind of Add-on (panel).",
+    static flags: {
+        entrypoint: OptionFlag<string, CustomOptions>;
+        template: OptionFlag<string, CustomOptions>;
+    } = {
+        entrypoint: Flags.string({
+            char: "e",
+            description: "Entrypoint type of Add-on (By default it is set as 'panel').",
             default: EntrypointType.PANEL,
             required: false,
             hidden: true
@@ -61,37 +61,21 @@ export class CreateCCWebAddOn extends Command {
             description: "Template to use for creating the Add-on project.",
             default: "",
             required: false
-        }),
-        analytics: Flags.string({
-            char: "a",
-            description: "Turn on/off sending analytics to Adobe.",
-            options: ["on", "off"],
-            required: false
-        }),
-        verbose: Flags.boolean({
-            char: "v",
-            description: "Enable verbose logging.",
-            default: false,
-            required: false
         })
     };
 
-    static args = {
-        addOnName: Args.string({
-            name: "addOnName",
+    static args: {
+        name: Arg<string, Record<string, unknown>>;
+    } = {
+        name: Args.string({
+            name: "name",
             description: "Name of the Add-on project.",
             required: true
         })
     };
 
     constructor(argv: string[], config: Config) {
-        super(argv, config);
-
-        this._analyticsConsent = IContainer.get<AnalyticsConsent>(IAnalyticsTypes.AnalyticsConsent);
-
-        this._analyticsService = IContainer.get<AnalyticsService>(IAnalyticsTypes.AnalyticsService);
-        this._analyticsService.program = new CLIProgram(PROGRAM_NAME, this.config.name + "@" + this.config.version);
-        this._analyticsService.startTime = Date.now();
+        super(argv, config, new CLIProgram(PROGRAM_NAME, config.name + "@" + config.version));
 
         this._addOnFactory = IContainer.get<AddOnFactory>(ITypes.AddOnFactory);
     }
@@ -100,17 +84,17 @@ export class CreateCCWebAddOn extends Command {
         UncaughtExceptionHandler.registerExceptionHandler(PROGRAM_NAME);
 
         const {
-            args: { addOnName },
-            flags: { kind, template, analytics, verbose }
-        } = await this.parse(CreateCCWebAddOn);
+            args: { name },
+            flags: { entrypoint, template, analytics, verbose }
+        } = await this.parse(Create);
 
         await this._seekAnalyticsConsent(analytics);
 
         console.log();
 
         const options = new CLIOptions(
-            kind.toLowerCase() as EntrypointType,
-            addOnName,
+            entrypoint.toLowerCase() as EntrypointType,
+            name,
             template.toLowerCase(),
             verbose
         );
@@ -118,16 +102,8 @@ export class CreateCCWebAddOn extends Command {
         await this._addOnFactory.create(options);
     }
 
-    async catch(error: { message: string }) {
+    async catch(error: { message: string }): Promise<void> {
         await this._analyticsService.postEvent(AnalyticsErrorMarkers.ERROR_INVALID_ARGS, error.message, false);
         throw error;
     }
-
-    private async _seekAnalyticsConsent(analytics: string | undefined): Promise<void> {
-        if (analytics === undefined) {
-            await this._analyticsConsent.get();
-        } else {
-            await this._analyticsConsent.set(analytics === "on");
-        }
-    }
 }

package/src/config/inversify.config.ts

@@ -29,8 +29,9 @@ import { AddOnTemplateSelector, WxpAddOnFactory } from "../app/index.js";
 import type { DirectoryValidator, EnvironmentValidator } from "../validators/index.js";
 import { AddOnDirectoryValidator, NodeEnvironmentValidator } from "../validators/index.js";
 import { ITypes } from "./inversify.types.js";
+import { Container } from "inversify";
 
-const container = ICoreContainer;
+const container: Container = ICoreContainer;
 
 container.bind<AddOnFactory>(ITypes.AddOnFactory).to(WxpAddOnFactory).inSingletonScope();
 

package/src/config/inversify.types.ts

@@ -22,7 +22,13 @@
  * SOFTWARE.
  ********************************************************************************/
 
-export const ITypes = {
+export const ITypes: {
+    Command: symbol;
+    AddOnFactory: symbol;
+    DirectoryValidator: symbol;
+    EnvironmentValidator: symbol;
+    TemplateSelector: symbol;
+} = {
     Command: Symbol.for("Command"),
     AddOnFactory: Symbol.for("AddOnFactory"),
     DirectoryValidator: Symbol.for("DirectoryValidator"),

package/src/constants.ts

@@ -24,7 +24,7 @@
 
 export const PROGRAM_NAME = "create-ccweb-add-on";
 
-export const ADD_ON_TEMPLATES = new Map<string, string>([
+export const ADD_ON_TEMPLATES: Map<string, string> = new Map<string, string>([
     ["javascript", "Get started with Add-on development using JavaScript"],
     ["swc-javascript", "Get started with Add-on development using using Spectrum Web Components and JavaScript"],
     ["swc-typescript", "Get started with Add-on development using using Spectrum Web Components and TypeScript"],
@@ -36,7 +36,7 @@ export const TEMP_TEMPLATE_PATH = ".template";
 
 export const WITH_DOCUMENT_SANDBOX = "with-document-sandbox";
 
-export const AVAILABLE_ADD_ON_TEMPLATES = [
+export const AVAILABLE_ADD_ON_TEMPLATES: string[] = [
     "javascript",
     "swc-javascript",
     "swc-typescript",

package/src/index.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2025 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * 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
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+export { run } from "@oclif/core";

package/src/models/CLIOptions.ts

@@ -29,9 +29,9 @@ import type { EntrypointType } from "@adobe/ccweb-add-on-manifest";
  */
 export class CLIOptions {
     /**
-     * Kind of the Add-on. For example: panel.
+     * Entrypoint type of the Add-on. Example: 'panel'.
      */
-    readonly addOnKind: EntrypointType;
+    readonly entrypointType: EntrypointType;
 
     /**
      * Name of the Add-on.
@@ -50,14 +50,14 @@ export class CLIOptions {
 
     /**
      * Instantiate {@link CLIOptions}.
-     * @param addOnKind - Kind of the Add-on. For example: panel.
+     * @param entrypointType - Kind of the Add-on. For example: panel.
      * @param addOnName - Name of the Add-on.
      * @param templateName - Template name.
      * @param verbose - Verbose flag.
      * @returns Reference to a new {@link CLIOptions} instance.
      */
-    constructor(addOnKind: EntrypointType, addOnName: string, templateName: string, verbose: boolean) {
-        this.addOnKind = addOnKind;
+    constructor(entrypointType: EntrypointType, addOnName: string, templateName: string, verbose: boolean) {
+        this.entrypointType = entrypointType;
         this.addOnName = addOnName;
         this.templateName = templateName;
         this.verbose = verbose;

package/src/test/app/{AddOnManager.spec.ts → AddOnPackageManager.spec.ts}

@@ -26,19 +26,22 @@ import { PackageJson } from "@adobe/ccweb-add-on-core";
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 import { assert } from "chai";
 import "mocha";
-import { AddOnManager } from "../../app/index.js";
+import { AddOnPackageManager } from "../../app/index.js";
 
 describe("AddOnManager", () => {
-    describe("getPackageJson ...", () => {
-        const runs = [{ addOnKind: EntrypointType.PANEL, addOnName: "test-app" }];
+    describe("getPackageJson", () => {
+        const runs = [{ entrypointType: EntrypointType.PANEL, addOnName: "test-app" }];
         runs.forEach(run => {
             it("should return package.json.", async () => {
-                const packageJson = AddOnManager.getPackageJson(run.addOnKind as EntrypointType, run.addOnName);
+                const packageJson = AddOnPackageManager.getPackageJson(
+                    run.entrypointType as EntrypointType,
+                    run.addOnName
+                );
                 const expectedPackageJson = new PackageJson({
                     name: run.addOnName,
                     version: "1.0.0",
                     description: "Adobe Creative Cloud Web Add-on.",
-                    keywords: ["Adobe", "Creative Cloud Web", "Add-on", run.addOnKind],
+                    keywords: ["Adobe", "Creative Cloud Web", "Add-on", run.entrypointType],
                     scripts: {
                         clean: "ccweb-add-on-scripts clean",
                         build: "ccweb-add-on-scripts build",

package/src/test/app/AddOnTemplateSelector.spec.ts

@@ -70,9 +70,14 @@ describe("AddOnTemplateSelector", () => {
             sandbox.restore();
         });
 
-        it("should return error if the Add-on kind is not valid.", async () => {
+        it("should return error if the Add-on entrypoint is not valid.", async () => {
             const processExitStub = sandbox.stub(process, "exit");
-            const options = new CLIOptions("test-add-on-kind" as EntrypointType, "test-add-on", templateName, false);
+            const options = new CLIOptions(
+                "test-add-on-entrypoint" as EntrypointType,
+                "test-add-on",
+                templateName,
+                false
+            );
 
             const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
 
@@ -80,11 +85,15 @@ describe("AddOnTemplateSelector", () => {
 
             assert.equal(logger.warning.callCount, 2);
             assert.equal(
-                logger.warning.getCall(0).calledWith("Please choose a valid Add-on kind (valid kind: panel)"),
+                logger.warning
+                    .getCall(0)
+                    .calledWith("Please choose a valid Add-on entrypoint (valid entrypoint: panel)"),
                 true
             );
             assert.equal(
-                logger.warning.getCall(1).calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel>`, { prefix: "  " }),
+                logger.warning
+                    .getCall(1)
+                    .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel>`, { prefix: "  " }),
                 true
             );
 
@@ -93,7 +102,7 @@ describe("AddOnTemplateSelector", () => {
 
             assert.equal(logger.information.callCount, 1);
             assert.equal(
-                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel`, {
+                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --entrypoint panel`, {
                     prefix: "  "
                 }),
                 true
@@ -102,28 +111,37 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(
                 analyticsService.postEvent.calledWith(
                     AnalyticsErrorMarkers.ERROR_INVALID_KIND,
-                    "Invalid Add-on kind specified"
+                    "Invalid Add-on entrypoint specified"
                 ),
                 true
             );
             assert.equal(processExitStub.calledWith(0), true);
         });
 
-        it("should return error if the app kind is not valid.", async () => {
+        it("should return error if the app entrypoint is not valid.", async () => {
             const processExitStub = sandbox.stub(process, "exit");
 
-            const cliOptions = new CLIOptions("test-add-on-kind" as EntrypointType, "test-add-on", templateName, false);
+            const cliOptions = new CLIOptions(
+                "test-add-on-entrypoint" as EntrypointType,
+                "test-add-on",
+                templateName,
+                false
+            );
 
             const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
             await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 2);
             assert.equal(
-                logger.warning.getCall(0).calledWith("Please choose a valid Add-on kind (valid kind: panel)"),
+                logger.warning
+                    .getCall(0)
+                    .calledWith("Please choose a valid Add-on entrypoint (valid entrypoint: panel)"),
                 true
             );
             assert.equal(
-                logger.warning.getCall(1).calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel>`, { prefix: "  " }),
+                logger.warning
+                    .getCall(1)
+                    .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel>`, { prefix: "  " }),
                 true
             );
 
@@ -132,7 +150,7 @@ describe("AddOnTemplateSelector", () => {
 
             assert.equal(logger.information.callCount, 1);
             assert.equal(
-                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel`, {
+                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --entrypoint panel`, {
                     prefix: "  "
                 }),
                 true
@@ -141,7 +159,7 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(
                 analyticsService.postEvent.calledWith(
                     AnalyticsErrorMarkers.ERROR_INVALID_KIND,
-                    "Invalid Add-on kind specified"
+                    "Invalid Add-on entrypoint specified"
                 ),
                 true
             );

package/src/test/app/WxpAddOnFactory.spec.ts

@@ -96,12 +96,12 @@ describe("WxpAddOnFactory", () => {
 
             const processExitStub = sandbox.stub(process, "exit");
 
-            const addOnKind = EntrypointType.PANEL;
+            const entrypointType = EntrypointType.PANEL;
             const addOnName = "test-add-on";
             const templateName = "javascript";
             const verbose = false;
 
-            await addOnFactory.create(new CLIOptions(addOnKind, addOnName, templateName, verbose));
+            await addOnFactory.create(new CLIOptions(entrypointType, addOnName, templateName, verbose));
 
             assert.equal(cliProcess.handleError.callCount, 1);
             assert.equal(cliProcess.handleError.calledWith(error), true);
@@ -118,7 +118,7 @@ describe("WxpAddOnFactory", () => {
 
         it("should handle the errors when template doesnt exist.", async () => {
             const run = {
-                addOnKind: EntrypointType.PANEL,
+                entrypointType: EntrypointType.PANEL,
                 addOnName: "test-add-on",
                 templateName: "javascript",
                 verbose: false
@@ -149,7 +149,7 @@ describe("WxpAddOnFactory", () => {
             templateSelector.setupTemplate.resolves(run.templateName);
 
             const options = new CLIOptions(
-                run.addOnKind as EntrypointType,
+                run.entrypointType as EntrypointType,
                 run.addOnName,
                 run.templateName,
                 run.verbose
@@ -162,19 +162,19 @@ describe("WxpAddOnFactory", () => {
 
         const runs = [
             {
-                addOnKind: EntrypointType.PANEL,
+                entrypointType: EntrypointType.PANEL,
                 addOnName: "test-add-on",
                 templateName: "javascript",
                 verbose: false
             },
             {
-                addOnKind: EntrypointType.PANEL,
+                entrypointType: EntrypointType.PANEL,
                 addOnName: "test-add-on",
                 templateName: "typescript",
                 verbose: true
             },
             {
-                addOnKind: EntrypointType.PANEL,
+                entrypointType: EntrypointType.PANEL,
                 addOnName: "test-add-on",
                 templateName: "react-javascript",
                 verbose: false
@@ -207,7 +207,7 @@ describe("WxpAddOnFactory", () => {
                 templateSelector.setupTemplate.resolves(run.templateName);
 
                 const options = new CLIOptions(
-                    run.addOnKind as EntrypointType,
+                    run.entrypointType as EntrypointType,
                     run.addOnName,
                     run.templateName,
                     run.verbose
@@ -236,7 +236,7 @@ describe("WxpAddOnFactory", () => {
                 const scaffolderOptions = new ScaffolderOptions(
                     addOnDirectory,
                     options.addOnName,
-                    options.addOnKind,
+                    options.entrypointType,
                     rootDirectory,
                     run.templateName,
                     options.verbose
@@ -244,8 +244,8 @@ describe("WxpAddOnFactory", () => {
                 const analyticsServiceEventData = [
                     "--addOnName",
                     run.addOnName,
-                    "--kind",
-                    run.addOnKind,
+                    "--entrypointType",
+                    run.entrypointType,
                     "--template",
                     run.templateName
                 ];

package/src/test/commands/command.spec.ts

@@ -0,0 +1,80 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2025 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * 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
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import type { AnalyticsConsent, AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
+import { runCommand } from "@oclif/test";
+import { assert } from "chai";
+import "mocha";
+import sinon from "sinon";
+import type { StubbedInstance } from "ts-sinon";
+import { stubInterface } from "ts-sinon";
+import { AddOnFactory } from "../../app/AddOnFactory.js";
+import { IContainer, ITypes } from "../../config/index.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
+
+describe("create-ccweb-add-on", () => {
+    let sandbox: sinon.SinonSandbox;
+
+    let container: sinon.SinonStub;
+
+    let addOnFactory: StubbedInstance<AddOnFactory>;
+
+    let analyticsConsent: StubbedInstance<AnalyticsConsent>;
+    let analyticsService: StubbedInstance<AnalyticsService>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        addOnFactory = stubInterface();
+        addOnFactory.create.resolves();
+
+        analyticsConsent = stubInterface();
+        analyticsService = stubInterface();
+
+        container = sandbox.stub(IContainer, "get");
+        container.withArgs(ITypes.AddOnFactory).returns(addOnFactory);
+
+        container.withArgs(IAnalyticsTypes.AnalyticsConsent).returns(analyticsConsent);
+        container.withArgs(IAnalyticsTypes.AnalyticsService).returns(analyticsService);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("create", () => {
+        it("should execute succesfully when correct parameters are passed.", async () => {
+            analyticsConsent.set.resolves();
+
+            await runCommand(["hello-world", "--entrypoint=panel", "--template=react-javascript"], {
+                root: "."
+            });
+
+            const options = new CLIOptions(EntrypointType.PANEL, "hello-world", "react-javascript", false);
+            assert.equal(addOnFactory.create.calledOnceWith(options), true);
+        });
+    });
+});