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

package/src/app/{AddOnManager.ts → PackageManager.ts}

@@ -28,21 +28,19 @@ import type { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 /**
  * Class to manage the Add-on project requirements.
  */
-export class AddOnManager {
+export class PackageManager {
     /**
      * Get package.json for the Add-on project.
-     * @param addOnKind - Kind of Add-on. For example: panel.
+     * @param entrypointType - Entrypoint type of Add-on. For example: panel, command, etc.
      * @param addOnName - Name of Add-on.
      * @returns package.json as {@link PackageJson}.
      */
-
-    // ToDo: [WXP-1625] Update the addOnKind parameter to entrypointType
-    static getPackageJson(addOnKind: EntrypointType, addOnName: string): PackageJson {
+    static getPackageJson(entrypointType: EntrypointType, addOnName: string): PackageJson {
         return new PackageJson({
             name: addOnName,
             version: "1.0.0",
             description: "Adobe Creative Cloud Web Add-on.",
-            keywords: ["Adobe", "Creative Cloud Web", "Add-on", addOnKind],
+            keywords: ["Adobe", "Creative Cloud Web", "Add-on", entrypointType],
             scripts: {
                 clean: "ccweb-add-on-scripts clean",
                 build: "ccweb-add-on-scripts build",

package/src/app/TemplateSelector.ts

@@ -22,17 +22,169 @@
  * SOFTWARE.
  ********************************************************************************/
 
+import type { AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import type { Logger } from "@adobe/ccweb-add-on-core";
+import { ITypes as ICoreTypes, isNullOrWhiteSpace } from "@adobe/ccweb-add-on-core";
+import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
+import chalk from "chalk";
+import { inject, injectable } from "inversify";
+import prompts from "prompts";
+import "reflect-metadata";
+import format from "string-template";
+import { AnalyticsErrorMarkers } from "../AnalyticsMarkers.js";
+import { ADD_ON_TEMPLATES, AVAILABLE_ADD_ON_TEMPLATES, PROGRAM_NAME, WITH_DOCUMENT_SANDBOX } from "../constants.js";
 import type { CLIOptions } from "../models/CLIOptions.js";
 
-/**
- * Template Selector interface.
- */
-export interface TemplateSelector {
+@injectable()
+export class TemplateSelector {
+    private readonly _logger: Logger;
+    private readonly _analyticsService: AnalyticsService;
+
+    /**
+     * Instantiate {@link TemplateSelector}.
+     * @param logger - {@link Logger} reference.
+     * @param analyticsService - {@link AnalyticsService} reference.
+     * @returns Reference to a new {@link TemplateSelector} instance.
+     */
+    constructor(
+        @inject(ICoreTypes.Logger) logger: Logger,
+        @inject(IAnalyticsTypes.AnalyticsService) analyticsService: AnalyticsService
+    ) {
+        this._logger = logger;
+        this._analyticsService = analyticsService;
+    }
+
     /**
      * Sets up a template, as selected/provided by the user
      * for scaffolding the add-on project.
      * @param options - {@link CLIOptions}.
      * @returns User selected/provided template name.
      */
-    setupTemplate(options: CLIOptions): Promise<string>;
+    async setupTemplate(options: CLIOptions): Promise<string> {
+        await this._validateAddOnEntrypoint(options.entrypointType);
+
+        if (!isNullOrWhiteSpace(options.templateName)) {
+            if (AVAILABLE_ADD_ON_TEMPLATES.includes(options.templateName)) {
+                return options.templateName;
+            } else {
+                this._logger.warning(LOGS.chooseValidTemplate, { prefix: LOGS.newLine });
+            }
+        }
+
+        // Add a line break for better log readability.
+        console.log();
+
+        const templateChoices = [];
+        for (const [templateName, description] of ADD_ON_TEMPLATES.entries()) {
+            templateChoices.push({
+                title: this._promptMessageOption(templateName, description),
+                value: templateName
+            });
+        }
+
+        const templateResponse = await prompts.prompt({
+            type: "select",
+            name: "selectedTemplate",
+            message: this._promptMessage(LOGS.setupTemplate),
+            choices: templateChoices,
+            initial: 0
+        });
+
+        if (!templateResponse || !templateResponse.selectedTemplate) {
+            console.log();
+            return process.exit(0);
+        }
+
+        if (!AVAILABLE_ADD_ON_TEMPLATES.includes(`${templateResponse.selectedTemplate}-${WITH_DOCUMENT_SANDBOX}`)) {
+            return templateResponse.selectedTemplate;
+        }
+
+        const documentSandboxChoices = [
+            {
+                title: this._promptMessageOption(LOGS.no),
+                value: false
+            },
+            {
+                title: this._promptMessageOption(LOGS.yes),
+                value: true
+            }
+        ];
+        const documentSandboxResponse = await prompts.prompt({
+            type: "select",
+            name: "includeDocumentSandbox",
+            message: this._promptMessage(LOGS.includeDocumentSandbox),
+            choices: documentSandboxChoices,
+            initial: 0
+        });
+
+        if (!documentSandboxResponse || documentSandboxResponse.includeDocumentSandbox === undefined) {
+            console.log();
+            return process.exit(0);
+        }
+
+        // Append `with-document-sandbox` to the template name if user wants to include document sandbox
+        return documentSandboxResponse.includeDocumentSandbox
+            ? `${templateResponse.selectedTemplate}-${WITH_DOCUMENT_SANDBOX}`
+            : templateResponse.selectedTemplate;
+    }
+
+    private _promptMessage(message: string): string {
+        return chalk.cyan(message);
+    }
+
+    private _promptMessageOption(option: string, description?: string): string {
+        if (description) {
+            return `${chalk.hex("#E59400").bold(`[${option}]:`)} ${chalk.green(description)}`;
+        }
+        return chalk.green.bold(option);
+    }
+
+    /**
+     * Validate whether entrypointType is valid or not.
+     * @param entrypointType - Add-on entrypoint. For example: panel.
+     */
+    private async _validateAddOnEntrypoint(entrypointType: EntrypointType): Promise<void> {
+        if (entrypointType !== EntrypointType.PANEL) {
+            this._logger.warning(LOGS.chooseValidEntrypointType);
+            this._logger.warning(
+                format(LOGS.executeProgramWithValidEntrypointType, {
+                    PROGRAM_NAME
+                }),
+                {
+                    prefix: LOGS.tab
+                }
+            );
+            this._logger.message(LOGS.forExample, { prefix: LOGS.newLine });
+            this._logger.information(
+                format(LOGS.executeProgramWithValidEntrypointTypeExample, {
+                    PROGRAM_NAME
+                }),
+                {
+                    prefix: LOGS.tab
+                }
+            );
+
+            await this._analyticsService.postEvent(
+                AnalyticsErrorMarkers.ERROR_INVALID_KIND,
+                LOGS.analyticsInvalidEntrypointType,
+                false
+            );
+            return process.exit(0);
+        }
+    }
 }
+const LOGS = {
+    newLine: "\n",
+    tab: "  ",
+    setupTemplate: "Please select a template which you want to scaffold the Add-on project with",
+    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:",
+    analyticsInvalidEntrypointType: "Invalid Add-on entrypoint specified",
+    includeDocumentSandbox: "Do you want to include document sandbox runtime?",
+    yes: "Yes",
+    no: "No"
+};

package/src/app/index.ts

@@ -23,7 +23,5 @@
  ********************************************************************************/
 
 export * from "./AddOnFactory.js";
-export * from "./AddOnManager.js";
-export * from "./AddOnTemplateSelector.js";
+export * from "./PackageManager.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 type { 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

@@ -23,21 +23,23 @@
  ********************************************************************************/
 
 import { IContainer as ICoreContainer } from "@adobe/ccweb-add-on-core";
+import type { Container } from "inversify";
 import "reflect-metadata";
-import type { AddOnFactory, TemplateSelector } from "../app/index.js";
-import { AddOnTemplateSelector, WxpAddOnFactory } from "../app/index.js";
-import type { DirectoryValidator, EnvironmentValidator } from "../validators/index.js";
-import { AddOnDirectoryValidator, NodeEnvironmentValidator } from "../validators/index.js";
+import { AddOnFactory } from "../app/AddOnFactory.js";
+import { TemplateSelector } from "../app/TemplateSelector.js";
+import { DirectoryValidator } from "../validators/DirectoryValidator.js";
+import { EnvironmentValidator } from "../validators/EnvironmentValidator.js";
+
 import { ITypes } from "./inversify.types.js";
 
-const container = ICoreContainer;
+const container: Container = ICoreContainer;
 
-container.bind<AddOnFactory>(ITypes.AddOnFactory).to(WxpAddOnFactory).inSingletonScope();
+container.bind<AddOnFactory>(ITypes.AddOnFactory).to(AddOnFactory).inSingletonScope();
 
-container.bind<DirectoryValidator>(ITypes.DirectoryValidator).to(AddOnDirectoryValidator).inSingletonScope();
+container.bind<DirectoryValidator>(ITypes.DirectoryValidator).to(DirectoryValidator).inSingletonScope();
 
-container.bind<EnvironmentValidator>(ITypes.EnvironmentValidator).to(NodeEnvironmentValidator).inSingletonScope();
+container.bind<EnvironmentValidator>(ITypes.EnvironmentValidator).to(EnvironmentValidator).inSingletonScope();
 
-container.bind<TemplateSelector>(ITypes.TemplateSelector).to(AddOnTemplateSelector).inSingletonScope();
+container.bind<TemplateSelector>(ITypes.TemplateSelector).to(TemplateSelector).inSingletonScope();
 
 export { container as IContainer };

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/{WxpAddOnFactory.spec.ts → AddOnFactory.spec.ts}

@@ -38,12 +38,13 @@ import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import url from "url";
 import { AnalyticsErrorMarkers, AnalyticsSuccessMarkers } from "../../AnalyticsMarkers.js";
-import type { AddOnFactory, TemplateSelector } from "../../app/index.js";
-import { WxpAddOnFactory } from "../../app/index.js";
-import { CLIOptions } from "../../models/index.js";
-import type { DirectoryValidator, EnvironmentValidator } from "../../validators/index.js";
+import { AddOnFactory } from "../../app/AddOnFactory.js";
+import type { TemplateSelector } from "../../app/TemplateSelector.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
+import type { DirectoryValidator } from "../../validators/DirectoryValidator.js";
+import type { EnvironmentValidator } from "../../validators/EnvironmentValidator.js";
 
-describe("WxpAddOnFactory", () => {
+describe("AddOnFactory", () => {
     let sandbox: SinonSandbox;
 
     let directoryValidator: StubbedInstance<DirectoryValidator>;
@@ -74,7 +75,7 @@ describe("WxpAddOnFactory", () => {
         analyticsService = stubInterface();
         analyticsService.postEvent.resolves();
 
-        addOnFactory = new WxpAddOnFactory(
+        addOnFactory = new AddOnFactory(
             directoryValidator,
             environmentValidator,
             templateSelector,
@@ -96,12 +97,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 +119,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 +150,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 +163,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 +208,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 +237,7 @@ describe("WxpAddOnFactory", () => {
                 const scaffolderOptions = new ScaffolderOptions(
                     addOnDirectory,
                     options.addOnName,
-                    options.addOnKind,
+                    options.entrypointType,
                     rootDirectory,
                     run.templateName,
                     options.verbose
@@ -244,8 +245,8 @@ describe("WxpAddOnFactory", () => {
                 const analyticsServiceEventData = [
                     "--addOnName",
                     run.addOnName,
-                    "--kind",
-                    run.addOnKind,
+                    "--entrypointType",
+                    run.entrypointType,
                     "--template",
                     run.templateName
                 ];

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

@@ -26,19 +26,19 @@ 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 { PackageManager } from "../../app/PackageManager.js";
 
-describe("AddOnManager", () => {
-    describe("getPackageJson ...", () => {
-        const runs = [{ addOnKind: EntrypointType.PANEL, addOnName: "test-app" }];
+describe("PackageManager", () => {
+    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 = PackageManager.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",